1 /* Buffer manipulation primitives for GNU Emacs.
2 Copyright (C) 1985,86,87,88,89,93,94,95,97,98, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include <sys/types.h>
26 #include <sys/param.h>
35 /* in 4.1, param.h fails to define this. */
36 #define MAXPATHLEN 1024
37 #endif /* not MAXPATHLEN */
44 #include "intervals.h"
49 #include "region-cache.h"
51 #include "blockinput.h"
56 struct buffer
*current_buffer
; /* the current buffer */
58 /* First buffer in chain of all buffers (in reverse order of creation).
59 Threaded through ->next. */
61 struct buffer
*all_buffers
;
63 /* This structure holds the default values of the buffer-local variables
64 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
65 The default value occupies the same slot in this structure
66 as an individual buffer's value occupies in that buffer.
67 Setting the default value also goes through the alist of buffers
68 and stores into each buffer that does not say it has a local value. */
70 struct buffer buffer_defaults
;
72 /* A Lisp_Object pointer to the above, used for staticpro */
74 static Lisp_Object Vbuffer_defaults
;
76 /* This structure marks which slots in a buffer have corresponding
77 default values in buffer_defaults.
78 Each such slot has a nonzero value in this structure.
79 The value has only one nonzero bit.
81 When a buffer has its own local value for a slot,
82 the entry for that slot (found in the same slot in this structure)
83 is turned on in the buffer's local_flags array.
85 If a slot in this structure is -1, then even though there may
86 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
87 and the corresponding slot in buffer_defaults is not used.
89 If a slot is -2, then there is no DEFVAR_PER_BUFFER for it,
90 but there is a default value which is copied into each buffer.
92 If a slot in this structure is negative, then even though there may
93 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
94 and the corresponding slot in buffer_defaults is not used.
96 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
97 zero, that is a bug */
99 struct buffer buffer_local_flags
;
101 /* This structure holds the names of symbols whose values may be
102 buffer-local. It is indexed and accessed in the same way as the above. */
104 struct buffer buffer_local_symbols
;
105 /* A Lisp_Object pointer to the above, used for staticpro */
106 static Lisp_Object Vbuffer_local_symbols
;
108 /* This structure holds the required types for the values in the
109 buffer-local slots. If a slot contains Qnil, then the
110 corresponding buffer slot may contain a value of any type. If a
111 slot contains an integer, then prospective values' tags must be
112 equal to that integer (except nil is always allowed).
113 When a tag does not match, the function
114 buffer_slot_type_mismatch will signal an error.
116 If a slot here contains -1, the corresponding variable is read-only. */
117 struct buffer buffer_local_types
;
119 /* Flags indicating which built-in buffer-local variables
120 are permanent locals. */
121 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
123 /* Number of per-buffer variables used. */
125 int last_per_buffer_idx
;
127 Lisp_Object
Fset_buffer ();
128 void set_buffer_internal ();
129 void set_buffer_internal_1 ();
130 static void call_overlay_mod_hooks ();
131 static void swap_out_buffer_local_variables ();
132 static void reset_buffer_local_variables ();
134 /* Alist of all buffer names vs the buffers. */
135 /* This used to be a variable, but is no longer,
136 to prevent lossage due to user rplac'ing this alist or its elements. */
137 Lisp_Object Vbuffer_alist
;
139 /* Functions to call before and after each text change. */
140 Lisp_Object Vbefore_change_functions
;
141 Lisp_Object Vafter_change_functions
;
143 Lisp_Object Vtransient_mark_mode
;
145 /* t means ignore all read-only text properties.
146 A list means ignore such a property if its value is a member of the list.
147 Any non-nil value means ignore buffer-read-only. */
148 Lisp_Object Vinhibit_read_only
;
150 /* List of functions to call that can query about killing a buffer.
151 If any of these functions returns nil, we don't kill it. */
152 Lisp_Object Vkill_buffer_query_functions
;
154 /* List of functions to call before changing an unmodified buffer. */
155 Lisp_Object Vfirst_change_hook
;
157 Lisp_Object Qfirst_change_hook
;
158 Lisp_Object Qbefore_change_functions
;
159 Lisp_Object Qafter_change_functions
;
161 /* If nonzero, all modification hooks are suppressed. */
162 int inhibit_modification_hooks
;
164 Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
166 Lisp_Object Qprotected_field
;
168 Lisp_Object QSFundamental
; /* A string "Fundamental" */
170 Lisp_Object Qkill_buffer_hook
;
172 Lisp_Object Qget_file_buffer
;
174 Lisp_Object Qoverlayp
;
176 Lisp_Object Qpriority
, Qwindow
, Qevaporate
, Qbefore_string
, Qafter_string
;
178 Lisp_Object Qmodification_hooks
;
179 Lisp_Object Qinsert_in_front_hooks
;
180 Lisp_Object Qinsert_behind_hooks
;
182 static void alloc_buffer_text
P_ ((struct buffer
*, size_t));
183 static void free_buffer_text
P_ ((struct buffer
*b
));
184 static Lisp_Object copy_overlays
P_ ((struct buffer
*, Lisp_Object
));
185 static void modify_overlay
P_ ((struct buffer
*, int, int));
188 /* For debugging; temporary. See set_buffer_internal. */
189 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
196 error ("No buffer named %s", SDATA (spec
));
197 error ("Invalid buffer argument");
200 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
201 doc
: /* Return non-nil if OBJECT is a buffer which has not been killed.
202 Value is nil if OBJECT is not a buffer or if it has been killed. */)
206 return ((BUFFERP (object
) && ! NILP (XBUFFER (object
)->name
))
210 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
211 doc
: /* Return a list of all existing live buffers.
212 If the optional arg FRAME is a frame, we return the buffer list
213 in the proper order for that frame: the buffers in FRAME's `buffer-list'
214 frame parameter come first, followed by the rest of the buffers. */)
218 Lisp_Object framelist
, general
;
219 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
227 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
229 /* Remove from GENERAL any buffer that duplicates one in FRAMELIST. */
231 while (! NILP (tail
))
233 general
= Fdelq (XCAR (tail
), general
);
236 return nconc2 (framelist
, general
);
242 /* Like Fassoc, but use Fstring_equal to compare
243 (which ignores text properties),
244 and don't ever QUIT. */
247 assoc_ignore_text_properties (key
, list
)
248 register Lisp_Object key
;
251 register Lisp_Object tail
;
252 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
254 register Lisp_Object elt
, tem
;
256 tem
= Fstring_equal (Fcar (elt
), key
);
263 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
264 doc
: /* Return the buffer named NAME (a string).
265 If there is no live buffer named NAME, return nil.
266 NAME may also be a buffer; if so, the value is that buffer. */)
268 register Lisp_Object name
;
274 return Fcdr (assoc_ignore_text_properties (name
, Vbuffer_alist
));
277 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
278 doc
: /* Return the buffer visiting file FILENAME (a string).
279 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
280 If there is no such live buffer, return nil.
281 See also `find-buffer-visiting'. */)
283 register Lisp_Object filename
;
285 register Lisp_Object tail
, buf
, tem
;
288 CHECK_STRING (filename
);
289 filename
= Fexpand_file_name (filename
, Qnil
);
291 /* If the file name has special constructs in it,
292 call the corresponding file handler. */
293 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
295 return call2 (handler
, Qget_file_buffer
, filename
);
297 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
299 buf
= Fcdr (XCAR (tail
));
300 if (!BUFFERP (buf
)) continue;
301 if (!STRINGP (XBUFFER (buf
)->filename
)) continue;
302 tem
= Fstring_equal (XBUFFER (buf
)->filename
, filename
);
310 get_truename_buffer (filename
)
311 register Lisp_Object filename
;
313 register Lisp_Object tail
, buf
, tem
;
315 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
317 buf
= Fcdr (XCAR (tail
));
318 if (!BUFFERP (buf
)) continue;
319 if (!STRINGP (XBUFFER (buf
)->file_truename
)) continue;
320 tem
= Fstring_equal (XBUFFER (buf
)->file_truename
, filename
);
327 /* Incremented for each buffer created, to assign the buffer number. */
330 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
331 doc
: /* Return the buffer named NAME, or create such a buffer and return it.
332 A new buffer is created if there is no live buffer named NAME.
333 If NAME starts with a space, the new buffer does not keep undo information.
334 If NAME is a buffer instead of a string, then it is the value returned.
335 The value is never nil. */)
337 register Lisp_Object name
;
339 register Lisp_Object buf
;
340 register struct buffer
*b
;
342 buf
= Fget_buffer (name
);
346 if (SCHARS (name
) == 0)
347 error ("Empty string for buffer name is not allowed");
349 b
= (struct buffer
*) allocate_buffer ();
351 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
353 /* An ordinary buffer uses its own struct buffer_text. */
354 b
->text
= &b
->own_text
;
357 BUF_GAP_SIZE (b
) = 20;
359 /* We allocate extra 1-byte at the tail and keep it always '\0' for
360 anchoring a search. */
361 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
363 if (! BUF_BEG_ADDR (b
))
364 buffer_memory_full ();
372 BUF_GPT_BYTE (b
) = 1;
373 BUF_BEGV_BYTE (b
) = 1;
377 BUF_OVERLAY_MODIFF (b
) = 1;
378 BUF_SAVE_MODIFF (b
) = 1;
379 BUF_INTERVALS (b
) = 0;
380 BUF_UNCHANGED_MODIFIED (b
) = 1;
381 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
382 BUF_END_UNCHANGED (b
) = 0;
383 BUF_BEG_UNCHANGED (b
) = 0;
384 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
386 b
->newline_cache
= 0;
387 b
->width_run_cache
= 0;
388 b
->width_table
= Qnil
;
389 b
->prevent_redisplay_optimizations_p
= 1;
391 /* Put this on the chain of all buffers including killed ones. */
392 b
->next
= all_buffers
;
395 /* An ordinary buffer normally doesn't need markers
396 to handle BEGV and ZV. */
398 b
->begv_marker
= Qnil
;
401 name
= Fcopy_sequence (name
);
402 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
405 if (SREF (name
, 0) != ' ')
411 reset_buffer_local_variables (b
, 1);
413 /* Put this in the alist of all live buffers. */
415 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
417 b
->mark
= Fmake_marker ();
418 BUF_MARKERS (b
) = Qnil
;
424 /* Return a list of overlays which is a copy of the overlay list
425 LIST, but for buffer B. */
428 copy_overlays (b
, list
)
432 Lisp_Object result
, buffer
;
434 XSETBUFFER (buffer
, b
);
436 for (result
= Qnil
; CONSP (list
); list
= XCDR (list
))
438 Lisp_Object overlay
, start
, end
, old_overlay
;
441 old_overlay
= XCAR (list
);
442 charpos
= marker_position (OVERLAY_START (old_overlay
));
443 start
= Fmake_marker ();
444 Fset_marker (start
, make_number (charpos
), buffer
);
445 XMARKER (start
)->insertion_type
446 = XMARKER (OVERLAY_START (old_overlay
))->insertion_type
;
448 charpos
= marker_position (OVERLAY_END (old_overlay
));
449 end
= Fmake_marker ();
450 Fset_marker (end
, make_number (charpos
), buffer
);
451 XMARKER (end
)->insertion_type
452 = XMARKER (OVERLAY_END (old_overlay
))->insertion_type
;
454 overlay
= allocate_misc ();
455 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
456 OVERLAY_START (overlay
) = start
;
457 OVERLAY_END (overlay
) = end
;
458 OVERLAY_PLIST (overlay
) = Fcopy_sequence (OVERLAY_PLIST (old_overlay
));
460 result
= Fcons (overlay
, result
);
463 return Fnreverse (result
);
467 /* Clone per-buffer values of buffer FROM.
469 Buffer TO gets the same per-buffer values as FROM, with the
470 following exceptions: (1) TO's name is left untouched, (2) markers
471 are copied and made to refer to TO, and (3) overlay lists are
475 clone_per_buffer_values (from
, to
)
476 struct buffer
*from
, *to
;
478 Lisp_Object to_buffer
;
481 XSETBUFFER (to_buffer
, to
);
483 for (offset
= PER_BUFFER_VAR_OFFSET (name
) + sizeof (Lisp_Object
);
485 offset
+= sizeof (Lisp_Object
))
489 obj
= PER_BUFFER_VALUE (from
, offset
);
492 struct Lisp_Marker
*m
= XMARKER (obj
);
493 obj
= Fmake_marker ();
494 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
495 set_marker_both (obj
, to_buffer
, m
->charpos
, m
->bytepos
);
498 PER_BUFFER_VALUE (to
, offset
) = obj
;
501 bcopy (from
->local_flags
, to
->local_flags
, sizeof to
->local_flags
);
503 to
->overlays_before
= copy_overlays (to
, from
->overlays_before
);
504 to
->overlays_after
= copy_overlays (to
, from
->overlays_after
);
508 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
510 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
511 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
512 BASE-BUFFER should be an existing buffer (or buffer name).
513 NAME should be a string which is not the name of an existing buffer.
514 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
515 such as major and minor modes, in the indirect buffer.
516 CLONE nil means the indirect buffer's state is reset to default values. */)
517 (base_buffer
, name
, clone
)
518 Lisp_Object base_buffer
, name
, clone
;
523 buf
= Fget_buffer (name
);
525 error ("Buffer name `%s' is in use", SDATA (name
));
527 base_buffer
= Fget_buffer (base_buffer
);
528 if (NILP (base_buffer
))
529 error ("No such buffer: `%s'", SDATA (name
));
531 if (SCHARS (name
) == 0)
532 error ("Empty string for buffer name is not allowed");
534 b
= (struct buffer
*) allocate_buffer ();
535 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
537 if (XBUFFER (base_buffer
)->base_buffer
)
538 b
->base_buffer
= XBUFFER (base_buffer
)->base_buffer
;
540 b
->base_buffer
= XBUFFER (base_buffer
);
542 /* Use the base buffer's text object. */
543 b
->text
= b
->base_buffer
->text
;
545 BUF_BEGV (b
) = BUF_BEGV (b
->base_buffer
);
546 BUF_ZV (b
) = BUF_ZV (b
->base_buffer
);
547 BUF_PT (b
) = BUF_PT (b
->base_buffer
);
548 BUF_BEGV_BYTE (b
) = BUF_BEGV_BYTE (b
->base_buffer
);
549 BUF_ZV_BYTE (b
) = BUF_ZV_BYTE (b
->base_buffer
);
550 BUF_PT_BYTE (b
) = BUF_PT_BYTE (b
->base_buffer
);
552 b
->newline_cache
= 0;
553 b
->width_run_cache
= 0;
554 b
->width_table
= Qnil
;
556 /* Put this on the chain of all buffers including killed ones. */
557 b
->next
= all_buffers
;
560 name
= Fcopy_sequence (name
);
561 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
565 reset_buffer_local_variables (b
, 1);
567 /* Put this in the alist of all live buffers. */
569 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
571 b
->mark
= Fmake_marker ();
574 /* The multibyte status belongs to the base buffer. */
575 b
->enable_multibyte_characters
= b
->base_buffer
->enable_multibyte_characters
;
577 /* Make sure the base buffer has markers for its narrowing. */
578 if (NILP (b
->base_buffer
->pt_marker
))
580 b
->base_buffer
->pt_marker
= Fmake_marker ();
581 set_marker_both (b
->base_buffer
->pt_marker
, base_buffer
,
582 BUF_PT (b
->base_buffer
),
583 BUF_PT_BYTE (b
->base_buffer
));
585 if (NILP (b
->base_buffer
->begv_marker
))
587 b
->base_buffer
->begv_marker
= Fmake_marker ();
588 set_marker_both (b
->base_buffer
->begv_marker
, base_buffer
,
589 BUF_BEGV (b
->base_buffer
),
590 BUF_BEGV_BYTE (b
->base_buffer
));
592 if (NILP (b
->base_buffer
->zv_marker
))
594 b
->base_buffer
->zv_marker
= Fmake_marker ();
595 set_marker_both (b
->base_buffer
->zv_marker
, base_buffer
,
596 BUF_ZV (b
->base_buffer
),
597 BUF_ZV_BYTE (b
->base_buffer
));
598 XMARKER (b
->base_buffer
->zv_marker
)->insertion_type
= 1;
603 /* Give the indirect buffer markers for its narrowing. */
604 b
->pt_marker
= Fmake_marker ();
605 set_marker_both (b
->pt_marker
, buf
, BUF_PT (b
), BUF_PT_BYTE (b
));
606 b
->begv_marker
= Fmake_marker ();
607 set_marker_both (b
->begv_marker
, buf
, BUF_BEGV (b
), BUF_BEGV_BYTE (b
));
608 b
->zv_marker
= Fmake_marker ();
609 set_marker_both (b
->zv_marker
, buf
, BUF_ZV (b
), BUF_ZV_BYTE (b
));
610 XMARKER (b
->zv_marker
)->insertion_type
= 1;
613 clone_per_buffer_values (b
->base_buffer
, b
);
618 /* Reinitialize everything about a buffer except its name and contents
619 and local variables. */
623 register struct buffer
*b
;
626 b
->file_truename
= Qnil
;
627 b
->directory
= (current_buffer
) ? current_buffer
->directory
: Qnil
;
629 XSETFASTINT (b
->save_length
, 0);
630 b
->last_window_start
= 1;
631 /* It is more conservative to start out "changed" than "unchanged". */
633 b
->prevent_redisplay_optimizations_p
= 1;
635 b
->auto_save_modified
= 0;
636 b
->auto_save_failure_time
= -1;
637 b
->auto_save_file_name
= Qnil
;
639 b
->overlays_before
= Qnil
;
640 b
->overlays_after
= Qnil
;
641 XSETFASTINT (b
->overlay_center
, 1);
642 b
->mark_active
= Qnil
;
643 b
->point_before_scroll
= Qnil
;
644 b
->file_format
= Qnil
;
645 b
->last_selected_window
= Qnil
;
646 XSETINT (b
->display_count
, 0);
647 b
->display_time
= Qnil
;
648 b
->enable_multibyte_characters
= buffer_defaults
.enable_multibyte_characters
;
649 b
->cursor_type
= buffer_defaults
.cursor_type
;
650 b
->extra_line_spacing
= buffer_defaults
.extra_line_spacing
;
652 b
->display_error_modiff
= 0;
655 /* Reset buffer B's local variables info.
656 Don't use this on a buffer that has already been in use;
657 it does not treat permanent locals consistently.
658 Instead, use Fkill_all_local_variables.
660 If PERMANENT_TOO is 1, then we reset permanent built-in
661 buffer-local variables. If PERMANENT_TOO is 0,
662 we preserve those. */
665 reset_buffer_local_variables (b
, permanent_too
)
666 register struct buffer
*b
;
672 /* Reset the major mode to Fundamental, together with all the
673 things that depend on the major mode.
674 default-major-mode is handled at a higher level.
675 We ignore it here. */
676 b
->major_mode
= Qfundamental_mode
;
678 b
->abbrev_table
= Vfundamental_mode_abbrev_table
;
679 b
->mode_name
= QSFundamental
;
680 b
->minor_modes
= Qnil
;
682 /* If the standard case table has been altered and invalidated,
683 fix up its insides first. */
684 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
685 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
686 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
687 Fset_standard_case_table (Vascii_downcase_table
);
689 b
->downcase_table
= Vascii_downcase_table
;
690 b
->upcase_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
691 b
->case_canon_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
692 b
->case_eqv_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
693 b
->invisibility_spec
= Qt
;
695 b
->buffer_file_type
= Qnil
;
698 /* Reset all (or most) per-buffer variables to their defaults. */
699 b
->local_var_alist
= Qnil
;
700 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
701 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
702 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
704 /* For each slot that has a default value,
705 copy that into the slot. */
707 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
709 offset
+= sizeof (Lisp_Object
))
711 int idx
= PER_BUFFER_IDX (offset
);
714 || buffer_permanent_local_flags
[idx
] == 0))
715 /* Is -2 used anywhere? */
717 PER_BUFFER_VALUE (b
, offset
) = PER_BUFFER_DEFAULT (offset
);
721 /* We split this away from generate-new-buffer, because rename-buffer
722 and set-visited-file-name ought to be able to use this to really
723 rename the buffer properly. */
725 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
727 doc
: /* Return a string that is the name of no existing buffer based on NAME.
728 If there is no live buffer named NAME, then return NAME.
729 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
730 until an unused name is found, and then return that name.
731 Optional second argument IGNORE specifies a name that is okay to use
732 \(if it is in the sequence to be tried)
733 even if a buffer with that name exists. */)
735 register Lisp_Object name
, ignore
;
737 register Lisp_Object gentemp
, tem
;
743 tem
= Fget_buffer (name
);
750 sprintf (number
, "<%d>", ++count
);
751 gentemp
= concat2 (name
, build_string (number
));
752 tem
= Fstring_equal (gentemp
, ignore
);
755 tem
= Fget_buffer (gentemp
);
762 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
763 doc
: /* Return the name of BUFFER, as a string.
764 With no argument or nil as argument, return the name of the current buffer. */)
766 register Lisp_Object buffer
;
769 return current_buffer
->name
;
770 CHECK_BUFFER (buffer
);
771 return XBUFFER (buffer
)->name
;
774 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
775 doc
: /* Return name of file BUFFER is visiting, or nil if none.
776 No argument or nil as argument means use the current buffer. */)
778 register Lisp_Object buffer
;
781 return current_buffer
->filename
;
782 CHECK_BUFFER (buffer
);
783 return XBUFFER (buffer
)->filename
;
786 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
788 doc
: /* Return the base buffer of indirect buffer BUFFER.
789 If BUFFER is not indirect, return nil. */)
791 register Lisp_Object buffer
;
794 Lisp_Object base_buffer
;
797 base
= current_buffer
->base_buffer
;
800 CHECK_BUFFER (buffer
);
801 base
= XBUFFER (buffer
)->base_buffer
;
806 XSETBUFFER (base_buffer
, base
);
810 DEFUN ("buffer-local-value", Fbuffer_local_value
,
811 Sbuffer_local_value
, 2, 2, 0,
812 doc
: /* Return the value of VARIABLE in BUFFER.
813 If VARIABLE does not have a buffer-local binding in BUFFER, the value
814 is the default binding of variable. */)
816 register Lisp_Object symbol
;
817 register Lisp_Object buffer
;
819 register struct buffer
*buf
;
820 register Lisp_Object result
;
822 CHECK_SYMBOL (symbol
);
823 CHECK_BUFFER (buffer
);
824 buf
= XBUFFER (buffer
);
826 /* Look in local_var_list */
827 result
= Fassoc (symbol
, buf
->local_var_alist
);
833 /* Look in special slots */
834 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
835 offset
< sizeof (struct buffer
);
836 /* sizeof EMACS_INT == sizeof Lisp_Object */
837 offset
+= (sizeof (EMACS_INT
)))
839 idx
= PER_BUFFER_IDX (offset
);
840 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
841 && SYMBOLP (PER_BUFFER_SYMBOL (offset
))
842 && EQ (PER_BUFFER_SYMBOL (offset
), symbol
))
844 result
= PER_BUFFER_VALUE (buf
, offset
);
851 result
= Fdefault_value (symbol
);
855 Lisp_Object valcontents
;
856 Lisp_Object current_alist_element
;
858 /* What binding is loaded right now? */
859 valcontents
= SYMBOL_VALUE (symbol
);
860 current_alist_element
861 = XCAR (XBUFFER_LOCAL_VALUE (valcontents
)->cdr
);
863 /* The value of the currently loaded binding is not
864 stored in it, but rather in the realvalue slot.
865 Store that value into the binding it belongs to
866 in case that is the one we are about to use. */
868 Fsetcdr (current_alist_element
,
869 do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
));
871 /* Now get the (perhaps updated) value out of the binding. */
872 result
= XCDR (result
);
875 if (EQ (result
, Qunbound
))
876 return Fsignal (Qvoid_variable
, Fcons (symbol
, Qnil
));
881 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
882 Sbuffer_local_variables
, 0, 1, 0,
883 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
884 Most elements look like (SYMBOL . VALUE), describing one variable.
885 For a symbol that is locally unbound, just the symbol appears in the value.
886 Note that storing new VALUEs in these elements doesn't change the variables.
887 No argument or nil as argument means use current buffer as BUFFER. */)
889 register Lisp_Object buffer
;
891 register struct buffer
*buf
;
892 register Lisp_Object result
;
895 buf
= current_buffer
;
898 CHECK_BUFFER (buffer
);
899 buf
= XBUFFER (buffer
);
905 register Lisp_Object tail
;
906 for (tail
= buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
908 Lisp_Object val
, elt
;
912 /* Reference each variable in the alist in buf.
913 If inquiring about the current buffer, this gets the current values,
914 so store them into the alist so the alist is up to date.
915 If inquiring about some other buffer, this swaps out any values
916 for that buffer, making the alist up to date automatically. */
917 val
= find_symbol_value (XCAR (elt
));
918 /* Use the current buffer value only if buf is the current buffer. */
919 if (buf
!= current_buffer
)
922 /* If symbol is unbound, put just the symbol in the list. */
923 if (EQ (val
, Qunbound
))
924 result
= Fcons (XCAR (elt
), result
);
925 /* Otherwise, put (symbol . value) in the list. */
927 result
= Fcons (Fcons (XCAR (elt
), val
), result
);
931 /* Add on all the variables stored in special slots. */
935 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
936 offset
< sizeof (struct buffer
);
937 /* sizeof EMACS_INT == sizeof Lisp_Object */
938 offset
+= (sizeof (EMACS_INT
)))
940 idx
= PER_BUFFER_IDX (offset
);
941 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
942 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
943 result
= Fcons (Fcons (PER_BUFFER_SYMBOL (offset
),
944 PER_BUFFER_VALUE (buf
, offset
)),
953 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
955 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
956 No argument or nil as argument means use current buffer as BUFFER. */)
958 register Lisp_Object buffer
;
960 register struct buffer
*buf
;
962 buf
= current_buffer
;
965 CHECK_BUFFER (buffer
);
966 buf
= XBUFFER (buffer
);
969 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
972 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
974 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
975 A non-nil FLAG means mark the buffer modified. */)
977 register Lisp_Object flag
;
979 register int already
;
980 register Lisp_Object fn
;
981 Lisp_Object buffer
, window
;
983 #ifdef CLASH_DETECTION
984 /* If buffer becoming modified, lock the file.
985 If buffer becoming unmodified, unlock the file. */
987 fn
= current_buffer
->file_truename
;
988 /* Test buffer-file-name so that binding it to nil is effective. */
989 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
991 already
= SAVE_MODIFF
< MODIFF
;
992 if (!already
&& !NILP (flag
))
994 else if (already
&& NILP (flag
))
997 #endif /* CLASH_DETECTION */
999 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1001 /* Set update_mode_lines only if buffer is displayed in some window.
1002 Packages like jit-lock or lazy-lock preserve a buffer's modified
1003 state by recording/restoring the state around blocks of code.
1004 Setting update_mode_lines makes redisplay consider all windows
1005 (on all frames). Stealth fontification of buffers not displayed
1006 would incur additional redisplay costs if we'd set
1007 update_modes_lines unconditionally.
1009 Ideally, I think there should be another mechanism for fontifying
1010 buffers without "modifying" buffers, or redisplay should be
1011 smarter about updating the `*' in mode lines. --gerd */
1012 XSETBUFFER (buffer
, current_buffer
);
1013 window
= Fget_buffer_window (buffer
, Qt
);
1014 if (WINDOWP (window
))
1016 ++update_mode_lines
;
1017 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1023 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1024 Srestore_buffer_modified_p
, 1, 1, 0,
1025 doc
: /* Like `set-buffer-modified-p', with a differences concerning redisplay.
1026 It is not ensured that mode lines will be updated to show the modified
1027 state of the current buffer. Use with care. */)
1031 #ifdef CLASH_DETECTION
1034 /* If buffer becoming modified, lock the file.
1035 If buffer becoming unmodified, unlock the file. */
1037 fn
= current_buffer
->file_truename
;
1038 /* Test buffer-file-name so that binding it to nil is effective. */
1039 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1041 int already
= SAVE_MODIFF
< MODIFF
;
1042 if (!already
&& !NILP (flag
))
1044 else if (already
&& NILP (flag
))
1047 #endif /* CLASH_DETECTION */
1049 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1053 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1055 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1056 Each buffer has a tick counter which is incremented each time the text in
1057 that buffer is changed. It wraps around occasionally.
1058 No argument or nil as argument means use current buffer as BUFFER. */)
1060 register Lisp_Object buffer
;
1062 register struct buffer
*buf
;
1064 buf
= current_buffer
;
1067 CHECK_BUFFER (buffer
);
1068 buf
= XBUFFER (buffer
);
1071 return make_number (BUF_MODIFF (buf
));
1074 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1075 "sRename buffer (to new name): \nP",
1076 doc
: /* Change current buffer's name to NEWNAME (a string).
1077 If second arg UNIQUE is nil or omitted, it is an error if a
1078 buffer named NEWNAME already exists.
1079 If UNIQUE is non-nil, come up with a new name using
1080 `generate-new-buffer-name'.
1081 Interactively, you can set UNIQUE with a prefix argument.
1082 We return the name we actually gave the buffer.
1083 This does not change the name of the visited file (if any). */)
1085 register Lisp_Object newname
, unique
;
1087 register Lisp_Object tem
, buf
;
1089 CHECK_STRING (newname
);
1091 if (SCHARS (newname
) == 0)
1092 error ("Empty string is invalid as a buffer name");
1094 tem
= Fget_buffer (newname
);
1097 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1098 rename the buffer automatically so you can create another
1099 with the original name. It makes UNIQUE equivalent to
1100 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1101 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1102 return current_buffer
->name
;
1104 newname
= Fgenerate_new_buffer_name (newname
, current_buffer
->name
);
1106 error ("Buffer name `%s' is in use", SDATA (newname
));
1109 current_buffer
->name
= newname
;
1111 /* Catch redisplay's attention. Unless we do this, the mode lines for
1112 any windows displaying current_buffer will stay unchanged. */
1113 update_mode_lines
++;
1115 XSETBUFFER (buf
, current_buffer
);
1116 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1117 if (NILP (current_buffer
->filename
)
1118 && !NILP (current_buffer
->auto_save_file_name
))
1119 call0 (intern ("rename-auto-save-file"));
1120 /* Refetch since that last call may have done GC. */
1121 return current_buffer
->name
;
1124 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1125 doc
: /* Return most recently selected buffer other than BUFFER.
1126 Buffers not visible in windows are preferred to visible buffers,
1127 unless optional second argument VISIBLE-OK is non-nil.
1128 If the optional third argument FRAME is non-nil, use that frame's
1129 buffer list instead of the selected frame's buffer list.
1130 If no other buffer exists, the buffer `*scratch*' is returned.
1131 If BUFFER is omitted or nil, some interesting buffer is returned. */)
1132 (buffer
, visible_ok
, frame
)
1133 register Lisp_Object buffer
, visible_ok
, frame
;
1135 Lisp_Object
Fset_buffer_major_mode ();
1136 register Lisp_Object tail
, buf
, notsogood
, tem
, pred
, add_ons
;
1140 frame
= selected_frame
;
1142 tail
= Vbuffer_alist
;
1143 pred
= frame_buffer_predicate (frame
);
1145 /* Consider buffers that have been seen in the selected frame
1146 before other buffers. */
1148 tem
= frame_buffer_list (frame
);
1152 if (BUFFERP (XCAR (tem
)))
1153 add_ons
= Fcons (Fcons (Qnil
, XCAR (tem
)), add_ons
);
1156 tail
= nconc2 (Fnreverse (add_ons
), tail
);
1158 for (; !NILP (tail
); tail
= Fcdr (tail
))
1160 buf
= Fcdr (Fcar (tail
));
1161 if (EQ (buf
, buffer
))
1163 if (SREF (XBUFFER (buf
)->name
, 0) == ' ')
1165 /* If the selected frame has a buffer_predicate,
1166 disregard buffers that don't fit the predicate. */
1169 tem
= call1 (pred
, buf
);
1174 if (NILP (visible_ok
))
1175 tem
= Fget_buffer_window (buf
, Qvisible
);
1180 if (NILP (notsogood
))
1183 if (!NILP (notsogood
))
1185 buf
= Fget_buffer (build_string ("*scratch*"));
1188 buf
= Fget_buffer_create (build_string ("*scratch*"));
1189 Fset_buffer_major_mode (buf
);
1194 DEFUN ("buffer-disable-undo", Fbuffer_disable_undo
, Sbuffer_disable_undo
,
1196 doc
: /* Make BUFFER stop keeping undo information.
1197 No argument or nil as argument means do this for the current buffer. */)
1199 register Lisp_Object buffer
;
1201 Lisp_Object real_buffer
;
1204 XSETBUFFER (real_buffer
, current_buffer
);
1207 real_buffer
= Fget_buffer (buffer
);
1208 if (NILP (real_buffer
))
1212 XBUFFER (real_buffer
)->undo_list
= Qt
;
1217 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1219 doc
: /* Start keeping undo information for buffer BUFFER.
1220 No argument or nil as argument means do this for the current buffer. */)
1222 register Lisp_Object buffer
;
1224 Lisp_Object real_buffer
;
1227 XSETBUFFER (real_buffer
, current_buffer
);
1230 real_buffer
= Fget_buffer (buffer
);
1231 if (NILP (real_buffer
))
1235 if (EQ (XBUFFER (real_buffer
)->undo_list
, Qt
))
1236 XBUFFER (real_buffer
)->undo_list
= Qnil
;
1242 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
1243 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
1244 The buffer being killed will be current while the hook is running.\n\
1247 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 1, 1, "bKill buffer: ",
1248 doc
: /* Kill the buffer BUFFER.
1249 The argument may be a buffer or may be the name of a buffer.
1250 An argument of nil means kill the current buffer.
1252 Value is t if the buffer is actually killed, nil if user says no.
1254 The value of `kill-buffer-hook' (which may be local to that buffer),
1255 if not void, is a list of functions to be called, with no arguments,
1256 before the buffer is actually killed. The buffer to be killed is current
1257 when the hook functions are called.
1259 Any processes that have this buffer as the `process-buffer' are killed
1265 register struct buffer
*b
;
1266 register Lisp_Object tem
;
1267 register struct Lisp_Marker
*m
;
1268 struct gcpro gcpro1
;
1271 buf
= Fcurrent_buffer ();
1273 buf
= Fget_buffer (buffer
);
1279 /* Avoid trouble for buffer already dead. */
1283 /* Query if the buffer is still modified. */
1284 if (INTERACTIVE
&& !NILP (b
->filename
)
1285 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1288 tem
= do_yes_or_no_p (format1 ("Buffer %s modified; kill anyway? ",
1295 /* Run hooks with the buffer to be killed the current buffer. */
1297 int count
= SPECPDL_INDEX ();
1300 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1301 set_buffer_internal (b
);
1303 /* First run the query functions; if any query is answered no,
1304 don't kill the buffer. */
1305 for (list
= Vkill_buffer_query_functions
; !NILP (list
); list
= Fcdr (list
))
1307 tem
= call0 (Fcar (list
));
1309 return unbind_to (count
, Qnil
);
1312 /* Then run the hooks. */
1313 Frun_hooks (1, &Qkill_buffer_hook
);
1314 unbind_to (count
, Qnil
);
1317 /* We have no more questions to ask. Verify that it is valid
1318 to kill the buffer. This must be done after the questions
1319 since anything can happen within do_yes_or_no_p. */
1321 /* Don't kill the minibuffer now current. */
1322 if (EQ (buf
, XWINDOW (minibuf_window
)->buffer
))
1328 /* When we kill a base buffer, kill all its indirect buffers.
1329 We do it at this stage so nothing terrible happens if they
1330 ask questions or their hooks get errors. */
1331 if (! b
->base_buffer
)
1333 struct buffer
*other
;
1337 for (other
= all_buffers
; other
; other
= other
->next
)
1338 /* all_buffers contains dead buffers too;
1339 don't re-kill them. */
1340 if (other
->base_buffer
== b
&& !NILP (other
->name
))
1343 XSETBUFFER (buf
, other
);
1350 /* Make this buffer not be current.
1351 In the process, notice if this is the sole visible buffer
1352 and give up if so. */
1353 if (b
== current_buffer
)
1355 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1357 if (b
== current_buffer
)
1361 /* Notice if the buffer to kill is the sole visible buffer
1362 when we're currently in the mini-buffer, and give up if so. */
1363 XSETBUFFER (tem
, current_buffer
);
1364 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
))
1366 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1371 /* Now there is no question: we can kill the buffer. */
1373 #ifdef CLASH_DETECTION
1374 /* Unlock this buffer's file, if it is locked. */
1376 #endif /* CLASH_DETECTION */
1378 kill_buffer_processes (buf
);
1380 tem
= Vinhibit_quit
;
1382 replace_buffer_in_all_windows (buf
);
1383 Vbuffer_alist
= Fdelq (Frassq (buf
, Vbuffer_alist
), Vbuffer_alist
);
1384 frames_discard_buffer (buf
);
1385 Vinhibit_quit
= tem
;
1387 /* Delete any auto-save file, if we saved it in this session.
1388 But not if the buffer is modified. */
1389 if (STRINGP (b
->auto_save_file_name
)
1390 && b
->auto_save_modified
!= 0
1391 && BUF_SAVE_MODIFF (b
) < b
->auto_save_modified
1392 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
))
1395 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
1397 internal_delete_file (b
->auto_save_file_name
);
1402 /* Unchain all markers that belong to this indirect buffer.
1403 Don't unchain the markers that belong to the base buffer
1404 or its other indirect buffers. */
1405 for (tem
= BUF_MARKERS (b
); !NILP (tem
); )
1411 unchain_marker (tem
);
1417 /* Unchain all markers of this buffer and its indirect buffers.
1418 and leave them pointing nowhere. */
1419 for (tem
= BUF_MARKERS (b
); !NILP (tem
); )
1426 BUF_MARKERS (b
) = Qnil
;
1427 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1429 /* Perhaps we should explicitly free the interval tree here... */
1432 /* Reset the local variables, so that this buffer's local values
1433 won't be protected from GC. They would be protected
1434 if they happened to remain encached in their symbols.
1435 This gets rid of them for certain. */
1436 swap_out_buffer_local_variables (b
);
1437 reset_buffer_local_variables (b
, 1);
1442 if (! b
->base_buffer
)
1443 free_buffer_text (b
);
1445 if (b
->newline_cache
)
1447 free_region_cache (b
->newline_cache
);
1448 b
->newline_cache
= 0;
1450 if (b
->width_run_cache
)
1452 free_region_cache (b
->width_run_cache
);
1453 b
->width_run_cache
= 0;
1455 b
->width_table
= Qnil
;
1457 b
->undo_list
= Qnil
;
1462 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
1463 we do this each time BUF is selected visibly, the more recently
1464 selected buffers are always closer to the front of the list. This
1465 means that other_buffer is more likely to choose a relevant buffer. */
1471 register Lisp_Object link
, prev
;
1473 frame
= selected_frame
;
1476 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCDR (link
))
1478 if (EQ (XCDR (XCAR (link
)), buf
))
1483 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
1484 we cannot use Fdelq itself here because it allows quitting. */
1487 Vbuffer_alist
= XCDR (Vbuffer_alist
);
1489 XSETCDR (prev
, XCDR (XCDR (prev
)));
1491 XSETCDR (link
, Vbuffer_alist
);
1492 Vbuffer_alist
= link
;
1494 /* Now move this buffer to the front of frame_buffer_list also. */
1497 for (link
= frame_buffer_list (frame
); CONSP (link
);
1500 if (EQ (XCAR (link
), buf
))
1505 /* Effectively do delq. */
1510 set_frame_buffer_list (frame
,
1511 XCDR (frame_buffer_list (frame
)));
1513 XSETCDR (prev
, XCDR (XCDR (prev
)));
1515 XSETCDR (link
, frame_buffer_list (frame
));
1516 set_frame_buffer_list (frame
, link
);
1519 set_frame_buffer_list (frame
, Fcons (buf
, frame_buffer_list (frame
)));
1522 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1523 doc
: /* Set an appropriate major mode for BUFFER.
1524 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1525 according to `default-major-mode'.
1526 Use this function before selecting the buffer, since it may need to inspect
1527 the current buffer's major mode. */)
1532 Lisp_Object function
;
1534 if (STRINGP (XBUFFER (buffer
)->name
)
1535 && strcmp (SDATA (XBUFFER (buffer
)->name
), "*scratch*") == 0)
1536 function
= find_symbol_value (intern ("initial-major-mode"));
1539 function
= buffer_defaults
.major_mode
;
1541 && NILP (Fget (current_buffer
->major_mode
, Qmode_class
)))
1542 function
= current_buffer
->major_mode
;
1545 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1548 count
= SPECPDL_INDEX ();
1550 /* To select a nonfundamental mode,
1551 select the buffer temporarily and then call the mode function. */
1553 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1555 Fset_buffer (buffer
);
1558 return unbind_to (count
, Qnil
);
1561 /* If switching buffers in WINDOW would be an error, return
1562 a C string saying what the error would be. */
1565 no_switch_window (window
)
1569 if (EQ (minibuf_window
, window
))
1570 return "Cannot switch buffers in minibuffer window";
1571 tem
= Fwindow_dedicated_p (window
);
1573 return "Cannot switch buffers in a dedicated window";
1577 /* Switch to buffer BUFFER in the selected window.
1578 If NORECORD is non-nil, don't call record_buffer. */
1581 switch_to_buffer_1 (buffer
, norecord
)
1582 Lisp_Object buffer
, norecord
;
1584 register Lisp_Object buf
;
1587 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1590 buf
= Fget_buffer (buffer
);
1593 buf
= Fget_buffer_create (buffer
);
1594 Fset_buffer_major_mode (buf
);
1598 if (NILP (norecord
))
1599 record_buffer (buf
);
1601 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
1602 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
1609 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2, "BSwitch to buffer: ",
1610 doc
: /* Select buffer BUFFER in the current window.
1611 BUFFER may be a buffer or a buffer name.
1612 Optional second arg NORECORD non-nil means
1613 do not put this buffer at the front of the list of recently selected ones.
1615 WARNING: This is NOT the way to work on another buffer temporarily
1616 within a Lisp program! Use `set-buffer' instead. That avoids messing with
1617 the window-buffer correspondences. */)
1619 Lisp_Object buffer
, norecord
;
1623 err
= no_switch_window (selected_window
);
1624 if (err
) error (err
);
1626 return switch_to_buffer_1 (buffer
, norecord
);
1629 DEFUN ("pop-to-buffer", Fpop_to_buffer
, Spop_to_buffer
, 1, 3, 0,
1630 doc
: /* Select buffer BUFFER in some window, preferably a different one.
1631 If BUFFER is nil, then some other buffer is chosen.
1632 If `pop-up-windows' is non-nil, windows can be split to do this.
1633 If optional second arg OTHER-WINDOW is non-nil, insist on finding another
1634 window even if BUFFER is already visible in the selected window.
1635 This uses the function `display-buffer' as a subroutine; see the documentation
1636 of `display-buffer' for additional customization information.
1638 Optional third arg NORECORD non-nil means
1639 do not put this buffer at the front of the list of recently selected ones. */)
1640 (buffer
, other_window
, norecord
)
1641 Lisp_Object buffer
, other_window
, norecord
;
1643 register Lisp_Object buf
;
1645 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1648 buf
= Fget_buffer (buffer
);
1651 buf
= Fget_buffer_create (buffer
);
1652 Fset_buffer_major_mode (buf
);
1656 if (NILP (norecord
))
1657 /* This seems bogus since Fselect_window will call record_buffer anyway. */
1658 record_buffer (buf
);
1659 Fselect_window (Fdisplay_buffer (buf
, other_window
, Qnil
));
1663 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1664 doc
: /* Return the current buffer as a Lisp object. */)
1667 register Lisp_Object buf
;
1668 XSETBUFFER (buf
, current_buffer
);
1672 /* Set the current buffer to B.
1674 We previously set windows_or_buffers_changed here to invalidate
1675 global unchanged information in beg_unchanged and end_unchanged.
1676 This is no longer necessary because we now compute unchanged
1677 information on a buffer-basis. Every action affecting other
1678 windows than the selected one requires a select_window at some
1679 time, and that increments windows_or_buffers_changed. */
1682 set_buffer_internal (b
)
1683 register struct buffer
*b
;
1685 if (current_buffer
!= b
)
1686 set_buffer_internal_1 (b
);
1689 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1690 This is used by redisplay. */
1693 set_buffer_internal_1 (b
)
1694 register struct buffer
*b
;
1696 register struct buffer
*old_buf
;
1697 register Lisp_Object tail
, valcontents
;
1700 #ifdef USE_MMAP_FOR_BUFFERS
1701 if (b
->text
->beg
== NULL
)
1702 enlarge_buffer_text (b
, 0);
1703 #endif /* USE_MMAP_FOR_BUFFERS */
1705 if (current_buffer
== b
)
1708 old_buf
= current_buffer
;
1710 last_known_column_point
= -1; /* invalidate indentation cache */
1714 /* Put the undo list back in the base buffer, so that it appears
1715 that an indirect buffer shares the undo list of its base. */
1716 if (old_buf
->base_buffer
)
1717 old_buf
->base_buffer
->undo_list
= old_buf
->undo_list
;
1719 /* If the old current buffer has markers to record PT, BEGV and ZV
1720 when it is not current, update them now. */
1721 if (! NILP (old_buf
->pt_marker
))
1724 XSETBUFFER (obuf
, old_buf
);
1725 set_marker_both (old_buf
->pt_marker
, obuf
,
1726 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1728 if (! NILP (old_buf
->begv_marker
))
1731 XSETBUFFER (obuf
, old_buf
);
1732 set_marker_both (old_buf
->begv_marker
, obuf
,
1733 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1735 if (! NILP (old_buf
->zv_marker
))
1738 XSETBUFFER (obuf
, old_buf
);
1739 set_marker_both (old_buf
->zv_marker
, obuf
,
1740 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1744 /* Get the undo list from the base buffer, so that it appears
1745 that an indirect buffer shares the undo list of its base. */
1747 b
->undo_list
= b
->base_buffer
->undo_list
;
1749 /* If the new current buffer has markers to record PT, BEGV and ZV
1750 when it is not current, fetch them now. */
1751 if (! NILP (b
->pt_marker
))
1753 BUF_PT (b
) = marker_position (b
->pt_marker
);
1754 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1756 if (! NILP (b
->begv_marker
))
1758 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1759 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1761 if (! NILP (b
->zv_marker
))
1763 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1764 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1767 /* Look down buffer's list of local Lisp variables
1768 to find and update any that forward into C variables. */
1770 for (tail
= b
->local_var_alist
; !NILP (tail
); tail
= XCDR (tail
))
1772 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1773 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1774 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1775 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1776 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1777 /* Just reference the variable
1778 to cause it to become set for this buffer. */
1779 Fsymbol_value (XCAR (XCAR (tail
)));
1782 /* Do the same with any others that were local to the previous buffer */
1785 for (tail
= old_buf
->local_var_alist
; !NILP (tail
); tail
= XCDR (tail
))
1787 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1788 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1789 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1790 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1791 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1792 /* Just reference the variable
1793 to cause it to become set for this buffer. */
1794 Fsymbol_value (XCAR (XCAR (tail
)));
1798 /* Switch to buffer B temporarily for redisplay purposes.
1799 This avoids certain things that don't need to be done within redisplay. */
1805 register struct buffer
*old_buf
;
1807 if (current_buffer
== b
)
1810 old_buf
= current_buffer
;
1815 /* If the old current buffer has markers to record PT, BEGV and ZV
1816 when it is not current, update them now. */
1817 if (! NILP (old_buf
->pt_marker
))
1820 XSETBUFFER (obuf
, old_buf
);
1821 set_marker_both (old_buf
->pt_marker
, obuf
,
1822 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1824 if (! NILP (old_buf
->begv_marker
))
1827 XSETBUFFER (obuf
, old_buf
);
1828 set_marker_both (old_buf
->begv_marker
, obuf
,
1829 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1831 if (! NILP (old_buf
->zv_marker
))
1834 XSETBUFFER (obuf
, old_buf
);
1835 set_marker_both (old_buf
->zv_marker
, obuf
,
1836 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1840 /* If the new current buffer has markers to record PT, BEGV and ZV
1841 when it is not current, fetch them now. */
1842 if (! NILP (b
->pt_marker
))
1844 BUF_PT (b
) = marker_position (b
->pt_marker
);
1845 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1847 if (! NILP (b
->begv_marker
))
1849 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1850 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1852 if (! NILP (b
->zv_marker
))
1854 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1855 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1859 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
1860 doc
: /* Make the buffer BUFFER current for editing operations.
1861 BUFFER may be a buffer or the name of an existing buffer.
1862 See also `save-excursion' when you want to make a buffer current temporarily.
1863 This function does not display the buffer, so its effect ends
1864 when the current command terminates.
1865 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently. */)
1867 register Lisp_Object buffer
;
1869 register Lisp_Object buf
;
1870 buf
= Fget_buffer (buffer
);
1873 if (NILP (XBUFFER (buf
)->name
))
1874 error ("Selecting deleted buffer");
1875 set_buffer_internal (XBUFFER (buf
));
1879 /* Set the current buffer to BUFFER provided it is alive. */
1882 set_buffer_if_live (buffer
)
1885 if (! NILP (XBUFFER (buffer
)->name
))
1886 Fset_buffer (buffer
);
1890 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
1891 Sbarf_if_buffer_read_only
, 0, 0, 0,
1892 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
1895 if (!NILP (current_buffer
->read_only
)
1896 && NILP (Vinhibit_read_only
))
1897 Fsignal (Qbuffer_read_only
, (Fcons (Fcurrent_buffer (), Qnil
)));
1901 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
1902 doc
: /* Put BUFFER at the end of the list of all buffers.
1903 There it is the least likely candidate for `other-buffer' to return;
1904 thus, the least likely buffer for \\[switch-to-buffer] to select by default.
1905 If BUFFER is nil or omitted, bury the current buffer.
1906 Also, if BUFFER is nil or omitted, remove the current buffer from the
1907 selected window if it is displayed there. */)
1909 register Lisp_Object buffer
;
1911 /* Figure out what buffer we're going to bury. */
1915 XSETBUFFER (buffer
, current_buffer
);
1917 tem
= Fwindow_buffer (selected_window
);
1918 /* If we're burying the current buffer, unshow it. */
1919 if (EQ (buffer
, tem
))
1921 if (NILP (Fwindow_dedicated_p (selected_window
)))
1922 Fswitch_to_buffer (Fother_buffer (buffer
, Qnil
, Qnil
), Qnil
);
1923 else if (NILP (XWINDOW (selected_window
)->parent
))
1924 Ficonify_frame (Fwindow_frame (selected_window
));
1926 Fdelete_window (selected_window
);
1933 buf1
= Fget_buffer (buffer
);
1939 /* Move buffer to the end of the buffer list. Do nothing if the
1940 buffer is killed. */
1941 if (!NILP (XBUFFER (buffer
)->name
))
1943 Lisp_Object aelt
, link
;
1945 aelt
= Frassq (buffer
, Vbuffer_alist
);
1946 link
= Fmemq (aelt
, Vbuffer_alist
);
1947 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1948 XSETCDR (link
, Qnil
);
1949 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
1951 /* Removing BUFFER from frame-specific lists
1952 has the effect of putting BUFFER at the end
1953 of the combined list in each frame. */
1954 frames_discard_buffer (buffer
);
1960 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
1961 doc
: /* Delete the entire contents of the current buffer.
1962 Any narrowing restriction in effect (see `narrow-to-region') is removed,
1963 so the buffer is truly empty after this. */)
1970 current_buffer
->last_window_start
= 1;
1971 /* Prevent warnings, or suspension of auto saving, that would happen
1972 if future size is less than past size. Use of erase-buffer
1973 implies that the future text is not really related to the past text. */
1974 XSETFASTINT (current_buffer
->save_length
, 0);
1979 validate_region (b
, e
)
1980 register Lisp_Object
*b
, *e
;
1982 CHECK_NUMBER_COERCE_MARKER (*b
);
1983 CHECK_NUMBER_COERCE_MARKER (*e
);
1985 if (XINT (*b
) > XINT (*e
))
1988 tem
= *b
; *b
= *e
; *e
= tem
;
1991 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
1992 && XINT (*e
) <= ZV
))
1993 args_out_of_range (*b
, *e
);
1996 /* Advance BYTE_POS up to a character boundary
1997 and return the adjusted position. */
2000 advance_to_char_boundary (byte_pos
)
2005 if (byte_pos
== BEG
)
2006 /* Beginning of buffer is always a character boundary. */
2009 c
= FETCH_BYTE (byte_pos
);
2010 if (! CHAR_HEAD_P (c
))
2012 /* We should advance BYTE_POS only when C is a constituent of a
2013 multibyte sequence. */
2014 int orig_byte_pos
= byte_pos
;
2019 c
= FETCH_BYTE (byte_pos
);
2021 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2023 if (byte_pos
< orig_byte_pos
)
2024 byte_pos
= orig_byte_pos
;
2025 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2026 surely advance to the correct character boundary. If C is
2027 not, BYTE_POS was unchanged. */
2033 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2035 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2036 If FLAG is t, this makes the buffer a multibyte buffer.
2037 If FLAG is nil, this makes the buffer a single-byte buffer.
2038 The buffer contents remain unchanged as a sequence of bytes
2039 but the contents viewed as characters do change. */)
2043 Lisp_Object tail
, markers
;
2044 struct buffer
*other
;
2045 int undo_enabled_p
= !EQ (current_buffer
->undo_list
, Qt
);
2046 int begv
= BEGV
, zv
= ZV
;
2047 int narrowed
= (BEG
!= begv
|| Z
!= zv
);
2048 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2050 if (current_buffer
->base_buffer
)
2051 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2053 /* Do nothing if nothing actually changes. */
2054 if (NILP (flag
) == NILP (current_buffer
->enable_multibyte_characters
))
2057 /* It would be better to update the list,
2058 but this is good enough for now. */
2060 current_buffer
->undo_list
= Qt
;
2062 /* If the cached position is for this buffer, clear it out. */
2063 clear_charpos_cache (current_buffer
);
2073 /* Do this first, so it can use CHAR_TO_BYTE
2074 to calculate the old correspondences. */
2075 set_intervals_multibyte (0);
2077 current_buffer
->enable_multibyte_characters
= Qnil
;
2083 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2085 tail
= BUF_MARKERS (current_buffer
);
2086 while (! NILP (tail
))
2088 XMARKER (tail
)->charpos
= XMARKER (tail
)->bytepos
;
2089 tail
= XMARKER (tail
)->chain
;
2092 /* Convert multibyte form of 8-bit characters to unibyte. */
2107 if (MULTIBYTE_STR_AS_UNIBYTE_P (p
, bytes
))
2108 p
+= bytes
, pos
+= bytes
;
2111 c
= STRING_CHAR (p
, stop
- pos
);
2112 /* Delete all bytes for this 8-bit character but the
2113 last one, and change the last one to the charcter
2116 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2128 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2136 /* Be sure not to have a multibyte sequence striding over the GAP.
2137 Ex: We change this: "...abc\201 _GAP_ \241def..."
2138 to: "...abc _GAP_ \201\241def..." */
2140 if (GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2141 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2143 unsigned char *p
= GPT_ADDR
- 1;
2145 while (! CHAR_HEAD_P (*p
) && p
> BEG_ADDR
) p
--;
2146 if (BASE_LEADING_CODE_P (*p
))
2148 int new_gpt
= GPT_BYTE
- (GPT_ADDR
- p
);
2150 move_gap_both (new_gpt
, new_gpt
);
2154 /* Make the buffer contents valid as multibyte by converting
2155 8-bit characters to multibyte form. */
2171 if (UNIBYTE_STR_AS_MULTIBYTE_P (p
, stop
- pos
, bytes
))
2172 p
+= bytes
, pos
+= bytes
;
2175 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2177 bytes
= CHAR_STRING (*p
, tmp
);
2179 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2181 insert_1_both (tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2182 /* Now the gap is after the just inserted data. */
2199 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2201 /* Do this first, so that chars_in_text asks the right question.
2202 set_intervals_multibyte needs it too. */
2203 current_buffer
->enable_multibyte_characters
= Qt
;
2205 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2206 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2208 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2210 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2211 if (BEGV_BYTE
> GPT_BYTE
)
2212 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2214 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2216 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2217 if (ZV_BYTE
> GPT_BYTE
)
2218 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2220 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2223 int pt_byte
= advance_to_char_boundary (PT_BYTE
);
2226 if (pt_byte
> GPT_BYTE
)
2227 pt
= chars_in_text (GAP_END_ADDR
, pt_byte
- GPT_BYTE
) + GPT
;
2229 pt
= chars_in_text (BEG_ADDR
, pt_byte
- BEG_BYTE
) + BEG
;
2230 TEMP_SET_PT_BOTH (pt
, pt_byte
);
2233 tail
= markers
= BUF_MARKERS (current_buffer
);
2235 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2236 getting confused by the markers that have not yet been updated.
2237 It is also a signal that it should never create a marker. */
2238 BUF_MARKERS (current_buffer
) = Qnil
;
2240 while (! NILP (tail
))
2242 XMARKER (tail
)->bytepos
2243 = advance_to_char_boundary (XMARKER (tail
)->bytepos
);
2244 XMARKER (tail
)->charpos
= BYTE_TO_CHAR (XMARKER (tail
)->bytepos
);
2246 tail
= XMARKER (tail
)->chain
;
2249 /* Make sure no markers were put on the chain
2250 while the chain value was incorrect. */
2251 if (! EQ (BUF_MARKERS (current_buffer
), Qnil
))
2254 BUF_MARKERS (current_buffer
) = markers
;
2256 /* Do this last, so it can calculate the new correspondences
2257 between chars and bytes. */
2258 set_intervals_multibyte (1);
2262 current_buffer
->undo_list
= Qnil
;
2264 /* Changing the multibyteness of a buffer means that all windows
2265 showing that buffer must be updated thoroughly. */
2266 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2267 ++windows_or_buffers_changed
;
2269 /* Copy this buffer's new multibyte status
2270 into all of its indirect buffers. */
2271 for (other
= all_buffers
; other
; other
= other
->next
)
2272 if (other
->base_buffer
== current_buffer
&& !NILP (other
->name
))
2274 other
->enable_multibyte_characters
2275 = current_buffer
->enable_multibyte_characters
;
2276 other
->prevent_redisplay_optimizations_p
= 1;
2279 /* Restore the modifiedness of the buffer. */
2280 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2281 Fset_buffer_modified_p (Qnil
);
2286 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
2288 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2289 Most local variable bindings are eliminated so that the default values
2290 become effective once more. Also, the syntax table is set from
2291 `standard-syntax-table', the local keymap is set to nil,
2292 and the abbrev table from `fundamental-mode-abbrev-table'.
2293 This function also forces redisplay of the mode line.
2295 Every function to select a new major mode starts by
2296 calling this function.
2298 As a special exception, local variables whose names have
2299 a non-nil `permanent-local' property are not eliminated by this function.
2301 The first thing this function does is run
2302 the normal hook `change-major-mode-hook'. */)
2305 register Lisp_Object alist
, sym
, tem
;
2308 if (!NILP (Vrun_hooks
))
2309 call1 (Vrun_hooks
, intern ("change-major-mode-hook"));
2310 oalist
= current_buffer
->local_var_alist
;
2312 /* Make sure none of the bindings in oalist
2313 remain swapped in, in their symbols. */
2315 swap_out_buffer_local_variables (current_buffer
);
2317 /* Actually eliminate all local bindings of this buffer. */
2319 reset_buffer_local_variables (current_buffer
, 0);
2321 /* Any which are supposed to be permanent,
2322 make local again, with the same values they had. */
2324 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2326 sym
= XCAR (XCAR (alist
));
2327 tem
= Fget (sym
, Qpermanent_local
);
2330 Fmake_local_variable (sym
);
2331 Fset (sym
, XCDR (XCAR (alist
)));
2335 /* Force mode-line redisplay. Useful here because all major mode
2336 commands call this function. */
2337 update_mode_lines
++;
2342 /* Make sure no local variables remain set up with buffer B
2343 for their current values. */
2346 swap_out_buffer_local_variables (b
)
2349 Lisp_Object oalist
, alist
, sym
, tem
, buffer
;
2351 XSETBUFFER (buffer
, b
);
2352 oalist
= b
->local_var_alist
;
2354 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2356 sym
= XCAR (XCAR (alist
));
2358 /* Need not do anything if some other buffer's binding is now encached. */
2359 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
;
2360 if (BUFFERP (tem
) && XBUFFER (tem
) == current_buffer
)
2362 /* Symbol is set up for this buffer's old local value.
2363 Set it up for the current buffer with the default value. */
2365 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->cdr
;
2366 /* Store the symbol's current value into the alist entry
2367 it is currently set up for. This is so that, if the
2368 local is marked permanent, and we make it local again
2369 later in Fkill_all_local_variables, we don't lose the value. */
2370 XSETCDR (XCAR (tem
),
2371 do_symval_forwarding (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->realvalue
));
2372 /* Switch to the symbol's default-value alist entry. */
2374 /* Mark it as current for buffer B. */
2375 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
= buffer
;
2376 /* Store the current value into any forwarding in the symbol. */
2377 store_symval_forwarding (sym
,
2378 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->realvalue
,
2384 /* Find all the overlays in the current buffer that contain position POS.
2385 Return the number found, and store them in a vector in *VEC_PTR.
2386 Store in *LEN_PTR the size allocated for the vector.
2387 Store in *NEXT_PTR the next position after POS where an overlay starts,
2388 or ZV if there are no more overlays.
2389 Store in *PREV_PTR the previous position before POS where an overlay ends,
2390 or where an overlay starts which ends at or after POS;
2391 or BEGV if there are no such overlays.
2392 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2394 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2395 when this function is called.
2397 If EXTEND is non-zero, we make the vector bigger if necessary.
2398 If EXTEND is zero, we never extend the vector,
2399 and we store only as many overlays as will fit.
2400 But we still return the total number of overlays.
2402 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2403 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2404 default (BEGV or ZV). */
2407 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
, change_req
)
2410 Lisp_Object
**vec_ptr
;
2416 Lisp_Object tail
, overlay
, start
, end
;
2419 Lisp_Object
*vec
= *vec_ptr
;
2422 int inhibit_storing
= 0;
2424 for (tail
= current_buffer
->overlays_before
;
2428 int startpos
, endpos
;
2430 overlay
= XCAR (tail
);
2432 start
= OVERLAY_START (overlay
);
2433 end
= OVERLAY_END (overlay
);
2434 endpos
= OVERLAY_POSITION (end
);
2441 startpos
= OVERLAY_POSITION (start
);
2442 /* This one ends at or after POS
2443 so its start counts for PREV_PTR if it's before POS. */
2444 if (prev
< startpos
&& startpos
< pos
)
2448 if (startpos
<= pos
)
2452 /* The supplied vector is full.
2453 Either make it bigger, or don't store any more in it. */
2456 /* Make it work with an initial len == 0. */
2461 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2465 inhibit_storing
= 1;
2468 if (!inhibit_storing
)
2470 /* Keep counting overlays even if we can't return them all. */
2473 else if (startpos
< next
)
2477 for (tail
= current_buffer
->overlays_after
;
2481 int startpos
, endpos
;
2483 overlay
= XCAR (tail
);
2485 start
= OVERLAY_START (overlay
);
2486 end
= OVERLAY_END (overlay
);
2487 startpos
= OVERLAY_POSITION (start
);
2490 if (startpos
< next
)
2494 endpos
= OVERLAY_POSITION (end
);
2501 *len_ptr
= len
*= 2;
2504 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2508 inhibit_storing
= 1;
2511 if (!inhibit_storing
)
2515 if (startpos
< pos
&& startpos
> prev
)
2518 else if (endpos
< pos
&& endpos
> prev
)
2520 else if (endpos
== pos
&& startpos
> prev
2521 && (!change_req
|| startpos
< pos
))
2532 /* Find all the overlays in the current buffer that overlap the range BEG-END
2533 or are empty at BEG.
2535 Return the number found, and store them in a vector in *VEC_PTR.
2536 Store in *LEN_PTR the size allocated for the vector.
2537 Store in *NEXT_PTR the next position after POS where an overlay starts,
2538 or ZV if there are no more overlays.
2539 Store in *PREV_PTR the previous position before POS where an overlay ends,
2540 or BEGV if there are no previous overlays.
2541 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2543 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2544 when this function is called.
2546 If EXTEND is non-zero, we make the vector bigger if necessary.
2547 If EXTEND is zero, we never extend the vector,
2548 and we store only as many overlays as will fit.
2549 But we still return the total number of overlays. */
2552 overlays_in (beg
, end
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
2555 Lisp_Object
**vec_ptr
;
2560 Lisp_Object tail
, overlay
, ostart
, oend
;
2563 Lisp_Object
*vec
= *vec_ptr
;
2566 int inhibit_storing
= 0;
2568 for (tail
= current_buffer
->overlays_before
;
2572 int startpos
, endpos
;
2574 overlay
= XCAR (tail
);
2576 ostart
= OVERLAY_START (overlay
);
2577 oend
= OVERLAY_END (overlay
);
2578 endpos
= OVERLAY_POSITION (oend
);
2585 startpos
= OVERLAY_POSITION (ostart
);
2586 /* Count an interval if it either overlaps the range
2587 or is empty at the start of the range. */
2588 if ((beg
< endpos
&& startpos
< end
)
2589 || (startpos
== endpos
&& beg
== endpos
))
2593 /* The supplied vector is full.
2594 Either make it bigger, or don't store any more in it. */
2597 *len_ptr
= len
*= 2;
2598 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2602 inhibit_storing
= 1;
2605 if (!inhibit_storing
)
2607 /* Keep counting overlays even if we can't return them all. */
2610 else if (startpos
< next
)
2614 for (tail
= current_buffer
->overlays_after
;
2618 int startpos
, endpos
;
2620 overlay
= XCAR (tail
);
2622 ostart
= OVERLAY_START (overlay
);
2623 oend
= OVERLAY_END (overlay
);
2624 startpos
= OVERLAY_POSITION (ostart
);
2627 if (startpos
< next
)
2631 endpos
= OVERLAY_POSITION (oend
);
2632 /* Count an interval if it either overlaps the range
2633 or is empty at the start of the range. */
2634 if ((beg
< endpos
&& startpos
< end
)
2635 || (startpos
== endpos
&& beg
== endpos
))
2641 *len_ptr
= len
*= 2;
2642 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2646 inhibit_storing
= 1;
2649 if (!inhibit_storing
)
2653 else if (endpos
< beg
&& endpos
> prev
)
2665 /* Return non-zero if there exists an overlay with a non-nil
2666 `mouse-face' property overlapping OVERLAY. */
2669 mouse_face_overlay_overlaps (overlay
)
2670 Lisp_Object overlay
;
2672 int start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2673 int end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2675 Lisp_Object
*v
, tem
;
2678 v
= (Lisp_Object
*) alloca (size
* sizeof *v
);
2679 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
2682 v
= (Lisp_Object
*) alloca (n
* sizeof *v
);
2683 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
2686 for (i
= 0; i
< n
; ++i
)
2687 if (!EQ (v
[i
], overlay
)
2688 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
2697 /* Fast function to just test if we're at an overlay boundary. */
2699 overlay_touches_p (pos
)
2702 Lisp_Object tail
, overlay
;
2704 for (tail
= current_buffer
->overlays_before
; GC_CONSP (tail
);
2709 overlay
= XCAR (tail
);
2710 if (!GC_OVERLAYP (overlay
))
2713 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2716 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
2720 for (tail
= current_buffer
->overlays_after
; GC_CONSP (tail
);
2725 overlay
= XCAR (tail
);
2726 if (!GC_OVERLAYP (overlay
))
2729 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2732 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
2740 Lisp_Object overlay
;
2746 compare_overlays (v1
, v2
)
2747 const void *v1
, *v2
;
2749 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
2750 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
2751 if (s1
->priority
!= s2
->priority
)
2752 return s1
->priority
- s2
->priority
;
2753 if (s1
->beg
!= s2
->beg
)
2754 return s1
->beg
- s2
->beg
;
2755 if (s1
->end
!= s2
->end
)
2756 return s2
->end
- s1
->end
;
2760 /* Sort an array of overlays by priority. The array is modified in place.
2761 The return value is the new size; this may be smaller than the original
2762 size if some of the overlays were invalid or were window-specific. */
2764 sort_overlays (overlay_vec
, noverlays
, w
)
2765 Lisp_Object
*overlay_vec
;
2770 struct sortvec
*sortvec
;
2771 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
2773 /* Put the valid and relevant overlays into sortvec. */
2775 for (i
= 0, j
= 0; i
< noverlays
; i
++)
2778 Lisp_Object overlay
;
2780 overlay
= overlay_vec
[i
];
2781 if (OVERLAY_VALID (overlay
)
2782 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
2783 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
2785 /* If we're interested in a specific window, then ignore
2786 overlays that are limited to some other window. */
2791 window
= Foverlay_get (overlay
, Qwindow
);
2792 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2796 /* This overlay is good and counts: put it into sortvec. */
2797 sortvec
[j
].overlay
= overlay
;
2798 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2799 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2800 tem
= Foverlay_get (overlay
, Qpriority
);
2802 sortvec
[j
].priority
= XINT (tem
);
2804 sortvec
[j
].priority
= 0;
2810 /* Sort the overlays into the proper order: increasing priority. */
2813 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
2815 for (i
= 0; i
< noverlays
; i
++)
2816 overlay_vec
[i
] = sortvec
[i
].overlay
;
2822 Lisp_Object string
, string2
;
2829 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
2830 int size
; /* Allocated length of that array. */
2831 int used
; /* How much of the array is currently in use. */
2832 int bytes
; /* Total length of the strings in buf. */
2835 /* Buffers for storing information about the overlays touching a given
2836 position. These could be automatic variables in overlay_strings, but
2837 it's more efficient to hold onto the memory instead of repeatedly
2838 allocating and freeing it. */
2839 static struct sortstrlist overlay_heads
, overlay_tails
;
2840 static unsigned char *overlay_str_buf
;
2842 /* Allocated length of overlay_str_buf. */
2843 static int overlay_str_len
;
2845 /* A comparison function suitable for passing to qsort. */
2847 cmp_for_strings (as1
, as2
)
2850 struct sortstr
*s1
= (struct sortstr
*)as1
;
2851 struct sortstr
*s2
= (struct sortstr
*)as2
;
2852 if (s1
->size
!= s2
->size
)
2853 return s2
->size
- s1
->size
;
2854 if (s1
->priority
!= s2
->priority
)
2855 return s1
->priority
- s2
->priority
;
2860 record_overlay_string (ssl
, str
, str2
, pri
, size
)
2861 struct sortstrlist
*ssl
;
2862 Lisp_Object str
, str2
, pri
;
2867 if (ssl
->used
== ssl
->size
)
2873 ssl
->buf
= ((struct sortstr
*)
2874 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
2876 ssl
->buf
[ssl
->used
].string
= str
;
2877 ssl
->buf
[ssl
->used
].string2
= str2
;
2878 ssl
->buf
[ssl
->used
].size
= size
;
2879 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
2882 if (NILP (current_buffer
->enable_multibyte_characters
))
2883 nbytes
= SCHARS (str
);
2884 else if (! STRING_MULTIBYTE (str
))
2885 nbytes
= count_size_as_multibyte (SDATA (str
),
2888 nbytes
= SBYTES (str
);
2890 ssl
->bytes
+= nbytes
;
2894 if (NILP (current_buffer
->enable_multibyte_characters
))
2895 nbytes
= SCHARS (str2
);
2896 else if (! STRING_MULTIBYTE (str2
))
2897 nbytes
= count_size_as_multibyte (SDATA (str2
),
2900 nbytes
= SBYTES (str2
);
2902 ssl
->bytes
+= nbytes
;
2906 /* Return the concatenation of the strings associated with overlays that
2907 begin or end at POS, ignoring overlays that are specific to a window
2908 other than W. The strings are concatenated in the appropriate order:
2909 shorter overlays nest inside longer ones, and higher priority inside
2910 lower. Normally all of the after-strings come first, but zero-sized
2911 overlays have their after-strings ride along with the before-strings
2912 because it would look strange to print them inside-out.
2914 Returns the string length, and stores the contents indirectly through
2915 PSTR, if that variable is non-null. The string may be overwritten by
2916 subsequent calls. */
2919 overlay_strings (pos
, w
, pstr
)
2922 unsigned char **pstr
;
2924 Lisp_Object ov
, overlay
, window
, str
;
2925 int startpos
, endpos
;
2926 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
2928 overlay_heads
.used
= overlay_heads
.bytes
= 0;
2929 overlay_tails
.used
= overlay_tails
.bytes
= 0;
2930 for (ov
= current_buffer
->overlays_before
; CONSP (ov
); ov
= XCDR (ov
))
2932 overlay
= XCAR (ov
);
2933 if (!OVERLAYP (overlay
))
2936 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2937 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2940 if (endpos
!= pos
&& startpos
!= pos
)
2942 window
= Foverlay_get (overlay
, Qwindow
);
2943 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2946 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
2947 record_overlay_string (&overlay_heads
, str
,
2949 ? Foverlay_get (overlay
, Qafter_string
)
2951 Foverlay_get (overlay
, Qpriority
),
2953 else if (endpos
== pos
2954 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
2955 record_overlay_string (&overlay_tails
, str
, Qnil
,
2956 Foverlay_get (overlay
, Qpriority
),
2959 for (ov
= current_buffer
->overlays_after
; CONSP (ov
); ov
= XCDR (ov
))
2961 overlay
= XCAR (ov
);
2962 if (!OVERLAYP (overlay
))
2965 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2966 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2969 if (endpos
!= pos
&& startpos
!= pos
)
2971 window
= Foverlay_get (overlay
, Qwindow
);
2972 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2975 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
2976 record_overlay_string (&overlay_heads
, str
,
2978 ? Foverlay_get (overlay
, Qafter_string
)
2980 Foverlay_get (overlay
, Qpriority
),
2982 else if (endpos
== pos
2983 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
2984 record_overlay_string (&overlay_tails
, str
, Qnil
,
2985 Foverlay_get (overlay
, Qpriority
),
2988 if (overlay_tails
.used
> 1)
2989 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
2991 if (overlay_heads
.used
> 1)
2992 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
2994 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
2999 int total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
3001 if (total
> overlay_str_len
)
3003 overlay_str_len
= total
;
3004 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
3007 p
= overlay_str_buf
;
3008 for (i
= overlay_tails
.used
; --i
>= 0;)
3011 tem
= overlay_tails
.buf
[i
].string
;
3012 nbytes
= copy_text (SDATA (tem
), p
,
3014 STRING_MULTIBYTE (tem
), multibyte
);
3017 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3020 tem
= overlay_heads
.buf
[i
].string
;
3021 nbytes
= copy_text (SDATA (tem
), p
,
3023 STRING_MULTIBYTE (tem
), multibyte
);
3025 tem
= overlay_heads
.buf
[i
].string2
;
3028 nbytes
= copy_text (SDATA (tem
), p
,
3030 STRING_MULTIBYTE (tem
), multibyte
);
3034 if (p
!= overlay_str_buf
+ total
)
3037 *pstr
= overlay_str_buf
;
3043 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3046 recenter_overlay_lists (buf
, pos
)
3050 Lisp_Object overlay
, tail
, next
, prev
, beg
, end
;
3052 /* See if anything in overlays_before should move to overlays_after. */
3054 /* We don't strictly need prev in this loop; it should always be nil.
3055 But we use it for symmetry and in case that should cease to be true
3056 with some future change. */
3058 for (tail
= buf
->overlays_before
;
3060 prev
= tail
, tail
= next
)
3063 overlay
= XCAR (tail
);
3065 /* If the overlay is not valid, get rid of it. */
3066 if (!OVERLAY_VALID (overlay
))
3071 /* Splice the cons cell TAIL out of overlays_before. */
3075 buf
->overlays_before
= next
;
3081 beg
= OVERLAY_START (overlay
);
3082 end
= OVERLAY_END (overlay
);
3084 if (OVERLAY_POSITION (end
) > pos
)
3086 /* OVERLAY needs to be moved. */
3087 int where
= OVERLAY_POSITION (beg
);
3088 Lisp_Object other
, other_prev
;
3090 /* Splice the cons cell TAIL out of overlays_before. */
3092 XSETCDR (prev
, next
);
3094 buf
->overlays_before
= next
;
3096 /* Search thru overlays_after for where to put it. */
3098 for (other
= buf
->overlays_after
;
3100 other_prev
= other
, other
= XCDR (other
))
3102 Lisp_Object otherbeg
, otheroverlay
;
3104 otheroverlay
= XCAR (other
);
3105 if (! OVERLAY_VALID (otheroverlay
))
3108 otherbeg
= OVERLAY_START (otheroverlay
);
3109 if (OVERLAY_POSITION (otherbeg
) >= where
)
3113 /* Add TAIL to overlays_after before OTHER. */
3114 XSETCDR (tail
, other
);
3115 if (!NILP (other_prev
))
3116 XSETCDR (other_prev
, tail
);
3118 buf
->overlays_after
= tail
;
3122 /* We've reached the things that should stay in overlays_before.
3123 All the rest of overlays_before must end even earlier,
3128 /* See if anything in overlays_after should be in overlays_before. */
3130 for (tail
= buf
->overlays_after
;
3132 prev
= tail
, tail
= next
)
3135 overlay
= XCAR (tail
);
3137 /* If the overlay is not valid, get rid of it. */
3138 if (!OVERLAY_VALID (overlay
))
3143 /* Splice the cons cell TAIL out of overlays_after. */
3147 buf
->overlays_after
= next
;
3153 beg
= OVERLAY_START (overlay
);
3154 end
= OVERLAY_END (overlay
);
3156 /* Stop looking, when we know that nothing further
3157 can possibly end before POS. */
3158 if (OVERLAY_POSITION (beg
) > pos
)
3161 if (OVERLAY_POSITION (end
) <= pos
)
3163 /* OVERLAY needs to be moved. */
3164 int where
= OVERLAY_POSITION (end
);
3165 Lisp_Object other
, other_prev
;
3167 /* Splice the cons cell TAIL out of overlays_after. */
3169 XSETCDR (prev
, next
);
3171 buf
->overlays_after
= next
;
3173 /* Search thru overlays_before for where to put it. */
3175 for (other
= buf
->overlays_before
;
3177 other_prev
= other
, other
= XCDR (other
))
3179 Lisp_Object otherend
, otheroverlay
;
3181 otheroverlay
= XCAR (other
);
3182 if (! OVERLAY_VALID (otheroverlay
))
3185 otherend
= OVERLAY_END (otheroverlay
);
3186 if (OVERLAY_POSITION (otherend
) <= where
)
3190 /* Add TAIL to overlays_before before OTHER. */
3191 XSETCDR (tail
, other
);
3192 if (!NILP (other_prev
))
3193 XSETCDR (other_prev
, tail
);
3195 buf
->overlays_before
= tail
;
3200 XSETFASTINT (buf
->overlay_center
, pos
);
3204 adjust_overlays_for_insert (pos
, length
)
3208 /* After an insertion, the lists are still sorted properly,
3209 but we may need to update the value of the overlay center. */
3210 if (XFASTINT (current_buffer
->overlay_center
) >= pos
)
3211 XSETFASTINT (current_buffer
->overlay_center
,
3212 XFASTINT (current_buffer
->overlay_center
) + length
);
3216 adjust_overlays_for_delete (pos
, length
)
3220 if (XFASTINT (current_buffer
->overlay_center
) < pos
)
3221 /* The deletion was to our right. No change needed; the before- and
3222 after-lists are still consistent. */
3224 else if (XFASTINT (current_buffer
->overlay_center
) > pos
+ length
)
3225 /* The deletion was to our left. We need to adjust the center value
3226 to account for the change in position, but the lists are consistent
3227 given the new value. */
3228 XSETFASTINT (current_buffer
->overlay_center
,
3229 XFASTINT (current_buffer
->overlay_center
) - length
);
3231 /* We're right in the middle. There might be things on the after-list
3232 that now belong on the before-list. Recentering will move them,
3233 and also update the center point. */
3234 recenter_overlay_lists (current_buffer
, pos
);
3237 /* Fix up overlays that were garbled as a result of permuting markers
3238 in the range START through END. Any overlay with at least one
3239 endpoint in this range will need to be unlinked from the overlay
3240 list and reinserted in its proper place.
3241 Such an overlay might even have negative size at this point.
3242 If so, we'll reverse the endpoints. Can you think of anything
3243 better to do in this situation? */
3245 fix_overlays_in_range (start
, end
)
3246 register int start
, end
;
3248 Lisp_Object overlay
;
3249 Lisp_Object before_list
, after_list
;
3250 /* These are either nil, indicating that before_list or after_list
3251 should be assigned, or the cons cell the cdr of which should be
3253 Lisp_Object beforep
= Qnil
, afterp
= Qnil
;
3254 /* 'Parent', likewise, indicates a cons cell or
3255 current_buffer->overlays_before or overlays_after, depending
3256 which loop we're in. */
3257 Lisp_Object tail
, parent
;
3258 int startpos
, endpos
;
3260 /* This algorithm shifts links around instead of consing and GCing.
3261 The loop invariant is that before_list (resp. after_list) is a
3262 well-formed list except that its last element, the CDR of beforep
3263 (resp. afterp) if beforep (afterp) isn't nil or before_list
3264 (after_list) if it is, is still uninitialized. So it's not a bug
3265 that before_list isn't initialized, although it may look
3267 for (parent
= Qnil
, tail
= current_buffer
->overlays_before
; CONSP (tail
);)
3269 overlay
= XCAR (tail
);
3270 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3273 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3275 || (startpos
>= start
&& startpos
< end
))
3277 /* If the overlay is backwards, fix that now. */
3278 if (startpos
> endpos
)
3281 Fset_marker (OVERLAY_START (overlay
), make_number (endpos
),
3283 Fset_marker (OVERLAY_END (overlay
), make_number (startpos
),
3285 tem
= startpos
; startpos
= endpos
; endpos
= tem
;
3287 /* Add it to the end of the wrong list. Later on,
3288 recenter_overlay_lists will move it to the right place. */
3289 if (endpos
< XINT (current_buffer
->overlay_center
))
3294 XSETCDR (afterp
, tail
);
3302 XSETCDR (beforep
, tail
);
3306 current_buffer
->overlays_before
= XCDR (tail
);
3308 XSETCDR (parent
, XCDR (tail
));
3312 parent
= tail
, tail
= XCDR (parent
);
3314 for (parent
= Qnil
, tail
= current_buffer
->overlays_after
; CONSP (tail
);)
3316 overlay
= XCAR (tail
);
3317 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3318 if (startpos
>= end
)
3320 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3321 if (startpos
>= start
3322 || (endpos
>= start
&& endpos
< end
))
3324 if (startpos
> endpos
)
3327 Fset_marker (OVERLAY_START (overlay
), make_number (endpos
),
3329 Fset_marker (OVERLAY_END (overlay
), make_number (startpos
),
3331 tem
= startpos
; startpos
= endpos
; endpos
= tem
;
3333 if (endpos
< XINT (current_buffer
->overlay_center
))
3338 XSETCDR (afterp
, tail
);
3346 XSETCDR (beforep
, tail
);
3350 current_buffer
->overlays_after
= XCDR (tail
);
3352 XSETCDR (parent
, XCDR (tail
));
3356 parent
= tail
, tail
= XCDR (parent
);
3359 /* Splice the constructed (wrong) lists into the buffer's lists,
3360 and let the recenter function make it sane again. */
3361 if (!NILP (beforep
))
3363 XSETCDR (beforep
, current_buffer
->overlays_before
);
3364 current_buffer
->overlays_before
= before_list
;
3366 recenter_overlay_lists (current_buffer
,
3367 XINT (current_buffer
->overlay_center
));
3371 XSETCDR (afterp
, current_buffer
->overlays_after
);
3372 current_buffer
->overlays_after
= after_list
;
3374 recenter_overlay_lists (current_buffer
,
3375 XINT (current_buffer
->overlay_center
));
3378 /* We have two types of overlay: the one whose ending marker is
3379 after-insertion-marker (this is the usual case) and the one whose
3380 ending marker is before-insertion-marker. When `overlays_before'
3381 contains overlays of the latter type and the former type in this
3382 order and both overlays end at inserting position, inserting a text
3383 increases only the ending marker of the latter type, which results
3384 in incorrect ordering of `overlays_before'.
3386 This function fixes ordering of overlays in the slot
3387 `overlays_before' of the buffer *BP. Before the insertion, `point'
3388 was at PREV, and now is at POS. */
3391 fix_overlays_before (bp
, prev
, pos
)
3395 /* If parent is nil, replace overlays_before; otherwise, XCDR(parent). */
3396 Lisp_Object tail
= bp
->overlays_before
, parent
= Qnil
;
3397 Lisp_Object right_pair
;
3400 /* After the insertion, the several overlays may be in incorrect
3401 order. The possibility is that, in the list `overlays_before',
3402 an overlay which ends at POS appears after an overlay which ends
3403 at PREV. Since POS is greater than PREV, we must fix the
3404 ordering of these overlays, by moving overlays ends at POS before
3405 the overlays ends at PREV. */
3407 /* At first, find a place where disordered overlays should be linked
3408 in. It is where an overlay which end before POS exists. (i.e. an
3409 overlay whose ending marker is after-insertion-marker if disorder
3412 && ((end
= OVERLAY_POSITION (OVERLAY_END (XCAR (tail
))))
3419 /* If we don't find such an overlay,
3420 or the found one ends before PREV,
3421 or the found one is the last one in the list,
3422 we don't have to fix anything. */
3425 || NILP (XCDR (tail
)))
3428 right_pair
= parent
;
3432 /* Now, end position of overlays in the list TAIL should be before
3433 or equal to PREV. In the loop, an overlay which ends at POS is
3434 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3435 we found an overlay which ends before PREV, the remaining
3436 overlays are in correct order. */
3437 while (!NILP (tail
))
3439 end
= OVERLAY_POSITION (OVERLAY_END (XCAR (tail
)));
3442 { /* This overlay is disordered. */
3443 Lisp_Object found
= tail
;
3445 /* Unlink the found overlay. */
3446 tail
= XCDR (found
);
3447 XSETCDR (parent
, tail
);
3448 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3449 and link it into the right place. */
3450 if (NILP (right_pair
))
3452 XSETCDR (found
, bp
->overlays_before
);
3453 bp
->overlays_before
= found
;
3457 XSETCDR (found
, XCDR (right_pair
));
3458 XSETCDR (right_pair
, found
);
3461 else if (end
== prev
)
3466 else /* No more disordered overlay. */
3471 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3472 doc
: /* Return t if OBJECT is an overlay. */)
3476 return (OVERLAYP (object
) ? Qt
: Qnil
);
3479 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3480 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3481 If omitted, BUFFER defaults to the current buffer.
3482 BEG and END may be integers or markers.
3483 The fourth arg FRONT-ADVANCE, if non-nil, makes the
3484 front delimiter advance when text is inserted there.
3485 The fifth arg REAR-ADVANCE, if non-nil, makes the
3486 rear delimiter advance when text is inserted there. */)
3487 (beg
, end
, buffer
, front_advance
, rear_advance
)
3488 Lisp_Object beg
, end
, buffer
;
3489 Lisp_Object front_advance
, rear_advance
;
3491 Lisp_Object overlay
;
3495 XSETBUFFER (buffer
, current_buffer
);
3497 CHECK_BUFFER (buffer
);
3499 && ! EQ (Fmarker_buffer (beg
), buffer
))
3500 error ("Marker points into wrong buffer");
3502 && ! EQ (Fmarker_buffer (end
), buffer
))
3503 error ("Marker points into wrong buffer");
3505 CHECK_NUMBER_COERCE_MARKER (beg
);
3506 CHECK_NUMBER_COERCE_MARKER (end
);
3508 if (XINT (beg
) > XINT (end
))
3511 temp
= beg
; beg
= end
; end
= temp
;
3514 b
= XBUFFER (buffer
);
3516 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3517 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3519 if (!NILP (front_advance
))
3520 XMARKER (beg
)->insertion_type
= 1;
3521 if (!NILP (rear_advance
))
3522 XMARKER (end
)->insertion_type
= 1;
3524 overlay
= allocate_misc ();
3525 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3526 XOVERLAY (overlay
)->start
= beg
;
3527 XOVERLAY (overlay
)->end
= end
;
3528 XOVERLAY (overlay
)->plist
= Qnil
;
3530 /* Put the new overlay on the wrong list. */
3531 end
= OVERLAY_END (overlay
);
3532 if (OVERLAY_POSITION (end
) < XINT (b
->overlay_center
))
3533 b
->overlays_after
= Fcons (overlay
, b
->overlays_after
);
3535 b
->overlays_before
= Fcons (overlay
, b
->overlays_before
);
3537 /* This puts it in the right list, and in the right order. */
3538 recenter_overlay_lists (b
, XINT (b
->overlay_center
));
3540 /* We don't need to redisplay the region covered by the overlay, because
3541 the overlay has no properties at the moment. */
3546 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3549 modify_overlay (buf
, start
, end
)
3560 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3562 /* If this is a buffer not in the selected window,
3563 we must do other windows. */
3564 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3565 windows_or_buffers_changed
= 1;
3566 /* If multiple windows show this buffer, we must do other windows. */
3567 else if (buffer_shared
> 1)
3568 windows_or_buffers_changed
= 1;
3570 ++BUF_OVERLAY_MODIFF (buf
);
3574 Lisp_Object
Fdelete_overlay ();
3576 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3577 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3578 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3579 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3581 (overlay
, beg
, end
, buffer
)
3582 Lisp_Object overlay
, beg
, end
, buffer
;
3584 struct buffer
*b
, *ob
;
3585 Lisp_Object obuffer
;
3586 int count
= SPECPDL_INDEX ();
3588 CHECK_OVERLAY (overlay
);
3590 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3592 XSETBUFFER (buffer
, current_buffer
);
3593 CHECK_BUFFER (buffer
);
3596 && ! EQ (Fmarker_buffer (beg
), buffer
))
3597 error ("Marker points into wrong buffer");
3599 && ! EQ (Fmarker_buffer (end
), buffer
))
3600 error ("Marker points into wrong buffer");
3602 CHECK_NUMBER_COERCE_MARKER (beg
);
3603 CHECK_NUMBER_COERCE_MARKER (end
);
3605 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3606 return Fdelete_overlay (overlay
);
3608 if (XINT (beg
) > XINT (end
))
3611 temp
= beg
; beg
= end
; end
= temp
;
3614 specbind (Qinhibit_quit
, Qt
);
3616 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3617 b
= XBUFFER (buffer
);
3618 ob
= BUFFERP (obuffer
) ? XBUFFER (obuffer
) : (struct buffer
*) 0;
3620 /* If the overlay has changed buffers, do a thorough redisplay. */
3621 if (!EQ (buffer
, obuffer
))
3623 /* Redisplay where the overlay was. */
3624 if (!NILP (obuffer
))
3629 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3630 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3632 modify_overlay (ob
, o_beg
, o_end
);
3635 /* Redisplay where the overlay is going to be. */
3636 modify_overlay (b
, XINT (beg
), XINT (end
));
3639 /* Redisplay the area the overlay has just left, or just enclosed. */
3643 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3644 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3646 if (o_beg
== XINT (beg
))
3647 modify_overlay (b
, o_end
, XINT (end
));
3648 else if (o_end
== XINT (end
))
3649 modify_overlay (b
, o_beg
, XINT (beg
));
3652 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
3653 if (XINT (end
) > o_end
) o_end
= XINT (end
);
3654 modify_overlay (b
, o_beg
, o_end
);
3658 if (!NILP (obuffer
))
3660 ob
->overlays_before
= Fdelq (overlay
, ob
->overlays_before
);
3661 ob
->overlays_after
= Fdelq (overlay
, ob
->overlays_after
);
3664 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3665 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3667 /* Put the overlay on the wrong list. */
3668 end
= OVERLAY_END (overlay
);
3669 if (OVERLAY_POSITION (end
) < XINT (b
->overlay_center
))
3670 b
->overlays_after
= Fcons (overlay
, b
->overlays_after
);
3672 b
->overlays_before
= Fcons (overlay
, b
->overlays_before
);
3674 /* This puts it in the right list, and in the right order. */
3675 recenter_overlay_lists (b
, XINT (b
->overlay_center
));
3677 return unbind_to (count
, overlay
);
3680 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
3681 doc
: /* Delete the overlay OVERLAY from its buffer. */)
3683 Lisp_Object overlay
;
3687 int count
= SPECPDL_INDEX ();
3689 CHECK_OVERLAY (overlay
);
3691 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3695 b
= XBUFFER (buffer
);
3696 specbind (Qinhibit_quit
, Qt
);
3698 b
->overlays_before
= Fdelq (overlay
, b
->overlays_before
);
3699 b
->overlays_after
= Fdelq (overlay
, b
->overlays_after
);
3701 marker_position (OVERLAY_START (overlay
)),
3702 marker_position (OVERLAY_END (overlay
)));
3703 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
3704 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
3706 /* When deleting an overlay with before or after strings, turn off
3707 display optimizations for the affected buffer, on the basis that
3708 these strings may contain newlines. This is easier to do than to
3709 check for that situation during redisplay. */
3710 if (!windows_or_buffers_changed
3711 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
3712 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
3713 b
->prevent_redisplay_optimizations_p
= 1;
3715 return unbind_to (count
, Qnil
);
3718 /* Overlay dissection functions. */
3720 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
3721 doc
: /* Return the position at which OVERLAY starts. */)
3723 Lisp_Object overlay
;
3725 CHECK_OVERLAY (overlay
);
3727 return (Fmarker_position (OVERLAY_START (overlay
)));
3730 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
3731 doc
: /* Return the position at which OVERLAY ends. */)
3733 Lisp_Object overlay
;
3735 CHECK_OVERLAY (overlay
);
3737 return (Fmarker_position (OVERLAY_END (overlay
)));
3740 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
3741 doc
: /* Return the buffer OVERLAY belongs to. */)
3743 Lisp_Object overlay
;
3745 CHECK_OVERLAY (overlay
);
3747 return Fmarker_buffer (OVERLAY_START (overlay
));
3750 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
3751 doc
: /* Return a list of the properties on OVERLAY.
3752 This is a copy of OVERLAY's plist; modifying its conses has no effect on
3755 Lisp_Object overlay
;
3757 CHECK_OVERLAY (overlay
);
3759 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
3763 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
3764 doc
: /* Return a list of the overlays that contain position POS. */)
3769 Lisp_Object
*overlay_vec
;
3773 CHECK_NUMBER_COERCE_MARKER (pos
);
3776 /* We can't use alloca here because overlays_at can call xrealloc. */
3777 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3779 /* Put all the overlays we want in a vector in overlay_vec.
3780 Store the length in len. */
3781 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3782 (int *) 0, (int *) 0, 0);
3784 /* Make a list of them all. */
3785 result
= Flist (noverlays
, overlay_vec
);
3787 xfree (overlay_vec
);
3791 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
3792 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
3793 Overlap means that at least one character is contained within the overlay
3794 and also contained within the specified region.
3795 Empty overlays are included in the result if they are located at BEG
3796 or between BEG and END. */)
3798 Lisp_Object beg
, end
;
3801 Lisp_Object
*overlay_vec
;
3805 CHECK_NUMBER_COERCE_MARKER (beg
);
3806 CHECK_NUMBER_COERCE_MARKER (end
);
3809 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3811 /* Put all the overlays we want in a vector in overlay_vec.
3812 Store the length in len. */
3813 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
3814 (int *) 0, (int *) 0);
3816 /* Make a list of them all. */
3817 result
= Flist (noverlays
, overlay_vec
);
3819 xfree (overlay_vec
);
3823 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
3825 doc
: /* Return the next position after POS where an overlay starts or ends.
3826 If there are no more overlay boundaries after POS, return (point-max). */)
3832 Lisp_Object
*overlay_vec
;
3836 CHECK_NUMBER_COERCE_MARKER (pos
);
3839 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3841 /* Put all the overlays we want in a vector in overlay_vec.
3842 Store the length in len.
3843 endpos gets the position where the next overlay starts. */
3844 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3845 &endpos
, (int *) 0, 1);
3847 /* If any of these overlays ends before endpos,
3848 use its ending point instead. */
3849 for (i
= 0; i
< noverlays
; i
++)
3854 oend
= OVERLAY_END (overlay_vec
[i
]);
3855 oendpos
= OVERLAY_POSITION (oend
);
3856 if (oendpos
< endpos
)
3860 xfree (overlay_vec
);
3861 return make_number (endpos
);
3864 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
3865 Sprevious_overlay_change
, 1, 1, 0,
3866 doc
: /* Return the previous position before POS where an overlay starts or ends.
3867 If there are no more overlay boundaries before POS, return (point-min). */)
3873 Lisp_Object
*overlay_vec
;
3876 CHECK_NUMBER_COERCE_MARKER (pos
);
3878 /* At beginning of buffer, we know the answer;
3879 avoid bug subtracting 1 below. */
3880 if (XINT (pos
) == BEGV
)
3884 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3886 /* Put all the overlays we want in a vector in overlay_vec.
3887 Store the length in len.
3888 prevpos gets the position of the previous change. */
3889 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3890 (int *) 0, &prevpos
, 1);
3892 xfree (overlay_vec
);
3893 return make_number (prevpos
);
3896 /* These functions are for debugging overlays. */
3898 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
3899 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
3900 The car has all the overlays before the overlay center;
3901 the cdr has all the overlays after the overlay center.
3902 Recentering overlays moves overlays between these lists.
3903 The lists you get are copies, so that changing them has no effect.
3904 However, the overlays you get are the real objects that the buffer uses. */)
3907 Lisp_Object before
, after
;
3908 before
= current_buffer
->overlays_before
;
3910 before
= Fcopy_sequence (before
);
3911 after
= current_buffer
->overlays_after
;
3913 after
= Fcopy_sequence (after
);
3915 return Fcons (before
, after
);
3918 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
3919 doc
: /* Recenter the overlays of the current buffer around position POS. */)
3923 CHECK_NUMBER_COERCE_MARKER (pos
);
3925 recenter_overlay_lists (current_buffer
, XINT (pos
));
3929 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
3930 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
3932 Lisp_Object overlay
, prop
;
3934 CHECK_OVERLAY (overlay
);
3935 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
3938 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
3939 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE. */)
3940 (overlay
, prop
, value
)
3941 Lisp_Object overlay
, prop
, value
;
3943 Lisp_Object tail
, buffer
;
3946 CHECK_OVERLAY (overlay
);
3948 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3950 for (tail
= XOVERLAY (overlay
)->plist
;
3951 CONSP (tail
) && CONSP (XCDR (tail
));
3952 tail
= XCDR (XCDR (tail
)))
3953 if (EQ (XCAR (tail
), prop
))
3955 changed
= !EQ (XCAR (XCDR (tail
)), value
);
3956 XSETCAR (XCDR (tail
), value
);
3959 /* It wasn't in the list, so add it to the front. */
3960 changed
= !NILP (value
);
3961 XOVERLAY (overlay
)->plist
3962 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
3964 if (! NILP (buffer
))
3967 modify_overlay (XBUFFER (buffer
),
3968 marker_position (OVERLAY_START (overlay
)),
3969 marker_position (OVERLAY_END (overlay
)));
3970 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
3971 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
3972 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
3973 Fdelete_overlay (overlay
);
3978 /* Subroutine of report_overlay_modification. */
3980 /* Lisp vector holding overlay hook functions to call.
3981 Vector elements come in pairs.
3982 Each even-index element is a list of hook functions.
3983 The following odd-index element is the overlay they came from.
3985 Before the buffer change, we fill in this vector
3986 as we call overlay hook functions.
3987 After the buffer change, we get the functions to call from this vector.
3988 This way we always call the same functions before and after the change. */
3989 static Lisp_Object last_overlay_modification_hooks
;
3991 /* Number of elements actually used in last_overlay_modification_hooks. */
3992 static int last_overlay_modification_hooks_used
;
3994 /* Add one functionlist/overlay pair
3995 to the end of last_overlay_modification_hooks. */
3998 add_overlay_mod_hooklist (functionlist
, overlay
)
3999 Lisp_Object functionlist
, overlay
;
4001 int oldsize
= XVECTOR (last_overlay_modification_hooks
)->size
;
4003 if (last_overlay_modification_hooks_used
== oldsize
)
4006 old
= last_overlay_modification_hooks
;
4007 last_overlay_modification_hooks
4008 = Fmake_vector (make_number (oldsize
* 2), Qnil
);
4009 bcopy (XVECTOR (old
)->contents
,
4010 XVECTOR (last_overlay_modification_hooks
)->contents
,
4011 sizeof (Lisp_Object
) * oldsize
);
4013 XVECTOR (last_overlay_modification_hooks
)->contents
[last_overlay_modification_hooks_used
++] = functionlist
;
4014 XVECTOR (last_overlay_modification_hooks
)->contents
[last_overlay_modification_hooks_used
++] = overlay
;
4017 /* Run the modification-hooks of overlays that include
4018 any part of the text in START to END.
4019 If this change is an insertion, also
4020 run the insert-before-hooks of overlay starting at END,
4021 and the insert-after-hooks of overlay ending at START.
4023 This is called both before and after the modification.
4024 AFTER is nonzero when we call after the modification.
4026 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4027 When AFTER is nonzero, they are the start position,
4028 the position after the inserted new text,
4029 and the length of deleted or replaced old text. */
4032 report_overlay_modification (start
, end
, after
, arg1
, arg2
, arg3
)
4033 Lisp_Object start
, end
;
4035 Lisp_Object arg1
, arg2
, arg3
;
4037 Lisp_Object prop
, overlay
, tail
;
4038 /* 1 if this change is an insertion. */
4039 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4041 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
4045 GCPRO5 (overlay
, tail
, arg1
, arg2
, arg3
);
4049 /* Call the functions recorded in last_overlay_modification_hooks
4050 rather than scanning the overlays again.
4051 First copy the vector contents, in case some of these hooks
4052 do subsequent modification of the buffer. */
4053 int size
= last_overlay_modification_hooks_used
;
4054 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
4057 bcopy (XVECTOR (last_overlay_modification_hooks
)->contents
,
4058 copy
, size
* sizeof (Lisp_Object
));
4060 gcpro1
.nvars
= size
;
4062 for (i
= 0; i
< size
;)
4064 Lisp_Object prop
, overlay
;
4066 overlay
= copy
[i
++];
4067 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4073 /* We are being called before a change.
4074 Scan the overlays to find the functions to call. */
4075 last_overlay_modification_hooks_used
= 0;
4077 for (tail
= current_buffer
->overlays_before
;
4081 int startpos
, endpos
;
4082 Lisp_Object ostart
, oend
;
4084 overlay
= XCAR (tail
);
4086 ostart
= OVERLAY_START (overlay
);
4087 oend
= OVERLAY_END (overlay
);
4088 endpos
= OVERLAY_POSITION (oend
);
4089 if (XFASTINT (start
) > endpos
)
4091 startpos
= OVERLAY_POSITION (ostart
);
4092 if (insertion
&& (XFASTINT (start
) == startpos
4093 || XFASTINT (end
) == startpos
))
4095 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4098 /* Copy TAIL in case the hook recenters the overlay lists. */
4100 tail
= Fcopy_sequence (tail
);
4102 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4105 if (insertion
&& (XFASTINT (start
) == endpos
4106 || XFASTINT (end
) == endpos
))
4108 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4112 tail
= Fcopy_sequence (tail
);
4114 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4117 /* Test for intersecting intervals. This does the right thing
4118 for both insertion and deletion. */
4119 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4121 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4125 tail
= Fcopy_sequence (tail
);
4127 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4133 for (tail
= current_buffer
->overlays_after
;
4137 int startpos
, endpos
;
4138 Lisp_Object ostart
, oend
;
4140 overlay
= XCAR (tail
);
4142 ostart
= OVERLAY_START (overlay
);
4143 oend
= OVERLAY_END (overlay
);
4144 startpos
= OVERLAY_POSITION (ostart
);
4145 endpos
= OVERLAY_POSITION (oend
);
4146 if (XFASTINT (end
) < startpos
)
4148 if (insertion
&& (XFASTINT (start
) == startpos
4149 || XFASTINT (end
) == startpos
))
4151 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4155 tail
= Fcopy_sequence (tail
);
4157 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4160 if (insertion
&& (XFASTINT (start
) == endpos
4161 || XFASTINT (end
) == endpos
))
4163 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4167 tail
= Fcopy_sequence (tail
);
4169 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4172 /* Test for intersecting intervals. This does the right thing
4173 for both insertion and deletion. */
4174 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4176 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4180 tail
= Fcopy_sequence (tail
);
4182 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4191 call_overlay_mod_hooks (list
, overlay
, after
, arg1
, arg2
, arg3
)
4192 Lisp_Object list
, overlay
;
4194 Lisp_Object arg1
, arg2
, arg3
;
4196 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4198 GCPRO4 (list
, arg1
, arg2
, arg3
);
4200 add_overlay_mod_hooklist (list
, overlay
);
4202 while (!NILP (list
))
4205 call4 (Fcar (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4207 call5 (Fcar (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4213 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4216 evaporate_overlays (pos
)
4219 Lisp_Object tail
, overlay
, hit_list
;
4222 if (pos
<= XFASTINT (current_buffer
->overlay_center
))
4223 for (tail
= current_buffer
->overlays_before
; CONSP (tail
);
4227 overlay
= XCAR (tail
);
4228 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4231 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4232 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4233 hit_list
= Fcons (overlay
, hit_list
);
4236 for (tail
= current_buffer
->overlays_after
; CONSP (tail
);
4240 overlay
= XCAR (tail
);
4241 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4244 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4245 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4246 hit_list
= Fcons (overlay
, hit_list
);
4248 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4249 Fdelete_overlay (XCAR (hit_list
));
4252 /* Somebody has tried to store a value with an unacceptable type
4253 in the slot with offset OFFSET. */
4256 buffer_slot_type_mismatch (offset
)
4262 switch (XINT (PER_BUFFER_TYPE (offset
)))
4265 type_name
= "integers";
4269 type_name
= "strings";
4273 type_name
= "symbols";
4280 sym
= PER_BUFFER_SYMBOL (offset
);
4281 error ("Only %s should be stored in the buffer-local variable %s",
4282 type_name
, SDATA (SYMBOL_NAME (sym
)));
4286 /***********************************************************************
4287 Allocation with mmap
4288 ***********************************************************************/
4290 #ifdef USE_MMAP_FOR_BUFFERS
4292 #include <sys/types.h>
4293 #include <sys/mman.h>
4296 #ifdef MAP_ANONYMOUS
4297 #define MAP_ANON MAP_ANONYMOUS
4304 #define MAP_FAILED ((void *) -1)
4317 /* Memory is allocated in regions which are mapped using mmap(2).
4318 The current implementation lets the system select mapped
4319 addresses; we're not using MAP_FIXED in general, except when
4320 trying to enlarge regions.
4322 Each mapped region starts with a mmap_region structure, the user
4323 area starts after that structure, aligned to MEM_ALIGN.
4325 +-----------------------+
4326 | struct mmap_info + |
4328 +-----------------------+
4332 +-----------------------+ */
4336 /* User-specified size. */
4337 size_t nbytes_specified
;
4339 /* Number of bytes mapped */
4340 size_t nbytes_mapped
;
4342 /* Pointer to the location holding the address of the memory
4343 allocated with the mmap'd block. The variable actually points
4344 after this structure. */
4347 /* Next and previous in list of all mmap'd regions. */
4348 struct mmap_region
*next
, *prev
;
4351 /* Doubly-linked list of mmap'd regions. */
4353 static struct mmap_region
*mmap_regions
;
4355 /* File descriptor for mmap. If we don't have anonymous mapping,
4356 /dev/zero will be opened on it. */
4360 /* Temporary storage for mmap_set_vars, see there. */
4362 static struct mmap_region
*mmap_regions_1
;
4363 static int mmap_fd_1
;
4365 /* Page size on this system. */
4367 static int mmap_page_size
;
4369 /* 1 means mmap has been intialized. */
4371 static int mmap_initialized_p
;
4373 /* Value is X rounded up to the next multiple of N. */
4375 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4377 /* Size of mmap_region structure plus padding. */
4379 #define MMAP_REGION_STRUCT_SIZE \
4380 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4382 /* Given a pointer P to the start of the user-visible part of a mapped
4383 region, return a pointer to the start of the region. */
4385 #define MMAP_REGION(P) \
4386 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4388 /* Given a pointer P to the start of a mapped region, return a pointer
4389 to the start of the user-visible part of the region. */
4391 #define MMAP_USER_AREA(P) \
4392 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4394 #define MEM_ALIGN sizeof (double)
4396 /* Predicate returning true if part of the address range [START ..
4397 END[ is currently mapped. Used to prevent overwriting an existing
4400 Default is to conservativly assume the address range is occupied by
4401 something else. This can be overridden by system configuration
4402 files if system-specific means to determine this exists. */
4404 #ifndef MMAP_ALLOCATED_P
4405 #define MMAP_ALLOCATED_P(start, end) 1
4408 /* Function prototypes. */
4410 static int mmap_free_1
P_ ((struct mmap_region
*));
4411 static int mmap_enlarge
P_ ((struct mmap_region
*, int));
4412 static struct mmap_region
*mmap_find
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
4413 static POINTER_TYPE
*mmap_alloc
P_ ((POINTER_TYPE
**, size_t));
4414 static POINTER_TYPE
*mmap_realloc
P_ ((POINTER_TYPE
**, size_t));
4415 static void mmap_free
P_ ((POINTER_TYPE
**ptr
));
4416 static void mmap_init
P_ ((void));
4419 /* Return a region overlapping address range START...END, or null if
4420 none. END is not including, i.e. the last byte in the range
4423 static struct mmap_region
*
4424 mmap_find (start
, end
)
4425 POINTER_TYPE
*start
, *end
;
4427 struct mmap_region
*r
;
4428 char *s
= (char *) start
, *e
= (char *) end
;
4430 for (r
= mmap_regions
; r
; r
= r
->next
)
4432 char *rstart
= (char *) r
;
4433 char *rend
= rstart
+ r
->nbytes_mapped
;
4435 if (/* First byte of range, i.e. START, in this region? */
4436 (s
>= rstart
&& s
< rend
)
4437 /* Last byte of range, i.e. END - 1, in this region? */
4438 || (e
> rstart
&& e
<= rend
)
4439 /* First byte of this region in the range? */
4440 || (rstart
>= s
&& rstart
< e
)
4441 /* Last byte of this region in the range? */
4442 || (rend
> s
&& rend
<= e
))
4450 /* Unmap a region. P is a pointer to the start of the user-araa of
4451 the region. Value is non-zero if successful. */
4455 struct mmap_region
*r
;
4458 r
->next
->prev
= r
->prev
;
4460 r
->prev
->next
= r
->next
;
4462 mmap_regions
= r
->next
;
4464 if (munmap ((POINTER_TYPE
*) r
, r
->nbytes_mapped
) == -1)
4466 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4474 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4475 Value is non-zero if successful. */
4478 mmap_enlarge (r
, npages
)
4479 struct mmap_region
*r
;
4482 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4488 /* Unmap pages at the end of the region. */
4489 nbytes
= - npages
* mmap_page_size
;
4490 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4491 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4494 r
->nbytes_mapped
-= nbytes
;
4498 else if (npages
> 0)
4500 nbytes
= npages
* mmap_page_size
;
4502 /* Try to map additional pages at the end of the region. We
4503 cannot do this if the address range is already occupied by
4504 something else because mmap deletes any previous mapping.
4505 I'm not sure this is worth doing, let's see. */
4506 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4510 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4511 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4512 if (p
== MAP_FAILED
)
4513 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4514 else if (p
!= (POINTER_TYPE
*) region_end
)
4516 /* Kernels are free to choose a different address. In
4517 that case, unmap what we've mapped above; we have
4519 if (munmap (p
, nbytes
) == -1)
4520 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4524 r
->nbytes_mapped
+= nbytes
;
4534 /* Set or reset variables holding references to mapped regions. If
4535 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4536 non-zero, set all variables to the start of the user-areas
4539 This function is called from Fdump_emacs to ensure that the dumped
4540 Emacs doesn't contain references to memory that won't be mapped
4541 when Emacs starts. */
4544 mmap_set_vars (restore_p
)
4547 struct mmap_region
*r
;
4551 mmap_regions
= mmap_regions_1
;
4552 mmap_fd
= mmap_fd_1
;
4553 for (r
= mmap_regions
; r
; r
= r
->next
)
4554 *r
->var
= MMAP_USER_AREA (r
);
4558 for (r
= mmap_regions
; r
; r
= r
->next
)
4560 mmap_regions_1
= mmap_regions
;
4561 mmap_regions
= NULL
;
4562 mmap_fd_1
= mmap_fd
;
4568 /* Allocate a block of storage large enough to hold NBYTES bytes of
4569 data. A pointer to the data is returned in *VAR. VAR is thus the
4570 address of some variable which will use the data area.
4572 The allocation of 0 bytes is valid.
4574 If we can't allocate the necessary memory, set *VAR to null, and
4577 static POINTER_TYPE
*
4578 mmap_alloc (var
, nbytes
)
4587 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4588 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4591 if (p
== MAP_FAILED
)
4593 if (errno
!= ENOMEM
)
4594 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4599 struct mmap_region
*r
= (struct mmap_region
*) p
;
4601 r
->nbytes_specified
= nbytes
;
4602 r
->nbytes_mapped
= map
;
4605 r
->next
= mmap_regions
;
4610 p
= MMAP_USER_AREA (p
);
4617 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4618 resize it to size NBYTES. Change *VAR to reflect the new block,
4619 and return this value. If more memory cannot be allocated, then
4620 leave *VAR unchanged, and return null. */
4622 static POINTER_TYPE
*
4623 mmap_realloc (var
, nbytes
)
4627 POINTER_TYPE
*result
;
4632 result
= mmap_alloc (var
, nbytes
);
4633 else if (nbytes
== 0)
4636 result
= mmap_alloc (var
, nbytes
);
4640 struct mmap_region
*r
= MMAP_REGION (*var
);
4641 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4646 POINTER_TYPE
*old_ptr
= *var
;
4648 /* Try to map additional pages at the end of the region.
4649 If that fails, allocate a new region, copy data
4650 from the old region, then free it. */
4651 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4654 r
->nbytes_specified
= nbytes
;
4655 *var
= result
= old_ptr
;
4657 else if (mmap_alloc (var
, nbytes
))
4659 bcopy (old_ptr
, *var
, r
->nbytes_specified
);
4660 mmap_free_1 (MMAP_REGION (old_ptr
));
4662 r
= MMAP_REGION (result
);
4663 r
->nbytes_specified
= nbytes
;
4671 else if (room
- nbytes
>= mmap_page_size
)
4673 /* Shrinking by at least a page. Let's give some
4674 memory back to the system.
4676 The extra parens are to make the division happens first,
4677 on positive values, so we know it will round towards
4679 mmap_enlarge (r
, - ((room
- nbytes
) / mmap_page_size
));
4681 r
->nbytes_specified
= nbytes
;
4685 /* Leave it alone. */
4687 r
->nbytes_specified
= nbytes
;
4695 /* Free a block of relocatable storage whose data is pointed to by
4696 PTR. Store 0 in *PTR to show there's no block allocated. */
4706 mmap_free_1 (MMAP_REGION (*var
));
4712 /* Perform necessary intializations for the use of mmap. */
4718 /* The value of mmap_fd is initially 0 in temacs, and -1
4719 in a dumped Emacs. */
4722 /* No anonymous mmap -- we need the file descriptor. */
4723 mmap_fd
= open ("/dev/zero", O_RDONLY
);
4725 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4727 #endif /* MAP_ANON == 0 */
4729 if (mmap_initialized_p
)
4731 mmap_initialized_p
= 1;
4737 mmap_page_size
= getpagesize ();
4740 #endif /* USE_MMAP_FOR_BUFFERS */
4744 /***********************************************************************
4745 Buffer-text Allocation
4746 ***********************************************************************/
4749 extern POINTER_TYPE
*r_alloc
P_ ((POINTER_TYPE
**, size_t));
4750 extern POINTER_TYPE
*r_re_alloc
P_ ((POINTER_TYPE
**, size_t));
4751 extern void r_alloc_free
P_ ((POINTER_TYPE
**ptr
));
4752 #endif /* REL_ALLOC */
4755 /* Allocate NBYTES bytes for buffer B's text buffer. */
4758 alloc_buffer_text (b
, nbytes
)
4765 #if defined USE_MMAP_FOR_BUFFERS
4766 p
= mmap_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4767 #elif defined REL_ALLOC
4768 p
= r_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4770 p
= xmalloc (nbytes
);
4779 b
->text
->beg
= (unsigned char *) p
;
4783 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4787 enlarge_buffer_text (b
, delta
)
4792 size_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4795 #if defined USE_MMAP_FOR_BUFFERS
4796 p
= mmap_realloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4797 #elif defined REL_ALLOC
4798 p
= r_re_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4800 p
= xrealloc (b
->text
->beg
, nbytes
);
4809 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
4814 /* Free buffer B's text buffer. */
4817 free_buffer_text (b
)
4822 #if defined USE_MMAP_FOR_BUFFERS
4823 mmap_free ((POINTER_TYPE
**) &b
->text
->beg
);
4824 #elif defined REL_ALLOC
4825 r_alloc_free ((POINTER_TYPE
**) &b
->text
->beg
);
4827 xfree (b
->text
->beg
);
4830 BUF_BEG_ADDR (b
) = NULL
;
4836 /***********************************************************************
4838 ***********************************************************************/
4845 bzero (buffer_permanent_local_flags
, sizeof buffer_permanent_local_flags
);
4847 /* Make sure all markable slots in buffer_defaults
4848 are initialized reasonably, so mark_buffer won't choke. */
4849 reset_buffer (&buffer_defaults
);
4850 reset_buffer_local_variables (&buffer_defaults
, 1);
4851 reset_buffer (&buffer_local_symbols
);
4852 reset_buffer_local_variables (&buffer_local_symbols
, 1);
4853 /* Prevent GC from getting confused. */
4854 buffer_defaults
.text
= &buffer_defaults
.own_text
;
4855 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
4856 BUF_INTERVALS (&buffer_defaults
) = 0;
4857 BUF_INTERVALS (&buffer_local_symbols
) = 0;
4858 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
4859 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
4861 /* Set up the default values of various buffer slots. */
4862 /* Must do these before making the first buffer! */
4864 /* real setup is done in bindings.el */
4865 buffer_defaults
.mode_line_format
= build_string ("%-");
4866 buffer_defaults
.header_line_format
= Qnil
;
4867 buffer_defaults
.abbrev_mode
= Qnil
;
4868 buffer_defaults
.overwrite_mode
= Qnil
;
4869 buffer_defaults
.case_fold_search
= Qt
;
4870 buffer_defaults
.auto_fill_function
= Qnil
;
4871 buffer_defaults
.selective_display
= Qnil
;
4873 buffer_defaults
.selective_display_ellipses
= Qt
;
4875 buffer_defaults
.abbrev_table
= Qnil
;
4876 buffer_defaults
.display_table
= Qnil
;
4877 buffer_defaults
.undo_list
= Qnil
;
4878 buffer_defaults
.mark_active
= Qnil
;
4879 buffer_defaults
.file_format
= Qnil
;
4880 buffer_defaults
.overlays_before
= Qnil
;
4881 buffer_defaults
.overlays_after
= Qnil
;
4882 XSETFASTINT (buffer_defaults
.overlay_center
, BEG
);
4884 XSETFASTINT (buffer_defaults
.tab_width
, 8);
4885 buffer_defaults
.truncate_lines
= Qnil
;
4886 buffer_defaults
.ctl_arrow
= Qt
;
4887 buffer_defaults
.direction_reversed
= Qnil
;
4888 buffer_defaults
.cursor_type
= Qt
;
4889 buffer_defaults
.extra_line_spacing
= Qnil
;
4892 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
4894 buffer_defaults
.enable_multibyte_characters
= Qt
;
4895 buffer_defaults
.buffer_file_coding_system
= Qnil
;
4896 XSETFASTINT (buffer_defaults
.fill_column
, 70);
4897 XSETFASTINT (buffer_defaults
.left_margin
, 0);
4898 buffer_defaults
.cache_long_line_scans
= Qnil
;
4899 buffer_defaults
.file_truename
= Qnil
;
4900 XSETFASTINT (buffer_defaults
.display_count
, 0);
4901 buffer_defaults
.indicate_empty_lines
= Qnil
;
4902 buffer_defaults
.scroll_up_aggressively
= Qnil
;
4903 buffer_defaults
.scroll_down_aggressively
= Qnil
;
4904 buffer_defaults
.display_time
= Qnil
;
4906 /* Assign the local-flags to the slots that have default values.
4907 The local flag is a bit that is used in the buffer
4908 to say that it has its own local value for the slot.
4909 The local flag bits are in the local_var_flags slot of the buffer. */
4911 /* Nothing can work if this isn't true */
4912 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
4914 /* 0 means not a lisp var, -1 means always local, else mask */
4915 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
4916 XSETINT (buffer_local_flags
.filename
, -1);
4917 XSETINT (buffer_local_flags
.directory
, -1);
4918 XSETINT (buffer_local_flags
.backed_up
, -1);
4919 XSETINT (buffer_local_flags
.save_length
, -1);
4920 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
4921 XSETINT (buffer_local_flags
.read_only
, -1);
4922 XSETINT (buffer_local_flags
.major_mode
, -1);
4923 XSETINT (buffer_local_flags
.mode_name
, -1);
4924 XSETINT (buffer_local_flags
.undo_list
, -1);
4925 XSETINT (buffer_local_flags
.mark_active
, -1);
4926 XSETINT (buffer_local_flags
.point_before_scroll
, -1);
4927 XSETINT (buffer_local_flags
.file_truename
, -1);
4928 XSETINT (buffer_local_flags
.invisibility_spec
, -1);
4929 XSETINT (buffer_local_flags
.file_format
, -1);
4930 XSETINT (buffer_local_flags
.display_count
, -1);
4931 XSETINT (buffer_local_flags
.display_time
, -1);
4932 XSETINT (buffer_local_flags
.enable_multibyte_characters
, -1);
4935 XSETFASTINT (buffer_local_flags
.mode_line_format
, idx
); ++idx
;
4936 XSETFASTINT (buffer_local_flags
.abbrev_mode
, idx
); ++idx
;
4937 XSETFASTINT (buffer_local_flags
.overwrite_mode
, idx
); ++idx
;
4938 XSETFASTINT (buffer_local_flags
.case_fold_search
, idx
); ++idx
;
4939 XSETFASTINT (buffer_local_flags
.auto_fill_function
, idx
); ++idx
;
4940 XSETFASTINT (buffer_local_flags
.selective_display
, idx
); ++idx
;
4942 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, idx
); ++idx
;
4944 XSETFASTINT (buffer_local_flags
.tab_width
, idx
); ++idx
;
4945 XSETFASTINT (buffer_local_flags
.truncate_lines
, idx
); ++idx
;
4946 XSETFASTINT (buffer_local_flags
.ctl_arrow
, idx
); ++idx
;
4947 XSETFASTINT (buffer_local_flags
.fill_column
, idx
); ++idx
;
4948 XSETFASTINT (buffer_local_flags
.left_margin
, idx
); ++idx
;
4949 XSETFASTINT (buffer_local_flags
.abbrev_table
, idx
); ++idx
;
4950 XSETFASTINT (buffer_local_flags
.display_table
, idx
); ++idx
;
4952 XSETFASTINT (buffer_local_flags
.buffer_file_type
, idx
);
4953 /* Make this one a permanent local. */
4954 buffer_permanent_local_flags
[idx
++] = 1;
4956 XSETFASTINT (buffer_local_flags
.syntax_table
, idx
); ++idx
;
4957 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, idx
); ++idx
;
4958 XSETFASTINT (buffer_local_flags
.category_table
, idx
); ++idx
;
4959 XSETFASTINT (buffer_local_flags
.direction_reversed
, idx
); ++idx
;
4960 XSETFASTINT (buffer_local_flags
.buffer_file_coding_system
, idx
);
4961 /* Make this one a permanent local. */
4962 buffer_permanent_local_flags
[idx
++] = 1;
4963 XSETFASTINT (buffer_local_flags
.left_margin_width
, idx
); ++idx
;
4964 XSETFASTINT (buffer_local_flags
.right_margin_width
, idx
); ++idx
;
4965 XSETFASTINT (buffer_local_flags
.indicate_empty_lines
, idx
); ++idx
;
4966 XSETFASTINT (buffer_local_flags
.scroll_up_aggressively
, idx
); ++idx
;
4967 XSETFASTINT (buffer_local_flags
.scroll_down_aggressively
, idx
); ++idx
;
4968 XSETFASTINT (buffer_local_flags
.header_line_format
, idx
); ++idx
;
4969 XSETFASTINT (buffer_local_flags
.cursor_type
, idx
); ++idx
;
4970 XSETFASTINT (buffer_local_flags
.extra_line_spacing
, idx
); ++idx
;
4972 /* Need more room? */
4973 if (idx
>= MAX_PER_BUFFER_VARS
)
4975 last_per_buffer_idx
= idx
;
4977 Vbuffer_alist
= Qnil
;
4981 QSFundamental
= build_string ("Fundamental");
4983 Qfundamental_mode
= intern ("fundamental-mode");
4984 buffer_defaults
.major_mode
= Qfundamental_mode
;
4986 Qmode_class
= intern ("mode-class");
4988 Qprotected_field
= intern ("protected-field");
4990 Qpermanent_local
= intern ("permanent-local");
4992 Qkill_buffer_hook
= intern ("kill-buffer-hook");
4994 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
4996 /* super-magic invisible buffer */
4997 Vbuffer_alist
= Qnil
;
4999 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5001 inhibit_modification_hooks
= 0;
5007 char buf
[MAXPATHLEN
+ 1];
5009 struct stat dotstat
, pwdstat
;
5013 #ifdef USE_MMAP_FOR_BUFFERS
5015 /* When using the ralloc implementation based on mmap(2), buffer
5016 text pointers will have been set to null in the dumped Emacs.
5020 for (b
= all_buffers
; b
; b
= b
->next
)
5021 if (b
->text
->beg
== NULL
)
5022 enlarge_buffer_text (b
, 0);
5024 #endif /* USE_MMAP_FOR_BUFFERS */
5026 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5027 if (NILP (buffer_defaults
.enable_multibyte_characters
))
5028 Fset_buffer_multibyte (Qnil
);
5030 /* If PWD is accurate, use it instead of calling getwd. PWD is
5031 sometimes a nicer name, and using it may avoid a fatal error if a
5032 parent directory is searchable but not readable. */
5033 if ((pwd
= getenv ("PWD")) != 0
5034 && (IS_DIRECTORY_SEP (*pwd
) || (*pwd
&& IS_DEVICE_SEP (pwd
[1])))
5035 && stat (pwd
, &pwdstat
) == 0
5036 && stat (".", &dotstat
) == 0
5037 && dotstat
.st_ino
== pwdstat
.st_ino
5038 && dotstat
.st_dev
== pwdstat
.st_dev
5039 && strlen (pwd
) < MAXPATHLEN
)
5042 else if (getcwd (buf
, MAXPATHLEN
+1) == 0)
5043 fatal ("`getcwd' failed: %s\n", strerror (errno
));
5045 else if (getwd (buf
) == 0)
5046 fatal ("`getwd' failed: %s\n", buf
);
5050 /* Maybe this should really use some standard subroutine
5051 whose definition is filename syntax dependent. */
5053 if (!(IS_DIRECTORY_SEP (buf
[rc
- 1])))
5055 buf
[rc
] = DIRECTORY_SEP
;
5058 #endif /* not VMS */
5060 current_buffer
->directory
= build_string (buf
);
5062 /* Add /: to the front of the name
5063 if it would otherwise be treated as magic. */
5064 temp
= Ffind_file_name_handler (current_buffer
->directory
, Qt
);
5066 /* If the default dir is just /, TEMP is non-nil
5067 because of the ange-ftp completion handler.
5068 However, it is not necessary to turn / into /:/.
5069 So avoid doing that. */
5070 && strcmp ("/", SDATA (current_buffer
->directory
)))
5071 current_buffer
->directory
5072 = concat2 (build_string ("/:"), current_buffer
->directory
);
5074 temp
= get_minibuffer (0);
5075 XBUFFER (temp
)->directory
= current_buffer
->directory
;
5078 /* initialize the buffer routines */
5082 staticpro (&last_overlay_modification_hooks
);
5083 last_overlay_modification_hooks
5084 = Fmake_vector (make_number (10), Qnil
);
5086 staticpro (&Vbuffer_defaults
);
5087 staticpro (&Vbuffer_local_symbols
);
5088 staticpro (&Qfundamental_mode
);
5089 staticpro (&Qmode_class
);
5090 staticpro (&QSFundamental
);
5091 staticpro (&Vbuffer_alist
);
5092 staticpro (&Qprotected_field
);
5093 staticpro (&Qpermanent_local
);
5094 staticpro (&Qkill_buffer_hook
);
5095 Qoverlayp
= intern ("overlayp");
5096 staticpro (&Qoverlayp
);
5097 Qevaporate
= intern ("evaporate");
5098 staticpro (&Qevaporate
);
5099 Qmodification_hooks
= intern ("modification-hooks");
5100 staticpro (&Qmodification_hooks
);
5101 Qinsert_in_front_hooks
= intern ("insert-in-front-hooks");
5102 staticpro (&Qinsert_in_front_hooks
);
5103 Qinsert_behind_hooks
= intern ("insert-behind-hooks");
5104 staticpro (&Qinsert_behind_hooks
);
5105 Qget_file_buffer
= intern ("get-file-buffer");
5106 staticpro (&Qget_file_buffer
);
5107 Qpriority
= intern ("priority");
5108 staticpro (&Qpriority
);
5109 Qwindow
= intern ("window");
5110 staticpro (&Qwindow
);
5111 Qbefore_string
= intern ("before-string");
5112 staticpro (&Qbefore_string
);
5113 Qafter_string
= intern ("after-string");
5114 staticpro (&Qafter_string
);
5115 Qfirst_change_hook
= intern ("first-change-hook");
5116 staticpro (&Qfirst_change_hook
);
5117 Qbefore_change_functions
= intern ("before-change-functions");
5118 staticpro (&Qbefore_change_functions
);
5119 Qafter_change_functions
= intern ("after-change-functions");
5120 staticpro (&Qafter_change_functions
);
5122 Fput (Qprotected_field
, Qerror_conditions
,
5123 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
5124 Fput (Qprotected_field
, Qerror_message
,
5125 build_string ("Attempt to modify a protected field"));
5127 /* All these use DEFVAR_LISP_NOPRO because the slots in
5128 buffer_defaults will all be marked via Vbuffer_defaults. */
5130 DEFVAR_LISP_NOPRO ("default-mode-line-format",
5131 &buffer_defaults
.mode_line_format
,
5132 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5133 This is the same as (default-value 'mode-line-format). */);
5135 DEFVAR_LISP_NOPRO ("default-header-line-format",
5136 &buffer_defaults
.header_line_format
,
5137 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5138 This is the same as (default-value 'header-line-format). */);
5140 DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults
.cursor_type
,
5141 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5142 This is the same as (default-value 'cursor-type). */);
5144 DEFVAR_LISP_NOPRO ("default-line-spacing",
5145 &buffer_defaults
.extra_line_spacing
,
5146 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5147 This is the same as (default-value 'line-spacing). */);
5149 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
5150 &buffer_defaults
.abbrev_mode
,
5151 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5152 This is the same as (default-value 'abbrev-mode). */);
5154 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
5155 &buffer_defaults
.ctl_arrow
,
5156 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5157 This is the same as (default-value 'ctl-arrow). */);
5159 DEFVAR_LISP_NOPRO ("default-direction-reversed",
5160 &buffer_defaults
.direction_reversed
,
5161 doc
: /* Default value of `direction_reversed' for buffers that do not override it.
5162 This is the same as (default-value 'direction-reversed). */);
5164 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
5165 &buffer_defaults
.enable_multibyte_characters
,
5166 doc
: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
5167 This is the same as (default-value 'enable-multibyte-characters). */);
5169 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
5170 &buffer_defaults
.buffer_file_coding_system
,
5171 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5172 This is the same as (default-value 'buffer-file-coding-system). */);
5174 DEFVAR_LISP_NOPRO ("default-truncate-lines",
5175 &buffer_defaults
.truncate_lines
,
5176 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5177 This is the same as (default-value 'truncate-lines). */);
5179 DEFVAR_LISP_NOPRO ("default-fill-column",
5180 &buffer_defaults
.fill_column
,
5181 doc
: /* Default value of `fill-column' for buffers that do not override it.
5182 This is the same as (default-value 'fill-column). */);
5184 DEFVAR_LISP_NOPRO ("default-left-margin",
5185 &buffer_defaults
.left_margin
,
5186 doc
: /* Default value of `left-margin' for buffers that do not override it.
5187 This is the same as (default-value 'left-margin). */);
5189 DEFVAR_LISP_NOPRO ("default-tab-width",
5190 &buffer_defaults
.tab_width
,
5191 doc
: /* Default value of `tab-width' for buffers that do not override it.
5192 This is the same as (default-value 'tab-width). */);
5194 DEFVAR_LISP_NOPRO ("default-case-fold-search",
5195 &buffer_defaults
.case_fold_search
,
5196 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5197 This is the same as (default-value 'case-fold-search). */);
5200 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
5201 &buffer_defaults
.buffer_file_type
,
5202 doc
: /* Default file type for buffers that do not override it.
5203 This is the same as (default-value 'buffer-file-type).
5204 The file type is nil for text, t for binary. */);
5207 DEFVAR_LISP_NOPRO ("default-left-margin-width",
5208 &buffer_defaults
.left_margin_width
,
5209 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5210 This is the same as (default-value 'left-margin-width). */);
5212 DEFVAR_LISP_NOPRO ("default-right-margin-width",
5213 &buffer_defaults
.right_margin_width
,
5214 doc
: /* Default value of `right_margin_width' for buffers that don't override it.
5215 This is the same as (default-value 'right-margin-width). */);
5217 DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
5218 &buffer_defaults
.indicate_empty_lines
,
5219 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5220 This is the same as (default-value 'indicate-empty-lines). */);
5222 DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
5223 &buffer_defaults
.scroll_up_aggressively
,
5224 doc
: /* Default value of `scroll-up-aggressively'.
5225 This value applies in buffers that don't have their own local values.
5226 This variable is an alias for (default-value 'scroll-up-aggressively). */);
5228 DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
5229 &buffer_defaults
.scroll_down_aggressively
,
5230 doc
: /* Default value of `scroll-down-aggressively'.
5231 This value applies in buffers that don't have their own local values.
5232 This variable is an alias for (default-value 'scroll-down-aggressively). */);
5234 DEFVAR_PER_BUFFER ("header-line-format",
5235 ¤t_buffer
->header_line_format
,
5237 doc
: /* Analogous to `mode-line-format', but controls the header line.
5238 The header line appears, optionally, at the top of a window;
5239 the mode line appears at the bottom. */);
5241 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
5243 doc
: /* Template for displaying mode line for current buffer.
5244 Each buffer has its own value of this variable.
5245 Value may be nil, a string, a symbol or a list or cons cell.
5246 A value of nil means don't display a mode line.
5247 For a symbol, its value is used (but it is ignored if t or nil).
5248 A string appearing directly as the value of a symbol is processed verbatim
5249 in that the %-constructs below are not recognized.
5250 For a list of the form `(:eval FORM)', FORM is evaluated and the result
5251 is used as a mode line element.
5252 For a list whose car is a symbol, the symbol's value is taken,
5253 and if that is non-nil, the cadr of the list is processed recursively.
5254 Otherwise, the caddr of the list (if there is one) is processed.
5255 For a list whose car is a string or list, each element is processed
5256 recursively and the results are effectively concatenated.
5257 For a list whose car is an integer, the cdr of the list is processed
5258 and padded (if the number is positive) or truncated (if negative)
5259 to the width specified by that number.
5260 A string is printed verbatim in the mode line except for %-constructs:
5261 (%-constructs are allowed when the string is the entire mode-line-format
5262 or when it is found in a cons-cell or a list)
5263 %b -- print buffer name. %f -- print visited file name.
5264 %F -- print frame name.
5265 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5266 %& is like %*, but ignore read-only-ness.
5267 % means buffer is read-only and * means it is modified.
5268 For a modified read-only buffer, %* gives % and %+ gives *.
5269 %s -- print process status. %l -- print the current line number.
5270 %c -- print the current column number (this makes editing slower).
5271 To make the column number update correctly in all cases,
5272 `column-number-mode' must be non-nil.
5273 %p -- print percent of buffer above top of window, or Top, Bot or All.
5274 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5275 or print Bottom or All.
5276 %m -- print the mode name.
5277 %n -- print Narrow if appropriate.
5278 %z -- print mnemonics of buffer, terminal, and keyboard coding systems.
5279 %Z -- like %z, but including the end-of-line format.
5280 %[ -- print one [ for each recursive editing level. %] similar.
5281 %% -- print %. %- -- print infinitely many dashes.
5282 Decimal digits after the % specify field width to which to pad. */);
5284 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
5285 doc
: /* *Major mode for new buffers. Defaults to `fundamental-mode'.
5286 nil here means use current buffer's major mode. */);
5288 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
5289 make_number (Lisp_Symbol
),
5290 doc
: /* Symbol for current buffer's major mode. */);
5292 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
5294 doc
: /* Pretty name of current buffer's major mode (a string). */);
5296 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
5297 doc
: /* Non-nil turns on automatic expansion of abbrevs as they are inserted. */);
5299 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
5301 doc
: /* *Non-nil if searches and matches should ignore case. */);
5303 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
5304 make_number (Lisp_Int
),
5305 doc
: /* *Column beyond which automatic line-wrapping should happen. */);
5307 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
5308 make_number (Lisp_Int
),
5309 doc
: /* *Column for the default indent-line-function to indent to.
5310 Linefeed indents to this column in Fundamental mode. */);
5312 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
5313 make_number (Lisp_Int
),
5314 doc
: /* *Distance between tab stops (for display of tab characters), in columns. */);
5316 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
5317 doc
: /* *Non-nil means display control chars with uparrow.
5318 A value of nil means use backslash and octal digits.
5319 This variable does not apply to characters whose display is specified
5320 in the current display table (if there is one). */);
5322 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5323 ¤t_buffer
->enable_multibyte_characters
,
5325 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5326 Otherwise they are regarded as unibyte. This affects the display,
5327 file I/O and the behavior of various editing commands.
5329 This variable is buffer-local but you cannot set it directly;
5330 use the function `set-buffer-multibyte' to change a buffer's representation.
5331 Changing its default value with `setq-default' is supported.
5332 See also variable `default-enable-multibyte-characters' and Info node
5333 `(elisp)Text Representations'. */);
5335 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5336 ¤t_buffer
->buffer_file_coding_system
, Qnil
,
5337 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5338 This variable applies to saving the buffer, and also to `write-region'
5339 and other functions that use `write-region'.
5340 It does not apply to sending output to subprocesses, however.
5342 If this is nil, the buffer is saved without any code conversion
5343 unless some coding system is specified in `file-coding-system-alist'
5344 for the buffer file.
5346 If the text to be saved cannot be encoded as specified by this variable,
5347 an alternative encoding is selected by `select-safe-coding-system', which see.
5349 The variable `coding-system-for-write', if non-nil, overrides this variable.
5351 This variable is never applied to a way of decoding a file while reading it. */);
5353 DEFVAR_PER_BUFFER ("direction-reversed", ¤t_buffer
->direction_reversed
,
5355 doc
: /* *Non-nil means lines in the buffer are displayed right to left. */);
5357 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
5358 doc
: /* *Non-nil means do not display continuation lines.
5359 Instead, give each line of text just one screen line.
5361 Note that this is overridden by the variable
5362 `truncate-partial-width-windows' if that variable is non-nil
5363 and this buffer is not full-frame width. */);
5366 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
5368 doc
: /* Non-nil if the visited file is a binary file.
5369 This variable is meaningful on MS-DOG and Windows NT.
5370 On those systems, it is automatically local in every buffer.
5371 On other systems, this variable is normally always nil. */);
5374 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
5375 make_number (Lisp_String
),
5376 doc
: /* Name of default directory of current buffer. Should end with slash.
5377 To interactively change the default directory, use command `cd'. */);
5379 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
5381 doc
: /* Function called (if non-nil) to perform auto-fill.
5382 It is called after self-inserting any character specified in
5383 the `auto-fill-chars' table.
5384 NOTE: This variable is not a hook;
5385 its value may not be a list of functions. */);
5387 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
5388 make_number (Lisp_String
),
5389 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5391 DEFVAR_PER_BUFFER ("buffer-file-truename", ¤t_buffer
->file_truename
,
5392 make_number (Lisp_String
),
5393 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5394 The truename of a file is calculated by `file-truename'
5395 and then abbreviated with `abbreviate-file-name'. */);
5397 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5398 ¤t_buffer
->auto_save_file_name
,
5399 make_number (Lisp_String
),
5400 doc
: /* Name of file for auto-saving current buffer.
5401 If it is nil, that means don't auto-save this buffer. */);
5403 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
5404 doc
: /* Non-nil if this buffer is read-only. */);
5406 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
5407 doc
: /* Non-nil if this buffer's file has been backed up.
5408 Backing up is done before the first time the file is saved. */);
5410 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
5411 make_number (Lisp_Int
),
5412 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5415 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
5417 doc
: /* Non-nil enables selective display.
5418 An Integer N as value means display only lines
5419 that start with less than n columns of space.
5420 A value of t means that the character ^M makes itself and
5421 all the rest of the line invisible; also, when saving the buffer
5422 in a file, save the ^M as a newline. */);
5425 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5426 ¤t_buffer
->selective_display_ellipses
,
5428 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5431 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
5432 doc
: /* Non-nil if self-insertion should replace existing text.
5433 The value should be one of `overwrite-mode-textual',
5434 `overwrite-mode-binary', or nil.
5435 If it is `overwrite-mode-textual', self-insertion still
5436 inserts at the end of a line, and inserts when point is before a tab,
5437 until the tab is filled in.
5438 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5440 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
5442 doc
: /* Display table that controls display of the contents of current buffer.
5444 If this variable is nil, the value of `standard-display-table' is used.
5445 Each window can have its own, overriding display table, see
5446 `set-window-display-table' and `window-display-table'.
5448 The display table is a char-table created with `make-display-table'.
5449 A char-table is an array indexed by character codes. Normal array
5450 primitives `aref' and `aset' can be used to access elements of a char-table.
5452 Each of the char-table elements control how to display the corresponding
5453 text character: the element at index C in the table says how to display
5454 the character whose code is C. Each element should be a vector of
5455 characters or nil. nil means display the character in the default fashion;
5456 otherwise, the characters from the vector are delivered to the screen
5457 instead of the original character.
5459 For example, (aset buffer-display-table ?X ?Y) will cause Emacs to display
5460 a capital Y instead of each X character.
5462 In addition, a char-table has six extra slots to control the display of:
5464 the end of a truncated screen line (extra-slot 0, a single character);
5465 the end of a continued line (extra-slot 1, a single character);
5466 the escape character used to display character codes in octal
5467 (extra-slot 2, a single character);
5468 the character used as an arrow for control characters (extra-slot 3,
5469 a single character);
5470 the decoration indicating the presence of invisible lines (extra-slot 4,
5471 a vector of characters);
5472 the character used to draw the border between side-by-side windows
5473 (extra-slot 5, a single character).
5475 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5477 DEFVAR_PER_BUFFER ("left-margin-width", ¤t_buffer
->left_margin_width
,
5479 doc
: /* *Width of left marginal area for display of a buffer.
5480 A value of nil means no marginal area. */);
5482 DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer
->right_margin_width
,
5484 doc
: /* *Width of right marginal area for display of a buffer.
5485 A value of nil means no marginal area. */);
5487 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5488 ¤t_buffer
->indicate_empty_lines
, Qnil
,
5489 doc
: /* *Visually indicate empty lines after the buffer end.
5490 If non-nil, a bitmap is displayed in the left fringe of a window on
5491 window-systems. */);
5493 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5494 ¤t_buffer
->scroll_up_aggressively
, Qnil
,
5495 doc
: /* *If a number, scroll display up aggressively.
5496 If scrolling a window because point is below the window end, choose
5497 a new window start so that point ends up that fraction of the window's
5498 height from the bottom of the window. */);
5500 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
5501 ¤t_buffer
->scroll_down_aggressively
, Qnil
,
5502 doc
: /* *If a number, scroll display down aggressively.
5503 If scrolling a window because point is above the window start, choose
5504 a new window start so that point ends up that fraction of the window's
5505 height from the top of the window. */);
5507 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
5511 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
5512 doc
: /* List of functions to call before each text change.
5513 Two arguments are passed to each function: the positions of
5514 the beginning and end of the range of old text to be changed.
5515 \(For an insertion, the beginning and end are at the same place.)
5516 No information is given about the length of the text after the change.
5518 Buffer changes made while executing the `before-change-functions'
5519 don't call any before-change or after-change functions.
5520 That's because these variables are temporarily set to nil.
5521 As a result, a hook function cannot straightforwardly alter the value of
5522 these variables. See the Emacs Lisp manual for a way of
5523 accomplishing an equivalent result by using other variables.
5525 If an unhandled error happens in running these functions,
5526 the variable's value remains nil. That prevents the error
5527 from happening repeatedly and making Emacs nonfunctional. */);
5528 Vbefore_change_functions
= Qnil
;
5530 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
5531 doc
: /* List of functions to call after each text change.
5532 Three arguments are passed to each function: the positions of
5533 the beginning and end of the range of changed text,
5534 and the length in bytes of the pre-change text replaced by that range.
5535 \(For an insertion, the pre-change length is zero;
5536 for a deletion, that length is the number of bytes deleted,
5537 and the post-change beginning and end are at the same place.)
5539 Buffer changes made while executing the `after-change-functions'
5540 don't call any before-change or after-change functions.
5541 That's because these variables are temporarily set to nil.
5542 As a result, a hook function cannot straightforwardly alter the value of
5543 these variables. See the Emacs Lisp manual for a way of
5544 accomplishing an equivalent result by using other variables.
5546 If an unhandled error happens in running these functions,
5547 the variable's value remains nil. That prevents the error
5548 from happening repeatedly and making Emacs nonfunctional. */);
5549 Vafter_change_functions
= Qnil
;
5551 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
5552 doc
: /* A list of functions to call before changing a buffer which is unmodified.
5553 The functions are run using the `run-hooks' function. */);
5554 Vfirst_change_hook
= Qnil
;
5556 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
5557 doc
: /* List of undo entries in current buffer.
5558 Recent changes come first; older changes follow newer.
5560 An entry (BEG . END) represents an insertion which begins at
5561 position BEG and ends at position END.
5563 An entry (TEXT . POSITION) represents the deletion of the string TEXT
5564 from (abs POSITION). If POSITION is positive, point was at the front
5565 of the text being deleted; if negative, point was at the end.
5567 An entry (t HIGH . LOW) indicates that the buffer previously had
5568 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions
5569 of the visited file's modification time, as of that time. If the
5570 modification time of the most recent save is different, this entry is
5573 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
5574 was modified between BEG and END. PROPERTY is the property name,
5575 and VALUE is the old value.
5577 An entry (MARKER . DISTANCE) indicates that the marker MARKER
5578 was adjusted in position by the offset DISTANCE (an integer).
5580 An entry of the form POSITION indicates that point was at the buffer
5581 location given by the integer. Undoing an entry of this form places
5584 nil marks undo boundaries. The undo command treats the changes
5585 between two undo boundaries as a single step to be undone.
5587 If the value of the variable is t, undo information is not recorded. */);
5589 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
5590 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
5592 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
5593 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
5595 Normally, the line-motion functions work by scanning the buffer for
5596 newlines. Columnar operations (like move-to-column and
5597 compute-motion) also work by scanning the buffer, summing character
5598 widths as they go. This works well for ordinary text, but if the
5599 buffer's lines are very long (say, more than 500 characters), these
5600 motion functions will take longer to execute. Emacs may also take
5601 longer to update the display.
5603 If cache-long-line-scans is non-nil, these motion functions cache the
5604 results of their scans, and consult the cache to avoid rescanning
5605 regions of the buffer until the text is modified. The caches are most
5606 beneficial when they prevent the most searching---that is, when the
5607 buffer contains long lines and large regions of characters with the
5608 same, fixed screen width.
5610 When cache-long-line-scans is non-nil, processing short lines will
5611 become slightly slower (because of the overhead of consulting the
5612 cache), and the caches will use memory roughly proportional to the
5613 number of newlines and characters whose screen width varies.
5615 The caches require no explicit maintenance; their accuracy is
5616 maintained internally by the Emacs primitives. Enabling or disabling
5617 the cache should not affect the behavior of any of the motion
5618 functions; it should only affect their performance. */);
5620 DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer
->point_before_scroll
, Qnil
,
5621 doc
: /* Value of point before the last series of scroll operations, or nil. */);
5623 DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer
->file_format
, Qnil
,
5624 doc
: /* List of formats to use when saving this buffer.
5625 Formats are defined by `format-alist'. This variable is
5626 set when a file is visited. Automatically local in all buffers. */);
5628 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
5629 ¤t_buffer
->invisibility_spec
, Qnil
,
5630 doc
: /* Invisibility spec of this buffer.
5631 The default is t, which means that text is invisible
5632 if it has a non-nil `invisible' property.
5633 If the value is a list, a text character is invisible if its `invisible'
5634 property is an element in that list.
5635 If an element is a cons cell of the form (PROP . ELLIPSIS),
5636 then characters with property value PROP are invisible,
5637 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
5639 DEFVAR_PER_BUFFER ("buffer-display-count",
5640 ¤t_buffer
->display_count
, Qnil
,
5641 doc
: /* A number incremented each time this buffer is displayed in a window.
5642 The function `set-window-buffer' increments it. */);
5644 DEFVAR_PER_BUFFER ("buffer-display-time",
5645 ¤t_buffer
->display_time
, Qnil
,
5646 doc
: /* Time stamp updated each time this buffer is displayed in a window.
5647 The function `set-window-buffer' updates this variable
5648 to the value obtained by calling `current-time'.
5649 If the buffer has never been shown in a window, the value is nil. */);
5651 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
5652 doc
: /* *Non-nil means deactivate the mark when the buffer contents change.
5653 Non-nil also enables highlighting of the region whenever the mark is active.
5654 The variable `highlight-nonselected-windows' controls whether to highlight
5655 all windows or just the selected window. */);
5656 Vtransient_mark_mode
= Qnil
;
5658 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
5659 doc
: /* *Non-nil means disregard read-only status of buffers or characters.
5660 If the value is t, disregard `buffer-read-only' and all `read-only'
5661 text properties. If the value is a list, disregard `buffer-read-only'
5662 and disregard a `read-only' text property if the property value
5663 is a member of the list. */);
5664 Vinhibit_read_only
= Qnil
;
5666 DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer
->cursor_type
, Qnil
,
5667 doc
: /* Cursor to use when this buffer is in the selected window.
5668 Values are interpreted as follows:
5670 t use the cursor specified for the frame
5671 nil don't display a cursor
5672 bar display a bar cursor with default width
5673 (bar . WIDTH) display a bar cursor with width WIDTH
5674 ANYTHING ELSE display a box cursor.
5676 When the buffer is displayed in a nonselected window,
5677 this variable has no effect; the cursor appears as a hollow box. */);
5679 DEFVAR_PER_BUFFER ("line-spacing",
5680 ¤t_buffer
->extra_line_spacing
, Qnil
,
5681 doc
: /* Additional space to put between lines when displaying a buffer.
5682 The space is measured in pixels, and put below lines on window systems. */);
5684 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
5685 doc
: /* List of functions called with no args to query before killing a buffer. */);
5686 Vkill_buffer_query_functions
= Qnil
;
5688 defsubr (&Sbuffer_live_p
);
5689 defsubr (&Sbuffer_list
);
5690 defsubr (&Sget_buffer
);
5691 defsubr (&Sget_file_buffer
);
5692 defsubr (&Sget_buffer_create
);
5693 defsubr (&Smake_indirect_buffer
);
5694 defsubr (&Sgenerate_new_buffer_name
);
5695 defsubr (&Sbuffer_name
);
5696 /*defsubr (&Sbuffer_number);*/
5697 defsubr (&Sbuffer_file_name
);
5698 defsubr (&Sbuffer_base_buffer
);
5699 defsubr (&Sbuffer_local_value
);
5700 defsubr (&Sbuffer_local_variables
);
5701 defsubr (&Sbuffer_modified_p
);
5702 defsubr (&Sset_buffer_modified_p
);
5703 defsubr (&Sbuffer_modified_tick
);
5704 defsubr (&Srename_buffer
);
5705 defsubr (&Sother_buffer
);
5706 defsubr (&Sbuffer_disable_undo
);
5707 defsubr (&Sbuffer_enable_undo
);
5708 defsubr (&Skill_buffer
);
5709 defsubr (&Sset_buffer_major_mode
);
5710 defsubr (&Sswitch_to_buffer
);
5711 defsubr (&Spop_to_buffer
);
5712 defsubr (&Scurrent_buffer
);
5713 defsubr (&Sset_buffer
);
5714 defsubr (&Sbarf_if_buffer_read_only
);
5715 defsubr (&Sbury_buffer
);
5716 defsubr (&Serase_buffer
);
5717 defsubr (&Sset_buffer_multibyte
);
5718 defsubr (&Skill_all_local_variables
);
5720 defsubr (&Soverlayp
);
5721 defsubr (&Smake_overlay
);
5722 defsubr (&Sdelete_overlay
);
5723 defsubr (&Smove_overlay
);
5724 defsubr (&Soverlay_start
);
5725 defsubr (&Soverlay_end
);
5726 defsubr (&Soverlay_buffer
);
5727 defsubr (&Soverlay_properties
);
5728 defsubr (&Soverlays_at
);
5729 defsubr (&Soverlays_in
);
5730 defsubr (&Snext_overlay_change
);
5731 defsubr (&Sprevious_overlay_change
);
5732 defsubr (&Soverlay_recenter
);
5733 defsubr (&Soverlay_lists
);
5734 defsubr (&Soverlay_get
);
5735 defsubr (&Soverlay_put
);
5736 defsubr (&Srestore_buffer_modified_p
);
5742 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
5743 initial_define_key (control_x_map
, 'k', "kill-buffer");
5745 /* This must not be in syms_of_buffer, because Qdisabled is not
5746 initialized when that function gets called. */
5747 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);