1 /* Buffer manipulation primitives for GNU Emacs.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994,
3 1995, 1997, 1998, 1999, 2000, 2001, 2002,
4 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
25 #include <sys/types.h>
27 #include <sys/param.h>
41 #include "intervals.h"
45 #include "character.h"
46 #include "region-cache.h"
48 #include "blockinput.h"
53 struct buffer
*current_buffer
; /* the current buffer */
55 /* First buffer in chain of all buffers (in reverse order of creation).
56 Threaded through ->next. */
58 struct buffer
*all_buffers
;
60 /* This structure holds the default values of the buffer-local variables
61 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
62 The default value occupies the same slot in this structure
63 as an individual buffer's value occupies in that buffer.
64 Setting the default value also goes through the alist of buffers
65 and stores into each buffer that does not say it has a local value. */
67 DECL_ALIGN (struct buffer
, buffer_defaults
);
69 /* A Lisp_Object pointer to the above, used for staticpro */
71 static Lisp_Object Vbuffer_defaults
;
73 /* This structure marks which slots in a buffer have corresponding
74 default values in buffer_defaults.
75 Each such slot has a nonzero value in this structure.
76 The value has only one nonzero bit.
78 When a buffer has its own local value for a slot,
79 the entry for that slot (found in the same slot in this structure)
80 is turned on in the buffer's local_flags array.
82 If a slot in this structure is -1, then even though there may
83 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
84 and the corresponding slot in buffer_defaults is not used.
86 If a slot is -2, then there is no DEFVAR_PER_BUFFER for it,
87 but there is a default value which is copied into each buffer.
89 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
90 zero, that is a bug */
92 struct buffer buffer_local_flags
;
94 /* This structure holds the names of symbols whose values may be
95 buffer-local. It is indexed and accessed in the same way as the above. */
97 DECL_ALIGN (struct buffer
, buffer_local_symbols
);
99 /* A Lisp_Object pointer to the above, used for staticpro */
100 static Lisp_Object Vbuffer_local_symbols
;
102 /* This structure holds the required types for the values in the
103 buffer-local slots. If a slot contains Qnil, then the
104 corresponding buffer slot may contain a value of any type. If a
105 slot contains an integer, then prospective values' tags must be
106 equal to that integer (except nil is always allowed).
107 When a tag does not match, the function
108 buffer_slot_type_mismatch will signal an error.
110 If a slot here contains -1, the corresponding variable is read-only. */
111 struct buffer buffer_local_types
;
113 /* Flags indicating which built-in buffer-local variables
114 are permanent locals. */
115 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
117 /* Number of per-buffer variables used. */
119 int last_per_buffer_idx
;
121 Lisp_Object
Fset_buffer ();
122 void set_buffer_internal ();
123 void set_buffer_internal_1 ();
124 static void call_overlay_mod_hooks ();
125 static void swap_out_buffer_local_variables ();
126 static void reset_buffer_local_variables ();
128 /* Alist of all buffer names vs the buffers. */
129 /* This used to be a variable, but is no longer,
130 to prevent lossage due to user rplac'ing this alist or its elements. */
131 Lisp_Object Vbuffer_alist
;
133 /* Functions to call before and after each text change. */
134 Lisp_Object Vbefore_change_functions
;
135 Lisp_Object Vafter_change_functions
;
137 Lisp_Object Vtransient_mark_mode
;
139 /* t means ignore all read-only text properties.
140 A list means ignore such a property if its value is a member of the list.
141 Any non-nil value means ignore buffer-read-only. */
142 Lisp_Object Vinhibit_read_only
;
144 /* List of functions to call that can query about killing a buffer.
145 If any of these functions returns nil, we don't kill it. */
146 Lisp_Object Vkill_buffer_query_functions
;
147 Lisp_Object Qkill_buffer_query_functions
;
149 /* Hook run before changing a major mode. */
150 Lisp_Object Vchange_major_mode_hook
, Qchange_major_mode_hook
;
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
));
185 static Lisp_Object buffer_lisp_local_variables
P_ ((struct buffer
*));
187 extern char * emacs_strerror
P_ ((int));
189 /* For debugging; temporary. See set_buffer_internal. */
190 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
197 error ("No buffer named %s", SDATA (spec
));
198 error ("Invalid buffer argument");
201 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
202 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
203 Value is nil if OBJECT is not a buffer or if it has been killed. */)
207 return ((BUFFERP (object
) && ! NILP (XBUFFER (object
)->name
))
211 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
212 doc
: /* Return a list of all existing live buffers.
213 If the optional arg FRAME is a frame, we return the buffer list
214 in the proper order for that frame: the buffers in FRAME's `buffer-list'
215 frame parameter come first, followed by the rest of the buffers. */)
220 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
224 Lisp_Object framelist
, prevlist
, tail
;
229 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
230 prevlist
= Fnreverse (Fcopy_sequence (XFRAME (frame
)->buried_buffer_list
));
232 /* Remove from GENERAL any buffer that duplicates one in
233 FRAMELIST or PREVLIST. */
237 general
= Fdelq (XCAR (tail
), general
);
243 general
= Fdelq (XCAR (tail
), general
);
250 return Fnconc (3, args
);
256 /* Like Fassoc, but use Fstring_equal to compare
257 (which ignores text properties),
258 and don't ever QUIT. */
261 assoc_ignore_text_properties (key
, list
)
262 register Lisp_Object key
;
265 register Lisp_Object tail
;
266 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
268 register Lisp_Object elt
, tem
;
270 tem
= Fstring_equal (Fcar (elt
), key
);
277 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
278 doc
: /* Return the buffer named NAME (a string).
279 If there is no live buffer named NAME, return nil.
280 NAME may also be a buffer; if so, the value is that buffer. */)
282 register Lisp_Object name
;
288 return Fcdr (assoc_ignore_text_properties (name
, Vbuffer_alist
));
291 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
292 doc
: /* Return the buffer visiting file FILENAME (a string).
293 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
294 If there is no such live buffer, return nil.
295 See also `find-buffer-visiting'. */)
297 register Lisp_Object filename
;
299 register Lisp_Object tail
, buf
, tem
;
302 CHECK_STRING (filename
);
303 filename
= Fexpand_file_name (filename
, Qnil
);
305 /* If the file name has special constructs in it,
306 call the corresponding file handler. */
307 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
309 return call2 (handler
, Qget_file_buffer
, filename
);
311 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
313 buf
= Fcdr (XCAR (tail
));
314 if (!BUFFERP (buf
)) continue;
315 if (!STRINGP (XBUFFER (buf
)->filename
)) continue;
316 tem
= Fstring_equal (XBUFFER (buf
)->filename
, filename
);
324 get_truename_buffer (filename
)
325 register Lisp_Object filename
;
327 register Lisp_Object tail
, buf
, tem
;
329 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
331 buf
= Fcdr (XCAR (tail
));
332 if (!BUFFERP (buf
)) continue;
333 if (!STRINGP (XBUFFER (buf
)->file_truename
)) continue;
334 tem
= Fstring_equal (XBUFFER (buf
)->file_truename
, filename
);
341 /* Incremented for each buffer created, to assign the buffer number. */
344 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
345 doc
: /* Return the buffer named NAME, or create such a buffer and return it.
346 A new buffer is created if there is no live buffer named NAME.
347 If NAME starts with a space, the new buffer does not keep undo information.
348 If NAME is a buffer instead of a string, then it is the value returned.
349 The value is never nil. */)
351 register Lisp_Object name
;
353 register Lisp_Object buf
;
354 register struct buffer
*b
;
356 buf
= Fget_buffer (name
);
360 if (SCHARS (name
) == 0)
361 error ("Empty string for buffer name is not allowed");
363 b
= (struct buffer
*) allocate_buffer ();
365 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
367 /* An ordinary buffer uses its own struct buffer_text. */
368 b
->text
= &b
->own_text
;
371 BUF_GAP_SIZE (b
) = 20;
373 /* We allocate extra 1-byte at the tail and keep it always '\0' for
374 anchoring a search. */
375 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
377 if (! BUF_BEG_ADDR (b
))
378 buffer_memory_full ();
385 BUF_PT_BYTE (b
) = BEG_BYTE
;
386 BUF_GPT_BYTE (b
) = BEG_BYTE
;
387 BUF_BEGV_BYTE (b
) = BEG_BYTE
;
388 BUF_ZV_BYTE (b
) = BEG_BYTE
;
389 BUF_Z_BYTE (b
) = BEG_BYTE
;
391 BUF_CHARS_MODIFF (b
) = 1;
392 BUF_OVERLAY_MODIFF (b
) = 1;
393 BUF_SAVE_MODIFF (b
) = 1;
394 BUF_INTERVALS (b
) = 0;
395 BUF_UNCHANGED_MODIFIED (b
) = 1;
396 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
397 BUF_END_UNCHANGED (b
) = 0;
398 BUF_BEG_UNCHANGED (b
) = 0;
399 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
401 b
->newline_cache
= 0;
402 b
->width_run_cache
= 0;
403 b
->width_table
= Qnil
;
404 b
->prevent_redisplay_optimizations_p
= 1;
406 /* Put this on the chain of all buffers including killed ones. */
407 b
->next
= all_buffers
;
410 /* An ordinary buffer normally doesn't need markers
411 to handle BEGV and ZV. */
413 b
->begv_marker
= Qnil
;
416 name
= Fcopy_sequence (name
);
417 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
420 if (SREF (name
, 0) != ' ')
426 reset_buffer_local_variables (b
, 1);
428 b
->mark
= Fmake_marker ();
429 BUF_MARKERS (b
) = NULL
;
432 /* Put this in the alist of all live buffers. */
433 XSETPVECTYPE (b
, PVEC_BUFFER
);
435 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
437 /* An error in calling the function here (should someone redefine it)
438 can lead to infinite regress until you run out of stack. rms
439 says that's not worth protecting against. */
440 if (!NILP (Ffboundp (Qucs_set_table_for_input
)))
441 /* buf is on buffer-alist, so no gcpro. */
442 call1 (Qucs_set_table_for_input
, buf
);
448 /* Return a list of overlays which is a copy of the overlay list
449 LIST, but for buffer B. */
451 static struct Lisp_Overlay
*
452 copy_overlays (b
, list
)
454 struct Lisp_Overlay
*list
;
457 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
459 XSETBUFFER (buffer
, b
);
461 for (; list
; list
= list
->next
)
463 Lisp_Object overlay
, start
, end
, old_overlay
;
466 XSETMISC (old_overlay
, list
);
467 charpos
= marker_position (OVERLAY_START (old_overlay
));
468 start
= Fmake_marker ();
469 Fset_marker (start
, make_number (charpos
), buffer
);
470 XMARKER (start
)->insertion_type
471 = XMARKER (OVERLAY_START (old_overlay
))->insertion_type
;
473 charpos
= marker_position (OVERLAY_END (old_overlay
));
474 end
= Fmake_marker ();
475 Fset_marker (end
, make_number (charpos
), buffer
);
476 XMARKER (end
)->insertion_type
477 = XMARKER (OVERLAY_END (old_overlay
))->insertion_type
;
479 overlay
= allocate_misc ();
480 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
481 OVERLAY_START (overlay
) = start
;
482 OVERLAY_END (overlay
) = end
;
483 OVERLAY_PLIST (overlay
) = Fcopy_sequence (OVERLAY_PLIST (old_overlay
));
484 XOVERLAY (overlay
)->next
= NULL
;
487 tail
= tail
->next
= XOVERLAY (overlay
);
489 result
= tail
= XOVERLAY (overlay
);
496 /* Clone per-buffer values of buffer FROM.
498 Buffer TO gets the same per-buffer values as FROM, with the
499 following exceptions: (1) TO's name is left untouched, (2) markers
500 are copied and made to refer to TO, and (3) overlay lists are
504 clone_per_buffer_values (from
, to
)
505 struct buffer
*from
, *to
;
507 Lisp_Object to_buffer
;
510 XSETBUFFER (to_buffer
, to
);
512 for (offset
= PER_BUFFER_VAR_OFFSET (name
) + sizeof (Lisp_Object
);
514 offset
+= sizeof (Lisp_Object
))
518 obj
= PER_BUFFER_VALUE (from
, offset
);
521 struct Lisp_Marker
*m
= XMARKER (obj
);
522 obj
= Fmake_marker ();
523 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
524 set_marker_both (obj
, to_buffer
, m
->charpos
, m
->bytepos
);
527 PER_BUFFER_VALUE (to
, offset
) = obj
;
530 bcopy (from
->local_flags
, to
->local_flags
, sizeof to
->local_flags
);
532 to
->overlays_before
= copy_overlays (to
, from
->overlays_before
);
533 to
->overlays_after
= copy_overlays (to
, from
->overlays_after
);
535 /* Get (a copy of) the alist of Lisp-level local variables of FROM
536 and install that in TO. */
537 to
->local_var_alist
= buffer_lisp_local_variables (from
);
540 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
542 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
543 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
544 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
545 NAME should be a string which is not the name of an existing buffer.
546 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
547 such as major and minor modes, in the indirect buffer.
548 CLONE nil means the indirect buffer's state is reset to default values. */)
549 (base_buffer
, name
, clone
)
550 Lisp_Object base_buffer
, name
, clone
;
552 Lisp_Object buf
, tem
;
556 buf
= Fget_buffer (name
);
558 error ("Buffer name `%s' is in use", SDATA (name
));
561 base_buffer
= Fget_buffer (base_buffer
);
562 if (NILP (base_buffer
))
563 error ("No such buffer: `%s'", SDATA (tem
));
564 if (NILP (XBUFFER (base_buffer
)->name
))
565 error ("Base buffer has been killed");
567 if (SCHARS (name
) == 0)
568 error ("Empty string for buffer name is not allowed");
570 b
= (struct buffer
*) allocate_buffer ();
571 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
572 XSETPVECTYPE (b
, PVEC_BUFFER
);
574 if (XBUFFER (base_buffer
)->base_buffer
)
575 b
->base_buffer
= XBUFFER (base_buffer
)->base_buffer
;
577 b
->base_buffer
= XBUFFER (base_buffer
);
579 /* Use the base buffer's text object. */
580 b
->text
= b
->base_buffer
->text
;
582 BUF_BEGV (b
) = BUF_BEGV (b
->base_buffer
);
583 BUF_ZV (b
) = BUF_ZV (b
->base_buffer
);
584 BUF_PT (b
) = BUF_PT (b
->base_buffer
);
585 BUF_BEGV_BYTE (b
) = BUF_BEGV_BYTE (b
->base_buffer
);
586 BUF_ZV_BYTE (b
) = BUF_ZV_BYTE (b
->base_buffer
);
587 BUF_PT_BYTE (b
) = BUF_PT_BYTE (b
->base_buffer
);
589 b
->newline_cache
= 0;
590 b
->width_run_cache
= 0;
591 b
->width_table
= Qnil
;
593 /* Put this on the chain of all buffers including killed ones. */
594 b
->next
= all_buffers
;
597 name
= Fcopy_sequence (name
);
598 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
602 reset_buffer_local_variables (b
, 1);
604 /* Put this in the alist of all live buffers. */
606 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
608 b
->mark
= Fmake_marker ();
611 /* The multibyte status belongs to the base buffer. */
612 b
->enable_multibyte_characters
= b
->base_buffer
->enable_multibyte_characters
;
614 /* Make sure the base buffer has markers for its narrowing. */
615 if (NILP (b
->base_buffer
->pt_marker
))
617 b
->base_buffer
->pt_marker
= Fmake_marker ();
618 set_marker_both (b
->base_buffer
->pt_marker
, base_buffer
,
619 BUF_PT (b
->base_buffer
),
620 BUF_PT_BYTE (b
->base_buffer
));
622 if (NILP (b
->base_buffer
->begv_marker
))
624 b
->base_buffer
->begv_marker
= Fmake_marker ();
625 set_marker_both (b
->base_buffer
->begv_marker
, base_buffer
,
626 BUF_BEGV (b
->base_buffer
),
627 BUF_BEGV_BYTE (b
->base_buffer
));
629 if (NILP (b
->base_buffer
->zv_marker
))
631 b
->base_buffer
->zv_marker
= Fmake_marker ();
632 set_marker_both (b
->base_buffer
->zv_marker
, base_buffer
,
633 BUF_ZV (b
->base_buffer
),
634 BUF_ZV_BYTE (b
->base_buffer
));
635 XMARKER (b
->base_buffer
->zv_marker
)->insertion_type
= 1;
640 /* Give the indirect buffer markers for its narrowing. */
641 b
->pt_marker
= Fmake_marker ();
642 set_marker_both (b
->pt_marker
, buf
, BUF_PT (b
), BUF_PT_BYTE (b
));
643 b
->begv_marker
= Fmake_marker ();
644 set_marker_both (b
->begv_marker
, buf
, BUF_BEGV (b
), BUF_BEGV_BYTE (b
));
645 b
->zv_marker
= Fmake_marker ();
646 set_marker_both (b
->zv_marker
, buf
, BUF_ZV (b
), BUF_ZV_BYTE (b
));
647 XMARKER (b
->zv_marker
)->insertion_type
= 1;
651 struct buffer
*old_b
= current_buffer
;
653 clone_per_buffer_values (b
->base_buffer
, b
);
655 b
->file_truename
= Qnil
;
656 b
->display_count
= make_number (0);
658 b
->auto_save_file_name
= Qnil
;
659 set_buffer_internal_1 (b
);
660 Fset (intern ("buffer-save-without-query"), Qnil
);
661 Fset (intern ("buffer-file-number"), Qnil
);
662 Fset (intern ("buffer-stale-function"), Qnil
);
663 set_buffer_internal_1 (old_b
);
670 delete_all_overlays (b
)
675 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
676 have to empty the list, otherwise we end up with overlays that
677 think they belong to this buffer while the buffer doesn't know about
679 while (b
->overlays_before
)
681 XSETMISC (overlay
, b
->overlays_before
);
682 Fdelete_overlay (overlay
);
684 while (b
->overlays_after
)
686 XSETMISC (overlay
, b
->overlays_after
);
687 Fdelete_overlay (overlay
);
689 eassert (b
->overlays_before
== NULL
);
690 eassert (b
->overlays_after
== NULL
);
693 /* Reinitialize everything about a buffer except its name and contents
695 If called on an already-initialized buffer, the list of overlays
696 should be deleted before calling this function, otherwise we end up
697 with overlays that claim to belong to the buffer but the buffer
698 claims it doesn't belong to it. */
702 register struct buffer
*b
;
705 b
->file_truename
= Qnil
;
706 b
->directory
= (current_buffer
) ? current_buffer
->directory
: Qnil
;
708 XSETFASTINT (b
->save_length
, 0);
709 b
->last_window_start
= 1;
710 /* It is more conservative to start out "changed" than "unchanged". */
712 b
->prevent_redisplay_optimizations_p
= 1;
714 b
->auto_save_modified
= 0;
715 b
->auto_save_failure_time
= -1;
716 b
->auto_save_file_name
= Qnil
;
718 b
->overlays_before
= NULL
;
719 b
->overlays_after
= NULL
;
720 b
->overlay_center
= BEG
;
721 b
->mark_active
= Qnil
;
722 b
->point_before_scroll
= Qnil
;
723 b
->file_format
= Qnil
;
724 b
->auto_save_file_format
= Qt
;
725 b
->last_selected_window
= Qnil
;
726 XSETINT (b
->display_count
, 0);
727 b
->display_time
= Qnil
;
728 b
->enable_multibyte_characters
= buffer_defaults
.enable_multibyte_characters
;
729 b
->cursor_type
= buffer_defaults
.cursor_type
;
730 b
->extra_line_spacing
= buffer_defaults
.extra_line_spacing
;
732 b
->display_error_modiff
= 0;
735 /* Reset buffer B's local variables info.
736 Don't use this on a buffer that has already been in use;
737 it does not treat permanent locals consistently.
738 Instead, use Fkill_all_local_variables.
740 If PERMANENT_TOO is 1, then we reset permanent built-in
741 buffer-local variables. If PERMANENT_TOO is 0,
742 we preserve those. */
745 reset_buffer_local_variables (b
, permanent_too
)
746 register struct buffer
*b
;
752 /* Reset the major mode to Fundamental, together with all the
753 things that depend on the major mode.
754 default-major-mode is handled at a higher level.
755 We ignore it here. */
756 b
->major_mode
= Qfundamental_mode
;
758 b
->mode_name
= QSFundamental
;
759 b
->minor_modes
= Qnil
;
761 /* If the standard case table has been altered and invalidated,
762 fix up its insides first. */
763 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
764 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
765 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
766 Fset_standard_case_table (Vascii_downcase_table
);
768 b
->downcase_table
= Vascii_downcase_table
;
769 b
->upcase_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
770 b
->case_canon_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
771 b
->case_eqv_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
772 b
->invisibility_spec
= Qt
;
774 b
->buffer_file_type
= Qnil
;
777 /* Reset all (or most) per-buffer variables to their defaults. */
778 b
->local_var_alist
= Qnil
;
779 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
780 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
781 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
783 /* For each slot that has a default value,
784 copy that into the slot. */
786 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
788 offset
+= sizeof (Lisp_Object
))
790 int idx
= PER_BUFFER_IDX (offset
);
793 || buffer_permanent_local_flags
[idx
] == 0))
794 /* Is -2 used anywhere? */
796 PER_BUFFER_VALUE (b
, offset
) = PER_BUFFER_DEFAULT (offset
);
800 /* We split this away from generate-new-buffer, because rename-buffer
801 and set-visited-file-name ought to be able to use this to really
802 rename the buffer properly. */
804 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
806 doc
: /* Return a string that is the name of no existing buffer based on NAME.
807 If there is no live buffer named NAME, then return NAME.
808 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
809 \(starting at 2) until an unused name is found, and then return that name.
810 Optional second argument IGNORE specifies a name that is okay to use (if
811 it is in the sequence to be tried) even if a buffer with that name exists. */)
813 register Lisp_Object name
, ignore
;
815 register Lisp_Object gentemp
, tem
;
821 tem
= Fstring_equal (name
, ignore
);
824 tem
= Fget_buffer (name
);
831 sprintf (number
, "<%d>", ++count
);
832 gentemp
= concat2 (name
, build_string (number
));
833 tem
= Fstring_equal (gentemp
, ignore
);
836 tem
= Fget_buffer (gentemp
);
843 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
844 doc
: /* Return the name of BUFFER, as a string.
845 With no argument or nil as argument, return the name of the current buffer. */)
847 register Lisp_Object buffer
;
850 return current_buffer
->name
;
851 CHECK_BUFFER (buffer
);
852 return XBUFFER (buffer
)->name
;
855 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
856 doc
: /* Return name of file BUFFER is visiting, or nil if none.
857 No argument or nil as argument means use the current buffer. */)
859 register Lisp_Object buffer
;
862 return current_buffer
->filename
;
863 CHECK_BUFFER (buffer
);
864 return XBUFFER (buffer
)->filename
;
867 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
869 doc
: /* Return the base buffer of indirect buffer BUFFER.
870 If BUFFER is not indirect, return nil.
871 BUFFER defaults to the current buffer. */)
873 register Lisp_Object buffer
;
876 Lisp_Object base_buffer
;
879 base
= current_buffer
->base_buffer
;
882 CHECK_BUFFER (buffer
);
883 base
= XBUFFER (buffer
)->base_buffer
;
888 XSETBUFFER (base_buffer
, base
);
892 DEFUN ("buffer-local-value", Fbuffer_local_value
,
893 Sbuffer_local_value
, 2, 2, 0,
894 doc
: /* Return the value of VARIABLE in BUFFER.
895 If VARIABLE does not have a buffer-local binding in BUFFER, the value
896 is the default binding of the variable. */)
898 register Lisp_Object variable
;
899 register Lisp_Object buffer
;
901 register struct buffer
*buf
;
902 register Lisp_Object result
;
904 CHECK_SYMBOL (variable
);
905 CHECK_BUFFER (buffer
);
906 buf
= XBUFFER (buffer
);
908 if (SYMBOLP (variable
))
909 variable
= indirect_variable (variable
);
911 /* Look in local_var_list */
912 result
= Fassoc (variable
, buf
->local_var_alist
);
918 /* Look in special slots */
919 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
920 offset
< sizeof (struct buffer
);
921 /* sizeof EMACS_INT == sizeof Lisp_Object */
922 offset
+= (sizeof (EMACS_INT
)))
924 idx
= PER_BUFFER_IDX (offset
);
925 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
926 && SYMBOLP (PER_BUFFER_SYMBOL (offset
))
927 && EQ (PER_BUFFER_SYMBOL (offset
), variable
))
929 result
= PER_BUFFER_VALUE (buf
, offset
);
936 result
= Fdefault_value (variable
);
940 Lisp_Object valcontents
;
941 Lisp_Object current_alist_element
;
943 /* What binding is loaded right now? */
944 valcontents
= SYMBOL_VALUE (variable
);
945 current_alist_element
946 = XCAR (XBUFFER_LOCAL_VALUE (valcontents
)->cdr
);
948 /* The value of the currently loaded binding is not
949 stored in it, but rather in the realvalue slot.
950 Store that value into the binding it belongs to
951 in case that is the one we are about to use. */
953 Fsetcdr (current_alist_element
,
954 do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
));
956 /* Now get the (perhaps updated) value out of the binding. */
957 result
= XCDR (result
);
960 if (!EQ (result
, Qunbound
))
963 xsignal1 (Qvoid_variable
, variable
);
966 /* Return an alist of the Lisp-level buffer-local bindings of
967 buffer BUF. That is, don't include the variables maintained
968 in special slots in the buffer object. */
971 buffer_lisp_local_variables (buf
)
974 Lisp_Object result
= Qnil
;
975 register Lisp_Object tail
;
976 for (tail
= buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
978 Lisp_Object val
, elt
;
982 /* Reference each variable in the alist in buf.
983 If inquiring about the current buffer, this gets the current values,
984 so store them into the alist so the alist is up to date.
985 If inquiring about some other buffer, this swaps out any values
986 for that buffer, making the alist up to date automatically. */
987 val
= find_symbol_value (XCAR (elt
));
988 /* Use the current buffer value only if buf is the current buffer. */
989 if (buf
!= current_buffer
)
992 /* If symbol is unbound, put just the symbol in the list. */
993 if (EQ (val
, Qunbound
))
994 result
= Fcons (XCAR (elt
), result
);
995 /* Otherwise, put (symbol . value) in the list. */
997 result
= Fcons (Fcons (XCAR (elt
), val
), result
);
1003 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1004 Sbuffer_local_variables
, 0, 1, 0,
1005 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1006 Most elements look like (SYMBOL . VALUE), describing one variable.
1007 For a symbol that is locally unbound, just the symbol appears in the value.
1008 Note that storing new VALUEs in these elements doesn't change the variables.
1009 No argument or nil as argument means use current buffer as BUFFER. */)
1011 register Lisp_Object buffer
;
1013 register struct buffer
*buf
;
1014 register Lisp_Object result
;
1017 buf
= current_buffer
;
1020 CHECK_BUFFER (buffer
);
1021 buf
= XBUFFER (buffer
);
1024 result
= buffer_lisp_local_variables (buf
);
1026 /* Add on all the variables stored in special slots. */
1030 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
1031 offset
< sizeof (struct buffer
);
1032 /* sizeof EMACS_INT == sizeof Lisp_Object */
1033 offset
+= (sizeof (EMACS_INT
)))
1035 idx
= PER_BUFFER_IDX (offset
);
1036 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1037 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1038 result
= Fcons (Fcons (PER_BUFFER_SYMBOL (offset
),
1039 PER_BUFFER_VALUE (buf
, offset
)),
1047 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1049 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1050 No argument or nil as argument means use current buffer as BUFFER. */)
1052 register Lisp_Object buffer
;
1054 register struct buffer
*buf
;
1056 buf
= current_buffer
;
1059 CHECK_BUFFER (buffer
);
1060 buf
= XBUFFER (buffer
);
1063 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1066 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1068 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1069 A non-nil FLAG means mark the buffer modified. */)
1071 register Lisp_Object flag
;
1073 register int already
;
1074 register Lisp_Object fn
;
1075 Lisp_Object buffer
, window
;
1077 #ifdef CLASH_DETECTION
1078 /* If buffer becoming modified, lock the file.
1079 If buffer becoming unmodified, unlock the file. */
1081 fn
= current_buffer
->file_truename
;
1082 /* Test buffer-file-name so that binding it to nil is effective. */
1083 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1085 already
= SAVE_MODIFF
< MODIFF
;
1086 if (!already
&& !NILP (flag
))
1088 else if (already
&& NILP (flag
))
1091 #endif /* CLASH_DETECTION */
1093 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1095 /* Set update_mode_lines only if buffer is displayed in some window.
1096 Packages like jit-lock or lazy-lock preserve a buffer's modified
1097 state by recording/restoring the state around blocks of code.
1098 Setting update_mode_lines makes redisplay consider all windows
1099 (on all frames). Stealth fontification of buffers not displayed
1100 would incur additional redisplay costs if we'd set
1101 update_modes_lines unconditionally.
1103 Ideally, I think there should be another mechanism for fontifying
1104 buffers without "modifying" buffers, or redisplay should be
1105 smarter about updating the `*' in mode lines. --gerd */
1106 XSETBUFFER (buffer
, current_buffer
);
1107 window
= Fget_buffer_window (buffer
, Qt
);
1108 if (WINDOWP (window
))
1110 ++update_mode_lines
;
1111 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1117 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1118 Srestore_buffer_modified_p
, 1, 1, 0,
1119 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1120 It is not ensured that mode lines will be updated to show the modified
1121 state of the current buffer. Use with care. */)
1125 #ifdef CLASH_DETECTION
1128 /* If buffer becoming modified, lock the file.
1129 If buffer becoming unmodified, unlock the file. */
1131 fn
= current_buffer
->file_truename
;
1132 /* Test buffer-file-name so that binding it to nil is effective. */
1133 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1135 int already
= SAVE_MODIFF
< MODIFF
;
1136 if (!already
&& !NILP (flag
))
1138 else if (already
&& NILP (flag
))
1141 #endif /* CLASH_DETECTION */
1143 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1147 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1149 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1150 Each buffer has a tick counter which is incremented each time the
1151 text in that buffer is changed. It wraps around occasionally.
1152 No argument or nil as argument means use current buffer as BUFFER. */)
1154 register Lisp_Object buffer
;
1156 register struct buffer
*buf
;
1158 buf
= current_buffer
;
1161 CHECK_BUFFER (buffer
);
1162 buf
= XBUFFER (buffer
);
1165 return make_number (BUF_MODIFF (buf
));
1168 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick
,
1169 Sbuffer_chars_modified_tick
, 0, 1, 0,
1170 doc
: /* Return BUFFER's character-change tick counter.
1171 Each buffer has a character-change tick counter, which is set to the
1172 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1173 time text in that buffer is inserted or deleted. By comparing the
1174 values returned by two individual calls of `buffer-chars-modified-tick',
1175 you can tell whether a character change occurred in that buffer in
1176 between these calls. No argument or nil as argument means use current
1177 buffer as BUFFER. */)
1179 register Lisp_Object buffer
;
1181 register struct buffer
*buf
;
1183 buf
= current_buffer
;
1186 CHECK_BUFFER (buffer
);
1187 buf
= XBUFFER (buffer
);
1190 return make_number (BUF_CHARS_MODIFF (buf
));
1193 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1194 "sRename buffer (to new name): \nP",
1195 doc
: /* Change current buffer's name to NEWNAME (a string).
1196 If second arg UNIQUE is nil or omitted, it is an error if a
1197 buffer named NEWNAME already exists.
1198 If UNIQUE is non-nil, come up with a new name using
1199 `generate-new-buffer-name'.
1200 Interactively, you can set UNIQUE with a prefix argument.
1201 We return the name we actually gave the buffer.
1202 This does not change the name of the visited file (if any). */)
1204 register Lisp_Object newname
, unique
;
1206 register Lisp_Object tem
, buf
;
1208 CHECK_STRING (newname
);
1210 if (SCHARS (newname
) == 0)
1211 error ("Empty string is invalid as a buffer name");
1213 tem
= Fget_buffer (newname
);
1216 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1217 rename the buffer automatically so you can create another
1218 with the original name. It makes UNIQUE equivalent to
1219 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1220 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1221 return current_buffer
->name
;
1223 newname
= Fgenerate_new_buffer_name (newname
, current_buffer
->name
);
1225 error ("Buffer name `%s' is in use", SDATA (newname
));
1228 current_buffer
->name
= newname
;
1230 /* Catch redisplay's attention. Unless we do this, the mode lines for
1231 any windows displaying current_buffer will stay unchanged. */
1232 update_mode_lines
++;
1234 XSETBUFFER (buf
, current_buffer
);
1235 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1236 if (NILP (current_buffer
->filename
)
1237 && !NILP (current_buffer
->auto_save_file_name
))
1238 call0 (intern ("rename-auto-save-file"));
1239 /* Refetch since that last call may have done GC. */
1240 return current_buffer
->name
;
1243 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1244 doc
: /* Return most recently selected buffer other than BUFFER.
1245 Buffers not visible in windows are preferred to visible buffers,
1246 unless optional second argument VISIBLE-OK is non-nil.
1247 If the optional third argument FRAME is non-nil, use that frame's
1248 buffer list instead of the selected frame's buffer list.
1249 If no other buffer exists, the buffer `*scratch*' is returned.
1250 If BUFFER is omitted or nil, some interesting buffer is returned. */)
1251 (buffer
, visible_ok
, frame
)
1252 register Lisp_Object buffer
, visible_ok
, frame
;
1254 Lisp_Object
Fset_buffer_major_mode ();
1255 register Lisp_Object tail
, buf
, notsogood
, tem
, pred
, add_ons
;
1259 frame
= selected_frame
;
1261 tail
= Vbuffer_alist
;
1262 pred
= frame_buffer_predicate (frame
);
1264 /* Consider buffers that have been seen in the selected frame
1265 before other buffers. */
1267 tem
= frame_buffer_list (frame
);
1271 if (BUFFERP (XCAR (tem
)))
1272 add_ons
= Fcons (Fcons (Qnil
, XCAR (tem
)), add_ons
);
1275 tail
= nconc2 (Fnreverse (add_ons
), tail
);
1277 for (; CONSP (tail
); tail
= XCDR (tail
))
1279 buf
= Fcdr (XCAR (tail
));
1280 if (EQ (buf
, buffer
))
1284 if (NILP (XBUFFER (buf
)->name
))
1286 if (SREF (XBUFFER (buf
)->name
, 0) == ' ')
1288 /* If the selected frame has a buffer_predicate,
1289 disregard buffers that don't fit the predicate. */
1292 tem
= call1 (pred
, buf
);
1297 if (NILP (visible_ok
))
1298 tem
= Fget_buffer_window (buf
, Qvisible
);
1303 if (NILP (notsogood
))
1306 if (!NILP (notsogood
))
1308 buf
= Fget_buffer (build_string ("*scratch*"));
1311 buf
= Fget_buffer_create (build_string ("*scratch*"));
1312 Fset_buffer_major_mode (buf
);
1317 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1319 doc
: /* Start keeping undo information for buffer BUFFER.
1320 No argument or nil as argument means do this for the current buffer. */)
1322 register Lisp_Object buffer
;
1324 Lisp_Object real_buffer
;
1327 XSETBUFFER (real_buffer
, current_buffer
);
1330 real_buffer
= Fget_buffer (buffer
);
1331 if (NILP (real_buffer
))
1335 if (EQ (XBUFFER (real_buffer
)->undo_list
, Qt
))
1336 XBUFFER (real_buffer
)->undo_list
= Qnil
;
1342 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
1343 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
1344 The buffer being killed will be current while the hook is running.\n\
1347 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 1, 1, "bKill buffer: ",
1348 doc
: /* Kill the buffer BUFFER.
1349 The argument may be a buffer or the name of a buffer.
1350 With a nil argument, kill the current buffer.
1352 Value is t if the buffer is actually killed, nil otherwise.
1354 The functions in `kill-buffer-query-functions' are called with BUFFER as
1355 the current buffer. If any of them returns nil, the buffer is not killed.
1357 The hook `kill-buffer-hook' is run before the buffer is actually killed.
1358 The buffer being killed will be current while the hook is running.
1360 Any processes that have this buffer as the `process-buffer' are killed
1366 register struct buffer
*b
;
1367 register Lisp_Object tem
;
1368 register struct Lisp_Marker
*m
;
1369 struct gcpro gcpro1
;
1372 buf
= Fcurrent_buffer ();
1374 buf
= Fget_buffer (buffer
);
1380 /* Avoid trouble for buffer already dead. */
1384 /* Query if the buffer is still modified. */
1385 if (INTERACTIVE
&& !NILP (b
->filename
)
1386 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1389 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1390 b
->name
, make_number (0)));
1396 /* Run hooks with the buffer to be killed the current buffer. */
1398 int count
= SPECPDL_INDEX ();
1399 Lisp_Object arglist
[1];
1401 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1402 set_buffer_internal (b
);
1404 /* First run the query functions; if any query is answered no,
1405 don't kill the buffer. */
1406 arglist
[0] = Qkill_buffer_query_functions
;
1407 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1409 return unbind_to (count
, Qnil
);
1411 /* Then run the hooks. */
1412 Frun_hooks (1, &Qkill_buffer_hook
);
1413 unbind_to (count
, Qnil
);
1416 /* We have no more questions to ask. Verify that it is valid
1417 to kill the buffer. This must be done after the questions
1418 since anything can happen within do_yes_or_no_p. */
1420 /* Don't kill the minibuffer now current. */
1421 if (EQ (buf
, XWINDOW (minibuf_window
)->buffer
))
1427 /* When we kill a base buffer, kill all its indirect buffers.
1428 We do it at this stage so nothing terrible happens if they
1429 ask questions or their hooks get errors. */
1430 if (! b
->base_buffer
)
1432 struct buffer
*other
;
1436 for (other
= all_buffers
; other
; other
= other
->next
)
1437 /* all_buffers contains dead buffers too;
1438 don't re-kill them. */
1439 if (other
->base_buffer
== b
&& !NILP (other
->name
))
1442 XSETBUFFER (buf
, other
);
1449 /* Make this buffer not be current.
1450 In the process, notice if this is the sole visible buffer
1451 and give up if so. */
1452 if (b
== current_buffer
)
1454 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1456 if (b
== current_buffer
)
1460 /* Notice if the buffer to kill is the sole visible buffer
1461 when we're currently in the mini-buffer, and give up if so. */
1462 XSETBUFFER (tem
, current_buffer
);
1463 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
))
1465 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1470 /* Now there is no question: we can kill the buffer. */
1472 #ifdef CLASH_DETECTION
1473 /* Unlock this buffer's file, if it is locked. */
1475 #endif /* CLASH_DETECTION */
1478 kill_buffer_processes (buf
);
1481 /* Killing buffer processes may run sentinels which may
1482 have called kill-buffer. */
1487 clear_charpos_cache (b
);
1489 tem
= Vinhibit_quit
;
1491 replace_buffer_in_all_windows (buf
);
1492 Vbuffer_alist
= Fdelq (Frassq (buf
, Vbuffer_alist
), Vbuffer_alist
);
1493 frames_discard_buffer (buf
);
1494 Vinhibit_quit
= tem
;
1496 /* Delete any auto-save file, if we saved it in this session.
1497 But not if the buffer is modified. */
1498 if (STRINGP (b
->auto_save_file_name
)
1499 && b
->auto_save_modified
!= 0
1500 && BUF_SAVE_MODIFF (b
) < b
->auto_save_modified
1501 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1502 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1505 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
1507 internal_delete_file (b
->auto_save_file_name
);
1512 /* Unchain all markers that belong to this indirect buffer.
1513 Don't unchain the markers that belong to the base buffer
1514 or its other indirect buffers. */
1515 for (m
= BUF_MARKERS (b
); m
; )
1517 struct Lisp_Marker
*next
= m
->next
;
1525 /* Unchain all markers of this buffer and its indirect buffers.
1526 and leave them pointing nowhere. */
1527 for (m
= BUF_MARKERS (b
); m
; )
1529 struct Lisp_Marker
*next
= m
->next
;
1534 BUF_MARKERS (b
) = NULL
;
1535 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1537 /* Perhaps we should explicitly free the interval tree here... */
1540 /* Reset the local variables, so that this buffer's local values
1541 won't be protected from GC. They would be protected
1542 if they happened to remain encached in their symbols.
1543 This gets rid of them for certain. */
1544 swap_out_buffer_local_variables (b
);
1545 reset_buffer_local_variables (b
, 1);
1550 if (! b
->base_buffer
)
1551 free_buffer_text (b
);
1553 if (b
->newline_cache
)
1555 free_region_cache (b
->newline_cache
);
1556 b
->newline_cache
= 0;
1558 if (b
->width_run_cache
)
1560 free_region_cache (b
->width_run_cache
);
1561 b
->width_run_cache
= 0;
1563 b
->width_table
= Qnil
;
1565 b
->undo_list
= Qnil
;
1570 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
1571 we do this each time BUF is selected visibly, the more recently
1572 selected buffers are always closer to the front of the list. This
1573 means that other_buffer is more likely to choose a relevant buffer. */
1579 register Lisp_Object link
, prev
;
1581 frame
= selected_frame
;
1584 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCDR (link
))
1586 if (EQ (XCDR (XCAR (link
)), buf
))
1591 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
1592 we cannot use Fdelq itself here because it allows quitting. */
1595 Vbuffer_alist
= XCDR (Vbuffer_alist
);
1597 XSETCDR (prev
, XCDR (XCDR (prev
)));
1599 XSETCDR (link
, Vbuffer_alist
);
1600 Vbuffer_alist
= link
;
1602 /* Effectively do a delq on buried_buffer_list. */
1605 for (link
= XFRAME (frame
)->buried_buffer_list
; CONSP (link
);
1608 if (EQ (XCAR (link
), buf
))
1611 XFRAME (frame
)->buried_buffer_list
= XCDR (link
);
1613 XSETCDR (prev
, XCDR (XCDR (prev
)));
1619 /* Now move this buffer to the front of frame_buffer_list also. */
1622 for (link
= frame_buffer_list (frame
); CONSP (link
);
1625 if (EQ (XCAR (link
), buf
))
1630 /* Effectively do delq. */
1635 set_frame_buffer_list (frame
,
1636 XCDR (frame_buffer_list (frame
)));
1638 XSETCDR (prev
, XCDR (XCDR (prev
)));
1640 XSETCDR (link
, frame_buffer_list (frame
));
1641 set_frame_buffer_list (frame
, link
);
1644 set_frame_buffer_list (frame
, Fcons (buf
, frame_buffer_list (frame
)));
1647 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1648 doc
: /* Set an appropriate major mode for BUFFER.
1649 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1650 according to `default-major-mode'.
1651 Use this function before selecting the buffer, since it may need to inspect
1652 the current buffer's major mode. */)
1657 Lisp_Object function
;
1659 CHECK_BUFFER (buffer
);
1661 if (STRINGP (XBUFFER (buffer
)->name
)
1662 && strcmp (SDATA (XBUFFER (buffer
)->name
), "*scratch*") == 0)
1663 function
= find_symbol_value (intern ("initial-major-mode"));
1666 function
= buffer_defaults
.major_mode
;
1668 && NILP (Fget (current_buffer
->major_mode
, Qmode_class
)))
1669 function
= current_buffer
->major_mode
;
1672 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1675 count
= SPECPDL_INDEX ();
1677 /* To select a nonfundamental mode,
1678 select the buffer temporarily and then call the mode function. */
1680 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1682 Fset_buffer (buffer
);
1685 return unbind_to (count
, Qnil
);
1688 /* If switching buffers in WINDOW would be an error, return
1689 a C string saying what the error would be. */
1692 no_switch_window (window
)
1696 if (EQ (minibuf_window
, window
))
1697 return "Cannot switch buffers in minibuffer window";
1698 tem
= Fwindow_dedicated_p (window
);
1700 return "Cannot switch buffers in a dedicated window";
1704 /* Switch to buffer BUFFER in the selected window.
1705 If NORECORD is non-nil, don't call record_buffer. */
1708 switch_to_buffer_1 (buffer
, norecord
)
1709 Lisp_Object buffer
, norecord
;
1711 register Lisp_Object buf
;
1714 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1717 buf
= Fget_buffer (buffer
);
1720 buf
= Fget_buffer_create (buffer
);
1721 Fset_buffer_major_mode (buf
);
1725 if (NILP (norecord
))
1726 record_buffer (buf
);
1728 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
1729 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
1736 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2, "BSwitch to buffer: ",
1737 doc
: /* Select buffer BUFFER in the current window.
1738 If BUFFER does not identify an existing buffer,
1739 then this function creates a buffer with that name.
1741 When called from Lisp, BUFFER may be a buffer, a string \(a buffer name),
1742 or nil. If BUFFER is nil, then this function chooses a buffer
1743 using `other-buffer'.
1744 Optional second arg NORECORD non-nil means
1745 do not put this buffer at the front of the list of recently selected ones.
1746 This function returns the buffer it switched to.
1748 WARNING: This is NOT the way to work on another buffer temporarily
1749 within a Lisp program! Use `set-buffer' instead. That avoids messing with
1750 the window-buffer correspondences. */)
1752 Lisp_Object buffer
, norecord
;
1756 if (EQ (buffer
, Fwindow_buffer (selected_window
)))
1758 /* Basically a NOP. Avoid signalling an error in the case where
1759 the selected window is dedicated, or a minibuffer. */
1761 /* But do put this buffer at the front of the buffer list,
1762 unless that has been inhibited. Note that even if
1763 BUFFER is at the front of the main buffer-list already,
1764 we still want to move it to the front of the frame's buffer list. */
1765 if (NILP (norecord
))
1766 record_buffer (buffer
);
1767 return Fset_buffer (buffer
);
1770 err
= no_switch_window (selected_window
);
1771 if (err
) error (err
);
1773 return switch_to_buffer_1 (buffer
, norecord
);
1776 DEFUN ("pop-to-buffer", Fpop_to_buffer
, Spop_to_buffer
, 1, 3, 0,
1777 doc
: /* Select buffer BUFFER in some window, preferably a different one.
1778 BUFFER may be a buffer, a string \(a buffer name), or nil.
1779 If BUFFER is a string which is not the name of an existing buffer,
1780 then this function creates a buffer with that name.
1781 If BUFFER is nil, then it chooses some other buffer.
1782 If `pop-up-windows' is non-nil, windows can be split to do this.
1783 If optional second arg OTHER-WINDOW is non-nil, insist on finding another
1784 window even if BUFFER is already visible in the selected window,
1785 and ignore `same-window-regexps' and `same-window-buffer-names'.
1786 This function returns the buffer it switched to.
1787 This uses the function `display-buffer' as a subroutine; see the documentation
1788 of `display-buffer' for additional customization information.
1790 Optional third arg NORECORD non-nil means
1791 do not put this buffer at the front of the list of recently selected ones. */)
1792 (buffer
, other_window
, norecord
)
1793 Lisp_Object buffer
, other_window
, norecord
;
1795 register Lisp_Object buf
;
1797 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1800 buf
= Fget_buffer (buffer
);
1803 buf
= Fget_buffer_create (buffer
);
1804 Fset_buffer_major_mode (buf
);
1808 Fselect_window (Fdisplay_buffer (buf
, other_window
, Qnil
), norecord
);
1812 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1813 doc
: /* Return the current buffer as a Lisp object. */)
1816 register Lisp_Object buf
;
1817 XSETBUFFER (buf
, current_buffer
);
1821 /* Set the current buffer to B.
1823 We previously set windows_or_buffers_changed here to invalidate
1824 global unchanged information in beg_unchanged and end_unchanged.
1825 This is no longer necessary because we now compute unchanged
1826 information on a buffer-basis. Every action affecting other
1827 windows than the selected one requires a select_window at some
1828 time, and that increments windows_or_buffers_changed. */
1831 set_buffer_internal (b
)
1832 register struct buffer
*b
;
1834 if (current_buffer
!= b
)
1835 set_buffer_internal_1 (b
);
1838 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1839 This is used by redisplay. */
1842 set_buffer_internal_1 (b
)
1843 register struct buffer
*b
;
1845 register struct buffer
*old_buf
;
1846 register Lisp_Object tail
, valcontents
;
1849 #ifdef USE_MMAP_FOR_BUFFERS
1850 if (b
->text
->beg
== NULL
)
1851 enlarge_buffer_text (b
, 0);
1852 #endif /* USE_MMAP_FOR_BUFFERS */
1854 if (current_buffer
== b
)
1857 old_buf
= current_buffer
;
1859 last_known_column_point
= -1; /* invalidate indentation cache */
1863 /* Put the undo list back in the base buffer, so that it appears
1864 that an indirect buffer shares the undo list of its base. */
1865 if (old_buf
->base_buffer
)
1866 old_buf
->base_buffer
->undo_list
= old_buf
->undo_list
;
1868 /* If the old current buffer has markers to record PT, BEGV and ZV
1869 when it is not current, update them now. */
1870 if (! NILP (old_buf
->pt_marker
))
1873 XSETBUFFER (obuf
, old_buf
);
1874 set_marker_both (old_buf
->pt_marker
, obuf
,
1875 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1877 if (! NILP (old_buf
->begv_marker
))
1880 XSETBUFFER (obuf
, old_buf
);
1881 set_marker_both (old_buf
->begv_marker
, obuf
,
1882 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1884 if (! NILP (old_buf
->zv_marker
))
1887 XSETBUFFER (obuf
, old_buf
);
1888 set_marker_both (old_buf
->zv_marker
, obuf
,
1889 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1893 /* Get the undo list from the base buffer, so that it appears
1894 that an indirect buffer shares the undo list of its base. */
1896 b
->undo_list
= b
->base_buffer
->undo_list
;
1898 /* If the new current buffer has markers to record PT, BEGV and ZV
1899 when it is not current, fetch them now. */
1900 if (! NILP (b
->pt_marker
))
1902 BUF_PT (b
) = marker_position (b
->pt_marker
);
1903 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1905 if (! NILP (b
->begv_marker
))
1907 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1908 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1910 if (! NILP (b
->zv_marker
))
1912 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1913 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1916 /* Look down buffer's list of local Lisp variables
1917 to find and update any that forward into C variables. */
1919 for (tail
= b
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1921 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1922 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1923 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1924 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1925 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1926 /* Just reference the variable
1927 to cause it to become set for this buffer. */
1928 Fsymbol_value (XCAR (XCAR (tail
)));
1931 /* Do the same with any others that were local to the previous buffer */
1934 for (tail
= old_buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1936 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1937 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1938 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1939 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1940 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1941 /* Just reference the variable
1942 to cause it to become set for this buffer. */
1943 Fsymbol_value (XCAR (XCAR (tail
)));
1947 /* Switch to buffer B temporarily for redisplay purposes.
1948 This avoids certain things that don't need to be done within redisplay. */
1954 register struct buffer
*old_buf
;
1956 if (current_buffer
== b
)
1959 old_buf
= current_buffer
;
1964 /* If the old current buffer has markers to record PT, BEGV and ZV
1965 when it is not current, update them now. */
1966 if (! NILP (old_buf
->pt_marker
))
1969 XSETBUFFER (obuf
, old_buf
);
1970 set_marker_both (old_buf
->pt_marker
, obuf
,
1971 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1973 if (! NILP (old_buf
->begv_marker
))
1976 XSETBUFFER (obuf
, old_buf
);
1977 set_marker_both (old_buf
->begv_marker
, obuf
,
1978 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1980 if (! NILP (old_buf
->zv_marker
))
1983 XSETBUFFER (obuf
, old_buf
);
1984 set_marker_both (old_buf
->zv_marker
, obuf
,
1985 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1989 /* If the new current buffer has markers to record PT, BEGV and ZV
1990 when it is not current, fetch them now. */
1991 if (! NILP (b
->pt_marker
))
1993 BUF_PT (b
) = marker_position (b
->pt_marker
);
1994 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1996 if (! NILP (b
->begv_marker
))
1998 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1999 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
2001 if (! NILP (b
->zv_marker
))
2003 BUF_ZV (b
) = marker_position (b
->zv_marker
);
2004 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
2008 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
2009 doc
: /* Make the buffer BUFFER current for editing operations.
2010 BUFFER may be a buffer or the name of an existing buffer.
2011 See also `save-excursion' when you want to make a buffer current temporarily.
2012 This function does not display the buffer, so its effect ends
2013 when the current command terminates.
2014 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently. */)
2016 register Lisp_Object buffer
;
2018 register Lisp_Object buf
;
2019 buf
= Fget_buffer (buffer
);
2022 if (NILP (XBUFFER (buf
)->name
))
2023 error ("Selecting deleted buffer");
2024 set_buffer_internal (XBUFFER (buf
));
2028 /* Set the current buffer to BUFFER provided it is alive. */
2031 set_buffer_if_live (buffer
)
2034 if (! NILP (XBUFFER (buffer
)->name
))
2035 Fset_buffer (buffer
);
2039 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2040 Sbarf_if_buffer_read_only
, 0, 0, 0,
2041 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2044 if (!NILP (current_buffer
->read_only
)
2045 && NILP (Vinhibit_read_only
))
2046 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2050 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
2051 doc
: /* Put BUFFER at the end of the list of all buffers.
2052 There it is the least likely candidate for `other-buffer' to return;
2053 thus, the least likely buffer for \\[switch-to-buffer] to select by default.
2054 You can specify a buffer name as BUFFER, or an actual buffer object.
2055 If BUFFER is nil or omitted, bury the current buffer.
2056 Also, if BUFFER is nil or omitted, remove the current buffer from the
2057 selected window if it is displayed there. */)
2059 register Lisp_Object buffer
;
2061 /* Figure out what buffer we're going to bury. */
2065 XSETBUFFER (buffer
, current_buffer
);
2067 tem
= Fwindow_buffer (selected_window
);
2068 /* If we're burying the current buffer, unshow it. */
2069 if (EQ (buffer
, tem
))
2071 if (NILP (Fwindow_dedicated_p (selected_window
)))
2072 Fswitch_to_buffer (Fother_buffer (buffer
, Qnil
, Qnil
), Qnil
);
2073 else if (NILP (XWINDOW (selected_window
)->parent
))
2074 Ficonify_frame (Fwindow_frame (selected_window
));
2076 Fdelete_window (selected_window
);
2083 buf1
= Fget_buffer (buffer
);
2089 /* Move buffer to the end of the buffer list. Do nothing if the
2090 buffer is killed. */
2091 if (!NILP (XBUFFER (buffer
)->name
))
2093 Lisp_Object aelt
, link
;
2095 aelt
= Frassq (buffer
, Vbuffer_alist
);
2096 link
= Fmemq (aelt
, Vbuffer_alist
);
2097 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2098 XSETCDR (link
, Qnil
);
2099 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
2101 XFRAME (selected_frame
)->buffer_list
2102 = Fdelq (buffer
, XFRAME (selected_frame
)->buffer_list
);
2103 XFRAME (selected_frame
)->buried_buffer_list
2104 = Fcons (buffer
, Fdelq (buffer
, XFRAME (selected_frame
)->buried_buffer_list
));
2110 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2111 doc
: /* Delete the entire contents of the current buffer.
2112 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2113 so the buffer is truly empty after this. */)
2120 current_buffer
->last_window_start
= 1;
2121 /* Prevent warnings, or suspension of auto saving, that would happen
2122 if future size is less than past size. Use of erase-buffer
2123 implies that the future text is not really related to the past text. */
2124 XSETFASTINT (current_buffer
->save_length
, 0);
2129 validate_region (b
, e
)
2130 register Lisp_Object
*b
, *e
;
2132 CHECK_NUMBER_COERCE_MARKER (*b
);
2133 CHECK_NUMBER_COERCE_MARKER (*e
);
2135 if (XINT (*b
) > XINT (*e
))
2138 tem
= *b
; *b
= *e
; *e
= tem
;
2141 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
2142 && XINT (*e
) <= ZV
))
2143 args_out_of_range (*b
, *e
);
2146 /* Advance BYTE_POS up to a character boundary
2147 and return the adjusted position. */
2150 advance_to_char_boundary (byte_pos
)
2155 if (byte_pos
== BEG
)
2156 /* Beginning of buffer is always a character boundary. */
2159 c
= FETCH_BYTE (byte_pos
);
2160 if (! CHAR_HEAD_P (c
))
2162 /* We should advance BYTE_POS only when C is a constituent of a
2163 multibyte sequence. */
2164 int orig_byte_pos
= byte_pos
;
2169 c
= FETCH_BYTE (byte_pos
);
2171 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2173 if (byte_pos
< orig_byte_pos
)
2174 byte_pos
= orig_byte_pos
;
2175 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2176 surely advance to the correct character boundary. If C is
2177 not, BYTE_POS was unchanged. */
2183 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2185 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2186 If FLAG is t, this makes the buffer a multibyte buffer.
2187 If FLAG is nil, this makes the buffer a single-byte buffer.
2188 In these cases, the buffer contents remain unchanged as a sequence of
2189 bytes but the contents viewed as characters do change.
2190 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2191 all eight-bit bytes to eight-bit characters.
2192 If the multibyte flag was really changed, undo information of the
2193 current buffer is cleared. */)
2197 struct Lisp_Marker
*tail
, *markers
;
2198 struct buffer
*other
;
2200 int narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2201 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2202 Lisp_Object old_undo
= current_buffer
->undo_list
;
2203 struct gcpro gcpro1
;
2205 if (current_buffer
->base_buffer
)
2206 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2208 /* Do nothing if nothing actually changes. */
2209 if (NILP (flag
) == NILP (current_buffer
->enable_multibyte_characters
))
2214 /* Don't record these buffer changes. We will put a special undo entry
2216 current_buffer
->undo_list
= Qt
;
2218 /* If the cached position is for this buffer, clear it out. */
2219 clear_charpos_cache (current_buffer
);
2222 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2224 begv
= BEGV
, zv
= ZV
;
2234 /* Do this first, so it can use CHAR_TO_BYTE
2235 to calculate the old correspondences. */
2236 set_intervals_multibyte (0);
2238 current_buffer
->enable_multibyte_characters
= Qnil
;
2244 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2247 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2248 tail
->charpos
= tail
->bytepos
;
2250 /* Convert multibyte form of 8-bit characters to unibyte. */
2265 if (ASCII_BYTE_P (*p
))
2267 else if (CHAR_BYTE8_HEAD_P (*p
))
2269 c
= STRING_CHAR_AND_LENGTH (p
, stop
- pos
, bytes
);
2270 /* Delete all bytes for this 8-bit character but the
2271 last one, and change the last one to the charcter
2274 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2286 bytes
= BYTES_BY_CHAR_HEAD (*p
);
2287 p
+= bytes
, pos
+= bytes
;
2291 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2297 unsigned char *p
, *pend
;
2299 /* Be sure not to have a multibyte sequence striding over the GAP.
2300 Ex: We change this: "...abc\302 _GAP_ \241def..."
2301 to: "...abc _GAP_ \302\241def..." */
2304 && GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2305 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2307 unsigned char *p
= GPT_ADDR
- 1;
2309 while (! CHAR_HEAD_P (*p
) && p
> BEG_ADDR
) p
--;
2310 if (BASE_LEADING_CODE_P (*p
))
2312 int new_gpt
= GPT_BYTE
- (GPT_ADDR
- p
);
2314 move_gap_both (new_gpt
, new_gpt
);
2318 /* Make the buffer contents valid as multibyte by converting
2319 8-bit characters to multibyte form. */
2337 if (ASCII_BYTE_P (*p
))
2339 else if (EQ (flag
, Qt
) && (bytes
= MULTIBYTE_LENGTH (p
, pend
)) > 0)
2340 p
+= bytes
, pos
+= bytes
;
2343 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2346 c
= BYTE8_TO_CHAR (*p
);
2347 bytes
= CHAR_STRING (c
, tmp
);
2349 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2351 insert_1_both (tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2352 /* Now the gap is after the just inserted data. */
2370 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2372 /* Do this first, so that chars_in_text asks the right question.
2373 set_intervals_multibyte needs it too. */
2374 current_buffer
->enable_multibyte_characters
= Qt
;
2376 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2377 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2379 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2381 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2382 if (BEGV_BYTE
> GPT_BYTE
)
2383 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2385 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2387 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2388 if (ZV_BYTE
> GPT_BYTE
)
2389 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2391 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2394 int pt_byte
= advance_to_char_boundary (PT_BYTE
);
2397 if (pt_byte
> GPT_BYTE
)
2398 pt
= chars_in_text (GAP_END_ADDR
, pt_byte
- GPT_BYTE
) + GPT
;
2400 pt
= chars_in_text (BEG_ADDR
, pt_byte
- BEG_BYTE
) + BEG
;
2401 TEMP_SET_PT_BOTH (pt
, pt_byte
);
2404 tail
= markers
= BUF_MARKERS (current_buffer
);
2406 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2407 getting confused by the markers that have not yet been updated.
2408 It is also a signal that it should never create a marker. */
2409 BUF_MARKERS (current_buffer
) = NULL
;
2411 for (; tail
; tail
= tail
->next
)
2413 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2414 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2417 /* Make sure no markers were put on the chain
2418 while the chain value was incorrect. */
2419 if (BUF_MARKERS (current_buffer
))
2422 BUF_MARKERS (current_buffer
) = markers
;
2424 /* Do this last, so it can calculate the new correspondences
2425 between chars and bytes. */
2426 set_intervals_multibyte (1);
2429 if (!EQ (old_undo
, Qt
))
2431 /* Represent all the above changes by a special undo entry. */
2432 extern Lisp_Object Qapply
;
2433 current_buffer
->undo_list
= Fcons (list3 (Qapply
,
2434 intern ("set-buffer-multibyte"),
2435 NILP (flag
) ? Qt
: Qnil
),
2441 /* Changing the multibyteness of a buffer means that all windows
2442 showing that buffer must be updated thoroughly. */
2443 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2444 ++windows_or_buffers_changed
;
2446 /* Copy this buffer's new multibyte status
2447 into all of its indirect buffers. */
2448 for (other
= all_buffers
; other
; other
= other
->next
)
2449 if (other
->base_buffer
== current_buffer
&& !NILP (other
->name
))
2451 other
->enable_multibyte_characters
2452 = current_buffer
->enable_multibyte_characters
;
2453 other
->prevent_redisplay_optimizations_p
= 1;
2456 /* Restore the modifiedness of the buffer. */
2457 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2458 Fset_buffer_modified_p (Qnil
);
2461 /* Update coding systems of this buffer's process (if any). */
2463 Lisp_Object process
;
2465 process
= Fget_buffer_process (Fcurrent_buffer ());
2466 if (PROCESSP (process
))
2467 setup_process_coding_systems (process
);
2469 #endif /* subprocesses */
2474 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
2476 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2477 Most local variable bindings are eliminated so that the default values
2478 become effective once more. Also, the syntax table is set from
2479 `standard-syntax-table', the local keymap is set to nil,
2480 and the abbrev table from `fundamental-mode-abbrev-table'.
2481 This function also forces redisplay of the mode line.
2483 Every function to select a new major mode starts by
2484 calling this function.
2486 As a special exception, local variables whose names have
2487 a non-nil `permanent-local' property are not eliminated by this function.
2489 The first thing this function does is run
2490 the normal hook `change-major-mode-hook'. */)
2493 register Lisp_Object alist
, sym
, tem
;
2496 if (!NILP (Vrun_hooks
))
2497 call1 (Vrun_hooks
, Qchange_major_mode_hook
);
2498 oalist
= current_buffer
->local_var_alist
;
2500 /* Make sure none of the bindings in oalist
2501 remain swapped in, in their symbols. */
2503 swap_out_buffer_local_variables (current_buffer
);
2505 /* Actually eliminate all local bindings of this buffer. */
2507 reset_buffer_local_variables (current_buffer
, 0);
2509 /* Any which are supposed to be permanent,
2510 make local again, with the same values they had. */
2512 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2514 sym
= XCAR (XCAR (alist
));
2515 tem
= Fget (sym
, Qpermanent_local
);
2518 Fmake_local_variable (sym
);
2519 Fset (sym
, XCDR (XCAR (alist
)));
2523 /* Force mode-line redisplay. Useful here because all major mode
2524 commands call this function. */
2525 update_mode_lines
++;
2530 /* Make sure no local variables remain set up with buffer B
2531 for their current values. */
2534 swap_out_buffer_local_variables (b
)
2537 Lisp_Object oalist
, alist
, sym
, tem
, buffer
;
2539 XSETBUFFER (buffer
, b
);
2540 oalist
= b
->local_var_alist
;
2542 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2544 sym
= XCAR (XCAR (alist
));
2546 /* Need not do anything if some other buffer's binding is now encached. */
2547 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
;
2548 if (BUFFERP (tem
) && XBUFFER (tem
) == current_buffer
)
2550 /* Symbol is set up for this buffer's old local value.
2551 Set it up for the current buffer with the default value. */
2553 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->cdr
;
2554 /* Store the symbol's current value into the alist entry
2555 it is currently set up for. This is so that, if the
2556 local is marked permanent, and we make it local again
2557 later in Fkill_all_local_variables, we don't lose the value. */
2558 XSETCDR (XCAR (tem
),
2559 do_symval_forwarding (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->realvalue
));
2560 /* Switch to the symbol's default-value alist entry. */
2562 /* Mark it as current for buffer B. */
2563 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
= buffer
;
2564 /* Store the current value into any forwarding in the symbol. */
2565 store_symval_forwarding (sym
,
2566 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->realvalue
,
2572 /* Find all the overlays in the current buffer that contain position POS.
2573 Return the number found, and store them in a vector in *VEC_PTR.
2574 Store in *LEN_PTR the size allocated for the vector.
2575 Store in *NEXT_PTR the next position after POS where an overlay starts,
2576 or ZV if there are no more overlays between POS and ZV.
2577 Store in *PREV_PTR the previous position before POS where an overlay ends,
2578 or where an overlay starts which ends at or after POS;
2579 or BEGV if there are no such overlays from BEGV to POS.
2580 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2582 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2583 when this function is called.
2585 If EXTEND is non-zero, we make the vector bigger if necessary.
2586 If EXTEND is zero, we never extend the vector,
2587 and we store only as many overlays as will fit.
2588 But we still return the total number of overlays.
2590 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2591 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2592 default (BEGV or ZV). */
2595 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
, change_req
)
2598 Lisp_Object
**vec_ptr
;
2604 Lisp_Object overlay
, start
, end
;
2605 struct Lisp_Overlay
*tail
;
2608 Lisp_Object
*vec
= *vec_ptr
;
2611 int inhibit_storing
= 0;
2613 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2615 int startpos
, endpos
;
2617 XSETMISC (overlay
, tail
);
2619 start
= OVERLAY_START (overlay
);
2620 end
= OVERLAY_END (overlay
);
2621 endpos
= OVERLAY_POSITION (end
);
2628 startpos
= OVERLAY_POSITION (start
);
2629 /* This one ends at or after POS
2630 so its start counts for PREV_PTR if it's before POS. */
2631 if (prev
< startpos
&& startpos
< pos
)
2635 if (startpos
<= pos
)
2639 /* The supplied vector is full.
2640 Either make it bigger, or don't store any more in it. */
2643 /* Make it work with an initial len == 0. */
2648 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2652 inhibit_storing
= 1;
2655 if (!inhibit_storing
)
2657 /* Keep counting overlays even if we can't return them all. */
2660 else if (startpos
< next
)
2664 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2666 int startpos
, endpos
;
2668 XSETMISC (overlay
, tail
);
2670 start
= OVERLAY_START (overlay
);
2671 end
= OVERLAY_END (overlay
);
2672 startpos
= OVERLAY_POSITION (start
);
2675 if (startpos
< next
)
2679 endpos
= OVERLAY_POSITION (end
);
2686 /* Make it work with an initial len == 0. */
2691 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2695 inhibit_storing
= 1;
2698 if (!inhibit_storing
)
2702 if (startpos
< pos
&& startpos
> prev
)
2705 else if (endpos
< pos
&& endpos
> prev
)
2707 else if (endpos
== pos
&& startpos
> prev
2708 && (!change_req
|| startpos
< pos
))
2719 /* Find all the overlays in the current buffer that overlap the range BEG-END
2720 or are empty at BEG.
2722 Return the number found, and store them in a vector in *VEC_PTR.
2723 Store in *LEN_PTR the size allocated for the vector.
2724 Store in *NEXT_PTR the next position after POS where an overlay starts,
2725 or ZV if there are no more overlays.
2726 Store in *PREV_PTR the previous position before POS where an overlay ends,
2727 or BEGV if there are no previous overlays.
2728 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2730 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2731 when this function is called.
2733 If EXTEND is non-zero, we make the vector bigger if necessary.
2734 If EXTEND is zero, we never extend the vector,
2735 and we store only as many overlays as will fit.
2736 But we still return the total number of overlays. */
2739 overlays_in (beg
, end
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
2742 Lisp_Object
**vec_ptr
;
2747 Lisp_Object overlay
, ostart
, oend
;
2748 struct Lisp_Overlay
*tail
;
2751 Lisp_Object
*vec
= *vec_ptr
;
2754 int inhibit_storing
= 0;
2756 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2758 int startpos
, endpos
;
2760 XSETMISC (overlay
, tail
);
2762 ostart
= OVERLAY_START (overlay
);
2763 oend
= OVERLAY_END (overlay
);
2764 endpos
= OVERLAY_POSITION (oend
);
2771 startpos
= OVERLAY_POSITION (ostart
);
2772 /* Count an interval if it either overlaps the range
2773 or is empty at the start of the range. */
2774 if ((beg
< endpos
&& startpos
< end
)
2775 || (startpos
== endpos
&& beg
== endpos
))
2779 /* The supplied vector is full.
2780 Either make it bigger, or don't store any more in it. */
2783 /* Make it work with an initial len == 0. */
2788 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2792 inhibit_storing
= 1;
2795 if (!inhibit_storing
)
2797 /* Keep counting overlays even if we can't return them all. */
2800 else if (startpos
< next
)
2804 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2806 int startpos
, endpos
;
2808 XSETMISC (overlay
, tail
);
2810 ostart
= OVERLAY_START (overlay
);
2811 oend
= OVERLAY_END (overlay
);
2812 startpos
= OVERLAY_POSITION (ostart
);
2815 if (startpos
< next
)
2819 endpos
= OVERLAY_POSITION (oend
);
2820 /* Count an interval if it either overlaps the range
2821 or is empty at the start of the range. */
2822 if ((beg
< endpos
&& startpos
< end
)
2823 || (startpos
== endpos
&& beg
== endpos
))
2829 /* Make it work with an initial len == 0. */
2834 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2838 inhibit_storing
= 1;
2841 if (!inhibit_storing
)
2845 else if (endpos
< beg
&& endpos
> prev
)
2857 /* Return non-zero if there exists an overlay with a non-nil
2858 `mouse-face' property overlapping OVERLAY. */
2861 mouse_face_overlay_overlaps (overlay
)
2862 Lisp_Object overlay
;
2864 int start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2865 int end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2867 Lisp_Object
*v
, tem
;
2870 v
= (Lisp_Object
*) alloca (size
* sizeof *v
);
2871 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
2874 v
= (Lisp_Object
*) alloca (n
* sizeof *v
);
2875 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
2878 for (i
= 0; i
< n
; ++i
)
2879 if (!EQ (v
[i
], overlay
)
2880 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
2889 /* Fast function to just test if we're at an overlay boundary. */
2891 overlay_touches_p (pos
)
2894 Lisp_Object overlay
;
2895 struct Lisp_Overlay
*tail
;
2897 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2901 XSETMISC (overlay
,tail
);
2902 if (!OVERLAYP (overlay
))
2905 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2908 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
2912 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2916 XSETMISC (overlay
, tail
);
2917 if (!OVERLAYP (overlay
))
2920 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2923 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
2931 Lisp_Object overlay
;
2937 compare_overlays (v1
, v2
)
2938 const void *v1
, *v2
;
2940 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
2941 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
2942 if (s1
->priority
!= s2
->priority
)
2943 return s1
->priority
- s2
->priority
;
2944 if (s1
->beg
!= s2
->beg
)
2945 return s1
->beg
- s2
->beg
;
2946 if (s1
->end
!= s2
->end
)
2947 return s2
->end
- s1
->end
;
2951 /* Sort an array of overlays by priority. The array is modified in place.
2952 The return value is the new size; this may be smaller than the original
2953 size if some of the overlays were invalid or were window-specific. */
2955 sort_overlays (overlay_vec
, noverlays
, w
)
2956 Lisp_Object
*overlay_vec
;
2961 struct sortvec
*sortvec
;
2962 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
2964 /* Put the valid and relevant overlays into sortvec. */
2966 for (i
= 0, j
= 0; i
< noverlays
; i
++)
2969 Lisp_Object overlay
;
2971 overlay
= overlay_vec
[i
];
2972 if (OVERLAY_VALID (overlay
)
2973 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
2974 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
2976 /* If we're interested in a specific window, then ignore
2977 overlays that are limited to some other window. */
2982 window
= Foverlay_get (overlay
, Qwindow
);
2983 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2987 /* This overlay is good and counts: put it into sortvec. */
2988 sortvec
[j
].overlay
= overlay
;
2989 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2990 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2991 tem
= Foverlay_get (overlay
, Qpriority
);
2993 sortvec
[j
].priority
= XINT (tem
);
2995 sortvec
[j
].priority
= 0;
3001 /* Sort the overlays into the proper order: increasing priority. */
3004 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
3006 for (i
= 0; i
< noverlays
; i
++)
3007 overlay_vec
[i
] = sortvec
[i
].overlay
;
3013 Lisp_Object string
, string2
;
3020 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
3021 int size
; /* Allocated length of that array. */
3022 int used
; /* How much of the array is currently in use. */
3023 int bytes
; /* Total length of the strings in buf. */
3026 /* Buffers for storing information about the overlays touching a given
3027 position. These could be automatic variables in overlay_strings, but
3028 it's more efficient to hold onto the memory instead of repeatedly
3029 allocating and freeing it. */
3030 static struct sortstrlist overlay_heads
, overlay_tails
;
3031 static unsigned char *overlay_str_buf
;
3033 /* Allocated length of overlay_str_buf. */
3034 static int overlay_str_len
;
3036 /* A comparison function suitable for passing to qsort. */
3038 cmp_for_strings (as1
, as2
)
3041 struct sortstr
*s1
= (struct sortstr
*)as1
;
3042 struct sortstr
*s2
= (struct sortstr
*)as2
;
3043 if (s1
->size
!= s2
->size
)
3044 return s2
->size
- s1
->size
;
3045 if (s1
->priority
!= s2
->priority
)
3046 return s1
->priority
- s2
->priority
;
3051 record_overlay_string (ssl
, str
, str2
, pri
, size
)
3052 struct sortstrlist
*ssl
;
3053 Lisp_Object str
, str2
, pri
;
3058 if (ssl
->used
== ssl
->size
)
3064 ssl
->buf
= ((struct sortstr
*)
3065 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
3067 ssl
->buf
[ssl
->used
].string
= str
;
3068 ssl
->buf
[ssl
->used
].string2
= str2
;
3069 ssl
->buf
[ssl
->used
].size
= size
;
3070 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3073 if (NILP (current_buffer
->enable_multibyte_characters
))
3074 nbytes
= SCHARS (str
);
3075 else if (! STRING_MULTIBYTE (str
))
3076 nbytes
= count_size_as_multibyte (SDATA (str
),
3079 nbytes
= SBYTES (str
);
3081 ssl
->bytes
+= nbytes
;
3085 if (NILP (current_buffer
->enable_multibyte_characters
))
3086 nbytes
= SCHARS (str2
);
3087 else if (! STRING_MULTIBYTE (str2
))
3088 nbytes
= count_size_as_multibyte (SDATA (str2
),
3091 nbytes
= SBYTES (str2
);
3093 ssl
->bytes
+= nbytes
;
3097 /* Return the concatenation of the strings associated with overlays that
3098 begin or end at POS, ignoring overlays that are specific to a window
3099 other than W. The strings are concatenated in the appropriate order:
3100 shorter overlays nest inside longer ones, and higher priority inside
3101 lower. Normally all of the after-strings come first, but zero-sized
3102 overlays have their after-strings ride along with the before-strings
3103 because it would look strange to print them inside-out.
3105 Returns the string length, and stores the contents indirectly through
3106 PSTR, if that variable is non-null. The string may be overwritten by
3107 subsequent calls. */
3110 overlay_strings (pos
, w
, pstr
)
3113 unsigned char **pstr
;
3115 Lisp_Object overlay
, window
, str
;
3116 struct Lisp_Overlay
*ov
;
3117 int startpos
, endpos
;
3118 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
3120 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3121 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3122 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3124 XSETMISC (overlay
, ov
);
3125 eassert (OVERLAYP (overlay
));
3127 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3128 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3131 if (endpos
!= pos
&& startpos
!= pos
)
3133 window
= Foverlay_get (overlay
, Qwindow
);
3134 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3137 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3138 record_overlay_string (&overlay_heads
, str
,
3140 ? Foverlay_get (overlay
, Qafter_string
)
3142 Foverlay_get (overlay
, Qpriority
),
3144 else if (endpos
== pos
3145 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3146 record_overlay_string (&overlay_tails
, str
, Qnil
,
3147 Foverlay_get (overlay
, Qpriority
),
3150 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3152 XSETMISC (overlay
, ov
);
3153 eassert (OVERLAYP (overlay
));
3155 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3156 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3159 if (endpos
!= pos
&& startpos
!= pos
)
3161 window
= Foverlay_get (overlay
, Qwindow
);
3162 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3165 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3166 record_overlay_string (&overlay_heads
, str
,
3168 ? Foverlay_get (overlay
, Qafter_string
)
3170 Foverlay_get (overlay
, Qpriority
),
3172 else if (endpos
== pos
3173 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3174 record_overlay_string (&overlay_tails
, str
, Qnil
,
3175 Foverlay_get (overlay
, Qpriority
),
3178 if (overlay_tails
.used
> 1)
3179 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3181 if (overlay_heads
.used
> 1)
3182 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3184 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3189 int total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3191 if (total
> overlay_str_len
)
3193 overlay_str_len
= total
;
3194 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
3197 p
= overlay_str_buf
;
3198 for (i
= overlay_tails
.used
; --i
>= 0;)
3201 tem
= overlay_tails
.buf
[i
].string
;
3202 nbytes
= copy_text (SDATA (tem
), p
,
3204 STRING_MULTIBYTE (tem
), multibyte
);
3207 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3210 tem
= overlay_heads
.buf
[i
].string
;
3211 nbytes
= copy_text (SDATA (tem
), p
,
3213 STRING_MULTIBYTE (tem
), multibyte
);
3215 tem
= overlay_heads
.buf
[i
].string2
;
3218 nbytes
= copy_text (SDATA (tem
), p
,
3220 STRING_MULTIBYTE (tem
), multibyte
);
3224 if (p
!= overlay_str_buf
+ total
)
3227 *pstr
= overlay_str_buf
;
3233 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3236 recenter_overlay_lists (buf
, pos
)
3240 Lisp_Object overlay
, beg
, end
;
3241 struct Lisp_Overlay
*prev
, *tail
, *next
;
3243 /* See if anything in overlays_before should move to overlays_after. */
3245 /* We don't strictly need prev in this loop; it should always be nil.
3246 But we use it for symmetry and in case that should cease to be true
3247 with some future change. */
3249 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3252 XSETMISC (overlay
, tail
);
3254 /* If the overlay is not valid, get rid of it. */
3255 if (!OVERLAY_VALID (overlay
))
3260 /* Splice the cons cell TAIL out of overlays_before. */
3264 buf
->overlays_before
= next
;
3270 beg
= OVERLAY_START (overlay
);
3271 end
= OVERLAY_END (overlay
);
3273 if (OVERLAY_POSITION (end
) > pos
)
3275 /* OVERLAY needs to be moved. */
3276 int where
= OVERLAY_POSITION (beg
);
3277 struct Lisp_Overlay
*other
, *other_prev
;
3279 /* Splice the cons cell TAIL out of overlays_before. */
3283 buf
->overlays_before
= next
;
3285 /* Search thru overlays_after for where to put it. */
3287 for (other
= buf
->overlays_after
; other
;
3288 other_prev
= other
, other
= other
->next
)
3290 Lisp_Object otherbeg
, otheroverlay
;
3292 XSETMISC (otheroverlay
, other
);
3293 eassert (OVERLAY_VALID (otheroverlay
));
3295 otherbeg
= OVERLAY_START (otheroverlay
);
3296 if (OVERLAY_POSITION (otherbeg
) >= where
)
3300 /* Add TAIL to overlays_after before OTHER. */
3303 other_prev
->next
= tail
;
3305 buf
->overlays_after
= tail
;
3309 /* We've reached the things that should stay in overlays_before.
3310 All the rest of overlays_before must end even earlier,
3315 /* See if anything in overlays_after should be in overlays_before. */
3317 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3320 XSETMISC (overlay
, tail
);
3322 /* If the overlay is not valid, get rid of it. */
3323 if (!OVERLAY_VALID (overlay
))
3328 /* Splice the cons cell TAIL out of overlays_after. */
3332 buf
->overlays_after
= next
;
3338 beg
= OVERLAY_START (overlay
);
3339 end
= OVERLAY_END (overlay
);
3341 /* Stop looking, when we know that nothing further
3342 can possibly end before POS. */
3343 if (OVERLAY_POSITION (beg
) > pos
)
3346 if (OVERLAY_POSITION (end
) <= pos
)
3348 /* OVERLAY needs to be moved. */
3349 int where
= OVERLAY_POSITION (end
);
3350 struct Lisp_Overlay
*other
, *other_prev
;
3352 /* Splice the cons cell TAIL out of overlays_after. */
3356 buf
->overlays_after
= next
;
3358 /* Search thru overlays_before for where to put it. */
3360 for (other
= buf
->overlays_before
; other
;
3361 other_prev
= other
, other
= other
->next
)
3363 Lisp_Object otherend
, otheroverlay
;
3365 XSETMISC (otheroverlay
, other
);
3366 eassert (OVERLAY_VALID (otheroverlay
));
3368 otherend
= OVERLAY_END (otheroverlay
);
3369 if (OVERLAY_POSITION (otherend
) <= where
)
3373 /* Add TAIL to overlays_before before OTHER. */
3376 other_prev
->next
= tail
;
3378 buf
->overlays_before
= tail
;
3383 buf
->overlay_center
= pos
;
3387 adjust_overlays_for_insert (pos
, length
)
3391 /* After an insertion, the lists are still sorted properly,
3392 but we may need to update the value of the overlay center. */
3393 if (current_buffer
->overlay_center
>= pos
)
3394 current_buffer
->overlay_center
+= length
;
3398 adjust_overlays_for_delete (pos
, length
)
3402 if (current_buffer
->overlay_center
< pos
)
3403 /* The deletion was to our right. No change needed; the before- and
3404 after-lists are still consistent. */
3406 else if (current_buffer
->overlay_center
> pos
+ length
)
3407 /* The deletion was to our left. We need to adjust the center value
3408 to account for the change in position, but the lists are consistent
3409 given the new value. */
3410 current_buffer
->overlay_center
-= length
;
3412 /* We're right in the middle. There might be things on the after-list
3413 that now belong on the before-list. Recentering will move them,
3414 and also update the center point. */
3415 recenter_overlay_lists (current_buffer
, pos
);
3418 /* Fix up overlays that were garbled as a result of permuting markers
3419 in the range START through END. Any overlay with at least one
3420 endpoint in this range will need to be unlinked from the overlay
3421 list and reinserted in its proper place.
3422 Such an overlay might even have negative size at this point.
3423 If so, we'll make the overlay empty. */
3425 fix_start_end_in_overlays (start
, end
)
3426 register int start
, end
;
3428 Lisp_Object overlay
;
3429 struct Lisp_Overlay
*before_list
, *after_list
;
3430 /* These are either nil, indicating that before_list or after_list
3431 should be assigned, or the cons cell the cdr of which should be
3433 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3434 /* 'Parent', likewise, indicates a cons cell or
3435 current_buffer->overlays_before or overlays_after, depending
3436 which loop we're in. */
3437 struct Lisp_Overlay
*tail
, *parent
;
3438 int startpos
, endpos
;
3440 /* This algorithm shifts links around instead of consing and GCing.
3441 The loop invariant is that before_list (resp. after_list) is a
3442 well-formed list except that its last element, the CDR of beforep
3443 (resp. afterp) if beforep (afterp) isn't nil or before_list
3444 (after_list) if it is, is still uninitialized. So it's not a bug
3445 that before_list isn't initialized, although it may look
3447 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3449 XSETMISC (overlay
, tail
);
3451 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3452 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3454 /* If the overlay is backwards, make it empty. */
3455 if (endpos
< startpos
)
3458 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3466 || (startpos
>= start
&& startpos
< end
))
3468 /* Add it to the end of the wrong list. Later on,
3469 recenter_overlay_lists will move it to the right place. */
3470 if (endpos
< current_buffer
->overlay_center
)
3475 afterp
->next
= tail
;
3483 beforep
->next
= tail
;
3487 current_buffer
->overlays_before
= tail
->next
;
3489 parent
->next
= tail
->next
;
3493 parent
= tail
, tail
= parent
->next
;
3495 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3497 XSETMISC (overlay
, tail
);
3499 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3500 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3502 /* If the overlay is backwards, make it empty. */
3503 if (endpos
< startpos
)
3506 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3510 if (startpos
>= end
)
3513 if (startpos
>= start
3514 || (endpos
>= start
&& endpos
< end
))
3516 if (endpos
< current_buffer
->overlay_center
)
3521 afterp
->next
= tail
;
3529 beforep
->next
= tail
;
3533 current_buffer
->overlays_after
= tail
->next
;
3535 parent
->next
= tail
->next
;
3539 parent
= tail
, tail
= parent
->next
;
3542 /* Splice the constructed (wrong) lists into the buffer's lists,
3543 and let the recenter function make it sane again. */
3546 beforep
->next
= current_buffer
->overlays_before
;
3547 current_buffer
->overlays_before
= before_list
;
3549 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3553 afterp
->next
= current_buffer
->overlays_after
;
3554 current_buffer
->overlays_after
= after_list
;
3556 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3559 /* We have two types of overlay: the one whose ending marker is
3560 after-insertion-marker (this is the usual case) and the one whose
3561 ending marker is before-insertion-marker. When `overlays_before'
3562 contains overlays of the latter type and the former type in this
3563 order and both overlays end at inserting position, inserting a text
3564 increases only the ending marker of the latter type, which results
3565 in incorrect ordering of `overlays_before'.
3567 This function fixes ordering of overlays in the slot
3568 `overlays_before' of the buffer *BP. Before the insertion, `point'
3569 was at PREV, and now is at POS. */
3572 fix_overlays_before (bp
, prev
, pos
)
3574 EMACS_INT prev
, pos
;
3576 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3577 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3581 /* After the insertion, the several overlays may be in incorrect
3582 order. The possibility is that, in the list `overlays_before',
3583 an overlay which ends at POS appears after an overlay which ends
3584 at PREV. Since POS is greater than PREV, we must fix the
3585 ordering of these overlays, by moving overlays ends at POS before
3586 the overlays ends at PREV. */
3588 /* At first, find a place where disordered overlays should be linked
3589 in. It is where an overlay which end before POS exists. (i.e. an
3590 overlay whose ending marker is after-insertion-marker if disorder
3593 && (XSETMISC (tem
, tail
),
3594 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3600 /* If we don't find such an overlay,
3601 or the found one ends before PREV,
3602 or the found one is the last one in the list,
3603 we don't have to fix anything. */
3604 if (!tail
|| end
< prev
|| !tail
->next
)
3607 right_pair
= parent
;
3611 /* Now, end position of overlays in the list TAIL should be before
3612 or equal to PREV. In the loop, an overlay which ends at POS is
3613 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3614 we found an overlay which ends before PREV, the remaining
3615 overlays are in correct order. */
3618 XSETMISC (tem
, tail
);
3619 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3622 { /* This overlay is disordered. */
3623 struct Lisp_Overlay
*found
= tail
;
3625 /* Unlink the found overlay. */
3627 parent
->next
= tail
;
3628 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3629 and link it into the right place. */
3632 found
->next
= bp
->overlays_before
;
3633 bp
->overlays_before
= found
;
3637 found
->next
= right_pair
->next
;
3638 right_pair
->next
= found
;
3641 else if (end
== prev
)
3646 else /* No more disordered overlay. */
3651 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3652 doc
: /* Return t if OBJECT is an overlay. */)
3656 return (OVERLAYP (object
) ? Qt
: Qnil
);
3659 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3660 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3661 If omitted, BUFFER defaults to the current buffer.
3662 BEG and END may be integers or markers.
3663 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3664 for the front of the overlay advance when text is inserted there
3665 \(which means the text *is not* included in the overlay).
3666 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3667 for the rear of the overlay advance when text is inserted there
3668 \(which means the text *is* included in the overlay). */)
3669 (beg
, end
, buffer
, front_advance
, rear_advance
)
3670 Lisp_Object beg
, end
, buffer
;
3671 Lisp_Object front_advance
, rear_advance
;
3673 Lisp_Object overlay
;
3677 XSETBUFFER (buffer
, current_buffer
);
3679 CHECK_BUFFER (buffer
);
3681 && ! EQ (Fmarker_buffer (beg
), buffer
))
3682 error ("Marker points into wrong buffer");
3684 && ! EQ (Fmarker_buffer (end
), buffer
))
3685 error ("Marker points into wrong buffer");
3687 CHECK_NUMBER_COERCE_MARKER (beg
);
3688 CHECK_NUMBER_COERCE_MARKER (end
);
3690 if (XINT (beg
) > XINT (end
))
3693 temp
= beg
; beg
= end
; end
= temp
;
3696 b
= XBUFFER (buffer
);
3698 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3699 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3701 if (!NILP (front_advance
))
3702 XMARKER (beg
)->insertion_type
= 1;
3703 if (!NILP (rear_advance
))
3704 XMARKER (end
)->insertion_type
= 1;
3706 overlay
= allocate_misc ();
3707 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3708 XOVERLAY (overlay
)->start
= beg
;
3709 XOVERLAY (overlay
)->end
= end
;
3710 XOVERLAY (overlay
)->plist
= Qnil
;
3711 XOVERLAY (overlay
)->next
= NULL
;
3713 /* Put the new overlay on the wrong list. */
3714 end
= OVERLAY_END (overlay
);
3715 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3717 if (b
->overlays_after
)
3718 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3719 b
->overlays_after
= XOVERLAY (overlay
);
3723 if (b
->overlays_before
)
3724 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3725 b
->overlays_before
= XOVERLAY (overlay
);
3728 /* This puts it in the right list, and in the right order. */
3729 recenter_overlay_lists (b
, b
->overlay_center
);
3731 /* We don't need to redisplay the region covered by the overlay, because
3732 the overlay has no properties at the moment. */
3737 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3740 modify_overlay (buf
, start
, end
)
3742 EMACS_INT start
, end
;
3751 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3753 /* If this is a buffer not in the selected window,
3754 we must do other windows. */
3755 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3756 windows_or_buffers_changed
= 1;
3757 /* If multiple windows show this buffer, we must do other windows. */
3758 else if (buffer_shared
> 1)
3759 windows_or_buffers_changed
= 1;
3760 /* If we modify an overlay at the end of the buffer, we cannot
3761 be sure that window end is still valid. */
3762 else if (end
>= ZV
&& start
<= ZV
)
3763 windows_or_buffers_changed
= 1;
3765 ++BUF_OVERLAY_MODIFF (buf
);
3769 Lisp_Object
Fdelete_overlay ();
3771 static struct Lisp_Overlay
*
3772 unchain_overlay (list
, overlay
)
3773 struct Lisp_Overlay
*list
, *overlay
;
3775 struct Lisp_Overlay
*tmp
, *prev
;
3776 for (tmp
= list
, prev
= NULL
; tmp
; prev
= tmp
, tmp
= tmp
->next
)
3780 prev
->next
= tmp
->next
;
3783 overlay
->next
= NULL
;
3789 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3790 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3791 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3792 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3794 (overlay
, beg
, end
, buffer
)
3795 Lisp_Object overlay
, beg
, end
, buffer
;
3797 struct buffer
*b
, *ob
;
3798 Lisp_Object obuffer
;
3799 int count
= SPECPDL_INDEX ();
3801 CHECK_OVERLAY (overlay
);
3803 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3805 XSETBUFFER (buffer
, current_buffer
);
3806 CHECK_BUFFER (buffer
);
3809 && ! EQ (Fmarker_buffer (beg
), buffer
))
3810 error ("Marker points into wrong buffer");
3812 && ! EQ (Fmarker_buffer (end
), buffer
))
3813 error ("Marker points into wrong buffer");
3815 CHECK_NUMBER_COERCE_MARKER (beg
);
3816 CHECK_NUMBER_COERCE_MARKER (end
);
3818 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3819 return Fdelete_overlay (overlay
);
3821 if (XINT (beg
) > XINT (end
))
3824 temp
= beg
; beg
= end
; end
= temp
;
3827 specbind (Qinhibit_quit
, Qt
);
3829 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3830 b
= XBUFFER (buffer
);
3831 ob
= BUFFERP (obuffer
) ? XBUFFER (obuffer
) : (struct buffer
*) 0;
3833 /* If the overlay has changed buffers, do a thorough redisplay. */
3834 if (!EQ (buffer
, obuffer
))
3836 /* Redisplay where the overlay was. */
3837 if (!NILP (obuffer
))
3842 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3843 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3845 modify_overlay (ob
, o_beg
, o_end
);
3848 /* Redisplay where the overlay is going to be. */
3849 modify_overlay (b
, XINT (beg
), XINT (end
));
3852 /* Redisplay the area the overlay has just left, or just enclosed. */
3856 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3857 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3859 if (o_beg
== XINT (beg
))
3860 modify_overlay (b
, o_end
, XINT (end
));
3861 else if (o_end
== XINT (end
))
3862 modify_overlay (b
, o_beg
, XINT (beg
));
3865 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
3866 if (XINT (end
) > o_end
) o_end
= XINT (end
);
3867 modify_overlay (b
, o_beg
, o_end
);
3871 if (!NILP (obuffer
))
3874 = unchain_overlay (ob
->overlays_before
, XOVERLAY (overlay
));
3876 = unchain_overlay (ob
->overlays_after
, XOVERLAY (overlay
));
3877 eassert (XOVERLAY (overlay
)->next
== NULL
);
3880 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3881 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3883 /* Put the overlay on the wrong list. */
3884 end
= OVERLAY_END (overlay
);
3885 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3887 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3888 b
->overlays_after
= XOVERLAY (overlay
);
3892 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3893 b
->overlays_before
= XOVERLAY (overlay
);
3896 /* This puts it in the right list, and in the right order. */
3897 recenter_overlay_lists (b
, b
->overlay_center
);
3899 return unbind_to (count
, overlay
);
3902 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
3903 doc
: /* Delete the overlay OVERLAY from its buffer. */)
3905 Lisp_Object overlay
;
3909 int count
= SPECPDL_INDEX ();
3911 CHECK_OVERLAY (overlay
);
3913 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3917 b
= XBUFFER (buffer
);
3918 specbind (Qinhibit_quit
, Qt
);
3920 b
->overlays_before
= unchain_overlay (b
->overlays_before
,XOVERLAY (overlay
));
3921 b
->overlays_after
= unchain_overlay (b
->overlays_after
, XOVERLAY (overlay
));
3922 eassert (XOVERLAY (overlay
)->next
== NULL
);
3924 marker_position (OVERLAY_START (overlay
)),
3925 marker_position (OVERLAY_END (overlay
)));
3926 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
3927 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
3929 /* When deleting an overlay with before or after strings, turn off
3930 display optimizations for the affected buffer, on the basis that
3931 these strings may contain newlines. This is easier to do than to
3932 check for that situation during redisplay. */
3933 if (!windows_or_buffers_changed
3934 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
3935 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
3936 b
->prevent_redisplay_optimizations_p
= 1;
3938 return unbind_to (count
, Qnil
);
3941 /* Overlay dissection functions. */
3943 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
3944 doc
: /* Return the position at which OVERLAY starts. */)
3946 Lisp_Object overlay
;
3948 CHECK_OVERLAY (overlay
);
3950 return (Fmarker_position (OVERLAY_START (overlay
)));
3953 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
3954 doc
: /* Return the position at which OVERLAY ends. */)
3956 Lisp_Object overlay
;
3958 CHECK_OVERLAY (overlay
);
3960 return (Fmarker_position (OVERLAY_END (overlay
)));
3963 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
3964 doc
: /* Return the buffer OVERLAY belongs to.
3965 Return nil if OVERLAY has been deleted. */)
3967 Lisp_Object overlay
;
3969 CHECK_OVERLAY (overlay
);
3971 return Fmarker_buffer (OVERLAY_START (overlay
));
3974 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
3975 doc
: /* Return a list of the properties on OVERLAY.
3976 This is a copy of OVERLAY's plist; modifying its conses has no effect on
3979 Lisp_Object overlay
;
3981 CHECK_OVERLAY (overlay
);
3983 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
3987 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
3988 doc
: /* Return a list of the overlays that contain the character at POS. */)
3993 Lisp_Object
*overlay_vec
;
3997 CHECK_NUMBER_COERCE_MARKER (pos
);
4000 /* We can't use alloca here because overlays_at can call xrealloc. */
4001 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4003 /* Put all the overlays we want in a vector in overlay_vec.
4004 Store the length in len. */
4005 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4006 (int *) 0, (int *) 0, 0);
4008 /* Make a list of them all. */
4009 result
= Flist (noverlays
, overlay_vec
);
4011 xfree (overlay_vec
);
4015 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
4016 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
4017 Overlap means that at least one character is contained within the overlay
4018 and also contained within the specified region.
4019 Empty overlays are included in the result if they are located at BEG
4020 or between BEG and END. */)
4022 Lisp_Object beg
, end
;
4025 Lisp_Object
*overlay_vec
;
4029 CHECK_NUMBER_COERCE_MARKER (beg
);
4030 CHECK_NUMBER_COERCE_MARKER (end
);
4033 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4035 /* Put all the overlays we want in a vector in overlay_vec.
4036 Store the length in len. */
4037 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
4038 (int *) 0, (int *) 0);
4040 /* Make a list of them all. */
4041 result
= Flist (noverlays
, overlay_vec
);
4043 xfree (overlay_vec
);
4047 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
4049 doc
: /* Return the next position after POS where an overlay starts or ends.
4050 If there are no overlay boundaries from POS to (point-max),
4051 the value is (point-max). */)
4057 Lisp_Object
*overlay_vec
;
4061 CHECK_NUMBER_COERCE_MARKER (pos
);
4064 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4066 /* Put all the overlays we want in a vector in overlay_vec.
4067 Store the length in len.
4068 endpos gets the position where the next overlay starts. */
4069 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4070 &endpos
, (int *) 0, 1);
4072 /* If any of these overlays ends before endpos,
4073 use its ending point instead. */
4074 for (i
= 0; i
< noverlays
; i
++)
4079 oend
= OVERLAY_END (overlay_vec
[i
]);
4080 oendpos
= OVERLAY_POSITION (oend
);
4081 if (oendpos
< endpos
)
4085 xfree (overlay_vec
);
4086 return make_number (endpos
);
4089 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4090 Sprevious_overlay_change
, 1, 1, 0,
4091 doc
: /* Return the previous position before POS where an overlay starts or ends.
4092 If there are no overlay boundaries from (point-min) to POS,
4093 the value is (point-min). */)
4099 Lisp_Object
*overlay_vec
;
4102 CHECK_NUMBER_COERCE_MARKER (pos
);
4104 /* At beginning of buffer, we know the answer;
4105 avoid bug subtracting 1 below. */
4106 if (XINT (pos
) == BEGV
)
4110 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4112 /* Put all the overlays we want in a vector in overlay_vec.
4113 Store the length in len.
4114 prevpos gets the position of the previous change. */
4115 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4116 (int *) 0, &prevpos
, 1);
4118 xfree (overlay_vec
);
4119 return make_number (prevpos
);
4122 /* These functions are for debugging overlays. */
4124 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4125 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4126 The car has all the overlays before the overlay center;
4127 the cdr has all the overlays after the overlay center.
4128 Recentering overlays moves overlays between these lists.
4129 The lists you get are copies, so that changing them has no effect.
4130 However, the overlays you get are the real objects that the buffer uses. */)
4133 struct Lisp_Overlay
*ol
;
4134 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4135 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4138 before
= Fcons (tmp
, before
);
4140 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4143 after
= Fcons (tmp
, after
);
4145 return Fcons (Fnreverse (before
), Fnreverse (after
));
4148 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4149 doc
: /* Recenter the overlays of the current buffer around position POS.
4150 That makes overlay lookup faster for positions near POS (but perhaps slower
4151 for positions far away from POS). */)
4155 CHECK_NUMBER_COERCE_MARKER (pos
);
4157 recenter_overlay_lists (current_buffer
, XINT (pos
));
4161 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4162 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4164 Lisp_Object overlay
, prop
;
4166 CHECK_OVERLAY (overlay
);
4167 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4170 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4171 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE. */)
4172 (overlay
, prop
, value
)
4173 Lisp_Object overlay
, prop
, value
;
4175 Lisp_Object tail
, buffer
;
4178 CHECK_OVERLAY (overlay
);
4180 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4182 for (tail
= XOVERLAY (overlay
)->plist
;
4183 CONSP (tail
) && CONSP (XCDR (tail
));
4184 tail
= XCDR (XCDR (tail
)))
4185 if (EQ (XCAR (tail
), prop
))
4187 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4188 XSETCAR (XCDR (tail
), value
);
4191 /* It wasn't in the list, so add it to the front. */
4192 changed
= !NILP (value
);
4193 XOVERLAY (overlay
)->plist
4194 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
4196 if (! NILP (buffer
))
4199 modify_overlay (XBUFFER (buffer
),
4200 marker_position (OVERLAY_START (overlay
)),
4201 marker_position (OVERLAY_END (overlay
)));
4202 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4203 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4204 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4205 Fdelete_overlay (overlay
);
4211 /* Subroutine of report_overlay_modification. */
4213 /* Lisp vector holding overlay hook functions to call.
4214 Vector elements come in pairs.
4215 Each even-index element is a list of hook functions.
4216 The following odd-index element is the overlay they came from.
4218 Before the buffer change, we fill in this vector
4219 as we call overlay hook functions.
4220 After the buffer change, we get the functions to call from this vector.
4221 This way we always call the same functions before and after the change. */
4222 static Lisp_Object last_overlay_modification_hooks
;
4224 /* Number of elements actually used in last_overlay_modification_hooks. */
4225 static int last_overlay_modification_hooks_used
;
4227 /* Add one functionlist/overlay pair
4228 to the end of last_overlay_modification_hooks. */
4231 add_overlay_mod_hooklist (functionlist
, overlay
)
4232 Lisp_Object functionlist
, overlay
;
4234 int oldsize
= XVECTOR (last_overlay_modification_hooks
)->size
;
4236 if (last_overlay_modification_hooks_used
== oldsize
)
4237 last_overlay_modification_hooks
= larger_vector
4238 (last_overlay_modification_hooks
, oldsize
* 2, Qnil
);
4239 AREF (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
++) = functionlist
;
4240 AREF (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
++) = overlay
;
4243 /* Run the modification-hooks of overlays that include
4244 any part of the text in START to END.
4245 If this change is an insertion, also
4246 run the insert-before-hooks of overlay starting at END,
4247 and the insert-after-hooks of overlay ending at START.
4249 This is called both before and after the modification.
4250 AFTER is nonzero when we call after the modification.
4252 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4253 When AFTER is nonzero, they are the start position,
4254 the position after the inserted new text,
4255 and the length of deleted or replaced old text. */
4258 report_overlay_modification (start
, end
, after
, arg1
, arg2
, arg3
)
4259 Lisp_Object start
, end
;
4261 Lisp_Object arg1
, arg2
, arg3
;
4263 Lisp_Object prop
, overlay
;
4264 struct Lisp_Overlay
*tail
;
4265 /* 1 if this change is an insertion. */
4266 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4267 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4272 /* We used to run the functions as soon as we found them and only register
4273 them in last_overlay_modification_hooks for the purpose of the `after'
4274 case. But running elisp code as we traverse the list of overlays is
4275 painful because the list can be modified by the elisp code so we had to
4276 copy at several places. We now simply do a read-only traversal that
4277 only collects the functions to run and we run them afterwards. It's
4278 simpler, especially since all the code was already there. -stef */
4282 /* We are being called before a change.
4283 Scan the overlays to find the functions to call. */
4284 last_overlay_modification_hooks_used
= 0;
4285 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4287 int startpos
, endpos
;
4288 Lisp_Object ostart
, oend
;
4290 XSETMISC (overlay
, tail
);
4292 ostart
= OVERLAY_START (overlay
);
4293 oend
= OVERLAY_END (overlay
);
4294 endpos
= OVERLAY_POSITION (oend
);
4295 if (XFASTINT (start
) > endpos
)
4297 startpos
= OVERLAY_POSITION (ostart
);
4298 if (insertion
&& (XFASTINT (start
) == startpos
4299 || XFASTINT (end
) == startpos
))
4301 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4303 add_overlay_mod_hooklist (prop
, overlay
);
4305 if (insertion
&& (XFASTINT (start
) == endpos
4306 || XFASTINT (end
) == endpos
))
4308 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4310 add_overlay_mod_hooklist (prop
, overlay
);
4312 /* Test for intersecting intervals. This does the right thing
4313 for both insertion and deletion. */
4314 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4316 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4318 add_overlay_mod_hooklist (prop
, overlay
);
4322 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4324 int startpos
, endpos
;
4325 Lisp_Object ostart
, oend
;
4327 XSETMISC (overlay
, tail
);
4329 ostart
= OVERLAY_START (overlay
);
4330 oend
= OVERLAY_END (overlay
);
4331 startpos
= OVERLAY_POSITION (ostart
);
4332 endpos
= OVERLAY_POSITION (oend
);
4333 if (XFASTINT (end
) < startpos
)
4335 if (insertion
&& (XFASTINT (start
) == startpos
4336 || XFASTINT (end
) == startpos
))
4338 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4340 add_overlay_mod_hooklist (prop
, overlay
);
4342 if (insertion
&& (XFASTINT (start
) == endpos
4343 || XFASTINT (end
) == endpos
))
4345 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4347 add_overlay_mod_hooklist (prop
, overlay
);
4349 /* Test for intersecting intervals. This does the right thing
4350 for both insertion and deletion. */
4351 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4353 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4355 add_overlay_mod_hooklist (prop
, overlay
);
4360 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4362 /* Call the functions recorded in last_overlay_modification_hooks.
4363 First copy the vector contents, in case some of these hooks
4364 do subsequent modification of the buffer. */
4365 int size
= last_overlay_modification_hooks_used
;
4366 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
4369 bcopy (XVECTOR (last_overlay_modification_hooks
)->contents
,
4370 copy
, size
* sizeof (Lisp_Object
));
4372 gcpro1
.nvars
= size
;
4374 for (i
= 0; i
< size
;)
4376 Lisp_Object prop
, overlay
;
4378 overlay
= copy
[i
++];
4379 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4386 call_overlay_mod_hooks (list
, overlay
, after
, arg1
, arg2
, arg3
)
4387 Lisp_Object list
, overlay
;
4389 Lisp_Object arg1
, arg2
, arg3
;
4391 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4393 GCPRO4 (list
, arg1
, arg2
, arg3
);
4395 while (CONSP (list
))
4398 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4400 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4406 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4409 evaporate_overlays (pos
)
4412 Lisp_Object overlay
, hit_list
;
4413 struct Lisp_Overlay
*tail
;
4416 if (pos
<= current_buffer
->overlay_center
)
4417 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4420 XSETMISC (overlay
, tail
);
4421 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4424 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4425 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4426 hit_list
= Fcons (overlay
, hit_list
);
4429 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4432 XSETMISC (overlay
, tail
);
4433 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4436 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4437 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4438 hit_list
= Fcons (overlay
, hit_list
);
4440 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4441 Fdelete_overlay (XCAR (hit_list
));
4444 /* Somebody has tried to store a value with an unacceptable type
4445 in the slot with offset OFFSET. */
4448 buffer_slot_type_mismatch (offset
)
4454 switch (XINT (PER_BUFFER_TYPE (offset
)))
4457 type_name
= "integers";
4461 type_name
= "strings";
4465 type_name
= "symbols";
4472 sym
= PER_BUFFER_SYMBOL (offset
);
4473 error ("Only %s should be stored in the buffer-local variable %s",
4474 type_name
, SDATA (SYMBOL_NAME (sym
)));
4478 /***********************************************************************
4479 Allocation with mmap
4480 ***********************************************************************/
4482 #ifdef USE_MMAP_FOR_BUFFERS
4484 #include <sys/types.h>
4485 #include <sys/mman.h>
4488 #ifdef MAP_ANONYMOUS
4489 #define MAP_ANON MAP_ANONYMOUS
4496 #define MAP_FAILED ((void *) -1)
4509 /* Memory is allocated in regions which are mapped using mmap(2).
4510 The current implementation lets the system select mapped
4511 addresses; we're not using MAP_FIXED in general, except when
4512 trying to enlarge regions.
4514 Each mapped region starts with a mmap_region structure, the user
4515 area starts after that structure, aligned to MEM_ALIGN.
4517 +-----------------------+
4518 | struct mmap_info + |
4520 +-----------------------+
4524 +-----------------------+ */
4528 /* User-specified size. */
4529 size_t nbytes_specified
;
4531 /* Number of bytes mapped */
4532 size_t nbytes_mapped
;
4534 /* Pointer to the location holding the address of the memory
4535 allocated with the mmap'd block. The variable actually points
4536 after this structure. */
4539 /* Next and previous in list of all mmap'd regions. */
4540 struct mmap_region
*next
, *prev
;
4543 /* Doubly-linked list of mmap'd regions. */
4545 static struct mmap_region
*mmap_regions
;
4547 /* File descriptor for mmap. If we don't have anonymous mapping,
4548 /dev/zero will be opened on it. */
4552 /* Temporary storage for mmap_set_vars, see there. */
4554 static struct mmap_region
*mmap_regions_1
;
4555 static int mmap_fd_1
;
4557 /* Page size on this system. */
4559 static int mmap_page_size
;
4561 /* 1 means mmap has been intialized. */
4563 static int mmap_initialized_p
;
4565 /* Value is X rounded up to the next multiple of N. */
4567 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4569 /* Size of mmap_region structure plus padding. */
4571 #define MMAP_REGION_STRUCT_SIZE \
4572 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4574 /* Given a pointer P to the start of the user-visible part of a mapped
4575 region, return a pointer to the start of the region. */
4577 #define MMAP_REGION(P) \
4578 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4580 /* Given a pointer P to the start of a mapped region, return a pointer
4581 to the start of the user-visible part of the region. */
4583 #define MMAP_USER_AREA(P) \
4584 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4586 #define MEM_ALIGN sizeof (double)
4588 /* Predicate returning true if part of the address range [START .. END]
4589 is currently mapped. Used to prevent overwriting an existing
4592 Default is to conservativly assume the address range is occupied by
4593 something else. This can be overridden by system configuration
4594 files if system-specific means to determine this exists. */
4596 #ifndef MMAP_ALLOCATED_P
4597 #define MMAP_ALLOCATED_P(start, end) 1
4600 /* Function prototypes. */
4602 static int mmap_free_1
P_ ((struct mmap_region
*));
4603 static int mmap_enlarge
P_ ((struct mmap_region
*, int));
4604 static struct mmap_region
*mmap_find
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
4605 static POINTER_TYPE
*mmap_alloc
P_ ((POINTER_TYPE
**, size_t));
4606 static POINTER_TYPE
*mmap_realloc
P_ ((POINTER_TYPE
**, size_t));
4607 static void mmap_free
P_ ((POINTER_TYPE
**ptr
));
4608 static void mmap_init
P_ ((void));
4611 /* Return a region overlapping address range START...END, or null if
4612 none. END is not including, i.e. the last byte in the range
4615 static struct mmap_region
*
4616 mmap_find (start
, end
)
4617 POINTER_TYPE
*start
, *end
;
4619 struct mmap_region
*r
;
4620 char *s
= (char *) start
, *e
= (char *) end
;
4622 for (r
= mmap_regions
; r
; r
= r
->next
)
4624 char *rstart
= (char *) r
;
4625 char *rend
= rstart
+ r
->nbytes_mapped
;
4627 if (/* First byte of range, i.e. START, in this region? */
4628 (s
>= rstart
&& s
< rend
)
4629 /* Last byte of range, i.e. END - 1, in this region? */
4630 || (e
> rstart
&& e
<= rend
)
4631 /* First byte of this region in the range? */
4632 || (rstart
>= s
&& rstart
< e
)
4633 /* Last byte of this region in the range? */
4634 || (rend
> s
&& rend
<= e
))
4642 /* Unmap a region. P is a pointer to the start of the user-araa of
4643 the region. Value is non-zero if successful. */
4647 struct mmap_region
*r
;
4650 r
->next
->prev
= r
->prev
;
4652 r
->prev
->next
= r
->next
;
4654 mmap_regions
= r
->next
;
4656 if (munmap ((POINTER_TYPE
*) r
, r
->nbytes_mapped
) == -1)
4658 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4666 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4667 Value is non-zero if successful. */
4670 mmap_enlarge (r
, npages
)
4671 struct mmap_region
*r
;
4674 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4680 /* Unmap pages at the end of the region. */
4681 nbytes
= - npages
* mmap_page_size
;
4682 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4683 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4686 r
->nbytes_mapped
-= nbytes
;
4690 else if (npages
> 0)
4692 nbytes
= npages
* mmap_page_size
;
4694 /* Try to map additional pages at the end of the region. We
4695 cannot do this if the address range is already occupied by
4696 something else because mmap deletes any previous mapping.
4697 I'm not sure this is worth doing, let's see. */
4698 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4702 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4703 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4704 if (p
== MAP_FAILED
)
4705 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4706 else if (p
!= (POINTER_TYPE
*) region_end
)
4708 /* Kernels are free to choose a different address. In
4709 that case, unmap what we've mapped above; we have
4711 if (munmap (p
, nbytes
) == -1)
4712 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4716 r
->nbytes_mapped
+= nbytes
;
4726 /* Set or reset variables holding references to mapped regions. If
4727 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4728 non-zero, set all variables to the start of the user-areas
4731 This function is called from Fdump_emacs to ensure that the dumped
4732 Emacs doesn't contain references to memory that won't be mapped
4733 when Emacs starts. */
4736 mmap_set_vars (restore_p
)
4739 struct mmap_region
*r
;
4743 mmap_regions
= mmap_regions_1
;
4744 mmap_fd
= mmap_fd_1
;
4745 for (r
= mmap_regions
; r
; r
= r
->next
)
4746 *r
->var
= MMAP_USER_AREA (r
);
4750 for (r
= mmap_regions
; r
; r
= r
->next
)
4752 mmap_regions_1
= mmap_regions
;
4753 mmap_regions
= NULL
;
4754 mmap_fd_1
= mmap_fd
;
4760 /* Allocate a block of storage large enough to hold NBYTES bytes of
4761 data. A pointer to the data is returned in *VAR. VAR is thus the
4762 address of some variable which will use the data area.
4764 The allocation of 0 bytes is valid.
4766 If we can't allocate the necessary memory, set *VAR to null, and
4769 static POINTER_TYPE
*
4770 mmap_alloc (var
, nbytes
)
4779 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4780 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4783 if (p
== MAP_FAILED
)
4785 if (errno
!= ENOMEM
)
4786 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4791 struct mmap_region
*r
= (struct mmap_region
*) p
;
4793 r
->nbytes_specified
= nbytes
;
4794 r
->nbytes_mapped
= map
;
4797 r
->next
= mmap_regions
;
4802 p
= MMAP_USER_AREA (p
);
4809 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4810 resize it to size NBYTES. Change *VAR to reflect the new block,
4811 and return this value. If more memory cannot be allocated, then
4812 leave *VAR unchanged, and return null. */
4814 static POINTER_TYPE
*
4815 mmap_realloc (var
, nbytes
)
4819 POINTER_TYPE
*result
;
4824 result
= mmap_alloc (var
, nbytes
);
4825 else if (nbytes
== 0)
4828 result
= mmap_alloc (var
, nbytes
);
4832 struct mmap_region
*r
= MMAP_REGION (*var
);
4833 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4838 POINTER_TYPE
*old_ptr
= *var
;
4840 /* Try to map additional pages at the end of the region.
4841 If that fails, allocate a new region, copy data
4842 from the old region, then free it. */
4843 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4846 r
->nbytes_specified
= nbytes
;
4847 *var
= result
= old_ptr
;
4849 else if (mmap_alloc (var
, nbytes
))
4851 bcopy (old_ptr
, *var
, r
->nbytes_specified
);
4852 mmap_free_1 (MMAP_REGION (old_ptr
));
4854 r
= MMAP_REGION (result
);
4855 r
->nbytes_specified
= nbytes
;
4863 else if (room
- nbytes
>= mmap_page_size
)
4865 /* Shrinking by at least a page. Let's give some
4866 memory back to the system.
4868 The extra parens are to make the division happens first,
4869 on positive values, so we know it will round towards
4871 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4873 r
->nbytes_specified
= nbytes
;
4877 /* Leave it alone. */
4879 r
->nbytes_specified
= nbytes
;
4887 /* Free a block of relocatable storage whose data is pointed to by
4888 PTR. Store 0 in *PTR to show there's no block allocated. */
4898 mmap_free_1 (MMAP_REGION (*var
));
4904 /* Perform necessary intializations for the use of mmap. */
4910 /* The value of mmap_fd is initially 0 in temacs, and -1
4911 in a dumped Emacs. */
4914 /* No anonymous mmap -- we need the file descriptor. */
4915 mmap_fd
= open ("/dev/zero", O_RDONLY
);
4917 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4919 #endif /* MAP_ANON == 0 */
4921 if (mmap_initialized_p
)
4923 mmap_initialized_p
= 1;
4929 mmap_page_size
= getpagesize ();
4932 #endif /* USE_MMAP_FOR_BUFFERS */
4936 /***********************************************************************
4937 Buffer-text Allocation
4938 ***********************************************************************/
4941 extern POINTER_TYPE
*r_alloc
P_ ((POINTER_TYPE
**, size_t));
4942 extern POINTER_TYPE
*r_re_alloc
P_ ((POINTER_TYPE
**, size_t));
4943 extern void r_alloc_free
P_ ((POINTER_TYPE
**ptr
));
4944 #endif /* REL_ALLOC */
4947 /* Allocate NBYTES bytes for buffer B's text buffer. */
4950 alloc_buffer_text (b
, nbytes
)
4957 #if defined USE_MMAP_FOR_BUFFERS
4958 p
= mmap_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4959 #elif defined REL_ALLOC
4960 p
= r_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4962 p
= xmalloc (nbytes
);
4971 b
->text
->beg
= (unsigned char *) p
;
4975 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4979 enlarge_buffer_text (b
, delta
)
4984 size_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4987 #if defined USE_MMAP_FOR_BUFFERS
4988 p
= mmap_realloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4989 #elif defined REL_ALLOC
4990 p
= r_re_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4992 p
= xrealloc (b
->text
->beg
, nbytes
);
5001 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
5006 /* Free buffer B's text buffer. */
5009 free_buffer_text (b
)
5014 #if defined USE_MMAP_FOR_BUFFERS
5015 mmap_free ((POINTER_TYPE
**) &b
->text
->beg
);
5016 #elif defined REL_ALLOC
5017 r_alloc_free ((POINTER_TYPE
**) &b
->text
->beg
);
5019 xfree (b
->text
->beg
);
5022 BUF_BEG_ADDR (b
) = NULL
;
5028 /***********************************************************************
5030 ***********************************************************************/
5037 bzero (buffer_permanent_local_flags
, sizeof buffer_permanent_local_flags
);
5039 /* Make sure all markable slots in buffer_defaults
5040 are initialized reasonably, so mark_buffer won't choke. */
5041 reset_buffer (&buffer_defaults
);
5042 reset_buffer_local_variables (&buffer_defaults
, 1);
5043 reset_buffer (&buffer_local_symbols
);
5044 reset_buffer_local_variables (&buffer_local_symbols
, 1);
5045 /* Prevent GC from getting confused. */
5046 buffer_defaults
.text
= &buffer_defaults
.own_text
;
5047 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5048 BUF_INTERVALS (&buffer_defaults
) = 0;
5049 BUF_INTERVALS (&buffer_local_symbols
) = 0;
5050 XSETPVECTYPE (&buffer_defaults
, PVEC_BUFFER
);
5051 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
5052 XSETPVECTYPE (&buffer_local_symbols
, PVEC_BUFFER
);
5053 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
5055 /* Set up the default values of various buffer slots. */
5056 /* Must do these before making the first buffer! */
5058 /* real setup is done in bindings.el */
5059 buffer_defaults
.mode_line_format
= build_string ("%-");
5060 buffer_defaults
.header_line_format
= Qnil
;
5061 buffer_defaults
.abbrev_mode
= Qnil
;
5062 buffer_defaults
.overwrite_mode
= Qnil
;
5063 buffer_defaults
.case_fold_search
= Qt
;
5064 buffer_defaults
.auto_fill_function
= Qnil
;
5065 buffer_defaults
.selective_display
= Qnil
;
5067 buffer_defaults
.selective_display_ellipses
= Qt
;
5069 buffer_defaults
.abbrev_table
= Qnil
;
5070 buffer_defaults
.display_table
= Qnil
;
5071 buffer_defaults
.undo_list
= Qnil
;
5072 buffer_defaults
.mark_active
= Qnil
;
5073 buffer_defaults
.file_format
= Qnil
;
5074 buffer_defaults
.auto_save_file_format
= Qt
;
5075 buffer_defaults
.overlays_before
= NULL
;
5076 buffer_defaults
.overlays_after
= NULL
;
5077 buffer_defaults
.overlay_center
= BEG
;
5079 XSETFASTINT (buffer_defaults
.tab_width
, 8);
5080 buffer_defaults
.truncate_lines
= Qnil
;
5081 buffer_defaults
.ctl_arrow
= Qt
;
5082 buffer_defaults
.direction_reversed
= Qnil
;
5083 buffer_defaults
.cursor_type
= Qt
;
5084 buffer_defaults
.extra_line_spacing
= Qnil
;
5085 buffer_defaults
.cursor_in_non_selected_windows
= Qt
;
5088 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
5090 buffer_defaults
.enable_multibyte_characters
= Qt
;
5091 buffer_defaults
.buffer_file_coding_system
= Qnil
;
5092 XSETFASTINT (buffer_defaults
.fill_column
, 70);
5093 XSETFASTINT (buffer_defaults
.left_margin
, 0);
5094 buffer_defaults
.cache_long_line_scans
= Qnil
;
5095 buffer_defaults
.file_truename
= Qnil
;
5096 XSETFASTINT (buffer_defaults
.display_count
, 0);
5097 XSETFASTINT (buffer_defaults
.left_margin_cols
, 0);
5098 XSETFASTINT (buffer_defaults
.right_margin_cols
, 0);
5099 buffer_defaults
.left_fringe_width
= Qnil
;
5100 buffer_defaults
.right_fringe_width
= Qnil
;
5101 buffer_defaults
.fringes_outside_margins
= Qnil
;
5102 buffer_defaults
.scroll_bar_width
= Qnil
;
5103 buffer_defaults
.vertical_scroll_bar_type
= Qt
;
5104 buffer_defaults
.indicate_empty_lines
= Qnil
;
5105 buffer_defaults
.indicate_buffer_boundaries
= Qnil
;
5106 buffer_defaults
.fringe_indicator_alist
= Qnil
;
5107 buffer_defaults
.fringe_cursor_alist
= Qnil
;
5108 buffer_defaults
.scroll_up_aggressively
= Qnil
;
5109 buffer_defaults
.scroll_down_aggressively
= Qnil
;
5110 buffer_defaults
.display_time
= Qnil
;
5112 /* Assign the local-flags to the slots that have default values.
5113 The local flag is a bit that is used in the buffer
5114 to say that it has its own local value for the slot.
5115 The local flag bits are in the local_var_flags slot of the buffer. */
5117 /* Nothing can work if this isn't true */
5118 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
5120 /* 0 means not a lisp var, -1 means always local, else mask */
5121 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
5122 XSETINT (buffer_local_flags
.filename
, -1);
5123 XSETINT (buffer_local_flags
.directory
, -1);
5124 XSETINT (buffer_local_flags
.backed_up
, -1);
5125 XSETINT (buffer_local_flags
.save_length
, -1);
5126 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
5127 XSETINT (buffer_local_flags
.read_only
, -1);
5128 XSETINT (buffer_local_flags
.major_mode
, -1);
5129 XSETINT (buffer_local_flags
.mode_name
, -1);
5130 XSETINT (buffer_local_flags
.undo_list
, -1);
5131 XSETINT (buffer_local_flags
.mark_active
, -1);
5132 XSETINT (buffer_local_flags
.point_before_scroll
, -1);
5133 XSETINT (buffer_local_flags
.file_truename
, -1);
5134 XSETINT (buffer_local_flags
.invisibility_spec
, -1);
5135 XSETINT (buffer_local_flags
.file_format
, -1);
5136 XSETINT (buffer_local_flags
.auto_save_file_format
, -1);
5137 XSETINT (buffer_local_flags
.display_count
, -1);
5138 XSETINT (buffer_local_flags
.display_time
, -1);
5139 XSETINT (buffer_local_flags
.enable_multibyte_characters
, -1);
5142 XSETFASTINT (buffer_local_flags
.mode_line_format
, idx
); ++idx
;
5143 XSETFASTINT (buffer_local_flags
.abbrev_mode
, idx
); ++idx
;
5144 XSETFASTINT (buffer_local_flags
.overwrite_mode
, idx
); ++idx
;
5145 XSETFASTINT (buffer_local_flags
.case_fold_search
, idx
); ++idx
;
5146 XSETFASTINT (buffer_local_flags
.auto_fill_function
, idx
); ++idx
;
5147 XSETFASTINT (buffer_local_flags
.selective_display
, idx
); ++idx
;
5149 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, idx
); ++idx
;
5151 XSETFASTINT (buffer_local_flags
.tab_width
, idx
); ++idx
;
5152 XSETFASTINT (buffer_local_flags
.truncate_lines
, idx
); ++idx
;
5153 XSETFASTINT (buffer_local_flags
.ctl_arrow
, idx
); ++idx
;
5154 XSETFASTINT (buffer_local_flags
.fill_column
, idx
); ++idx
;
5155 XSETFASTINT (buffer_local_flags
.left_margin
, idx
); ++idx
;
5156 XSETFASTINT (buffer_local_flags
.abbrev_table
, idx
); ++idx
;
5157 XSETFASTINT (buffer_local_flags
.display_table
, idx
); ++idx
;
5159 XSETFASTINT (buffer_local_flags
.buffer_file_type
, idx
);
5160 /* Make this one a permanent local. */
5161 buffer_permanent_local_flags
[idx
++] = 1;
5163 XSETFASTINT (buffer_local_flags
.syntax_table
, idx
); ++idx
;
5164 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, idx
); ++idx
;
5165 XSETFASTINT (buffer_local_flags
.category_table
, idx
); ++idx
;
5166 XSETFASTINT (buffer_local_flags
.direction_reversed
, idx
); ++idx
;
5167 XSETFASTINT (buffer_local_flags
.buffer_file_coding_system
, idx
);
5168 /* Make this one a permanent local. */
5169 buffer_permanent_local_flags
[idx
++] = 1;
5170 XSETFASTINT (buffer_local_flags
.left_margin_cols
, idx
); ++idx
;
5171 XSETFASTINT (buffer_local_flags
.right_margin_cols
, idx
); ++idx
;
5172 XSETFASTINT (buffer_local_flags
.left_fringe_width
, idx
); ++idx
;
5173 XSETFASTINT (buffer_local_flags
.right_fringe_width
, idx
); ++idx
;
5174 XSETFASTINT (buffer_local_flags
.fringes_outside_margins
, idx
); ++idx
;
5175 XSETFASTINT (buffer_local_flags
.scroll_bar_width
, idx
); ++idx
;
5176 XSETFASTINT (buffer_local_flags
.vertical_scroll_bar_type
, idx
); ++idx
;
5177 XSETFASTINT (buffer_local_flags
.indicate_empty_lines
, idx
); ++idx
;
5178 XSETFASTINT (buffer_local_flags
.indicate_buffer_boundaries
, idx
); ++idx
;
5179 XSETFASTINT (buffer_local_flags
.fringe_indicator_alist
, idx
); ++idx
;
5180 XSETFASTINT (buffer_local_flags
.fringe_cursor_alist
, idx
); ++idx
;
5181 XSETFASTINT (buffer_local_flags
.scroll_up_aggressively
, idx
); ++idx
;
5182 XSETFASTINT (buffer_local_flags
.scroll_down_aggressively
, idx
); ++idx
;
5183 XSETFASTINT (buffer_local_flags
.header_line_format
, idx
); ++idx
;
5184 XSETFASTINT (buffer_local_flags
.cursor_type
, idx
); ++idx
;
5185 XSETFASTINT (buffer_local_flags
.extra_line_spacing
, idx
); ++idx
;
5186 XSETFASTINT (buffer_local_flags
.cursor_in_non_selected_windows
, idx
); ++idx
;
5188 /* Need more room? */
5189 if (idx
>= MAX_PER_BUFFER_VARS
)
5191 last_per_buffer_idx
= idx
;
5193 Vbuffer_alist
= Qnil
;
5197 QSFundamental
= build_string ("Fundamental");
5199 Qfundamental_mode
= intern ("fundamental-mode");
5200 buffer_defaults
.major_mode
= Qfundamental_mode
;
5202 Qmode_class
= intern ("mode-class");
5204 Qprotected_field
= intern ("protected-field");
5206 Qpermanent_local
= intern ("permanent-local");
5208 Qkill_buffer_hook
= intern ("kill-buffer-hook");
5209 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5211 Qucs_set_table_for_input
= intern ("ucs-set-table-for-input");
5213 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
5215 /* super-magic invisible buffer */
5216 Vbuffer_alist
= Qnil
;
5218 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5220 inhibit_modification_hooks
= 0;
5230 #ifdef USE_MMAP_FOR_BUFFERS
5232 /* When using the ralloc implementation based on mmap(2), buffer
5233 text pointers will have been set to null in the dumped Emacs.
5237 for (b
= all_buffers
; b
; b
= b
->next
)
5238 if (b
->text
->beg
== NULL
)
5239 enlarge_buffer_text (b
, 0);
5241 #endif /* USE_MMAP_FOR_BUFFERS */
5243 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5244 if (NILP (buffer_defaults
.enable_multibyte_characters
))
5245 Fset_buffer_multibyte (Qnil
);
5247 pwd
= get_current_dir_name ();
5250 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5253 /* Maybe this should really use some standard subroutine
5254 whose definition is filename syntax dependent. */
5256 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5258 /* Grow buffer to add directory separator and '\0'. */
5259 pwd
= (char *) xrealloc (pwd
, len
+ 2);
5260 pwd
[len
] = DIRECTORY_SEP
;
5261 pwd
[len
+ 1] = '\0';
5263 #endif /* not VMS */
5265 current_buffer
->directory
= make_unibyte_string (pwd
, strlen (pwd
));
5266 if (! NILP (buffer_defaults
.enable_multibyte_characters
))
5267 /* At this moment, we still don't know how to decode the
5268 directory name. So, we keep the bytes in multibyte form so
5269 that ENCODE_FILE correctly gets the original bytes. */
5270 current_buffer
->directory
5271 = string_to_multibyte (current_buffer
->directory
);
5273 /* Add /: to the front of the name
5274 if it would otherwise be treated as magic. */
5275 temp
= Ffind_file_name_handler (current_buffer
->directory
, Qt
);
5277 /* If the default dir is just /, TEMP is non-nil
5278 because of the ange-ftp completion handler.
5279 However, it is not necessary to turn / into /:/.
5280 So avoid doing that. */
5281 && strcmp ("/", SDATA (current_buffer
->directory
)))
5282 current_buffer
->directory
5283 = concat2 (build_string ("/:"), current_buffer
->directory
);
5285 temp
= get_minibuffer (0);
5286 XBUFFER (temp
)->directory
= current_buffer
->directory
;
5291 /* Similar to defvar_lisp but define a variable whose value is the Lisp
5292 Object stored in the current buffer. address is the address of the slot
5293 in the buffer that is current now. */
5295 /* TYPE is nil for a general Lisp variable.
5296 An integer specifies a type; then only LIsp values
5297 with that type code are allowed (except that nil is allowed too).
5298 LNAME is the LIsp-level variable name.
5299 VNAME is the name of the buffer slot.
5300 DOC is a dummy where you write the doc string as a comment. */
5301 #define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
5302 defvar_per_buffer (lname, vname, type, 0)
5305 defvar_per_buffer (namestring
, address
, type
, doc
)
5307 Lisp_Object
*address
;
5311 Lisp_Object sym
, val
;
5314 sym
= intern (namestring
);
5315 val
= allocate_misc ();
5316 offset
= (char *)address
- (char *)current_buffer
;
5318 XMISCTYPE (val
) = Lisp_Misc_Buffer_Objfwd
;
5319 XBUFFER_OBJFWD (val
)->offset
= offset
;
5320 SET_SYMBOL_VALUE (sym
, val
);
5321 PER_BUFFER_SYMBOL (offset
) = sym
;
5322 PER_BUFFER_TYPE (offset
) = type
;
5324 if (PER_BUFFER_IDX (offset
) == 0)
5325 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5326 slot of buffer_local_flags */
5331 /* initialize the buffer routines */
5335 staticpro (&last_overlay_modification_hooks
);
5336 last_overlay_modification_hooks
5337 = Fmake_vector (make_number (10), Qnil
);
5339 staticpro (&Vbuffer_defaults
);
5340 staticpro (&Vbuffer_local_symbols
);
5341 staticpro (&Qfundamental_mode
);
5342 staticpro (&Qmode_class
);
5343 staticpro (&QSFundamental
);
5344 staticpro (&Vbuffer_alist
);
5345 staticpro (&Qprotected_field
);
5346 staticpro (&Qpermanent_local
);
5347 staticpro (&Qkill_buffer_hook
);
5348 Qoverlayp
= intern ("overlayp");
5349 staticpro (&Qoverlayp
);
5350 Qevaporate
= intern ("evaporate");
5351 staticpro (&Qevaporate
);
5352 Qmodification_hooks
= intern ("modification-hooks");
5353 staticpro (&Qmodification_hooks
);
5354 Qinsert_in_front_hooks
= intern ("insert-in-front-hooks");
5355 staticpro (&Qinsert_in_front_hooks
);
5356 Qinsert_behind_hooks
= intern ("insert-behind-hooks");
5357 staticpro (&Qinsert_behind_hooks
);
5358 Qget_file_buffer
= intern ("get-file-buffer");
5359 staticpro (&Qget_file_buffer
);
5360 Qpriority
= intern ("priority");
5361 staticpro (&Qpriority
);
5362 Qwindow
= intern ("window");
5363 staticpro (&Qwindow
);
5364 Qbefore_string
= intern ("before-string");
5365 staticpro (&Qbefore_string
);
5366 Qafter_string
= intern ("after-string");
5367 staticpro (&Qafter_string
);
5368 Qfirst_change_hook
= intern ("first-change-hook");
5369 staticpro (&Qfirst_change_hook
);
5370 Qbefore_change_functions
= intern ("before-change-functions");
5371 staticpro (&Qbefore_change_functions
);
5372 Qafter_change_functions
= intern ("after-change-functions");
5373 staticpro (&Qafter_change_functions
);
5374 staticpro (&Qucs_set_table_for_input
);
5376 Qkill_buffer_query_functions
= intern ("kill-buffer-query-functions");
5377 staticpro (&Qkill_buffer_query_functions
);
5379 Fput (Qprotected_field
, Qerror_conditions
,
5380 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
5381 Fput (Qprotected_field
, Qerror_message
,
5382 build_string ("Attempt to modify a protected field"));
5384 /* All these use DEFVAR_LISP_NOPRO because the slots in
5385 buffer_defaults will all be marked via Vbuffer_defaults. */
5387 DEFVAR_LISP_NOPRO ("default-mode-line-format",
5388 &buffer_defaults
.mode_line_format
,
5389 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5390 This is the same as (default-value 'mode-line-format). */);
5392 DEFVAR_LISP_NOPRO ("default-header-line-format",
5393 &buffer_defaults
.header_line_format
,
5394 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5395 This is the same as (default-value 'header-line-format). */);
5397 DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults
.cursor_type
,
5398 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5399 This is the same as (default-value 'cursor-type). */);
5401 DEFVAR_LISP_NOPRO ("default-line-spacing",
5402 &buffer_defaults
.extra_line_spacing
,
5403 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5404 This is the same as (default-value 'line-spacing). */);
5406 DEFVAR_LISP_NOPRO ("default-cursor-in-non-selected-windows",
5407 &buffer_defaults
.cursor_in_non_selected_windows
,
5408 doc
: /* Default value of `cursor-in-non-selected-windows'.
5409 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5411 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
5412 &buffer_defaults
.abbrev_mode
,
5413 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5414 This is the same as (default-value 'abbrev-mode). */);
5416 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
5417 &buffer_defaults
.ctl_arrow
,
5418 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5419 This is the same as (default-value 'ctl-arrow). */);
5421 DEFVAR_LISP_NOPRO ("default-direction-reversed",
5422 &buffer_defaults
.direction_reversed
,
5423 doc
: /* Default value of `direction-reversed' for buffers that do not override it.
5424 This is the same as (default-value 'direction-reversed). */);
5426 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
5427 &buffer_defaults
.enable_multibyte_characters
,
5428 doc
: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
5429 This is the same as (default-value 'enable-multibyte-characters). */);
5431 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
5432 &buffer_defaults
.buffer_file_coding_system
,
5433 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5434 This is the same as (default-value 'buffer-file-coding-system). */);
5436 DEFVAR_LISP_NOPRO ("default-truncate-lines",
5437 &buffer_defaults
.truncate_lines
,
5438 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5439 This is the same as (default-value 'truncate-lines). */);
5441 DEFVAR_LISP_NOPRO ("default-fill-column",
5442 &buffer_defaults
.fill_column
,
5443 doc
: /* Default value of `fill-column' for buffers that do not override it.
5444 This is the same as (default-value 'fill-column). */);
5446 DEFVAR_LISP_NOPRO ("default-left-margin",
5447 &buffer_defaults
.left_margin
,
5448 doc
: /* Default value of `left-margin' for buffers that do not override it.
5449 This is the same as (default-value 'left-margin). */);
5451 DEFVAR_LISP_NOPRO ("default-tab-width",
5452 &buffer_defaults
.tab_width
,
5453 doc
: /* Default value of `tab-width' for buffers that do not override it.
5454 This is the same as (default-value 'tab-width). */);
5456 DEFVAR_LISP_NOPRO ("default-case-fold-search",
5457 &buffer_defaults
.case_fold_search
,
5458 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5459 This is the same as (default-value 'case-fold-search). */);
5462 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
5463 &buffer_defaults
.buffer_file_type
,
5464 doc
: /* Default file type for buffers that do not override it.
5465 This is the same as (default-value 'buffer-file-type).
5466 The file type is nil for text, t for binary. */);
5469 DEFVAR_LISP_NOPRO ("default-left-margin-width",
5470 &buffer_defaults
.left_margin_cols
,
5471 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5472 This is the same as (default-value 'left-margin-width). */);
5474 DEFVAR_LISP_NOPRO ("default-right-margin-width",
5475 &buffer_defaults
.right_margin_cols
,
5476 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5477 This is the same as (default-value 'right-margin-width). */);
5479 DEFVAR_LISP_NOPRO ("default-left-fringe-width",
5480 &buffer_defaults
.left_fringe_width
,
5481 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5482 This is the same as (default-value 'left-fringe-width). */);
5484 DEFVAR_LISP_NOPRO ("default-right-fringe-width",
5485 &buffer_defaults
.right_fringe_width
,
5486 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5487 This is the same as (default-value 'right-fringe-width). */);
5489 DEFVAR_LISP_NOPRO ("default-fringes-outside-margins",
5490 &buffer_defaults
.fringes_outside_margins
,
5491 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5492 This is the same as (default-value 'fringes-outside-margins). */);
5494 DEFVAR_LISP_NOPRO ("default-scroll-bar-width",
5495 &buffer_defaults
.scroll_bar_width
,
5496 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5497 This is the same as (default-value 'scroll-bar-width). */);
5499 DEFVAR_LISP_NOPRO ("default-vertical-scroll-bar",
5500 &buffer_defaults
.vertical_scroll_bar_type
,
5501 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5502 This is the same as (default-value 'vertical-scroll-bar). */);
5504 DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
5505 &buffer_defaults
.indicate_empty_lines
,
5506 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5507 This is the same as (default-value 'indicate-empty-lines). */);
5509 DEFVAR_LISP_NOPRO ("default-indicate-buffer-boundaries",
5510 &buffer_defaults
.indicate_buffer_boundaries
,
5511 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5512 This is the same as (default-value 'indicate-buffer-boundaries). */);
5514 DEFVAR_LISP_NOPRO ("default-fringe-indicator-alist",
5515 &buffer_defaults
.fringe_indicator_alist
,
5516 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5517 This is the same as (default-value 'fringe-indicator-alist'). */);
5519 DEFVAR_LISP_NOPRO ("default-fringe-cursor-alist",
5520 &buffer_defaults
.fringe_cursor_alist
,
5521 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5522 This is the same as (default-value 'fringe-cursor-alist'). */);
5524 DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
5525 &buffer_defaults
.scroll_up_aggressively
,
5526 doc
: /* Default value of `scroll-up-aggressively'.
5527 This value applies in buffers that don't have their own local values.
5528 This is the same as (default-value 'scroll-up-aggressively). */);
5530 DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
5531 &buffer_defaults
.scroll_down_aggressively
,
5532 doc
: /* Default value of `scroll-down-aggressively'.
5533 This value applies in buffers that don't have their own local values.
5534 This is the same as (default-value 'scroll-down-aggressively). */);
5536 DEFVAR_PER_BUFFER ("header-line-format",
5537 ¤t_buffer
->header_line_format
,
5539 doc
: /* Analogous to `mode-line-format', but controls the header line.
5540 The header line appears, optionally, at the top of a window;
5541 the mode line appears at the bottom. */);
5543 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
5545 doc
: /* Template for displaying mode line for current buffer.
5546 Each buffer has its own value of this variable.
5547 Value may be nil, a string, a symbol or a list or cons cell.
5548 A value of nil means don't display a mode line.
5549 For a symbol, its value is used (but it is ignored if t or nil).
5550 A string appearing directly as the value of a symbol is processed verbatim
5551 in that the %-constructs below are not recognized.
5552 Note that unless the symbol is marked as a `risky-local-variable', all
5553 properties in any strings, as well as all :eval and :propertize forms
5554 in the value of that symbol will be ignored.
5555 For a list of the form `(:eval FORM)', FORM is evaluated and the result
5556 is used as a mode line element. Be careful--FORM should not load any files,
5557 because that can cause an infinite recursion.
5558 For a list of the form `(:propertize ELT PROPS...)', ELT is displayed
5559 with the specified properties PROPS applied.
5560 For a list whose car is a symbol, the symbol's value is taken,
5561 and if that is non-nil, the cadr of the list is processed recursively.
5562 Otherwise, the caddr of the list (if there is one) is processed.
5563 For a list whose car is a string or list, each element is processed
5564 recursively and the results are effectively concatenated.
5565 For a list whose car is an integer, the cdr of the list is processed
5566 and padded (if the number is positive) or truncated (if negative)
5567 to the width specified by that number.
5568 A string is printed verbatim in the mode line except for %-constructs:
5569 (%-constructs are allowed when the string is the entire mode-line-format
5570 or when it is found in a cons-cell or a list)
5571 %b -- print buffer name. %f -- print visited file name.
5572 %F -- print frame name.
5573 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5574 %& is like %*, but ignore read-only-ness.
5575 % means buffer is read-only and * means it is modified.
5576 For a modified read-only buffer, %* gives % and %+ gives *.
5577 %s -- print process status. %l -- print the current line number.
5578 %c -- print the current column number (this makes editing slower).
5579 To make the column number update correctly in all cases,
5580 `column-number-mode' must be non-nil.
5581 %i -- print the size of the buffer.
5582 %I -- like %i, but use k, M, G, etc., to abbreviate.
5583 %p -- print percent of buffer above top of window, or Top, Bot or All.
5584 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5585 or print Bottom or All.
5586 %n -- print Narrow if appropriate.
5587 %t -- visited file is text or binary (if OS supports this distinction).
5588 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5589 %Z -- like %z, but including the end-of-line format.
5590 %e -- print error message about full memory.
5591 %@ -- print @ or hyphen. @ means that default-directory is on a
5593 %[ -- print one [ for each recursive editing level. %] similar.
5594 %% -- print %. %- -- print infinitely many dashes.
5595 Decimal digits after the % specify field width to which to pad. */);
5597 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
5598 doc
: /* *Major mode for new buffers. Defaults to `fundamental-mode'.
5599 A value of nil means use current buffer's major mode,
5600 provided it is not marked as "special".
5602 When a mode is used by default, `find-file' switches to it
5603 before it reads the contents into the buffer and before
5604 it finishes setting up the buffer. Thus, the mode and
5605 its hooks should not expect certain variables such as
5606 `buffer-read-only' and `buffer-file-coding-system' to be set up. */);
5608 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
5609 make_number (Lisp_Symbol
),
5610 doc
: /* Symbol for current buffer's major mode. */);
5612 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
5614 doc
: /* Pretty name of current buffer's major mode (a string). */);
5616 DEFVAR_PER_BUFFER ("local-abbrev-table", ¤t_buffer
->abbrev_table
, Qnil
,
5617 doc
: /* Local (mode-specific) abbrev table of current buffer. */);
5619 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
5620 doc
: /* Non-nil turns on automatic expansion of abbrevs as they are inserted. */);
5622 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
5624 doc
: /* *Non-nil if searches and matches should ignore case. */);
5626 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
5627 make_number (Lisp_Int
),
5628 doc
: /* *Column beyond which automatic line-wrapping should happen.
5629 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5631 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
5632 make_number (Lisp_Int
),
5633 doc
: /* *Column for the default `indent-line-function' to indent to.
5634 Linefeed indents to this column in Fundamental mode. */);
5636 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
5637 make_number (Lisp_Int
),
5638 doc
: /* *Distance between tab stops (for display of tab characters), in columns. */);
5640 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
5641 doc
: /* *Non-nil means display control chars with uparrow.
5642 A value of nil means use backslash and octal digits.
5643 This variable does not apply to characters whose display is specified
5644 in the current display table (if there is one). */);
5646 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5647 ¤t_buffer
->enable_multibyte_characters
,
5649 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5650 Otherwise they are regarded as unibyte. This affects the display,
5651 file I/O and the behavior of various editing commands.
5653 This variable is buffer-local but you cannot set it directly;
5654 use the function `set-buffer-multibyte' to change a buffer's representation.
5655 Changing its default value with `setq-default' is supported.
5656 See also variable `default-enable-multibyte-characters' and Info node
5657 `(elisp)Text Representations'. */);
5658 XSYMBOL (intern ("enable-multibyte-characters"))->constant
= 1;
5660 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5661 ¤t_buffer
->buffer_file_coding_system
, Qnil
,
5662 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5663 This variable applies to saving the buffer, and also to `write-region'
5664 and other functions that use `write-region'.
5665 It does not apply to sending output to subprocesses, however.
5667 If this is nil, the buffer is saved without any code conversion
5668 unless some coding system is specified in `file-coding-system-alist'
5669 for the buffer file.
5671 If the text to be saved cannot be encoded as specified by this variable,
5672 an alternative encoding is selected by `select-safe-coding-system', which see.
5674 The variable `coding-system-for-write', if non-nil, overrides this variable.
5676 This variable is never applied to a way of decoding a file while reading it. */);
5678 DEFVAR_PER_BUFFER ("direction-reversed", ¤t_buffer
->direction_reversed
,
5680 doc
: /* *Non-nil means lines in the buffer are displayed right to left. */);
5682 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
5683 doc
: /* *Non-nil means do not display continuation lines.
5684 Instead, give each line of text just one screen line.
5686 Note that this is overridden by the variable
5687 `truncate-partial-width-windows' if that variable is non-nil
5688 and this buffer is not full-frame width. */);
5691 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
5693 doc
: /* Non-nil if the visited file is a binary file.
5694 This variable is meaningful on MS-DOG and Windows NT.
5695 On those systems, it is automatically local in every buffer.
5696 On other systems, this variable is normally always nil. */);
5699 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
5700 make_number (Lisp_String
),
5701 doc
: /* Name of default directory of current buffer. Should end with slash.
5702 To interactively change the default directory, use command `cd'. */);
5704 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
5706 doc
: /* Function called (if non-nil) to perform auto-fill.
5707 It is called after self-inserting any character specified in
5708 the `auto-fill-chars' table.
5709 NOTE: This variable is not a hook;
5710 its value may not be a list of functions. */);
5712 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
5713 make_number (Lisp_String
),
5714 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5716 DEFVAR_PER_BUFFER ("buffer-file-truename", ¤t_buffer
->file_truename
,
5717 make_number (Lisp_String
),
5718 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5719 The truename of a file is calculated by `file-truename'
5720 and then abbreviated with `abbreviate-file-name'. */);
5722 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5723 ¤t_buffer
->auto_save_file_name
,
5724 make_number (Lisp_String
),
5725 doc
: /* Name of file for auto-saving current buffer.
5726 If it is nil, that means don't auto-save this buffer. */);
5728 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
5729 doc
: /* Non-nil if this buffer is read-only. */);
5731 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
5732 doc
: /* Non-nil if this buffer's file has been backed up.
5733 Backing up is done before the first time the file is saved. */);
5735 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
5736 make_number (Lisp_Int
),
5737 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5740 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
5742 doc
: /* Non-nil enables selective display.
5743 An integer N as value means display only lines
5744 that start with less than N columns of space.
5745 A value of t means that the character ^M makes itself and
5746 all the rest of the line invisible; also, when saving the buffer
5747 in a file, save the ^M as a newline. */);
5750 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5751 ¤t_buffer
->selective_display_ellipses
,
5753 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5756 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
5757 doc
: /* Non-nil if self-insertion should replace existing text.
5758 The value should be one of `overwrite-mode-textual',
5759 `overwrite-mode-binary', or nil.
5760 If it is `overwrite-mode-textual', self-insertion still
5761 inserts at the end of a line, and inserts when point is before a tab,
5762 until the tab is filled in.
5763 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5765 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
5767 doc
: /* Display table that controls display of the contents of current buffer.
5769 If this variable is nil, the value of `standard-display-table' is used.
5770 Each window can have its own, overriding display table, see
5771 `set-window-display-table' and `window-display-table'.
5773 The display table is a char-table created with `make-display-table'.
5774 A char-table is an array indexed by character codes. Normal array
5775 primitives `aref' and `aset' can be used to access elements of a char-table.
5777 Each of the char-table elements control how to display the corresponding
5778 text character: the element at index C in the table says how to display
5779 the character whose code is C. Each element should be a vector of
5780 characters or nil. The value nil means display the character in the
5781 default fashion; otherwise, the characters from the vector are delivered
5782 to the screen instead of the original character.
5784 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5785 to display a capital Y instead of each X character.
5787 In addition, a char-table has six extra slots to control the display of:
5789 the end of a truncated screen line (extra-slot 0, a single character);
5790 the end of a continued line (extra-slot 1, a single character);
5791 the escape character used to display character codes in octal
5792 (extra-slot 2, a single character);
5793 the character used as an arrow for control characters (extra-slot 3,
5794 a single character);
5795 the decoration indicating the presence of invisible lines (extra-slot 4,
5796 a vector of characters);
5797 the character used to draw the border between side-by-side windows
5798 (extra-slot 5, a single character).
5800 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5802 DEFVAR_PER_BUFFER ("left-margin-width", ¤t_buffer
->left_margin_cols
,
5804 doc
: /* *Width of left marginal area for display of a buffer.
5805 A value of nil means no marginal area. */);
5807 DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer
->right_margin_cols
,
5809 doc
: /* *Width of right marginal area for display of a buffer.
5810 A value of nil means no marginal area. */);
5812 DEFVAR_PER_BUFFER ("left-fringe-width", ¤t_buffer
->left_fringe_width
,
5814 doc
: /* *Width of this buffer's left fringe (in pixels).
5815 A value of 0 means no left fringe is shown in this buffer's window.
5816 A value of nil means to use the left fringe width from the window's frame. */);
5818 DEFVAR_PER_BUFFER ("right-fringe-width", ¤t_buffer
->right_fringe_width
,
5820 doc
: /* *Width of this buffer's right fringe (in pixels).
5821 A value of 0 means no right fringe is shown in this buffer's window.
5822 A value of nil means to use the right fringe width from the window's frame. */);
5824 DEFVAR_PER_BUFFER ("fringes-outside-margins", ¤t_buffer
->fringes_outside_margins
,
5826 doc
: /* *Non-nil means to display fringes outside display margins.
5827 A value of nil means to display fringes between margins and buffer text. */);
5829 DEFVAR_PER_BUFFER ("scroll-bar-width", ¤t_buffer
->scroll_bar_width
,
5831 doc
: /* *Width of this buffer's scroll bars in pixels.
5832 A value of nil means to use the scroll bar width from the window's frame. */);
5834 DEFVAR_PER_BUFFER ("vertical-scroll-bar", ¤t_buffer
->vertical_scroll_bar_type
,
5836 doc
: /* *Position of this buffer's vertical scroll bar.
5837 The value takes effect whenever you tell a window to display this buffer;
5838 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5840 A value of `left' or `right' means put the vertical scroll bar at that side
5841 of the window; a value of nil means don't show any vertical scroll bars.
5842 A value of t (the default) means do whatever the window's frame specifies. */);
5844 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5845 ¤t_buffer
->indicate_empty_lines
, Qnil
,
5846 doc
: /* *Visually indicate empty lines after the buffer end.
5847 If non-nil, a bitmap is displayed in the left fringe of a window on
5848 window-systems. */);
5850 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5851 ¤t_buffer
->indicate_buffer_boundaries
, Qnil
,
5852 doc
: /* *Visually indicate buffer boundaries and scrolling.
5853 If non-nil, the first and last line of the buffer are marked in the fringe
5854 of a window on window-systems with angle bitmaps, or if the window can be
5855 scrolled, the top and bottom line of the window are marked with up and down
5858 If value is a symbol `left' or `right', both angle and arrow bitmaps
5859 are displayed in the left or right fringe, resp. Any other value
5860 that doesn't look like an alist means display the angle bitmaps in
5861 the left fringe but no arrows.
5863 You can exercise more precise control by using an alist as the
5864 value. Each alist element (INDICATOR . POSITION) specifies
5865 where to show one of the indicators. INDICATOR is one of `top',
5866 `bottom', `up', `down', or t, which specifies the default position,
5867 and POSITION is one of `left', `right', or nil, meaning do not show
5870 For example, ((top . left) (t . right)) places the top angle bitmap in
5871 left fringe, the bottom angle bitmap in right fringe, and both arrow
5872 bitmaps in right fringe. To show just the angle bitmaps in the left
5873 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5875 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5876 ¤t_buffer
->fringe_indicator_alist
, Qnil
,
5877 doc
: /* *Mapping from logical to physical fringe indicator bitmaps.
5878 The value is an alist where each element (INDICATOR . BITMAPS)
5879 specifies the fringe bitmaps used to display a specific logical
5882 INDICATOR specifies the logical indicator type which is one of the
5883 following symbols: `truncation' , `continuation', `overlay-arrow',
5884 `top', `bottom', `up', `down', `one-line', `empty-line', or `unknown'.
5886 BITMAPS is list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5887 the actual bitmap shown in the left or right fringe for the logical
5888 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5889 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
5890 are used only for the `bottom' and `one-line' indicators when the last
5891 \(only) line in has no final newline. BITMAPS may also be a single
5892 symbol which is used in both left and right fringes. */);
5894 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
5895 ¤t_buffer
->fringe_cursor_alist
, Qnil
,
5896 doc
: /* *Mapping from logical to physical fringe cursor bitmaps.
5897 The value is an alist where each element (CURSOR . BITMAP)
5898 specifies the fringe bitmaps used to display a specific logical
5899 cursor type in the fringe.
5901 CURSOR specifies the logical cursor type which is one of the following
5902 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
5903 one is used to show a hollow cursor on narrow lines display lines
5904 where the normal hollow cursor will not fit.
5906 BITMAP is the corresponding fringe bitmap shown for the logical
5909 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5910 ¤t_buffer
->scroll_up_aggressively
, Qnil
,
5911 doc
: /* How far to scroll windows upward.
5912 If you move point off the bottom, the window scrolls automatically.
5913 This variable controls how far it scrolls. The value nil, the default,
5914 means scroll to center point. A fraction means scroll to put point
5915 that fraction of the window's height from the bottom of the window.
5916 When the value is 0.0, point goes at the bottom line, which in the simple
5917 case that you moved off with C-f means scrolling just one line. 1.0 means
5918 point goes at the top, so that in that simple case, the window
5919 scrolls by a full window height. Meaningful values are
5920 between 0.0 and 1.0, inclusive. */);
5922 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
5923 ¤t_buffer
->scroll_down_aggressively
, Qnil
,
5924 doc
: /* How far to scroll windows downward.
5925 If you move point off the top, the window scrolls automatically.
5926 This variable controls how far it scrolls. The value nil, the default,
5927 means scroll to center point. A fraction means scroll to put point
5928 that fraction of the window's height from the top of the window.
5929 When the value is 0.0, point goes at the top line, which in the simple
5930 case that you moved off with C-b means scrolling just one line. 1.0 means
5931 point goes at the bottom, so that in that simple case, the window
5932 scrolls by a full window height. Meaningful values are
5933 between 0.0 and 1.0, inclusive. */);
5935 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
5939 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
5940 doc
: /* List of functions to call before each text change.
5941 Two arguments are passed to each function: the positions of
5942 the beginning and end of the range of old text to be changed.
5943 \(For an insertion, the beginning and end are at the same place.)
5944 No information is given about the length of the text after the change.
5946 Buffer changes made while executing the `before-change-functions'
5947 don't call any before-change or after-change functions.
5948 That's because these variables are temporarily set to nil.
5949 As a result, a hook function cannot straightforwardly alter the value of
5950 these variables. See the Emacs Lisp manual for a way of
5951 accomplishing an equivalent result by using other variables.
5953 If an unhandled error happens in running these functions,
5954 the variable's value remains nil. That prevents the error
5955 from happening repeatedly and making Emacs nonfunctional. */);
5956 Vbefore_change_functions
= Qnil
;
5958 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
5959 doc
: /* List of functions to call after each text change.
5960 Three arguments are passed to each function: the positions of
5961 the beginning and end of the range of changed text,
5962 and the length in bytes of the pre-change text replaced by that range.
5963 \(For an insertion, the pre-change length is zero;
5964 for a deletion, that length is the number of bytes deleted,
5965 and the post-change beginning and end are at the same place.)
5967 Buffer changes made while executing the `after-change-functions'
5968 don't call any before-change or after-change functions.
5969 That's because these variables are temporarily set to nil.
5970 As a result, a hook function cannot straightforwardly alter the value of
5971 these variables. See the Emacs Lisp manual for a way of
5972 accomplishing an equivalent result by using other variables.
5974 If an unhandled error happens in running these functions,
5975 the variable's value remains nil. That prevents the error
5976 from happening repeatedly and making Emacs nonfunctional. */);
5977 Vafter_change_functions
= Qnil
;
5979 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
5980 doc
: /* A list of functions to call before changing a buffer which is unmodified.
5981 The functions are run using the `run-hooks' function. */);
5982 Vfirst_change_hook
= Qnil
;
5984 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
5985 doc
: /* List of undo entries in current buffer.
5986 Recent changes come first; older changes follow newer.
5988 An entry (BEG . END) represents an insertion which begins at
5989 position BEG and ends at position END.
5991 An entry (TEXT . POSITION) represents the deletion of the string TEXT
5992 from (abs POSITION). If POSITION is positive, point was at the front
5993 of the text being deleted; if negative, point was at the end.
5995 An entry (t HIGH . LOW) indicates that the buffer previously had
5996 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions
5997 of the visited file's modification time, as of that time. If the
5998 modification time of the most recent save is different, this entry is
6001 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6002 was modified between BEG and END. PROPERTY is the property name,
6003 and VALUE is the old value.
6005 An entry (apply FUN-NAME . ARGS) means undo the change with
6006 \(apply FUN-NAME ARGS).
6008 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6009 in the active region. BEG and END is the range affected by this entry
6010 and DELTA is the number of bytes added or deleted in that range by
6013 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6014 was adjusted in position by the offset DISTANCE (an integer).
6016 An entry of the form POSITION indicates that point was at the buffer
6017 location given by the integer. Undoing an entry of this form places
6020 Entries with value `nil' mark undo boundaries. The undo command treats
6021 the changes between two undo boundaries as a single step to be undone.
6023 If the value of the variable is t, undo information is not recorded. */);
6025 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
6026 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
6028 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
6029 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
6031 Normally, the line-motion functions work by scanning the buffer for
6032 newlines. Columnar operations (like `move-to-column' and
6033 `compute-motion') also work by scanning the buffer, summing character
6034 widths as they go. This works well for ordinary text, but if the
6035 buffer's lines are very long (say, more than 500 characters), these
6036 motion functions will take longer to execute. Emacs may also take
6037 longer to update the display.
6039 If `cache-long-line-scans' is non-nil, these motion functions cache the
6040 results of their scans, and consult the cache to avoid rescanning
6041 regions of the buffer until the text is modified. The caches are most
6042 beneficial when they prevent the most searching---that is, when the
6043 buffer contains long lines and large regions of characters with the
6044 same, fixed screen width.
6046 When `cache-long-line-scans' is non-nil, processing short lines will
6047 become slightly slower (because of the overhead of consulting the
6048 cache), and the caches will use memory roughly proportional to the
6049 number of newlines and characters whose screen width varies.
6051 The caches require no explicit maintenance; their accuracy is
6052 maintained internally by the Emacs primitives. Enabling or disabling
6053 the cache should not affect the behavior of any of the motion
6054 functions; it should only affect their performance. */);
6056 DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer
->point_before_scroll
, Qnil
,
6057 doc
: /* Value of point before the last series of scroll operations, or nil. */);
6059 DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer
->file_format
, Qnil
,
6060 doc
: /* List of formats to use when saving this buffer.
6061 Formats are defined by `format-alist'. This variable is
6062 set when a file is visited. */);
6064 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6065 ¤t_buffer
->auto_save_file_format
, Qnil
,
6066 doc
: /* *Format in which to write auto-save files.
6067 Should be a list of symbols naming formats that are defined in `format-alist'.
6068 If it is t, which is the default, auto-save files are written in the
6069 same format as a regular save would use. */);
6071 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6072 ¤t_buffer
->invisibility_spec
, Qnil
,
6073 doc
: /* Invisibility spec of this buffer.
6074 The default is t, which means that text is invisible
6075 if it has a non-nil `invisible' property.
6076 If the value is a list, a text character is invisible if its `invisible'
6077 property is an element in that list (or is a list with members in common).
6078 If an element is a cons cell of the form (PROP . ELLIPSIS),
6079 then characters with property value PROP are invisible,
6080 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
6082 DEFVAR_PER_BUFFER ("buffer-display-count",
6083 ¤t_buffer
->display_count
, Qnil
,
6084 doc
: /* A number incremented each time this buffer is displayed in a window.
6085 The function `set-window-buffer' increments it. */);
6087 DEFVAR_PER_BUFFER ("buffer-display-time",
6088 ¤t_buffer
->display_time
, Qnil
,
6089 doc
: /* Time stamp updated each time this buffer is displayed in a window.
6090 The function `set-window-buffer' updates this variable
6091 to the value obtained by calling `current-time'.
6092 If the buffer has never been shown in a window, the value is nil. */);
6094 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
6095 doc
: /* *Non-nil means deactivate the mark when the buffer contents change.
6096 Non-nil also enables highlighting of the region whenever the mark is active.
6097 The variable `highlight-nonselected-windows' controls whether to highlight
6098 all windows or just the selected window.
6100 If the value is `lambda', that enables Transient Mark mode temporarily
6101 until the next buffer modification. If a command sets the value to `only',
6102 that enables Transient Mark mode for the following command only.
6103 During that following command, the value of `transient-mark-mode'
6104 is `identity'. If it is still `identity' at the end of that command,
6105 it changes to nil. */);
6106 Vtransient_mark_mode
= Qnil
;
6108 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
6109 doc
: /* *Non-nil means disregard read-only status of buffers or characters.
6110 If the value is t, disregard `buffer-read-only' and all `read-only'
6111 text properties. If the value is a list, disregard `buffer-read-only'
6112 and disregard a `read-only' text property if the property value
6113 is a member of the list. */);
6114 Vinhibit_read_only
= Qnil
;
6116 DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer
->cursor_type
, Qnil
,
6117 doc
: /* Cursor to use when this buffer is in the selected window.
6118 Values are interpreted as follows:
6120 t use the cursor specified for the frame
6121 nil don't display a cursor
6122 box display a filled box cursor
6123 hollow display a hollow box cursor
6124 bar display a vertical bar cursor with default width
6125 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6126 hbar display a horizontal bar cursor with default height
6127 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6128 ANYTHING ELSE display a hollow box cursor
6130 When the buffer is displayed in a nonselected window,
6131 this variable has no effect; the cursor appears as a hollow box. */);
6133 DEFVAR_PER_BUFFER ("line-spacing",
6134 ¤t_buffer
->extra_line_spacing
, Qnil
,
6135 doc
: /* Additional space to put between lines when displaying a buffer.
6136 The space is measured in pixels, and put below lines on window systems.
6137 If value is a floating point number, it specifies the spacing relative
6138 to the default frame line height. A value of nil means add no extra space. */);
6140 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6141 ¤t_buffer
->cursor_in_non_selected_windows
, Qnil
,
6142 doc
: /* *Cursor type to display in non-selected windows.
6143 The value t means to use hollow box cursor. See `cursor-type' for other values. */);
6145 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
6146 doc
: /* List of functions called with no args to query before killing a buffer.
6147 The buffer being killed will be current while the functions are running.
6148 If any of them returns nil, the buffer is not killed. */);
6149 Vkill_buffer_query_functions
= Qnil
;
6151 DEFVAR_LISP ("change-major-mode-hook", &Vchange_major_mode_hook
,
6152 doc
: /* Normal hook run before changing the major mode of a buffer.
6153 The function `kill-all-local-variables' runs this before doing anything else. */);
6154 Vchange_major_mode_hook
= Qnil
;
6155 Qchange_major_mode_hook
= intern ("change-major-mode-hook");
6156 staticpro (&Qchange_major_mode_hook
);
6158 defsubr (&Sbuffer_live_p
);
6159 defsubr (&Sbuffer_list
);
6160 defsubr (&Sget_buffer
);
6161 defsubr (&Sget_file_buffer
);
6162 defsubr (&Sget_buffer_create
);
6163 defsubr (&Smake_indirect_buffer
);
6164 defsubr (&Sgenerate_new_buffer_name
);
6165 defsubr (&Sbuffer_name
);
6166 /*defsubr (&Sbuffer_number);*/
6167 defsubr (&Sbuffer_file_name
);
6168 defsubr (&Sbuffer_base_buffer
);
6169 defsubr (&Sbuffer_local_value
);
6170 defsubr (&Sbuffer_local_variables
);
6171 defsubr (&Sbuffer_modified_p
);
6172 defsubr (&Sset_buffer_modified_p
);
6173 defsubr (&Sbuffer_modified_tick
);
6174 defsubr (&Sbuffer_chars_modified_tick
);
6175 defsubr (&Srename_buffer
);
6176 defsubr (&Sother_buffer
);
6177 defsubr (&Sbuffer_enable_undo
);
6178 defsubr (&Skill_buffer
);
6179 defsubr (&Sset_buffer_major_mode
);
6180 defsubr (&Sswitch_to_buffer
);
6181 defsubr (&Spop_to_buffer
);
6182 defsubr (&Scurrent_buffer
);
6183 defsubr (&Sset_buffer
);
6184 defsubr (&Sbarf_if_buffer_read_only
);
6185 defsubr (&Sbury_buffer
);
6186 defsubr (&Serase_buffer
);
6187 defsubr (&Sset_buffer_multibyte
);
6188 defsubr (&Skill_all_local_variables
);
6190 defsubr (&Soverlayp
);
6191 defsubr (&Smake_overlay
);
6192 defsubr (&Sdelete_overlay
);
6193 defsubr (&Smove_overlay
);
6194 defsubr (&Soverlay_start
);
6195 defsubr (&Soverlay_end
);
6196 defsubr (&Soverlay_buffer
);
6197 defsubr (&Soverlay_properties
);
6198 defsubr (&Soverlays_at
);
6199 defsubr (&Soverlays_in
);
6200 defsubr (&Snext_overlay_change
);
6201 defsubr (&Sprevious_overlay_change
);
6202 defsubr (&Soverlay_recenter
);
6203 defsubr (&Soverlay_lists
);
6204 defsubr (&Soverlay_get
);
6205 defsubr (&Soverlay_put
);
6206 defsubr (&Srestore_buffer_modified_p
);
6212 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6213 initial_define_key (control_x_map
, 'k', "kill-buffer");
6215 /* This must not be in syms_of_buffer, because Qdisabled is not
6216 initialized when that function gets called. */
6217 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);
6220 /* arch-tag: e48569bf-69a9-4b65-a23b-8e68769436e1
6221 (do not change this comment) */