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 /* List of functions to call before changing an unmodified buffer. */
150 Lisp_Object Vfirst_change_hook
;
152 Lisp_Object Qfirst_change_hook
;
153 Lisp_Object Qbefore_change_functions
;
154 Lisp_Object Qafter_change_functions
;
155 Lisp_Object Qucs_set_table_for_input
;
157 /* If nonzero, all modification hooks are suppressed. */
158 int inhibit_modification_hooks
;
160 Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
162 Lisp_Object Qprotected_field
;
164 Lisp_Object QSFundamental
; /* A string "Fundamental" */
166 Lisp_Object Qkill_buffer_hook
;
168 Lisp_Object Qget_file_buffer
;
170 Lisp_Object Qoverlayp
;
172 Lisp_Object Qpriority
, Qwindow
, Qevaporate
, Qbefore_string
, Qafter_string
;
174 Lisp_Object Qmodification_hooks
;
175 Lisp_Object Qinsert_in_front_hooks
;
176 Lisp_Object Qinsert_behind_hooks
;
178 static void alloc_buffer_text
P_ ((struct buffer
*, size_t));
179 static void free_buffer_text
P_ ((struct buffer
*b
));
180 static struct Lisp_Overlay
* copy_overlays
P_ ((struct buffer
*, struct Lisp_Overlay
*));
181 static void modify_overlay
P_ ((struct buffer
*, EMACS_INT
, EMACS_INT
));
182 static Lisp_Object buffer_lisp_local_variables
P_ ((struct buffer
*));
185 /* For debugging; temporary. See set_buffer_internal. */
186 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
193 error ("No buffer named %s", SDATA (spec
));
194 error ("Invalid buffer argument");
197 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
198 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
199 Value is nil if OBJECT is not a buffer or if it has been killed. */)
203 return ((BUFFERP (object
) && ! NILP (XBUFFER (object
)->name
))
207 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
208 doc
: /* Return a list of all existing live buffers.
209 If the optional arg FRAME is a frame, we return the buffer list
210 in the proper order for that frame: the buffers in FRAME's `buffer-list'
211 frame parameter come first, followed by the rest of the buffers. */)
215 Lisp_Object framelist
, general
;
216 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
224 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
226 /* Remove from GENERAL any buffer that duplicates one in FRAMELIST. */
228 while (! NILP (tail
))
230 general
= Fdelq (XCAR (tail
), general
);
233 return nconc2 (framelist
, general
);
239 /* Like Fassoc, but use Fstring_equal to compare
240 (which ignores text properties),
241 and don't ever QUIT. */
244 assoc_ignore_text_properties (key
, list
)
245 register Lisp_Object key
;
248 register Lisp_Object tail
;
249 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
251 register Lisp_Object elt
, tem
;
253 tem
= Fstring_equal (Fcar (elt
), key
);
260 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
261 doc
: /* Return the buffer named NAME (a string).
262 If there is no live buffer named NAME, return nil.
263 NAME may also be a buffer; if so, the value is that buffer. */)
265 register Lisp_Object name
;
271 return Fcdr (assoc_ignore_text_properties (name
, Vbuffer_alist
));
274 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
275 doc
: /* Return the buffer visiting file FILENAME (a string).
276 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
277 If there is no such live buffer, return nil.
278 See also `find-buffer-visiting'. */)
280 register Lisp_Object filename
;
282 register Lisp_Object tail
, buf
, tem
;
285 CHECK_STRING (filename
);
286 filename
= Fexpand_file_name (filename
, Qnil
);
288 /* If the file name has special constructs in it,
289 call the corresponding file handler. */
290 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
292 return call2 (handler
, Qget_file_buffer
, filename
);
294 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
296 buf
= Fcdr (XCAR (tail
));
297 if (!BUFFERP (buf
)) continue;
298 if (!STRINGP (XBUFFER (buf
)->filename
)) continue;
299 tem
= Fstring_equal (XBUFFER (buf
)->filename
, filename
);
307 get_truename_buffer (filename
)
308 register Lisp_Object filename
;
310 register Lisp_Object tail
, buf
, tem
;
312 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
314 buf
= Fcdr (XCAR (tail
));
315 if (!BUFFERP (buf
)) continue;
316 if (!STRINGP (XBUFFER (buf
)->file_truename
)) continue;
317 tem
= Fstring_equal (XBUFFER (buf
)->file_truename
, filename
);
324 /* Incremented for each buffer created, to assign the buffer number. */
327 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
328 doc
: /* Return the buffer named NAME, or create such a buffer and return it.
329 A new buffer is created if there is no live buffer named NAME.
330 If NAME starts with a space, the new buffer does not keep undo information.
331 If NAME is a buffer instead of a string, then it is the value returned.
332 The value is never nil. */)
334 register Lisp_Object name
;
336 register Lisp_Object buf
;
337 register struct buffer
*b
;
339 buf
= Fget_buffer (name
);
343 if (SCHARS (name
) == 0)
344 error ("Empty string for buffer name is not allowed");
346 b
= (struct buffer
*) allocate_buffer ();
348 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
350 /* An ordinary buffer uses its own struct buffer_text. */
351 b
->text
= &b
->own_text
;
354 BUF_GAP_SIZE (b
) = 20;
356 /* We allocate extra 1-byte at the tail and keep it always '\0' for
357 anchoring a search. */
358 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
360 if (! BUF_BEG_ADDR (b
))
361 buffer_memory_full ();
368 BUF_PT_BYTE (b
) = BEG_BYTE
;
369 BUF_GPT_BYTE (b
) = BEG_BYTE
;
370 BUF_BEGV_BYTE (b
) = BEG_BYTE
;
371 BUF_ZV_BYTE (b
) = BEG_BYTE
;
372 BUF_Z_BYTE (b
) = BEG_BYTE
;
374 BUF_OVERLAY_MODIFF (b
) = 1;
375 BUF_SAVE_MODIFF (b
) = 1;
376 BUF_INTERVALS (b
) = 0;
377 BUF_UNCHANGED_MODIFIED (b
) = 1;
378 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
379 BUF_END_UNCHANGED (b
) = 0;
380 BUF_BEG_UNCHANGED (b
) = 0;
381 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
383 b
->newline_cache
= 0;
384 b
->width_run_cache
= 0;
385 b
->width_table
= Qnil
;
386 b
->prevent_redisplay_optimizations_p
= 1;
388 /* Put this on the chain of all buffers including killed ones. */
389 b
->next
= all_buffers
;
392 /* An ordinary buffer normally doesn't need markers
393 to handle BEGV and ZV. */
395 b
->begv_marker
= Qnil
;
398 name
= Fcopy_sequence (name
);
399 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
402 if (SREF (name
, 0) != ' ')
408 reset_buffer_local_variables (b
, 1);
410 b
->mark
= Fmake_marker ();
411 BUF_MARKERS (b
) = NULL
;
414 /* Put this in the alist of all live buffers. */
416 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
418 /* An error in calling the function here (should someone redfine it)
419 can lead to infinite regress until you run out of stack. rms
420 says that's not worth protecting against. */
421 if (!NILP (Ffboundp (Qucs_set_table_for_input
)))
422 /* buf is on buffer-alist, so no gcpro. */
423 call1 (Qucs_set_table_for_input
, buf
);
429 /* Return a list of overlays which is a copy of the overlay list
430 LIST, but for buffer B. */
432 static struct Lisp_Overlay
*
433 copy_overlays (b
, list
)
435 struct Lisp_Overlay
*list
;
438 struct Lisp_Overlay
*result
= NULL
, *tail
= NULL
;
440 XSETBUFFER (buffer
, b
);
442 for (; list
; list
= list
->next
)
444 Lisp_Object overlay
, start
, end
, old_overlay
;
447 XSETMISC (old_overlay
, list
);
448 charpos
= marker_position (OVERLAY_START (old_overlay
));
449 start
= Fmake_marker ();
450 Fset_marker (start
, make_number (charpos
), buffer
);
451 XMARKER (start
)->insertion_type
452 = XMARKER (OVERLAY_START (old_overlay
))->insertion_type
;
454 charpos
= marker_position (OVERLAY_END (old_overlay
));
455 end
= Fmake_marker ();
456 Fset_marker (end
, make_number (charpos
), buffer
);
457 XMARKER (end
)->insertion_type
458 = XMARKER (OVERLAY_END (old_overlay
))->insertion_type
;
460 overlay
= allocate_misc ();
461 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
462 OVERLAY_START (overlay
) = start
;
463 OVERLAY_END (overlay
) = end
;
464 OVERLAY_PLIST (overlay
) = Fcopy_sequence (OVERLAY_PLIST (old_overlay
));
465 XOVERLAY (overlay
)->next
= NULL
;
468 tail
= tail
->next
= XOVERLAY (overlay
);
470 result
= tail
= XOVERLAY (overlay
);
477 /* Clone per-buffer values of buffer FROM.
479 Buffer TO gets the same per-buffer values as FROM, with the
480 following exceptions: (1) TO's name is left untouched, (2) markers
481 are copied and made to refer to TO, and (3) overlay lists are
485 clone_per_buffer_values (from
, to
)
486 struct buffer
*from
, *to
;
488 Lisp_Object to_buffer
;
491 XSETBUFFER (to_buffer
, to
);
493 for (offset
= PER_BUFFER_VAR_OFFSET (name
) + sizeof (Lisp_Object
);
495 offset
+= sizeof (Lisp_Object
))
499 obj
= PER_BUFFER_VALUE (from
, offset
);
502 struct Lisp_Marker
*m
= XMARKER (obj
);
503 obj
= Fmake_marker ();
504 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
505 set_marker_both (obj
, to_buffer
, m
->charpos
, m
->bytepos
);
508 PER_BUFFER_VALUE (to
, offset
) = obj
;
511 bcopy (from
->local_flags
, to
->local_flags
, sizeof to
->local_flags
);
513 to
->overlays_before
= copy_overlays (to
, from
->overlays_before
);
514 to
->overlays_after
= copy_overlays (to
, from
->overlays_after
);
516 /* Get (a copy of) the alist of Lisp-level local variables of FROM
517 and install that in TO. */
518 to
->local_var_alist
= buffer_lisp_local_variables (from
);
521 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
523 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
524 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
525 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
526 NAME should be a string which is not the name of an existing buffer.
527 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
528 such as major and minor modes, in the indirect buffer.
529 CLONE nil means the indirect buffer's state is reset to default values. */)
530 (base_buffer
, name
, clone
)
531 Lisp_Object base_buffer
, name
, clone
;
533 Lisp_Object buf
, tem
;
537 buf
= Fget_buffer (name
);
539 error ("Buffer name `%s' is in use", SDATA (name
));
542 base_buffer
= Fget_buffer (base_buffer
);
543 if (NILP (base_buffer
))
544 error ("No such buffer: `%s'", SDATA (tem
));
545 if (NILP (XBUFFER (base_buffer
)->name
))
546 error ("Base buffer has been killed");
548 if (SCHARS (name
) == 0)
549 error ("Empty string for buffer name is not allowed");
551 b
= (struct buffer
*) allocate_buffer ();
552 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
554 if (XBUFFER (base_buffer
)->base_buffer
)
555 b
->base_buffer
= XBUFFER (base_buffer
)->base_buffer
;
557 b
->base_buffer
= XBUFFER (base_buffer
);
559 /* Use the base buffer's text object. */
560 b
->text
= b
->base_buffer
->text
;
562 BUF_BEGV (b
) = BUF_BEGV (b
->base_buffer
);
563 BUF_ZV (b
) = BUF_ZV (b
->base_buffer
);
564 BUF_PT (b
) = BUF_PT (b
->base_buffer
);
565 BUF_BEGV_BYTE (b
) = BUF_BEGV_BYTE (b
->base_buffer
);
566 BUF_ZV_BYTE (b
) = BUF_ZV_BYTE (b
->base_buffer
);
567 BUF_PT_BYTE (b
) = BUF_PT_BYTE (b
->base_buffer
);
569 b
->newline_cache
= 0;
570 b
->width_run_cache
= 0;
571 b
->width_table
= Qnil
;
573 /* Put this on the chain of all buffers including killed ones. */
574 b
->next
= all_buffers
;
577 name
= Fcopy_sequence (name
);
578 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
582 reset_buffer_local_variables (b
, 1);
584 /* Put this in the alist of all live buffers. */
586 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
588 b
->mark
= Fmake_marker ();
591 /* The multibyte status belongs to the base buffer. */
592 b
->enable_multibyte_characters
= b
->base_buffer
->enable_multibyte_characters
;
594 /* Make sure the base buffer has markers for its narrowing. */
595 if (NILP (b
->base_buffer
->pt_marker
))
597 b
->base_buffer
->pt_marker
= Fmake_marker ();
598 set_marker_both (b
->base_buffer
->pt_marker
, base_buffer
,
599 BUF_PT (b
->base_buffer
),
600 BUF_PT_BYTE (b
->base_buffer
));
602 if (NILP (b
->base_buffer
->begv_marker
))
604 b
->base_buffer
->begv_marker
= Fmake_marker ();
605 set_marker_both (b
->base_buffer
->begv_marker
, base_buffer
,
606 BUF_BEGV (b
->base_buffer
),
607 BUF_BEGV_BYTE (b
->base_buffer
));
609 if (NILP (b
->base_buffer
->zv_marker
))
611 b
->base_buffer
->zv_marker
= Fmake_marker ();
612 set_marker_both (b
->base_buffer
->zv_marker
, base_buffer
,
613 BUF_ZV (b
->base_buffer
),
614 BUF_ZV_BYTE (b
->base_buffer
));
615 XMARKER (b
->base_buffer
->zv_marker
)->insertion_type
= 1;
620 /* Give the indirect buffer markers for its narrowing. */
621 b
->pt_marker
= Fmake_marker ();
622 set_marker_both (b
->pt_marker
, buf
, BUF_PT (b
), BUF_PT_BYTE (b
));
623 b
->begv_marker
= Fmake_marker ();
624 set_marker_both (b
->begv_marker
, buf
, BUF_BEGV (b
), BUF_BEGV_BYTE (b
));
625 b
->zv_marker
= Fmake_marker ();
626 set_marker_both (b
->zv_marker
, buf
, BUF_ZV (b
), BUF_ZV_BYTE (b
));
627 XMARKER (b
->zv_marker
)->insertion_type
= 1;
631 struct buffer
*old_b
= current_buffer
;
633 clone_per_buffer_values (b
->base_buffer
, b
);
635 b
->file_truename
= Qnil
;
636 b
->display_count
= make_number (0);
638 b
->auto_save_file_name
= Qnil
;
639 set_buffer_internal_1 (b
);
640 Fset (intern ("buffer-save-without-query"), Qnil
);
641 Fset (intern ("buffer-file-number"), Qnil
);
642 Fset (intern ("buffer-stale-function"), Qnil
);
643 set_buffer_internal_1 (old_b
);
650 delete_all_overlays (b
)
655 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
656 have to empty the list, otherwise we end up with overlays that
657 think they belong to this buffer while the buffer doesn't know about
659 while (b
->overlays_before
)
661 XSETMISC (overlay
, b
->overlays_before
);
662 Fdelete_overlay (overlay
);
664 while (b
->overlays_after
)
666 XSETMISC (overlay
, b
->overlays_after
);
667 Fdelete_overlay (overlay
);
669 eassert (b
->overlays_before
== NULL
);
670 eassert (b
->overlays_after
== NULL
);
673 /* Reinitialize everything about a buffer except its name and contents
675 If called on an already-initialized buffer, the list of overlays
676 should be deleted before calling this function, otherwise we end up
677 with overlays that claim to belong to the buffer but the buffer
678 claims it doesn't belong to it. */
682 register struct buffer
*b
;
685 b
->file_truename
= Qnil
;
686 b
->directory
= (current_buffer
) ? current_buffer
->directory
: Qnil
;
688 XSETFASTINT (b
->save_length
, 0);
689 b
->last_window_start
= 1;
690 /* It is more conservative to start out "changed" than "unchanged". */
692 b
->prevent_redisplay_optimizations_p
= 1;
694 b
->auto_save_modified
= 0;
695 b
->auto_save_failure_time
= -1;
696 b
->auto_save_file_name
= Qnil
;
698 b
->overlays_before
= NULL
;
699 b
->overlays_after
= NULL
;
700 b
->overlay_center
= BEG
;
701 b
->mark_active
= Qnil
;
702 b
->point_before_scroll
= Qnil
;
703 b
->file_format
= Qnil
;
704 b
->auto_save_file_format
= Qt
;
705 b
->last_selected_window
= Qnil
;
706 XSETINT (b
->display_count
, 0);
707 b
->display_time
= Qnil
;
708 b
->enable_multibyte_characters
= buffer_defaults
.enable_multibyte_characters
;
709 b
->cursor_type
= buffer_defaults
.cursor_type
;
710 b
->extra_line_spacing
= buffer_defaults
.extra_line_spacing
;
712 b
->display_error_modiff
= 0;
715 /* Reset buffer B's local variables info.
716 Don't use this on a buffer that has already been in use;
717 it does not treat permanent locals consistently.
718 Instead, use Fkill_all_local_variables.
720 If PERMANENT_TOO is 1, then we reset permanent built-in
721 buffer-local variables. If PERMANENT_TOO is 0,
722 we preserve those. */
725 reset_buffer_local_variables (b
, permanent_too
)
726 register struct buffer
*b
;
732 /* Reset the major mode to Fundamental, together with all the
733 things that depend on the major mode.
734 default-major-mode is handled at a higher level.
735 We ignore it here. */
736 b
->major_mode
= Qfundamental_mode
;
738 b
->mode_name
= QSFundamental
;
739 b
->minor_modes
= Qnil
;
741 /* If the standard case table has been altered and invalidated,
742 fix up its insides first. */
743 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
744 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
745 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
746 Fset_standard_case_table (Vascii_downcase_table
);
748 b
->downcase_table
= Vascii_downcase_table
;
749 b
->upcase_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
750 b
->case_canon_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
751 b
->case_eqv_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
752 b
->invisibility_spec
= Qt
;
754 b
->buffer_file_type
= Qnil
;
757 /* Reset all (or most) per-buffer variables to their defaults. */
758 b
->local_var_alist
= Qnil
;
759 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
760 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
761 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
763 /* For each slot that has a default value,
764 copy that into the slot. */
766 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
768 offset
+= sizeof (Lisp_Object
))
770 int idx
= PER_BUFFER_IDX (offset
);
773 || buffer_permanent_local_flags
[idx
] == 0))
774 /* Is -2 used anywhere? */
776 PER_BUFFER_VALUE (b
, offset
) = PER_BUFFER_DEFAULT (offset
);
780 /* We split this away from generate-new-buffer, because rename-buffer
781 and set-visited-file-name ought to be able to use this to really
782 rename the buffer properly. */
784 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
786 doc
: /* Return a string that is the name of no existing buffer based on NAME.
787 If there is no live buffer named NAME, then return NAME.
788 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
789 \(starting at 2) until an unused name is found, and then return that name.
790 Optional second argument IGNORE specifies a name that is okay to use
791 \(if it is in the sequence to be tried)
792 even if a buffer with that name exists. */)
794 register Lisp_Object name
, ignore
;
796 register Lisp_Object gentemp
, tem
;
802 tem
= Fstring_equal (name
, ignore
);
805 tem
= Fget_buffer (name
);
812 sprintf (number
, "<%d>", ++count
);
813 gentemp
= concat2 (name
, build_string (number
));
814 tem
= Fstring_equal (gentemp
, ignore
);
817 tem
= Fget_buffer (gentemp
);
824 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
825 doc
: /* Return the name of BUFFER, as a string.
826 With no argument or nil as argument, return the name of the current buffer. */)
828 register Lisp_Object buffer
;
831 return current_buffer
->name
;
832 CHECK_BUFFER (buffer
);
833 return XBUFFER (buffer
)->name
;
836 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
837 doc
: /* Return name of file BUFFER is visiting, or nil if none.
838 No argument or nil as argument means use the current buffer. */)
840 register Lisp_Object buffer
;
843 return current_buffer
->filename
;
844 CHECK_BUFFER (buffer
);
845 return XBUFFER (buffer
)->filename
;
848 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
850 doc
: /* Return the base buffer of indirect buffer BUFFER.
851 If BUFFER is not indirect, return nil.
852 BUFFER defaults to the current buffer. */)
854 register Lisp_Object buffer
;
857 Lisp_Object base_buffer
;
860 base
= current_buffer
->base_buffer
;
863 CHECK_BUFFER (buffer
);
864 base
= XBUFFER (buffer
)->base_buffer
;
869 XSETBUFFER (base_buffer
, base
);
873 DEFUN ("buffer-local-value", Fbuffer_local_value
,
874 Sbuffer_local_value
, 2, 2, 0,
875 doc
: /* Return the value of VARIABLE in BUFFER.
876 If VARIABLE does not have a buffer-local binding in BUFFER, the value
877 is the default binding of the variable. */)
879 register Lisp_Object variable
;
880 register Lisp_Object buffer
;
882 register struct buffer
*buf
;
883 register Lisp_Object result
;
885 CHECK_SYMBOL (variable
);
886 CHECK_BUFFER (buffer
);
887 buf
= XBUFFER (buffer
);
889 if (SYMBOLP (variable
))
890 variable
= indirect_variable (variable
);
892 /* Look in local_var_list */
893 result
= Fassoc (variable
, buf
->local_var_alist
);
899 /* Look in special slots */
900 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
901 offset
< sizeof (struct buffer
);
902 /* sizeof EMACS_INT == sizeof Lisp_Object */
903 offset
+= (sizeof (EMACS_INT
)))
905 idx
= PER_BUFFER_IDX (offset
);
906 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
907 && SYMBOLP (PER_BUFFER_SYMBOL (offset
))
908 && EQ (PER_BUFFER_SYMBOL (offset
), variable
))
910 result
= PER_BUFFER_VALUE (buf
, offset
);
917 result
= Fdefault_value (variable
);
921 Lisp_Object valcontents
;
922 Lisp_Object current_alist_element
;
924 /* What binding is loaded right now? */
925 valcontents
= SYMBOL_VALUE (variable
);
926 current_alist_element
927 = XCAR (XBUFFER_LOCAL_VALUE (valcontents
)->cdr
);
929 /* The value of the currently loaded binding is not
930 stored in it, but rather in the realvalue slot.
931 Store that value into the binding it belongs to
932 in case that is the one we are about to use. */
934 Fsetcdr (current_alist_element
,
935 do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
));
937 /* Now get the (perhaps updated) value out of the binding. */
938 result
= XCDR (result
);
941 if (!EQ (result
, Qunbound
))
944 xsignal1 (Qvoid_variable
, variable
);
947 /* Return an alist of the Lisp-level buffer-local bindings of
948 buffer BUF. That is, don't include the variables maintained
949 in special slots in the buffer object. */
952 buffer_lisp_local_variables (buf
)
955 Lisp_Object result
= Qnil
;
956 register Lisp_Object tail
;
957 for (tail
= buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
959 Lisp_Object val
, elt
;
963 /* Reference each variable in the alist in buf.
964 If inquiring about the current buffer, this gets the current values,
965 so store them into the alist so the alist is up to date.
966 If inquiring about some other buffer, this swaps out any values
967 for that buffer, making the alist up to date automatically. */
968 val
= find_symbol_value (XCAR (elt
));
969 /* Use the current buffer value only if buf is the current buffer. */
970 if (buf
!= current_buffer
)
973 /* If symbol is unbound, put just the symbol in the list. */
974 if (EQ (val
, Qunbound
))
975 result
= Fcons (XCAR (elt
), result
);
976 /* Otherwise, put (symbol . value) in the list. */
978 result
= Fcons (Fcons (XCAR (elt
), val
), result
);
984 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
985 Sbuffer_local_variables
, 0, 1, 0,
986 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
987 Most elements look like (SYMBOL . VALUE), describing one variable.
988 For a symbol that is locally unbound, just the symbol appears in the value.
989 Note that storing new VALUEs in these elements doesn't change the variables.
990 No argument or nil as argument means use current buffer as BUFFER. */)
992 register Lisp_Object buffer
;
994 register struct buffer
*buf
;
995 register Lisp_Object result
;
998 buf
= current_buffer
;
1001 CHECK_BUFFER (buffer
);
1002 buf
= XBUFFER (buffer
);
1005 result
= buffer_lisp_local_variables (buf
);
1007 /* Add on all the variables stored in special slots. */
1011 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
1012 offset
< sizeof (struct buffer
);
1013 /* sizeof EMACS_INT == sizeof Lisp_Object */
1014 offset
+= (sizeof (EMACS_INT
)))
1016 idx
= PER_BUFFER_IDX (offset
);
1017 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
1018 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
1019 result
= Fcons (Fcons (PER_BUFFER_SYMBOL (offset
),
1020 PER_BUFFER_VALUE (buf
, offset
)),
1028 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
1030 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
1031 No argument or nil as argument means use current buffer as BUFFER. */)
1033 register Lisp_Object buffer
;
1035 register struct buffer
*buf
;
1037 buf
= current_buffer
;
1040 CHECK_BUFFER (buffer
);
1041 buf
= XBUFFER (buffer
);
1044 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
1047 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
1049 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
1050 A non-nil FLAG means mark the buffer modified. */)
1052 register Lisp_Object flag
;
1054 register int already
;
1055 register Lisp_Object fn
;
1056 Lisp_Object buffer
, window
;
1058 #ifdef CLASH_DETECTION
1059 /* If buffer becoming modified, lock the file.
1060 If buffer becoming unmodified, unlock the file. */
1062 fn
= current_buffer
->file_truename
;
1063 /* Test buffer-file-name so that binding it to nil is effective. */
1064 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1066 already
= SAVE_MODIFF
< MODIFF
;
1067 if (!already
&& !NILP (flag
))
1069 else if (already
&& NILP (flag
))
1072 #endif /* CLASH_DETECTION */
1074 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1076 /* Set update_mode_lines only if buffer is displayed in some window.
1077 Packages like jit-lock or lazy-lock preserve a buffer's modified
1078 state by recording/restoring the state around blocks of code.
1079 Setting update_mode_lines makes redisplay consider all windows
1080 (on all frames). Stealth fontification of buffers not displayed
1081 would incur additional redisplay costs if we'd set
1082 update_modes_lines unconditionally.
1084 Ideally, I think there should be another mechanism for fontifying
1085 buffers without "modifying" buffers, or redisplay should be
1086 smarter about updating the `*' in mode lines. --gerd */
1087 XSETBUFFER (buffer
, current_buffer
);
1088 window
= Fget_buffer_window (buffer
, Qt
);
1089 if (WINDOWP (window
))
1091 ++update_mode_lines
;
1092 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1098 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1099 Srestore_buffer_modified_p
, 1, 1, 0,
1100 doc
: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1101 It is not ensured that mode lines will be updated to show the modified
1102 state of the current buffer. Use with care. */)
1106 #ifdef CLASH_DETECTION
1109 /* If buffer becoming modified, lock the file.
1110 If buffer becoming unmodified, unlock the file. */
1112 fn
= current_buffer
->file_truename
;
1113 /* Test buffer-file-name so that binding it to nil is effective. */
1114 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1116 int already
= SAVE_MODIFF
< MODIFF
;
1117 if (!already
&& !NILP (flag
))
1119 else if (already
&& NILP (flag
))
1122 #endif /* CLASH_DETECTION */
1124 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1128 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1130 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1131 Each buffer has a tick counter which is incremented each time the text in
1132 that buffer is changed. It wraps around occasionally.
1133 No argument or nil as argument means use current buffer as BUFFER. */)
1135 register Lisp_Object buffer
;
1137 register struct buffer
*buf
;
1139 buf
= current_buffer
;
1142 CHECK_BUFFER (buffer
);
1143 buf
= XBUFFER (buffer
);
1146 return make_number (BUF_MODIFF (buf
));
1149 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1150 "sRename buffer (to new name): \nP",
1151 doc
: /* Change current buffer's name to NEWNAME (a string).
1152 If second arg UNIQUE is nil or omitted, it is an error if a
1153 buffer named NEWNAME already exists.
1154 If UNIQUE is non-nil, come up with a new name using
1155 `generate-new-buffer-name'.
1156 Interactively, you can set UNIQUE with a prefix argument.
1157 We return the name we actually gave the buffer.
1158 This does not change the name of the visited file (if any). */)
1160 register Lisp_Object newname
, unique
;
1162 register Lisp_Object tem
, buf
;
1164 CHECK_STRING (newname
);
1166 if (SCHARS (newname
) == 0)
1167 error ("Empty string is invalid as a buffer name");
1169 tem
= Fget_buffer (newname
);
1172 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1173 rename the buffer automatically so you can create another
1174 with the original name. It makes UNIQUE equivalent to
1175 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1176 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1177 return current_buffer
->name
;
1179 newname
= Fgenerate_new_buffer_name (newname
, current_buffer
->name
);
1181 error ("Buffer name `%s' is in use", SDATA (newname
));
1184 current_buffer
->name
= newname
;
1186 /* Catch redisplay's attention. Unless we do this, the mode lines for
1187 any windows displaying current_buffer will stay unchanged. */
1188 update_mode_lines
++;
1190 XSETBUFFER (buf
, current_buffer
);
1191 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1192 if (NILP (current_buffer
->filename
)
1193 && !NILP (current_buffer
->auto_save_file_name
))
1194 call0 (intern ("rename-auto-save-file"));
1195 /* Refetch since that last call may have done GC. */
1196 return current_buffer
->name
;
1199 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1200 doc
: /* Return most recently selected buffer other than BUFFER.
1201 Buffers not visible in windows are preferred to visible buffers,
1202 unless optional second argument VISIBLE-OK is non-nil.
1203 If the optional third argument FRAME is non-nil, use that frame's
1204 buffer list instead of the selected frame's buffer list.
1205 If no other buffer exists, the buffer `*scratch*' is returned.
1206 If BUFFER is omitted or nil, some interesting buffer is returned. */)
1207 (buffer
, visible_ok
, frame
)
1208 register Lisp_Object buffer
, visible_ok
, frame
;
1210 Lisp_Object
Fset_buffer_major_mode ();
1211 register Lisp_Object tail
, buf
, notsogood
, tem
, pred
, add_ons
;
1215 frame
= selected_frame
;
1217 tail
= Vbuffer_alist
;
1218 pred
= frame_buffer_predicate (frame
);
1220 /* Consider buffers that have been seen in the selected frame
1221 before other buffers. */
1223 tem
= frame_buffer_list (frame
);
1227 if (BUFFERP (XCAR (tem
)))
1228 add_ons
= Fcons (Fcons (Qnil
, XCAR (tem
)), add_ons
);
1231 tail
= nconc2 (Fnreverse (add_ons
), tail
);
1233 for (; CONSP (tail
); tail
= XCDR (tail
))
1235 buf
= Fcdr (XCAR (tail
));
1236 if (EQ (buf
, buffer
))
1240 if (NILP (XBUFFER (buf
)->name
))
1242 if (SREF (XBUFFER (buf
)->name
, 0) == ' ')
1244 /* If the selected frame has a buffer_predicate,
1245 disregard buffers that don't fit the predicate. */
1248 tem
= call1 (pred
, buf
);
1253 if (NILP (visible_ok
))
1254 tem
= Fget_buffer_window (buf
, Qvisible
);
1259 if (NILP (notsogood
))
1262 if (!NILP (notsogood
))
1264 buf
= Fget_buffer (build_string ("*scratch*"));
1267 buf
= Fget_buffer_create (build_string ("*scratch*"));
1268 Fset_buffer_major_mode (buf
);
1273 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1275 doc
: /* Start keeping undo information for buffer BUFFER.
1276 No argument or nil as argument means do this for the current buffer. */)
1278 register Lisp_Object buffer
;
1280 Lisp_Object real_buffer
;
1283 XSETBUFFER (real_buffer
, current_buffer
);
1286 real_buffer
= Fget_buffer (buffer
);
1287 if (NILP (real_buffer
))
1291 if (EQ (XBUFFER (real_buffer
)->undo_list
, Qt
))
1292 XBUFFER (real_buffer
)->undo_list
= Qnil
;
1298 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
1299 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
1300 The buffer being killed will be current while the hook is running.\n\
1303 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 1, 1, "bKill buffer: ",
1304 doc
: /* Kill the buffer BUFFER.
1305 The argument may be a buffer or may be the name of a buffer.
1306 An argument of nil means kill the current buffer.
1308 Value is t if the buffer is actually killed, nil if user says no.
1310 The value of `kill-buffer-hook' (which may be local to that buffer),
1311 if not void, is a list of functions to be called, with no arguments,
1312 before the buffer is actually killed. The buffer to be killed is current
1313 when the hook functions are called.
1315 Any processes that have this buffer as the `process-buffer' are killed
1321 register struct buffer
*b
;
1322 register Lisp_Object tem
;
1323 register struct Lisp_Marker
*m
;
1324 struct gcpro gcpro1
;
1327 buf
= Fcurrent_buffer ();
1329 buf
= Fget_buffer (buffer
);
1335 /* Avoid trouble for buffer already dead. */
1339 /* Query if the buffer is still modified. */
1340 if (INTERACTIVE
&& !NILP (b
->filename
)
1341 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1344 tem
= do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1345 b
->name
, make_number (0)));
1351 /* Run hooks with the buffer to be killed the current buffer. */
1353 int count
= SPECPDL_INDEX ();
1354 Lisp_Object arglist
[1];
1356 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1357 set_buffer_internal (b
);
1359 /* First run the query functions; if any query is answered no,
1360 don't kill the buffer. */
1361 arglist
[0] = Qkill_buffer_query_functions
;
1362 tem
= Frun_hook_with_args_until_failure (1, arglist
);
1364 return unbind_to (count
, Qnil
);
1366 /* Then run the hooks. */
1367 Frun_hooks (1, &Qkill_buffer_hook
);
1368 unbind_to (count
, Qnil
);
1371 /* We have no more questions to ask. Verify that it is valid
1372 to kill the buffer. This must be done after the questions
1373 since anything can happen within do_yes_or_no_p. */
1375 /* Don't kill the minibuffer now current. */
1376 if (EQ (buf
, XWINDOW (minibuf_window
)->buffer
))
1382 /* When we kill a base buffer, kill all its indirect buffers.
1383 We do it at this stage so nothing terrible happens if they
1384 ask questions or their hooks get errors. */
1385 if (! b
->base_buffer
)
1387 struct buffer
*other
;
1391 for (other
= all_buffers
; other
; other
= other
->next
)
1392 /* all_buffers contains dead buffers too;
1393 don't re-kill them. */
1394 if (other
->base_buffer
== b
&& !NILP (other
->name
))
1397 XSETBUFFER (buf
, other
);
1404 /* Make this buffer not be current.
1405 In the process, notice if this is the sole visible buffer
1406 and give up if so. */
1407 if (b
== current_buffer
)
1409 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1411 if (b
== current_buffer
)
1415 /* Notice if the buffer to kill is the sole visible buffer
1416 when we're currently in the mini-buffer, and give up if so. */
1417 XSETBUFFER (tem
, current_buffer
);
1418 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
))
1420 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1425 /* Now there is no question: we can kill the buffer. */
1427 #ifdef CLASH_DETECTION
1428 /* Unlock this buffer's file, if it is locked. */
1430 #endif /* CLASH_DETECTION */
1432 kill_buffer_processes (buf
);
1433 clear_charpos_cache (b
);
1435 tem
= Vinhibit_quit
;
1437 replace_buffer_in_all_windows (buf
);
1438 Vbuffer_alist
= Fdelq (Frassq (buf
, Vbuffer_alist
), Vbuffer_alist
);
1439 frames_discard_buffer (buf
);
1440 Vinhibit_quit
= tem
;
1442 /* Delete any auto-save file, if we saved it in this session.
1443 But not if the buffer is modified. */
1444 if (STRINGP (b
->auto_save_file_name
)
1445 && b
->auto_save_modified
!= 0
1446 && BUF_SAVE_MODIFF (b
) < b
->auto_save_modified
1447 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
)
1448 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1451 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
1453 internal_delete_file (b
->auto_save_file_name
);
1458 /* Unchain all markers that belong to this indirect buffer.
1459 Don't unchain the markers that belong to the base buffer
1460 or its other indirect buffers. */
1461 for (m
= BUF_MARKERS (b
); m
; )
1463 struct Lisp_Marker
*next
= m
->next
;
1471 /* Unchain all markers of this buffer and its indirect buffers.
1472 and leave them pointing nowhere. */
1473 for (m
= BUF_MARKERS (b
); m
; )
1475 struct Lisp_Marker
*next
= m
->next
;
1480 BUF_MARKERS (b
) = NULL
;
1481 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1483 /* Perhaps we should explicitly free the interval tree here... */
1486 /* Reset the local variables, so that this buffer's local values
1487 won't be protected from GC. They would be protected
1488 if they happened to remain encached in their symbols.
1489 This gets rid of them for certain. */
1490 swap_out_buffer_local_variables (b
);
1491 reset_buffer_local_variables (b
, 1);
1496 if (! b
->base_buffer
)
1497 free_buffer_text (b
);
1499 if (b
->newline_cache
)
1501 free_region_cache (b
->newline_cache
);
1502 b
->newline_cache
= 0;
1504 if (b
->width_run_cache
)
1506 free_region_cache (b
->width_run_cache
);
1507 b
->width_run_cache
= 0;
1509 b
->width_table
= Qnil
;
1511 b
->undo_list
= Qnil
;
1516 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
1517 we do this each time BUF is selected visibly, the more recently
1518 selected buffers are always closer to the front of the list. This
1519 means that other_buffer is more likely to choose a relevant buffer. */
1525 register Lisp_Object link
, prev
;
1527 frame
= selected_frame
;
1530 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCDR (link
))
1532 if (EQ (XCDR (XCAR (link
)), buf
))
1537 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
1538 we cannot use Fdelq itself here because it allows quitting. */
1541 Vbuffer_alist
= XCDR (Vbuffer_alist
);
1543 XSETCDR (prev
, XCDR (XCDR (prev
)));
1545 XSETCDR (link
, Vbuffer_alist
);
1546 Vbuffer_alist
= link
;
1548 /* Now move this buffer to the front of frame_buffer_list also. */
1551 for (link
= frame_buffer_list (frame
); CONSP (link
);
1554 if (EQ (XCAR (link
), buf
))
1559 /* Effectively do delq. */
1564 set_frame_buffer_list (frame
,
1565 XCDR (frame_buffer_list (frame
)));
1567 XSETCDR (prev
, XCDR (XCDR (prev
)));
1569 XSETCDR (link
, frame_buffer_list (frame
));
1570 set_frame_buffer_list (frame
, link
);
1573 set_frame_buffer_list (frame
, Fcons (buf
, frame_buffer_list (frame
)));
1576 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1577 doc
: /* Set an appropriate major mode for BUFFER.
1578 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1579 according to `default-major-mode'.
1580 Use this function before selecting the buffer, since it may need to inspect
1581 the current buffer's major mode. */)
1586 Lisp_Object function
;
1588 if (STRINGP (XBUFFER (buffer
)->name
)
1589 && strcmp (SDATA (XBUFFER (buffer
)->name
), "*scratch*") == 0)
1590 function
= find_symbol_value (intern ("initial-major-mode"));
1593 function
= buffer_defaults
.major_mode
;
1595 && NILP (Fget (current_buffer
->major_mode
, Qmode_class
)))
1596 function
= current_buffer
->major_mode
;
1599 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1602 count
= SPECPDL_INDEX ();
1604 /* To select a nonfundamental mode,
1605 select the buffer temporarily and then call the mode function. */
1607 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1609 Fset_buffer (buffer
);
1612 return unbind_to (count
, Qnil
);
1615 /* If switching buffers in WINDOW would be an error, return
1616 a C string saying what the error would be. */
1619 no_switch_window (window
)
1623 if (EQ (minibuf_window
, window
))
1624 return "Cannot switch buffers in minibuffer window";
1625 tem
= Fwindow_dedicated_p (window
);
1627 return "Cannot switch buffers in a dedicated window";
1631 /* Switch to buffer BUFFER in the selected window.
1632 If NORECORD is non-nil, don't call record_buffer. */
1635 switch_to_buffer_1 (buffer
, norecord
)
1636 Lisp_Object buffer
, norecord
;
1638 register Lisp_Object buf
;
1641 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1644 buf
= Fget_buffer (buffer
);
1647 buf
= Fget_buffer_create (buffer
);
1648 Fset_buffer_major_mode (buf
);
1652 if (NILP (norecord
))
1653 record_buffer (buf
);
1655 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
1656 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
1663 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2, "BSwitch to buffer: ",
1664 doc
: /* Select buffer BUFFER in the current window.
1665 If BUFFER does not identify an existing buffer,
1666 then this function creates a buffer with that name.
1668 When called from Lisp, BUFFER may be a buffer, a string \(a buffer name),
1669 or nil. If BUFFER is nil, then this function chooses a buffer
1670 using `other-buffer'.
1671 Optional second arg NORECORD non-nil means
1672 do not put this buffer at the front of the list of recently selected ones.
1673 This function returns the buffer it switched to.
1675 WARNING: This is NOT the way to work on another buffer temporarily
1676 within a Lisp program! Use `set-buffer' instead. That avoids messing with
1677 the window-buffer correspondences. */)
1679 Lisp_Object buffer
, norecord
;
1683 if (EQ (buffer
, Fwindow_buffer (selected_window
)))
1684 /* Basically a NOP. Avoid signalling an error if the selected window
1685 is dedicated, or a minibuffer, ... */
1686 return Fset_buffer (buffer
);
1688 err
= no_switch_window (selected_window
);
1689 if (err
) error (err
);
1691 return switch_to_buffer_1 (buffer
, norecord
);
1694 DEFUN ("pop-to-buffer", Fpop_to_buffer
, Spop_to_buffer
, 1, 3, 0,
1695 doc
: /* Select buffer BUFFER in some window, preferably a different one.
1696 BUFFER may be a buffer, a string \(a buffer name), or nil.
1697 If BUFFER is a string which is not the name of an existing buffer,
1698 then this function creates a buffer with that name.
1699 If BUFFER is nil, then it chooses some other buffer.
1700 If `pop-up-windows' is non-nil, windows can be split to do this.
1701 If optional second arg OTHER-WINDOW is non-nil, insist on finding another
1702 window even if BUFFER is already visible in the selected window,
1703 and ignore `same-window-regexps' and `same-window-buffer-names'.
1704 This function returns the buffer it switched to.
1705 This uses the function `display-buffer' as a subroutine; see the documentation
1706 of `display-buffer' for additional customization information.
1708 Optional third arg NORECORD non-nil means
1709 do not put this buffer at the front of the list of recently selected ones. */)
1710 (buffer
, other_window
, norecord
)
1711 Lisp_Object buffer
, other_window
, norecord
;
1713 register Lisp_Object buf
;
1715 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1718 buf
= Fget_buffer (buffer
);
1721 buf
= Fget_buffer_create (buffer
);
1722 Fset_buffer_major_mode (buf
);
1726 Fselect_window (Fdisplay_buffer (buf
, other_window
, Qnil
), norecord
);
1730 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1731 doc
: /* Return the current buffer as a Lisp object. */)
1734 register Lisp_Object buf
;
1735 XSETBUFFER (buf
, current_buffer
);
1739 /* Set the current buffer to B.
1741 We previously set windows_or_buffers_changed here to invalidate
1742 global unchanged information in beg_unchanged and end_unchanged.
1743 This is no longer necessary because we now compute unchanged
1744 information on a buffer-basis. Every action affecting other
1745 windows than the selected one requires a select_window at some
1746 time, and that increments windows_or_buffers_changed. */
1749 set_buffer_internal (b
)
1750 register struct buffer
*b
;
1752 if (current_buffer
!= b
)
1753 set_buffer_internal_1 (b
);
1756 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1757 This is used by redisplay. */
1760 set_buffer_internal_1 (b
)
1761 register struct buffer
*b
;
1763 register struct buffer
*old_buf
;
1764 register Lisp_Object tail
, valcontents
;
1767 #ifdef USE_MMAP_FOR_BUFFERS
1768 if (b
->text
->beg
== NULL
)
1769 enlarge_buffer_text (b
, 0);
1770 #endif /* USE_MMAP_FOR_BUFFERS */
1772 if (current_buffer
== b
)
1775 old_buf
= current_buffer
;
1777 last_known_column_point
= -1; /* invalidate indentation cache */
1781 /* Put the undo list back in the base buffer, so that it appears
1782 that an indirect buffer shares the undo list of its base. */
1783 if (old_buf
->base_buffer
)
1784 old_buf
->base_buffer
->undo_list
= old_buf
->undo_list
;
1786 /* If the old current buffer has markers to record PT, BEGV and ZV
1787 when it is not current, update them now. */
1788 if (! NILP (old_buf
->pt_marker
))
1791 XSETBUFFER (obuf
, old_buf
);
1792 set_marker_both (old_buf
->pt_marker
, obuf
,
1793 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1795 if (! NILP (old_buf
->begv_marker
))
1798 XSETBUFFER (obuf
, old_buf
);
1799 set_marker_both (old_buf
->begv_marker
, obuf
,
1800 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1802 if (! NILP (old_buf
->zv_marker
))
1805 XSETBUFFER (obuf
, old_buf
);
1806 set_marker_both (old_buf
->zv_marker
, obuf
,
1807 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1811 /* Get the undo list from the base buffer, so that it appears
1812 that an indirect buffer shares the undo list of its base. */
1814 b
->undo_list
= b
->base_buffer
->undo_list
;
1816 /* If the new current buffer has markers to record PT, BEGV and ZV
1817 when it is not current, fetch them now. */
1818 if (! NILP (b
->pt_marker
))
1820 BUF_PT (b
) = marker_position (b
->pt_marker
);
1821 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1823 if (! NILP (b
->begv_marker
))
1825 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1826 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1828 if (! NILP (b
->zv_marker
))
1830 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1831 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1834 /* Look down buffer's list of local Lisp variables
1835 to find and update any that forward into C variables. */
1837 for (tail
= b
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1839 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1840 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1841 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1842 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1843 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1844 /* Just reference the variable
1845 to cause it to become set for this buffer. */
1846 Fsymbol_value (XCAR (XCAR (tail
)));
1849 /* Do the same with any others that were local to the previous buffer */
1852 for (tail
= old_buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
1854 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1855 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1856 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1857 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1858 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1859 /* Just reference the variable
1860 to cause it to become set for this buffer. */
1861 Fsymbol_value (XCAR (XCAR (tail
)));
1865 /* Switch to buffer B temporarily for redisplay purposes.
1866 This avoids certain things that don't need to be done within redisplay. */
1872 register struct buffer
*old_buf
;
1874 if (current_buffer
== b
)
1877 old_buf
= current_buffer
;
1882 /* If the old current buffer has markers to record PT, BEGV and ZV
1883 when it is not current, update them now. */
1884 if (! NILP (old_buf
->pt_marker
))
1887 XSETBUFFER (obuf
, old_buf
);
1888 set_marker_both (old_buf
->pt_marker
, obuf
,
1889 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1891 if (! NILP (old_buf
->begv_marker
))
1894 XSETBUFFER (obuf
, old_buf
);
1895 set_marker_both (old_buf
->begv_marker
, obuf
,
1896 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1898 if (! NILP (old_buf
->zv_marker
))
1901 XSETBUFFER (obuf
, old_buf
);
1902 set_marker_both (old_buf
->zv_marker
, obuf
,
1903 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1907 /* If the new current buffer has markers to record PT, BEGV and ZV
1908 when it is not current, fetch them now. */
1909 if (! NILP (b
->pt_marker
))
1911 BUF_PT (b
) = marker_position (b
->pt_marker
);
1912 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1914 if (! NILP (b
->begv_marker
))
1916 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1917 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1919 if (! NILP (b
->zv_marker
))
1921 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1922 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1926 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
1927 doc
: /* Make the buffer BUFFER current for editing operations.
1928 BUFFER may be a buffer or the name of an existing buffer.
1929 See also `save-excursion' when you want to make a buffer current temporarily.
1930 This function does not display the buffer, so its effect ends
1931 when the current command terminates.
1932 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently. */)
1934 register Lisp_Object buffer
;
1936 register Lisp_Object buf
;
1937 buf
= Fget_buffer (buffer
);
1940 if (NILP (XBUFFER (buf
)->name
))
1941 error ("Selecting deleted buffer");
1942 set_buffer_internal (XBUFFER (buf
));
1946 /* Set the current buffer to BUFFER provided it is alive. */
1949 set_buffer_if_live (buffer
)
1952 if (! NILP (XBUFFER (buffer
)->name
))
1953 Fset_buffer (buffer
);
1957 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
1958 Sbarf_if_buffer_read_only
, 0, 0, 0,
1959 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
1962 if (!NILP (current_buffer
->read_only
)
1963 && NILP (Vinhibit_read_only
))
1964 xsignal1 (Qbuffer_read_only
, Fcurrent_buffer ());
1968 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
1969 doc
: /* Put BUFFER at the end of the list of all buffers.
1970 There it is the least likely candidate for `other-buffer' to return;
1971 thus, the least likely buffer for \\[switch-to-buffer] to select by default.
1972 You can specify a buffer name as BUFFER, or an actual buffer object.
1973 If BUFFER is nil or omitted, bury the current buffer.
1974 Also, if BUFFER is nil or omitted, remove the current buffer from the
1975 selected window if it is displayed there. */)
1977 register Lisp_Object buffer
;
1979 /* Figure out what buffer we're going to bury. */
1983 XSETBUFFER (buffer
, current_buffer
);
1985 tem
= Fwindow_buffer (selected_window
);
1986 /* If we're burying the current buffer, unshow it. */
1987 if (EQ (buffer
, tem
))
1989 if (NILP (Fwindow_dedicated_p (selected_window
)))
1990 Fswitch_to_buffer (Fother_buffer (buffer
, Qnil
, Qnil
), Qnil
);
1991 else if (NILP (XWINDOW (selected_window
)->parent
))
1992 Ficonify_frame (Fwindow_frame (selected_window
));
1994 Fdelete_window (selected_window
);
2001 buf1
= Fget_buffer (buffer
);
2007 /* Move buffer to the end of the buffer list. Do nothing if the
2008 buffer is killed. */
2009 if (!NILP (XBUFFER (buffer
)->name
))
2011 Lisp_Object aelt
, link
;
2013 aelt
= Frassq (buffer
, Vbuffer_alist
);
2014 link
= Fmemq (aelt
, Vbuffer_alist
);
2015 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
2016 XSETCDR (link
, Qnil
);
2017 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
2019 /* Removing BUFFER from frame-specific lists
2020 has the effect of putting BUFFER at the end
2021 of the combined list in each frame. */
2022 frames_discard_buffer (buffer
);
2028 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
2029 doc
: /* Delete the entire contents of the current buffer.
2030 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2031 so the buffer is truly empty after this. */)
2038 current_buffer
->last_window_start
= 1;
2039 /* Prevent warnings, or suspension of auto saving, that would happen
2040 if future size is less than past size. Use of erase-buffer
2041 implies that the future text is not really related to the past text. */
2042 XSETFASTINT (current_buffer
->save_length
, 0);
2047 validate_region (b
, e
)
2048 register Lisp_Object
*b
, *e
;
2050 CHECK_NUMBER_COERCE_MARKER (*b
);
2051 CHECK_NUMBER_COERCE_MARKER (*e
);
2053 if (XINT (*b
) > XINT (*e
))
2056 tem
= *b
; *b
= *e
; *e
= tem
;
2059 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
2060 && XINT (*e
) <= ZV
))
2061 args_out_of_range (*b
, *e
);
2064 /* Advance BYTE_POS up to a character boundary
2065 and return the adjusted position. */
2068 advance_to_char_boundary (byte_pos
)
2073 if (byte_pos
== BEG
)
2074 /* Beginning of buffer is always a character boundary. */
2077 c
= FETCH_BYTE (byte_pos
);
2078 if (! CHAR_HEAD_P (c
))
2080 /* We should advance BYTE_POS only when C is a constituent of a
2081 multibyte sequence. */
2082 int orig_byte_pos
= byte_pos
;
2087 c
= FETCH_BYTE (byte_pos
);
2089 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2091 if (byte_pos
< orig_byte_pos
)
2092 byte_pos
= orig_byte_pos
;
2093 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2094 surely advance to the correct character boundary. If C is
2095 not, BYTE_POS was unchanged. */
2101 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2103 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2104 If FLAG is t, this makes the buffer a multibyte buffer.
2105 If FLAG is nil, this makes the buffer a single-byte buffer.
2106 The buffer contents remain unchanged as a sequence of bytes
2107 but the contents viewed as characters do change.
2108 If the multibyte flag was really changed, undo information of the
2109 current buffer is cleared. */)
2113 struct Lisp_Marker
*tail
, *markers
;
2114 struct buffer
*other
;
2115 int undo_enabled_p
= !EQ (current_buffer
->undo_list
, Qt
);
2117 int narrowed
= (BEG
!= BEGV
|| Z
!= ZV
);
2118 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2120 if (current_buffer
->base_buffer
)
2121 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2123 /* Do nothing if nothing actually changes. */
2124 if (NILP (flag
) == NILP (current_buffer
->enable_multibyte_characters
))
2127 /* It would be better to update the list,
2128 but this is good enough for now. */
2130 current_buffer
->undo_list
= Qt
;
2132 /* If the cached position is for this buffer, clear it out. */
2133 clear_charpos_cache (current_buffer
);
2136 begv
= BEGV_BYTE
, zv
= ZV_BYTE
;
2138 begv
= BEGV
, zv
= ZV
;
2148 /* Do this first, so it can use CHAR_TO_BYTE
2149 to calculate the old correspondences. */
2150 set_intervals_multibyte (0);
2152 current_buffer
->enable_multibyte_characters
= Qnil
;
2158 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2161 for (tail
= BUF_MARKERS (current_buffer
); tail
; tail
= tail
->next
)
2162 tail
->charpos
= tail
->bytepos
;
2164 /* Convert multibyte form of 8-bit characters to unibyte. */
2179 if (MULTIBYTE_STR_AS_UNIBYTE_P (p
, bytes
))
2180 p
+= bytes
, pos
+= bytes
;
2183 c
= STRING_CHAR (p
, stop
- pos
);
2184 /* Delete all bytes for this 8-bit character but the
2185 last one, and change the last one to the charcter
2188 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2200 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2208 /* Be sure not to have a multibyte sequence striding over the GAP.
2209 Ex: We change this: "...abc\201 _GAP_ \241def..."
2210 to: "...abc _GAP_ \201\241def..." */
2212 if (GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2213 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2215 unsigned char *p
= GPT_ADDR
- 1;
2217 while (! CHAR_HEAD_P (*p
) && p
> BEG_ADDR
) p
--;
2218 if (BASE_LEADING_CODE_P (*p
))
2220 int new_gpt
= GPT_BYTE
- (GPT_ADDR
- p
);
2222 move_gap_both (new_gpt
, new_gpt
);
2226 /* Make the buffer contents valid as multibyte by converting
2227 8-bit characters to multibyte form. */
2243 if (UNIBYTE_STR_AS_MULTIBYTE_P (p
, stop
- pos
, bytes
))
2244 p
+= bytes
, pos
+= bytes
;
2247 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2249 bytes
= CHAR_STRING (*p
, tmp
);
2251 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2253 insert_1_both (tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2254 /* Now the gap is after the just inserted data. */
2271 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2273 /* Do this first, so that chars_in_text asks the right question.
2274 set_intervals_multibyte needs it too. */
2275 current_buffer
->enable_multibyte_characters
= Qt
;
2277 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2278 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2280 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2282 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2283 if (BEGV_BYTE
> GPT_BYTE
)
2284 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2286 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2288 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2289 if (ZV_BYTE
> GPT_BYTE
)
2290 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2292 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2295 int pt_byte
= advance_to_char_boundary (PT_BYTE
);
2298 if (pt_byte
> GPT_BYTE
)
2299 pt
= chars_in_text (GAP_END_ADDR
, pt_byte
- GPT_BYTE
) + GPT
;
2301 pt
= chars_in_text (BEG_ADDR
, pt_byte
- BEG_BYTE
) + BEG
;
2302 TEMP_SET_PT_BOTH (pt
, pt_byte
);
2305 tail
= markers
= BUF_MARKERS (current_buffer
);
2307 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2308 getting confused by the markers that have not yet been updated.
2309 It is also a signal that it should never create a marker. */
2310 BUF_MARKERS (current_buffer
) = NULL
;
2312 for (; tail
; tail
= tail
->next
)
2314 tail
->bytepos
= advance_to_char_boundary (tail
->bytepos
);
2315 tail
->charpos
= BYTE_TO_CHAR (tail
->bytepos
);
2318 /* Make sure no markers were put on the chain
2319 while the chain value was incorrect. */
2320 if (BUF_MARKERS (current_buffer
))
2323 BUF_MARKERS (current_buffer
) = markers
;
2325 /* Do this last, so it can calculate the new correspondences
2326 between chars and bytes. */
2327 set_intervals_multibyte (1);
2331 current_buffer
->undo_list
= Qnil
;
2333 /* Changing the multibyteness of a buffer means that all windows
2334 showing that buffer must be updated thoroughly. */
2335 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2336 ++windows_or_buffers_changed
;
2338 /* Copy this buffer's new multibyte status
2339 into all of its indirect buffers. */
2340 for (other
= all_buffers
; other
; other
= other
->next
)
2341 if (other
->base_buffer
== current_buffer
&& !NILP (other
->name
))
2343 other
->enable_multibyte_characters
2344 = current_buffer
->enable_multibyte_characters
;
2345 other
->prevent_redisplay_optimizations_p
= 1;
2348 /* Restore the modifiedness of the buffer. */
2349 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2350 Fset_buffer_modified_p (Qnil
);
2353 /* Update coding systems of this buffer's process (if any). */
2355 Lisp_Object process
;
2357 process
= Fget_buffer_process (Fcurrent_buffer ());
2358 if (PROCESSP (process
))
2359 setup_process_coding_systems (process
);
2361 #endif /* subprocesses */
2366 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
2368 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2369 Most local variable bindings are eliminated so that the default values
2370 become effective once more. Also, the syntax table is set from
2371 `standard-syntax-table', the local keymap is set to nil,
2372 and the abbrev table from `fundamental-mode-abbrev-table'.
2373 This function also forces redisplay of the mode line.
2375 Every function to select a new major mode starts by
2376 calling this function.
2378 As a special exception, local variables whose names have
2379 a non-nil `permanent-local' property are not eliminated by this function.
2381 The first thing this function does is run
2382 the normal hook `change-major-mode-hook'. */)
2385 register Lisp_Object alist
, sym
, tem
;
2388 if (!NILP (Vrun_hooks
))
2389 call1 (Vrun_hooks
, intern ("change-major-mode-hook"));
2390 oalist
= current_buffer
->local_var_alist
;
2392 /* Make sure none of the bindings in oalist
2393 remain swapped in, in their symbols. */
2395 swap_out_buffer_local_variables (current_buffer
);
2397 /* Actually eliminate all local bindings of this buffer. */
2399 reset_buffer_local_variables (current_buffer
, 0);
2401 /* Any which are supposed to be permanent,
2402 make local again, with the same values they had. */
2404 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2406 sym
= XCAR (XCAR (alist
));
2407 tem
= Fget (sym
, Qpermanent_local
);
2410 Fmake_local_variable (sym
);
2411 Fset (sym
, XCDR (XCAR (alist
)));
2415 /* Force mode-line redisplay. Useful here because all major mode
2416 commands call this function. */
2417 update_mode_lines
++;
2422 /* Make sure no local variables remain set up with buffer B
2423 for their current values. */
2426 swap_out_buffer_local_variables (b
)
2429 Lisp_Object oalist
, alist
, sym
, tem
, buffer
;
2431 XSETBUFFER (buffer
, b
);
2432 oalist
= b
->local_var_alist
;
2434 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2436 sym
= XCAR (XCAR (alist
));
2438 /* Need not do anything if some other buffer's binding is now encached. */
2439 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
;
2440 if (BUFFERP (tem
) && XBUFFER (tem
) == current_buffer
)
2442 /* Symbol is set up for this buffer's old local value.
2443 Set it up for the current buffer with the default value. */
2445 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->cdr
;
2446 /* Store the symbol's current value into the alist entry
2447 it is currently set up for. This is so that, if the
2448 local is marked permanent, and we make it local again
2449 later in Fkill_all_local_variables, we don't lose the value. */
2450 XSETCDR (XCAR (tem
),
2451 do_symval_forwarding (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->realvalue
));
2452 /* Switch to the symbol's default-value alist entry. */
2454 /* Mark it as current for buffer B. */
2455 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
= buffer
;
2456 /* Store the current value into any forwarding in the symbol. */
2457 store_symval_forwarding (sym
,
2458 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->realvalue
,
2464 /* Find all the overlays in the current buffer that contain position POS.
2465 Return the number found, and store them in a vector in *VEC_PTR.
2466 Store in *LEN_PTR the size allocated for the vector.
2467 Store in *NEXT_PTR the next position after POS where an overlay starts,
2468 or ZV if there are no more overlays between POS and ZV.
2469 Store in *PREV_PTR the previous position before POS where an overlay ends,
2470 or where an overlay starts which ends at or after POS;
2471 or BEGV if there are no such overlays from BEGV to POS.
2472 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2474 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2475 when this function is called.
2477 If EXTEND is non-zero, we make the vector bigger if necessary.
2478 If EXTEND is zero, we never extend the vector,
2479 and we store only as many overlays as will fit.
2480 But we still return the total number of overlays.
2482 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2483 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2484 default (BEGV or ZV). */
2487 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
, change_req
)
2490 Lisp_Object
**vec_ptr
;
2496 Lisp_Object overlay
, start
, end
;
2497 struct Lisp_Overlay
*tail
;
2500 Lisp_Object
*vec
= *vec_ptr
;
2503 int inhibit_storing
= 0;
2505 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2507 int startpos
, endpos
;
2509 XSETMISC (overlay
, tail
);
2511 start
= OVERLAY_START (overlay
);
2512 end
= OVERLAY_END (overlay
);
2513 endpos
= OVERLAY_POSITION (end
);
2520 startpos
= OVERLAY_POSITION (start
);
2521 /* This one ends at or after POS
2522 so its start counts for PREV_PTR if it's before POS. */
2523 if (prev
< startpos
&& startpos
< pos
)
2527 if (startpos
<= pos
)
2531 /* The supplied vector is full.
2532 Either make it bigger, or don't store any more in it. */
2535 /* Make it work with an initial len == 0. */
2540 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2544 inhibit_storing
= 1;
2547 if (!inhibit_storing
)
2549 /* Keep counting overlays even if we can't return them all. */
2552 else if (startpos
< next
)
2556 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2558 int startpos
, endpos
;
2560 XSETMISC (overlay
, tail
);
2562 start
= OVERLAY_START (overlay
);
2563 end
= OVERLAY_END (overlay
);
2564 startpos
= OVERLAY_POSITION (start
);
2567 if (startpos
< next
)
2571 endpos
= OVERLAY_POSITION (end
);
2578 /* Make it work with an initial len == 0. */
2583 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2587 inhibit_storing
= 1;
2590 if (!inhibit_storing
)
2594 if (startpos
< pos
&& startpos
> prev
)
2597 else if (endpos
< pos
&& endpos
> prev
)
2599 else if (endpos
== pos
&& startpos
> prev
2600 && (!change_req
|| startpos
< pos
))
2611 /* Find all the overlays in the current buffer that overlap the range BEG-END
2612 or are empty at BEG.
2614 Return the number found, and store them in a vector in *VEC_PTR.
2615 Store in *LEN_PTR the size allocated for the vector.
2616 Store in *NEXT_PTR the next position after POS where an overlay starts,
2617 or ZV if there are no more overlays.
2618 Store in *PREV_PTR the previous position before POS where an overlay ends,
2619 or BEGV if there are no previous overlays.
2620 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2622 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2623 when this function is called.
2625 If EXTEND is non-zero, we make the vector bigger if necessary.
2626 If EXTEND is zero, we never extend the vector,
2627 and we store only as many overlays as will fit.
2628 But we still return the total number of overlays. */
2631 overlays_in (beg
, end
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
2634 Lisp_Object
**vec_ptr
;
2639 Lisp_Object overlay
, ostart
, oend
;
2640 struct Lisp_Overlay
*tail
;
2643 Lisp_Object
*vec
= *vec_ptr
;
2646 int inhibit_storing
= 0;
2648 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2650 int startpos
, endpos
;
2652 XSETMISC (overlay
, tail
);
2654 ostart
= OVERLAY_START (overlay
);
2655 oend
= OVERLAY_END (overlay
);
2656 endpos
= OVERLAY_POSITION (oend
);
2663 startpos
= OVERLAY_POSITION (ostart
);
2664 /* Count an interval if it either overlaps the range
2665 or is empty at the start of the range. */
2666 if ((beg
< endpos
&& startpos
< end
)
2667 || (startpos
== endpos
&& beg
== endpos
))
2671 /* The supplied vector is full.
2672 Either make it bigger, or don't store any more in it. */
2675 /* Make it work with an initial len == 0. */
2680 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2684 inhibit_storing
= 1;
2687 if (!inhibit_storing
)
2689 /* Keep counting overlays even if we can't return them all. */
2692 else if (startpos
< next
)
2696 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2698 int startpos
, endpos
;
2700 XSETMISC (overlay
, tail
);
2702 ostart
= OVERLAY_START (overlay
);
2703 oend
= OVERLAY_END (overlay
);
2704 startpos
= OVERLAY_POSITION (ostart
);
2707 if (startpos
< next
)
2711 endpos
= OVERLAY_POSITION (oend
);
2712 /* Count an interval if it either overlaps the range
2713 or is empty at the start of the range. */
2714 if ((beg
< endpos
&& startpos
< end
)
2715 || (startpos
== endpos
&& beg
== endpos
))
2721 /* Make it work with an initial len == 0. */
2726 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2730 inhibit_storing
= 1;
2733 if (!inhibit_storing
)
2737 else if (endpos
< beg
&& endpos
> prev
)
2749 /* Return non-zero if there exists an overlay with a non-nil
2750 `mouse-face' property overlapping OVERLAY. */
2753 mouse_face_overlay_overlaps (overlay
)
2754 Lisp_Object overlay
;
2756 int start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2757 int end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2759 Lisp_Object
*v
, tem
;
2762 v
= (Lisp_Object
*) alloca (size
* sizeof *v
);
2763 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
2766 v
= (Lisp_Object
*) alloca (n
* sizeof *v
);
2767 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
2770 for (i
= 0; i
< n
; ++i
)
2771 if (!EQ (v
[i
], overlay
)
2772 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
2781 /* Fast function to just test if we're at an overlay boundary. */
2783 overlay_touches_p (pos
)
2786 Lisp_Object overlay
;
2787 struct Lisp_Overlay
*tail
;
2789 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
2793 XSETMISC (overlay
,tail
);
2794 if (!GC_OVERLAYP (overlay
))
2797 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2800 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
2804 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
2808 XSETMISC (overlay
, tail
);
2809 if (!GC_OVERLAYP (overlay
))
2812 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2815 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
2823 Lisp_Object overlay
;
2829 compare_overlays (v1
, v2
)
2830 const void *v1
, *v2
;
2832 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
2833 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
2834 if (s1
->priority
!= s2
->priority
)
2835 return s1
->priority
- s2
->priority
;
2836 if (s1
->beg
!= s2
->beg
)
2837 return s1
->beg
- s2
->beg
;
2838 if (s1
->end
!= s2
->end
)
2839 return s2
->end
- s1
->end
;
2843 /* Sort an array of overlays by priority. The array is modified in place.
2844 The return value is the new size; this may be smaller than the original
2845 size if some of the overlays were invalid or were window-specific. */
2847 sort_overlays (overlay_vec
, noverlays
, w
)
2848 Lisp_Object
*overlay_vec
;
2853 struct sortvec
*sortvec
;
2854 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
2856 /* Put the valid and relevant overlays into sortvec. */
2858 for (i
= 0, j
= 0; i
< noverlays
; i
++)
2861 Lisp_Object overlay
;
2863 overlay
= overlay_vec
[i
];
2864 if (OVERLAY_VALID (overlay
)
2865 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
2866 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
2868 /* If we're interested in a specific window, then ignore
2869 overlays that are limited to some other window. */
2874 window
= Foverlay_get (overlay
, Qwindow
);
2875 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2879 /* This overlay is good and counts: put it into sortvec. */
2880 sortvec
[j
].overlay
= overlay
;
2881 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2882 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2883 tem
= Foverlay_get (overlay
, Qpriority
);
2885 sortvec
[j
].priority
= XINT (tem
);
2887 sortvec
[j
].priority
= 0;
2893 /* Sort the overlays into the proper order: increasing priority. */
2896 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
2898 for (i
= 0; i
< noverlays
; i
++)
2899 overlay_vec
[i
] = sortvec
[i
].overlay
;
2905 Lisp_Object string
, string2
;
2912 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
2913 int size
; /* Allocated length of that array. */
2914 int used
; /* How much of the array is currently in use. */
2915 int bytes
; /* Total length of the strings in buf. */
2918 /* Buffers for storing information about the overlays touching a given
2919 position. These could be automatic variables in overlay_strings, but
2920 it's more efficient to hold onto the memory instead of repeatedly
2921 allocating and freeing it. */
2922 static struct sortstrlist overlay_heads
, overlay_tails
;
2923 static unsigned char *overlay_str_buf
;
2925 /* Allocated length of overlay_str_buf. */
2926 static int overlay_str_len
;
2928 /* A comparison function suitable for passing to qsort. */
2930 cmp_for_strings (as1
, as2
)
2933 struct sortstr
*s1
= (struct sortstr
*)as1
;
2934 struct sortstr
*s2
= (struct sortstr
*)as2
;
2935 if (s1
->size
!= s2
->size
)
2936 return s2
->size
- s1
->size
;
2937 if (s1
->priority
!= s2
->priority
)
2938 return s1
->priority
- s2
->priority
;
2943 record_overlay_string (ssl
, str
, str2
, pri
, size
)
2944 struct sortstrlist
*ssl
;
2945 Lisp_Object str
, str2
, pri
;
2950 if (ssl
->used
== ssl
->size
)
2956 ssl
->buf
= ((struct sortstr
*)
2957 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
2959 ssl
->buf
[ssl
->used
].string
= str
;
2960 ssl
->buf
[ssl
->used
].string2
= str2
;
2961 ssl
->buf
[ssl
->used
].size
= size
;
2962 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
2965 if (NILP (current_buffer
->enable_multibyte_characters
))
2966 nbytes
= SCHARS (str
);
2967 else if (! STRING_MULTIBYTE (str
))
2968 nbytes
= count_size_as_multibyte (SDATA (str
),
2971 nbytes
= SBYTES (str
);
2973 ssl
->bytes
+= nbytes
;
2977 if (NILP (current_buffer
->enable_multibyte_characters
))
2978 nbytes
= SCHARS (str2
);
2979 else if (! STRING_MULTIBYTE (str2
))
2980 nbytes
= count_size_as_multibyte (SDATA (str2
),
2983 nbytes
= SBYTES (str2
);
2985 ssl
->bytes
+= nbytes
;
2989 /* Return the concatenation of the strings associated with overlays that
2990 begin or end at POS, ignoring overlays that are specific to a window
2991 other than W. The strings are concatenated in the appropriate order:
2992 shorter overlays nest inside longer ones, and higher priority inside
2993 lower. Normally all of the after-strings come first, but zero-sized
2994 overlays have their after-strings ride along with the before-strings
2995 because it would look strange to print them inside-out.
2997 Returns the string length, and stores the contents indirectly through
2998 PSTR, if that variable is non-null. The string may be overwritten by
2999 subsequent calls. */
3002 overlay_strings (pos
, w
, pstr
)
3005 unsigned char **pstr
;
3007 Lisp_Object overlay
, window
, str
;
3008 struct Lisp_Overlay
*ov
;
3009 int startpos
, endpos
;
3010 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
3012 overlay_heads
.used
= overlay_heads
.bytes
= 0;
3013 overlay_tails
.used
= overlay_tails
.bytes
= 0;
3014 for (ov
= current_buffer
->overlays_before
; ov
; ov
= ov
->next
)
3016 XSETMISC (overlay
, ov
);
3017 eassert (OVERLAYP (overlay
));
3019 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3020 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3023 if (endpos
!= pos
&& startpos
!= pos
)
3025 window
= Foverlay_get (overlay
, Qwindow
);
3026 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3029 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3030 record_overlay_string (&overlay_heads
, str
,
3032 ? Foverlay_get (overlay
, Qafter_string
)
3034 Foverlay_get (overlay
, Qpriority
),
3036 else if (endpos
== pos
3037 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3038 record_overlay_string (&overlay_tails
, str
, Qnil
,
3039 Foverlay_get (overlay
, Qpriority
),
3042 for (ov
= current_buffer
->overlays_after
; ov
; ov
= ov
->next
)
3044 XSETMISC (overlay
, ov
);
3045 eassert (OVERLAYP (overlay
));
3047 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3048 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3051 if (endpos
!= pos
&& startpos
!= pos
)
3053 window
= Foverlay_get (overlay
, Qwindow
);
3054 if (WINDOWP (window
) && XWINDOW (window
) != w
)
3057 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
3058 record_overlay_string (&overlay_heads
, str
,
3060 ? Foverlay_get (overlay
, Qafter_string
)
3062 Foverlay_get (overlay
, Qpriority
),
3064 else if (endpos
== pos
3065 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
3066 record_overlay_string (&overlay_tails
, str
, Qnil
,
3067 Foverlay_get (overlay
, Qpriority
),
3070 if (overlay_tails
.used
> 1)
3071 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
3073 if (overlay_heads
.used
> 1)
3074 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
3076 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
3081 int total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3083 if (total
> overlay_str_len
)
3085 overlay_str_len
= total
;
3086 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
3089 p
= overlay_str_buf
;
3090 for (i
= overlay_tails
.used
; --i
>= 0;)
3093 tem
= overlay_tails
.buf
[i
].string
;
3094 nbytes
= copy_text (SDATA (tem
), p
,
3096 STRING_MULTIBYTE (tem
), multibyte
);
3099 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3102 tem
= overlay_heads
.buf
[i
].string
;
3103 nbytes
= copy_text (SDATA (tem
), p
,
3105 STRING_MULTIBYTE (tem
), multibyte
);
3107 tem
= overlay_heads
.buf
[i
].string2
;
3110 nbytes
= copy_text (SDATA (tem
), p
,
3112 STRING_MULTIBYTE (tem
), multibyte
);
3116 if (p
!= overlay_str_buf
+ total
)
3119 *pstr
= overlay_str_buf
;
3125 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3128 recenter_overlay_lists (buf
, pos
)
3132 Lisp_Object overlay
, beg
, end
;
3133 struct Lisp_Overlay
*prev
, *tail
, *next
;
3135 /* See if anything in overlays_before should move to overlays_after. */
3137 /* We don't strictly need prev in this loop; it should always be nil.
3138 But we use it for symmetry and in case that should cease to be true
3139 with some future change. */
3141 for (tail
= buf
->overlays_before
; tail
; prev
= tail
, tail
= next
)
3144 XSETMISC (overlay
, tail
);
3146 /* If the overlay is not valid, get rid of it. */
3147 if (!OVERLAY_VALID (overlay
))
3152 /* Splice the cons cell TAIL out of overlays_before. */
3156 buf
->overlays_before
= next
;
3162 beg
= OVERLAY_START (overlay
);
3163 end
= OVERLAY_END (overlay
);
3165 if (OVERLAY_POSITION (end
) > pos
)
3167 /* OVERLAY needs to be moved. */
3168 int where
= OVERLAY_POSITION (beg
);
3169 struct Lisp_Overlay
*other
, *other_prev
;
3171 /* Splice the cons cell TAIL out of overlays_before. */
3175 buf
->overlays_before
= next
;
3177 /* Search thru overlays_after for where to put it. */
3179 for (other
= buf
->overlays_after
; other
;
3180 other_prev
= other
, other
= other
->next
)
3182 Lisp_Object otherbeg
, otheroverlay
;
3184 XSETMISC (otheroverlay
, other
);
3185 eassert (OVERLAY_VALID (otheroverlay
));
3187 otherbeg
= OVERLAY_START (otheroverlay
);
3188 if (OVERLAY_POSITION (otherbeg
) >= where
)
3192 /* Add TAIL to overlays_after before OTHER. */
3195 other_prev
->next
= tail
;
3197 buf
->overlays_after
= tail
;
3201 /* We've reached the things that should stay in overlays_before.
3202 All the rest of overlays_before must end even earlier,
3207 /* See if anything in overlays_after should be in overlays_before. */
3209 for (tail
= buf
->overlays_after
; tail
; prev
= tail
, tail
= next
)
3212 XSETMISC (overlay
, tail
);
3214 /* If the overlay is not valid, get rid of it. */
3215 if (!OVERLAY_VALID (overlay
))
3220 /* Splice the cons cell TAIL out of overlays_after. */
3224 buf
->overlays_after
= next
;
3230 beg
= OVERLAY_START (overlay
);
3231 end
= OVERLAY_END (overlay
);
3233 /* Stop looking, when we know that nothing further
3234 can possibly end before POS. */
3235 if (OVERLAY_POSITION (beg
) > pos
)
3238 if (OVERLAY_POSITION (end
) <= pos
)
3240 /* OVERLAY needs to be moved. */
3241 int where
= OVERLAY_POSITION (end
);
3242 struct Lisp_Overlay
*other
, *other_prev
;
3244 /* Splice the cons cell TAIL out of overlays_after. */
3248 buf
->overlays_after
= next
;
3250 /* Search thru overlays_before for where to put it. */
3252 for (other
= buf
->overlays_before
; other
;
3253 other_prev
= other
, other
= other
->next
)
3255 Lisp_Object otherend
, otheroverlay
;
3257 XSETMISC (otheroverlay
, other
);
3258 eassert (OVERLAY_VALID (otheroverlay
));
3260 otherend
= OVERLAY_END (otheroverlay
);
3261 if (OVERLAY_POSITION (otherend
) <= where
)
3265 /* Add TAIL to overlays_before before OTHER. */
3268 other_prev
->next
= tail
;
3270 buf
->overlays_before
= tail
;
3275 buf
->overlay_center
= pos
;
3279 adjust_overlays_for_insert (pos
, length
)
3283 /* After an insertion, the lists are still sorted properly,
3284 but we may need to update the value of the overlay center. */
3285 if (current_buffer
->overlay_center
>= pos
)
3286 current_buffer
->overlay_center
+= length
;
3290 adjust_overlays_for_delete (pos
, length
)
3294 if (current_buffer
->overlay_center
< pos
)
3295 /* The deletion was to our right. No change needed; the before- and
3296 after-lists are still consistent. */
3298 else if (current_buffer
->overlay_center
> pos
+ length
)
3299 /* The deletion was to our left. We need to adjust the center value
3300 to account for the change in position, but the lists are consistent
3301 given the new value. */
3302 current_buffer
->overlay_center
-= length
;
3304 /* We're right in the middle. There might be things on the after-list
3305 that now belong on the before-list. Recentering will move them,
3306 and also update the center point. */
3307 recenter_overlay_lists (current_buffer
, pos
);
3310 /* Fix up overlays that were garbled as a result of permuting markers
3311 in the range START through END. Any overlay with at least one
3312 endpoint in this range will need to be unlinked from the overlay
3313 list and reinserted in its proper place.
3314 Such an overlay might even have negative size at this point.
3315 If so, we'll make the overlay empty. */
3317 fix_start_end_in_overlays (start
, end
)
3318 register int start
, end
;
3320 Lisp_Object overlay
;
3321 struct Lisp_Overlay
*before_list
, *after_list
;
3322 /* These are either nil, indicating that before_list or after_list
3323 should be assigned, or the cons cell the cdr of which should be
3325 struct Lisp_Overlay
*beforep
= NULL
, *afterp
= NULL
;
3326 /* 'Parent', likewise, indicates a cons cell or
3327 current_buffer->overlays_before or overlays_after, depending
3328 which loop we're in. */
3329 struct Lisp_Overlay
*tail
, *parent
;
3330 int startpos
, endpos
;
3332 /* This algorithm shifts links around instead of consing and GCing.
3333 The loop invariant is that before_list (resp. after_list) is a
3334 well-formed list except that its last element, the CDR of beforep
3335 (resp. afterp) if beforep (afterp) isn't nil or before_list
3336 (after_list) if it is, is still uninitialized. So it's not a bug
3337 that before_list isn't initialized, although it may look
3339 for (parent
= NULL
, tail
= current_buffer
->overlays_before
; tail
;)
3341 XSETMISC (overlay
, tail
);
3343 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3344 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3346 /* If the overlay is backwards, make it empty. */
3347 if (endpos
< startpos
)
3350 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3358 || (startpos
>= start
&& startpos
< end
))
3360 /* Add it to the end of the wrong list. Later on,
3361 recenter_overlay_lists will move it to the right place. */
3362 if (endpos
< current_buffer
->overlay_center
)
3367 afterp
->next
= tail
;
3375 beforep
->next
= tail
;
3379 current_buffer
->overlays_before
= tail
->next
;
3381 parent
->next
= tail
->next
;
3385 parent
= tail
, tail
= parent
->next
;
3387 for (parent
= NULL
, tail
= current_buffer
->overlays_after
; tail
;)
3389 XSETMISC (overlay
, tail
);
3391 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3392 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3394 /* If the overlay is backwards, make it empty. */
3395 if (endpos
< startpos
)
3398 Fset_marker (OVERLAY_START (overlay
), make_number (startpos
),
3402 if (startpos
>= end
)
3405 if (startpos
>= start
3406 || (endpos
>= start
&& endpos
< end
))
3408 if (endpos
< current_buffer
->overlay_center
)
3413 afterp
->next
= tail
;
3421 beforep
->next
= tail
;
3425 current_buffer
->overlays_after
= tail
->next
;
3427 parent
->next
= tail
->next
;
3431 parent
= tail
, tail
= parent
->next
;
3434 /* Splice the constructed (wrong) lists into the buffer's lists,
3435 and let the recenter function make it sane again. */
3438 beforep
->next
= current_buffer
->overlays_before
;
3439 current_buffer
->overlays_before
= before_list
;
3441 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3445 afterp
->next
= current_buffer
->overlays_after
;
3446 current_buffer
->overlays_after
= after_list
;
3448 recenter_overlay_lists (current_buffer
, current_buffer
->overlay_center
);
3451 /* We have two types of overlay: the one whose ending marker is
3452 after-insertion-marker (this is the usual case) and the one whose
3453 ending marker is before-insertion-marker. When `overlays_before'
3454 contains overlays of the latter type and the former type in this
3455 order and both overlays end at inserting position, inserting a text
3456 increases only the ending marker of the latter type, which results
3457 in incorrect ordering of `overlays_before'.
3459 This function fixes ordering of overlays in the slot
3460 `overlays_before' of the buffer *BP. Before the insertion, `point'
3461 was at PREV, and now is at POS. */
3464 fix_overlays_before (bp
, prev
, pos
)
3466 EMACS_INT prev
, pos
;
3468 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3469 struct Lisp_Overlay
*tail
= bp
->overlays_before
, *parent
= NULL
, *right_pair
;
3473 /* After the insertion, the several overlays may be in incorrect
3474 order. The possibility is that, in the list `overlays_before',
3475 an overlay which ends at POS appears after an overlay which ends
3476 at PREV. Since POS is greater than PREV, we must fix the
3477 ordering of these overlays, by moving overlays ends at POS before
3478 the overlays ends at PREV. */
3480 /* At first, find a place where disordered overlays should be linked
3481 in. It is where an overlay which end before POS exists. (i.e. an
3482 overlay whose ending marker is after-insertion-marker if disorder
3485 && (XSETMISC (tem
, tail
),
3486 (end
= OVERLAY_POSITION (OVERLAY_END (tem
))) >= pos
))
3492 /* If we don't find such an overlay,
3493 or the found one ends before PREV,
3494 or the found one is the last one in the list,
3495 we don't have to fix anything. */
3496 if (!tail
|| end
< prev
|| !tail
->next
)
3499 right_pair
= parent
;
3503 /* Now, end position of overlays in the list TAIL should be before
3504 or equal to PREV. In the loop, an overlay which ends at POS is
3505 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3506 we found an overlay which ends before PREV, the remaining
3507 overlays are in correct order. */
3510 XSETMISC (tem
, tail
);
3511 end
= OVERLAY_POSITION (OVERLAY_END (tem
));
3514 { /* This overlay is disordered. */
3515 struct Lisp_Overlay
*found
= tail
;
3517 /* Unlink the found overlay. */
3519 parent
->next
= tail
;
3520 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3521 and link it into the right place. */
3524 found
->next
= bp
->overlays_before
;
3525 bp
->overlays_before
= found
;
3529 found
->next
= right_pair
->next
;
3530 right_pair
->next
= found
;
3533 else if (end
== prev
)
3538 else /* No more disordered overlay. */
3543 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3544 doc
: /* Return t if OBJECT is an overlay. */)
3548 return (OVERLAYP (object
) ? Qt
: Qnil
);
3551 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3552 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3553 If omitted, BUFFER defaults to the current buffer.
3554 BEG and END may be integers or markers.
3555 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3556 for the front of the overlay advance when text is inserted there
3557 \(which means the text *is not* included in the overlay).
3558 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3559 for the rear of the overlay advance when text is inserted there
3560 \(which means the text *is* included in the overlay). */)
3561 (beg
, end
, buffer
, front_advance
, rear_advance
)
3562 Lisp_Object beg
, end
, buffer
;
3563 Lisp_Object front_advance
, rear_advance
;
3565 Lisp_Object overlay
;
3569 XSETBUFFER (buffer
, current_buffer
);
3571 CHECK_BUFFER (buffer
);
3573 && ! EQ (Fmarker_buffer (beg
), buffer
))
3574 error ("Marker points into wrong buffer");
3576 && ! EQ (Fmarker_buffer (end
), buffer
))
3577 error ("Marker points into wrong buffer");
3579 CHECK_NUMBER_COERCE_MARKER (beg
);
3580 CHECK_NUMBER_COERCE_MARKER (end
);
3582 if (XINT (beg
) > XINT (end
))
3585 temp
= beg
; beg
= end
; end
= temp
;
3588 b
= XBUFFER (buffer
);
3590 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3591 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3593 if (!NILP (front_advance
))
3594 XMARKER (beg
)->insertion_type
= 1;
3595 if (!NILP (rear_advance
))
3596 XMARKER (end
)->insertion_type
= 1;
3598 overlay
= allocate_misc ();
3599 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3600 XOVERLAY (overlay
)->start
= beg
;
3601 XOVERLAY (overlay
)->end
= end
;
3602 XOVERLAY (overlay
)->plist
= Qnil
;
3603 XOVERLAY (overlay
)->next
= NULL
;
3605 /* Put the new overlay on the wrong list. */
3606 end
= OVERLAY_END (overlay
);
3607 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3609 if (b
->overlays_after
)
3610 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3611 b
->overlays_after
= XOVERLAY (overlay
);
3615 if (b
->overlays_before
)
3616 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3617 b
->overlays_before
= XOVERLAY (overlay
);
3620 /* This puts it in the right list, and in the right order. */
3621 recenter_overlay_lists (b
, b
->overlay_center
);
3623 /* We don't need to redisplay the region covered by the overlay, because
3624 the overlay has no properties at the moment. */
3629 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3632 modify_overlay (buf
, start
, end
)
3634 EMACS_INT start
, end
;
3643 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3645 /* If this is a buffer not in the selected window,
3646 we must do other windows. */
3647 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3648 windows_or_buffers_changed
= 1;
3649 /* If multiple windows show this buffer, we must do other windows. */
3650 else if (buffer_shared
> 1)
3651 windows_or_buffers_changed
= 1;
3652 /* If we modify an overlay at the end of the buffer, we cannot
3653 be sure that window end is still valid. */
3654 else if (end
>= ZV
&& start
<= ZV
)
3655 windows_or_buffers_changed
= 1;
3657 ++BUF_OVERLAY_MODIFF (buf
);
3661 Lisp_Object
Fdelete_overlay ();
3663 static struct Lisp_Overlay
*
3664 unchain_overlay (list
, overlay
)
3665 struct Lisp_Overlay
*list
, *overlay
;
3667 struct Lisp_Overlay
*tmp
, *prev
;
3668 for (tmp
= list
, prev
= NULL
; tmp
; prev
= tmp
, tmp
= tmp
->next
)
3672 prev
->next
= tmp
->next
;
3675 overlay
->next
= NULL
;
3681 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3682 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3683 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3684 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3686 (overlay
, beg
, end
, buffer
)
3687 Lisp_Object overlay
, beg
, end
, buffer
;
3689 struct buffer
*b
, *ob
;
3690 Lisp_Object obuffer
;
3691 int count
= SPECPDL_INDEX ();
3693 CHECK_OVERLAY (overlay
);
3695 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3697 XSETBUFFER (buffer
, current_buffer
);
3698 CHECK_BUFFER (buffer
);
3701 && ! EQ (Fmarker_buffer (beg
), buffer
))
3702 error ("Marker points into wrong buffer");
3704 && ! EQ (Fmarker_buffer (end
), buffer
))
3705 error ("Marker points into wrong buffer");
3707 CHECK_NUMBER_COERCE_MARKER (beg
);
3708 CHECK_NUMBER_COERCE_MARKER (end
);
3710 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3711 return Fdelete_overlay (overlay
);
3713 if (XINT (beg
) > XINT (end
))
3716 temp
= beg
; beg
= end
; end
= temp
;
3719 specbind (Qinhibit_quit
, Qt
);
3721 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3722 b
= XBUFFER (buffer
);
3723 ob
= BUFFERP (obuffer
) ? XBUFFER (obuffer
) : (struct buffer
*) 0;
3725 /* If the overlay has changed buffers, do a thorough redisplay. */
3726 if (!EQ (buffer
, obuffer
))
3728 /* Redisplay where the overlay was. */
3729 if (!NILP (obuffer
))
3734 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3735 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3737 modify_overlay (ob
, o_beg
, o_end
);
3740 /* Redisplay where the overlay is going to be. */
3741 modify_overlay (b
, XINT (beg
), XINT (end
));
3744 /* Redisplay the area the overlay has just left, or just enclosed. */
3748 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3749 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3751 if (o_beg
== XINT (beg
))
3752 modify_overlay (b
, o_end
, XINT (end
));
3753 else if (o_end
== XINT (end
))
3754 modify_overlay (b
, o_beg
, XINT (beg
));
3757 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
3758 if (XINT (end
) > o_end
) o_end
= XINT (end
);
3759 modify_overlay (b
, o_beg
, o_end
);
3763 if (!NILP (obuffer
))
3766 = unchain_overlay (ob
->overlays_before
, XOVERLAY (overlay
));
3768 = unchain_overlay (ob
->overlays_after
, XOVERLAY (overlay
));
3769 eassert (XOVERLAY (overlay
)->next
== NULL
);
3772 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3773 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3775 /* Put the overlay on the wrong list. */
3776 end
= OVERLAY_END (overlay
);
3777 if (OVERLAY_POSITION (end
) < b
->overlay_center
)
3779 XOVERLAY (overlay
)->next
= b
->overlays_after
;
3780 b
->overlays_after
= XOVERLAY (overlay
);
3784 XOVERLAY (overlay
)->next
= b
->overlays_before
;
3785 b
->overlays_before
= XOVERLAY (overlay
);
3788 /* This puts it in the right list, and in the right order. */
3789 recenter_overlay_lists (b
, b
->overlay_center
);
3791 return unbind_to (count
, overlay
);
3794 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
3795 doc
: /* Delete the overlay OVERLAY from its buffer. */)
3797 Lisp_Object overlay
;
3801 int count
= SPECPDL_INDEX ();
3803 CHECK_OVERLAY (overlay
);
3805 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3809 b
= XBUFFER (buffer
);
3810 specbind (Qinhibit_quit
, Qt
);
3812 b
->overlays_before
= unchain_overlay (b
->overlays_before
,XOVERLAY (overlay
));
3813 b
->overlays_after
= unchain_overlay (b
->overlays_after
, XOVERLAY (overlay
));
3814 eassert (XOVERLAY (overlay
)->next
== NULL
);
3816 marker_position (OVERLAY_START (overlay
)),
3817 marker_position (OVERLAY_END (overlay
)));
3818 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
3819 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
3821 /* When deleting an overlay with before or after strings, turn off
3822 display optimizations for the affected buffer, on the basis that
3823 these strings may contain newlines. This is easier to do than to
3824 check for that situation during redisplay. */
3825 if (!windows_or_buffers_changed
3826 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
3827 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
3828 b
->prevent_redisplay_optimizations_p
= 1;
3830 return unbind_to (count
, Qnil
);
3833 /* Overlay dissection functions. */
3835 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
3836 doc
: /* Return the position at which OVERLAY starts. */)
3838 Lisp_Object overlay
;
3840 CHECK_OVERLAY (overlay
);
3842 return (Fmarker_position (OVERLAY_START (overlay
)));
3845 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
3846 doc
: /* Return the position at which OVERLAY ends. */)
3848 Lisp_Object overlay
;
3850 CHECK_OVERLAY (overlay
);
3852 return (Fmarker_position (OVERLAY_END (overlay
)));
3855 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
3856 doc
: /* Return the buffer OVERLAY belongs to.
3857 Return nil if OVERLAY has been deleted. */)
3859 Lisp_Object overlay
;
3861 CHECK_OVERLAY (overlay
);
3863 return Fmarker_buffer (OVERLAY_START (overlay
));
3866 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
3867 doc
: /* Return a list of the properties on OVERLAY.
3868 This is a copy of OVERLAY's plist; modifying its conses has no effect on
3871 Lisp_Object overlay
;
3873 CHECK_OVERLAY (overlay
);
3875 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
3879 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
3880 doc
: /* Return a list of the overlays that contain position POS. */)
3885 Lisp_Object
*overlay_vec
;
3889 CHECK_NUMBER_COERCE_MARKER (pos
);
3892 /* We can't use alloca here because overlays_at can call xrealloc. */
3893 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3895 /* Put all the overlays we want in a vector in overlay_vec.
3896 Store the length in len. */
3897 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3898 (int *) 0, (int *) 0, 0);
3900 /* Make a list of them all. */
3901 result
= Flist (noverlays
, overlay_vec
);
3903 xfree (overlay_vec
);
3907 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
3908 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
3909 Overlap means that at least one character is contained within the overlay
3910 and also contained within the specified region.
3911 Empty overlays are included in the result if they are located at BEG
3912 or between BEG and END. */)
3914 Lisp_Object beg
, end
;
3917 Lisp_Object
*overlay_vec
;
3921 CHECK_NUMBER_COERCE_MARKER (beg
);
3922 CHECK_NUMBER_COERCE_MARKER (end
);
3925 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3927 /* Put all the overlays we want in a vector in overlay_vec.
3928 Store the length in len. */
3929 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
3930 (int *) 0, (int *) 0);
3932 /* Make a list of them all. */
3933 result
= Flist (noverlays
, overlay_vec
);
3935 xfree (overlay_vec
);
3939 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
3941 doc
: /* Return the next position after POS where an overlay starts or ends.
3942 If there are no overlay boundaries from POS to (point-max),
3943 the value is (point-max). */)
3949 Lisp_Object
*overlay_vec
;
3953 CHECK_NUMBER_COERCE_MARKER (pos
);
3956 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3958 /* Put all the overlays we want in a vector in overlay_vec.
3959 Store the length in len.
3960 endpos gets the position where the next overlay starts. */
3961 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3962 &endpos
, (int *) 0, 1);
3964 /* If any of these overlays ends before endpos,
3965 use its ending point instead. */
3966 for (i
= 0; i
< noverlays
; i
++)
3971 oend
= OVERLAY_END (overlay_vec
[i
]);
3972 oendpos
= OVERLAY_POSITION (oend
);
3973 if (oendpos
< endpos
)
3977 xfree (overlay_vec
);
3978 return make_number (endpos
);
3981 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
3982 Sprevious_overlay_change
, 1, 1, 0,
3983 doc
: /* Return the previous position before POS where an overlay starts or ends.
3984 If there are no overlay boundaries from (point-min) to POS,
3985 the value is (point-min). */)
3991 Lisp_Object
*overlay_vec
;
3994 CHECK_NUMBER_COERCE_MARKER (pos
);
3996 /* At beginning of buffer, we know the answer;
3997 avoid bug subtracting 1 below. */
3998 if (XINT (pos
) == BEGV
)
4002 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
4004 /* Put all the overlays we want in a vector in overlay_vec.
4005 Store the length in len.
4006 prevpos gets the position of the previous change. */
4007 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
4008 (int *) 0, &prevpos
, 1);
4010 xfree (overlay_vec
);
4011 return make_number (prevpos
);
4014 /* These functions are for debugging overlays. */
4016 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
4017 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
4018 The car has all the overlays before the overlay center;
4019 the cdr has all the overlays after the overlay center.
4020 Recentering overlays moves overlays between these lists.
4021 The lists you get are copies, so that changing them has no effect.
4022 However, the overlays you get are the real objects that the buffer uses. */)
4025 struct Lisp_Overlay
*ol
;
4026 Lisp_Object before
= Qnil
, after
= Qnil
, tmp
;
4027 for (ol
= current_buffer
->overlays_before
; ol
; ol
= ol
->next
)
4030 before
= Fcons (tmp
, before
);
4032 for (ol
= current_buffer
->overlays_after
; ol
; ol
= ol
->next
)
4035 after
= Fcons (tmp
, after
);
4037 return Fcons (Fnreverse (before
), Fnreverse (after
));
4040 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
4041 doc
: /* Recenter the overlays of the current buffer around position POS.
4042 That makes overlay lookup faster for positions near POS (but perhaps slower
4043 for positions far away from POS). */)
4047 CHECK_NUMBER_COERCE_MARKER (pos
);
4049 recenter_overlay_lists (current_buffer
, XINT (pos
));
4053 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
4054 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
4056 Lisp_Object overlay
, prop
;
4058 CHECK_OVERLAY (overlay
);
4059 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
4062 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
4063 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE. */)
4064 (overlay
, prop
, value
)
4065 Lisp_Object overlay
, prop
, value
;
4067 Lisp_Object tail
, buffer
;
4070 CHECK_OVERLAY (overlay
);
4072 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
4074 for (tail
= XOVERLAY (overlay
)->plist
;
4075 CONSP (tail
) && CONSP (XCDR (tail
));
4076 tail
= XCDR (XCDR (tail
)))
4077 if (EQ (XCAR (tail
), prop
))
4079 changed
= !EQ (XCAR (XCDR (tail
)), value
);
4080 XSETCAR (XCDR (tail
), value
);
4083 /* It wasn't in the list, so add it to the front. */
4084 changed
= !NILP (value
);
4085 XOVERLAY (overlay
)->plist
4086 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
4088 if (! NILP (buffer
))
4091 modify_overlay (XBUFFER (buffer
),
4092 marker_position (OVERLAY_START (overlay
)),
4093 marker_position (OVERLAY_END (overlay
)));
4094 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
4095 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
4096 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
4097 Fdelete_overlay (overlay
);
4103 /* Subroutine of report_overlay_modification. */
4105 /* Lisp vector holding overlay hook functions to call.
4106 Vector elements come in pairs.
4107 Each even-index element is a list of hook functions.
4108 The following odd-index element is the overlay they came from.
4110 Before the buffer change, we fill in this vector
4111 as we call overlay hook functions.
4112 After the buffer change, we get the functions to call from this vector.
4113 This way we always call the same functions before and after the change. */
4114 static Lisp_Object last_overlay_modification_hooks
;
4116 /* Number of elements actually used in last_overlay_modification_hooks. */
4117 static int last_overlay_modification_hooks_used
;
4119 /* Add one functionlist/overlay pair
4120 to the end of last_overlay_modification_hooks. */
4123 add_overlay_mod_hooklist (functionlist
, overlay
)
4124 Lisp_Object functionlist
, overlay
;
4126 int oldsize
= XVECTOR (last_overlay_modification_hooks
)->size
;
4128 if (last_overlay_modification_hooks_used
== oldsize
)
4131 old
= last_overlay_modification_hooks
;
4132 last_overlay_modification_hooks
4133 = Fmake_vector (make_number (oldsize
* 2), Qnil
);
4134 bcopy (XVECTOR (old
)->contents
,
4135 XVECTOR (last_overlay_modification_hooks
)->contents
,
4136 sizeof (Lisp_Object
) * oldsize
);
4138 AREF (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
++) = functionlist
;
4139 AREF (last_overlay_modification_hooks
, last_overlay_modification_hooks_used
++) = overlay
;
4142 /* Run the modification-hooks of overlays that include
4143 any part of the text in START to END.
4144 If this change is an insertion, also
4145 run the insert-before-hooks of overlay starting at END,
4146 and the insert-after-hooks of overlay ending at START.
4148 This is called both before and after the modification.
4149 AFTER is nonzero when we call after the modification.
4151 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4152 When AFTER is nonzero, they are the start position,
4153 the position after the inserted new text,
4154 and the length of deleted or replaced old text. */
4157 report_overlay_modification (start
, end
, after
, arg1
, arg2
, arg3
)
4158 Lisp_Object start
, end
;
4160 Lisp_Object arg1
, arg2
, arg3
;
4162 Lisp_Object prop
, overlay
;
4163 struct Lisp_Overlay
*tail
;
4164 /* 1 if this change is an insertion. */
4165 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4166 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4171 /* We used to run the functions as soon as we found them and only register
4172 them in last_overlay_modification_hooks for the purpose of the `after'
4173 case. But running elisp code as we traverse the list of overlays is
4174 painful because the list can be modified by the elisp code so we had to
4175 copy at several places. We now simply do a read-only traversal that
4176 only collects the functions to run and we run them afterwards. It's
4177 simpler, especially since all the code was already there. -stef */
4181 /* We are being called before a change.
4182 Scan the overlays to find the functions to call. */
4183 last_overlay_modification_hooks_used
= 0;
4184 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4186 int startpos
, endpos
;
4187 Lisp_Object ostart
, oend
;
4189 XSETMISC (overlay
, tail
);
4191 ostart
= OVERLAY_START (overlay
);
4192 oend
= OVERLAY_END (overlay
);
4193 endpos
= OVERLAY_POSITION (oend
);
4194 if (XFASTINT (start
) > endpos
)
4196 startpos
= OVERLAY_POSITION (ostart
);
4197 if (insertion
&& (XFASTINT (start
) == startpos
4198 || XFASTINT (end
) == startpos
))
4200 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4202 add_overlay_mod_hooklist (prop
, overlay
);
4204 if (insertion
&& (XFASTINT (start
) == endpos
4205 || XFASTINT (end
) == endpos
))
4207 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4209 add_overlay_mod_hooklist (prop
, overlay
);
4211 /* Test for intersecting intervals. This does the right thing
4212 for both insertion and deletion. */
4213 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4215 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4217 add_overlay_mod_hooklist (prop
, overlay
);
4221 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4223 int startpos
, endpos
;
4224 Lisp_Object ostart
, oend
;
4226 XSETMISC (overlay
, tail
);
4228 ostart
= OVERLAY_START (overlay
);
4229 oend
= OVERLAY_END (overlay
);
4230 startpos
= OVERLAY_POSITION (ostart
);
4231 endpos
= OVERLAY_POSITION (oend
);
4232 if (XFASTINT (end
) < startpos
)
4234 if (insertion
&& (XFASTINT (start
) == startpos
4235 || XFASTINT (end
) == startpos
))
4237 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4239 add_overlay_mod_hooklist (prop
, overlay
);
4241 if (insertion
&& (XFASTINT (start
) == endpos
4242 || XFASTINT (end
) == endpos
))
4244 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4246 add_overlay_mod_hooklist (prop
, overlay
);
4248 /* Test for intersecting intervals. This does the right thing
4249 for both insertion and deletion. */
4250 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4252 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4254 add_overlay_mod_hooklist (prop
, overlay
);
4259 GCPRO4 (overlay
, arg1
, arg2
, arg3
);
4261 /* Call the functions recorded in last_overlay_modification_hooks.
4262 First copy the vector contents, in case some of these hooks
4263 do subsequent modification of the buffer. */
4264 int size
= last_overlay_modification_hooks_used
;
4265 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
4268 bcopy (XVECTOR (last_overlay_modification_hooks
)->contents
,
4269 copy
, size
* sizeof (Lisp_Object
));
4271 gcpro1
.nvars
= size
;
4273 for (i
= 0; i
< size
;)
4275 Lisp_Object prop
, overlay
;
4277 overlay
= copy
[i
++];
4278 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4285 call_overlay_mod_hooks (list
, overlay
, after
, arg1
, arg2
, arg3
)
4286 Lisp_Object list
, overlay
;
4288 Lisp_Object arg1
, arg2
, arg3
;
4290 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4292 GCPRO4 (list
, arg1
, arg2
, arg3
);
4294 while (CONSP (list
))
4297 call4 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4299 call5 (XCAR (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4305 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4308 evaporate_overlays (pos
)
4311 Lisp_Object overlay
, hit_list
;
4312 struct Lisp_Overlay
*tail
;
4315 if (pos
<= current_buffer
->overlay_center
)
4316 for (tail
= current_buffer
->overlays_before
; tail
; tail
= tail
->next
)
4319 XSETMISC (overlay
, tail
);
4320 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4323 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4324 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4325 hit_list
= Fcons (overlay
, hit_list
);
4328 for (tail
= current_buffer
->overlays_after
; tail
; tail
= tail
->next
)
4331 XSETMISC (overlay
, tail
);
4332 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4335 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4336 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4337 hit_list
= Fcons (overlay
, hit_list
);
4339 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4340 Fdelete_overlay (XCAR (hit_list
));
4343 /* Somebody has tried to store a value with an unacceptable type
4344 in the slot with offset OFFSET. */
4347 buffer_slot_type_mismatch (offset
)
4353 switch (XINT (PER_BUFFER_TYPE (offset
)))
4356 type_name
= "integers";
4360 type_name
= "strings";
4364 type_name
= "symbols";
4371 sym
= PER_BUFFER_SYMBOL (offset
);
4372 error ("Only %s should be stored in the buffer-local variable %s",
4373 type_name
, SDATA (SYMBOL_NAME (sym
)));
4377 /***********************************************************************
4378 Allocation with mmap
4379 ***********************************************************************/
4381 #ifdef USE_MMAP_FOR_BUFFERS
4383 #include <sys/types.h>
4384 #include <sys/mman.h>
4387 #ifdef MAP_ANONYMOUS
4388 #define MAP_ANON MAP_ANONYMOUS
4395 #define MAP_FAILED ((void *) -1)
4408 /* Memory is allocated in regions which are mapped using mmap(2).
4409 The current implementation lets the system select mapped
4410 addresses; we're not using MAP_FIXED in general, except when
4411 trying to enlarge regions.
4413 Each mapped region starts with a mmap_region structure, the user
4414 area starts after that structure, aligned to MEM_ALIGN.
4416 +-----------------------+
4417 | struct mmap_info + |
4419 +-----------------------+
4423 +-----------------------+ */
4427 /* User-specified size. */
4428 size_t nbytes_specified
;
4430 /* Number of bytes mapped */
4431 size_t nbytes_mapped
;
4433 /* Pointer to the location holding the address of the memory
4434 allocated with the mmap'd block. The variable actually points
4435 after this structure. */
4438 /* Next and previous in list of all mmap'd regions. */
4439 struct mmap_region
*next
, *prev
;
4442 /* Doubly-linked list of mmap'd regions. */
4444 static struct mmap_region
*mmap_regions
;
4446 /* File descriptor for mmap. If we don't have anonymous mapping,
4447 /dev/zero will be opened on it. */
4451 /* Temporary storage for mmap_set_vars, see there. */
4453 static struct mmap_region
*mmap_regions_1
;
4454 static int mmap_fd_1
;
4456 /* Page size on this system. */
4458 static int mmap_page_size
;
4460 /* 1 means mmap has been intialized. */
4462 static int mmap_initialized_p
;
4464 /* Value is X rounded up to the next multiple of N. */
4466 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4468 /* Size of mmap_region structure plus padding. */
4470 #define MMAP_REGION_STRUCT_SIZE \
4471 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4473 /* Given a pointer P to the start of the user-visible part of a mapped
4474 region, return a pointer to the start of the region. */
4476 #define MMAP_REGION(P) \
4477 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4479 /* Given a pointer P to the start of a mapped region, return a pointer
4480 to the start of the user-visible part of the region. */
4482 #define MMAP_USER_AREA(P) \
4483 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4485 #define MEM_ALIGN sizeof (double)
4487 /* Predicate returning true if part of the address range [START .. END]
4488 is currently mapped. Used to prevent overwriting an existing
4491 Default is to conservativly assume the address range is occupied by
4492 something else. This can be overridden by system configuration
4493 files if system-specific means to determine this exists. */
4495 #ifndef MMAP_ALLOCATED_P
4496 #define MMAP_ALLOCATED_P(start, end) 1
4499 /* Function prototypes. */
4501 static int mmap_free_1
P_ ((struct mmap_region
*));
4502 static int mmap_enlarge
P_ ((struct mmap_region
*, int));
4503 static struct mmap_region
*mmap_find
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
4504 static POINTER_TYPE
*mmap_alloc
P_ ((POINTER_TYPE
**, size_t));
4505 static POINTER_TYPE
*mmap_realloc
P_ ((POINTER_TYPE
**, size_t));
4506 static void mmap_free
P_ ((POINTER_TYPE
**ptr
));
4507 static void mmap_init
P_ ((void));
4510 /* Return a region overlapping address range START...END, or null if
4511 none. END is not including, i.e. the last byte in the range
4514 static struct mmap_region
*
4515 mmap_find (start
, end
)
4516 POINTER_TYPE
*start
, *end
;
4518 struct mmap_region
*r
;
4519 char *s
= (char *) start
, *e
= (char *) end
;
4521 for (r
= mmap_regions
; r
; r
= r
->next
)
4523 char *rstart
= (char *) r
;
4524 char *rend
= rstart
+ r
->nbytes_mapped
;
4526 if (/* First byte of range, i.e. START, in this region? */
4527 (s
>= rstart
&& s
< rend
)
4528 /* Last byte of range, i.e. END - 1, in this region? */
4529 || (e
> rstart
&& e
<= rend
)
4530 /* First byte of this region in the range? */
4531 || (rstart
>= s
&& rstart
< e
)
4532 /* Last byte of this region in the range? */
4533 || (rend
> s
&& rend
<= e
))
4541 /* Unmap a region. P is a pointer to the start of the user-araa of
4542 the region. Value is non-zero if successful. */
4546 struct mmap_region
*r
;
4549 r
->next
->prev
= r
->prev
;
4551 r
->prev
->next
= r
->next
;
4553 mmap_regions
= r
->next
;
4555 if (munmap ((POINTER_TYPE
*) r
, r
->nbytes_mapped
) == -1)
4557 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4565 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4566 Value is non-zero if successful. */
4569 mmap_enlarge (r
, npages
)
4570 struct mmap_region
*r
;
4573 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4579 /* Unmap pages at the end of the region. */
4580 nbytes
= - npages
* mmap_page_size
;
4581 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4582 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4585 r
->nbytes_mapped
-= nbytes
;
4589 else if (npages
> 0)
4591 nbytes
= npages
* mmap_page_size
;
4593 /* Try to map additional pages at the end of the region. We
4594 cannot do this if the address range is already occupied by
4595 something else because mmap deletes any previous mapping.
4596 I'm not sure this is worth doing, let's see. */
4597 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4601 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4602 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4603 if (p
== MAP_FAILED
)
4604 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4605 else if (p
!= (POINTER_TYPE
*) region_end
)
4607 /* Kernels are free to choose a different address. In
4608 that case, unmap what we've mapped above; we have
4610 if (munmap (p
, nbytes
) == -1)
4611 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4615 r
->nbytes_mapped
+= nbytes
;
4625 /* Set or reset variables holding references to mapped regions. If
4626 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4627 non-zero, set all variables to the start of the user-areas
4630 This function is called from Fdump_emacs to ensure that the dumped
4631 Emacs doesn't contain references to memory that won't be mapped
4632 when Emacs starts. */
4635 mmap_set_vars (restore_p
)
4638 struct mmap_region
*r
;
4642 mmap_regions
= mmap_regions_1
;
4643 mmap_fd
= mmap_fd_1
;
4644 for (r
= mmap_regions
; r
; r
= r
->next
)
4645 *r
->var
= MMAP_USER_AREA (r
);
4649 for (r
= mmap_regions
; r
; r
= r
->next
)
4651 mmap_regions_1
= mmap_regions
;
4652 mmap_regions
= NULL
;
4653 mmap_fd_1
= mmap_fd
;
4659 /* Allocate a block of storage large enough to hold NBYTES bytes of
4660 data. A pointer to the data is returned in *VAR. VAR is thus the
4661 address of some variable which will use the data area.
4663 The allocation of 0 bytes is valid.
4665 If we can't allocate the necessary memory, set *VAR to null, and
4668 static POINTER_TYPE
*
4669 mmap_alloc (var
, nbytes
)
4678 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4679 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4682 if (p
== MAP_FAILED
)
4684 if (errno
!= ENOMEM
)
4685 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4690 struct mmap_region
*r
= (struct mmap_region
*) p
;
4692 r
->nbytes_specified
= nbytes
;
4693 r
->nbytes_mapped
= map
;
4696 r
->next
= mmap_regions
;
4701 p
= MMAP_USER_AREA (p
);
4708 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4709 resize it to size NBYTES. Change *VAR to reflect the new block,
4710 and return this value. If more memory cannot be allocated, then
4711 leave *VAR unchanged, and return null. */
4713 static POINTER_TYPE
*
4714 mmap_realloc (var
, nbytes
)
4718 POINTER_TYPE
*result
;
4723 result
= mmap_alloc (var
, nbytes
);
4724 else if (nbytes
== 0)
4727 result
= mmap_alloc (var
, nbytes
);
4731 struct mmap_region
*r
= MMAP_REGION (*var
);
4732 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4737 POINTER_TYPE
*old_ptr
= *var
;
4739 /* Try to map additional pages at the end of the region.
4740 If that fails, allocate a new region, copy data
4741 from the old region, then free it. */
4742 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4745 r
->nbytes_specified
= nbytes
;
4746 *var
= result
= old_ptr
;
4748 else if (mmap_alloc (var
, nbytes
))
4750 bcopy (old_ptr
, *var
, r
->nbytes_specified
);
4751 mmap_free_1 (MMAP_REGION (old_ptr
));
4753 r
= MMAP_REGION (result
);
4754 r
->nbytes_specified
= nbytes
;
4762 else if (room
- nbytes
>= mmap_page_size
)
4764 /* Shrinking by at least a page. Let's give some
4765 memory back to the system.
4767 The extra parens are to make the division happens first,
4768 on positive values, so we know it will round towards
4770 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4772 r
->nbytes_specified
= nbytes
;
4776 /* Leave it alone. */
4778 r
->nbytes_specified
= nbytes
;
4786 /* Free a block of relocatable storage whose data is pointed to by
4787 PTR. Store 0 in *PTR to show there's no block allocated. */
4797 mmap_free_1 (MMAP_REGION (*var
));
4803 /* Perform necessary intializations for the use of mmap. */
4809 /* The value of mmap_fd is initially 0 in temacs, and -1
4810 in a dumped Emacs. */
4813 /* No anonymous mmap -- we need the file descriptor. */
4814 mmap_fd
= open ("/dev/zero", O_RDONLY
);
4816 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4818 #endif /* MAP_ANON == 0 */
4820 if (mmap_initialized_p
)
4822 mmap_initialized_p
= 1;
4828 mmap_page_size
= getpagesize ();
4831 #endif /* USE_MMAP_FOR_BUFFERS */
4835 /***********************************************************************
4836 Buffer-text Allocation
4837 ***********************************************************************/
4840 extern POINTER_TYPE
*r_alloc
P_ ((POINTER_TYPE
**, size_t));
4841 extern POINTER_TYPE
*r_re_alloc
P_ ((POINTER_TYPE
**, size_t));
4842 extern void r_alloc_free
P_ ((POINTER_TYPE
**ptr
));
4843 #endif /* REL_ALLOC */
4846 /* Allocate NBYTES bytes for buffer B's text buffer. */
4849 alloc_buffer_text (b
, nbytes
)
4856 #if defined USE_MMAP_FOR_BUFFERS
4857 p
= mmap_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4858 #elif defined REL_ALLOC
4859 p
= r_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4861 p
= xmalloc (nbytes
);
4870 b
->text
->beg
= (unsigned char *) p
;
4874 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4878 enlarge_buffer_text (b
, delta
)
4883 size_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4886 #if defined USE_MMAP_FOR_BUFFERS
4887 p
= mmap_realloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4888 #elif defined REL_ALLOC
4889 p
= r_re_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4891 p
= xrealloc (b
->text
->beg
, nbytes
);
4900 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
4905 /* Free buffer B's text buffer. */
4908 free_buffer_text (b
)
4913 #if defined USE_MMAP_FOR_BUFFERS
4914 mmap_free ((POINTER_TYPE
**) &b
->text
->beg
);
4915 #elif defined REL_ALLOC
4916 r_alloc_free ((POINTER_TYPE
**) &b
->text
->beg
);
4918 xfree (b
->text
->beg
);
4921 BUF_BEG_ADDR (b
) = NULL
;
4927 /***********************************************************************
4929 ***********************************************************************/
4936 bzero (buffer_permanent_local_flags
, sizeof buffer_permanent_local_flags
);
4938 /* Make sure all markable slots in buffer_defaults
4939 are initialized reasonably, so mark_buffer won't choke. */
4940 reset_buffer (&buffer_defaults
);
4941 reset_buffer_local_variables (&buffer_defaults
, 1);
4942 reset_buffer (&buffer_local_symbols
);
4943 reset_buffer_local_variables (&buffer_local_symbols
, 1);
4944 /* Prevent GC from getting confused. */
4945 buffer_defaults
.text
= &buffer_defaults
.own_text
;
4946 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
4947 BUF_INTERVALS (&buffer_defaults
) = 0;
4948 BUF_INTERVALS (&buffer_local_symbols
) = 0;
4949 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
4950 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
4952 /* Set up the default values of various buffer slots. */
4953 /* Must do these before making the first buffer! */
4955 /* real setup is done in bindings.el */
4956 buffer_defaults
.mode_line_format
= build_string ("%-");
4957 buffer_defaults
.header_line_format
= Qnil
;
4958 buffer_defaults
.abbrev_mode
= Qnil
;
4959 buffer_defaults
.overwrite_mode
= Qnil
;
4960 buffer_defaults
.case_fold_search
= Qt
;
4961 buffer_defaults
.auto_fill_function
= Qnil
;
4962 buffer_defaults
.selective_display
= Qnil
;
4964 buffer_defaults
.selective_display_ellipses
= Qt
;
4966 buffer_defaults
.abbrev_table
= Qnil
;
4967 buffer_defaults
.display_table
= Qnil
;
4968 buffer_defaults
.undo_list
= Qnil
;
4969 buffer_defaults
.mark_active
= Qnil
;
4970 buffer_defaults
.file_format
= Qnil
;
4971 buffer_defaults
.auto_save_file_format
= Qt
;
4972 buffer_defaults
.overlays_before
= NULL
;
4973 buffer_defaults
.overlays_after
= NULL
;
4974 buffer_defaults
.overlay_center
= BEG
;
4976 XSETFASTINT (buffer_defaults
.tab_width
, 8);
4977 buffer_defaults
.truncate_lines
= Qnil
;
4978 buffer_defaults
.ctl_arrow
= Qt
;
4979 buffer_defaults
.direction_reversed
= Qnil
;
4980 buffer_defaults
.cursor_type
= Qt
;
4981 buffer_defaults
.extra_line_spacing
= Qnil
;
4982 buffer_defaults
.cursor_in_non_selected_windows
= Qt
;
4985 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
4987 buffer_defaults
.enable_multibyte_characters
= Qt
;
4988 buffer_defaults
.buffer_file_coding_system
= Qnil
;
4989 XSETFASTINT (buffer_defaults
.fill_column
, 70);
4990 XSETFASTINT (buffer_defaults
.left_margin
, 0);
4991 buffer_defaults
.cache_long_line_scans
= Qnil
;
4992 buffer_defaults
.file_truename
= Qnil
;
4993 XSETFASTINT (buffer_defaults
.display_count
, 0);
4994 XSETFASTINT (buffer_defaults
.left_margin_cols
, 0);
4995 XSETFASTINT (buffer_defaults
.right_margin_cols
, 0);
4996 buffer_defaults
.left_fringe_width
= Qnil
;
4997 buffer_defaults
.right_fringe_width
= Qnil
;
4998 buffer_defaults
.fringes_outside_margins
= Qnil
;
4999 buffer_defaults
.scroll_bar_width
= Qnil
;
5000 buffer_defaults
.vertical_scroll_bar_type
= Qt
;
5001 buffer_defaults
.indicate_empty_lines
= Qnil
;
5002 buffer_defaults
.indicate_buffer_boundaries
= Qnil
;
5003 buffer_defaults
.fringe_indicator_alist
= Qnil
;
5004 buffer_defaults
.fringe_cursor_alist
= Qnil
;
5005 buffer_defaults
.scroll_up_aggressively
= Qnil
;
5006 buffer_defaults
.scroll_down_aggressively
= Qnil
;
5007 buffer_defaults
.display_time
= Qnil
;
5009 /* Assign the local-flags to the slots that have default values.
5010 The local flag is a bit that is used in the buffer
5011 to say that it has its own local value for the slot.
5012 The local flag bits are in the local_var_flags slot of the buffer. */
5014 /* Nothing can work if this isn't true */
5015 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
5017 /* 0 means not a lisp var, -1 means always local, else mask */
5018 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
5019 XSETINT (buffer_local_flags
.filename
, -1);
5020 XSETINT (buffer_local_flags
.directory
, -1);
5021 XSETINT (buffer_local_flags
.backed_up
, -1);
5022 XSETINT (buffer_local_flags
.save_length
, -1);
5023 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
5024 XSETINT (buffer_local_flags
.read_only
, -1);
5025 XSETINT (buffer_local_flags
.major_mode
, -1);
5026 XSETINT (buffer_local_flags
.mode_name
, -1);
5027 XSETINT (buffer_local_flags
.undo_list
, -1);
5028 XSETINT (buffer_local_flags
.mark_active
, -1);
5029 XSETINT (buffer_local_flags
.point_before_scroll
, -1);
5030 XSETINT (buffer_local_flags
.file_truename
, -1);
5031 XSETINT (buffer_local_flags
.invisibility_spec
, -1);
5032 XSETINT (buffer_local_flags
.file_format
, -1);
5033 XSETINT (buffer_local_flags
.auto_save_file_format
, -1);
5034 XSETINT (buffer_local_flags
.display_count
, -1);
5035 XSETINT (buffer_local_flags
.display_time
, -1);
5036 XSETINT (buffer_local_flags
.enable_multibyte_characters
, -1);
5039 XSETFASTINT (buffer_local_flags
.mode_line_format
, idx
); ++idx
;
5040 XSETFASTINT (buffer_local_flags
.abbrev_mode
, idx
); ++idx
;
5041 XSETFASTINT (buffer_local_flags
.overwrite_mode
, idx
); ++idx
;
5042 XSETFASTINT (buffer_local_flags
.case_fold_search
, idx
); ++idx
;
5043 XSETFASTINT (buffer_local_flags
.auto_fill_function
, idx
); ++idx
;
5044 XSETFASTINT (buffer_local_flags
.selective_display
, idx
); ++idx
;
5046 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, idx
); ++idx
;
5048 XSETFASTINT (buffer_local_flags
.tab_width
, idx
); ++idx
;
5049 XSETFASTINT (buffer_local_flags
.truncate_lines
, idx
); ++idx
;
5050 XSETFASTINT (buffer_local_flags
.ctl_arrow
, idx
); ++idx
;
5051 XSETFASTINT (buffer_local_flags
.fill_column
, idx
); ++idx
;
5052 XSETFASTINT (buffer_local_flags
.left_margin
, idx
); ++idx
;
5053 XSETFASTINT (buffer_local_flags
.abbrev_table
, idx
); ++idx
;
5054 XSETFASTINT (buffer_local_flags
.display_table
, idx
); ++idx
;
5056 XSETFASTINT (buffer_local_flags
.buffer_file_type
, idx
);
5057 /* Make this one a permanent local. */
5058 buffer_permanent_local_flags
[idx
++] = 1;
5060 XSETFASTINT (buffer_local_flags
.syntax_table
, idx
); ++idx
;
5061 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, idx
); ++idx
;
5062 XSETFASTINT (buffer_local_flags
.category_table
, idx
); ++idx
;
5063 XSETFASTINT (buffer_local_flags
.direction_reversed
, idx
); ++idx
;
5064 XSETFASTINT (buffer_local_flags
.buffer_file_coding_system
, idx
);
5065 /* Make this one a permanent local. */
5066 buffer_permanent_local_flags
[idx
++] = 1;
5067 XSETFASTINT (buffer_local_flags
.left_margin_cols
, idx
); ++idx
;
5068 XSETFASTINT (buffer_local_flags
.right_margin_cols
, idx
); ++idx
;
5069 XSETFASTINT (buffer_local_flags
.left_fringe_width
, idx
); ++idx
;
5070 XSETFASTINT (buffer_local_flags
.right_fringe_width
, idx
); ++idx
;
5071 XSETFASTINT (buffer_local_flags
.fringes_outside_margins
, idx
); ++idx
;
5072 XSETFASTINT (buffer_local_flags
.scroll_bar_width
, idx
); ++idx
;
5073 XSETFASTINT (buffer_local_flags
.vertical_scroll_bar_type
, idx
); ++idx
;
5074 XSETFASTINT (buffer_local_flags
.indicate_empty_lines
, idx
); ++idx
;
5075 XSETFASTINT (buffer_local_flags
.indicate_buffer_boundaries
, idx
); ++idx
;
5076 XSETFASTINT (buffer_local_flags
.fringe_indicator_alist
, idx
); ++idx
;
5077 XSETFASTINT (buffer_local_flags
.fringe_cursor_alist
, idx
); ++idx
;
5078 XSETFASTINT (buffer_local_flags
.scroll_up_aggressively
, idx
); ++idx
;
5079 XSETFASTINT (buffer_local_flags
.scroll_down_aggressively
, idx
); ++idx
;
5080 XSETFASTINT (buffer_local_flags
.header_line_format
, idx
); ++idx
;
5081 XSETFASTINT (buffer_local_flags
.cursor_type
, idx
); ++idx
;
5082 XSETFASTINT (buffer_local_flags
.extra_line_spacing
, idx
); ++idx
;
5083 XSETFASTINT (buffer_local_flags
.cursor_in_non_selected_windows
, idx
); ++idx
;
5085 /* Need more room? */
5086 if (idx
>= MAX_PER_BUFFER_VARS
)
5088 last_per_buffer_idx
= idx
;
5090 Vbuffer_alist
= Qnil
;
5094 QSFundamental
= build_string ("Fundamental");
5096 Qfundamental_mode
= intern ("fundamental-mode");
5097 buffer_defaults
.major_mode
= Qfundamental_mode
;
5099 Qmode_class
= intern ("mode-class");
5101 Qprotected_field
= intern ("protected-field");
5103 Qpermanent_local
= intern ("permanent-local");
5105 Qkill_buffer_hook
= intern ("kill-buffer-hook");
5106 Fput (Qkill_buffer_hook
, Qpermanent_local
, Qt
);
5108 Qucs_set_table_for_input
= intern ("ucs-set-table-for-input");
5110 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
5112 /* super-magic invisible buffer */
5113 Vbuffer_alist
= Qnil
;
5115 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5117 inhibit_modification_hooks
= 0;
5127 #ifdef USE_MMAP_FOR_BUFFERS
5129 /* When using the ralloc implementation based on mmap(2), buffer
5130 text pointers will have been set to null in the dumped Emacs.
5134 for (b
= all_buffers
; b
; b
= b
->next
)
5135 if (b
->text
->beg
== NULL
)
5136 enlarge_buffer_text (b
, 0);
5138 #endif /* USE_MMAP_FOR_BUFFERS */
5140 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5141 if (NILP (buffer_defaults
.enable_multibyte_characters
))
5142 Fset_buffer_multibyte (Qnil
);
5144 pwd
= get_current_dir_name ();
5147 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno
));
5150 /* Maybe this should really use some standard subroutine
5151 whose definition is filename syntax dependent. */
5153 if (!(IS_DIRECTORY_SEP (pwd
[len
- 1])))
5155 /* Grow buffer to add directory separator and '\0'. */
5156 pwd
= (char *) xrealloc (pwd
, len
+ 2);
5157 pwd
[len
] = DIRECTORY_SEP
;
5158 pwd
[len
+ 1] = '\0';
5160 #endif /* not VMS */
5162 current_buffer
->directory
= make_unibyte_string (pwd
, strlen (pwd
));
5163 if (! NILP (buffer_defaults
.enable_multibyte_characters
))
5164 /* At this moment, we still don't know how to decode the
5165 directory name. So, we keep the bytes in multibyte form so
5166 that ENCODE_FILE correctly gets the original bytes. */
5167 current_buffer
->directory
5168 = string_to_multibyte (current_buffer
->directory
);
5170 /* Add /: to the front of the name
5171 if it would otherwise be treated as magic. */
5172 temp
= Ffind_file_name_handler (current_buffer
->directory
, Qt
);
5174 /* If the default dir is just /, TEMP is non-nil
5175 because of the ange-ftp completion handler.
5176 However, it is not necessary to turn / into /:/.
5177 So avoid doing that. */
5178 && strcmp ("/", SDATA (current_buffer
->directory
)))
5179 current_buffer
->directory
5180 = concat2 (build_string ("/:"), current_buffer
->directory
);
5182 temp
= get_minibuffer (0);
5183 XBUFFER (temp
)->directory
= current_buffer
->directory
;
5188 /* initialize the buffer routines */
5192 staticpro (&last_overlay_modification_hooks
);
5193 last_overlay_modification_hooks
5194 = Fmake_vector (make_number (10), Qnil
);
5196 staticpro (&Vbuffer_defaults
);
5197 staticpro (&Vbuffer_local_symbols
);
5198 staticpro (&Qfundamental_mode
);
5199 staticpro (&Qmode_class
);
5200 staticpro (&QSFundamental
);
5201 staticpro (&Vbuffer_alist
);
5202 staticpro (&Qprotected_field
);
5203 staticpro (&Qpermanent_local
);
5204 staticpro (&Qkill_buffer_hook
);
5205 Qoverlayp
= intern ("overlayp");
5206 staticpro (&Qoverlayp
);
5207 Qevaporate
= intern ("evaporate");
5208 staticpro (&Qevaporate
);
5209 Qmodification_hooks
= intern ("modification-hooks");
5210 staticpro (&Qmodification_hooks
);
5211 Qinsert_in_front_hooks
= intern ("insert-in-front-hooks");
5212 staticpro (&Qinsert_in_front_hooks
);
5213 Qinsert_behind_hooks
= intern ("insert-behind-hooks");
5214 staticpro (&Qinsert_behind_hooks
);
5215 Qget_file_buffer
= intern ("get-file-buffer");
5216 staticpro (&Qget_file_buffer
);
5217 Qpriority
= intern ("priority");
5218 staticpro (&Qpriority
);
5219 Qwindow
= intern ("window");
5220 staticpro (&Qwindow
);
5221 Qbefore_string
= intern ("before-string");
5222 staticpro (&Qbefore_string
);
5223 Qafter_string
= intern ("after-string");
5224 staticpro (&Qafter_string
);
5225 Qfirst_change_hook
= intern ("first-change-hook");
5226 staticpro (&Qfirst_change_hook
);
5227 Qbefore_change_functions
= intern ("before-change-functions");
5228 staticpro (&Qbefore_change_functions
);
5229 Qafter_change_functions
= intern ("after-change-functions");
5230 staticpro (&Qafter_change_functions
);
5231 staticpro (&Qucs_set_table_for_input
);
5233 Qkill_buffer_query_functions
= intern ("kill-buffer-query-functions");
5234 staticpro (&Qkill_buffer_query_functions
);
5236 Fput (Qprotected_field
, Qerror_conditions
,
5237 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
5238 Fput (Qprotected_field
, Qerror_message
,
5239 build_string ("Attempt to modify a protected field"));
5241 /* All these use DEFVAR_LISP_NOPRO because the slots in
5242 buffer_defaults will all be marked via Vbuffer_defaults. */
5244 DEFVAR_LISP_NOPRO ("default-mode-line-format",
5245 &buffer_defaults
.mode_line_format
,
5246 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5247 This is the same as (default-value 'mode-line-format). */);
5249 DEFVAR_LISP_NOPRO ("default-header-line-format",
5250 &buffer_defaults
.header_line_format
,
5251 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5252 This is the same as (default-value 'header-line-format). */);
5254 DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults
.cursor_type
,
5255 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5256 This is the same as (default-value 'cursor-type). */);
5258 DEFVAR_LISP_NOPRO ("default-line-spacing",
5259 &buffer_defaults
.extra_line_spacing
,
5260 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5261 This is the same as (default-value 'line-spacing). */);
5263 DEFVAR_LISP_NOPRO ("default-cursor-in-non-selected-windows",
5264 &buffer_defaults
.cursor_in_non_selected_windows
,
5265 doc
: /* Default value of `cursor-in-non-selected-windows'.
5266 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5268 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
5269 &buffer_defaults
.abbrev_mode
,
5270 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5271 This is the same as (default-value 'abbrev-mode). */);
5273 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
5274 &buffer_defaults
.ctl_arrow
,
5275 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5276 This is the same as (default-value 'ctl-arrow). */);
5278 DEFVAR_LISP_NOPRO ("default-direction-reversed",
5279 &buffer_defaults
.direction_reversed
,
5280 doc
: /* Default value of `direction-reversed' for buffers that do not override it.
5281 This is the same as (default-value 'direction-reversed). */);
5283 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
5284 &buffer_defaults
.enable_multibyte_characters
,
5285 doc
: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
5286 This is the same as (default-value 'enable-multibyte-characters). */);
5288 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
5289 &buffer_defaults
.buffer_file_coding_system
,
5290 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5291 This is the same as (default-value 'buffer-file-coding-system). */);
5293 DEFVAR_LISP_NOPRO ("default-truncate-lines",
5294 &buffer_defaults
.truncate_lines
,
5295 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5296 This is the same as (default-value 'truncate-lines). */);
5298 DEFVAR_LISP_NOPRO ("default-fill-column",
5299 &buffer_defaults
.fill_column
,
5300 doc
: /* Default value of `fill-column' for buffers that do not override it.
5301 This is the same as (default-value 'fill-column). */);
5303 DEFVAR_LISP_NOPRO ("default-left-margin",
5304 &buffer_defaults
.left_margin
,
5305 doc
: /* Default value of `left-margin' for buffers that do not override it.
5306 This is the same as (default-value 'left-margin). */);
5308 DEFVAR_LISP_NOPRO ("default-tab-width",
5309 &buffer_defaults
.tab_width
,
5310 doc
: /* Default value of `tab-width' for buffers that do not override it.
5311 This is the same as (default-value 'tab-width). */);
5313 DEFVAR_LISP_NOPRO ("default-case-fold-search",
5314 &buffer_defaults
.case_fold_search
,
5315 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5316 This is the same as (default-value 'case-fold-search). */);
5319 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
5320 &buffer_defaults
.buffer_file_type
,
5321 doc
: /* Default file type for buffers that do not override it.
5322 This is the same as (default-value 'buffer-file-type).
5323 The file type is nil for text, t for binary. */);
5326 DEFVAR_LISP_NOPRO ("default-left-margin-width",
5327 &buffer_defaults
.left_margin_cols
,
5328 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5329 This is the same as (default-value 'left-margin-width). */);
5331 DEFVAR_LISP_NOPRO ("default-right-margin-width",
5332 &buffer_defaults
.right_margin_cols
,
5333 doc
: /* Default value of `right-margin-width' for buffers that don't override it.
5334 This is the same as (default-value 'right-margin-width). */);
5336 DEFVAR_LISP_NOPRO ("default-left-fringe-width",
5337 &buffer_defaults
.left_fringe_width
,
5338 doc
: /* Default value of `left-fringe-width' for buffers that don't override it.
5339 This is the same as (default-value 'left-fringe-width). */);
5341 DEFVAR_LISP_NOPRO ("default-right-fringe-width",
5342 &buffer_defaults
.right_fringe_width
,
5343 doc
: /* Default value of `right-fringe-width' for buffers that don't override it.
5344 This is the same as (default-value 'right-fringe-width). */);
5346 DEFVAR_LISP_NOPRO ("default-fringes-outside-margins",
5347 &buffer_defaults
.fringes_outside_margins
,
5348 doc
: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5349 This is the same as (default-value 'fringes-outside-margins). */);
5351 DEFVAR_LISP_NOPRO ("default-scroll-bar-width",
5352 &buffer_defaults
.scroll_bar_width
,
5353 doc
: /* Default value of `scroll-bar-width' for buffers that don't override it.
5354 This is the same as (default-value 'scroll-bar-width). */);
5356 DEFVAR_LISP_NOPRO ("default-vertical-scroll-bar",
5357 &buffer_defaults
.vertical_scroll_bar_type
,
5358 doc
: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5359 This is the same as (default-value 'vertical-scroll-bar). */);
5361 DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
5362 &buffer_defaults
.indicate_empty_lines
,
5363 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5364 This is the same as (default-value 'indicate-empty-lines). */);
5366 DEFVAR_LISP_NOPRO ("default-indicate-buffer-boundaries",
5367 &buffer_defaults
.indicate_buffer_boundaries
,
5368 doc
: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5369 This is the same as (default-value 'indicate-buffer-boundaries). */);
5371 DEFVAR_LISP_NOPRO ("default-fringe-indicator-alist",
5372 &buffer_defaults
.fringe_indicator_alist
,
5373 doc
: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5374 This is the same as (default-value 'fringe-indicator-alist'). */);
5376 DEFVAR_LISP_NOPRO ("default-fringe-cursor-alist",
5377 &buffer_defaults
.fringe_cursor_alist
,
5378 doc
: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5379 This is the same as (default-value 'fringe-cursor-alist'). */);
5381 DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
5382 &buffer_defaults
.scroll_up_aggressively
,
5383 doc
: /* Default value of `scroll-up-aggressively'.
5384 This value applies in buffers that don't have their own local values.
5385 This variable is an alias for (default-value 'scroll-up-aggressively). */);
5387 DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
5388 &buffer_defaults
.scroll_down_aggressively
,
5389 doc
: /* Default value of `scroll-down-aggressively'.
5390 This value applies in buffers that don't have their own local values.
5391 This variable is an alias for (default-value 'scroll-down-aggressively). */);
5393 DEFVAR_PER_BUFFER ("header-line-format",
5394 ¤t_buffer
->header_line_format
,
5396 doc
: /* Analogous to `mode-line-format', but controls the header line.
5397 The header line appears, optionally, at the top of a window;
5398 the mode line appears at the bottom. */);
5400 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
5402 doc
: /* Template for displaying mode line for current buffer.
5403 Each buffer has its own value of this variable.
5404 Value may be nil, a string, a symbol or a list or cons cell.
5405 A value of nil means don't display a mode line.
5406 For a symbol, its value is used (but it is ignored if t or nil).
5407 A string appearing directly as the value of a symbol is processed verbatim
5408 in that the %-constructs below are not recognized.
5409 Note that unless the symbol is marked as a `risky-local-variable', all
5410 properties in any strings, as well as all :eval and :propertize forms
5411 in the value of that symbol will be ignored.
5412 For a list of the form `(:eval FORM)', FORM is evaluated and the result
5413 is used as a mode line element. Be careful--FORM should not load any files,
5414 because that can cause an infinite recursion.
5415 For a list of the form `(:propertize ELT PROPS...)', ELT is displayed
5416 with the specified properties PROPS applied.
5417 For a list whose car is a symbol, the symbol's value is taken,
5418 and if that is non-nil, the cadr of the list is processed recursively.
5419 Otherwise, the caddr of the list (if there is one) is processed.
5420 For a list whose car is a string or list, each element is processed
5421 recursively and the results are effectively concatenated.
5422 For a list whose car is an integer, the cdr of the list is processed
5423 and padded (if the number is positive) or truncated (if negative)
5424 to the width specified by that number.
5425 A string is printed verbatim in the mode line except for %-constructs:
5426 (%-constructs are allowed when the string is the entire mode-line-format
5427 or when it is found in a cons-cell or a list)
5428 %b -- print buffer name. %f -- print visited file name.
5429 %F -- print frame name.
5430 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5431 %& is like %*, but ignore read-only-ness.
5432 % means buffer is read-only and * means it is modified.
5433 For a modified read-only buffer, %* gives % and %+ gives *.
5434 %s -- print process status. %l -- print the current line number.
5435 %c -- print the current column number (this makes editing slower).
5436 To make the column number update correctly in all cases,
5437 `column-number-mode' must be non-nil.
5438 %i -- print the size of the buffer.
5439 %I -- like %i, but use k, M, G, etc., to abbreviate.
5440 %p -- print percent of buffer above top of window, or Top, Bot or All.
5441 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5442 or print Bottom or All.
5443 %n -- print Narrow if appropriate.
5444 %t -- visited file is text or binary (if OS supports this distinction).
5445 %z -- print mnemonics of buffer, terminal, and keyboard coding systems.
5446 %Z -- like %z, but including the end-of-line format.
5447 %e -- print error message about full memory.
5448 %[ -- print one [ for each recursive editing level. %] similar.
5449 %% -- print %. %- -- print infinitely many dashes.
5450 Decimal digits after the % specify field width to which to pad. */);
5452 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
5453 doc
: /* *Major mode for new buffers. Defaults to `fundamental-mode'.
5454 nil here means use current buffer's major mode, provided it is not
5455 marked as "special".
5457 When a mode is used by default, `find-file' switches to it
5458 before it reads the contents into the buffer and before
5459 it finishes setting up the buffer. Thus, the mode and
5460 its hooks should not expect certain variables such as
5461 `buffer-read-only' and `buffer-file-coding-system' to be set up. */);
5463 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
5464 make_number (Lisp_Symbol
),
5465 doc
: /* Symbol for current buffer's major mode. */);
5467 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
5469 doc
: /* Pretty name of current buffer's major mode (a string). */);
5471 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
5472 doc
: /* Non-nil turns on automatic expansion of abbrevs as they are inserted. */);
5474 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
5476 doc
: /* *Non-nil if searches and matches should ignore case. */);
5478 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
5479 make_number (Lisp_Int
),
5480 doc
: /* *Column beyond which automatic line-wrapping should happen.
5481 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5483 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
5484 make_number (Lisp_Int
),
5485 doc
: /* *Column for the default indent-line-function to indent to.
5486 Linefeed indents to this column in Fundamental mode. */);
5488 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
5489 make_number (Lisp_Int
),
5490 doc
: /* *Distance between tab stops (for display of tab characters), in columns. */);
5492 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
5493 doc
: /* *Non-nil means display control chars with uparrow.
5494 A value of nil means use backslash and octal digits.
5495 This variable does not apply to characters whose display is specified
5496 in the current display table (if there is one). */);
5498 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5499 ¤t_buffer
->enable_multibyte_characters
,
5501 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5502 Otherwise they are regarded as unibyte. This affects the display,
5503 file I/O and the behavior of various editing commands.
5505 This variable is buffer-local but you cannot set it directly;
5506 use the function `set-buffer-multibyte' to change a buffer's representation.
5507 Changing its default value with `setq-default' is supported.
5508 See also variable `default-enable-multibyte-characters' and Info node
5509 `(elisp)Text Representations'. */);
5510 XSYMBOL (intern ("enable-multibyte-characters"))->constant
= 1;
5512 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5513 ¤t_buffer
->buffer_file_coding_system
, Qnil
,
5514 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5515 This variable applies to saving the buffer, and also to `write-region'
5516 and other functions that use `write-region'.
5517 It does not apply to sending output to subprocesses, however.
5519 If this is nil, the buffer is saved without any code conversion
5520 unless some coding system is specified in `file-coding-system-alist'
5521 for the buffer file.
5523 If the text to be saved cannot be encoded as specified by this variable,
5524 an alternative encoding is selected by `select-safe-coding-system', which see.
5526 The variable `coding-system-for-write', if non-nil, overrides this variable.
5528 This variable is never applied to a way of decoding a file while reading it. */);
5530 DEFVAR_PER_BUFFER ("direction-reversed", ¤t_buffer
->direction_reversed
,
5532 doc
: /* *Non-nil means lines in the buffer are displayed right to left. */);
5534 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
5535 doc
: /* *Non-nil means do not display continuation lines.
5536 Instead, give each line of text just one screen line.
5538 Note that this is overridden by the variable
5539 `truncate-partial-width-windows' if that variable is non-nil
5540 and this buffer is not full-frame width. */);
5543 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
5545 doc
: /* Non-nil if the visited file is a binary file.
5546 This variable is meaningful on MS-DOG and Windows NT.
5547 On those systems, it is automatically local in every buffer.
5548 On other systems, this variable is normally always nil. */);
5551 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
5552 make_number (Lisp_String
),
5553 doc
: /* Name of default directory of current buffer. Should end with slash.
5554 To interactively change the default directory, use command `cd'. */);
5556 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
5558 doc
: /* Function called (if non-nil) to perform auto-fill.
5559 It is called after self-inserting any character specified in
5560 the `auto-fill-chars' table.
5561 NOTE: This variable is not a hook;
5562 its value may not be a list of functions. */);
5564 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
5565 make_number (Lisp_String
),
5566 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5568 DEFVAR_PER_BUFFER ("buffer-file-truename", ¤t_buffer
->file_truename
,
5569 make_number (Lisp_String
),
5570 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5571 The truename of a file is calculated by `file-truename'
5572 and then abbreviated with `abbreviate-file-name'. */);
5574 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5575 ¤t_buffer
->auto_save_file_name
,
5576 make_number (Lisp_String
),
5577 doc
: /* Name of file for auto-saving current buffer.
5578 If it is nil, that means don't auto-save this buffer. */);
5580 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
5581 doc
: /* Non-nil if this buffer is read-only. */);
5583 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
5584 doc
: /* Non-nil if this buffer's file has been backed up.
5585 Backing up is done before the first time the file is saved. */);
5587 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
5588 make_number (Lisp_Int
),
5589 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5592 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
5594 doc
: /* Non-nil enables selective display.
5595 An Integer N as value means display only lines
5596 that start with less than n columns of space.
5597 A value of t means that the character ^M makes itself and
5598 all the rest of the line invisible; also, when saving the buffer
5599 in a file, save the ^M as a newline. */);
5602 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5603 ¤t_buffer
->selective_display_ellipses
,
5605 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5608 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
5609 doc
: /* Non-nil if self-insertion should replace existing text.
5610 The value should be one of `overwrite-mode-textual',
5611 `overwrite-mode-binary', or nil.
5612 If it is `overwrite-mode-textual', self-insertion still
5613 inserts at the end of a line, and inserts when point is before a tab,
5614 until the tab is filled in.
5615 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5617 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
5619 doc
: /* Display table that controls display of the contents of current buffer.
5621 If this variable is nil, the value of `standard-display-table' is used.
5622 Each window can have its own, overriding display table, see
5623 `set-window-display-table' and `window-display-table'.
5625 The display table is a char-table created with `make-display-table'.
5626 A char-table is an array indexed by character codes. Normal array
5627 primitives `aref' and `aset' can be used to access elements of a char-table.
5629 Each of the char-table elements control how to display the corresponding
5630 text character: the element at index C in the table says how to display
5631 the character whose code is C. Each element should be a vector of
5632 characters or nil. nil means display the character in the default fashion;
5633 otherwise, the characters from the vector are delivered to the screen
5634 instead of the original character.
5636 For example, (aset buffer-display-table ?X ?Y) will cause Emacs to display
5637 a capital Y instead of each X character.
5639 In addition, a char-table has six extra slots to control the display of:
5641 the end of a truncated screen line (extra-slot 0, a single character);
5642 the end of a continued line (extra-slot 1, a single character);
5643 the escape character used to display character codes in octal
5644 (extra-slot 2, a single character);
5645 the character used as an arrow for control characters (extra-slot 3,
5646 a single character);
5647 the decoration indicating the presence of invisible lines (extra-slot 4,
5648 a vector of characters);
5649 the character used to draw the border between side-by-side windows
5650 (extra-slot 5, a single character).
5652 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5654 DEFVAR_PER_BUFFER ("left-margin-width", ¤t_buffer
->left_margin_cols
,
5656 doc
: /* *Width of left marginal area for display of a buffer.
5657 A value of nil means no marginal area. */);
5659 DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer
->right_margin_cols
,
5661 doc
: /* *Width of right marginal area for display of a buffer.
5662 A value of nil means no marginal area. */);
5664 DEFVAR_PER_BUFFER ("left-fringe-width", ¤t_buffer
->left_fringe_width
,
5666 doc
: /* *Width of this buffer's left fringe (in pixels).
5667 A value of 0 means no left fringe is shown in this buffer's window.
5668 A value of nil means to use the left fringe width from the window's frame. */);
5670 DEFVAR_PER_BUFFER ("right-fringe-width", ¤t_buffer
->right_fringe_width
,
5672 doc
: /* *Width of this buffer's right fringe (in pixels).
5673 A value of 0 means no right fringe is shown in this buffer's window.
5674 A value of nil means to use the right fringe width from the window's frame. */);
5676 DEFVAR_PER_BUFFER ("fringes-outside-margins", ¤t_buffer
->fringes_outside_margins
,
5678 doc
: /* *Non-nil means to display fringes outside display margins.
5679 A value of nil means to display fringes between margins and buffer text. */);
5681 DEFVAR_PER_BUFFER ("scroll-bar-width", ¤t_buffer
->scroll_bar_width
,
5683 doc
: /* *Width of this buffer's scroll bars in pixels.
5684 A value of nil means to use the scroll bar width from the window's frame. */);
5686 DEFVAR_PER_BUFFER ("vertical-scroll-bar", ¤t_buffer
->vertical_scroll_bar_type
,
5688 doc
: /* *Position of this buffer's vertical scroll bar.
5689 The value takes effect whenever you tell a window to display this buffer;
5690 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5692 A value of `left' or `right' means put the vertical scroll bar at that side
5693 of the window; a value of nil means don't show any vertical scroll bars.
5694 A value of t (the default) means do whatever the window's frame specifies. */);
5696 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5697 ¤t_buffer
->indicate_empty_lines
, Qnil
,
5698 doc
: /* *Visually indicate empty lines after the buffer end.
5699 If non-nil, a bitmap is displayed in the left fringe of a window on
5700 window-systems. */);
5702 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5703 ¤t_buffer
->indicate_buffer_boundaries
, Qnil
,
5704 doc
: /* *Visually indicate buffer boundaries and scrolling.
5705 If non-nil, the first and last line of the buffer are marked in the fringe
5706 of a window on window-systems with angle bitmaps, or if the window can be
5707 scrolled, the top and bottom line of the window are marked with up and down
5710 If value is a symbol `left' or `right', both angle and arrow bitmaps
5711 are displayed in the left or right fringe, resp. Any other value
5712 that doesn't look like an alist means display the angle bitmaps in
5713 the left fringe but no arrows.
5715 You can exercise more precise control by using an alist as the
5716 value. Each alist element (INDICATOR . POSITION) specifies
5717 where to show one of the indicators. INDICATOR is one of `top',
5718 `bottom', `up', `down', or t, which specifies the default position,
5719 and POSITION is one of `left', `right', or nil, meaning do not show
5722 For example, ((top . left) (t . right)) places the top angle bitmap in
5723 left fringe, the bottom angle bitmap in right fringe, and both arrow
5724 bitmaps in right fringe. To show just the angle bitmaps in the left
5725 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5727 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5728 ¤t_buffer
->fringe_indicator_alist
, Qnil
,
5729 doc
: /* *Mapping from logical to physical fringe indicator bitmaps.
5730 The value is an alist where each element (INDICATOR . BITMAPS)
5731 specifies the fringe bitmaps used to display a specific logical
5734 INDICATOR specifies the logical indicator type which is one of the
5735 following symbols: `truncation' , `continuation', `overlay-arrow',
5736 `top', `bottom', `up', `down', `one-line', `empty-line', or `unknown'.
5738 BITMAPS is list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5739 the actual bitmap shown in the left or right fringe for the logical
5740 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5741 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
5742 are used only for the `bottom' and `one-line' indicators when the last
5743 \(only) line in has no final newline. BITMAPS may also be a single
5744 symbol which is used in both left and right fringes. */);
5746 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
5747 ¤t_buffer
->fringe_cursor_alist
, Qnil
,
5748 doc
: /* *Mapping from logical to physical fringe cursor bitmaps.
5749 The value is an alist where each element (CURSOR . BITMAP)
5750 specifies the fringe bitmaps used to display a specific logical
5751 cursor type in the fringe.
5753 CURSOR specifies the logical cursor type which is one of the following
5754 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
5755 one is used to show a hollow cursor on narrow lines display lines
5756 where the normal hollow cursor will not fit.
5758 BITMAP is the corresponding fringe bitmap shown for the logical
5761 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5762 ¤t_buffer
->scroll_up_aggressively
, Qnil
,
5763 doc
: /* How far to scroll windows upward.
5764 If you move point off the bottom, the window scrolls automatically.
5765 This variable controls how far it scrolls. nil, the default,
5766 means scroll to center point. A fraction means scroll to put point
5767 that fraction of the window's height from the bottom of the window.
5768 When the value is 0.0, point goes at the bottom line, which in the simple
5769 case that you moved off with C-f means scrolling just one line. 1.0 means
5770 point goes at the top, so that in that simple case, the window
5771 scrolls by a full window height. Meaningful values are
5772 between 0.0 and 1.0, inclusive. */);
5774 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
5775 ¤t_buffer
->scroll_down_aggressively
, Qnil
,
5776 doc
: /* How far to scroll windows downward.
5777 If you move point off the top, the window scrolls automatically.
5778 This variable controls how far it scrolls. nil, the default,
5779 means scroll to center point. A fraction means scroll to put point
5780 that fraction of the window's height from the top of the window.
5781 When the value is 0.0, point goes at the top line, which in the simple
5782 case that you moved off with C-b means scrolling just one line. 1.0 means
5783 point goes at the bottom, so that in that simple case, the window
5784 scrolls by a full window height. Meaningful values are
5785 between 0.0 and 1.0, inclusive. */);
5787 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
5791 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
5792 doc
: /* List of functions to call before each text change.
5793 Two arguments are passed to each function: the positions of
5794 the beginning and end of the range of old text to be changed.
5795 \(For an insertion, the beginning and end are at the same place.)
5796 No information is given about the length of the text after the change.
5798 Buffer changes made while executing the `before-change-functions'
5799 don't call any before-change or after-change functions.
5800 That's because these variables are temporarily set to nil.
5801 As a result, a hook function cannot straightforwardly alter the value of
5802 these variables. See the Emacs Lisp manual for a way of
5803 accomplishing an equivalent result by using other variables.
5805 If an unhandled error happens in running these functions,
5806 the variable's value remains nil. That prevents the error
5807 from happening repeatedly and making Emacs nonfunctional. */);
5808 Vbefore_change_functions
= Qnil
;
5810 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
5811 doc
: /* List of functions to call after each text change.
5812 Three arguments are passed to each function: the positions of
5813 the beginning and end of the range of changed text,
5814 and the length in bytes of the pre-change text replaced by that range.
5815 \(For an insertion, the pre-change length is zero;
5816 for a deletion, that length is the number of bytes deleted,
5817 and the post-change beginning and end are at the same place.)
5819 Buffer changes made while executing the `after-change-functions'
5820 don't call any before-change or after-change functions.
5821 That's because these variables are temporarily set to nil.
5822 As a result, a hook function cannot straightforwardly alter the value of
5823 these variables. See the Emacs Lisp manual for a way of
5824 accomplishing an equivalent result by using other variables.
5826 If an unhandled error happens in running these functions,
5827 the variable's value remains nil. That prevents the error
5828 from happening repeatedly and making Emacs nonfunctional. */);
5829 Vafter_change_functions
= Qnil
;
5831 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
5832 doc
: /* A list of functions to call before changing a buffer which is unmodified.
5833 The functions are run using the `run-hooks' function. */);
5834 Vfirst_change_hook
= Qnil
;
5836 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
5837 doc
: /* List of undo entries in current buffer.
5838 Recent changes come first; older changes follow newer.
5840 An entry (BEG . END) represents an insertion which begins at
5841 position BEG and ends at position END.
5843 An entry (TEXT . POSITION) represents the deletion of the string TEXT
5844 from (abs POSITION). If POSITION is positive, point was at the front
5845 of the text being deleted; if negative, point was at the end.
5847 An entry (t HIGH . LOW) indicates that the buffer previously had
5848 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions
5849 of the visited file's modification time, as of that time. If the
5850 modification time of the most recent save is different, this entry is
5853 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
5854 was modified between BEG and END. PROPERTY is the property name,
5855 and VALUE is the old value.
5857 An entry (apply FUN-NAME . ARGS) means undo the change with
5858 \(apply FUN-NAME ARGS).
5860 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
5861 in the active region. BEG and END is the range affected by this entry
5862 and DELTA is the number of bytes added or deleted in that range by
5865 An entry (MARKER . DISTANCE) indicates that the marker MARKER
5866 was adjusted in position by the offset DISTANCE (an integer).
5868 An entry of the form POSITION indicates that point was at the buffer
5869 location given by the integer. Undoing an entry of this form places
5872 nil marks undo boundaries. The undo command treats the changes
5873 between two undo boundaries as a single step to be undone.
5875 If the value of the variable is t, undo information is not recorded. */);
5877 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
5878 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
5880 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
5881 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
5883 Normally, the line-motion functions work by scanning the buffer for
5884 newlines. Columnar operations (like `move-to-column' and
5885 `compute-motion') also work by scanning the buffer, summing character
5886 widths as they go. This works well for ordinary text, but if the
5887 buffer's lines are very long (say, more than 500 characters), these
5888 motion functions will take longer to execute. Emacs may also take
5889 longer to update the display.
5891 If `cache-long-line-scans' is non-nil, these motion functions cache the
5892 results of their scans, and consult the cache to avoid rescanning
5893 regions of the buffer until the text is modified. The caches are most
5894 beneficial when they prevent the most searching---that is, when the
5895 buffer contains long lines and large regions of characters with the
5896 same, fixed screen width.
5898 When `cache-long-line-scans' is non-nil, processing short lines will
5899 become slightly slower (because of the overhead of consulting the
5900 cache), and the caches will use memory roughly proportional to the
5901 number of newlines and characters whose screen width varies.
5903 The caches require no explicit maintenance; their accuracy is
5904 maintained internally by the Emacs primitives. Enabling or disabling
5905 the cache should not affect the behavior of any of the motion
5906 functions; it should only affect their performance. */);
5908 DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer
->point_before_scroll
, Qnil
,
5909 doc
: /* Value of point before the last series of scroll operations, or nil. */);
5911 DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer
->file_format
, Qnil
,
5912 doc
: /* List of formats to use when saving this buffer.
5913 Formats are defined by `format-alist'. This variable is
5914 set when a file is visited. */);
5916 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
5917 ¤t_buffer
->auto_save_file_format
, Qnil
,
5918 doc
: /* *Format in which to write auto-save files.
5919 Should be a list of symbols naming formats that are defined in `format-alist'.
5920 If it is t, which is the default, auto-save files are written in the
5921 same format as a regular save would use. */);
5923 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
5924 ¤t_buffer
->invisibility_spec
, Qnil
,
5925 doc
: /* Invisibility spec of this buffer.
5926 The default is t, which means that text is invisible
5927 if it has a non-nil `invisible' property.
5928 If the value is a list, a text character is invisible if its `invisible'
5929 property is an element in that list.
5930 If an element is a cons cell of the form (PROP . ELLIPSIS),
5931 then characters with property value PROP are invisible,
5932 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
5934 DEFVAR_PER_BUFFER ("buffer-display-count",
5935 ¤t_buffer
->display_count
, Qnil
,
5936 doc
: /* A number incremented each time this buffer is displayed in a window.
5937 The function `set-window-buffer' increments it. */);
5939 DEFVAR_PER_BUFFER ("buffer-display-time",
5940 ¤t_buffer
->display_time
, Qnil
,
5941 doc
: /* Time stamp updated each time this buffer is displayed in a window.
5942 The function `set-window-buffer' updates this variable
5943 to the value obtained by calling `current-time'.
5944 If the buffer has never been shown in a window, the value is nil. */);
5946 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
5947 doc
: /* *Non-nil means deactivate the mark when the buffer contents change.
5948 Non-nil also enables highlighting of the region whenever the mark is active.
5949 The variable `highlight-nonselected-windows' controls whether to highlight
5950 all windows or just the selected window.
5952 If the value is `lambda', that enables Transient Mark mode temporarily
5953 until the next buffer modification. If a command sets the value to `only',
5954 that enables Transient Mark mode for the following command only.
5955 During that following command, the value of `transient-mark-mode'
5956 is `identity'. If it is still `identity' at the end of that command,
5957 it changes to nil. */);
5958 Vtransient_mark_mode
= Qnil
;
5960 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
5961 doc
: /* *Non-nil means disregard read-only status of buffers or characters.
5962 If the value is t, disregard `buffer-read-only' and all `read-only'
5963 text properties. If the value is a list, disregard `buffer-read-only'
5964 and disregard a `read-only' text property if the property value
5965 is a member of the list. */);
5966 Vinhibit_read_only
= Qnil
;
5968 DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer
->cursor_type
, Qnil
,
5969 doc
: /* Cursor to use when this buffer is in the selected window.
5970 Values are interpreted as follows:
5972 t use the cursor specified for the frame
5973 nil don't display a cursor
5974 box display a filled box cursor
5975 hollow display a hollow box cursor
5976 bar display a vertical bar cursor with default width
5977 (bar . WIDTH) display a vertical bar cursor with width WIDTH
5978 hbar display a horizontal bar cursor with default height
5979 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
5980 ANYTHING ELSE display a hollow box cursor
5982 When the buffer is displayed in a nonselected window,
5983 this variable has no effect; the cursor appears as a hollow box. */);
5985 DEFVAR_PER_BUFFER ("line-spacing",
5986 ¤t_buffer
->extra_line_spacing
, Qnil
,
5987 doc
: /* Additional space to put between lines when displaying a buffer.
5988 The space is measured in pixels, and put below lines on window systems.
5989 If value is a floating point number, it specifies the spacing relative
5990 to the default frame line height. nil means add no extra space. */);
5992 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
5993 ¤t_buffer
->cursor_in_non_selected_windows
, Qnil
,
5994 doc
: /* *Cursor type to display in non-selected windows.
5995 t means to use hollow box cursor. See `cursor-type' for other values. */);
5997 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
5998 doc
: /* List of functions called with no args to query before killing a buffer. */);
5999 Vkill_buffer_query_functions
= Qnil
;
6001 defsubr (&Sbuffer_live_p
);
6002 defsubr (&Sbuffer_list
);
6003 defsubr (&Sget_buffer
);
6004 defsubr (&Sget_file_buffer
);
6005 defsubr (&Sget_buffer_create
);
6006 defsubr (&Smake_indirect_buffer
);
6007 defsubr (&Sgenerate_new_buffer_name
);
6008 defsubr (&Sbuffer_name
);
6009 /*defsubr (&Sbuffer_number);*/
6010 defsubr (&Sbuffer_file_name
);
6011 defsubr (&Sbuffer_base_buffer
);
6012 defsubr (&Sbuffer_local_value
);
6013 defsubr (&Sbuffer_local_variables
);
6014 defsubr (&Sbuffer_modified_p
);
6015 defsubr (&Sset_buffer_modified_p
);
6016 defsubr (&Sbuffer_modified_tick
);
6017 defsubr (&Srename_buffer
);
6018 defsubr (&Sother_buffer
);
6019 defsubr (&Sbuffer_enable_undo
);
6020 defsubr (&Skill_buffer
);
6021 defsubr (&Sset_buffer_major_mode
);
6022 defsubr (&Sswitch_to_buffer
);
6023 defsubr (&Spop_to_buffer
);
6024 defsubr (&Scurrent_buffer
);
6025 defsubr (&Sset_buffer
);
6026 defsubr (&Sbarf_if_buffer_read_only
);
6027 defsubr (&Sbury_buffer
);
6028 defsubr (&Serase_buffer
);
6029 defsubr (&Sset_buffer_multibyte
);
6030 defsubr (&Skill_all_local_variables
);
6032 defsubr (&Soverlayp
);
6033 defsubr (&Smake_overlay
);
6034 defsubr (&Sdelete_overlay
);
6035 defsubr (&Smove_overlay
);
6036 defsubr (&Soverlay_start
);
6037 defsubr (&Soverlay_end
);
6038 defsubr (&Soverlay_buffer
);
6039 defsubr (&Soverlay_properties
);
6040 defsubr (&Soverlays_at
);
6041 defsubr (&Soverlays_in
);
6042 defsubr (&Snext_overlay_change
);
6043 defsubr (&Sprevious_overlay_change
);
6044 defsubr (&Soverlay_recenter
);
6045 defsubr (&Soverlay_lists
);
6046 defsubr (&Soverlay_get
);
6047 defsubr (&Soverlay_put
);
6048 defsubr (&Srestore_buffer_modified_p
);
6054 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
6055 initial_define_key (control_x_map
, 'k', "kill-buffer");
6057 /* This must not be in syms_of_buffer, because Qdisabled is not
6058 initialized when that function gets called. */
6059 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);
6062 /* arch-tag: e48569bf-69a9-4b65-a23b-8e68769436e1
6063 (do not change this comment) */