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 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 2, 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"
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
*));
188 /* For debugging; temporary. See set_buffer_internal. */
189 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
196 error ("No buffer named %s", SDATA (spec
));
197 error ("Invalid buffer argument");
200 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
201 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
202 Value is nil if OBJECT is not a buffer or if it has been killed. */)
206 return ((BUFFERP (object
) && ! NILP (XBUFFER (object
)->name
))
210 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
211 doc
: /* Return a list of all existing live buffers.
212 If the optional arg FRAME is a frame, we return the buffer list
213 in the proper order for that frame: the buffers in FRAME's `buffer-list'
214 frame parameter come first, followed by the rest of the buffers. */)
219 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
223 Lisp_Object framelist
, prevlist
, tail
;
228 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
229 prevlist
= Fnreverse (Fcopy_sequence (XFRAME (frame
)->buried_buffer_list
));
231 /* Remove from GENERAL any buffer that duplicates one in
232 FRAMELIST or PREVLIST. */
236 general
= Fdelq (XCAR (tail
), general
);
242 general
= Fdelq (XCAR (tail
), general
);
249 return Fnconc (3, args
);
255 /* Like Fassoc, but use Fstring_equal to compare
256 (which ignores text properties),
257 and don't ever QUIT. */
260 assoc_ignore_text_properties (key
, list
)
261 register Lisp_Object key
;
264 register Lisp_Object tail
;
265 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
267 register Lisp_Object elt
, tem
;
269 tem
= Fstring_equal (Fcar (elt
), key
);
276 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
277 doc
: /* Return the buffer named NAME (a string).
278 If there is no live buffer named NAME, return nil.
279 NAME may also be a buffer; if so, the value is that buffer. */)
281 register Lisp_Object name
;
287 return Fcdr (assoc_ignore_text_properties (name
, Vbuffer_alist
));
290 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
291 doc
: /* Return the buffer visiting file FILENAME (a string).
292 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
293 If there is no such live buffer, return nil.
294 See also `find-buffer-visiting'. */)
296 register Lisp_Object filename
;
298 register Lisp_Object tail
, buf
, tem
;
301 CHECK_STRING (filename
);
302 filename
= Fexpand_file_name (filename
, Qnil
);
304 /* If the file name has special constructs in it,
305 call the corresponding file handler. */
306 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
308 return call2 (handler
, Qget_file_buffer
, filename
);
310 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
312 buf
= Fcdr (XCAR (tail
));
313 if (!BUFFERP (buf
)) continue;
314 if (!STRINGP (XBUFFER (buf
)->filename
)) continue;
315 tem
= Fstring_equal (XBUFFER (buf
)->filename
, filename
);
323 get_truename_buffer (filename
)
324 register Lisp_Object filename
;
326 register Lisp_Object tail
, buf
, tem
;
328 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
330 buf
= Fcdr (XCAR (tail
));
331 if (!BUFFERP (buf
)) continue;
332 if (!STRINGP (XBUFFER (buf
)->file_truename
)) continue;
333 tem
= Fstring_equal (XBUFFER (buf
)->file_truename
, filename
);
340 /* Incremented for each buffer created, to assign the buffer number. */
343 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
344 doc
: /* Return the buffer named NAME, or create such a buffer and return it.
345 A new buffer is created if there is no live buffer named NAME.
346 If NAME starts with a space, the new buffer does not keep undo information.
347 If NAME is a buffer instead of a string, then it is the value returned.
348 The value is never nil. */)
350 register Lisp_Object name
;
352 register Lisp_Object buf
;
353 register struct buffer
*b
;
355 buf
= Fget_buffer (name
);
359 if (SCHARS (name
) == 0)
360 error ("Empty string for buffer name is not allowed");
362 b
= (struct buffer
*) allocate_buffer ();
364 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
366 /* An ordinary buffer uses its own struct buffer_text. */
367 b
->text
= &b
->own_text
;
370 BUF_GAP_SIZE (b
) = 20;
372 /* We allocate extra 1-byte at the tail and keep it always '\0' for
373 anchoring a search. */
374 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
376 if (! BUF_BEG_ADDR (b
))
377 buffer_memory_full ();
384 BUF_PT_BYTE (b
) = BEG_BYTE
;
385 BUF_GPT_BYTE (b
) = BEG_BYTE
;
386 BUF_BEGV_BYTE (b
) = BEG_BYTE
;
387 BUF_ZV_BYTE (b
) = BEG_BYTE
;
388 BUF_Z_BYTE (b
) = BEG_BYTE
;
390 BUF_OVERLAY_MODIFF (b
) = 1;
391 BUF_SAVE_MODIFF (b
) = 1;
392 BUF_INTERVALS (b
) = 0;
393 BUF_UNCHANGED_MODIFIED (b
) = 1;
394 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
395 BUF_END_UNCHANGED (b
) = 0;
396 BUF_BEG_UNCHANGED (b
) = 0;
397 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
399 b
->newline_cache
= 0;
400 b
->width_run_cache
= 0;
401 b
->width_table
= Qnil
;
402 b
->prevent_redisplay_optimizations_p
= 1;
404 /* Put this on the chain of all buffers including killed ones. */
405 b
->next
= all_buffers
;
408 /* An ordinary buffer normally doesn't need markers
409 to handle BEGV and ZV. */
411 b
->begv_marker
= Qnil
;
414 name
= Fcopy_sequence (name
);
415 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
418 if (SREF (name
, 0) != ' ')
424 reset_buffer_local_variables (b
, 1);
426 b
->mark
= Fmake_marker ();
427 BUF_MARKERS (b
) = NULL
;
430 /* Put this in the alist of all live buffers. */
432 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
434 /* An error in calling the function here (should someone redfine it)
435 can lead to infinite regress until you run out of stack. rms
436 says that's not worth protecting against. */
437 if (!NILP (Ffboundp (Qucs_set_table_for_input
)))
438 /* buf is on buffer-alist, so no gcpro. */
439 call1 (Qucs_set_table_for_input
, buf
);
445 /* Return a list of overlays which is a copy of the overlay list
446 LIST, but for buffer B. */
448 static struct Lisp_Overlay
*
449 copy_overlays (b
, list
)
451 struct Lisp_Overlay
*list
;
454 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
456 XSETBUFFER (buffer
, b
);
458 for (; list
; list
= list
->next
)
460 Lisp_Object overlay
, start
, end
, old_overlay
;
463 XSETMISC (old_overlay
, list
);
464 charpos
= marker_position (OVERLAY_START (old_overlay
));
465 start
= Fmake_marker ();
466 Fset_marker (start
, make_number (charpos
), buffer
);
467 XMARKER (start
)->insertion_type
468 = XMARKER (OVERLAY_START (old_overlay
))->insertion_type
;
470 charpos
= marker_position (OVERLAY_END (old_overlay
));
471 end
= Fmake_marker ();
472 Fset_marker (end
, make_number (charpos
), buffer
);
473 XMARKER (end
)->insertion_type
474 = XMARKER (OVERLAY_END (old_overlay
))->insertion_type
;
476 overlay
= allocate_misc ();
477 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
478 OVERLAY_START (overlay
) = start
;
479 OVERLAY_END (overlay
) = end
;
480 OVERLAY_PLIST (overlay
) = Fcopy_sequence (OVERLAY_PLIST (old_overlay
));
481 XOVERLAY (overlay
)->next
= NULL
;
484 tail
= tail
->next
= XOVERLAY (overlay
);
486 result
= tail
= XOVERLAY (overlay
);
493 /* Clone per-buffer values of buffer FROM.
495 Buffer TO gets the same per-buffer values as FROM, with the
496 following exceptions: (1) TO's name is left untouched, (2) markers
497 are copied and made to refer to TO, and (3) overlay lists are
501 clone_per_buffer_values (from
, to
)
502 struct buffer
*from
, *to
;
504 Lisp_Object to_buffer
;
507 XSETBUFFER (to_buffer
, to
);
509 for (offset
= PER_BUFFER_VAR_OFFSET (name
) + sizeof (Lisp_Object
);
511 offset
+= sizeof (Lisp_Object
))
515 obj
= PER_BUFFER_VALUE (from
, offset
);
518 struct Lisp_Marker
*m
= XMARKER (obj
);
519 obj
= Fmake_marker ();
520 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
521 set_marker_both (obj
, to_buffer
, m
->charpos
, m
->bytepos
);
524 PER_BUFFER_VALUE (to
, offset
) = obj
;
527 bcopy (from
->local_flags
, to
->local_flags
, sizeof to
->local_flags
);
529 to
->overlays_before
= copy_overlays (to
, from
->overlays_before
);
530 to
->overlays_after
= copy_overlays (to
, from
->overlays_after
);
532 /* Get (a copy of) the alist of Lisp-level local variables of FROM
533 and install that in TO. */
534 to
->local_var_alist
= buffer_lisp_local_variables (from
);
537 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
539 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
540 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
541 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
542 NAME should be a string which is not the name of an existing buffer.
543 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
544 such as major and minor modes, in the indirect buffer.
545 CLONE nil means the indirect buffer's state is reset to default values. */)
546 (base_buffer
, name
, clone
)
547 Lisp_Object base_buffer
, name
, clone
;
549 Lisp_Object buf
, tem
;
553 buf
= Fget_buffer (name
);
555 error ("Buffer name `%s' is in use", SDATA (name
));
558 base_buffer
= Fget_buffer (base_buffer
);
559 if (NILP (base_buffer
))
560 error ("No such buffer: `%s'", SDATA (tem
));
561 if (NILP (XBUFFER (base_buffer
)->name
))
562 error ("Base buffer has been killed");
564 if (SCHARS (name
) == 0)
565 error ("Empty string for buffer name is not allowed");
567 b
= (struct buffer
*) allocate_buffer ();
568 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
570 if (XBUFFER (base_buffer
)->base_buffer
)
571 b
->base_buffer
= XBUFFER (base_buffer
)->base_buffer
;
573 b
->base_buffer
= XBUFFER (base_buffer
);
575 /* Use the base buffer's text object. */
576 b
->text
= b
->base_buffer
->text
;
578 BUF_BEGV (b
) = BUF_BEGV (b
->base_buffer
);
579 BUF_ZV (b
) = BUF_ZV (b
->base_buffer
);
580 BUF_PT (b
) = BUF_PT (b
->base_buffer
);
581 BUF_BEGV_BYTE (b
) = BUF_BEGV_BYTE (b
->base_buffer
);
582 BUF_ZV_BYTE (b
) = BUF_ZV_BYTE (b
->base_buffer
);
583 BUF_PT_BYTE (b
) = BUF_PT_BYTE (b
->base_buffer
);
585 b
->newline_cache
= 0;
586 b
->width_run_cache
= 0;
587 b
->width_table
= Qnil
;
589 /* Put this on the chain of all buffers including killed ones. */
590 b
->next
= all_buffers
;
593 name
= Fcopy_sequence (name
);
594 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
598 reset_buffer_local_variables (b
, 1);
600 /* Put this in the alist of all live buffers. */
602 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
604 b
->mark
= Fmake_marker ();
607 /* The multibyte status belongs to the base buffer. */
608 b
->enable_multibyte_characters
= b
->base_buffer
->enable_multibyte_characters
;
610 /* Make sure the base buffer has markers for its narrowing. */
611 if (NILP (b
->base_buffer
->pt_marker
))
613 b
->base_buffer
->pt_marker
= Fmake_marker ();
614 set_marker_both (b
->base_buffer
->pt_marker
, base_buffer
,
615 BUF_PT (b
->base_buffer
),
616 BUF_PT_BYTE (b
->base_buffer
));
618 if (NILP (b
->base_buffer
->begv_marker
))
620 b
->base_buffer
->begv_marker
= Fmake_marker ();
621 set_marker_both (b
->base_buffer
->begv_marker
, base_buffer
,
622 BUF_BEGV (b
->base_buffer
),
623 BUF_BEGV_BYTE (b
->base_buffer
));
625 if (NILP (b
->base_buffer
->zv_marker
))
627 b
->base_buffer
->zv_marker
= Fmake_marker ();
628 set_marker_both (b
->base_buffer
->zv_marker
, base_buffer
,
629 BUF_ZV (b
->base_buffer
),
630 BUF_ZV_BYTE (b
->base_buffer
));
631 XMARKER (b
->base_buffer
->zv_marker
)->insertion_type
= 1;
636 /* Give the indirect buffer markers for its narrowing. */
637 b
->pt_marker
= Fmake_marker ();
638 set_marker_both (b
->pt_marker
, buf
, BUF_PT (b
), BUF_PT_BYTE (b
));
639 b
->begv_marker
= Fmake_marker ();
640 set_marker_both (b
->begv_marker
, buf
, BUF_BEGV (b
), BUF_BEGV_BYTE (b
));
641 b
->zv_marker
= Fmake_marker ();
642 set_marker_both (b
->zv_marker
, buf
, BUF_ZV (b
), BUF_ZV_BYTE (b
));
643 XMARKER (b
->zv_marker
)->insertion_type
= 1;
647 struct buffer
*old_b
= current_buffer
;
649 clone_per_buffer_values (b
->base_buffer
, b
);
651 b
->file_truename
= Qnil
;
652 b
->display_count
= make_number (0);
654 b
->auto_save_file_name
= Qnil
;
655 set_buffer_internal_1 (b
);
656 Fset (intern ("buffer-save-without-query"), Qnil
);
657 Fset (intern ("buffer-file-number"), Qnil
);
658 Fset (intern ("buffer-stale-function"), Qnil
);
659 set_buffer_internal_1 (old_b
);
666 delete_all_overlays (b
)
671 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
672 have to empty the list, otherwise we end up with overlays that
673 think they belong to this buffer while the buffer doesn't know about
675 while (b
->overlays_before
)
677 XSETMISC (overlay
, b
->overlays_before
);
678 Fdelete_overlay (overlay
);
680 while (b
->overlays_after
)
682 XSETMISC (overlay
, b
->overlays_after
);
683 Fdelete_overlay (overlay
);
685 eassert (b
->overlays_before
== NULL
);
686 eassert (b
->overlays_after
== NULL
);
689 /* Reinitialize everything about a buffer except its name and contents
691 If called on an already-initialized buffer, the list of overlays
692 should be deleted before calling this function, otherwise we end up
693 with overlays that claim to belong to the buffer but the buffer
694 claims it doesn't belong to it. */
698 register struct buffer
*b
;
701 b
->file_truename
= Qnil
;
702 b
->directory
= (current_buffer
) ? current_buffer
->directory
: Qnil
;
704 XSETFASTINT (b
->save_length
, 0);
705 b
->last_window_start
= 1;
706 /* It is more conservative to start out "changed" than "unchanged". */
708 b
->prevent_redisplay_optimizations_p
= 1;
710 b
->auto_save_modified
= 0;
711 b
->auto_save_failure_time
= -1;
712 b
->auto_save_file_name
= Qnil
;
714 b
->overlays_before
= NULL
;
715 b
->overlays_after
= NULL
;
716 b
->overlay_center
= BEG
;
717 b
->mark_active
= Qnil
;
718 b
->point_before_scroll
= Qnil
;
719 b
->file_format
= Qnil
;
720 b
->auto_save_file_format
= Qt
;
721 b
->last_selected_window
= Qnil
;
722 XSETINT (b
->display_count
, 0);
723 b
->display_time
= Qnil
;
724 b
->enable_multibyte_characters
= buffer_defaults
.enable_multibyte_characters
;
725 b
->cursor_type
= buffer_defaults
.cursor_type
;
726 b
->extra_line_spacing
= buffer_defaults
.extra_line_spacing
;
728 b
->display_error_modiff
= 0;
731 /* Reset buffer B's local variables info.
732 Don't use this on a buffer that has already been in use;
733 it does not treat permanent locals consistently.
734 Instead, use Fkill_all_local_variables.
736 If PERMANENT_TOO is 1, then we reset permanent built-in
737 buffer-local variables. If PERMANENT_TOO is 0,
738 we preserve those. */
741 reset_buffer_local_variables (b
, permanent_too
)
742 register struct buffer
*b
;
748 /* Reset the major mode to Fundamental, together with all the
749 things that depend on the major mode.
750 default-major-mode is handled at a higher level.
751 We ignore it here. */
752 b
->major_mode
= Qfundamental_mode
;
754 b
->mode_name
= QSFundamental
;
755 b
->minor_modes
= Qnil
;
757 /* If the standard case table has been altered and invalidated,
758 fix up its insides first. */
759 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
760 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
761 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
762 Fset_standard_case_table (Vascii_downcase_table
);
764 b
->downcase_table
= Vascii_downcase_table
;
765 b
->upcase_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
766 b
->case_canon_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
767 b
->case_eqv_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
768 b
->invisibility_spec
= Qt
;
770 b
->buffer_file_type
= Qnil
;
773 /* Reset all (or most) per-buffer variables to their defaults. */
774 b
->local_var_alist
= Qnil
;
775 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
776 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
777 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
779 /* For each slot that has a default value,
780 copy that into the slot. */
782 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
784 offset
+= sizeof (Lisp_Object
))
786 int idx
= PER_BUFFER_IDX (offset
);
789 || buffer_permanent_local_flags
[idx
] == 0))
790 /* Is -2 used anywhere? */
792 PER_BUFFER_VALUE (b
, offset
) = PER_BUFFER_DEFAULT (offset
);
796 /* We split this away from generate-new-buffer, because rename-buffer
797 and set-visited-file-name ought to be able to use this to really
798 rename the buffer properly. */
800 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
802 doc
: /* Return a string that is the name of no existing buffer based on NAME.
803 If there is no live buffer named NAME, then return NAME.
804 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
805 \(starting at 2) until an unused name is found, and then return that name.
806 Optional second argument IGNORE specifies a name that is okay to use
807 \(if it is in the sequence to be tried)
808 even if a buffer with that name exists. */)
810 register Lisp_Object name
, ignore
;
812 register Lisp_Object gentemp
, tem
;
818 tem
= Fstring_equal (name
, ignore
);
821 tem
= Fget_buffer (name
);
828 sprintf (number
, "<%d>", ++count
);
829 gentemp
= concat2 (name
, build_string (number
));
830 tem
= Fstring_equal (gentemp
, ignore
);
833 tem
= Fget_buffer (gentemp
);
840 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
841 doc
: /* Return the name of BUFFER, as a string.
842 With no argument or nil as argument, return the name of the current buffer. */)
844 register Lisp_Object buffer
;
847 return current_buffer
->name
;
848 CHECK_BUFFER (buffer
);
849 return XBUFFER (buffer
)->name
;
852 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
853 doc
: /* Return name of file BUFFER is visiting, or nil if none.
854 No argument or nil as argument means use the current buffer. */)
856 register Lisp_Object buffer
;
859 return current_buffer
->filename
;
860 CHECK_BUFFER (buffer
);
861 return XBUFFER (buffer
)->filename
;
864 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
866 doc
: /* Return the base buffer of indirect buffer BUFFER.
867 If BUFFER is not indirect, return nil.
868 BUFFER defaults to the current buffer. */)
870 register Lisp_Object buffer
;
873 Lisp_Object base_buffer
;
876 base
= current_buffer
->base_buffer
;
879 CHECK_BUFFER (buffer
);
880 base
= XBUFFER (buffer
)->base_buffer
;
885 XSETBUFFER (base_buffer
, base
);
889 DEFUN ("buffer-local-value", Fbuffer_local_value
,
890 Sbuffer_local_value
, 2, 2, 0,
891 doc
: /* Return the value of VARIABLE in BUFFER.
892 If VARIABLE does not have a buffer-local binding in BUFFER, the value
893 is the default binding of the variable. */)
895 register Lisp_Object variable
;
896 register Lisp_Object buffer
;
898 register struct buffer
*buf
;
899 register Lisp_Object result
;
901 CHECK_SYMBOL (variable
);
902 CHECK_BUFFER (buffer
);
903 buf
= XBUFFER (buffer
);
905 if (SYMBOLP (variable
))
906 variable
= indirect_variable (variable
);
908 /* Look in local_var_list */
909 result
= Fassoc (variable
, buf
->local_var_alist
);
915 /* Look in special slots */
916 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
917 offset
< sizeof (struct buffer
);
918 /* sizeof EMACS_INT == sizeof Lisp_Object */
919 offset
+= (sizeof (EMACS_INT
)))
921 idx
= PER_BUFFER_IDX (offset
);
922 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
923 && SYMBOLP (PER_BUFFER_SYMBOL (offset
))
924 && EQ (PER_BUFFER_SYMBOL (offset
), variable
))
926 result
= PER_BUFFER_VALUE (buf
, offset
);
933 result
= Fdefault_value (variable
);
937 Lisp_Object valcontents
;
938 Lisp_Object current_alist_element
;
940 /* What binding is loaded right now? */
941 valcontents
= SYMBOL_VALUE (variable
);
942 current_alist_element
943 = XCAR (XBUFFER_LOCAL_VALUE (valcontents
)->cdr
);
945 /* The value of the currently loaded binding is not
946 stored in it, but rather in the realvalue slot.
947 Store that value into the binding it belongs to
948 in case that is the one we are about to use. */
950 Fsetcdr (current_alist_element
,
951 do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
));
953 /* Now get the (perhaps updated) value out of the binding. */
954 result
= XCDR (result
);
957 if (!EQ (result
, Qunbound
))
960 xsignal1 (Qvoid_variable
, variable
);
963 /* Return an alist of the Lisp-level buffer-local bindings of
964 buffer BUF. That is, don't include the variables maintained
965 in special slots in the buffer object. */
968 buffer_lisp_local_variables (buf
)
971 Lisp_Object result
= Qnil
;
972 register Lisp_Object tail
;
973 for (tail
= buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
975 Lisp_Object val
, elt
;
979 /* Reference each variable in the alist in buf.
980 If inquiring about the current buffer, this gets the current values,
981 so store them into the alist so the alist is up to date.
982 If inquiring about some other buffer, this swaps out any values
983 for that buffer, making the alist up to date automatically. */
984 val
= find_symbol_value (XCAR (elt
));
985 /* Use the current buffer value only if buf is the current buffer. */
986 if (buf
!= current_buffer
)
989 /* If symbol is unbound, put just the symbol in the list. */
990 if (EQ (val
, Qunbound
))
991 result
= Fcons (XCAR (elt
), result
);
992 /* Otherwise, put (symbol . value) in the list. */
994 result
= Fcons (Fcons (XCAR (elt
), val
), result
);
1000 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
1001 Sbuffer_local_variables
, 0, 1, 0,
1002 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
1003 Most elements look like (SYMBOL . VALUE), describing one variable.
1004 For a symbol that is locally unbound, just the symbol appears in the value.
1005 Note that storing new VALUEs in these elements doesn't change the variables.
1006 No argument or nil as argument means use current buffer as BUFFER. */)
1008 register Lisp_Object buffer
;
1010 register struct buffer
*buf
;
1011 register Lisp_Object result
;
1014 buf
= current_buffer
;
1017 CHECK_BUFFER (buffer
);
1018 buf
= XBUFFER (buffer
);
1021 result
= buffer_lisp_local_variables (buf
);
1023 /* Add on all the variables stored in special slots. */
1027 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
1028 offset
< sizeof (struct buffer
);
1029 /* sizeof EMACS_INT == sizeof Lisp_Object */
1030 offset
+= (sizeof (EMACS_INT
)))
1032 idx
= PER_BUFFER_IDX (offset
);
1033 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1034 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1035 result
= Fcons (Fcons (PER_BUFFER_SYMBOL (offset
),
1036 PER_BUFFER_VALUE (buf
, offset
)),
1044 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1046 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1047 No argument or nil as argument means use current buffer as BUFFER. */)
1049 register Lisp_Object buffer
;
1051 register struct buffer
*buf
;
1053 buf
= current_buffer
;
1056 CHECK_BUFFER (buffer
);
1057 buf
= XBUFFER (buffer
);
1060 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1063 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1065 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1066 A non-nil FLAG means mark the buffer modified. */)
1068 register Lisp_Object flag
;
1070 register int already
;
1071 register Lisp_Object fn
;
1072 Lisp_Object buffer
, window
;
1074 #ifdef CLASH_DETECTION
1075 /* If buffer becoming modified, lock the file.
1076 If buffer becoming unmodified, unlock the file. */
1078 fn
= current_buffer
->file_truename
;
1079 /* Test buffer-file-name so that binding it to nil is effective. */
1080 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1082 already
= SAVE_MODIFF
< MODIFF
;
1083 if (!already
&& !NILP (flag
))
1085 else if (already
&& NILP (flag
))
1088 #endif /* CLASH_DETECTION */
1090 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1092 /* Set update_mode_lines only if buffer is displayed in some window.
1093 Packages like jit-lock or lazy-lock preserve a buffer's modified
1094 state by recording/restoring the state around blocks of code.
1095 Setting update_mode_lines makes redisplay consider all windows
1096 (on all frames). Stealth fontification of buffers not displayed
1097 would incur additional redisplay costs if we'd set
1098 update_modes_lines unconditionally.
1100 Ideally, I think there should be another mechanism for fontifying
1101 buffers without "modifying" buffers, or redisplay should be
1102 smarter about updating the `*' in mode lines. --gerd */
1103 XSETBUFFER (buffer
, current_buffer
);
1104 window
= Fget_buffer_window (buffer
, Qt
);
1105 if (WINDOWP (window
))
1107 ++update_mode_lines
;
1108 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1114 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1115 Srestore_buffer_modified_p
, 1, 1, 0,
1116 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1117 It is not ensured that mode lines will be updated to show the modified
1118 state of the current buffer. Use with care. */)
1122 #ifdef CLASH_DETECTION
1125 /* If buffer becoming modified, lock the file.
1126 If buffer becoming unmodified, unlock the file. */
1128 fn
= current_buffer
->file_truename
;
1129 /* Test buffer-file-name so that binding it to nil is effective. */
1130 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1132 int already
= SAVE_MODIFF
< MODIFF
;
1133 if (!already
&& !NILP (flag
))
1135 else if (already
&& NILP (flag
))
1138 #endif /* CLASH_DETECTION */
1140 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1144 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1146 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1147 Each buffer has a tick counter which is incremented each time the text in
1148 that buffer is changed. It wraps around occasionally.
1149 No argument or nil as argument means use current buffer as BUFFER. */)
1151 register Lisp_Object buffer
;
1153 register struct buffer
*buf
;
1155 buf
= current_buffer
;
1158 CHECK_BUFFER (buffer
);
1159 buf
= XBUFFER (buffer
);
1162 return make_number (BUF_MODIFF (buf
));
1165 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1166 "sRename buffer (to new name): \nP",
1167 doc
: /* Change current buffer's name to NEWNAME (a string).
1168 If second arg UNIQUE is nil or omitted, it is an error if a
1169 buffer named NEWNAME already exists.
1170 If UNIQUE is non-nil, come up with a new name using
1171 `generate-new-buffer-name'.
1172 Interactively, you can set UNIQUE with a prefix argument.
1173 We return the name we actually gave the buffer.
1174 This does not change the name of the visited file (if any). */)
1176 register Lisp_Object newname
, unique
;
1178 register Lisp_Object tem
, buf
;
1180 CHECK_STRING (newname
);
1182 if (SCHARS (newname
) == 0)
1183 error ("Empty string is invalid as a buffer name");
1185 tem
= Fget_buffer (newname
);
1188 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1189 rename the buffer automatically so you can create another
1190 with the original name. It makes UNIQUE equivalent to
1191 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1192 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1193 return current_buffer
->name
;
1195 newname
= Fgenerate_new_buffer_name (newname
, current_buffer
->name
);
1197 error ("Buffer name `%s' is in use", SDATA (newname
));
1200 current_buffer
->name
= newname
;
1202 /* Catch redisplay's attention. Unless we do this, the mode lines for
1203 any windows displaying current_buffer will stay unchanged. */
1204 update_mode_lines
++;
1206 XSETBUFFER (buf
, current_buffer
);
1207 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1208 if (NILP (current_buffer
->filename
)
1209 && !NILP (current_buffer
->auto_save_file_name
))
1210 call0 (intern ("rename-auto-save-file"));
1211 /* Refetch since that last call may have done GC. */
1212 return current_buffer
->name
;
1215 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1216 doc
: /* Return most recently selected buffer other than BUFFER.
1217 Buffers not visible in windows are preferred to visible buffers,
1218 unless optional second argument VISIBLE-OK is non-nil.
1219 If the optional third argument FRAME is non-nil, use that frame's
1220 buffer list instead of the selected frame's buffer list.
1221 If no other buffer exists, the buffer `*scratch*' is returned.
1222 If BUFFER is omitted or nil, some interesting buffer is returned. */)
1223 (buffer
, visible_ok
, frame
)
1224 register Lisp_Object buffer
, visible_ok
, frame
;
1226 Lisp_Object
Fset_buffer_major_mode ();
1227 register Lisp_Object tail
, buf
, notsogood
, tem
, pred
, add_ons
;
1231 frame
= selected_frame
;
1233 tail
= Vbuffer_alist
;
1234 pred
= frame_buffer_predicate (frame
);
1236 /* Consider buffers that have been seen in the selected frame
1237 before other buffers. */
1239 tem
= frame_buffer_list (frame
);
1243 if (BUFFERP (XCAR (tem
)))
1244 add_ons
= Fcons (Fcons (Qnil
, XCAR (tem
)), add_ons
);
1247 tail
= nconc2 (Fnreverse (add_ons
), tail
);
1249 for (; CONSP (tail
); tail
= XCDR (tail
))
1251 buf
= Fcdr (XCAR (tail
));
1252 if (EQ (buf
, buffer
))
1256 if (NILP (XBUFFER (buf
)->name
))
1258 if (SREF (XBUFFER (buf
)->name
, 0) == ' ')
1260 /* If the selected frame has a buffer_predicate,
1261 disregard buffers that don't fit the predicate. */
1264 tem
= call1 (pred
, buf
);
1269 if (NILP (visible_ok
))
1270 tem
= Fget_buffer_window (buf
, Qvisible
);
1275 if (NILP (notsogood
))
1278 if (!NILP (notsogood
))
1280 buf
= Fget_buffer (build_string ("*scratch*"));
1283 buf
= Fget_buffer_create (build_string ("*scratch*"));
1284 Fset_buffer_major_mode (buf
);
1289 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1291 doc
: /* Start keeping undo information for buffer BUFFER.
1292 No argument or nil as argument means do this for the current buffer. */)
1294 register Lisp_Object buffer
;
1296 Lisp_Object real_buffer
;
1299 XSETBUFFER (real_buffer
, current_buffer
);
1302 real_buffer
= Fget_buffer (buffer
);
1303 if (NILP (real_buffer
))
1307 if (EQ (XBUFFER (real_buffer
)->undo_list
, Qt
))
1308 XBUFFER (real_buffer
)->undo_list
= Qnil
;
1314 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
1315 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
1316 The buffer being killed will be current while the hook is running.\n\
1319 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 1, 1, "bKill buffer: ",
1320 doc
: /* Kill the buffer BUFFER.
1321 The argument may be a buffer or may be the name of a buffer.
1322 An argument of nil means kill the current buffer.
1324 Value is t if the buffer is actually killed, nil if user says no.
1326 The value of `kill-buffer-hook' (which may be local to that buffer),
1327 if not void, is a list of functions to be called, with no arguments,
1328 before the buffer is actually killed. The buffer to be killed is current
1329 when the hook functions are called.
1331 Any processes that have this buffer as the `process-buffer' are killed
1337 register struct buffer
*b
;
1338 register Lisp_Object tem
;
1339 register struct Lisp_Marker
*m
;
1340 struct gcpro gcpro1
;
1343 buf
= Fcurrent_buffer ();
1345 buf
= Fget_buffer (buffer
);
1351 /* Avoid trouble for buffer already dead. */
1355 /* Query if the buffer is still modified. */
1356 if (INTERACTIVE
&& !NILP (b
->filename
)
1357 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1360 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1361 b
->name
, make_number (0)));
1367 /* Run hooks with the buffer to be killed the current buffer. */
1369 int count
= SPECPDL_INDEX ();
1370 Lisp_Object arglist
[1];
1372 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1373 set_buffer_internal (b
);
1375 /* First run the query functions; if any query is answered no,
1376 don't kill the buffer. */
1377 arglist
[0] = Qkill_buffer_query_functions
;
1378 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1380 return unbind_to (count
, Qnil
);
1382 /* Then run the hooks. */
1383 Frun_hooks (1, &Qkill_buffer_hook
);
1384 unbind_to (count
, Qnil
);
1387 /* We have no more questions to ask. Verify that it is valid
1388 to kill the buffer. This must be done after the questions
1389 since anything can happen within do_yes_or_no_p. */
1391 /* Don't kill the minibuffer now current. */
1392 if (EQ (buf
, XWINDOW (minibuf_window
)->buffer
))
1398 /* When we kill a base buffer, kill all its indirect buffers.
1399 We do it at this stage so nothing terrible happens if they
1400 ask questions or their hooks get errors. */
1401 if (! b
->base_buffer
)
1403 struct buffer
*other
;
1407 for (other
= all_buffers
; other
; other
= other
->next
)
1408 /* all_buffers contains dead buffers too;
1409 don't re-kill them. */
1410 if (other
->base_buffer
== b
&& !NILP (other
->name
))
1413 XSETBUFFER (buf
, other
);
1420 /* Make this buffer not be current.
1421 In the process, notice if this is the sole visible buffer
1422 and give up if so. */
1423 if (b
== current_buffer
)
1425 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1427 if (b
== current_buffer
)
1431 /* Notice if the buffer to kill is the sole visible buffer
1432 when we're currently in the mini-buffer, and give up if so. */
1433 XSETBUFFER (tem
, current_buffer
);
1434 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
))
1436 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1441 /* Now there is no question: we can kill the buffer. */
1443 #ifdef CLASH_DETECTION
1444 /* Unlock this buffer's file, if it is locked. */
1446 #endif /* CLASH_DETECTION */
1448 kill_buffer_processes (buf
);
1449 clear_charpos_cache (b
);
1451 tem
= Vinhibit_quit
;
1453 replace_buffer_in_all_windows (buf
);
1454 Vbuffer_alist
= Fdelq (Frassq (buf
, Vbuffer_alist
), Vbuffer_alist
);
1455 frames_discard_buffer (buf
);
1456 Vinhibit_quit
= tem
;
1458 /* Delete any auto-save file, if we saved it in this session.
1459 But not if the buffer is modified. */
1460 if (STRINGP (b
->auto_save_file_name
)
1461 && b
->auto_save_modified
!= 0
1462 && BUF_SAVE_MODIFF (b
) < b
->auto_save_modified
1463 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1464 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1467 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
1469 internal_delete_file (b
->auto_save_file_name
);
1474 /* Unchain all markers that belong to this indirect buffer.
1475 Don't unchain the markers that belong to the base buffer
1476 or its other indirect buffers. */
1477 for (m
= BUF_MARKERS (b
); m
; )
1479 struct Lisp_Marker
*next
= m
->next
;
1487 /* Unchain all markers of this buffer and its indirect buffers.
1488 and leave them pointing nowhere. */
1489 for (m
= BUF_MARKERS (b
); m
; )
1491 struct Lisp_Marker
*next
= m
->next
;
1496 BUF_MARKERS (b
) = NULL
;
1497 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1499 /* Perhaps we should explicitly free the interval tree here... */
1502 /* Reset the local variables, so that this buffer's local values
1503 won't be protected from GC. They would be protected
1504 if they happened to remain encached in their symbols.
1505 This gets rid of them for certain. */
1506 swap_out_buffer_local_variables (b
);
1507 reset_buffer_local_variables (b
, 1);
1512 if (! b
->base_buffer
)
1513 free_buffer_text (b
);
1515 if (b
->newline_cache
)
1517 free_region_cache (b
->newline_cache
);
1518 b
->newline_cache
= 0;
1520 if (b
->width_run_cache
)
1522 free_region_cache (b
->width_run_cache
);
1523 b
->width_run_cache
= 0;
1525 b
->width_table
= Qnil
;
1527 b
->undo_list
= Qnil
;
1532 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
1533 we do this each time BUF is selected visibly, the more recently
1534 selected buffers are always closer to the front of the list. This
1535 means that other_buffer is more likely to choose a relevant buffer. */
1541 register Lisp_Object link
, prev
;
1543 frame
= selected_frame
;
1546 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCDR (link
))
1548 if (EQ (XCDR (XCAR (link
)), buf
))
1553 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
1554 we cannot use Fdelq itself here because it allows quitting. */
1557 Vbuffer_alist
= XCDR (Vbuffer_alist
);
1559 XSETCDR (prev
, XCDR (XCDR (prev
)));
1561 XSETCDR (link
, Vbuffer_alist
);
1562 Vbuffer_alist
= link
;
1564 /* Effectively do a delq on buried_buffer_list. */
1567 for (link
= XFRAME (frame
)->buried_buffer_list
; CONSP (link
);
1570 if (EQ (XCAR (link
), buf
))
1573 XFRAME (frame
)->buried_buffer_list
= XCDR (link
);
1575 XSETCDR (prev
, XCDR (XCDR (prev
)));
1581 /* Now move this buffer to the front of frame_buffer_list also. */
1584 for (link
= frame_buffer_list (frame
); CONSP (link
);
1587 if (EQ (XCAR (link
), buf
))
1592 /* Effectively do delq. */
1597 set_frame_buffer_list (frame
,
1598 XCDR (frame_buffer_list (frame
)));
1600 XSETCDR (prev
, XCDR (XCDR (prev
)));
1602 XSETCDR (link
, frame_buffer_list (frame
));
1603 set_frame_buffer_list (frame
, link
);
1606 set_frame_buffer_list (frame
, Fcons (buf
, frame_buffer_list (frame
)));
1609 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1610 doc
: /* Set an appropriate major mode for BUFFER.
1611 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1612 according to `default-major-mode'.
1613 Use this function before selecting the buffer, since it may need to inspect
1614 the current buffer's major mode. */)
1619 Lisp_Object function
;
1621 if (STRINGP (XBUFFER (buffer
)->name
)
1622 && strcmp (SDATA (XBUFFER (buffer
)->name
), "*scratch*") == 0)
1623 function
= find_symbol_value (intern ("initial-major-mode"));
1626 function
= buffer_defaults
.major_mode
;
1628 && NILP (Fget (current_buffer
->major_mode
, Qmode_class
)))
1629 function
= current_buffer
->major_mode
;
1632 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1635 count
= SPECPDL_INDEX ();
1637 /* To select a nonfundamental mode,
1638 select the buffer temporarily and then call the mode function. */
1640 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1642 Fset_buffer (buffer
);
1645 return unbind_to (count
, Qnil
);
1648 /* If switching buffers in WINDOW would be an error, return
1649 a C string saying what the error would be. */
1652 no_switch_window (window
)
1656 if (EQ (minibuf_window
, window
))
1657 return "Cannot switch buffers in minibuffer window";
1658 tem
= Fwindow_dedicated_p (window
);
1660 return "Cannot switch buffers in a dedicated window";
1664 /* Switch to buffer BUFFER in the selected window.
1665 If NORECORD is non-nil, don't call record_buffer. */
1668 switch_to_buffer_1 (buffer
, norecord
)
1669 Lisp_Object buffer
, norecord
;
1671 register Lisp_Object buf
;
1674 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1677 buf
= Fget_buffer (buffer
);
1680 buf
= Fget_buffer_create (buffer
);
1681 Fset_buffer_major_mode (buf
);
1685 if (NILP (norecord
))
1686 record_buffer (buf
);
1688 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
1689 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
1696 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2, "BSwitch to buffer: ",
1697 doc
: /* Select buffer BUFFER in the current window.
1698 If BUFFER does not identify an existing buffer,
1699 then this function creates a buffer with that name.
1701 When called from Lisp, BUFFER may be a buffer, a string \(a buffer name),
1702 or nil. If BUFFER is nil, then this function chooses a buffer
1703 using `other-buffer'.
1704 Optional second arg NORECORD non-nil means
1705 do not put this buffer at the front of the list of recently selected ones.
1706 This function returns the buffer it switched to.
1708 WARNING: This is NOT the way to work on another buffer temporarily
1709 within a Lisp program! Use `set-buffer' instead. That avoids messing with
1710 the window-buffer correspondences. */)
1712 Lisp_Object buffer
, norecord
;
1716 if (EQ (buffer
, Fwindow_buffer (selected_window
)))
1718 /* Basically a NOP. Avoid signalling an error in the case where
1719 the selected window is dedicated, or a minibuffer. */
1721 /* But do put this buffer at the front of the buffer list,
1722 unless that has been inhibited. Note that even if
1723 BUFFER is at the front of the main buffer-list already,
1724 we still want to move it to the front of the frame's buffer list. */
1725 if (NILP (norecord
))
1726 record_buffer (buffer
);
1727 return Fset_buffer (buffer
);
1730 err
= no_switch_window (selected_window
);
1731 if (err
) error (err
);
1733 return switch_to_buffer_1 (buffer
, norecord
);
1736 DEFUN ("pop-to-buffer", Fpop_to_buffer
, Spop_to_buffer
, 1, 3, 0,
1737 doc
: /* Select buffer BUFFER in some window, preferably a different one.
1738 BUFFER may be a buffer, a string \(a buffer name), or nil.
1739 If BUFFER is a string which is not the name of an existing buffer,
1740 then this function creates a buffer with that name.
1741 If BUFFER is nil, then it chooses some other buffer.
1742 If `pop-up-windows' is non-nil, windows can be split to do this.
1743 If optional second arg OTHER-WINDOW is non-nil, insist on finding another
1744 window even if BUFFER is already visible in the selected window,
1745 and ignore `same-window-regexps' and `same-window-buffer-names'.
1746 This function returns the buffer it switched to.
1747 This uses the function `display-buffer' as a subroutine; see the documentation
1748 of `display-buffer' for additional customization information.
1750 Optional third arg NORECORD non-nil means
1751 do not put this buffer at the front of the list of recently selected ones. */)
1752 (buffer
, other_window
, norecord
)
1753 Lisp_Object buffer
, other_window
, norecord
;
1755 register Lisp_Object buf
;
1757 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1760 buf
= Fget_buffer (buffer
);
1763 buf
= Fget_buffer_create (buffer
);
1764 Fset_buffer_major_mode (buf
);
1768 Fselect_window (Fdisplay_buffer (buf
, other_window
, Qnil
), norecord
);
1772 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1773 doc
: /* Return the current buffer as a Lisp object. */)
1776 register Lisp_Object buf
;
1777 XSETBUFFER (buf
, current_buffer
);
1781 /* Set the current buffer to B.
1783 We previously set windows_or_buffers_changed here to invalidate
1784 global unchanged information in beg_unchanged and end_unchanged.
1785 This is no longer necessary because we now compute unchanged
1786 information on a buffer-basis. Every action affecting other
1787 windows than the selected one requires a select_window at some
1788 time, and that increments windows_or_buffers_changed. */
1791 set_buffer_internal (b
)
1792 register struct buffer
*b
;
1794 if (current_buffer
!= b
)
1795 set_buffer_internal_1 (b
);
1798 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1799 This is used by redisplay. */
1802 set_buffer_internal_1 (b
)
1803 register struct buffer
*b
;
1805 register struct buffer
*old_buf
;
1806 register Lisp_Object tail
, valcontents
;
1809 #ifdef USE_MMAP_FOR_BUFFERS
1810 if (b
->text
->beg
== NULL
)
1811 enlarge_buffer_text (b
, 0);
1812 #endif /* USE_MMAP_FOR_BUFFERS */
1814 if (current_buffer
== b
)
1817 old_buf
= current_buffer
;
1819 last_known_column_point
= -1; /* invalidate indentation cache */
1823 /* Put the undo list back in the base buffer, so that it appears
1824 that an indirect buffer shares the undo list of its base. */
1825 if (old_buf
->base_buffer
)
1826 old_buf
->base_buffer
->undo_list
= old_buf
->undo_list
;
1828 /* If the old current buffer has markers to record PT, BEGV and ZV
1829 when it is not current, update them now. */
1830 if (! NILP (old_buf
->pt_marker
))
1833 XSETBUFFER (obuf
, old_buf
);
1834 set_marker_both (old_buf
->pt_marker
, obuf
,
1835 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1837 if (! NILP (old_buf
->begv_marker
))
1840 XSETBUFFER (obuf
, old_buf
);
1841 set_marker_both (old_buf
->begv_marker
, obuf
,
1842 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1844 if (! NILP (old_buf
->zv_marker
))
1847 XSETBUFFER (obuf
, old_buf
);
1848 set_marker_both (old_buf
->zv_marker
, obuf
,
1849 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1853 /* Get the undo list from the base buffer, so that it appears
1854 that an indirect buffer shares the undo list of its base. */
1856 b
->undo_list
= b
->base_buffer
->undo_list
;
1858 /* If the new current buffer has markers to record PT, BEGV and ZV
1859 when it is not current, fetch them now. */
1860 if (! NILP (b
->pt_marker
))
1862 BUF_PT (b
) = marker_position (b
->pt_marker
);
1863 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1865 if (! NILP (b
->begv_marker
))
1867 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1868 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1870 if (! NILP (b
->zv_marker
))
1872 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1873 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1876 /* Look down buffer's list of local Lisp variables
1877 to find and update any that forward into C variables. */
1879 for (tail
= b
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1881 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1882 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1883 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1884 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1885 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1886 /* Just reference the variable
1887 to cause it to become set for this buffer. */
1888 Fsymbol_value (XCAR (XCAR (tail
)));
1891 /* Do the same with any others that were local to the previous buffer */
1894 for (tail
= old_buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1896 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1897 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1898 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1899 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1900 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1901 /* Just reference the variable
1902 to cause it to become set for this buffer. */
1903 Fsymbol_value (XCAR (XCAR (tail
)));
1907 /* Switch to buffer B temporarily for redisplay purposes.
1908 This avoids certain things that don't need to be done within redisplay. */
1914 register struct buffer
*old_buf
;
1916 if (current_buffer
== b
)
1919 old_buf
= current_buffer
;
1924 /* If the old current buffer has markers to record PT, BEGV and ZV
1925 when it is not current, update them now. */
1926 if (! NILP (old_buf
->pt_marker
))
1929 XSETBUFFER (obuf
, old_buf
);
1930 set_marker_both (old_buf
->pt_marker
, obuf
,
1931 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1933 if (! NILP (old_buf
->begv_marker
))
1936 XSETBUFFER (obuf
, old_buf
);
1937 set_marker_both (old_buf
->begv_marker
, obuf
,
1938 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1940 if (! NILP (old_buf
->zv_marker
))
1943 XSETBUFFER (obuf
, old_buf
);
1944 set_marker_both (old_buf
->zv_marker
, obuf
,
1945 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1949 /* If the new current buffer has markers to record PT, BEGV and ZV
1950 when it is not current, fetch them now. */
1951 if (! NILP (b
->pt_marker
))
1953 BUF_PT (b
) = marker_position (b
->pt_marker
);
1954 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1956 if (! NILP (b
->begv_marker
))
1958 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1959 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1961 if (! NILP (b
->zv_marker
))
1963 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1964 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1968 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
1969 doc
: /* Make the buffer BUFFER current for editing operations.
1970 BUFFER may be a buffer or the name of an existing buffer.
1971 See also `save-excursion' when you want to make a buffer current temporarily.
1972 This function does not display the buffer, so its effect ends
1973 when the current command terminates.
1974 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently. */)
1976 register Lisp_Object buffer
;
1978 register Lisp_Object buf
;
1979 buf
= Fget_buffer (buffer
);
1982 if (NILP (XBUFFER (buf
)->name
))
1983 error ("Selecting deleted buffer");
1984 set_buffer_internal (XBUFFER (buf
));
1988 /* Set the current buffer to BUFFER provided it is alive. */
1991 set_buffer_if_live (buffer
)
1994 if (! NILP (XBUFFER (buffer
)->name
))
1995 Fset_buffer (buffer
);
1999 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
2000 Sbarf_if_buffer_read_only
, 0, 0, 0,
2001 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2004 if (!NILP (current_buffer
->read_only
)
2005 && NILP (Vinhibit_read_only
))
2006 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
2010 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
2011 doc
: /* Put BUFFER at the end of the list of all buffers.
2012 There it is the least likely candidate for `other-buffer' to return;
2013 thus, the least likely buffer for \\[switch-to-buffer] to select by default.
2014 You can specify a buffer name as BUFFER, or an actual buffer object.
2015 If BUFFER is nil or omitted, bury the current buffer.
2016 Also, if BUFFER is nil or omitted, remove the current buffer from the
2017 selected window if it is displayed there. */)
2019 register Lisp_Object buffer
;
2021 /* Figure out what buffer we're going to bury. */
2025 XSETBUFFER (buffer
, current_buffer
);
2027 tem
= Fwindow_buffer (selected_window
);
2028 /* If we're burying the current buffer, unshow it. */
2029 if (EQ (buffer
, tem
))
2031 if (NILP (Fwindow_dedicated_p (selected_window
)))
2032 Fswitch_to_buffer (Fother_buffer (buffer
, Qnil
, Qnil
), Qnil
);
2033 else if (NILP (XWINDOW (selected_window
)->parent
))
2034 Ficonify_frame (Fwindow_frame (selected_window
));
2036 Fdelete_window (selected_window
);
2043 buf1
= Fget_buffer (buffer
);
2049 /* Move buffer to the end of the buffer list. Do nothing if the
2050 buffer is killed. */
2051 if (!NILP (XBUFFER (buffer
)->name
))
2053 Lisp_Object aelt
, link
;
2055 aelt
= Frassq (buffer
, Vbuffer_alist
);
2056 link
= Fmemq (aelt
, Vbuffer_alist
);
2057 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2058 XSETCDR (link
, Qnil
);
2059 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
2061 XFRAME (selected_frame
)->buffer_list
2062 = Fdelq (buffer
, XFRAME (selected_frame
)->buffer_list
);
2063 XFRAME (selected_frame
)->buried_buffer_list
2064 = Fcons (buffer
, Fdelq (buffer
, XFRAME (selected_frame
)->buried_buffer_list
));
2070 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2071 doc
: /* Delete the entire contents of the current buffer.
2072 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2073 so the buffer is truly empty after this. */)
2080 current_buffer
->last_window_start
= 1;
2081 /* Prevent warnings, or suspension of auto saving, that would happen
2082 if future size is less than past size. Use of erase-buffer
2083 implies that the future text is not really related to the past text. */
2084 XSETFASTINT (current_buffer
->save_length
, 0);
2089 validate_region (b
, e
)
2090 register Lisp_Object
*b
, *e
;
2092 CHECK_NUMBER_COERCE_MARKER (*b
);
2093 CHECK_NUMBER_COERCE_MARKER (*e
);
2095 if (XINT (*b
) > XINT (*e
))
2098 tem
= *b
; *b
= *e
; *e
= tem
;
2101 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
2102 && XINT (*e
) <= ZV
))
2103 args_out_of_range (*b
, *e
);
2106 /* Advance BYTE_POS up to a character boundary
2107 and return the adjusted position. */
2110 advance_to_char_boundary (byte_pos
)
2115 if (byte_pos
== BEG
)
2116 /* Beginning of buffer is always a character boundary. */
2119 c
= FETCH_BYTE (byte_pos
);
2120 if (! CHAR_HEAD_P (c
))
2122 /* We should advance BYTE_POS only when C is a constituent of a
2123 multibyte sequence. */
2124 int orig_byte_pos
= byte_pos
;
2129 c
= FETCH_BYTE (byte_pos
);
2131 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2133 if (byte_pos
< orig_byte_pos
)
2134 byte_pos
= orig_byte_pos
;
2135 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2136 surely advance to the correct character boundary. If C is
2137 not, BYTE_POS was unchanged. */
2143 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2145 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2146 If FLAG is t, this makes the buffer a multibyte buffer.
2147 If FLAG is nil, this makes the buffer a single-byte buffer.
2148 The buffer contents remain unchanged as a sequence of bytes
2149 but the contents viewed as characters do change.
2150 If the multibyte flag was really changed, undo information of the
2151 current buffer is cleared. */)
2155 struct Lisp_Marker
*tail
, *markers
;
2156 struct buffer
*other
;
2158 int narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2159 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2160 Lisp_Object old_undo
= current_buffer
->undo_list
;
2161 struct gcpro gcpro1
;
2163 if (current_buffer
->base_buffer
)
2164 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2166 /* Do nothing if nothing actually changes. */
2167 if (NILP (flag
) == NILP (current_buffer
->enable_multibyte_characters
))
2172 /* Don't record these buffer changes. We will put a special undo entry
2174 current_buffer
->undo_list
= Qt
;
2176 /* If the cached position is for this buffer, clear it out. */
2177 clear_charpos_cache (current_buffer
);
2180 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2182 begv
= BEGV
, zv
= ZV
;
2192 /* Do this first, so it can use CHAR_TO_BYTE
2193 to calculate the old correspondences. */
2194 set_intervals_multibyte (0);
2196 current_buffer
->enable_multibyte_characters
= Qnil
;
2202 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2205 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2206 tail
->charpos
= tail
->bytepos
;
2208 /* Convert multibyte form of 8-bit characters to unibyte. */
2223 if (MULTIBYTE_STR_AS_UNIBYTE_P (p
, bytes
))
2224 p
+= bytes
, pos
+= bytes
;
2227 c
= STRING_CHAR (p
, stop
- pos
);
2228 /* Delete all bytes for this 8-bit character but the
2229 last one, and change the last one to the charcter
2232 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2244 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2252 /* Be sure not to have a multibyte sequence striding over the GAP.
2253 Ex: We change this: "...abc\201 _GAP_ \241def..."
2254 to: "...abc _GAP_ \201\241def..." */
2256 if (GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2257 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2259 unsigned char *p
= GPT_ADDR
- 1;
2261 while (! CHAR_HEAD_P (*p
) && p
> BEG_ADDR
) p
--;
2262 if (BASE_LEADING_CODE_P (*p
))
2264 int new_gpt
= GPT_BYTE
- (GPT_ADDR
- p
);
2266 move_gap_both (new_gpt
, new_gpt
);
2270 /* Make the buffer contents valid as multibyte by converting
2271 8-bit characters to multibyte form. */
2287 if (UNIBYTE_STR_AS_MULTIBYTE_P (p
, stop
- pos
, bytes
))
2288 p
+= bytes
, pos
+= bytes
;
2291 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2293 bytes
= CHAR_STRING (*p
, tmp
);
2295 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2297 insert_1_both (tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2298 /* Now the gap is after the just inserted data. */
2315 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2317 /* Do this first, so that chars_in_text asks the right question.
2318 set_intervals_multibyte needs it too. */
2319 current_buffer
->enable_multibyte_characters
= Qt
;
2321 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2322 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2324 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2326 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2327 if (BEGV_BYTE
> GPT_BYTE
)
2328 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2330 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2332 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2333 if (ZV_BYTE
> GPT_BYTE
)
2334 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2336 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2339 int pt_byte
= advance_to_char_boundary (PT_BYTE
);
2342 if (pt_byte
> GPT_BYTE
)
2343 pt
= chars_in_text (GAP_END_ADDR
, pt_byte
- GPT_BYTE
) + GPT
;
2345 pt
= chars_in_text (BEG_ADDR
, pt_byte
- BEG_BYTE
) + BEG
;
2346 TEMP_SET_PT_BOTH (pt
, pt_byte
);
2349 tail
= markers
= BUF_MARKERS (current_buffer
);
2351 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2352 getting confused by the markers that have not yet been updated.
2353 It is also a signal that it should never create a marker. */
2354 BUF_MARKERS (current_buffer
) = NULL
;
2356 for (; tail
; tail
= tail
->next
)
2358 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2359 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2362 /* Make sure no markers were put on the chain
2363 while the chain value was incorrect. */
2364 if (BUF_MARKERS (current_buffer
))
2367 BUF_MARKERS (current_buffer
) = markers
;
2369 /* Do this last, so it can calculate the new correspondences
2370 between chars and bytes. */
2371 set_intervals_multibyte (1);
2374 if (!EQ (old_undo
, Qt
))
2376 /* Represent all the above changes by a special undo entry. */
2377 extern Lisp_Object Qapply
;
2378 current_buffer
->undo_list
= Fcons (list3 (Qapply
,
2379 intern ("set-buffer-multibyte"),
2380 NILP (flag
) ? Qt
: Qnil
),
2386 /* Changing the multibyteness of a buffer means that all windows
2387 showing that buffer must be updated thoroughly. */
2388 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2389 ++windows_or_buffers_changed
;
2391 /* Copy this buffer's new multibyte status
2392 into all of its indirect buffers. */
2393 for (other
= all_buffers
; other
; other
= other
->next
)
2394 if (other
->base_buffer
== current_buffer
&& !NILP (other
->name
))
2396 other
->enable_multibyte_characters
2397 = current_buffer
->enable_multibyte_characters
;
2398 other
->prevent_redisplay_optimizations_p
= 1;
2401 /* Restore the modifiedness of the buffer. */
2402 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2403 Fset_buffer_modified_p (Qnil
);
2406 /* Update coding systems of this buffer's process (if any). */
2408 Lisp_Object process
;
2410 process
= Fget_buffer_process (Fcurrent_buffer ());
2411 if (PROCESSP (process
))
2412 setup_process_coding_systems (process
);
2414 #endif /* subprocesses */
2419 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
2421 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2422 Most local variable bindings are eliminated so that the default values
2423 become effective once more. Also, the syntax table is set from
2424 `standard-syntax-table', the local keymap is set to nil,
2425 and the abbrev table from `fundamental-mode-abbrev-table'.
2426 This function also forces redisplay of the mode line.
2428 Every function to select a new major mode starts by
2429 calling this function.
2431 As a special exception, local variables whose names have
2432 a non-nil `permanent-local' property are not eliminated by this function.
2434 The first thing this function does is run
2435 the normal hook `change-major-mode-hook'. */)
2438 register Lisp_Object alist
, sym
, tem
;
2441 if (!NILP (Vrun_hooks
))
2442 call1 (Vrun_hooks
, Qchange_major_mode_hook
);
2443 oalist
= current_buffer
->local_var_alist
;
2445 /* Make sure none of the bindings in oalist
2446 remain swapped in, in their symbols. */
2448 swap_out_buffer_local_variables (current_buffer
);
2450 /* Actually eliminate all local bindings of this buffer. */
2452 reset_buffer_local_variables (current_buffer
, 0);
2454 /* Any which are supposed to be permanent,
2455 make local again, with the same values they had. */
2457 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2459 sym
= XCAR (XCAR (alist
));
2460 tem
= Fget (sym
, Qpermanent_local
);
2463 Fmake_local_variable (sym
);
2464 Fset (sym
, XCDR (XCAR (alist
)));
2468 /* Force mode-line redisplay. Useful here because all major mode
2469 commands call this function. */
2470 update_mode_lines
++;
2475 /* Make sure no local variables remain set up with buffer B
2476 for their current values. */
2479 swap_out_buffer_local_variables (b
)
2482 Lisp_Object oalist
, alist
, sym
, tem
, buffer
;
2484 XSETBUFFER (buffer
, b
);
2485 oalist
= b
->local_var_alist
;
2487 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2489 sym
= XCAR (XCAR (alist
));
2491 /* Need not do anything if some other buffer's binding is now encached. */
2492 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
;
2493 if (BUFFERP (tem
) && XBUFFER (tem
) == current_buffer
)
2495 /* Symbol is set up for this buffer's old local value.
2496 Set it up for the current buffer with the default value. */
2498 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->cdr
;
2499 /* Store the symbol's current value into the alist entry
2500 it is currently set up for. This is so that, if the
2501 local is marked permanent, and we make it local again
2502 later in Fkill_all_local_variables, we don't lose the value. */
2503 XSETCDR (XCAR (tem
),
2504 do_symval_forwarding (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->realvalue
));
2505 /* Switch to the symbol's default-value alist entry. */
2507 /* Mark it as current for buffer B. */
2508 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
= buffer
;
2509 /* Store the current value into any forwarding in the symbol. */
2510 store_symval_forwarding (sym
,
2511 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->realvalue
,
2517 /* Find all the overlays in the current buffer that contain position POS.
2518 Return the number found, and store them in a vector in *VEC_PTR.
2519 Store in *LEN_PTR the size allocated for the vector.
2520 Store in *NEXT_PTR the next position after POS where an overlay starts,
2521 or ZV if there are no more overlays between POS and ZV.
2522 Store in *PREV_PTR the previous position before POS where an overlay ends,
2523 or where an overlay starts which ends at or after POS;
2524 or BEGV if there are no such overlays from BEGV to POS.
2525 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2527 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2528 when this function is called.
2530 If EXTEND is non-zero, we make the vector bigger if necessary.
2531 If EXTEND is zero, we never extend the vector,
2532 and we store only as many overlays as will fit.
2533 But we still return the total number of overlays.
2535 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2536 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2537 default (BEGV or ZV). */
2540 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
, change_req
)
2543 Lisp_Object
**vec_ptr
;
2549 Lisp_Object overlay
, start
, end
;
2550 struct Lisp_Overlay
*tail
;
2553 Lisp_Object
*vec
= *vec_ptr
;
2556 int inhibit_storing
= 0;
2558 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2560 int startpos
, endpos
;
2562 XSETMISC (overlay
, tail
);
2564 start
= OVERLAY_START (overlay
);
2565 end
= OVERLAY_END (overlay
);
2566 endpos
= OVERLAY_POSITION (end
);
2573 startpos
= OVERLAY_POSITION (start
);
2574 /* This one ends at or after POS
2575 so its start counts for PREV_PTR if it's before POS. */
2576 if (prev
< startpos
&& startpos
< pos
)
2580 if (startpos
<= pos
)
2584 /* The supplied vector is full.
2585 Either make it bigger, or don't store any more in it. */
2588 /* Make it work with an initial len == 0. */
2593 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2597 inhibit_storing
= 1;
2600 if (!inhibit_storing
)
2602 /* Keep counting overlays even if we can't return them all. */
2605 else if (startpos
< next
)
2609 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2611 int startpos
, endpos
;
2613 XSETMISC (overlay
, tail
);
2615 start
= OVERLAY_START (overlay
);
2616 end
= OVERLAY_END (overlay
);
2617 startpos
= OVERLAY_POSITION (start
);
2620 if (startpos
< next
)
2624 endpos
= OVERLAY_POSITION (end
);
2631 /* Make it work with an initial len == 0. */
2636 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2640 inhibit_storing
= 1;
2643 if (!inhibit_storing
)
2647 if (startpos
< pos
&& startpos
> prev
)
2650 else if (endpos
< pos
&& endpos
> prev
)
2652 else if (endpos
== pos
&& startpos
> prev
2653 && (!change_req
|| startpos
< pos
))
2664 /* Find all the overlays in the current buffer that overlap the range BEG-END
2665 or are empty at BEG.
2667 Return the number found, and store them in a vector in *VEC_PTR.
2668 Store in *LEN_PTR the size allocated for the vector.
2669 Store in *NEXT_PTR the next position after POS where an overlay starts,
2670 or ZV if there are no more overlays.
2671 Store in *PREV_PTR the previous position before POS where an overlay ends,
2672 or BEGV if there are no previous overlays.
2673 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2675 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2676 when this function is called.
2678 If EXTEND is non-zero, we make the vector bigger if necessary.
2679 If EXTEND is zero, we never extend the vector,
2680 and we store only as many overlays as will fit.
2681 But we still return the total number of overlays. */
2684 overlays_in (beg
, end
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
2687 Lisp_Object
**vec_ptr
;
2692 Lisp_Object overlay
, ostart
, oend
;
2693 struct Lisp_Overlay
*tail
;
2696 Lisp_Object
*vec
= *vec_ptr
;
2699 int inhibit_storing
= 0;
2701 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2703 int startpos
, endpos
;
2705 XSETMISC (overlay
, tail
);
2707 ostart
= OVERLAY_START (overlay
);
2708 oend
= OVERLAY_END (overlay
);
2709 endpos
= OVERLAY_POSITION (oend
);
2716 startpos
= OVERLAY_POSITION (ostart
);
2717 /* Count an interval if it either overlaps the range
2718 or is empty at the start of the range. */
2719 if ((beg
< endpos
&& startpos
< end
)
2720 || (startpos
== endpos
&& beg
== endpos
))
2724 /* The supplied vector is full.
2725 Either make it bigger, or don't store any more in it. */
2728 /* Make it work with an initial len == 0. */
2733 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2737 inhibit_storing
= 1;
2740 if (!inhibit_storing
)
2742 /* Keep counting overlays even if we can't return them all. */
2745 else if (startpos
< next
)
2749 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2751 int startpos
, endpos
;
2753 XSETMISC (overlay
, tail
);
2755 ostart
= OVERLAY_START (overlay
);
2756 oend
= OVERLAY_END (overlay
);
2757 startpos
= OVERLAY_POSITION (ostart
);
2760 if (startpos
< next
)
2764 endpos
= OVERLAY_POSITION (oend
);
2765 /* Count an interval if it either overlaps the range
2766 or is empty at the start of the range. */
2767 if ((beg
< endpos
&& startpos
< end
)
2768 || (startpos
== endpos
&& beg
== endpos
))
2774 /* Make it work with an initial len == 0. */
2779 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2783 inhibit_storing
= 1;
2786 if (!inhibit_storing
)
2790 else if (endpos
< beg
&& endpos
> prev
)
2802 /* Return non-zero if there exists an overlay with a non-nil
2803 `mouse-face' property overlapping OVERLAY. */
2806 mouse_face_overlay_overlaps (overlay
)
2807 Lisp_Object overlay
;
2809 int start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2810 int end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2812 Lisp_Object
*v
, tem
;
2815 v
= (Lisp_Object
*) alloca (size
* sizeof *v
);
2816 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
2819 v
= (Lisp_Object
*) alloca (n
* sizeof *v
);
2820 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
2823 for (i
= 0; i
< n
; ++i
)
2824 if (!EQ (v
[i
], overlay
)
2825 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
2834 /* Fast function to just test if we're at an overlay boundary. */
2836 overlay_touches_p (pos
)
2839 Lisp_Object overlay
;
2840 struct Lisp_Overlay
*tail
;
2842 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2846 XSETMISC (overlay
,tail
);
2847 if (!GC_OVERLAYP (overlay
))
2850 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2853 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
2857 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2861 XSETMISC (overlay
, tail
);
2862 if (!GC_OVERLAYP (overlay
))
2865 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2868 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
2876 Lisp_Object overlay
;
2882 compare_overlays (v1
, v2
)
2883 const void *v1
, *v2
;
2885 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
2886 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
2887 if (s1
->priority
!= s2
->priority
)
2888 return s1
->priority
- s2
->priority
;
2889 if (s1
->beg
!= s2
->beg
)
2890 return s1
->beg
- s2
->beg
;
2891 if (s1
->end
!= s2
->end
)
2892 return s2
->end
- s1
->end
;
2896 /* Sort an array of overlays by priority. The array is modified in place.
2897 The return value is the new size; this may be smaller than the original
2898 size if some of the overlays were invalid or were window-specific. */
2900 sort_overlays (overlay_vec
, noverlays
, w
)
2901 Lisp_Object
*overlay_vec
;
2906 struct sortvec
*sortvec
;
2907 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
2909 /* Put the valid and relevant overlays into sortvec. */
2911 for (i
= 0, j
= 0; i
< noverlays
; i
++)
2914 Lisp_Object overlay
;
2916 overlay
= overlay_vec
[i
];
2917 if (OVERLAY_VALID (overlay
)
2918 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
2919 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
2921 /* If we're interested in a specific window, then ignore
2922 overlays that are limited to some other window. */
2927 window
= Foverlay_get (overlay
, Qwindow
);
2928 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2932 /* This overlay is good and counts: put it into sortvec. */
2933 sortvec
[j
].overlay
= overlay
;
2934 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2935 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2936 tem
= Foverlay_get (overlay
, Qpriority
);
2938 sortvec
[j
].priority
= XINT (tem
);
2940 sortvec
[j
].priority
= 0;
2946 /* Sort the overlays into the proper order: increasing priority. */
2949 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
2951 for (i
= 0; i
< noverlays
; i
++)
2952 overlay_vec
[i
] = sortvec
[i
].overlay
;
2958 Lisp_Object string
, string2
;
2965 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
2966 int size
; /* Allocated length of that array. */
2967 int used
; /* How much of the array is currently in use. */
2968 int bytes
; /* Total length of the strings in buf. */
2971 /* Buffers for storing information about the overlays touching a given
2972 position. These could be automatic variables in overlay_strings, but
2973 it's more efficient to hold onto the memory instead of repeatedly
2974 allocating and freeing it. */
2975 static struct sortstrlist overlay_heads
, overlay_tails
;
2976 static unsigned char *overlay_str_buf
;
2978 /* Allocated length of overlay_str_buf. */
2979 static int overlay_str_len
;
2981 /* A comparison function suitable for passing to qsort. */
2983 cmp_for_strings (as1
, as2
)
2986 struct sortstr
*s1
= (struct sortstr
*)as1
;
2987 struct sortstr
*s2
= (struct sortstr
*)as2
;
2988 if (s1
->size
!= s2
->size
)
2989 return s2
->size
- s1
->size
;
2990 if (s1
->priority
!= s2
->priority
)
2991 return s1
->priority
- s2
->priority
;
2996 record_overlay_string (ssl
, str
, str2
, pri
, size
)
2997 struct sortstrlist
*ssl
;
2998 Lisp_Object str
, str2
, pri
;
3003 if (ssl
->used
== ssl
->size
)
3009 ssl
->buf
= ((struct sortstr
*)
3010 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
3012 ssl
->buf
[ssl
->used
].string
= str
;
3013 ssl
->buf
[ssl
->used
].string2
= str2
;
3014 ssl
->buf
[ssl
->used
].size
= size
;
3015 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
3018 if (NILP (current_buffer
->enable_multibyte_characters
))
3019 nbytes
= SCHARS (str
);
3020 else if (! STRING_MULTIBYTE (str
))
3021 nbytes
= count_size_as_multibyte (SDATA (str
),
3024 nbytes
= SBYTES (str
);
3026 ssl
->bytes
+= nbytes
;
3030 if (NILP (current_buffer
->enable_multibyte_characters
))
3031 nbytes
= SCHARS (str2
);
3032 else if (! STRING_MULTIBYTE (str2
))
3033 nbytes
= count_size_as_multibyte (SDATA (str2
),
3036 nbytes
= SBYTES (str2
);
3038 ssl
->bytes
+= nbytes
;
3042 /* Return the concatenation of the strings associated with overlays that
3043 begin or end at POS, ignoring overlays that are specific to a window
3044 other than W. The strings are concatenated in the appropriate order:
3045 shorter overlays nest inside longer ones, and higher priority inside
3046 lower. Normally all of the after-strings come first, but zero-sized
3047 overlays have their after-strings ride along with the before-strings
3048 because it would look strange to print them inside-out.
3050 Returns the string length, and stores the contents indirectly through
3051 PSTR, if that variable is non-null. The string may be overwritten by
3052 subsequent calls. */
3055 overlay_strings (pos
, w
, pstr
)
3058 unsigned char **pstr
;
3060 Lisp_Object overlay
, window
, str
;
3061 struct Lisp_Overlay
*ov
;
3062 int startpos
, endpos
;
3063 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
3065 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3066 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3067 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3069 XSETMISC (overlay
, ov
);
3070 eassert (OVERLAYP (overlay
));
3072 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3073 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3076 if (endpos
!= pos
&& startpos
!= pos
)
3078 window
= Foverlay_get (overlay
, Qwindow
);
3079 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3082 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3083 record_overlay_string (&overlay_heads
, str
,
3085 ? Foverlay_get (overlay
, Qafter_string
)
3087 Foverlay_get (overlay
, Qpriority
),
3089 else if (endpos
== pos
3090 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3091 record_overlay_string (&overlay_tails
, str
, Qnil
,
3092 Foverlay_get (overlay
, Qpriority
),
3095 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3097 XSETMISC (overlay
, ov
);
3098 eassert (OVERLAYP (overlay
));
3100 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3101 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3104 if (endpos
!= pos
&& startpos
!= pos
)
3106 window
= Foverlay_get (overlay
, Qwindow
);
3107 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3110 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3111 record_overlay_string (&overlay_heads
, str
,
3113 ? Foverlay_get (overlay
, Qafter_string
)
3115 Foverlay_get (overlay
, Qpriority
),
3117 else if (endpos
== pos
3118 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3119 record_overlay_string (&overlay_tails
, str
, Qnil
,
3120 Foverlay_get (overlay
, Qpriority
),
3123 if (overlay_tails
.used
> 1)
3124 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3126 if (overlay_heads
.used
> 1)
3127 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3129 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3134 int total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3136 if (total
> overlay_str_len
)
3138 overlay_str_len
= total
;
3139 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
3142 p
= overlay_str_buf
;
3143 for (i
= overlay_tails
.used
; --i
>= 0;)
3146 tem
= overlay_tails
.buf
[i
].string
;
3147 nbytes
= copy_text (SDATA (tem
), p
,
3149 STRING_MULTIBYTE (tem
), multibyte
);
3152 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3155 tem
= overlay_heads
.buf
[i
].string
;
3156 nbytes
= copy_text (SDATA (tem
), p
,
3158 STRING_MULTIBYTE (tem
), multibyte
);
3160 tem
= overlay_heads
.buf
[i
].string2
;
3163 nbytes
= copy_text (SDATA (tem
), p
,
3165 STRING_MULTIBYTE (tem
), multibyte
);
3169 if (p
!= overlay_str_buf
+ total
)
3172 *pstr
= overlay_str_buf
;
3178 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3181 recenter_overlay_lists (buf
, pos
)
3185 Lisp_Object overlay
, beg
, end
;
3186 struct Lisp_Overlay
*prev
, *tail
, *next
;
3188 /* See if anything in overlays_before should move to overlays_after. */
3190 /* We don't strictly need prev in this loop; it should always be nil.
3191 But we use it for symmetry and in case that should cease to be true
3192 with some future change. */
3194 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3197 XSETMISC (overlay
, tail
);
3199 /* If the overlay is not valid, get rid of it. */
3200 if (!OVERLAY_VALID (overlay
))
3205 /* Splice the cons cell TAIL out of overlays_before. */
3209 buf
->overlays_before
= next
;
3215 beg
= OVERLAY_START (overlay
);
3216 end
= OVERLAY_END (overlay
);
3218 if (OVERLAY_POSITION (end
) > pos
)
3220 /* OVERLAY needs to be moved. */
3221 int where
= OVERLAY_POSITION (beg
);
3222 struct Lisp_Overlay
*other
, *other_prev
;
3224 /* Splice the cons cell TAIL out of overlays_before. */
3228 buf
->overlays_before
= next
;
3230 /* Search thru overlays_after for where to put it. */
3232 for (other
= buf
->overlays_after
; other
;
3233 other_prev
= other
, other
= other
->next
)
3235 Lisp_Object otherbeg
, otheroverlay
;
3237 XSETMISC (otheroverlay
, other
);
3238 eassert (OVERLAY_VALID (otheroverlay
));
3240 otherbeg
= OVERLAY_START (otheroverlay
);
3241 if (OVERLAY_POSITION (otherbeg
) >= where
)
3245 /* Add TAIL to overlays_after before OTHER. */
3248 other_prev
->next
= tail
;
3250 buf
->overlays_after
= tail
;
3254 /* We've reached the things that should stay in overlays_before.
3255 All the rest of overlays_before must end even earlier,
3260 /* See if anything in overlays_after should be in overlays_before. */
3262 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3265 XSETMISC (overlay
, tail
);
3267 /* If the overlay is not valid, get rid of it. */
3268 if (!OVERLAY_VALID (overlay
))
3273 /* Splice the cons cell TAIL out of overlays_after. */
3277 buf
->overlays_after
= next
;
3283 beg
= OVERLAY_START (overlay
);
3284 end
= OVERLAY_END (overlay
);
3286 /* Stop looking, when we know that nothing further
3287 can possibly end before POS. */
3288 if (OVERLAY_POSITION (beg
) > pos
)
3291 if (OVERLAY_POSITION (end
) <= pos
)
3293 /* OVERLAY needs to be moved. */
3294 int where
= OVERLAY_POSITION (end
);
3295 struct Lisp_Overlay
*other
, *other_prev
;
3297 /* Splice the cons cell TAIL out of overlays_after. */
3301 buf
->overlays_after
= next
;
3303 /* Search thru overlays_before for where to put it. */
3305 for (other
= buf
->overlays_before
; other
;
3306 other_prev
= other
, other
= other
->next
)
3308 Lisp_Object otherend
, otheroverlay
;
3310 XSETMISC (otheroverlay
, other
);
3311 eassert (OVERLAY_VALID (otheroverlay
));
3313 otherend
= OVERLAY_END (otheroverlay
);
3314 if (OVERLAY_POSITION (otherend
) <= where
)
3318 /* Add TAIL to overlays_before before OTHER. */
3321 other_prev
->next
= tail
;
3323 buf
->overlays_before
= tail
;
3328 buf
->overlay_center
= pos
;
3332 adjust_overlays_for_insert (pos
, length
)
3336 /* After an insertion, the lists are still sorted properly,
3337 but we may need to update the value of the overlay center. */
3338 if (current_buffer
->overlay_center
>= pos
)
3339 current_buffer
->overlay_center
+= length
;
3343 adjust_overlays_for_delete (pos
, length
)
3347 if (current_buffer
->overlay_center
< pos
)
3348 /* The deletion was to our right. No change needed; the before- and
3349 after-lists are still consistent. */
3351 else if (current_buffer
->overlay_center
> pos
+ length
)
3352 /* The deletion was to our left. We need to adjust the center value
3353 to account for the change in position, but the lists are consistent
3354 given the new value. */
3355 current_buffer
->overlay_center
-= length
;
3357 /* We're right in the middle. There might be things on the after-list
3358 that now belong on the before-list. Recentering will move them,
3359 and also update the center point. */
3360 recenter_overlay_lists (current_buffer
, pos
);
3363 /* Fix up overlays that were garbled as a result of permuting markers
3364 in the range START through END. Any overlay with at least one
3365 endpoint in this range will need to be unlinked from the overlay
3366 list and reinserted in its proper place.
3367 Such an overlay might even have negative size at this point.
3368 If so, we'll make the overlay empty. */
3370 fix_start_end_in_overlays (start
, end
)
3371 register int start
, end
;
3373 Lisp_Object overlay
;
3374 struct Lisp_Overlay
*before_list
, *after_list
;
3375 /* These are either nil, indicating that before_list or after_list
3376 should be assigned, or the cons cell the cdr of which should be
3378 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3379 /* 'Parent', likewise, indicates a cons cell or
3380 current_buffer->overlays_before or overlays_after, depending
3381 which loop we're in. */
3382 struct Lisp_Overlay
*tail
, *parent
;
3383 int startpos
, endpos
;
3385 /* This algorithm shifts links around instead of consing and GCing.
3386 The loop invariant is that before_list (resp. after_list) is a
3387 well-formed list except that its last element, the CDR of beforep
3388 (resp. afterp) if beforep (afterp) isn't nil or before_list
3389 (after_list) if it is, is still uninitialized. So it's not a bug
3390 that before_list isn't initialized, although it may look
3392 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3394 XSETMISC (overlay
, tail
);
3396 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3397 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3399 /* If the overlay is backwards, make it empty. */
3400 if (endpos
< startpos
)
3403 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3411 || (startpos
>= start
&& startpos
< end
))
3413 /* Add it to the end of the wrong list. Later on,
3414 recenter_overlay_lists will move it to the right place. */
3415 if (endpos
< current_buffer
->overlay_center
)
3420 afterp
->next
= tail
;
3428 beforep
->next
= tail
;
3432 current_buffer
->overlays_before
= tail
->next
;
3434 parent
->next
= tail
->next
;
3438 parent
= tail
, tail
= parent
->next
;
3440 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3442 XSETMISC (overlay
, tail
);
3444 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3445 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3447 /* If the overlay is backwards, make it empty. */
3448 if (endpos
< startpos
)
3451 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3455 if (startpos
>= end
)
3458 if (startpos
>= start
3459 || (endpos
>= start
&& endpos
< end
))
3461 if (endpos
< current_buffer
->overlay_center
)
3466 afterp
->next
= tail
;
3474 beforep
->next
= tail
;
3478 current_buffer
->overlays_after
= tail
->next
;
3480 parent
->next
= tail
->next
;
3484 parent
= tail
, tail
= parent
->next
;
3487 /* Splice the constructed (wrong) lists into the buffer's lists,
3488 and let the recenter function make it sane again. */
3491 beforep
->next
= current_buffer
->overlays_before
;
3492 current_buffer
->overlays_before
= before_list
;
3494 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3498 afterp
->next
= current_buffer
->overlays_after
;
3499 current_buffer
->overlays_after
= after_list
;
3501 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3504 /* We have two types of overlay: the one whose ending marker is
3505 after-insertion-marker (this is the usual case) and the one whose
3506 ending marker is before-insertion-marker. When `overlays_before'
3507 contains overlays of the latter type and the former type in this
3508 order and both overlays end at inserting position, inserting a text
3509 increases only the ending marker of the latter type, which results
3510 in incorrect ordering of `overlays_before'.
3512 This function fixes ordering of overlays in the slot
3513 `overlays_before' of the buffer *BP. Before the insertion, `point'
3514 was at PREV, and now is at POS. */
3517 fix_overlays_before (bp
, prev
, pos
)
3519 EMACS_INT prev
, pos
;
3521 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3522 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3526 /* After the insertion, the several overlays may be in incorrect
3527 order. The possibility is that, in the list `overlays_before',
3528 an overlay which ends at POS appears after an overlay which ends
3529 at PREV. Since POS is greater than PREV, we must fix the
3530 ordering of these overlays, by moving overlays ends at POS before
3531 the overlays ends at PREV. */
3533 /* At first, find a place where disordered overlays should be linked
3534 in. It is where an overlay which end before POS exists. (i.e. an
3535 overlay whose ending marker is after-insertion-marker if disorder
3538 && (XSETMISC (tem
, tail
),
3539 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3545 /* If we don't find such an overlay,
3546 or the found one ends before PREV,
3547 or the found one is the last one in the list,
3548 we don't have to fix anything. */
3549 if (!tail
|| end
< prev
|| !tail
->next
)
3552 right_pair
= parent
;
3556 /* Now, end position of overlays in the list TAIL should be before
3557 or equal to PREV. In the loop, an overlay which ends at POS is
3558 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3559 we found an overlay which ends before PREV, the remaining
3560 overlays are in correct order. */
3563 XSETMISC (tem
, tail
);
3564 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3567 { /* This overlay is disordered. */
3568 struct Lisp_Overlay
*found
= tail
;
3570 /* Unlink the found overlay. */
3572 parent
->next
= tail
;
3573 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3574 and link it into the right place. */
3577 found
->next
= bp
->overlays_before
;
3578 bp
->overlays_before
= found
;
3582 found
->next
= right_pair
->next
;
3583 right_pair
->next
= found
;
3586 else if (end
== prev
)
3591 else /* No more disordered overlay. */
3596 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3597 doc
: /* Return t if OBJECT is an overlay. */)
3601 return (OVERLAYP (object
) ? Qt
: Qnil
);
3604 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3605 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3606 If omitted, BUFFER defaults to the current buffer.
3607 BEG and END may be integers or markers.
3608 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3609 for the front of the overlay advance when text is inserted there
3610 \(which means the text *is not* included in the overlay).
3611 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3612 for the rear of the overlay advance when text is inserted there
3613 \(which means the text *is* included in the overlay). */)
3614 (beg
, end
, buffer
, front_advance
, rear_advance
)
3615 Lisp_Object beg
, end
, buffer
;
3616 Lisp_Object front_advance
, rear_advance
;
3618 Lisp_Object overlay
;
3622 XSETBUFFER (buffer
, current_buffer
);
3624 CHECK_BUFFER (buffer
);
3626 && ! EQ (Fmarker_buffer (beg
), buffer
))
3627 error ("Marker points into wrong buffer");
3629 && ! EQ (Fmarker_buffer (end
), buffer
))
3630 error ("Marker points into wrong buffer");
3632 CHECK_NUMBER_COERCE_MARKER (beg
);
3633 CHECK_NUMBER_COERCE_MARKER (end
);
3635 if (XINT (beg
) > XINT (end
))
3638 temp
= beg
; beg
= end
; end
= temp
;
3641 b
= XBUFFER (buffer
);
3643 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3644 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3646 if (!NILP (front_advance
))
3647 XMARKER (beg
)->insertion_type
= 1;
3648 if (!NILP (rear_advance
))
3649 XMARKER (end
)->insertion_type
= 1;
3651 overlay
= allocate_misc ();
3652 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3653 XOVERLAY (overlay
)->start
= beg
;
3654 XOVERLAY (overlay
)->end
= end
;
3655 XOVERLAY (overlay
)->plist
= Qnil
;
3656 XOVERLAY (overlay
)->next
= NULL
;
3658 /* Put the new overlay on the wrong list. */
3659 end
= OVERLAY_END (overlay
);
3660 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3662 if (b
->overlays_after
)
3663 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3664 b
->overlays_after
= XOVERLAY (overlay
);
3668 if (b
->overlays_before
)
3669 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3670 b
->overlays_before
= XOVERLAY (overlay
);
3673 /* This puts it in the right list, and in the right order. */
3674 recenter_overlay_lists (b
, b
->overlay_center
);
3676 /* We don't need to redisplay the region covered by the overlay, because
3677 the overlay has no properties at the moment. */
3682 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3685 modify_overlay (buf
, start
, end
)
3687 EMACS_INT start
, end
;
3696 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3698 /* If this is a buffer not in the selected window,
3699 we must do other windows. */
3700 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3701 windows_or_buffers_changed
= 1;
3702 /* If multiple windows show this buffer, we must do other windows. */
3703 else if (buffer_shared
> 1)
3704 windows_or_buffers_changed
= 1;
3705 /* If we modify an overlay at the end of the buffer, we cannot
3706 be sure that window end is still valid. */
3707 else if (end
>= ZV
&& start
<= ZV
)
3708 windows_or_buffers_changed
= 1;
3710 ++BUF_OVERLAY_MODIFF (buf
);
3714 Lisp_Object
Fdelete_overlay ();
3716 static struct Lisp_Overlay
*
3717 unchain_overlay (list
, overlay
)
3718 struct Lisp_Overlay
*list
, *overlay
;
3720 struct Lisp_Overlay
*tmp
, *prev
;
3721 for (tmp
= list
, prev
= NULL
; tmp
; prev
= tmp
, tmp
= tmp
->next
)
3725 prev
->next
= tmp
->next
;
3728 overlay
->next
= NULL
;
3734 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3735 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3736 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3737 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3739 (overlay
, beg
, end
, buffer
)
3740 Lisp_Object overlay
, beg
, end
, buffer
;
3742 struct buffer
*b
, *ob
;
3743 Lisp_Object obuffer
;
3744 int count
= SPECPDL_INDEX ();
3746 CHECK_OVERLAY (overlay
);
3748 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3750 XSETBUFFER (buffer
, current_buffer
);
3751 CHECK_BUFFER (buffer
);
3754 && ! EQ (Fmarker_buffer (beg
), buffer
))
3755 error ("Marker points into wrong buffer");
3757 && ! EQ (Fmarker_buffer (end
), buffer
))
3758 error ("Marker points into wrong buffer");
3760 CHECK_NUMBER_COERCE_MARKER (beg
);
3761 CHECK_NUMBER_COERCE_MARKER (end
);
3763 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3764 return Fdelete_overlay (overlay
);
3766 if (XINT (beg
) > XINT (end
))
3769 temp
= beg
; beg
= end
; end
= temp
;
3772 specbind (Qinhibit_quit
, Qt
);
3774 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3775 b
= XBUFFER (buffer
);
3776 ob
= BUFFERP (obuffer
) ? XBUFFER (obuffer
) : (struct buffer
*) 0;
3778 /* If the overlay has changed buffers, do a thorough redisplay. */
3779 if (!EQ (buffer
, obuffer
))
3781 /* Redisplay where the overlay was. */
3782 if (!NILP (obuffer
))
3787 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3788 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3790 modify_overlay (ob
, o_beg
, o_end
);
3793 /* Redisplay where the overlay is going to be. */
3794 modify_overlay (b
, XINT (beg
), XINT (end
));
3797 /* Redisplay the area the overlay has just left, or just enclosed. */
3801 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3802 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3804 if (o_beg
== XINT (beg
))
3805 modify_overlay (b
, o_end
, XINT (end
));
3806 else if (o_end
== XINT (end
))
3807 modify_overlay (b
, o_beg
, XINT (beg
));
3810 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
3811 if (XINT (end
) > o_end
) o_end
= XINT (end
);
3812 modify_overlay (b
, o_beg
, o_end
);
3816 if (!NILP (obuffer
))
3819 = unchain_overlay (ob
->overlays_before
, XOVERLAY (overlay
));
3821 = unchain_overlay (ob
->overlays_after
, XOVERLAY (overlay
));
3822 eassert (XOVERLAY (overlay
)->next
== NULL
);
3825 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3826 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3828 /* Put the overlay on the wrong list. */
3829 end
= OVERLAY_END (overlay
);
3830 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3832 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3833 b
->overlays_after
= XOVERLAY (overlay
);
3837 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3838 b
->overlays_before
= XOVERLAY (overlay
);
3841 /* This puts it in the right list, and in the right order. */
3842 recenter_overlay_lists (b
, b
->overlay_center
);
3844 return unbind_to (count
, overlay
);
3847 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
3848 doc
: /* Delete the overlay OVERLAY from its buffer. */)
3850 Lisp_Object overlay
;
3854 int count
= SPECPDL_INDEX ();
3856 CHECK_OVERLAY (overlay
);
3858 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3862 b
= XBUFFER (buffer
);
3863 specbind (Qinhibit_quit
, Qt
);
3865 b
->overlays_before
= unchain_overlay (b
->overlays_before
,XOVERLAY (overlay
));
3866 b
->overlays_after
= unchain_overlay (b
->overlays_after
, XOVERLAY (overlay
));
3867 eassert (XOVERLAY (overlay
)->next
== NULL
);
3869 marker_position (OVERLAY_START (overlay
)),
3870 marker_position (OVERLAY_END (overlay
)));
3871 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
3872 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
3874 /* When deleting an overlay with before or after strings, turn off
3875 display optimizations for the affected buffer, on the basis that
3876 these strings may contain newlines. This is easier to do than to
3877 check for that situation during redisplay. */
3878 if (!windows_or_buffers_changed
3879 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
3880 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
3881 b
->prevent_redisplay_optimizations_p
= 1;
3883 return unbind_to (count
, Qnil
);
3886 /* Overlay dissection functions. */
3888 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
3889 doc
: /* Return the position at which OVERLAY starts. */)
3891 Lisp_Object overlay
;
3893 CHECK_OVERLAY (overlay
);
3895 return (Fmarker_position (OVERLAY_START (overlay
)));
3898 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
3899 doc
: /* Return the position at which OVERLAY ends. */)
3901 Lisp_Object overlay
;
3903 CHECK_OVERLAY (overlay
);
3905 return (Fmarker_position (OVERLAY_END (overlay
)));
3908 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
3909 doc
: /* Return the buffer OVERLAY belongs to.
3910 Return nil if OVERLAY has been deleted. */)
3912 Lisp_Object overlay
;
3914 CHECK_OVERLAY (overlay
);
3916 return Fmarker_buffer (OVERLAY_START (overlay
));
3919 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
3920 doc
: /* Return a list of the properties on OVERLAY.
3921 This is a copy of OVERLAY's plist; modifying its conses has no effect on
3924 Lisp_Object overlay
;
3926 CHECK_OVERLAY (overlay
);
3928 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
3932 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
3933 doc
: /* Return a list of the overlays that contain position POS. */)
3938 Lisp_Object
*overlay_vec
;
3942 CHECK_NUMBER_COERCE_MARKER (pos
);
3945 /* We can't use alloca here because overlays_at can call xrealloc. */
3946 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3948 /* Put all the overlays we want in a vector in overlay_vec.
3949 Store the length in len. */
3950 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3951 (int *) 0, (int *) 0, 0);
3953 /* Make a list of them all. */
3954 result
= Flist (noverlays
, overlay_vec
);
3956 xfree (overlay_vec
);
3960 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
3961 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
3962 Overlap means that at least one character is contained within the overlay
3963 and also contained within the specified region.
3964 Empty overlays are included in the result if they are located at BEG
3965 or between BEG and END. */)
3967 Lisp_Object beg
, end
;
3970 Lisp_Object
*overlay_vec
;
3974 CHECK_NUMBER_COERCE_MARKER (beg
);
3975 CHECK_NUMBER_COERCE_MARKER (end
);
3978 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3980 /* Put all the overlays we want in a vector in overlay_vec.
3981 Store the length in len. */
3982 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
3983 (int *) 0, (int *) 0);
3985 /* Make a list of them all. */
3986 result
= Flist (noverlays
, overlay_vec
);
3988 xfree (overlay_vec
);
3992 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
3994 doc
: /* Return the next position after POS where an overlay starts or ends.
3995 If there are no overlay boundaries from POS to (point-max),
3996 the value is (point-max). */)
4002 Lisp_Object
*overlay_vec
;
4006 CHECK_NUMBER_COERCE_MARKER (pos
);
4009 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4011 /* Put all the overlays we want in a vector in overlay_vec.
4012 Store the length in len.
4013 endpos gets the position where the next overlay starts. */
4014 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4015 &endpos
, (int *) 0, 1);
4017 /* If any of these overlays ends before endpos,
4018 use its ending point instead. */
4019 for (i
= 0; i
< noverlays
; i
++)
4024 oend
= OVERLAY_END (overlay_vec
[i
]);
4025 oendpos
= OVERLAY_POSITION (oend
);
4026 if (oendpos
< endpos
)
4030 xfree (overlay_vec
);
4031 return make_number (endpos
);
4034 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
4035 Sprevious_overlay_change
, 1, 1, 0,
4036 doc
: /* Return the previous position before POS where an overlay starts or ends.
4037 If there are no overlay boundaries from (point-min) to POS,
4038 the value is (point-min). */)
4044 Lisp_Object
*overlay_vec
;
4047 CHECK_NUMBER_COERCE_MARKER (pos
);
4049 /* At beginning of buffer, we know the answer;
4050 avoid bug subtracting 1 below. */
4051 if (XINT (pos
) == BEGV
)
4055 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4057 /* Put all the overlays we want in a vector in overlay_vec.
4058 Store the length in len.
4059 prevpos gets the position of the previous change. */
4060 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4061 (int *) 0, &prevpos
, 1);
4063 xfree (overlay_vec
);
4064 return make_number (prevpos
);
4067 /* These functions are for debugging overlays. */
4069 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4070 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4071 The car has all the overlays before the overlay center;
4072 the cdr has all the overlays after the overlay center.
4073 Recentering overlays moves overlays between these lists.
4074 The lists you get are copies, so that changing them has no effect.
4075 However, the overlays you get are the real objects that the buffer uses. */)
4078 struct Lisp_Overlay
*ol
;
4079 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4080 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4083 before
= Fcons (tmp
, before
);
4085 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4088 after
= Fcons (tmp
, after
);
4090 return Fcons (Fnreverse (before
), Fnreverse (after
));
4093 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4094 doc
: /* Recenter the overlays of the current buffer around position POS.
4095 That makes overlay lookup faster for positions near POS (but perhaps slower
4096 for positions far away from POS). */)
4100 CHECK_NUMBER_COERCE_MARKER (pos
);
4102 recenter_overlay_lists (current_buffer
, XINT (pos
));
4106 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4107 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4109 Lisp_Object overlay
, prop
;
4111 CHECK_OVERLAY (overlay
);
4112 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4115 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4116 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE. */)
4117 (overlay
, prop
, value
)
4118 Lisp_Object overlay
, prop
, value
;
4120 Lisp_Object tail
, buffer
;
4123 CHECK_OVERLAY (overlay
);
4125 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4127 for (tail
= XOVERLAY (overlay
)->plist
;
4128 CONSP (tail
) && CONSP (XCDR (tail
));
4129 tail
= XCDR (XCDR (tail
)))
4130 if (EQ (XCAR (tail
), prop
))
4132 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4133 XSETCAR (XCDR (tail
), value
);
4136 /* It wasn't in the list, so add it to the front. */
4137 changed
= !NILP (value
);
4138 XOVERLAY (overlay
)->plist
4139 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
4141 if (! NILP (buffer
))
4144 modify_overlay (XBUFFER (buffer
),
4145 marker_position (OVERLAY_START (overlay
)),
4146 marker_position (OVERLAY_END (overlay
)));
4147 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4148 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4149 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4150 Fdelete_overlay (overlay
);
4156 /* Subroutine of report_overlay_modification. */
4158 /* Lisp vector holding overlay hook functions to call.
4159 Vector elements come in pairs.
4160 Each even-index element is a list of hook functions.
4161 The following odd-index element is the overlay they came from.
4163 Before the buffer change, we fill in this vector
4164 as we call overlay hook functions.
4165 After the buffer change, we get the functions to call from this vector.
4166 This way we always call the same functions before and after the change. */
4167 static Lisp_Object last_overlay_modification_hooks
;
4169 /* Number of elements actually used in last_overlay_modification_hooks. */
4170 static int last_overlay_modification_hooks_used
;
4172 /* Add one functionlist/overlay pair
4173 to the end of last_overlay_modification_hooks. */
4176 add_overlay_mod_hooklist (functionlist
, overlay
)
4177 Lisp_Object functionlist
, overlay
;
4179 int oldsize
= XVECTOR (last_overlay_modification_hooks
)->size
;
4181 if (last_overlay_modification_hooks_used
== oldsize
)
4184 old
= last_overlay_modification_hooks
;
4185 last_overlay_modification_hooks
4186 = Fmake_vector (make_number (oldsize
* 2), Qnil
);
4187 bcopy (XVECTOR (old
)->contents
,
4188 XVECTOR (last_overlay_modification_hooks
)->contents
,
4189 sizeof (Lisp_Object
) * oldsize
);
4191 AREF (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
++) = functionlist
;
4192 AREF (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
++) = overlay
;
4195 /* Run the modification-hooks of overlays that include
4196 any part of the text in START to END.
4197 If this change is an insertion, also
4198 run the insert-before-hooks of overlay starting at END,
4199 and the insert-after-hooks of overlay ending at START.
4201 This is called both before and after the modification.
4202 AFTER is nonzero when we call after the modification.
4204 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4205 When AFTER is nonzero, they are the start position,
4206 the position after the inserted new text,
4207 and the length of deleted or replaced old text. */
4210 report_overlay_modification (start
, end
, after
, arg1
, arg2
, arg3
)
4211 Lisp_Object start
, end
;
4213 Lisp_Object arg1
, arg2
, arg3
;
4215 Lisp_Object prop
, overlay
;
4216 struct Lisp_Overlay
*tail
;
4217 /* 1 if this change is an insertion. */
4218 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4219 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4224 /* We used to run the functions as soon as we found them and only register
4225 them in last_overlay_modification_hooks for the purpose of the `after'
4226 case. But running elisp code as we traverse the list of overlays is
4227 painful because the list can be modified by the elisp code so we had to
4228 copy at several places. We now simply do a read-only traversal that
4229 only collects the functions to run and we run them afterwards. It's
4230 simpler, especially since all the code was already there. -stef */
4234 /* We are being called before a change.
4235 Scan the overlays to find the functions to call. */
4236 last_overlay_modification_hooks_used
= 0;
4237 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4239 int startpos
, endpos
;
4240 Lisp_Object ostart
, oend
;
4242 XSETMISC (overlay
, tail
);
4244 ostart
= OVERLAY_START (overlay
);
4245 oend
= OVERLAY_END (overlay
);
4246 endpos
= OVERLAY_POSITION (oend
);
4247 if (XFASTINT (start
) > endpos
)
4249 startpos
= OVERLAY_POSITION (ostart
);
4250 if (insertion
&& (XFASTINT (start
) == startpos
4251 || XFASTINT (end
) == startpos
))
4253 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4255 add_overlay_mod_hooklist (prop
, overlay
);
4257 if (insertion
&& (XFASTINT (start
) == endpos
4258 || XFASTINT (end
) == endpos
))
4260 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4262 add_overlay_mod_hooklist (prop
, overlay
);
4264 /* Test for intersecting intervals. This does the right thing
4265 for both insertion and deletion. */
4266 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4268 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4270 add_overlay_mod_hooklist (prop
, overlay
);
4274 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4276 int startpos
, endpos
;
4277 Lisp_Object ostart
, oend
;
4279 XSETMISC (overlay
, tail
);
4281 ostart
= OVERLAY_START (overlay
);
4282 oend
= OVERLAY_END (overlay
);
4283 startpos
= OVERLAY_POSITION (ostart
);
4284 endpos
= OVERLAY_POSITION (oend
);
4285 if (XFASTINT (end
) < startpos
)
4287 if (insertion
&& (XFASTINT (start
) == startpos
4288 || XFASTINT (end
) == startpos
))
4290 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4292 add_overlay_mod_hooklist (prop
, overlay
);
4294 if (insertion
&& (XFASTINT (start
) == endpos
4295 || XFASTINT (end
) == endpos
))
4297 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4299 add_overlay_mod_hooklist (prop
, overlay
);
4301 /* Test for intersecting intervals. This does the right thing
4302 for both insertion and deletion. */
4303 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4305 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4307 add_overlay_mod_hooklist (prop
, overlay
);
4312 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4314 /* Call the functions recorded in last_overlay_modification_hooks.
4315 First copy the vector contents, in case some of these hooks
4316 do subsequent modification of the buffer. */
4317 int size
= last_overlay_modification_hooks_used
;
4318 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
4321 bcopy (XVECTOR (last_overlay_modification_hooks
)->contents
,
4322 copy
, size
* sizeof (Lisp_Object
));
4324 gcpro1
.nvars
= size
;
4326 for (i
= 0; i
< size
;)
4328 Lisp_Object prop
, overlay
;
4330 overlay
= copy
[i
++];
4331 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4338 call_overlay_mod_hooks (list
, overlay
, after
, arg1
, arg2
, arg3
)
4339 Lisp_Object list
, overlay
;
4341 Lisp_Object arg1
, arg2
, arg3
;
4343 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4345 GCPRO4 (list
, arg1
, arg2
, arg3
);
4347 while (CONSP (list
))
4350 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4352 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4358 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4361 evaporate_overlays (pos
)
4364 Lisp_Object overlay
, hit_list
;
4365 struct Lisp_Overlay
*tail
;
4368 if (pos
<= current_buffer
->overlay_center
)
4369 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4372 XSETMISC (overlay
, tail
);
4373 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4376 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4377 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4378 hit_list
= Fcons (overlay
, hit_list
);
4381 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4384 XSETMISC (overlay
, tail
);
4385 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4388 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4389 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4390 hit_list
= Fcons (overlay
, hit_list
);
4392 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4393 Fdelete_overlay (XCAR (hit_list
));
4396 /* Somebody has tried to store a value with an unacceptable type
4397 in the slot with offset OFFSET. */
4400 buffer_slot_type_mismatch (offset
)
4406 switch (XINT (PER_BUFFER_TYPE (offset
)))
4409 type_name
= "integers";
4413 type_name
= "strings";
4417 type_name
= "symbols";
4424 sym
= PER_BUFFER_SYMBOL (offset
);
4425 error ("Only %s should be stored in the buffer-local variable %s",
4426 type_name
, SDATA (SYMBOL_NAME (sym
)));
4430 /***********************************************************************
4431 Allocation with mmap
4432 ***********************************************************************/
4434 #ifdef USE_MMAP_FOR_BUFFERS
4436 #include <sys/types.h>
4437 #include <sys/mman.h>
4440 #ifdef MAP_ANONYMOUS
4441 #define MAP_ANON MAP_ANONYMOUS
4448 #define MAP_FAILED ((void *) -1)
4461 /* Memory is allocated in regions which are mapped using mmap(2).
4462 The current implementation lets the system select mapped
4463 addresses; we're not using MAP_FIXED in general, except when
4464 trying to enlarge regions.
4466 Each mapped region starts with a mmap_region structure, the user
4467 area starts after that structure, aligned to MEM_ALIGN.
4469 +-----------------------+
4470 | struct mmap_info + |
4472 +-----------------------+
4476 +-----------------------+ */
4480 /* User-specified size. */
4481 size_t nbytes_specified
;
4483 /* Number of bytes mapped */
4484 size_t nbytes_mapped
;
4486 /* Pointer to the location holding the address of the memory
4487 allocated with the mmap'd block. The variable actually points
4488 after this structure. */
4491 /* Next and previous in list of all mmap'd regions. */
4492 struct mmap_region
*next
, *prev
;
4495 /* Doubly-linked list of mmap'd regions. */
4497 static struct mmap_region
*mmap_regions
;
4499 /* File descriptor for mmap. If we don't have anonymous mapping,
4500 /dev/zero will be opened on it. */
4504 /* Temporary storage for mmap_set_vars, see there. */
4506 static struct mmap_region
*mmap_regions_1
;
4507 static int mmap_fd_1
;
4509 /* Page size on this system. */
4511 static int mmap_page_size
;
4513 /* 1 means mmap has been intialized. */
4515 static int mmap_initialized_p
;
4517 /* Value is X rounded up to the next multiple of N. */
4519 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4521 /* Size of mmap_region structure plus padding. */
4523 #define MMAP_REGION_STRUCT_SIZE \
4524 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4526 /* Given a pointer P to the start of the user-visible part of a mapped
4527 region, return a pointer to the start of the region. */
4529 #define MMAP_REGION(P) \
4530 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4532 /* Given a pointer P to the start of a mapped region, return a pointer
4533 to the start of the user-visible part of the region. */
4535 #define MMAP_USER_AREA(P) \
4536 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4538 #define MEM_ALIGN sizeof (double)
4540 /* Predicate returning true if part of the address range [START .. END]
4541 is currently mapped. Used to prevent overwriting an existing
4544 Default is to conservativly assume the address range is occupied by
4545 something else. This can be overridden by system configuration
4546 files if system-specific means to determine this exists. */
4548 #ifndef MMAP_ALLOCATED_P
4549 #define MMAP_ALLOCATED_P(start, end) 1
4552 /* Function prototypes. */
4554 static int mmap_free_1
P_ ((struct mmap_region
*));
4555 static int mmap_enlarge
P_ ((struct mmap_region
*, int));
4556 static struct mmap_region
*mmap_find
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
4557 static POINTER_TYPE
*mmap_alloc
P_ ((POINTER_TYPE
**, size_t));
4558 static POINTER_TYPE
*mmap_realloc
P_ ((POINTER_TYPE
**, size_t));
4559 static void mmap_free
P_ ((POINTER_TYPE
**ptr
));
4560 static void mmap_init
P_ ((void));
4563 /* Return a region overlapping address range START...END, or null if
4564 none. END is not including, i.e. the last byte in the range
4567 static struct mmap_region
*
4568 mmap_find (start
, end
)
4569 POINTER_TYPE
*start
, *end
;
4571 struct mmap_region
*r
;
4572 char *s
= (char *) start
, *e
= (char *) end
;
4574 for (r
= mmap_regions
; r
; r
= r
->next
)
4576 char *rstart
= (char *) r
;
4577 char *rend
= rstart
+ r
->nbytes_mapped
;
4579 if (/* First byte of range, i.e. START, in this region? */
4580 (s
>= rstart
&& s
< rend
)
4581 /* Last byte of range, i.e. END - 1, in this region? */
4582 || (e
> rstart
&& e
<= rend
)
4583 /* First byte of this region in the range? */
4584 || (rstart
>= s
&& rstart
< e
)
4585 /* Last byte of this region in the range? */
4586 || (rend
> s
&& rend
<= e
))
4594 /* Unmap a region. P is a pointer to the start of the user-araa of
4595 the region. Value is non-zero if successful. */
4599 struct mmap_region
*r
;
4602 r
->next
->prev
= r
->prev
;
4604 r
->prev
->next
= r
->next
;
4606 mmap_regions
= r
->next
;
4608 if (munmap ((POINTER_TYPE
*) r
, r
->nbytes_mapped
) == -1)
4610 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4618 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4619 Value is non-zero if successful. */
4622 mmap_enlarge (r
, npages
)
4623 struct mmap_region
*r
;
4626 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4632 /* Unmap pages at the end of the region. */
4633 nbytes
= - npages
* mmap_page_size
;
4634 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4635 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4638 r
->nbytes_mapped
-= nbytes
;
4642 else if (npages
> 0)
4644 nbytes
= npages
* mmap_page_size
;
4646 /* Try to map additional pages at the end of the region. We
4647 cannot do this if the address range is already occupied by
4648 something else because mmap deletes any previous mapping.
4649 I'm not sure this is worth doing, let's see. */
4650 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4654 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4655 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4656 if (p
== MAP_FAILED
)
4657 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4658 else if (p
!= (POINTER_TYPE
*) region_end
)
4660 /* Kernels are free to choose a different address. In
4661 that case, unmap what we've mapped above; we have
4663 if (munmap (p
, nbytes
) == -1)
4664 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4668 r
->nbytes_mapped
+= nbytes
;
4678 /* Set or reset variables holding references to mapped regions. If
4679 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4680 non-zero, set all variables to the start of the user-areas
4683 This function is called from Fdump_emacs to ensure that the dumped
4684 Emacs doesn't contain references to memory that won't be mapped
4685 when Emacs starts. */
4688 mmap_set_vars (restore_p
)
4691 struct mmap_region
*r
;
4695 mmap_regions
= mmap_regions_1
;
4696 mmap_fd
= mmap_fd_1
;
4697 for (r
= mmap_regions
; r
; r
= r
->next
)
4698 *r
->var
= MMAP_USER_AREA (r
);
4702 for (r
= mmap_regions
; r
; r
= r
->next
)
4704 mmap_regions_1
= mmap_regions
;
4705 mmap_regions
= NULL
;
4706 mmap_fd_1
= mmap_fd
;
4712 /* Allocate a block of storage large enough to hold NBYTES bytes of
4713 data. A pointer to the data is returned in *VAR. VAR is thus the
4714 address of some variable which will use the data area.
4716 The allocation of 0 bytes is valid.
4718 If we can't allocate the necessary memory, set *VAR to null, and
4721 static POINTER_TYPE
*
4722 mmap_alloc (var
, nbytes
)
4731 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4732 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4735 if (p
== MAP_FAILED
)
4737 if (errno
!= ENOMEM
)
4738 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4743 struct mmap_region
*r
= (struct mmap_region
*) p
;
4745 r
->nbytes_specified
= nbytes
;
4746 r
->nbytes_mapped
= map
;
4749 r
->next
= mmap_regions
;
4754 p
= MMAP_USER_AREA (p
);
4761 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4762 resize it to size NBYTES. Change *VAR to reflect the new block,
4763 and return this value. If more memory cannot be allocated, then
4764 leave *VAR unchanged, and return null. */
4766 static POINTER_TYPE
*
4767 mmap_realloc (var
, nbytes
)
4771 POINTER_TYPE
*result
;
4776 result
= mmap_alloc (var
, nbytes
);
4777 else if (nbytes
== 0)
4780 result
= mmap_alloc (var
, nbytes
);
4784 struct mmap_region
*r
= MMAP_REGION (*var
);
4785 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4790 POINTER_TYPE
*old_ptr
= *var
;
4792 /* Try to map additional pages at the end of the region.
4793 If that fails, allocate a new region, copy data
4794 from the old region, then free it. */
4795 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4798 r
->nbytes_specified
= nbytes
;
4799 *var
= result
= old_ptr
;
4801 else if (mmap_alloc (var
, nbytes
))
4803 bcopy (old_ptr
, *var
, r
->nbytes_specified
);
4804 mmap_free_1 (MMAP_REGION (old_ptr
));
4806 r
= MMAP_REGION (result
);
4807 r
->nbytes_specified
= nbytes
;
4815 else if (room
- nbytes
>= mmap_page_size
)
4817 /* Shrinking by at least a page. Let's give some
4818 memory back to the system.
4820 The extra parens are to make the division happens first,
4821 on positive values, so we know it will round towards
4823 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4825 r
->nbytes_specified
= nbytes
;
4829 /* Leave it alone. */
4831 r
->nbytes_specified
= nbytes
;
4839 /* Free a block of relocatable storage whose data is pointed to by
4840 PTR. Store 0 in *PTR to show there's no block allocated. */
4850 mmap_free_1 (MMAP_REGION (*var
));
4856 /* Perform necessary intializations for the use of mmap. */
4862 /* The value of mmap_fd is initially 0 in temacs, and -1
4863 in a dumped Emacs. */
4866 /* No anonymous mmap -- we need the file descriptor. */
4867 mmap_fd
= open ("/dev/zero", O_RDONLY
);
4869 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4871 #endif /* MAP_ANON == 0 */
4873 if (mmap_initialized_p
)
4875 mmap_initialized_p
= 1;
4881 mmap_page_size
= getpagesize ();
4884 #endif /* USE_MMAP_FOR_BUFFERS */
4888 /***********************************************************************
4889 Buffer-text Allocation
4890 ***********************************************************************/
4893 extern POINTER_TYPE
*r_alloc
P_ ((POINTER_TYPE
**, size_t));
4894 extern POINTER_TYPE
*r_re_alloc
P_ ((POINTER_TYPE
**, size_t));
4895 extern void r_alloc_free
P_ ((POINTER_TYPE
**ptr
));
4896 #endif /* REL_ALLOC */
4899 /* Allocate NBYTES bytes for buffer B's text buffer. */
4902 alloc_buffer_text (b
, nbytes
)
4909 #if defined USE_MMAP_FOR_BUFFERS
4910 p
= mmap_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4911 #elif defined REL_ALLOC
4912 p
= r_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4914 p
= xmalloc (nbytes
);
4923 b
->text
->beg
= (unsigned char *) p
;
4927 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4931 enlarge_buffer_text (b
, delta
)
4936 size_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4939 #if defined USE_MMAP_FOR_BUFFERS
4940 p
= mmap_realloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4941 #elif defined REL_ALLOC
4942 p
= r_re_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4944 p
= xrealloc (b
->text
->beg
, nbytes
);
4953 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
4958 /* Free buffer B's text buffer. */
4961 free_buffer_text (b
)
4966 #if defined USE_MMAP_FOR_BUFFERS
4967 mmap_free ((POINTER_TYPE
**) &b
->text
->beg
);
4968 #elif defined REL_ALLOC
4969 r_alloc_free ((POINTER_TYPE
**) &b
->text
->beg
);
4971 xfree (b
->text
->beg
);
4974 BUF_BEG_ADDR (b
) = NULL
;
4980 /***********************************************************************
4982 ***********************************************************************/
4989 bzero (buffer_permanent_local_flags
, sizeof buffer_permanent_local_flags
);
4991 /* Make sure all markable slots in buffer_defaults
4992 are initialized reasonably, so mark_buffer won't choke. */
4993 reset_buffer (&buffer_defaults
);
4994 reset_buffer_local_variables (&buffer_defaults
, 1);
4995 reset_buffer (&buffer_local_symbols
);
4996 reset_buffer_local_variables (&buffer_local_symbols
, 1);
4997 /* Prevent GC from getting confused. */
4998 buffer_defaults
.text
= &buffer_defaults
.own_text
;
4999 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
5000 BUF_INTERVALS (&buffer_defaults
) = 0;
5001 BUF_INTERVALS (&buffer_local_symbols
) = 0;
5002 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
5003 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
5005 /* Set up the default values of various buffer slots. */
5006 /* Must do these before making the first buffer! */
5008 /* real setup is done in bindings.el */
5009 buffer_defaults
.mode_line_format
= build_string ("%-");
5010 buffer_defaults
.header_line_format
= Qnil
;
5011 buffer_defaults
.abbrev_mode
= Qnil
;
5012 buffer_defaults
.overwrite_mode
= Qnil
;
5013 buffer_defaults
.case_fold_search
= Qt
;
5014 buffer_defaults
.auto_fill_function
= Qnil
;
5015 buffer_defaults
.selective_display
= Qnil
;
5017 buffer_defaults
.selective_display_ellipses
= Qt
;
5019 buffer_defaults
.abbrev_table
= Qnil
;
5020 buffer_defaults
.display_table
= Qnil
;
5021 buffer_defaults
.undo_list
= Qnil
;
5022 buffer_defaults
.mark_active
= Qnil
;
5023 buffer_defaults
.file_format
= Qnil
;
5024 buffer_defaults
.auto_save_file_format
= Qt
;
5025 buffer_defaults
.overlays_before
= NULL
;
5026 buffer_defaults
.overlays_after
= NULL
;
5027 buffer_defaults
.overlay_center
= BEG
;
5029 XSETFASTINT (buffer_defaults
.tab_width
, 8);
5030 buffer_defaults
.truncate_lines
= Qnil
;
5031 buffer_defaults
.ctl_arrow
= Qt
;
5032 buffer_defaults
.direction_reversed
= Qnil
;
5033 buffer_defaults
.cursor_type
= Qt
;
5034 buffer_defaults
.extra_line_spacing
= Qnil
;
5035 buffer_defaults
.cursor_in_non_selected_windows
= Qt
;
5038 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
5040 buffer_defaults
.enable_multibyte_characters
= Qt
;
5041 buffer_defaults
.buffer_file_coding_system
= Qnil
;
5042 XSETFASTINT (buffer_defaults
.fill_column
, 70);
5043 XSETFASTINT (buffer_defaults
.left_margin
, 0);
5044 buffer_defaults
.cache_long_line_scans
= Qnil
;
5045 buffer_defaults
.file_truename
= Qnil
;
5046 XSETFASTINT (buffer_defaults
.display_count
, 0);
5047 XSETFASTINT (buffer_defaults
.left_margin_cols
, 0);
5048 XSETFASTINT (buffer_defaults
.right_margin_cols
, 0);
5049 buffer_defaults
.left_fringe_width
= Qnil
;
5050 buffer_defaults
.right_fringe_width
= Qnil
;
5051 buffer_defaults
.fringes_outside_margins
= Qnil
;
5052 buffer_defaults
.scroll_bar_width
= Qnil
;
5053 buffer_defaults
.vertical_scroll_bar_type
= Qt
;
5054 buffer_defaults
.indicate_empty_lines
= Qnil
;
5055 buffer_defaults
.indicate_buffer_boundaries
= Qnil
;
5056 buffer_defaults
.fringe_indicator_alist
= Qnil
;
5057 buffer_defaults
.fringe_cursor_alist
= Qnil
;
5058 buffer_defaults
.scroll_up_aggressively
= Qnil
;
5059 buffer_defaults
.scroll_down_aggressively
= Qnil
;
5060 buffer_defaults
.display_time
= Qnil
;
5062 /* Assign the local-flags to the slots that have default values.
5063 The local flag is a bit that is used in the buffer
5064 to say that it has its own local value for the slot.
5065 The local flag bits are in the local_var_flags slot of the buffer. */
5067 /* Nothing can work if this isn't true */
5068 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
5070 /* 0 means not a lisp var, -1 means always local, else mask */
5071 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
5072 XSETINT (buffer_local_flags
.filename
, -1);
5073 XSETINT (buffer_local_flags
.directory
, -1);
5074 XSETINT (buffer_local_flags
.backed_up
, -1);
5075 XSETINT (buffer_local_flags
.save_length
, -1);
5076 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
5077 XSETINT (buffer_local_flags
.read_only
, -1);
5078 XSETINT (buffer_local_flags
.major_mode
, -1);
5079 XSETINT (buffer_local_flags
.mode_name
, -1);
5080 XSETINT (buffer_local_flags
.undo_list
, -1);
5081 XSETINT (buffer_local_flags
.mark_active
, -1);
5082 XSETINT (buffer_local_flags
.point_before_scroll
, -1);
5083 XSETINT (buffer_local_flags
.file_truename
, -1);
5084 XSETINT (buffer_local_flags
.invisibility_spec
, -1);
5085 XSETINT (buffer_local_flags
.file_format
, -1);
5086 XSETINT (buffer_local_flags
.auto_save_file_format
, -1);
5087 XSETINT (buffer_local_flags
.display_count
, -1);
5088 XSETINT (buffer_local_flags
.display_time
, -1);
5089 XSETINT (buffer_local_flags
.enable_multibyte_characters
, -1);
5092 XSETFASTINT (buffer_local_flags
.mode_line_format
, idx
); ++idx
;
5093 XSETFASTINT (buffer_local_flags
.abbrev_mode
, idx
); ++idx
;
5094 XSETFASTINT (buffer_local_flags
.overwrite_mode
, idx
); ++idx
;
5095 XSETFASTINT (buffer_local_flags
.case_fold_search
, idx
); ++idx
;
5096 XSETFASTINT (buffer_local_flags
.auto_fill_function
, idx
); ++idx
;
5097 XSETFASTINT (buffer_local_flags
.selective_display
, idx
); ++idx
;
5099 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, idx
); ++idx
;
5101 XSETFASTINT (buffer_local_flags
.tab_width
, idx
); ++idx
;
5102 XSETFASTINT (buffer_local_flags
.truncate_lines
, idx
); ++idx
;
5103 XSETFASTINT (buffer_local_flags
.ctl_arrow
, idx
); ++idx
;
5104 XSETFASTINT (buffer_local_flags
.fill_column
, idx
); ++idx
;
5105 XSETFASTINT (buffer_local_flags
.left_margin
, idx
); ++idx
;
5106 XSETFASTINT (buffer_local_flags
.abbrev_table
, idx
); ++idx
;
5107 XSETFASTINT (buffer_local_flags
.display_table
, idx
); ++idx
;
5109 XSETFASTINT (buffer_local_flags
.buffer_file_type
, idx
);
5110 /* Make this one a permanent local. */
5111 buffer_permanent_local_flags
[idx
++] = 1;
5113 XSETFASTINT (buffer_local_flags
.syntax_table
, idx
); ++idx
;
5114 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, idx
); ++idx
;
5115 XSETFASTINT (buffer_local_flags
.category_table
, idx
); ++idx
;
5116 XSETFASTINT (buffer_local_flags
.direction_reversed
, idx
); ++idx
;
5117 XSETFASTINT (buffer_local_flags
.buffer_file_coding_system
, idx
);
5118 /* Make this one a permanent local. */
5119 buffer_permanent_local_flags
[idx
++] = 1;
5120 XSETFASTINT (buffer_local_flags
.left_margin_cols
, idx
); ++idx
;
5121 XSETFASTINT (buffer_local_flags
.right_margin_cols
, idx
); ++idx
;
5122 XSETFASTINT (buffer_local_flags
.left_fringe_width
, idx
); ++idx
;
5123 XSETFASTINT (buffer_local_flags
.right_fringe_width
, idx
); ++idx
;
5124 XSETFASTINT (buffer_local_flags
.fringes_outside_margins
, idx
); ++idx
;
5125 XSETFASTINT (buffer_local_flags
.scroll_bar_width
, idx
); ++idx
;
5126 XSETFASTINT (buffer_local_flags
.vertical_scroll_bar_type
, idx
); ++idx
;
5127 XSETFASTINT (buffer_local_flags
.indicate_empty_lines
, idx
); ++idx
;
5128 XSETFASTINT (buffer_local_flags
.indicate_buffer_boundaries
, idx
); ++idx
;
5129 XSETFASTINT (buffer_local_flags
.fringe_indicator_alist
, idx
); ++idx
;
5130 XSETFASTINT (buffer_local_flags
.fringe_cursor_alist
, idx
); ++idx
;
5131 XSETFASTINT (buffer_local_flags
.scroll_up_aggressively
, idx
); ++idx
;
5132 XSETFASTINT (buffer_local_flags
.scroll_down_aggressively
, idx
); ++idx
;
5133 XSETFASTINT (buffer_local_flags
.header_line_format
, idx
); ++idx
;
5134 XSETFASTINT (buffer_local_flags
.cursor_type
, idx
); ++idx
;
5135 XSETFASTINT (buffer_local_flags
.extra_line_spacing
, idx
); ++idx
;
5136 XSETFASTINT (buffer_local_flags
.cursor_in_non_selected_windows
, idx
); ++idx
;
5138 /* Need more room? */
5139 if (idx
>= MAX_PER_BUFFER_VARS
)
5141 last_per_buffer_idx
= idx
;
5143 Vbuffer_alist
= Qnil
;
5147 QSFundamental
= build_string ("Fundamental");
5149 Qfundamental_mode
= intern ("fundamental-mode");
5150 buffer_defaults
.major_mode
= Qfundamental_mode
;
5152 Qmode_class
= intern ("mode-class");
5154 Qprotected_field
= intern ("protected-field");
5156 Qpermanent_local
= intern ("permanent-local");
5158 Qkill_buffer_hook
= intern ("kill-buffer-hook");
5159 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5161 Qucs_set_table_for_input
= intern ("ucs-set-table-for-input");
5163 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
5165 /* super-magic invisible buffer */
5166 Vbuffer_alist
= Qnil
;
5168 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5170 inhibit_modification_hooks
= 0;
5180 #ifdef USE_MMAP_FOR_BUFFERS
5182 /* When using the ralloc implementation based on mmap(2), buffer
5183 text pointers will have been set to null in the dumped Emacs.
5187 for (b
= all_buffers
; b
; b
= b
->next
)
5188 if (b
->text
->beg
== NULL
)
5189 enlarge_buffer_text (b
, 0);
5191 #endif /* USE_MMAP_FOR_BUFFERS */
5193 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5194 if (NILP (buffer_defaults
.enable_multibyte_characters
))
5195 Fset_buffer_multibyte (Qnil
);
5197 pwd
= get_current_dir_name ();
5200 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5203 /* Maybe this should really use some standard subroutine
5204 whose definition is filename syntax dependent. */
5206 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5208 /* Grow buffer to add directory separator and '\0'. */
5209 pwd
= (char *) xrealloc (pwd
, len
+ 2);
5210 pwd
[len
] = DIRECTORY_SEP
;
5211 pwd
[len
+ 1] = '\0';
5213 #endif /* not VMS */
5215 current_buffer
->directory
= make_unibyte_string (pwd
, strlen (pwd
));
5216 if (! NILP (buffer_defaults
.enable_multibyte_characters
))
5217 /* At this moment, we still don't know how to decode the
5218 directory name. So, we keep the bytes in multibyte form so
5219 that ENCODE_FILE correctly gets the original bytes. */
5220 current_buffer
->directory
5221 = string_to_multibyte (current_buffer
->directory
);
5223 /* Add /: to the front of the name
5224 if it would otherwise be treated as magic. */
5225 temp
= Ffind_file_name_handler (current_buffer
->directory
, Qt
);
5227 /* If the default dir is just /, TEMP is non-nil
5228 because of the ange-ftp completion handler.
5229 However, it is not necessary to turn / into /:/.
5230 So avoid doing that. */
5231 && strcmp ("/", SDATA (current_buffer
->directory
)))
5232 current_buffer
->directory
5233 = concat2 (build_string ("/:"), current_buffer
->directory
);
5235 temp
= get_minibuffer (0);
5236 XBUFFER (temp
)->directory
= current_buffer
->directory
;
5241 /* initialize the buffer routines */
5245 staticpro (&last_overlay_modification_hooks
);
5246 last_overlay_modification_hooks
5247 = Fmake_vector (make_number (10), Qnil
);
5249 staticpro (&Vbuffer_defaults
);
5250 staticpro (&Vbuffer_local_symbols
);
5251 staticpro (&Qfundamental_mode
);
5252 staticpro (&Qmode_class
);
5253 staticpro (&QSFundamental
);
5254 staticpro (&Vbuffer_alist
);
5255 staticpro (&Qprotected_field
);
5256 staticpro (&Qpermanent_local
);
5257 staticpro (&Qkill_buffer_hook
);
5258 Qoverlayp
= intern ("overlayp");
5259 staticpro (&Qoverlayp
);
5260 Qevaporate
= intern ("evaporate");
5261 staticpro (&Qevaporate
);
5262 Qmodification_hooks
= intern ("modification-hooks");
5263 staticpro (&Qmodification_hooks
);
5264 Qinsert_in_front_hooks
= intern ("insert-in-front-hooks");
5265 staticpro (&Qinsert_in_front_hooks
);
5266 Qinsert_behind_hooks
= intern ("insert-behind-hooks");
5267 staticpro (&Qinsert_behind_hooks
);
5268 Qget_file_buffer
= intern ("get-file-buffer");
5269 staticpro (&Qget_file_buffer
);
5270 Qpriority
= intern ("priority");
5271 staticpro (&Qpriority
);
5272 Qwindow
= intern ("window");
5273 staticpro (&Qwindow
);
5274 Qbefore_string
= intern ("before-string");
5275 staticpro (&Qbefore_string
);
5276 Qafter_string
= intern ("after-string");
5277 staticpro (&Qafter_string
);
5278 Qfirst_change_hook
= intern ("first-change-hook");
5279 staticpro (&Qfirst_change_hook
);
5280 Qbefore_change_functions
= intern ("before-change-functions");
5281 staticpro (&Qbefore_change_functions
);
5282 Qafter_change_functions
= intern ("after-change-functions");
5283 staticpro (&Qafter_change_functions
);
5284 staticpro (&Qucs_set_table_for_input
);
5286 Qkill_buffer_query_functions
= intern ("kill-buffer-query-functions");
5287 staticpro (&Qkill_buffer_query_functions
);
5289 Fput (Qprotected_field
, Qerror_conditions
,
5290 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
5291 Fput (Qprotected_field
, Qerror_message
,
5292 build_string ("Attempt to modify a protected field"));
5294 /* All these use DEFVAR_LISP_NOPRO because the slots in
5295 buffer_defaults will all be marked via Vbuffer_defaults. */
5297 DEFVAR_LISP_NOPRO ("default-mode-line-format",
5298 &buffer_defaults
.mode_line_format
,
5299 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5300 This is the same as (default-value 'mode-line-format). */);
5302 DEFVAR_LISP_NOPRO ("default-header-line-format",
5303 &buffer_defaults
.header_line_format
,
5304 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5305 This is the same as (default-value 'header-line-format). */);
5307 DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults
.cursor_type
,
5308 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5309 This is the same as (default-value 'cursor-type). */);
5311 DEFVAR_LISP_NOPRO ("default-line-spacing",
5312 &buffer_defaults
.extra_line_spacing
,
5313 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5314 This is the same as (default-value 'line-spacing). */);
5316 DEFVAR_LISP_NOPRO ("default-cursor-in-non-selected-windows",
5317 &buffer_defaults
.cursor_in_non_selected_windows
,
5318 doc
: /* Default value of `cursor-in-non-selected-windows'.
5319 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5321 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
5322 &buffer_defaults
.abbrev_mode
,
5323 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5324 This is the same as (default-value 'abbrev-mode). */);
5326 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
5327 &buffer_defaults
.ctl_arrow
,
5328 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5329 This is the same as (default-value 'ctl-arrow). */);
5331 DEFVAR_LISP_NOPRO ("default-direction-reversed",
5332 &buffer_defaults
.direction_reversed
,
5333 doc
: /* Default value of `direction-reversed' for buffers that do not override it.
5334 This is the same as (default-value 'direction-reversed). */);
5336 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
5337 &buffer_defaults
.enable_multibyte_characters
,
5338 doc
: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
5339 This is the same as (default-value 'enable-multibyte-characters). */);
5341 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
5342 &buffer_defaults
.buffer_file_coding_system
,
5343 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5344 This is the same as (default-value 'buffer-file-coding-system). */);
5346 DEFVAR_LISP_NOPRO ("default-truncate-lines",
5347 &buffer_defaults
.truncate_lines
,
5348 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5349 This is the same as (default-value 'truncate-lines). */);
5351 DEFVAR_LISP_NOPRO ("default-fill-column",
5352 &buffer_defaults
.fill_column
,
5353 doc
: /* Default value of `fill-column' for buffers that do not override it.
5354 This is the same as (default-value 'fill-column). */);
5356 DEFVAR_LISP_NOPRO ("default-left-margin",
5357 &buffer_defaults
.left_margin
,
5358 doc
: /* Default value of `left-margin' for buffers that do not override it.
5359 This is the same as (default-value 'left-margin). */);
5361 DEFVAR_LISP_NOPRO ("default-tab-width",
5362 &buffer_defaults
.tab_width
,
5363 doc
: /* Default value of `tab-width' for buffers that do not override it.
5364 This is the same as (default-value 'tab-width). */);
5366 DEFVAR_LISP_NOPRO ("default-case-fold-search",
5367 &buffer_defaults
.case_fold_search
,
5368 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5369 This is the same as (default-value 'case-fold-search). */);
5372 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
5373 &buffer_defaults
.buffer_file_type
,
5374 doc
: /* Default file type for buffers that do not override it.
5375 This is the same as (default-value 'buffer-file-type).
5376 The file type is nil for text, t for binary. */);
5379 DEFVAR_LISP_NOPRO ("default-left-margin-width",
5380 &buffer_defaults
.left_margin_cols
,
5381 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5382 This is the same as (default-value 'left-margin-width). */);
5384 DEFVAR_LISP_NOPRO ("default-right-margin-width",
5385 &buffer_defaults
.right_margin_cols
,
5386 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5387 This is the same as (default-value 'right-margin-width). */);
5389 DEFVAR_LISP_NOPRO ("default-left-fringe-width",
5390 &buffer_defaults
.left_fringe_width
,
5391 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5392 This is the same as (default-value 'left-fringe-width). */);
5394 DEFVAR_LISP_NOPRO ("default-right-fringe-width",
5395 &buffer_defaults
.right_fringe_width
,
5396 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5397 This is the same as (default-value 'right-fringe-width). */);
5399 DEFVAR_LISP_NOPRO ("default-fringes-outside-margins",
5400 &buffer_defaults
.fringes_outside_margins
,
5401 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5402 This is the same as (default-value 'fringes-outside-margins). */);
5404 DEFVAR_LISP_NOPRO ("default-scroll-bar-width",
5405 &buffer_defaults
.scroll_bar_width
,
5406 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5407 This is the same as (default-value 'scroll-bar-width). */);
5409 DEFVAR_LISP_NOPRO ("default-vertical-scroll-bar",
5410 &buffer_defaults
.vertical_scroll_bar_type
,
5411 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5412 This is the same as (default-value 'vertical-scroll-bar). */);
5414 DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
5415 &buffer_defaults
.indicate_empty_lines
,
5416 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5417 This is the same as (default-value 'indicate-empty-lines). */);
5419 DEFVAR_LISP_NOPRO ("default-indicate-buffer-boundaries",
5420 &buffer_defaults
.indicate_buffer_boundaries
,
5421 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5422 This is the same as (default-value 'indicate-buffer-boundaries). */);
5424 DEFVAR_LISP_NOPRO ("default-fringe-indicator-alist",
5425 &buffer_defaults
.fringe_indicator_alist
,
5426 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5427 This is the same as (default-value 'fringe-indicator-alist'). */);
5429 DEFVAR_LISP_NOPRO ("default-fringe-cursor-alist",
5430 &buffer_defaults
.fringe_cursor_alist
,
5431 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5432 This is the same as (default-value 'fringe-cursor-alist'). */);
5434 DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
5435 &buffer_defaults
.scroll_up_aggressively
,
5436 doc
: /* Default value of `scroll-up-aggressively'.
5437 This value applies in buffers that don't have their own local values.
5438 This variable is an alias for (default-value 'scroll-up-aggressively). */);
5440 DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
5441 &buffer_defaults
.scroll_down_aggressively
,
5442 doc
: /* Default value of `scroll-down-aggressively'.
5443 This value applies in buffers that don't have their own local values.
5444 This variable is an alias for (default-value 'scroll-down-aggressively). */);
5446 DEFVAR_PER_BUFFER ("header-line-format",
5447 ¤t_buffer
->header_line_format
,
5449 doc
: /* Analogous to `mode-line-format', but controls the header line.
5450 The header line appears, optionally, at the top of a window;
5451 the mode line appears at the bottom. */);
5453 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
5455 doc
: /* Template for displaying mode line for current buffer.
5456 Each buffer has its own value of this variable.
5457 Value may be nil, a string, a symbol or a list or cons cell.
5458 A value of nil means don't display a mode line.
5459 For a symbol, its value is used (but it is ignored if t or nil).
5460 A string appearing directly as the value of a symbol is processed verbatim
5461 in that the %-constructs below are not recognized.
5462 Note that unless the symbol is marked as a `risky-local-variable', all
5463 properties in any strings, as well as all :eval and :propertize forms
5464 in the value of that symbol will be ignored.
5465 For a list of the form `(:eval FORM)', FORM is evaluated and the result
5466 is used as a mode line element. Be careful--FORM should not load any files,
5467 because that can cause an infinite recursion.
5468 For a list of the form `(:propertize ELT PROPS...)', ELT is displayed
5469 with the specified properties PROPS applied.
5470 For a list whose car is a symbol, the symbol's value is taken,
5471 and if that is non-nil, the cadr of the list is processed recursively.
5472 Otherwise, the caddr of the list (if there is one) is processed.
5473 For a list whose car is a string or list, each element is processed
5474 recursively and the results are effectively concatenated.
5475 For a list whose car is an integer, the cdr of the list is processed
5476 and padded (if the number is positive) or truncated (if negative)
5477 to the width specified by that number.
5478 A string is printed verbatim in the mode line except for %-constructs:
5479 (%-constructs are allowed when the string is the entire mode-line-format
5480 or when it is found in a cons-cell or a list)
5481 %b -- print buffer name. %f -- print visited file name.
5482 %F -- print frame name.
5483 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5484 %& is like %*, but ignore read-only-ness.
5485 % means buffer is read-only and * means it is modified.
5486 For a modified read-only buffer, %* gives % and %+ gives *.
5487 %s -- print process status. %l -- print the current line number.
5488 %c -- print the current column number (this makes editing slower).
5489 To make the column number update correctly in all cases,
5490 `column-number-mode' must be non-nil.
5491 %i -- print the size of the buffer.
5492 %I -- like %i, but use k, M, G, etc., to abbreviate.
5493 %p -- print percent of buffer above top of window, or Top, Bot or All.
5494 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5495 or print Bottom or All.
5496 %n -- print Narrow if appropriate.
5497 %t -- visited file is text or binary (if OS supports this distinction).
5498 %z -- print mnemonics of buffer, terminal, and keyboard coding systems.
5499 %Z -- like %z, but including the end-of-line format.
5500 %e -- print error message about full memory.
5501 %[ -- print one [ for each recursive editing level. %] similar.
5502 %% -- print %. %- -- print infinitely many dashes.
5503 Decimal digits after the % specify field width to which to pad. */);
5505 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
5506 doc
: /* *Major mode for new buffers. Defaults to `fundamental-mode'.
5507 nil here means use current buffer's major mode, provided it is not
5508 marked as "special".
5510 When a mode is used by default, `find-file' switches to it
5511 before it reads the contents into the buffer and before
5512 it finishes setting up the buffer. Thus, the mode and
5513 its hooks should not expect certain variables such as
5514 `buffer-read-only' and `buffer-file-coding-system' to be set up. */);
5516 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
5517 make_number (Lisp_Symbol
),
5518 doc
: /* Symbol for current buffer's major mode. */);
5520 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
5522 doc
: /* Pretty name of current buffer's major mode (a string). */);
5524 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
5525 doc
: /* Non-nil turns on automatic expansion of abbrevs as they are inserted. */);
5527 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
5529 doc
: /* *Non-nil if searches and matches should ignore case. */);
5531 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
5532 make_number (Lisp_Int
),
5533 doc
: /* *Column beyond which automatic line-wrapping should happen.
5534 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5536 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
5537 make_number (Lisp_Int
),
5538 doc
: /* *Column for the default indent-line-function to indent to.
5539 Linefeed indents to this column in Fundamental mode. */);
5541 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
5542 make_number (Lisp_Int
),
5543 doc
: /* *Distance between tab stops (for display of tab characters), in columns. */);
5545 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
5546 doc
: /* *Non-nil means display control chars with uparrow.
5547 A value of nil means use backslash and octal digits.
5548 This variable does not apply to characters whose display is specified
5549 in the current display table (if there is one). */);
5551 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5552 ¤t_buffer
->enable_multibyte_characters
,
5554 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5555 Otherwise they are regarded as unibyte. This affects the display,
5556 file I/O and the behavior of various editing commands.
5558 This variable is buffer-local but you cannot set it directly;
5559 use the function `set-buffer-multibyte' to change a buffer's representation.
5560 Changing its default value with `setq-default' is supported.
5561 See also variable `default-enable-multibyte-characters' and Info node
5562 `(elisp)Text Representations'. */);
5563 XSYMBOL (intern ("enable-multibyte-characters"))->constant
= 1;
5565 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5566 ¤t_buffer
->buffer_file_coding_system
, Qnil
,
5567 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5568 This variable applies to saving the buffer, and also to `write-region'
5569 and other functions that use `write-region'.
5570 It does not apply to sending output to subprocesses, however.
5572 If this is nil, the buffer is saved without any code conversion
5573 unless some coding system is specified in `file-coding-system-alist'
5574 for the buffer file.
5576 If the text to be saved cannot be encoded as specified by this variable,
5577 an alternative encoding is selected by `select-safe-coding-system', which see.
5579 The variable `coding-system-for-write', if non-nil, overrides this variable.
5581 This variable is never applied to a way of decoding a file while reading it. */);
5583 DEFVAR_PER_BUFFER ("direction-reversed", ¤t_buffer
->direction_reversed
,
5585 doc
: /* *Non-nil means lines in the buffer are displayed right to left. */);
5587 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
5588 doc
: /* *Non-nil means do not display continuation lines.
5589 Instead, give each line of text just one screen line.
5591 Note that this is overridden by the variable
5592 `truncate-partial-width-windows' if that variable is non-nil
5593 and this buffer is not full-frame width. */);
5596 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
5598 doc
: /* Non-nil if the visited file is a binary file.
5599 This variable is meaningful on MS-DOG and Windows NT.
5600 On those systems, it is automatically local in every buffer.
5601 On other systems, this variable is normally always nil. */);
5604 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
5605 make_number (Lisp_String
),
5606 doc
: /* Name of default directory of current buffer. Should end with slash.
5607 To interactively change the default directory, use command `cd'. */);
5609 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
5611 doc
: /* Function called (if non-nil) to perform auto-fill.
5612 It is called after self-inserting any character specified in
5613 the `auto-fill-chars' table.
5614 NOTE: This variable is not a hook;
5615 its value may not be a list of functions. */);
5617 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
5618 make_number (Lisp_String
),
5619 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5621 DEFVAR_PER_BUFFER ("buffer-file-truename", ¤t_buffer
->file_truename
,
5622 make_number (Lisp_String
),
5623 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5624 The truename of a file is calculated by `file-truename'
5625 and then abbreviated with `abbreviate-file-name'. */);
5627 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5628 ¤t_buffer
->auto_save_file_name
,
5629 make_number (Lisp_String
),
5630 doc
: /* Name of file for auto-saving current buffer.
5631 If it is nil, that means don't auto-save this buffer. */);
5633 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
5634 doc
: /* Non-nil if this buffer is read-only. */);
5636 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
5637 doc
: /* Non-nil if this buffer's file has been backed up.
5638 Backing up is done before the first time the file is saved. */);
5640 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
5641 make_number (Lisp_Int
),
5642 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5645 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
5647 doc
: /* Non-nil enables selective display.
5648 An Integer N as value means display only lines
5649 that start with less than n columns of space.
5650 A value of t means that the character ^M makes itself and
5651 all the rest of the line invisible; also, when saving the buffer
5652 in a file, save the ^M as a newline. */);
5655 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5656 ¤t_buffer
->selective_display_ellipses
,
5658 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5661 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
5662 doc
: /* Non-nil if self-insertion should replace existing text.
5663 The value should be one of `overwrite-mode-textual',
5664 `overwrite-mode-binary', or nil.
5665 If it is `overwrite-mode-textual', self-insertion still
5666 inserts at the end of a line, and inserts when point is before a tab,
5667 until the tab is filled in.
5668 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5670 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
5672 doc
: /* Display table that controls display of the contents of current buffer.
5674 If this variable is nil, the value of `standard-display-table' is used.
5675 Each window can have its own, overriding display table, see
5676 `set-window-display-table' and `window-display-table'.
5678 The display table is a char-table created with `make-display-table'.
5679 A char-table is an array indexed by character codes. Normal array
5680 primitives `aref' and `aset' can be used to access elements of a char-table.
5682 Each of the char-table elements control how to display the corresponding
5683 text character: the element at index C in the table says how to display
5684 the character whose code is C. Each element should be a vector of
5685 characters or nil. nil means display the character in the default fashion;
5686 otherwise, the characters from the vector are delivered to the screen
5687 instead of the original character.
5689 For example, (aset buffer-display-table ?X ?Y) will cause Emacs to display
5690 a capital Y instead of each X character.
5692 In addition, a char-table has six extra slots to control the display of:
5694 the end of a truncated screen line (extra-slot 0, a single character);
5695 the end of a continued line (extra-slot 1, a single character);
5696 the escape character used to display character codes in octal
5697 (extra-slot 2, a single character);
5698 the character used as an arrow for control characters (extra-slot 3,
5699 a single character);
5700 the decoration indicating the presence of invisible lines (extra-slot 4,
5701 a vector of characters);
5702 the character used to draw the border between side-by-side windows
5703 (extra-slot 5, a single character).
5705 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5707 DEFVAR_PER_BUFFER ("left-margin-width", ¤t_buffer
->left_margin_cols
,
5709 doc
: /* *Width of left marginal area for display of a buffer.
5710 A value of nil means no marginal area. */);
5712 DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer
->right_margin_cols
,
5714 doc
: /* *Width of right marginal area for display of a buffer.
5715 A value of nil means no marginal area. */);
5717 DEFVAR_PER_BUFFER ("left-fringe-width", ¤t_buffer
->left_fringe_width
,
5719 doc
: /* *Width of this buffer's left fringe (in pixels).
5720 A value of 0 means no left fringe is shown in this buffer's window.
5721 A value of nil means to use the left fringe width from the window's frame. */);
5723 DEFVAR_PER_BUFFER ("right-fringe-width", ¤t_buffer
->right_fringe_width
,
5725 doc
: /* *Width of this buffer's right fringe (in pixels).
5726 A value of 0 means no right fringe is shown in this buffer's window.
5727 A value of nil means to use the right fringe width from the window's frame. */);
5729 DEFVAR_PER_BUFFER ("fringes-outside-margins", ¤t_buffer
->fringes_outside_margins
,
5731 doc
: /* *Non-nil means to display fringes outside display margins.
5732 A value of nil means to display fringes between margins and buffer text. */);
5734 DEFVAR_PER_BUFFER ("scroll-bar-width", ¤t_buffer
->scroll_bar_width
,
5736 doc
: /* *Width of this buffer's scroll bars in pixels.
5737 A value of nil means to use the scroll bar width from the window's frame. */);
5739 DEFVAR_PER_BUFFER ("vertical-scroll-bar", ¤t_buffer
->vertical_scroll_bar_type
,
5741 doc
: /* *Position of this buffer's vertical scroll bar.
5742 The value takes effect whenever you tell a window to display this buffer;
5743 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5745 A value of `left' or `right' means put the vertical scroll bar at that side
5746 of the window; a value of nil means don't show any vertical scroll bars.
5747 A value of t (the default) means do whatever the window's frame specifies. */);
5749 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5750 ¤t_buffer
->indicate_empty_lines
, Qnil
,
5751 doc
: /* *Visually indicate empty lines after the buffer end.
5752 If non-nil, a bitmap is displayed in the left fringe of a window on
5753 window-systems. */);
5755 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5756 ¤t_buffer
->indicate_buffer_boundaries
, Qnil
,
5757 doc
: /* *Visually indicate buffer boundaries and scrolling.
5758 If non-nil, the first and last line of the buffer are marked in the fringe
5759 of a window on window-systems with angle bitmaps, or if the window can be
5760 scrolled, the top and bottom line of the window are marked with up and down
5763 If value is a symbol `left' or `right', both angle and arrow bitmaps
5764 are displayed in the left or right fringe, resp. Any other value
5765 that doesn't look like an alist means display the angle bitmaps in
5766 the left fringe but no arrows.
5768 You can exercise more precise control by using an alist as the
5769 value. Each alist element (INDICATOR . POSITION) specifies
5770 where to show one of the indicators. INDICATOR is one of `top',
5771 `bottom', `up', `down', or t, which specifies the default position,
5772 and POSITION is one of `left', `right', or nil, meaning do not show
5775 For example, ((top . left) (t . right)) places the top angle bitmap in
5776 left fringe, the bottom angle bitmap in right fringe, and both arrow
5777 bitmaps in right fringe. To show just the angle bitmaps in the left
5778 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5780 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5781 ¤t_buffer
->fringe_indicator_alist
, Qnil
,
5782 doc
: /* *Mapping from logical to physical fringe indicator bitmaps.
5783 The value is an alist where each element (INDICATOR . BITMAPS)
5784 specifies the fringe bitmaps used to display a specific logical
5787 INDICATOR specifies the logical indicator type which is one of the
5788 following symbols: `truncation' , `continuation', `overlay-arrow',
5789 `top', `bottom', `up', `down', `one-line', `empty-line', or `unknown'.
5791 BITMAPS is list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5792 the actual bitmap shown in the left or right fringe for the logical
5793 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5794 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
5795 are used only for the `bottom' and `one-line' indicators when the last
5796 \(only) line in has no final newline. BITMAPS may also be a single
5797 symbol which is used in both left and right fringes. */);
5799 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
5800 ¤t_buffer
->fringe_cursor_alist
, Qnil
,
5801 doc
: /* *Mapping from logical to physical fringe cursor bitmaps.
5802 The value is an alist where each element (CURSOR . BITMAP)
5803 specifies the fringe bitmaps used to display a specific logical
5804 cursor type in the fringe.
5806 CURSOR specifies the logical cursor type which is one of the following
5807 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
5808 one is used to show a hollow cursor on narrow lines display lines
5809 where the normal hollow cursor will not fit.
5811 BITMAP is the corresponding fringe bitmap shown for the logical
5814 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5815 ¤t_buffer
->scroll_up_aggressively
, Qnil
,
5816 doc
: /* How far to scroll windows upward.
5817 If you move point off the bottom, the window scrolls automatically.
5818 This variable controls how far it scrolls. nil, the default,
5819 means scroll to center point. A fraction means scroll to put point
5820 that fraction of the window's height from the bottom of the window.
5821 When the value is 0.0, point goes at the bottom line, which in the simple
5822 case that you moved off with C-f means scrolling just one line. 1.0 means
5823 point goes at the top, so that in that simple case, the window
5824 scrolls by a full window height. Meaningful values are
5825 between 0.0 and 1.0, inclusive. */);
5827 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
5828 ¤t_buffer
->scroll_down_aggressively
, Qnil
,
5829 doc
: /* How far to scroll windows downward.
5830 If you move point off the top, the window scrolls automatically.
5831 This variable controls how far it scrolls. nil, the default,
5832 means scroll to center point. A fraction means scroll to put point
5833 that fraction of the window's height from the top of the window.
5834 When the value is 0.0, point goes at the top line, which in the simple
5835 case that you moved off with C-b means scrolling just one line. 1.0 means
5836 point goes at the bottom, so that in that simple case, the window
5837 scrolls by a full window height. Meaningful values are
5838 between 0.0 and 1.0, inclusive. */);
5840 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
5844 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
5845 doc
: /* List of functions to call before each text change.
5846 Two arguments are passed to each function: the positions of
5847 the beginning and end of the range of old text to be changed.
5848 \(For an insertion, the beginning and end are at the same place.)
5849 No information is given about the length of the text after the change.
5851 Buffer changes made while executing the `before-change-functions'
5852 don't call any before-change or after-change functions.
5853 That's because these variables are temporarily set to nil.
5854 As a result, a hook function cannot straightforwardly alter the value of
5855 these variables. See the Emacs Lisp manual for a way of
5856 accomplishing an equivalent result by using other variables.
5858 If an unhandled error happens in running these functions,
5859 the variable's value remains nil. That prevents the error
5860 from happening repeatedly and making Emacs nonfunctional. */);
5861 Vbefore_change_functions
= Qnil
;
5863 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
5864 doc
: /* List of functions to call after each text change.
5865 Three arguments are passed to each function: the positions of
5866 the beginning and end of the range of changed text,
5867 and the length in bytes of the pre-change text replaced by that range.
5868 \(For an insertion, the pre-change length is zero;
5869 for a deletion, that length is the number of bytes deleted,
5870 and the post-change beginning and end are at the same place.)
5872 Buffer changes made while executing the `after-change-functions'
5873 don't call any before-change or after-change functions.
5874 That's because these variables are temporarily set to nil.
5875 As a result, a hook function cannot straightforwardly alter the value of
5876 these variables. See the Emacs Lisp manual for a way of
5877 accomplishing an equivalent result by using other variables.
5879 If an unhandled error happens in running these functions,
5880 the variable's value remains nil. That prevents the error
5881 from happening repeatedly and making Emacs nonfunctional. */);
5882 Vafter_change_functions
= Qnil
;
5884 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
5885 doc
: /* A list of functions to call before changing a buffer which is unmodified.
5886 The functions are run using the `run-hooks' function. */);
5887 Vfirst_change_hook
= Qnil
;
5889 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
5890 doc
: /* List of undo entries in current buffer.
5891 Recent changes come first; older changes follow newer.
5893 An entry (BEG . END) represents an insertion which begins at
5894 position BEG and ends at position END.
5896 An entry (TEXT . POSITION) represents the deletion of the string TEXT
5897 from (abs POSITION). If POSITION is positive, point was at the front
5898 of the text being deleted; if negative, point was at the end.
5900 An entry (t HIGH . LOW) indicates that the buffer previously had
5901 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions
5902 of the visited file's modification time, as of that time. If the
5903 modification time of the most recent save is different, this entry is
5906 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
5907 was modified between BEG and END. PROPERTY is the property name,
5908 and VALUE is the old value.
5910 An entry (apply FUN-NAME . ARGS) means undo the change with
5911 \(apply FUN-NAME ARGS).
5913 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
5914 in the active region. BEG and END is the range affected by this entry
5915 and DELTA is the number of bytes added or deleted in that range by
5918 An entry (MARKER . DISTANCE) indicates that the marker MARKER
5919 was adjusted in position by the offset DISTANCE (an integer).
5921 An entry of the form POSITION indicates that point was at the buffer
5922 location given by the integer. Undoing an entry of this form places
5925 nil marks undo boundaries. The undo command treats the changes
5926 between two undo boundaries as a single step to be undone.
5928 If the value of the variable is t, undo information is not recorded. */);
5930 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
5931 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
5933 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
5934 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
5936 Normally, the line-motion functions work by scanning the buffer for
5937 newlines. Columnar operations (like `move-to-column' and
5938 `compute-motion') also work by scanning the buffer, summing character
5939 widths as they go. This works well for ordinary text, but if the
5940 buffer's lines are very long (say, more than 500 characters), these
5941 motion functions will take longer to execute. Emacs may also take
5942 longer to update the display.
5944 If `cache-long-line-scans' is non-nil, these motion functions cache the
5945 results of their scans, and consult the cache to avoid rescanning
5946 regions of the buffer until the text is modified. The caches are most
5947 beneficial when they prevent the most searching---that is, when the
5948 buffer contains long lines and large regions of characters with the
5949 same, fixed screen width.
5951 When `cache-long-line-scans' is non-nil, processing short lines will
5952 become slightly slower (because of the overhead of consulting the
5953 cache), and the caches will use memory roughly proportional to the
5954 number of newlines and characters whose screen width varies.
5956 The caches require no explicit maintenance; their accuracy is
5957 maintained internally by the Emacs primitives. Enabling or disabling
5958 the cache should not affect the behavior of any of the motion
5959 functions; it should only affect their performance. */);
5961 DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer
->point_before_scroll
, Qnil
,
5962 doc
: /* Value of point before the last series of scroll operations, or nil. */);
5964 DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer
->file_format
, Qnil
,
5965 doc
: /* List of formats to use when saving this buffer.
5966 Formats are defined by `format-alist'. This variable is
5967 set when a file is visited. */);
5969 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
5970 ¤t_buffer
->auto_save_file_format
, Qnil
,
5971 doc
: /* *Format in which to write auto-save files.
5972 Should be a list of symbols naming formats that are defined in `format-alist'.
5973 If it is t, which is the default, auto-save files are written in the
5974 same format as a regular save would use. */);
5976 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
5977 ¤t_buffer
->invisibility_spec
, Qnil
,
5978 doc
: /* Invisibility spec of this buffer.
5979 The default is t, which means that text is invisible
5980 if it has a non-nil `invisible' property.
5981 If the value is a list, a text character is invisible if its `invisible'
5982 property is an element in that list.
5983 If an element is a cons cell of the form (PROP . ELLIPSIS),
5984 then characters with property value PROP are invisible,
5985 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
5987 DEFVAR_PER_BUFFER ("buffer-display-count",
5988 ¤t_buffer
->display_count
, Qnil
,
5989 doc
: /* A number incremented each time this buffer is displayed in a window.
5990 The function `set-window-buffer' increments it. */);
5992 DEFVAR_PER_BUFFER ("buffer-display-time",
5993 ¤t_buffer
->display_time
, Qnil
,
5994 doc
: /* Time stamp updated each time this buffer is displayed in a window.
5995 The function `set-window-buffer' updates this variable
5996 to the value obtained by calling `current-time'.
5997 If the buffer has never been shown in a window, the value is nil. */);
5999 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
6000 doc
: /* *Non-nil means deactivate the mark when the buffer contents change.
6001 Non-nil also enables highlighting of the region whenever the mark is active.
6002 The variable `highlight-nonselected-windows' controls whether to highlight
6003 all windows or just the selected window.
6005 If the value is `lambda', that enables Transient Mark mode temporarily
6006 until the next buffer modification. If a command sets the value to `only',
6007 that enables Transient Mark mode for the following command only.
6008 During that following command, the value of `transient-mark-mode'
6009 is `identity'. If it is still `identity' at the end of that command,
6010 it changes to nil. */);
6011 Vtransient_mark_mode
= Qnil
;
6013 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
6014 doc
: /* *Non-nil means disregard read-only status of buffers or characters.
6015 If the value is t, disregard `buffer-read-only' and all `read-only'
6016 text properties. If the value is a list, disregard `buffer-read-only'
6017 and disregard a `read-only' text property if the property value
6018 is a member of the list. */);
6019 Vinhibit_read_only
= Qnil
;
6021 DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer
->cursor_type
, Qnil
,
6022 doc
: /* Cursor to use when this buffer is in the selected window.
6023 Values are interpreted as follows:
6025 t use the cursor specified for the frame
6026 nil don't display a cursor
6027 box display a filled box cursor
6028 hollow display a hollow box cursor
6029 bar display a vertical bar cursor with default width
6030 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6031 hbar display a horizontal bar cursor with default height
6032 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6033 ANYTHING ELSE display a hollow box cursor
6035 When the buffer is displayed in a nonselected window,
6036 this variable has no effect; the cursor appears as a hollow box. */);
6038 DEFVAR_PER_BUFFER ("line-spacing",
6039 ¤t_buffer
->extra_line_spacing
, Qnil
,
6040 doc
: /* Additional space to put between lines when displaying a buffer.
6041 The space is measured in pixels, and put below lines on window systems.
6042 If value is a floating point number, it specifies the spacing relative
6043 to the default frame line height. nil means add no extra space. */);
6045 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6046 ¤t_buffer
->cursor_in_non_selected_windows
, Qnil
,
6047 doc
: /* *Cursor type to display in non-selected windows.
6048 t means to use hollow box cursor. See `cursor-type' for other values. */);
6050 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
6051 doc
: /* List of functions called with no args to query before killing a buffer. */);
6052 Vkill_buffer_query_functions
= Qnil
;
6054 DEFVAR_LISP ("change-major-mode-hook", &Vchange_major_mode_hook
,
6055 doc
: /* Normal hook run before changing the major mode of a buffer.
6056 The function `kill-all-local-variables' runs this before doing anything else. */);
6057 Vchange_major_mode_hook
= Qnil
;
6058 Qchange_major_mode_hook
= intern ("change-major-mode-hook");
6059 staticpro (&Qchange_major_mode_hook
);
6061 defsubr (&Sbuffer_live_p
);
6062 defsubr (&Sbuffer_list
);
6063 defsubr (&Sget_buffer
);
6064 defsubr (&Sget_file_buffer
);
6065 defsubr (&Sget_buffer_create
);
6066 defsubr (&Smake_indirect_buffer
);
6067 defsubr (&Sgenerate_new_buffer_name
);
6068 defsubr (&Sbuffer_name
);
6069 /*defsubr (&Sbuffer_number);*/
6070 defsubr (&Sbuffer_file_name
);
6071 defsubr (&Sbuffer_base_buffer
);
6072 defsubr (&Sbuffer_local_value
);
6073 defsubr (&Sbuffer_local_variables
);
6074 defsubr (&Sbuffer_modified_p
);
6075 defsubr (&Sset_buffer_modified_p
);
6076 defsubr (&Sbuffer_modified_tick
);
6077 defsubr (&Srename_buffer
);
6078 defsubr (&Sother_buffer
);
6079 defsubr (&Sbuffer_enable_undo
);
6080 defsubr (&Skill_buffer
);
6081 defsubr (&Sset_buffer_major_mode
);
6082 defsubr (&Sswitch_to_buffer
);
6083 defsubr (&Spop_to_buffer
);
6084 defsubr (&Scurrent_buffer
);
6085 defsubr (&Sset_buffer
);
6086 defsubr (&Sbarf_if_buffer_read_only
);
6087 defsubr (&Sbury_buffer
);
6088 defsubr (&Serase_buffer
);
6089 defsubr (&Sset_buffer_multibyte
);
6090 defsubr (&Skill_all_local_variables
);
6092 defsubr (&Soverlayp
);
6093 defsubr (&Smake_overlay
);
6094 defsubr (&Sdelete_overlay
);
6095 defsubr (&Smove_overlay
);
6096 defsubr (&Soverlay_start
);
6097 defsubr (&Soverlay_end
);
6098 defsubr (&Soverlay_buffer
);
6099 defsubr (&Soverlay_properties
);
6100 defsubr (&Soverlays_at
);
6101 defsubr (&Soverlays_in
);
6102 defsubr (&Snext_overlay_change
);
6103 defsubr (&Sprevious_overlay_change
);
6104 defsubr (&Soverlay_recenter
);
6105 defsubr (&Soverlay_lists
);
6106 defsubr (&Soverlay_get
);
6107 defsubr (&Soverlay_put
);
6108 defsubr (&Srestore_buffer_modified_p
);
6114 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6115 initial_define_key (control_x_map
, 'k', "kill-buffer");
6117 /* This must not be in syms_of_buffer, because Qdisabled is not
6118 initialized when that function gets called. */
6119 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);
6122 /* arch-tag: e48569bf-69a9-4b65-a23b-8e68769436e1
6123 (do not change this comment) */