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 that frame's buffer list. */)
216 Lisp_Object framelist
, general
;
217 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
225 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
227 /* Remove from GENERAL any buffer that duplicates one in FRAMELIST. */
229 while (! NILP (tail
))
231 general
= Fdelq (XCAR (tail
), general
);
234 return nconc2 (framelist
, general
);
240 /* Like Fassoc, but use Fstring_equal to compare
241 (which ignores text properties),
242 and don't ever QUIT. */
245 assoc_ignore_text_properties (key
, list
)
246 register Lisp_Object key
;
249 register Lisp_Object tail
;
250 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
252 register Lisp_Object elt
, tem
;
254 tem
= Fstring_equal (Fcar (elt
), key
);
261 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
262 doc
: /* Return the buffer named NAME (a string).
263 If there is no live buffer named NAME, return nil.
264 NAME may also be a buffer; if so, the value is that buffer. */)
266 register Lisp_Object name
;
272 return Fcdr (assoc_ignore_text_properties (name
, Vbuffer_alist
));
275 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
276 doc
: /* Return the buffer visiting file FILENAME (a string).
277 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
278 If there is no such live buffer, return nil.
279 See also `find-buffer-visiting'. */)
281 register Lisp_Object filename
;
283 register Lisp_Object tail
, buf
, tem
;
286 CHECK_STRING (filename
);
287 filename
= Fexpand_file_name (filename
, Qnil
);
289 /* If the file name has special constructs in it,
290 call the corresponding file handler. */
291 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
293 return call2 (handler
, Qget_file_buffer
, filename
);
295 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
297 buf
= Fcdr (XCAR (tail
));
298 if (!BUFFERP (buf
)) continue;
299 if (!STRINGP (XBUFFER (buf
)->filename
)) continue;
300 tem
= Fstring_equal (XBUFFER (buf
)->filename
, filename
);
308 get_truename_buffer (filename
)
309 register Lisp_Object filename
;
311 register Lisp_Object tail
, buf
, tem
;
313 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
315 buf
= Fcdr (XCAR (tail
));
316 if (!BUFFERP (buf
)) continue;
317 if (!STRINGP (XBUFFER (buf
)->file_truename
)) continue;
318 tem
= Fstring_equal (XBUFFER (buf
)->file_truename
, filename
);
325 /* Incremented for each buffer created, to assign the buffer number. */
328 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
329 doc
: /* Return the buffer named NAME, or create such a buffer and return it.
330 A new buffer is created if there is no live buffer named NAME.
331 If NAME starts with a space, the new buffer does not keep undo information.
332 If NAME is a buffer instead of a string, then it is the value returned.
333 The value is never nil. */)
335 register Lisp_Object name
;
337 register Lisp_Object buf
;
338 register struct buffer
*b
;
340 buf
= Fget_buffer (name
);
344 if (SCHARS (name
) == 0)
345 error ("Empty string for buffer name is not allowed");
347 b
= (struct buffer
*) allocate_buffer ();
349 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
351 /* An ordinary buffer uses its own struct buffer_text. */
352 b
->text
= &b
->own_text
;
355 BUF_GAP_SIZE (b
) = 20;
357 /* We allocate extra 1-byte at the tail and keep it always '\0' for
358 anchoring a search. */
359 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
361 if (! BUF_BEG_ADDR (b
))
362 buffer_memory_full ();
370 BUF_GPT_BYTE (b
) = 1;
371 BUF_BEGV_BYTE (b
) = 1;
375 BUF_OVERLAY_MODIFF (b
) = 1;
376 BUF_SAVE_MODIFF (b
) = 1;
377 BUF_INTERVALS (b
) = 0;
378 BUF_UNCHANGED_MODIFIED (b
) = 1;
379 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
380 BUF_END_UNCHANGED (b
) = 0;
381 BUF_BEG_UNCHANGED (b
) = 0;
382 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
384 b
->newline_cache
= 0;
385 b
->width_run_cache
= 0;
386 b
->width_table
= Qnil
;
387 b
->prevent_redisplay_optimizations_p
= 1;
389 /* Put this on the chain of all buffers including killed ones. */
390 b
->next
= all_buffers
;
393 /* An ordinary buffer normally doesn't need markers
394 to handle BEGV and ZV. */
396 b
->begv_marker
= Qnil
;
399 name
= Fcopy_sequence (name
);
400 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
403 if (SREF (name
, 0) != ' ')
409 reset_buffer_local_variables (b
, 1);
411 /* Put this in the alist of all live buffers. */
413 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
415 b
->mark
= Fmake_marker ();
416 BUF_MARKERS (b
) = Qnil
;
422 /* Return a list of overlays which is a copy of the overlay list
423 LIST, but for buffer B. */
426 copy_overlays (b
, list
)
430 Lisp_Object result
, buffer
;
432 XSETBUFFER (buffer
, b
);
434 for (result
= Qnil
; CONSP (list
); list
= XCDR (list
))
436 Lisp_Object overlay
, start
, end
, old_overlay
;
439 old_overlay
= XCAR (list
);
440 charpos
= marker_position (OVERLAY_START (old_overlay
));
441 start
= Fmake_marker ();
442 Fset_marker (start
, make_number (charpos
), buffer
);
443 XMARKER (start
)->insertion_type
444 = XMARKER (OVERLAY_START (old_overlay
))->insertion_type
;
446 charpos
= marker_position (OVERLAY_END (old_overlay
));
447 end
= Fmake_marker ();
448 Fset_marker (end
, make_number (charpos
), buffer
);
449 XMARKER (end
)->insertion_type
450 = XMARKER (OVERLAY_END (old_overlay
))->insertion_type
;
452 overlay
= allocate_misc ();
453 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
454 OVERLAY_START (overlay
) = start
;
455 OVERLAY_END (overlay
) = end
;
456 OVERLAY_PLIST (overlay
) = Fcopy_sequence (OVERLAY_PLIST (old_overlay
));
458 result
= Fcons (overlay
, result
);
461 return Fnreverse (result
);
465 /* Clone per-buffer values of buffer FROM.
467 Buffer TO gets the same per-buffer values as FROM, with the
468 following exceptions: (1) TO's name is left untouched, (2) markers
469 are copied and made to refer to TO, and (3) overlay lists are
473 clone_per_buffer_values (from
, to
)
474 struct buffer
*from
, *to
;
476 Lisp_Object to_buffer
;
479 XSETBUFFER (to_buffer
, to
);
481 for (offset
= PER_BUFFER_VAR_OFFSET (name
) + sizeof (Lisp_Object
);
483 offset
+= sizeof (Lisp_Object
))
487 obj
= PER_BUFFER_VALUE (from
, offset
);
490 struct Lisp_Marker
*m
= XMARKER (obj
);
491 obj
= Fmake_marker ();
492 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
493 set_marker_both (obj
, to_buffer
, m
->charpos
, m
->bytepos
);
496 PER_BUFFER_VALUE (to
, offset
) = obj
;
499 bcopy (from
->local_flags
, to
->local_flags
, sizeof to
->local_flags
);
501 to
->overlays_before
= copy_overlays (to
, from
->overlays_before
);
502 to
->overlays_after
= copy_overlays (to
, from
->overlays_after
);
506 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
508 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
509 doc
: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
510 BASE-BUFFER should be an existing buffer (or buffer name).
511 NAME should be a string which is not the name of an existing buffer.
512 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
513 such as major and minor modes, in the indirect buffer.
514 CLONE nil means the indirect buffer's state is reset to default values. */)
515 (base_buffer
, name
, clone
)
516 Lisp_Object base_buffer
, name
, clone
;
521 buf
= Fget_buffer (name
);
523 error ("Buffer name `%s' is in use", SDATA (name
));
525 base_buffer
= Fget_buffer (base_buffer
);
526 if (NILP (base_buffer
))
527 error ("No such buffer: `%s'", SDATA (name
));
529 if (SCHARS (name
) == 0)
530 error ("Empty string for buffer name is not allowed");
532 b
= (struct buffer
*) allocate_buffer ();
533 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
535 if (XBUFFER (base_buffer
)->base_buffer
)
536 b
->base_buffer
= XBUFFER (base_buffer
)->base_buffer
;
538 b
->base_buffer
= XBUFFER (base_buffer
);
540 /* Use the base buffer's text object. */
541 b
->text
= b
->base_buffer
->text
;
543 BUF_BEGV (b
) = BUF_BEGV (b
->base_buffer
);
544 BUF_ZV (b
) = BUF_ZV (b
->base_buffer
);
545 BUF_PT (b
) = BUF_PT (b
->base_buffer
);
546 BUF_BEGV_BYTE (b
) = BUF_BEGV_BYTE (b
->base_buffer
);
547 BUF_ZV_BYTE (b
) = BUF_ZV_BYTE (b
->base_buffer
);
548 BUF_PT_BYTE (b
) = BUF_PT_BYTE (b
->base_buffer
);
550 b
->newline_cache
= 0;
551 b
->width_run_cache
= 0;
552 b
->width_table
= Qnil
;
554 /* Put this on the chain of all buffers including killed ones. */
555 b
->next
= all_buffers
;
558 name
= Fcopy_sequence (name
);
559 STRING_SET_INTERVALS (name
, NULL_INTERVAL
);
563 reset_buffer_local_variables (b
, 1);
565 /* Put this in the alist of all live buffers. */
567 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
569 b
->mark
= Fmake_marker ();
572 /* The multibyte status belongs to the base buffer. */
573 b
->enable_multibyte_characters
= b
->base_buffer
->enable_multibyte_characters
;
575 /* Make sure the base buffer has markers for its narrowing. */
576 if (NILP (b
->base_buffer
->pt_marker
))
578 b
->base_buffer
->pt_marker
= Fmake_marker ();
579 set_marker_both (b
->base_buffer
->pt_marker
, base_buffer
,
580 BUF_PT (b
->base_buffer
),
581 BUF_PT_BYTE (b
->base_buffer
));
583 if (NILP (b
->base_buffer
->begv_marker
))
585 b
->base_buffer
->begv_marker
= Fmake_marker ();
586 set_marker_both (b
->base_buffer
->begv_marker
, base_buffer
,
587 BUF_BEGV (b
->base_buffer
),
588 BUF_BEGV_BYTE (b
->base_buffer
));
590 if (NILP (b
->base_buffer
->zv_marker
))
592 b
->base_buffer
->zv_marker
= Fmake_marker ();
593 set_marker_both (b
->base_buffer
->zv_marker
, base_buffer
,
594 BUF_ZV (b
->base_buffer
),
595 BUF_ZV_BYTE (b
->base_buffer
));
596 XMARKER (b
->base_buffer
->zv_marker
)->insertion_type
= 1;
601 /* Give the indirect buffer markers for its narrowing. */
602 b
->pt_marker
= Fmake_marker ();
603 set_marker_both (b
->pt_marker
, buf
, BUF_PT (b
), BUF_PT_BYTE (b
));
604 b
->begv_marker
= Fmake_marker ();
605 set_marker_both (b
->begv_marker
, buf
, BUF_BEGV (b
), BUF_BEGV_BYTE (b
));
606 b
->zv_marker
= Fmake_marker ();
607 set_marker_both (b
->zv_marker
, buf
, BUF_ZV (b
), BUF_ZV_BYTE (b
));
608 XMARKER (b
->zv_marker
)->insertion_type
= 1;
611 clone_per_buffer_values (b
->base_buffer
, b
);
616 /* Reinitialize everything about a buffer except its name and contents
617 and local variables. */
621 register struct buffer
*b
;
624 b
->file_truename
= Qnil
;
625 b
->directory
= (current_buffer
) ? current_buffer
->directory
: Qnil
;
627 XSETFASTINT (b
->save_length
, 0);
628 b
->last_window_start
= 1;
629 /* It is more conservative to start out "changed" than "unchanged". */
631 b
->prevent_redisplay_optimizations_p
= 1;
633 b
->auto_save_modified
= 0;
634 b
->auto_save_failure_time
= -1;
635 b
->auto_save_file_name
= Qnil
;
637 b
->overlays_before
= Qnil
;
638 b
->overlays_after
= Qnil
;
639 XSETFASTINT (b
->overlay_center
, 1);
640 b
->mark_active
= Qnil
;
641 b
->point_before_scroll
= Qnil
;
642 b
->file_format
= Qnil
;
643 b
->last_selected_window
= Qnil
;
644 XSETINT (b
->display_count
, 0);
645 b
->display_time
= Qnil
;
646 b
->enable_multibyte_characters
= buffer_defaults
.enable_multibyte_characters
;
647 b
->cursor_type
= buffer_defaults
.cursor_type
;
648 b
->extra_line_spacing
= buffer_defaults
.extra_line_spacing
;
650 b
->display_error_modiff
= 0;
653 /* Reset buffer B's local variables info.
654 Don't use this on a buffer that has already been in use;
655 it does not treat permanent locals consistently.
656 Instead, use Fkill_all_local_variables.
658 If PERMANENT_TOO is 1, then we reset permanent built-in
659 buffer-local variables. If PERMANENT_TOO is 0,
660 we preserve those. */
663 reset_buffer_local_variables (b
, permanent_too
)
664 register struct buffer
*b
;
670 /* Reset the major mode to Fundamental, together with all the
671 things that depend on the major mode.
672 default-major-mode is handled at a higher level.
673 We ignore it here. */
674 b
->major_mode
= Qfundamental_mode
;
676 b
->abbrev_table
= Vfundamental_mode_abbrev_table
;
677 b
->mode_name
= QSFundamental
;
678 b
->minor_modes
= Qnil
;
680 /* If the standard case table has been altered and invalidated,
681 fix up its insides first. */
682 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
683 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
684 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
685 Fset_standard_case_table (Vascii_downcase_table
);
687 b
->downcase_table
= Vascii_downcase_table
;
688 b
->upcase_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
689 b
->case_canon_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
690 b
->case_eqv_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
691 b
->invisibility_spec
= Qt
;
693 b
->buffer_file_type
= Qnil
;
696 /* Reset all (or most) per-buffer variables to their defaults. */
697 b
->local_var_alist
= Qnil
;
698 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
699 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
700 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
702 /* For each slot that has a default value,
703 copy that into the slot. */
705 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
707 offset
+= sizeof (Lisp_Object
))
709 int idx
= PER_BUFFER_IDX (offset
);
712 || buffer_permanent_local_flags
[idx
] == 0))
713 /* Is -2 used anywhere? */
715 PER_BUFFER_VALUE (b
, offset
) = PER_BUFFER_DEFAULT (offset
);
719 /* We split this away from generate-new-buffer, because rename-buffer
720 and set-visited-file-name ought to be able to use this to really
721 rename the buffer properly. */
723 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
725 doc
: /* Return a string that is the name of no existing buffer based on NAME.
726 If there is no live buffer named NAME, then return NAME.
727 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
728 until an unused name is found, and then return that name.
729 Optional second argument IGNORE specifies a name that is okay to use
730 \(if it is in the sequence to be tried)
731 even if a buffer with that name exists. */)
733 register Lisp_Object name
, ignore
;
735 register Lisp_Object gentemp
, tem
;
741 tem
= Fget_buffer (name
);
748 sprintf (number
, "<%d>", ++count
);
749 gentemp
= concat2 (name
, build_string (number
));
750 tem
= Fstring_equal (gentemp
, ignore
);
753 tem
= Fget_buffer (gentemp
);
760 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
761 doc
: /* Return the name of BUFFER, as a string.
762 With no argument or nil as argument, return the name of the current buffer. */)
764 register Lisp_Object buffer
;
767 return current_buffer
->name
;
768 CHECK_BUFFER (buffer
);
769 return XBUFFER (buffer
)->name
;
772 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
773 doc
: /* Return name of file BUFFER is visiting, or nil if none.
774 No argument or nil as argument means use the current buffer. */)
776 register Lisp_Object buffer
;
779 return current_buffer
->filename
;
780 CHECK_BUFFER (buffer
);
781 return XBUFFER (buffer
)->filename
;
784 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
786 doc
: /* Return the base buffer of indirect buffer BUFFER.
787 If BUFFER is not indirect, return nil. */)
789 register Lisp_Object buffer
;
792 Lisp_Object base_buffer
;
795 base
= current_buffer
->base_buffer
;
798 CHECK_BUFFER (buffer
);
799 base
= XBUFFER (buffer
)->base_buffer
;
804 XSETBUFFER (base_buffer
, base
);
808 DEFUN ("buffer-local-value", Fbuffer_local_value
,
809 Sbuffer_local_value
, 2, 2, 0,
810 doc
: /* Return the value of VARIABLE in BUFFER.
811 If VARIABLE does not have a buffer-local binding in BUFFER, the value
812 is the default binding of variable. */)
814 register Lisp_Object symbol
;
815 register Lisp_Object buffer
;
817 register struct buffer
*buf
;
818 register Lisp_Object result
;
820 CHECK_SYMBOL (symbol
);
821 CHECK_BUFFER (buffer
);
822 buf
= XBUFFER (buffer
);
824 /* Look in local_var_list */
825 result
= Fassoc (symbol
, buf
->local_var_alist
);
831 /* Look in special slots */
832 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
833 offset
< sizeof (struct buffer
);
834 /* sizeof EMACS_INT == sizeof Lisp_Object */
835 offset
+= (sizeof (EMACS_INT
)))
837 idx
= PER_BUFFER_IDX (offset
);
838 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
839 && SYMBOLP (PER_BUFFER_SYMBOL (offset
))
840 && EQ (PER_BUFFER_SYMBOL (offset
), symbol
))
842 result
= PER_BUFFER_VALUE (buf
, offset
);
849 result
= Fdefault_value (symbol
);
853 Lisp_Object valcontents
;
854 Lisp_Object current_alist_element
;
856 /* What binding is loaded right now? */
857 valcontents
= SYMBOL_VALUE (symbol
);
858 current_alist_element
859 = XCAR (XBUFFER_LOCAL_VALUE (valcontents
)->cdr
);
861 /* The value of the currently loaded binding is not
862 stored in it, but rather in the realvalue slot.
863 Store that value into the binding it belongs to
864 in case that is the one we are about to use. */
866 Fsetcdr (current_alist_element
,
867 do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
));
869 /* Now get the (perhaps updated) value out of the binding. */
870 result
= XCDR (result
);
873 if (EQ (result
, Qunbound
))
874 return Fsignal (Qvoid_variable
, Fcons (symbol
, Qnil
));
879 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
880 Sbuffer_local_variables
, 0, 1, 0,
881 doc
: /* Return an alist of variables that are buffer-local in BUFFER.
882 Most elements look like (SYMBOL . VALUE), describing one variable.
883 For a symbol that is locally unbound, just the symbol appears in the value.
884 Note that storing new VALUEs in these elements doesn't change the variables.
885 No argument or nil as argument means use current buffer as BUFFER. */)
887 register Lisp_Object buffer
;
889 register struct buffer
*buf
;
890 register Lisp_Object result
;
893 buf
= current_buffer
;
896 CHECK_BUFFER (buffer
);
897 buf
= XBUFFER (buffer
);
903 register Lisp_Object tail
;
904 for (tail
= buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
906 Lisp_Object val
, elt
;
910 /* Reference each variable in the alist in buf.
911 If inquiring about the current buffer, this gets the current values,
912 so store them into the alist so the alist is up to date.
913 If inquiring about some other buffer, this swaps out any values
914 for that buffer, making the alist up to date automatically. */
915 val
= find_symbol_value (XCAR (elt
));
916 /* Use the current buffer value only if buf is the current buffer. */
917 if (buf
!= current_buffer
)
920 /* If symbol is unbound, put just the symbol in the list. */
921 if (EQ (val
, Qunbound
))
922 result
= Fcons (XCAR (elt
), result
);
923 /* Otherwise, put (symbol . value) in the list. */
925 result
= Fcons (Fcons (XCAR (elt
), val
), result
);
929 /* Add on all the variables stored in special slots. */
933 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
934 offset
< sizeof (struct buffer
);
935 /* sizeof EMACS_INT == sizeof Lisp_Object */
936 offset
+= (sizeof (EMACS_INT
)))
938 idx
= PER_BUFFER_IDX (offset
);
939 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
940 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
941 result
= Fcons (Fcons (PER_BUFFER_SYMBOL (offset
),
942 PER_BUFFER_VALUE (buf
, offset
)),
951 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
953 doc
: /* Return t if BUFFER was modified since its file was last read or saved.
954 No argument or nil as argument means use current buffer as BUFFER. */)
956 register Lisp_Object buffer
;
958 register struct buffer
*buf
;
960 buf
= current_buffer
;
963 CHECK_BUFFER (buffer
);
964 buf
= XBUFFER (buffer
);
967 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
970 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
972 doc
: /* Mark current buffer as modified or unmodified according to FLAG.
973 A non-nil FLAG means mark the buffer modified. */)
975 register Lisp_Object flag
;
977 register int already
;
978 register Lisp_Object fn
;
979 Lisp_Object buffer
, window
;
981 #ifdef CLASH_DETECTION
982 /* If buffer becoming modified, lock the file.
983 If buffer becoming unmodified, unlock the file. */
985 fn
= current_buffer
->file_truename
;
986 /* Test buffer-file-name so that binding it to nil is effective. */
987 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
989 already
= SAVE_MODIFF
< MODIFF
;
990 if (!already
&& !NILP (flag
))
992 else if (already
&& NILP (flag
))
995 #endif /* CLASH_DETECTION */
997 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
999 /* Set update_mode_lines only if buffer is displayed in some window.
1000 Packages like jit-lock or lazy-lock preserve a buffer's modified
1001 state by recording/restoring the state around blocks of code.
1002 Setting update_mode_lines makes redisplay consider all windows
1003 (on all frames). Stealth fontification of buffers not displayed
1004 would incur additional redisplay costs if we'd set
1005 update_modes_lines unconditionally.
1007 Ideally, I think there should be another mechanism for fontifying
1008 buffers without "modifying" buffers, or redisplay should be
1009 smarter about updating the `*' in mode lines. --gerd */
1010 XSETBUFFER (buffer
, current_buffer
);
1011 window
= Fget_buffer_window (buffer
, Qt
);
1012 if (WINDOWP (window
))
1014 ++update_mode_lines
;
1015 current_buffer
->prevent_redisplay_optimizations_p
= 1;
1021 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
1022 Srestore_buffer_modified_p
, 1, 1, 0,
1023 doc
: /* Like `set-buffer-modified-p', with a differences concerning redisplay.
1024 It is not ensured that mode lines will be updated to show the modified
1025 state of the current buffer. Use with care. */)
1029 #ifdef CLASH_DETECTION
1032 /* If buffer becoming modified, lock the file.
1033 If buffer becoming unmodified, unlock the file. */
1035 fn
= current_buffer
->file_truename
;
1036 /* Test buffer-file-name so that binding it to nil is effective. */
1037 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
1039 int already
= SAVE_MODIFF
< MODIFF
;
1040 if (!already
&& !NILP (flag
))
1042 else if (already
&& NILP (flag
))
1045 #endif /* CLASH_DETECTION */
1047 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
1051 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
1053 doc
: /* Return BUFFER's tick counter, incremented for each change in text.
1054 Each buffer has a tick counter which is incremented each time the text in
1055 that buffer is changed. It wraps around occasionally.
1056 No argument or nil as argument means use current buffer as BUFFER. */)
1058 register Lisp_Object buffer
;
1060 register struct buffer
*buf
;
1062 buf
= current_buffer
;
1065 CHECK_BUFFER (buffer
);
1066 buf
= XBUFFER (buffer
);
1069 return make_number (BUF_MODIFF (buf
));
1072 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
1073 "sRename buffer (to new name): \nP",
1074 doc
: /* Change current buffer's name to NEWNAME (a string).
1075 If second arg UNIQUE is nil or omitted, it is an error if a
1076 buffer named NEWNAME already exists.
1077 If UNIQUE is non-nil, come up with a new name using
1078 `generate-new-buffer-name'.
1079 Interactively, you can set UNIQUE with a prefix argument.
1080 We return the name we actually gave the buffer.
1081 This does not change the name of the visited file (if any). */)
1083 register Lisp_Object newname
, unique
;
1085 register Lisp_Object tem
, buf
;
1087 CHECK_STRING (newname
);
1089 if (SCHARS (newname
) == 0)
1090 error ("Empty string is invalid as a buffer name");
1092 tem
= Fget_buffer (newname
);
1095 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1096 rename the buffer automatically so you can create another
1097 with the original name. It makes UNIQUE equivalent to
1098 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1099 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
1100 return current_buffer
->name
;
1102 newname
= Fgenerate_new_buffer_name (newname
, current_buffer
->name
);
1104 error ("Buffer name `%s' is in use", SDATA (newname
));
1107 current_buffer
->name
= newname
;
1109 /* Catch redisplay's attention. Unless we do this, the mode lines for
1110 any windows displaying current_buffer will stay unchanged. */
1111 update_mode_lines
++;
1113 XSETBUFFER (buf
, current_buffer
);
1114 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
1115 if (NILP (current_buffer
->filename
)
1116 && !NILP (current_buffer
->auto_save_file_name
))
1117 call0 (intern ("rename-auto-save-file"));
1118 /* Refetch since that last call may have done GC. */
1119 return current_buffer
->name
;
1122 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1123 doc
: /* Return most recently selected buffer other than BUFFER.
1124 Buffers not visible in windows are preferred to visible buffers,
1125 unless optional second argument VISIBLE-OK is non-nil.
1126 If the optional third argument FRAME is non-nil, use that frame's
1127 buffer list instead of the selected frame's buffer list.
1128 If no other buffer exists, the buffer `*scratch*' is returned.
1129 If BUFFER is omitted or nil, some interesting buffer is returned. */)
1130 (buffer
, visible_ok
, frame
)
1131 register Lisp_Object buffer
, visible_ok
, frame
;
1133 Lisp_Object
Fset_buffer_major_mode ();
1134 register Lisp_Object tail
, buf
, notsogood
, tem
, pred
, add_ons
;
1138 frame
= selected_frame
;
1140 tail
= Vbuffer_alist
;
1141 pred
= frame_buffer_predicate (frame
);
1143 /* Consider buffers that have been seen in the selected frame
1144 before other buffers. */
1146 tem
= frame_buffer_list (frame
);
1150 if (BUFFERP (XCAR (tem
)))
1151 add_ons
= Fcons (Fcons (Qnil
, XCAR (tem
)), add_ons
);
1154 tail
= nconc2 (Fnreverse (add_ons
), tail
);
1156 for (; !NILP (tail
); tail
= Fcdr (tail
))
1158 buf
= Fcdr (Fcar (tail
));
1159 if (EQ (buf
, buffer
))
1161 if (SREF (XBUFFER (buf
)->name
, 0) == ' ')
1163 /* If the selected frame has a buffer_predicate,
1164 disregard buffers that don't fit the predicate. */
1167 tem
= call1 (pred
, buf
);
1172 if (NILP (visible_ok
))
1173 tem
= Fget_buffer_window (buf
, Qvisible
);
1178 if (NILP (notsogood
))
1181 if (!NILP (notsogood
))
1183 buf
= Fget_buffer (build_string ("*scratch*"));
1186 buf
= Fget_buffer_create (build_string ("*scratch*"));
1187 Fset_buffer_major_mode (buf
);
1192 DEFUN ("buffer-disable-undo", Fbuffer_disable_undo
, Sbuffer_disable_undo
,
1194 doc
: /* Make BUFFER stop keeping undo information.
1195 No argument or nil as argument means do this for the current buffer. */)
1197 register Lisp_Object buffer
;
1199 Lisp_Object real_buffer
;
1202 XSETBUFFER (real_buffer
, current_buffer
);
1205 real_buffer
= Fget_buffer (buffer
);
1206 if (NILP (real_buffer
))
1210 XBUFFER (real_buffer
)->undo_list
= Qt
;
1215 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1217 doc
: /* Start keeping undo information for buffer BUFFER.
1218 No argument or nil as argument means do this for the current buffer. */)
1220 register Lisp_Object buffer
;
1222 Lisp_Object real_buffer
;
1225 XSETBUFFER (real_buffer
, current_buffer
);
1228 real_buffer
= Fget_buffer (buffer
);
1229 if (NILP (real_buffer
))
1233 if (EQ (XBUFFER (real_buffer
)->undo_list
, Qt
))
1234 XBUFFER (real_buffer
)->undo_list
= Qnil
;
1240 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
1241 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
1242 The buffer being killed will be current while the hook is running.\n\
1245 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 1, 1, "bKill buffer: ",
1246 doc
: /* Kill the buffer BUFFER.
1247 The argument may be a buffer or may be the name of a buffer.
1248 An argument of nil means kill the current buffer.
1250 Value is t if the buffer is actually killed, nil if user says no.
1252 The value of `kill-buffer-hook' (which may be local to that buffer),
1253 if not void, is a list of functions to be called, with no arguments,
1254 before the buffer is actually killed. The buffer to be killed is current
1255 when the hook functions are called.
1257 Any processes that have this buffer as the `process-buffer' are killed
1263 register struct buffer
*b
;
1264 register Lisp_Object tem
;
1265 register struct Lisp_Marker
*m
;
1266 struct gcpro gcpro1
;
1269 buf
= Fcurrent_buffer ();
1271 buf
= Fget_buffer (buffer
);
1277 /* Avoid trouble for buffer already dead. */
1281 /* Query if the buffer is still modified. */
1282 if (INTERACTIVE
&& !NILP (b
->filename
)
1283 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1286 tem
= do_yes_or_no_p (format1 ("Buffer %s modified; kill anyway? ",
1293 /* Run hooks with the buffer to be killed the current buffer. */
1295 int count
= SPECPDL_INDEX ();
1298 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1299 set_buffer_internal (b
);
1301 /* First run the query functions; if any query is answered no,
1302 don't kill the buffer. */
1303 for (list
= Vkill_buffer_query_functions
; !NILP (list
); list
= Fcdr (list
))
1305 tem
= call0 (Fcar (list
));
1307 return unbind_to (count
, Qnil
);
1310 /* Then run the hooks. */
1311 Frun_hooks (1, &Qkill_buffer_hook
);
1312 unbind_to (count
, Qnil
);
1315 /* We have no more questions to ask. Verify that it is valid
1316 to kill the buffer. This must be done after the questions
1317 since anything can happen within do_yes_or_no_p. */
1319 /* Don't kill the minibuffer now current. */
1320 if (EQ (buf
, XWINDOW (minibuf_window
)->buffer
))
1326 /* When we kill a base buffer, kill all its indirect buffers.
1327 We do it at this stage so nothing terrible happens if they
1328 ask questions or their hooks get errors. */
1329 if (! b
->base_buffer
)
1331 struct buffer
*other
;
1335 for (other
= all_buffers
; other
; other
= other
->next
)
1336 /* all_buffers contains dead buffers too;
1337 don't re-kill them. */
1338 if (other
->base_buffer
== b
&& !NILP (other
->name
))
1341 XSETBUFFER (buf
, other
);
1348 /* Make this buffer not be current.
1349 In the process, notice if this is the sole visible buffer
1350 and give up if so. */
1351 if (b
== current_buffer
)
1353 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1355 if (b
== current_buffer
)
1359 /* Notice if the buffer to kill is the sole visible buffer
1360 when we're currently in the mini-buffer, and give up if so. */
1361 XSETBUFFER (tem
, current_buffer
);
1362 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
))
1364 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1369 /* Now there is no question: we can kill the buffer. */
1371 #ifdef CLASH_DETECTION
1372 /* Unlock this buffer's file, if it is locked. */
1374 #endif /* CLASH_DETECTION */
1376 kill_buffer_processes (buf
);
1378 tem
= Vinhibit_quit
;
1380 replace_buffer_in_all_windows (buf
);
1381 Vbuffer_alist
= Fdelq (Frassq (buf
, Vbuffer_alist
), Vbuffer_alist
);
1382 frames_discard_buffer (buf
);
1383 Vinhibit_quit
= tem
;
1385 /* Delete any auto-save file, if we saved it in this session.
1386 But not if the buffer is modified. */
1387 if (STRINGP (b
->auto_save_file_name
)
1388 && b
->auto_save_modified
!= 0
1389 && BUF_SAVE_MODIFF (b
) < b
->auto_save_modified
1390 && BUF_SAVE_MODIFF (b
) < BUF_MODIFF (b
))
1393 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
1395 internal_delete_file (b
->auto_save_file_name
);
1400 /* Unchain all markers that belong to this indirect buffer.
1401 Don't unchain the markers that belong to the base buffer
1402 or its other indirect buffers. */
1403 for (tem
= BUF_MARKERS (b
); !NILP (tem
); )
1409 unchain_marker (tem
);
1415 /* Unchain all markers of this buffer and its indirect buffers.
1416 and leave them pointing nowhere. */
1417 for (tem
= BUF_MARKERS (b
); !NILP (tem
); )
1424 BUF_MARKERS (b
) = Qnil
;
1425 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1427 /* Perhaps we should explicitly free the interval tree here... */
1430 /* Reset the local variables, so that this buffer's local values
1431 won't be protected from GC. They would be protected
1432 if they happened to remain encached in their symbols.
1433 This gets rid of them for certain. */
1434 swap_out_buffer_local_variables (b
);
1435 reset_buffer_local_variables (b
, 1);
1440 if (! b
->base_buffer
)
1441 free_buffer_text (b
);
1443 if (b
->newline_cache
)
1445 free_region_cache (b
->newline_cache
);
1446 b
->newline_cache
= 0;
1448 if (b
->width_run_cache
)
1450 free_region_cache (b
->width_run_cache
);
1451 b
->width_run_cache
= 0;
1453 b
->width_table
= Qnil
;
1455 b
->undo_list
= Qnil
;
1460 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
1461 we do this each time BUF is selected visibly, the more recently
1462 selected buffers are always closer to the front of the list. This
1463 means that other_buffer is more likely to choose a relevant buffer. */
1469 register Lisp_Object link
, prev
;
1471 frame
= selected_frame
;
1474 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCDR (link
))
1476 if (EQ (XCDR (XCAR (link
)), buf
))
1481 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
1482 we cannot use Fdelq itself here because it allows quitting. */
1485 Vbuffer_alist
= XCDR (Vbuffer_alist
);
1487 XSETCDR (prev
, XCDR (XCDR (prev
)));
1489 XSETCDR (link
, Vbuffer_alist
);
1490 Vbuffer_alist
= link
;
1492 /* Now move this buffer to the front of frame_buffer_list also. */
1495 for (link
= frame_buffer_list (frame
); CONSP (link
);
1498 if (EQ (XCAR (link
), buf
))
1503 /* Effectively do delq. */
1508 set_frame_buffer_list (frame
,
1509 XCDR (frame_buffer_list (frame
)));
1511 XSETCDR (prev
, XCDR (XCDR (prev
)));
1513 XSETCDR (link
, frame_buffer_list (frame
));
1514 set_frame_buffer_list (frame
, link
);
1517 set_frame_buffer_list (frame
, Fcons (buf
, frame_buffer_list (frame
)));
1520 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1521 doc
: /* Set an appropriate major mode for BUFFER.
1522 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1523 according to `default-major-mode'.
1524 Use this function before selecting the buffer, since it may need to inspect
1525 the current buffer's major mode. */)
1530 Lisp_Object function
;
1532 if (STRINGP (XBUFFER (buffer
)->name
)
1533 && strcmp (SDATA (XBUFFER (buffer
)->name
), "*scratch*") == 0)
1534 function
= find_symbol_value (intern ("initial-major-mode"));
1537 function
= buffer_defaults
.major_mode
;
1539 && NILP (Fget (current_buffer
->major_mode
, Qmode_class
)))
1540 function
= current_buffer
->major_mode
;
1543 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1546 count
= SPECPDL_INDEX ();
1548 /* To select a nonfundamental mode,
1549 select the buffer temporarily and then call the mode function. */
1551 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1553 Fset_buffer (buffer
);
1556 return unbind_to (count
, Qnil
);
1559 /* If switching buffers in WINDOW would be an error, return
1560 a C string saying what the error would be. */
1563 no_switch_window (window
)
1567 if (EQ (minibuf_window
, window
))
1568 return "Cannot switch buffers in minibuffer window";
1569 tem
= Fwindow_dedicated_p (window
);
1571 return "Cannot switch buffers in a dedicated window";
1575 /* Switch to buffer BUFFER in the selected window.
1576 If NORECORD is non-nil, don't call record_buffer. */
1579 switch_to_buffer_1 (buffer
, norecord
)
1580 Lisp_Object buffer
, norecord
;
1582 register Lisp_Object buf
;
1585 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1588 buf
= Fget_buffer (buffer
);
1591 buf
= Fget_buffer_create (buffer
);
1592 Fset_buffer_major_mode (buf
);
1596 if (NILP (norecord
))
1597 record_buffer (buf
);
1599 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
1600 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
1607 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2, "BSwitch to buffer: ",
1608 doc
: /* Select buffer BUFFER in the current window.
1609 BUFFER may be a buffer or a buffer name.
1610 Optional second arg NORECORD non-nil means
1611 do not put this buffer at the front of the list of recently selected ones.
1613 WARNING: This is NOT the way to work on another buffer temporarily
1614 within a Lisp program! Use `set-buffer' instead. That avoids messing with
1615 the window-buffer correspondences. */)
1617 Lisp_Object buffer
, norecord
;
1621 err
= no_switch_window (selected_window
);
1622 if (err
) error (err
);
1624 return switch_to_buffer_1 (buffer
, norecord
);
1627 DEFUN ("pop-to-buffer", Fpop_to_buffer
, Spop_to_buffer
, 1, 3, 0,
1628 doc
: /* Select buffer BUFFER in some window, preferably a different one.
1629 If BUFFER is nil, then some other buffer is chosen.
1630 If `pop-up-windows' is non-nil, windows can be split to do this.
1631 If optional second arg OTHER-WINDOW is non-nil, insist on finding another
1632 window even if BUFFER is already visible in the selected window.
1633 This uses the function `display-buffer' as a subroutine; see the documentation
1634 of `display-buffer' for additional customization information.
1636 Optional third arg NORECORD non-nil means
1637 do not put this buffer at the front of the list of recently selected ones. */)
1638 (buffer
, other_window
, norecord
)
1639 Lisp_Object buffer
, other_window
, norecord
;
1641 register Lisp_Object buf
;
1643 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1646 buf
= Fget_buffer (buffer
);
1649 buf
= Fget_buffer_create (buffer
);
1650 Fset_buffer_major_mode (buf
);
1654 if (NILP (norecord
))
1655 /* This seems bogus since Fselect_window will call record_buffer anyway. */
1656 record_buffer (buf
);
1657 Fselect_window (Fdisplay_buffer (buf
, other_window
, Qnil
));
1661 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1662 doc
: /* Return the current buffer as a Lisp object. */)
1665 register Lisp_Object buf
;
1666 XSETBUFFER (buf
, current_buffer
);
1670 /* Set the current buffer to B.
1672 We previously set windows_or_buffers_changed here to invalidate
1673 global unchanged information in beg_unchanged and end_unchanged.
1674 This is no longer necessary because we now compute unchanged
1675 information on a buffer-basis. Every action affecting other
1676 windows than the selected one requires a select_window at some
1677 time, and that increments windows_or_buffers_changed. */
1680 set_buffer_internal (b
)
1681 register struct buffer
*b
;
1683 if (current_buffer
!= b
)
1684 set_buffer_internal_1 (b
);
1687 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1688 This is used by redisplay. */
1691 set_buffer_internal_1 (b
)
1692 register struct buffer
*b
;
1694 register struct buffer
*old_buf
;
1695 register Lisp_Object tail
, valcontents
;
1698 #ifdef USE_MMAP_FOR_BUFFERS
1699 if (b
->text
->beg
== NULL
)
1700 enlarge_buffer_text (b
, 0);
1701 #endif /* USE_MMAP_FOR_BUFFERS */
1703 if (current_buffer
== b
)
1706 old_buf
= current_buffer
;
1708 last_known_column_point
= -1; /* invalidate indentation cache */
1712 /* Put the undo list back in the base buffer, so that it appears
1713 that an indirect buffer shares the undo list of its base. */
1714 if (old_buf
->base_buffer
)
1715 old_buf
->base_buffer
->undo_list
= old_buf
->undo_list
;
1717 /* If the old current buffer has markers to record PT, BEGV and ZV
1718 when it is not current, update them now. */
1719 if (! NILP (old_buf
->pt_marker
))
1722 XSETBUFFER (obuf
, old_buf
);
1723 set_marker_both (old_buf
->pt_marker
, obuf
,
1724 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1726 if (! NILP (old_buf
->begv_marker
))
1729 XSETBUFFER (obuf
, old_buf
);
1730 set_marker_both (old_buf
->begv_marker
, obuf
,
1731 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1733 if (! NILP (old_buf
->zv_marker
))
1736 XSETBUFFER (obuf
, old_buf
);
1737 set_marker_both (old_buf
->zv_marker
, obuf
,
1738 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1742 /* Get the undo list from the base buffer, so that it appears
1743 that an indirect buffer shares the undo list of its base. */
1745 b
->undo_list
= b
->base_buffer
->undo_list
;
1747 /* If the new current buffer has markers to record PT, BEGV and ZV
1748 when it is not current, fetch them now. */
1749 if (! NILP (b
->pt_marker
))
1751 BUF_PT (b
) = marker_position (b
->pt_marker
);
1752 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1754 if (! NILP (b
->begv_marker
))
1756 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1757 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1759 if (! NILP (b
->zv_marker
))
1761 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1762 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1765 /* Look down buffer's list of local Lisp variables
1766 to find and update any that forward into C variables. */
1768 for (tail
= b
->local_var_alist
; !NILP (tail
); tail
= XCDR (tail
))
1770 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1771 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1772 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1773 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1774 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1775 /* Just reference the variable
1776 to cause it to become set for this buffer. */
1777 Fsymbol_value (XCAR (XCAR (tail
)));
1780 /* Do the same with any others that were local to the previous buffer */
1783 for (tail
= old_buf
->local_var_alist
; !NILP (tail
); tail
= XCDR (tail
))
1785 valcontents
= SYMBOL_VALUE (XCAR (XCAR (tail
)));
1786 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1787 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1788 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1789 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1790 /* Just reference the variable
1791 to cause it to become set for this buffer. */
1792 Fsymbol_value (XCAR (XCAR (tail
)));
1796 /* Switch to buffer B temporarily for redisplay purposes.
1797 This avoids certain things that don't need to be done within redisplay. */
1803 register struct buffer
*old_buf
;
1805 if (current_buffer
== b
)
1808 old_buf
= current_buffer
;
1813 /* If the old current buffer has markers to record PT, BEGV and ZV
1814 when it is not current, update them now. */
1815 if (! NILP (old_buf
->pt_marker
))
1818 XSETBUFFER (obuf
, old_buf
);
1819 set_marker_both (old_buf
->pt_marker
, obuf
,
1820 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1822 if (! NILP (old_buf
->begv_marker
))
1825 XSETBUFFER (obuf
, old_buf
);
1826 set_marker_both (old_buf
->begv_marker
, obuf
,
1827 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1829 if (! NILP (old_buf
->zv_marker
))
1832 XSETBUFFER (obuf
, old_buf
);
1833 set_marker_both (old_buf
->zv_marker
, obuf
,
1834 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1838 /* If the new current buffer has markers to record PT, BEGV and ZV
1839 when it is not current, fetch them now. */
1840 if (! NILP (b
->pt_marker
))
1842 BUF_PT (b
) = marker_position (b
->pt_marker
);
1843 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1845 if (! NILP (b
->begv_marker
))
1847 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1848 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1850 if (! NILP (b
->zv_marker
))
1852 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1853 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1857 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
1858 doc
: /* Make the buffer BUFFER current for editing operations.
1859 BUFFER may be a buffer or the name of an existing buffer.
1860 See also `save-excursion' when you want to make a buffer current temporarily.
1861 This function does not display the buffer, so its effect ends
1862 when the current command terminates.
1863 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently. */)
1865 register Lisp_Object buffer
;
1867 register Lisp_Object buf
;
1868 buf
= Fget_buffer (buffer
);
1871 if (NILP (XBUFFER (buf
)->name
))
1872 error ("Selecting deleted buffer");
1873 set_buffer_internal (XBUFFER (buf
));
1877 /* Set the current buffer to BUFFER provided it is alive. */
1880 set_buffer_if_live (buffer
)
1883 if (! NILP (XBUFFER (buffer
)->name
))
1884 Fset_buffer (buffer
);
1888 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
1889 Sbarf_if_buffer_read_only
, 0, 0, 0,
1890 doc
: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
1893 if (!NILP (current_buffer
->read_only
)
1894 && NILP (Vinhibit_read_only
))
1895 Fsignal (Qbuffer_read_only
, (Fcons (Fcurrent_buffer (), Qnil
)));
1899 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
1900 doc
: /* Put BUFFER at the end of the list of all buffers.
1901 There it is the least likely candidate for `other-buffer' to return;
1902 thus, the least likely buffer for \\[switch-to-buffer] to select by default.
1903 If BUFFER is nil or omitted, bury the current buffer.
1904 Also, if BUFFER is nil or omitted, remove the current buffer from the
1905 selected window if it is displayed there. */)
1907 register Lisp_Object buffer
;
1909 /* Figure out what buffer we're going to bury. */
1913 XSETBUFFER (buffer
, current_buffer
);
1915 tem
= Fwindow_buffer (selected_window
);
1916 /* If we're burying the current buffer, unshow it. */
1917 if (EQ (buffer
, tem
))
1919 if (NILP (Fwindow_dedicated_p (selected_window
)))
1920 Fswitch_to_buffer (Fother_buffer (buffer
, Qnil
, Qnil
), Qnil
);
1921 else if (NILP (XWINDOW (selected_window
)->parent
))
1922 Ficonify_frame (Fwindow_frame (selected_window
));
1924 Fdelete_window (selected_window
);
1931 buf1
= Fget_buffer (buffer
);
1937 /* Move buffer to the end of the buffer list. Do nothing if the
1938 buffer is killed. */
1939 if (!NILP (XBUFFER (buffer
)->name
))
1941 Lisp_Object aelt
, link
;
1943 aelt
= Frassq (buffer
, Vbuffer_alist
);
1944 link
= Fmemq (aelt
, Vbuffer_alist
);
1945 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1946 XSETCDR (link
, Qnil
);
1947 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
1949 /* Removing BUFFER from frame-specific lists
1950 has the effect of putting BUFFER at the end
1951 of the combined list in each frame. */
1952 frames_discard_buffer (buffer
);
1958 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
1959 doc
: /* Delete the entire contents of the current buffer.
1960 Any narrowing restriction in effect (see `narrow-to-region') is removed,
1961 so the buffer is truly empty after this. */)
1968 current_buffer
->last_window_start
= 1;
1969 /* Prevent warnings, or suspension of auto saving, that would happen
1970 if future size is less than past size. Use of erase-buffer
1971 implies that the future text is not really related to the past text. */
1972 XSETFASTINT (current_buffer
->save_length
, 0);
1977 validate_region (b
, e
)
1978 register Lisp_Object
*b
, *e
;
1980 CHECK_NUMBER_COERCE_MARKER (*b
);
1981 CHECK_NUMBER_COERCE_MARKER (*e
);
1983 if (XINT (*b
) > XINT (*e
))
1986 tem
= *b
; *b
= *e
; *e
= tem
;
1989 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
1990 && XINT (*e
) <= ZV
))
1991 args_out_of_range (*b
, *e
);
1994 /* Advance BYTE_POS up to a character boundary
1995 and return the adjusted position. */
1998 advance_to_char_boundary (byte_pos
)
2003 if (byte_pos
== BEG
)
2004 /* Beginning of buffer is always a character boundary. */
2007 c
= FETCH_BYTE (byte_pos
);
2008 if (! CHAR_HEAD_P (c
))
2010 /* We should advance BYTE_POS only when C is a constituent of a
2011 multibyte sequence. */
2012 int orig_byte_pos
= byte_pos
;
2017 c
= FETCH_BYTE (byte_pos
);
2019 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
2021 if (byte_pos
< orig_byte_pos
)
2022 byte_pos
= orig_byte_pos
;
2023 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2024 surely advance to the correct character boundary. If C is
2025 not, BYTE_POS was unchanged. */
2031 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
2033 doc
: /* Set the multibyte flag of the current buffer to FLAG.
2034 If FLAG is t, this makes the buffer a multibyte buffer.
2035 If FLAG is nil, this makes the buffer a single-byte buffer.
2036 The buffer contents remain unchanged as a sequence of bytes
2037 but the contents viewed as characters do change. */)
2041 Lisp_Object tail
, markers
;
2042 struct buffer
*other
;
2043 int undo_enabled_p
= !EQ (current_buffer
->undo_list
, Qt
);
2044 int begv
= BEGV
, zv
= ZV
;
2045 int narrowed
= (BEG
!= begv
|| Z
!= zv
);
2046 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
2048 if (current_buffer
->base_buffer
)
2049 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2051 /* Do nothing if nothing actually changes. */
2052 if (NILP (flag
) == NILP (current_buffer
->enable_multibyte_characters
))
2055 /* It would be better to update the list,
2056 but this is good enough for now. */
2058 current_buffer
->undo_list
= Qt
;
2060 /* If the cached position is for this buffer, clear it out. */
2061 clear_charpos_cache (current_buffer
);
2071 /* Do this first, so it can use CHAR_TO_BYTE
2072 to calculate the old correspondences. */
2073 set_intervals_multibyte (0);
2075 current_buffer
->enable_multibyte_characters
= Qnil
;
2081 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
2083 tail
= BUF_MARKERS (current_buffer
);
2084 while (! NILP (tail
))
2086 XMARKER (tail
)->charpos
= XMARKER (tail
)->bytepos
;
2087 tail
= XMARKER (tail
)->chain
;
2090 /* Convert multibyte form of 8-bit characters to unibyte. */
2105 if (MULTIBYTE_STR_AS_UNIBYTE_P (p
, bytes
))
2106 p
+= bytes
, pos
+= bytes
;
2109 c
= STRING_CHAR (p
, stop
- pos
);
2110 /* Delete all bytes for this 8-bit character but the
2111 last one, and change the last one to the charcter
2114 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
2126 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2134 /* Be sure not to have a multibyte sequence striding over the GAP.
2135 Ex: We change this: "...abc\201 _GAP_ \241def..."
2136 to: "...abc _GAP_ \201\241def..." */
2138 if (GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
2139 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
2141 unsigned char *p
= GPT_ADDR
- 1;
2143 while (! CHAR_HEAD_P (*p
) && p
> BEG_ADDR
) p
--;
2144 if (BASE_LEADING_CODE_P (*p
))
2146 int new_gpt
= GPT_BYTE
- (GPT_ADDR
- p
);
2148 move_gap_both (new_gpt
, new_gpt
);
2152 /* Make the buffer contents valid as multibyte by converting
2153 8-bit characters to multibyte form. */
2169 if (UNIBYTE_STR_AS_MULTIBYTE_P (p
, stop
- pos
, bytes
))
2170 p
+= bytes
, pos
+= bytes
;
2173 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2175 bytes
= CHAR_STRING (*p
, tmp
);
2177 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2179 insert_1_both (tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2180 /* Now the gap is after the just inserted data. */
2197 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2199 /* Do this first, so that chars_in_text asks the right question.
2200 set_intervals_multibyte needs it too. */
2201 current_buffer
->enable_multibyte_characters
= Qt
;
2203 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2204 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2206 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2208 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2209 if (BEGV_BYTE
> GPT_BYTE
)
2210 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2212 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2214 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2215 if (ZV_BYTE
> GPT_BYTE
)
2216 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2218 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2221 int pt_byte
= advance_to_char_boundary (PT_BYTE
);
2224 if (pt_byte
> GPT_BYTE
)
2225 pt
= chars_in_text (GAP_END_ADDR
, pt_byte
- GPT_BYTE
) + GPT
;
2227 pt
= chars_in_text (BEG_ADDR
, pt_byte
- BEG_BYTE
) + BEG
;
2228 TEMP_SET_PT_BOTH (pt
, pt_byte
);
2231 tail
= markers
= BUF_MARKERS (current_buffer
);
2233 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2234 getting confused by the markers that have not yet been updated.
2235 It is also a signal that it should never create a marker. */
2236 BUF_MARKERS (current_buffer
) = Qnil
;
2238 while (! NILP (tail
))
2240 XMARKER (tail
)->bytepos
2241 = advance_to_char_boundary (XMARKER (tail
)->bytepos
);
2242 XMARKER (tail
)->charpos
= BYTE_TO_CHAR (XMARKER (tail
)->bytepos
);
2244 tail
= XMARKER (tail
)->chain
;
2247 /* Make sure no markers were put on the chain
2248 while the chain value was incorrect. */
2249 if (! EQ (BUF_MARKERS (current_buffer
), Qnil
))
2252 BUF_MARKERS (current_buffer
) = markers
;
2254 /* Do this last, so it can calculate the new correspondences
2255 between chars and bytes. */
2256 set_intervals_multibyte (1);
2260 current_buffer
->undo_list
= Qnil
;
2262 /* Changing the multibyteness of a buffer means that all windows
2263 showing that buffer must be updated thoroughly. */
2264 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2265 ++windows_or_buffers_changed
;
2267 /* Copy this buffer's new multibyte status
2268 into all of its indirect buffers. */
2269 for (other
= all_buffers
; other
; other
= other
->next
)
2270 if (other
->base_buffer
== current_buffer
&& !NILP (other
->name
))
2272 other
->enable_multibyte_characters
2273 = current_buffer
->enable_multibyte_characters
;
2274 other
->prevent_redisplay_optimizations_p
= 1;
2277 /* Restore the modifiedness of the buffer. */
2278 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2279 Fset_buffer_modified_p (Qnil
);
2284 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
2286 doc
: /* Switch to Fundamental mode by killing current buffer's local variables.
2287 Most local variable bindings are eliminated so that the default values
2288 become effective once more. Also, the syntax table is set from
2289 `standard-syntax-table', the local keymap is set to nil,
2290 and the abbrev table from `fundamental-mode-abbrev-table'.
2291 This function also forces redisplay of the mode line.
2293 Every function to select a new major mode starts by
2294 calling this function.
2296 As a special exception, local variables whose names have
2297 a non-nil `permanent-local' property are not eliminated by this function.
2299 The first thing this function does is run
2300 the normal hook `change-major-mode-hook'. */)
2303 register Lisp_Object alist
, sym
, tem
;
2306 if (!NILP (Vrun_hooks
))
2307 call1 (Vrun_hooks
, intern ("change-major-mode-hook"));
2308 oalist
= current_buffer
->local_var_alist
;
2310 /* Make sure none of the bindings in oalist
2311 remain swapped in, in their symbols. */
2313 swap_out_buffer_local_variables (current_buffer
);
2315 /* Actually eliminate all local bindings of this buffer. */
2317 reset_buffer_local_variables (current_buffer
, 0);
2319 /* Any which are supposed to be permanent,
2320 make local again, with the same values they had. */
2322 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2324 sym
= XCAR (XCAR (alist
));
2325 tem
= Fget (sym
, Qpermanent_local
);
2328 Fmake_local_variable (sym
);
2329 Fset (sym
, XCDR (XCAR (alist
)));
2333 /* Force mode-line redisplay. Useful here because all major mode
2334 commands call this function. */
2335 update_mode_lines
++;
2340 /* Make sure no local variables remain set up with buffer B
2341 for their current values. */
2344 swap_out_buffer_local_variables (b
)
2347 Lisp_Object oalist
, alist
, sym
, tem
, buffer
;
2349 XSETBUFFER (buffer
, b
);
2350 oalist
= b
->local_var_alist
;
2352 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2354 sym
= XCAR (XCAR (alist
));
2356 /* Need not do anything if some other buffer's binding is now encached. */
2357 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
;
2358 if (BUFFERP (tem
) && XBUFFER (tem
) == current_buffer
)
2360 /* Symbol is set up for this buffer's old local value.
2361 Set it up for the current buffer with the default value. */
2363 tem
= XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->cdr
;
2364 /* Store the symbol's current value into the alist entry
2365 it is currently set up for. This is so that, if the
2366 local is marked permanent, and we make it local again
2367 later in Fkill_all_local_variables, we don't lose the value. */
2368 XSETCDR (XCAR (tem
),
2369 do_symval_forwarding (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->realvalue
));
2370 /* Switch to the symbol's default-value alist entry. */
2372 /* Mark it as current for buffer B. */
2373 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->buffer
= buffer
;
2374 /* Store the current value into any forwarding in the symbol. */
2375 store_symval_forwarding (sym
,
2376 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym
))->realvalue
,
2382 /* Find all the overlays in the current buffer that contain position POS.
2383 Return the number found, and store them in a vector in *VEC_PTR.
2384 Store in *LEN_PTR the size allocated for the vector.
2385 Store in *NEXT_PTR the next position after POS where an overlay starts,
2386 or ZV if there are no more overlays.
2387 Store in *PREV_PTR the previous position before POS where an overlay ends,
2388 or where an overlay starts which ends at or after POS;
2389 or BEGV if there are no such overlays.
2390 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2392 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2393 when this function is called.
2395 If EXTEND is non-zero, we make the vector bigger if necessary.
2396 If EXTEND is zero, we never extend the vector,
2397 and we store only as many overlays as will fit.
2398 But we still return the total number of overlays.
2400 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2401 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2402 default (BEGV or ZV). */
2405 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
, change_req
)
2408 Lisp_Object
**vec_ptr
;
2414 Lisp_Object tail
, overlay
, start
, end
;
2417 Lisp_Object
*vec
= *vec_ptr
;
2420 int inhibit_storing
= 0;
2422 for (tail
= current_buffer
->overlays_before
;
2426 int startpos
, endpos
;
2428 overlay
= XCAR (tail
);
2430 start
= OVERLAY_START (overlay
);
2431 end
= OVERLAY_END (overlay
);
2432 endpos
= OVERLAY_POSITION (end
);
2439 startpos
= OVERLAY_POSITION (start
);
2440 /* This one ends at or after POS
2441 so its start counts for PREV_PTR if it's before POS. */
2442 if (prev
< startpos
&& startpos
< pos
)
2446 if (startpos
<= pos
)
2450 /* The supplied vector is full.
2451 Either make it bigger, or don't store any more in it. */
2454 /* Make it work with an initial len == 0. */
2459 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2463 inhibit_storing
= 1;
2466 if (!inhibit_storing
)
2468 /* Keep counting overlays even if we can't return them all. */
2471 else if (startpos
< next
)
2475 for (tail
= current_buffer
->overlays_after
;
2479 int startpos
, endpos
;
2481 overlay
= XCAR (tail
);
2483 start
= OVERLAY_START (overlay
);
2484 end
= OVERLAY_END (overlay
);
2485 startpos
= OVERLAY_POSITION (start
);
2488 if (startpos
< next
)
2492 endpos
= OVERLAY_POSITION (end
);
2499 *len_ptr
= len
*= 2;
2502 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2506 inhibit_storing
= 1;
2509 if (!inhibit_storing
)
2513 if (startpos
< pos
&& startpos
> prev
)
2516 else if (endpos
< pos
&& endpos
> prev
)
2518 else if (endpos
== pos
&& startpos
> prev
2519 && (!change_req
|| startpos
< pos
))
2530 /* Find all the overlays in the current buffer that overlap the range BEG-END
2531 or are empty at BEG.
2533 Return the number found, and store them in a vector in *VEC_PTR.
2534 Store in *LEN_PTR the size allocated for the vector.
2535 Store in *NEXT_PTR the next position after POS where an overlay starts,
2536 or ZV if there are no more overlays.
2537 Store in *PREV_PTR the previous position before POS where an overlay ends,
2538 or BEGV if there are no previous overlays.
2539 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2541 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2542 when this function is called.
2544 If EXTEND is non-zero, we make the vector bigger if necessary.
2545 If EXTEND is zero, we never extend the vector,
2546 and we store only as many overlays as will fit.
2547 But we still return the total number of overlays. */
2550 overlays_in (beg
, end
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
2553 Lisp_Object
**vec_ptr
;
2558 Lisp_Object tail
, overlay
, ostart
, oend
;
2561 Lisp_Object
*vec
= *vec_ptr
;
2564 int inhibit_storing
= 0;
2566 for (tail
= current_buffer
->overlays_before
;
2570 int startpos
, endpos
;
2572 overlay
= XCAR (tail
);
2574 ostart
= OVERLAY_START (overlay
);
2575 oend
= OVERLAY_END (overlay
);
2576 endpos
= OVERLAY_POSITION (oend
);
2583 startpos
= OVERLAY_POSITION (ostart
);
2584 /* Count an interval if it either overlaps the range
2585 or is empty at the start of the range. */
2586 if ((beg
< endpos
&& startpos
< end
)
2587 || (startpos
== endpos
&& beg
== endpos
))
2591 /* The supplied vector is full.
2592 Either make it bigger, or don't store any more in it. */
2595 *len_ptr
= len
*= 2;
2596 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2600 inhibit_storing
= 1;
2603 if (!inhibit_storing
)
2605 /* Keep counting overlays even if we can't return them all. */
2608 else if (startpos
< next
)
2612 for (tail
= current_buffer
->overlays_after
;
2616 int startpos
, endpos
;
2618 overlay
= XCAR (tail
);
2620 ostart
= OVERLAY_START (overlay
);
2621 oend
= OVERLAY_END (overlay
);
2622 startpos
= OVERLAY_POSITION (ostart
);
2625 if (startpos
< next
)
2629 endpos
= OVERLAY_POSITION (oend
);
2630 /* Count an interval if it either overlaps the range
2631 or is empty at the start of the range. */
2632 if ((beg
< endpos
&& startpos
< end
)
2633 || (startpos
== endpos
&& beg
== endpos
))
2639 *len_ptr
= len
*= 2;
2640 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2644 inhibit_storing
= 1;
2647 if (!inhibit_storing
)
2651 else if (endpos
< beg
&& endpos
> prev
)
2663 /* Return non-zero if there exists an overlay with a non-nil
2664 `mouse-face' property overlapping OVERLAY. */
2667 mouse_face_overlay_overlaps (overlay
)
2668 Lisp_Object overlay
;
2670 int start
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2671 int end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2673 Lisp_Object
*v
, tem
;
2676 v
= (Lisp_Object
*) alloca (size
* sizeof *v
);
2677 n
= overlays_in (start
, end
, 0, &v
, &size
, NULL
, NULL
);
2680 v
= (Lisp_Object
*) alloca (n
* sizeof *v
);
2681 overlays_in (start
, end
, 0, &v
, &n
, NULL
, NULL
);
2684 for (i
= 0; i
< n
; ++i
)
2685 if (!EQ (v
[i
], overlay
)
2686 && (tem
= Foverlay_get (overlay
, Qmouse_face
),
2695 /* Fast function to just test if we're at an overlay boundary. */
2697 overlay_touches_p (pos
)
2700 Lisp_Object tail
, overlay
;
2702 for (tail
= current_buffer
->overlays_before
; GC_CONSP (tail
);
2707 overlay
= XCAR (tail
);
2708 if (!GC_OVERLAYP (overlay
))
2711 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2714 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
2718 for (tail
= current_buffer
->overlays_after
; GC_CONSP (tail
);
2723 overlay
= XCAR (tail
);
2724 if (!GC_OVERLAYP (overlay
))
2727 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2730 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
2738 Lisp_Object overlay
;
2744 compare_overlays (v1
, v2
)
2745 const void *v1
, *v2
;
2747 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
2748 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
2749 if (s1
->priority
!= s2
->priority
)
2750 return s1
->priority
- s2
->priority
;
2751 if (s1
->beg
!= s2
->beg
)
2752 return s1
->beg
- s2
->beg
;
2753 if (s1
->end
!= s2
->end
)
2754 return s2
->end
- s1
->end
;
2758 /* Sort an array of overlays by priority. The array is modified in place.
2759 The return value is the new size; this may be smaller than the original
2760 size if some of the overlays were invalid or were window-specific. */
2762 sort_overlays (overlay_vec
, noverlays
, w
)
2763 Lisp_Object
*overlay_vec
;
2768 struct sortvec
*sortvec
;
2769 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
2771 /* Put the valid and relevant overlays into sortvec. */
2773 for (i
= 0, j
= 0; i
< noverlays
; i
++)
2776 Lisp_Object overlay
;
2778 overlay
= overlay_vec
[i
];
2779 if (OVERLAY_VALID (overlay
)
2780 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
2781 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
2783 /* If we're interested in a specific window, then ignore
2784 overlays that are limited to some other window. */
2789 window
= Foverlay_get (overlay
, Qwindow
);
2790 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2794 /* This overlay is good and counts: put it into sortvec. */
2795 sortvec
[j
].overlay
= overlay
;
2796 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2797 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2798 tem
= Foverlay_get (overlay
, Qpriority
);
2800 sortvec
[j
].priority
= XINT (tem
);
2802 sortvec
[j
].priority
= 0;
2808 /* Sort the overlays into the proper order: increasing priority. */
2811 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
2813 for (i
= 0; i
< noverlays
; i
++)
2814 overlay_vec
[i
] = sortvec
[i
].overlay
;
2820 Lisp_Object string
, string2
;
2827 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
2828 int size
; /* Allocated length of that array. */
2829 int used
; /* How much of the array is currently in use. */
2830 int bytes
; /* Total length of the strings in buf. */
2833 /* Buffers for storing information about the overlays touching a given
2834 position. These could be automatic variables in overlay_strings, but
2835 it's more efficient to hold onto the memory instead of repeatedly
2836 allocating and freeing it. */
2837 static struct sortstrlist overlay_heads
, overlay_tails
;
2838 static unsigned char *overlay_str_buf
;
2840 /* Allocated length of overlay_str_buf. */
2841 static int overlay_str_len
;
2843 /* A comparison function suitable for passing to qsort. */
2845 cmp_for_strings (as1
, as2
)
2848 struct sortstr
*s1
= (struct sortstr
*)as1
;
2849 struct sortstr
*s2
= (struct sortstr
*)as2
;
2850 if (s1
->size
!= s2
->size
)
2851 return s2
->size
- s1
->size
;
2852 if (s1
->priority
!= s2
->priority
)
2853 return s1
->priority
- s2
->priority
;
2858 record_overlay_string (ssl
, str
, str2
, pri
, size
)
2859 struct sortstrlist
*ssl
;
2860 Lisp_Object str
, str2
, pri
;
2865 if (ssl
->used
== ssl
->size
)
2871 ssl
->buf
= ((struct sortstr
*)
2872 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
2874 ssl
->buf
[ssl
->used
].string
= str
;
2875 ssl
->buf
[ssl
->used
].string2
= str2
;
2876 ssl
->buf
[ssl
->used
].size
= size
;
2877 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
2880 if (NILP (current_buffer
->enable_multibyte_characters
))
2881 nbytes
= SCHARS (str
);
2882 else if (! STRING_MULTIBYTE (str
))
2883 nbytes
= count_size_as_multibyte (SDATA (str
),
2886 nbytes
= SBYTES (str
);
2888 ssl
->bytes
+= nbytes
;
2892 if (NILP (current_buffer
->enable_multibyte_characters
))
2893 nbytes
= SCHARS (str2
);
2894 else if (! STRING_MULTIBYTE (str2
))
2895 nbytes
= count_size_as_multibyte (SDATA (str2
),
2898 nbytes
= SBYTES (str2
);
2900 ssl
->bytes
+= nbytes
;
2904 /* Return the concatenation of the strings associated with overlays that
2905 begin or end at POS, ignoring overlays that are specific to a window
2906 other than W. The strings are concatenated in the appropriate order:
2907 shorter overlays nest inside longer ones, and higher priority inside
2908 lower. Normally all of the after-strings come first, but zero-sized
2909 overlays have their after-strings ride along with the before-strings
2910 because it would look strange to print them inside-out.
2912 Returns the string length, and stores the contents indirectly through
2913 PSTR, if that variable is non-null. The string may be overwritten by
2914 subsequent calls. */
2917 overlay_strings (pos
, w
, pstr
)
2920 unsigned char **pstr
;
2922 Lisp_Object ov
, overlay
, window
, str
;
2923 int startpos
, endpos
;
2924 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
2926 overlay_heads
.used
= overlay_heads
.bytes
= 0;
2927 overlay_tails
.used
= overlay_tails
.bytes
= 0;
2928 for (ov
= current_buffer
->overlays_before
; CONSP (ov
); ov
= XCDR (ov
))
2930 overlay
= XCAR (ov
);
2931 if (!OVERLAYP (overlay
))
2934 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2935 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2938 if (endpos
!= pos
&& startpos
!= pos
)
2940 window
= Foverlay_get (overlay
, Qwindow
);
2941 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2944 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
2945 record_overlay_string (&overlay_heads
, str
,
2947 ? Foverlay_get (overlay
, Qafter_string
)
2949 Foverlay_get (overlay
, Qpriority
),
2951 else if (endpos
== pos
2952 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
2953 record_overlay_string (&overlay_tails
, str
, Qnil
,
2954 Foverlay_get (overlay
, Qpriority
),
2957 for (ov
= current_buffer
->overlays_after
; CONSP (ov
); ov
= XCDR (ov
))
2959 overlay
= XCAR (ov
);
2960 if (!OVERLAYP (overlay
))
2963 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2964 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2967 if (endpos
!= pos
&& startpos
!= pos
)
2969 window
= Foverlay_get (overlay
, Qwindow
);
2970 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2973 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
2974 record_overlay_string (&overlay_heads
, str
,
2976 ? Foverlay_get (overlay
, Qafter_string
)
2978 Foverlay_get (overlay
, Qpriority
),
2980 else if (endpos
== pos
2981 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
2982 record_overlay_string (&overlay_tails
, str
, Qnil
,
2983 Foverlay_get (overlay
, Qpriority
),
2986 if (overlay_tails
.used
> 1)
2987 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
2989 if (overlay_heads
.used
> 1)
2990 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
2992 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
2997 int total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
2999 if (total
> overlay_str_len
)
3001 overlay_str_len
= total
;
3002 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
3005 p
= overlay_str_buf
;
3006 for (i
= overlay_tails
.used
; --i
>= 0;)
3009 tem
= overlay_tails
.buf
[i
].string
;
3010 nbytes
= copy_text (SDATA (tem
), p
,
3012 STRING_MULTIBYTE (tem
), multibyte
);
3015 for (i
= 0; i
< overlay_heads
.used
; ++i
)
3018 tem
= overlay_heads
.buf
[i
].string
;
3019 nbytes
= copy_text (SDATA (tem
), p
,
3021 STRING_MULTIBYTE (tem
), multibyte
);
3023 tem
= overlay_heads
.buf
[i
].string2
;
3026 nbytes
= copy_text (SDATA (tem
), p
,
3028 STRING_MULTIBYTE (tem
), multibyte
);
3032 if (p
!= overlay_str_buf
+ total
)
3035 *pstr
= overlay_str_buf
;
3041 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3044 recenter_overlay_lists (buf
, pos
)
3048 Lisp_Object overlay
, tail
, next
, prev
, beg
, end
;
3050 /* See if anything in overlays_before should move to overlays_after. */
3052 /* We don't strictly need prev in this loop; it should always be nil.
3053 But we use it for symmetry and in case that should cease to be true
3054 with some future change. */
3056 for (tail
= buf
->overlays_before
;
3058 prev
= tail
, tail
= next
)
3061 overlay
= XCAR (tail
);
3063 /* If the overlay is not valid, get rid of it. */
3064 if (!OVERLAY_VALID (overlay
))
3069 /* Splice the cons cell TAIL out of overlays_before. */
3073 buf
->overlays_before
= next
;
3079 beg
= OVERLAY_START (overlay
);
3080 end
= OVERLAY_END (overlay
);
3082 if (OVERLAY_POSITION (end
) > pos
)
3084 /* OVERLAY needs to be moved. */
3085 int where
= OVERLAY_POSITION (beg
);
3086 Lisp_Object other
, other_prev
;
3088 /* Splice the cons cell TAIL out of overlays_before. */
3090 XSETCDR (prev
, next
);
3092 buf
->overlays_before
= next
;
3094 /* Search thru overlays_after for where to put it. */
3096 for (other
= buf
->overlays_after
;
3098 other_prev
= other
, other
= XCDR (other
))
3100 Lisp_Object otherbeg
, otheroverlay
;
3102 otheroverlay
= XCAR (other
);
3103 if (! OVERLAY_VALID (otheroverlay
))
3106 otherbeg
= OVERLAY_START (otheroverlay
);
3107 if (OVERLAY_POSITION (otherbeg
) >= where
)
3111 /* Add TAIL to overlays_after before OTHER. */
3112 XSETCDR (tail
, other
);
3113 if (!NILP (other_prev
))
3114 XSETCDR (other_prev
, tail
);
3116 buf
->overlays_after
= tail
;
3120 /* We've reached the things that should stay in overlays_before.
3121 All the rest of overlays_before must end even earlier,
3126 /* See if anything in overlays_after should be in overlays_before. */
3128 for (tail
= buf
->overlays_after
;
3130 prev
= tail
, tail
= next
)
3133 overlay
= XCAR (tail
);
3135 /* If the overlay is not valid, get rid of it. */
3136 if (!OVERLAY_VALID (overlay
))
3141 /* Splice the cons cell TAIL out of overlays_after. */
3145 buf
->overlays_after
= next
;
3151 beg
= OVERLAY_START (overlay
);
3152 end
= OVERLAY_END (overlay
);
3154 /* Stop looking, when we know that nothing further
3155 can possibly end before POS. */
3156 if (OVERLAY_POSITION (beg
) > pos
)
3159 if (OVERLAY_POSITION (end
) <= pos
)
3161 /* OVERLAY needs to be moved. */
3162 int where
= OVERLAY_POSITION (end
);
3163 Lisp_Object other
, other_prev
;
3165 /* Splice the cons cell TAIL out of overlays_after. */
3167 XSETCDR (prev
, next
);
3169 buf
->overlays_after
= next
;
3171 /* Search thru overlays_before for where to put it. */
3173 for (other
= buf
->overlays_before
;
3175 other_prev
= other
, other
= XCDR (other
))
3177 Lisp_Object otherend
, otheroverlay
;
3179 otheroverlay
= XCAR (other
);
3180 if (! OVERLAY_VALID (otheroverlay
))
3183 otherend
= OVERLAY_END (otheroverlay
);
3184 if (OVERLAY_POSITION (otherend
) <= where
)
3188 /* Add TAIL to overlays_before before OTHER. */
3189 XSETCDR (tail
, other
);
3190 if (!NILP (other_prev
))
3191 XSETCDR (other_prev
, tail
);
3193 buf
->overlays_before
= tail
;
3198 XSETFASTINT (buf
->overlay_center
, pos
);
3202 adjust_overlays_for_insert (pos
, length
)
3206 /* After an insertion, the lists are still sorted properly,
3207 but we may need to update the value of the overlay center. */
3208 if (XFASTINT (current_buffer
->overlay_center
) >= pos
)
3209 XSETFASTINT (current_buffer
->overlay_center
,
3210 XFASTINT (current_buffer
->overlay_center
) + length
);
3214 adjust_overlays_for_delete (pos
, length
)
3218 if (XFASTINT (current_buffer
->overlay_center
) < pos
)
3219 /* The deletion was to our right. No change needed; the before- and
3220 after-lists are still consistent. */
3222 else if (XFASTINT (current_buffer
->overlay_center
) > pos
+ length
)
3223 /* The deletion was to our left. We need to adjust the center value
3224 to account for the change in position, but the lists are consistent
3225 given the new value. */
3226 XSETFASTINT (current_buffer
->overlay_center
,
3227 XFASTINT (current_buffer
->overlay_center
) - length
);
3229 /* We're right in the middle. There might be things on the after-list
3230 that now belong on the before-list. Recentering will move them,
3231 and also update the center point. */
3232 recenter_overlay_lists (current_buffer
, pos
);
3235 /* Fix up overlays that were garbled as a result of permuting markers
3236 in the range START through END. Any overlay with at least one
3237 endpoint in this range will need to be unlinked from the overlay
3238 list and reinserted in its proper place.
3239 Such an overlay might even have negative size at this point.
3240 If so, we'll reverse the endpoints. Can you think of anything
3241 better to do in this situation? */
3243 fix_overlays_in_range (start
, end
)
3244 register int start
, end
;
3246 Lisp_Object overlay
;
3247 Lisp_Object before_list
, after_list
;
3248 /* These are either nil, indicating that before_list or after_list
3249 should be assigned, or the cons cell the cdr of which should be
3251 Lisp_Object beforep
= Qnil
, afterp
= Qnil
;
3252 /* 'Parent', likewise, indicates a cons cell or
3253 current_buffer->overlays_before or overlays_after, depending
3254 which loop we're in. */
3255 Lisp_Object tail
, parent
;
3256 int startpos
, endpos
;
3258 /* This algorithm shifts links around instead of consing and GCing.
3259 The loop invariant is that before_list (resp. after_list) is a
3260 well-formed list except that its last element, the CDR of beforep
3261 (resp. afterp) if beforep (afterp) isn't nil or before_list
3262 (after_list) if it is, is still uninitialized. So it's not a bug
3263 that before_list isn't initialized, although it may look
3265 for (parent
= Qnil
, tail
= current_buffer
->overlays_before
; CONSP (tail
);)
3267 overlay
= XCAR (tail
);
3268 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3271 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3273 || (startpos
>= start
&& startpos
< end
))
3275 /* If the overlay is backwards, fix that now. */
3276 if (startpos
> endpos
)
3279 Fset_marker (OVERLAY_START (overlay
), make_number (endpos
),
3281 Fset_marker (OVERLAY_END (overlay
), make_number (startpos
),
3283 tem
= startpos
; startpos
= endpos
; endpos
= tem
;
3285 /* Add it to the end of the wrong list. Later on,
3286 recenter_overlay_lists will move it to the right place. */
3287 if (endpos
< XINT (current_buffer
->overlay_center
))
3292 XSETCDR (afterp
, tail
);
3300 XSETCDR (beforep
, tail
);
3304 current_buffer
->overlays_before
= XCDR (tail
);
3306 XSETCDR (parent
, XCDR (tail
));
3310 parent
= tail
, tail
= XCDR (parent
);
3312 for (parent
= Qnil
, tail
= current_buffer
->overlays_after
; CONSP (tail
);)
3314 overlay
= XCAR (tail
);
3315 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3316 if (startpos
>= end
)
3318 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3319 if (startpos
>= start
3320 || (endpos
>= start
&& endpos
< end
))
3322 if (startpos
> endpos
)
3325 Fset_marker (OVERLAY_START (overlay
), make_number (endpos
),
3327 Fset_marker (OVERLAY_END (overlay
), make_number (startpos
),
3329 tem
= startpos
; startpos
= endpos
; endpos
= tem
;
3331 if (endpos
< XINT (current_buffer
->overlay_center
))
3336 XSETCDR (afterp
, tail
);
3344 XSETCDR (beforep
, tail
);
3348 current_buffer
->overlays_after
= XCDR (tail
);
3350 XSETCDR (parent
, XCDR (tail
));
3354 parent
= tail
, tail
= XCDR (parent
);
3357 /* Splice the constructed (wrong) lists into the buffer's lists,
3358 and let the recenter function make it sane again. */
3359 if (!NILP (beforep
))
3361 XSETCDR (beforep
, current_buffer
->overlays_before
);
3362 current_buffer
->overlays_before
= before_list
;
3364 recenter_overlay_lists (current_buffer
,
3365 XINT (current_buffer
->overlay_center
));
3369 XSETCDR (afterp
, current_buffer
->overlays_after
);
3370 current_buffer
->overlays_after
= after_list
;
3372 recenter_overlay_lists (current_buffer
,
3373 XINT (current_buffer
->overlay_center
));
3376 /* We have two types of overlay: the one whose ending marker is
3377 after-insertion-marker (this is the usual case) and the one whose
3378 ending marker is before-insertion-marker. When `overlays_before'
3379 contains overlays of the latter type and the former type in this
3380 order and both overlays end at inserting position, inserting a text
3381 increases only the ending marker of the latter type, which results
3382 in incorrect ordering of `overlays_before'.
3384 This function fixes ordering of overlays in the slot
3385 `overlays_before' of the buffer *BP. Before the insertion, `point'
3386 was at PREV, and now is at POS. */
3389 fix_overlays_before (bp
, prev
, pos
)
3393 /* If parent is nil, replace overlays_before; otherwise, XCDR(parent). */
3394 Lisp_Object tail
= bp
->overlays_before
, parent
= Qnil
;
3395 Lisp_Object right_pair
;
3398 /* After the insertion, the several overlays may be in incorrect
3399 order. The possibility is that, in the list `overlays_before',
3400 an overlay which ends at POS appears after an overlay which ends
3401 at PREV. Since POS is greater than PREV, we must fix the
3402 ordering of these overlays, by moving overlays ends at POS before
3403 the overlays ends at PREV. */
3405 /* At first, find a place where disordered overlays should be linked
3406 in. It is where an overlay which end before POS exists. (i.e. an
3407 overlay whose ending marker is after-insertion-marker if disorder
3410 && ((end
= OVERLAY_POSITION (OVERLAY_END (XCAR (tail
))))
3417 /* If we don't find such an overlay,
3418 or the found one ends before PREV,
3419 or the found one is the last one in the list,
3420 we don't have to fix anything. */
3423 || NILP (XCDR (tail
)))
3426 right_pair
= parent
;
3430 /* Now, end position of overlays in the list TAIL should be before
3431 or equal to PREV. In the loop, an overlay which ends at POS is
3432 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3433 we found an overlay which ends before PREV, the remaining
3434 overlays are in correct order. */
3435 while (!NILP (tail
))
3437 end
= OVERLAY_POSITION (OVERLAY_END (XCAR (tail
)));
3440 { /* This overlay is disordered. */
3441 Lisp_Object found
= tail
;
3443 /* Unlink the found overlay. */
3444 tail
= XCDR (found
);
3445 XSETCDR (parent
, tail
);
3446 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3447 and link it into the right place. */
3448 if (NILP (right_pair
))
3450 XSETCDR (found
, bp
->overlays_before
);
3451 bp
->overlays_before
= found
;
3455 XSETCDR (found
, XCDR (right_pair
));
3456 XSETCDR (right_pair
, found
);
3459 else if (end
== prev
)
3464 else /* No more disordered overlay. */
3469 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3470 doc
: /* Return t if OBJECT is an overlay. */)
3474 return (OVERLAYP (object
) ? Qt
: Qnil
);
3477 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3478 doc
: /* Create a new overlay with range BEG to END in BUFFER.
3479 If omitted, BUFFER defaults to the current buffer.
3480 BEG and END may be integers or markers.
3481 The fourth arg FRONT-ADVANCE, if non-nil, makes the
3482 front delimiter advance when text is inserted there.
3483 The fifth arg REAR-ADVANCE, if non-nil, makes the
3484 rear delimiter advance when text is inserted there. */)
3485 (beg
, end
, buffer
, front_advance
, rear_advance
)
3486 Lisp_Object beg
, end
, buffer
;
3487 Lisp_Object front_advance
, rear_advance
;
3489 Lisp_Object overlay
;
3493 XSETBUFFER (buffer
, current_buffer
);
3495 CHECK_BUFFER (buffer
);
3497 && ! EQ (Fmarker_buffer (beg
), buffer
))
3498 error ("Marker points into wrong buffer");
3500 && ! EQ (Fmarker_buffer (end
), buffer
))
3501 error ("Marker points into wrong buffer");
3503 CHECK_NUMBER_COERCE_MARKER (beg
);
3504 CHECK_NUMBER_COERCE_MARKER (end
);
3506 if (XINT (beg
) > XINT (end
))
3509 temp
= beg
; beg
= end
; end
= temp
;
3512 b
= XBUFFER (buffer
);
3514 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3515 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3517 if (!NILP (front_advance
))
3518 XMARKER (beg
)->insertion_type
= 1;
3519 if (!NILP (rear_advance
))
3520 XMARKER (end
)->insertion_type
= 1;
3522 overlay
= allocate_misc ();
3523 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3524 XOVERLAY (overlay
)->start
= beg
;
3525 XOVERLAY (overlay
)->end
= end
;
3526 XOVERLAY (overlay
)->plist
= Qnil
;
3528 /* Put the new overlay on the wrong list. */
3529 end
= OVERLAY_END (overlay
);
3530 if (OVERLAY_POSITION (end
) < XINT (b
->overlay_center
))
3531 b
->overlays_after
= Fcons (overlay
, b
->overlays_after
);
3533 b
->overlays_before
= Fcons (overlay
, b
->overlays_before
);
3535 /* This puts it in the right list, and in the right order. */
3536 recenter_overlay_lists (b
, XINT (b
->overlay_center
));
3538 /* We don't need to redisplay the region covered by the overlay, because
3539 the overlay has no properties at the moment. */
3544 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3547 modify_overlay (buf
, start
, end
)
3558 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3560 /* If this is a buffer not in the selected window,
3561 we must do other windows. */
3562 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3563 windows_or_buffers_changed
= 1;
3564 /* If multiple windows show this buffer, we must do other windows. */
3565 else if (buffer_shared
> 1)
3566 windows_or_buffers_changed
= 1;
3568 ++BUF_OVERLAY_MODIFF (buf
);
3572 Lisp_Object
Fdelete_overlay ();
3574 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3575 doc
: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3576 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3577 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3579 (overlay
, beg
, end
, buffer
)
3580 Lisp_Object overlay
, beg
, end
, buffer
;
3582 struct buffer
*b
, *ob
;
3583 Lisp_Object obuffer
;
3584 int count
= SPECPDL_INDEX ();
3586 CHECK_OVERLAY (overlay
);
3588 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3590 XSETBUFFER (buffer
, current_buffer
);
3591 CHECK_BUFFER (buffer
);
3594 && ! EQ (Fmarker_buffer (beg
), buffer
))
3595 error ("Marker points into wrong buffer");
3597 && ! EQ (Fmarker_buffer (end
), buffer
))
3598 error ("Marker points into wrong buffer");
3600 CHECK_NUMBER_COERCE_MARKER (beg
);
3601 CHECK_NUMBER_COERCE_MARKER (end
);
3603 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3604 return Fdelete_overlay (overlay
);
3606 if (XINT (beg
) > XINT (end
))
3609 temp
= beg
; beg
= end
; end
= temp
;
3612 specbind (Qinhibit_quit
, Qt
);
3614 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3615 b
= XBUFFER (buffer
);
3616 ob
= BUFFERP (obuffer
) ? XBUFFER (obuffer
) : (struct buffer
*) 0;
3618 /* If the overlay has changed buffers, do a thorough redisplay. */
3619 if (!EQ (buffer
, obuffer
))
3621 /* Redisplay where the overlay was. */
3622 if (!NILP (obuffer
))
3627 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3628 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3630 modify_overlay (ob
, o_beg
, o_end
);
3633 /* Redisplay where the overlay is going to be. */
3634 modify_overlay (b
, XINT (beg
), XINT (end
));
3637 /* Redisplay the area the overlay has just left, or just enclosed. */
3641 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3642 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3644 if (o_beg
== XINT (beg
))
3645 modify_overlay (b
, o_end
, XINT (end
));
3646 else if (o_end
== XINT (end
))
3647 modify_overlay (b
, o_beg
, XINT (beg
));
3650 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
3651 if (XINT (end
) > o_end
) o_end
= XINT (end
);
3652 modify_overlay (b
, o_beg
, o_end
);
3656 if (!NILP (obuffer
))
3658 ob
->overlays_before
= Fdelq (overlay
, ob
->overlays_before
);
3659 ob
->overlays_after
= Fdelq (overlay
, ob
->overlays_after
);
3662 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3663 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3665 /* Put the overlay on the wrong list. */
3666 end
= OVERLAY_END (overlay
);
3667 if (OVERLAY_POSITION (end
) < XINT (b
->overlay_center
))
3668 b
->overlays_after
= Fcons (overlay
, b
->overlays_after
);
3670 b
->overlays_before
= Fcons (overlay
, b
->overlays_before
);
3672 /* This puts it in the right list, and in the right order. */
3673 recenter_overlay_lists (b
, XINT (b
->overlay_center
));
3675 return unbind_to (count
, overlay
);
3678 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
3679 doc
: /* Delete the overlay OVERLAY from its buffer. */)
3681 Lisp_Object overlay
;
3685 int count
= SPECPDL_INDEX ();
3687 CHECK_OVERLAY (overlay
);
3689 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3693 b
= XBUFFER (buffer
);
3694 specbind (Qinhibit_quit
, Qt
);
3696 b
->overlays_before
= Fdelq (overlay
, b
->overlays_before
);
3697 b
->overlays_after
= Fdelq (overlay
, b
->overlays_after
);
3699 marker_position (OVERLAY_START (overlay
)),
3700 marker_position (OVERLAY_END (overlay
)));
3701 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
3702 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
3704 /* When deleting an overlay with before or after strings, turn off
3705 display optimizations for the affected buffer, on the basis that
3706 these strings may contain newlines. This is easier to do than to
3707 check for that situation during redisplay. */
3708 if (!windows_or_buffers_changed
3709 && (!NILP (Foverlay_get (overlay
, Qbefore_string
))
3710 || !NILP (Foverlay_get (overlay
, Qafter_string
))))
3711 b
->prevent_redisplay_optimizations_p
= 1;
3713 return unbind_to (count
, Qnil
);
3716 /* Overlay dissection functions. */
3718 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
3719 doc
: /* Return the position at which OVERLAY starts. */)
3721 Lisp_Object overlay
;
3723 CHECK_OVERLAY (overlay
);
3725 return (Fmarker_position (OVERLAY_START (overlay
)));
3728 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
3729 doc
: /* Return the position at which OVERLAY ends. */)
3731 Lisp_Object overlay
;
3733 CHECK_OVERLAY (overlay
);
3735 return (Fmarker_position (OVERLAY_END (overlay
)));
3738 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
3739 doc
: /* Return the buffer OVERLAY belongs to. */)
3741 Lisp_Object overlay
;
3743 CHECK_OVERLAY (overlay
);
3745 return Fmarker_buffer (OVERLAY_START (overlay
));
3748 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
3749 doc
: /* Return a list of the properties on OVERLAY.
3750 This is a copy of OVERLAY's plist; modifying its conses has no effect on
3753 Lisp_Object overlay
;
3755 CHECK_OVERLAY (overlay
);
3757 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
3761 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
3762 doc
: /* Return a list of the overlays that contain position POS. */)
3767 Lisp_Object
*overlay_vec
;
3771 CHECK_NUMBER_COERCE_MARKER (pos
);
3774 /* We can't use alloca here because overlays_at can call xrealloc. */
3775 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3777 /* Put all the overlays we want in a vector in overlay_vec.
3778 Store the length in len. */
3779 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3780 (int *) 0, (int *) 0, 0);
3782 /* Make a list of them all. */
3783 result
= Flist (noverlays
, overlay_vec
);
3785 xfree (overlay_vec
);
3789 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
3790 doc
: /* Return a list of the overlays that overlap the region BEG ... END.
3791 Overlap means that at least one character is contained within the overlay
3792 and also contained within the specified region.
3793 Empty overlays are included in the result if they are located at BEG
3794 or between BEG and END. */)
3796 Lisp_Object beg
, end
;
3799 Lisp_Object
*overlay_vec
;
3803 CHECK_NUMBER_COERCE_MARKER (beg
);
3804 CHECK_NUMBER_COERCE_MARKER (end
);
3807 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3809 /* Put all the overlays we want in a vector in overlay_vec.
3810 Store the length in len. */
3811 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
3812 (int *) 0, (int *) 0);
3814 /* Make a list of them all. */
3815 result
= Flist (noverlays
, overlay_vec
);
3817 xfree (overlay_vec
);
3821 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
3823 doc
: /* Return the next position after POS where an overlay starts or ends.
3824 If there are no more overlay boundaries after POS, return (point-max). */)
3830 Lisp_Object
*overlay_vec
;
3834 CHECK_NUMBER_COERCE_MARKER (pos
);
3837 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3839 /* Put all the overlays we want in a vector in overlay_vec.
3840 Store the length in len.
3841 endpos gets the position where the next overlay starts. */
3842 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3843 &endpos
, (int *) 0, 1);
3845 /* If any of these overlays ends before endpos,
3846 use its ending point instead. */
3847 for (i
= 0; i
< noverlays
; i
++)
3852 oend
= OVERLAY_END (overlay_vec
[i
]);
3853 oendpos
= OVERLAY_POSITION (oend
);
3854 if (oendpos
< endpos
)
3858 xfree (overlay_vec
);
3859 return make_number (endpos
);
3862 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
3863 Sprevious_overlay_change
, 1, 1, 0,
3864 doc
: /* Return the previous position before POS where an overlay starts or ends.
3865 If there are no more overlay boundaries before POS, return (point-min). */)
3871 Lisp_Object
*overlay_vec
;
3874 CHECK_NUMBER_COERCE_MARKER (pos
);
3876 /* At beginning of buffer, we know the answer;
3877 avoid bug subtracting 1 below. */
3878 if (XINT (pos
) == BEGV
)
3882 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3884 /* Put all the overlays we want in a vector in overlay_vec.
3885 Store the length in len.
3886 prevpos gets the position of the previous change. */
3887 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3888 (int *) 0, &prevpos
, 1);
3890 xfree (overlay_vec
);
3891 return make_number (prevpos
);
3894 /* These functions are for debugging overlays. */
3896 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
3897 doc
: /* Return a pair of lists giving all the overlays of the current buffer.
3898 The car has all the overlays before the overlay center;
3899 the cdr has all the overlays after the overlay center.
3900 Recentering overlays moves overlays between these lists.
3901 The lists you get are copies, so that changing them has no effect.
3902 However, the overlays you get are the real objects that the buffer uses. */)
3905 Lisp_Object before
, after
;
3906 before
= current_buffer
->overlays_before
;
3908 before
= Fcopy_sequence (before
);
3909 after
= current_buffer
->overlays_after
;
3911 after
= Fcopy_sequence (after
);
3913 return Fcons (before
, after
);
3916 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
3917 doc
: /* Recenter the overlays of the current buffer around position POS. */)
3921 CHECK_NUMBER_COERCE_MARKER (pos
);
3923 recenter_overlay_lists (current_buffer
, XINT (pos
));
3927 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
3928 doc
: /* Get the property of overlay OVERLAY with property name PROP. */)
3930 Lisp_Object overlay
, prop
;
3932 CHECK_OVERLAY (overlay
);
3933 return lookup_char_property (XOVERLAY (overlay
)->plist
, prop
, 0);
3936 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
3937 doc
: /* Set one property of overlay OVERLAY: give property PROP value VALUE. */)
3938 (overlay
, prop
, value
)
3939 Lisp_Object overlay
, prop
, value
;
3941 Lisp_Object tail
, buffer
;
3944 CHECK_OVERLAY (overlay
);
3946 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3948 for (tail
= XOVERLAY (overlay
)->plist
;
3949 CONSP (tail
) && CONSP (XCDR (tail
));
3950 tail
= XCDR (XCDR (tail
)))
3951 if (EQ (XCAR (tail
), prop
))
3953 changed
= !EQ (XCAR (XCDR (tail
)), value
);
3954 XSETCAR (XCDR (tail
), value
);
3957 /* It wasn't in the list, so add it to the front. */
3958 changed
= !NILP (value
);
3959 XOVERLAY (overlay
)->plist
3960 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
3962 if (! NILP (buffer
))
3965 modify_overlay (XBUFFER (buffer
),
3966 marker_position (OVERLAY_START (overlay
)),
3967 marker_position (OVERLAY_END (overlay
)));
3968 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
3969 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
3970 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
3971 Fdelete_overlay (overlay
);
3976 /* Subroutine of report_overlay_modification. */
3978 /* Lisp vector holding overlay hook functions to call.
3979 Vector elements come in pairs.
3980 Each even-index element is a list of hook functions.
3981 The following odd-index element is the overlay they came from.
3983 Before the buffer change, we fill in this vector
3984 as we call overlay hook functions.
3985 After the buffer change, we get the functions to call from this vector.
3986 This way we always call the same functions before and after the change. */
3987 static Lisp_Object last_overlay_modification_hooks
;
3989 /* Number of elements actually used in last_overlay_modification_hooks. */
3990 static int last_overlay_modification_hooks_used
;
3992 /* Add one functionlist/overlay pair
3993 to the end of last_overlay_modification_hooks. */
3996 add_overlay_mod_hooklist (functionlist
, overlay
)
3997 Lisp_Object functionlist
, overlay
;
3999 int oldsize
= XVECTOR (last_overlay_modification_hooks
)->size
;
4001 if (last_overlay_modification_hooks_used
== oldsize
)
4004 old
= last_overlay_modification_hooks
;
4005 last_overlay_modification_hooks
4006 = Fmake_vector (make_number (oldsize
* 2), Qnil
);
4007 bcopy (XVECTOR (old
)->contents
,
4008 XVECTOR (last_overlay_modification_hooks
)->contents
,
4009 sizeof (Lisp_Object
) * oldsize
);
4011 XVECTOR (last_overlay_modification_hooks
)->contents
[last_overlay_modification_hooks_used
++] = functionlist
;
4012 XVECTOR (last_overlay_modification_hooks
)->contents
[last_overlay_modification_hooks_used
++] = overlay
;
4015 /* Run the modification-hooks of overlays that include
4016 any part of the text in START to END.
4017 If this change is an insertion, also
4018 run the insert-before-hooks of overlay starting at END,
4019 and the insert-after-hooks of overlay ending at START.
4021 This is called both before and after the modification.
4022 AFTER is nonzero when we call after the modification.
4024 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4025 When AFTER is nonzero, they are the start position,
4026 the position after the inserted new text,
4027 and the length of deleted or replaced old text. */
4030 report_overlay_modification (start
, end
, after
, arg1
, arg2
, arg3
)
4031 Lisp_Object start
, end
;
4033 Lisp_Object arg1
, arg2
, arg3
;
4035 Lisp_Object prop
, overlay
, tail
;
4036 /* 1 if this change is an insertion. */
4037 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
4039 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
4043 GCPRO5 (overlay
, tail
, arg1
, arg2
, arg3
);
4047 /* Call the functions recorded in last_overlay_modification_hooks
4048 rather than scanning the overlays again.
4049 First copy the vector contents, in case some of these hooks
4050 do subsequent modification of the buffer. */
4051 int size
= last_overlay_modification_hooks_used
;
4052 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
4055 bcopy (XVECTOR (last_overlay_modification_hooks
)->contents
,
4056 copy
, size
* sizeof (Lisp_Object
));
4058 gcpro1
.nvars
= size
;
4060 for (i
= 0; i
< size
;)
4062 Lisp_Object prop
, overlay
;
4064 overlay
= copy
[i
++];
4065 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4071 /* We are being called before a change.
4072 Scan the overlays to find the functions to call. */
4073 last_overlay_modification_hooks_used
= 0;
4075 for (tail
= current_buffer
->overlays_before
;
4079 int startpos
, endpos
;
4080 Lisp_Object ostart
, oend
;
4082 overlay
= XCAR (tail
);
4084 ostart
= OVERLAY_START (overlay
);
4085 oend
= OVERLAY_END (overlay
);
4086 endpos
= OVERLAY_POSITION (oend
);
4087 if (XFASTINT (start
) > endpos
)
4089 startpos
= OVERLAY_POSITION (ostart
);
4090 if (insertion
&& (XFASTINT (start
) == startpos
4091 || XFASTINT (end
) == startpos
))
4093 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4096 /* Copy TAIL in case the hook recenters the overlay lists. */
4098 tail
= Fcopy_sequence (tail
);
4100 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4103 if (insertion
&& (XFASTINT (start
) == endpos
4104 || XFASTINT (end
) == endpos
))
4106 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4110 tail
= Fcopy_sequence (tail
);
4112 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4115 /* Test for intersecting intervals. This does the right thing
4116 for both insertion and deletion. */
4117 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4119 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4123 tail
= Fcopy_sequence (tail
);
4125 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4131 for (tail
= current_buffer
->overlays_after
;
4135 int startpos
, endpos
;
4136 Lisp_Object ostart
, oend
;
4138 overlay
= XCAR (tail
);
4140 ostart
= OVERLAY_START (overlay
);
4141 oend
= OVERLAY_END (overlay
);
4142 startpos
= OVERLAY_POSITION (ostart
);
4143 endpos
= OVERLAY_POSITION (oend
);
4144 if (XFASTINT (end
) < startpos
)
4146 if (insertion
&& (XFASTINT (start
) == startpos
4147 || XFASTINT (end
) == startpos
))
4149 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
4153 tail
= Fcopy_sequence (tail
);
4155 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4158 if (insertion
&& (XFASTINT (start
) == endpos
4159 || XFASTINT (end
) == endpos
))
4161 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
4165 tail
= Fcopy_sequence (tail
);
4167 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4170 /* Test for intersecting intervals. This does the right thing
4171 for both insertion and deletion. */
4172 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
4174 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
4178 tail
= Fcopy_sequence (tail
);
4180 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
4189 call_overlay_mod_hooks (list
, overlay
, after
, arg1
, arg2
, arg3
)
4190 Lisp_Object list
, overlay
;
4192 Lisp_Object arg1
, arg2
, arg3
;
4194 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4196 GCPRO4 (list
, arg1
, arg2
, arg3
);
4198 add_overlay_mod_hooklist (list
, overlay
);
4200 while (!NILP (list
))
4203 call4 (Fcar (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
4205 call5 (Fcar (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4211 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4214 evaporate_overlays (pos
)
4217 Lisp_Object tail
, overlay
, hit_list
;
4220 if (pos
<= XFASTINT (current_buffer
->overlay_center
))
4221 for (tail
= current_buffer
->overlays_before
; CONSP (tail
);
4225 overlay
= XCAR (tail
);
4226 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4229 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4230 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4231 hit_list
= Fcons (overlay
, hit_list
);
4234 for (tail
= current_buffer
->overlays_after
; CONSP (tail
);
4238 overlay
= XCAR (tail
);
4239 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4242 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4243 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4244 hit_list
= Fcons (overlay
, hit_list
);
4246 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4247 Fdelete_overlay (XCAR (hit_list
));
4250 /* Somebody has tried to store a value with an unacceptable type
4251 in the slot with offset OFFSET. */
4254 buffer_slot_type_mismatch (offset
)
4260 switch (XINT (PER_BUFFER_TYPE (offset
)))
4263 type_name
= "integers";
4267 type_name
= "strings";
4271 type_name
= "symbols";
4278 sym
= PER_BUFFER_SYMBOL (offset
);
4279 error ("Only %s should be stored in the buffer-local variable %s",
4280 type_name
, SDATA (SYMBOL_NAME (sym
)));
4284 /***********************************************************************
4285 Allocation with mmap
4286 ***********************************************************************/
4288 #ifdef USE_MMAP_FOR_BUFFERS
4290 #include <sys/types.h>
4291 #include <sys/mman.h>
4294 #ifdef MAP_ANONYMOUS
4295 #define MAP_ANON MAP_ANONYMOUS
4302 #define MAP_FAILED ((void *) -1)
4315 /* Memory is allocated in regions which are mapped using mmap(2).
4316 The current implementation lets the system select mapped
4317 addresses; we're not using MAP_FIXED in general, except when
4318 trying to enlarge regions.
4320 Each mapped region starts with a mmap_region structure, the user
4321 area starts after that structure, aligned to MEM_ALIGN.
4323 +-----------------------+
4324 | struct mmap_info + |
4326 +-----------------------+
4330 +-----------------------+ */
4334 /* User-specified size. */
4335 size_t nbytes_specified
;
4337 /* Number of bytes mapped */
4338 size_t nbytes_mapped
;
4340 /* Pointer to the location holding the address of the memory
4341 allocated with the mmap'd block. The variable actually points
4342 after this structure. */
4345 /* Next and previous in list of all mmap'd regions. */
4346 struct mmap_region
*next
, *prev
;
4349 /* Doubly-linked list of mmap'd regions. */
4351 static struct mmap_region
*mmap_regions
;
4353 /* File descriptor for mmap. If we don't have anonymous mapping,
4354 /dev/zero will be opened on it. */
4358 /* Temporary storage for mmap_set_vars, see there. */
4360 static struct mmap_region
*mmap_regions_1
;
4361 static int mmap_fd_1
;
4363 /* Page size on this system. */
4365 static int mmap_page_size
;
4367 /* 1 means mmap has been intialized. */
4369 static int mmap_initialized_p
;
4371 /* Value is X rounded up to the next multiple of N. */
4373 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4375 /* Size of mmap_region structure plus padding. */
4377 #define MMAP_REGION_STRUCT_SIZE \
4378 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4380 /* Given a pointer P to the start of the user-visible part of a mapped
4381 region, return a pointer to the start of the region. */
4383 #define MMAP_REGION(P) \
4384 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4386 /* Given a pointer P to the start of a mapped region, return a pointer
4387 to the start of the user-visible part of the region. */
4389 #define MMAP_USER_AREA(P) \
4390 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4392 #define MEM_ALIGN sizeof (double)
4394 /* Predicate returning true if part of the address range [START ..
4395 END[ is currently mapped. Used to prevent overwriting an existing
4398 Default is to conservativly assume the address range is occupied by
4399 something else. This can be overridden by system configuration
4400 files if system-specific means to determine this exists. */
4402 #ifndef MMAP_ALLOCATED_P
4403 #define MMAP_ALLOCATED_P(start, end) 1
4406 /* Function prototypes. */
4408 static int mmap_free_1
P_ ((struct mmap_region
*));
4409 static int mmap_enlarge
P_ ((struct mmap_region
*, int));
4410 static struct mmap_region
*mmap_find
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
4411 static POINTER_TYPE
*mmap_alloc
P_ ((POINTER_TYPE
**, size_t));
4412 static POINTER_TYPE
*mmap_realloc
P_ ((POINTER_TYPE
**, size_t));
4413 static void mmap_free
P_ ((POINTER_TYPE
**ptr
));
4414 static void mmap_init
P_ ((void));
4417 /* Return a region overlapping address range START...END, or null if
4418 none. END is not including, i.e. the last byte in the range
4421 static struct mmap_region
*
4422 mmap_find (start
, end
)
4423 POINTER_TYPE
*start
, *end
;
4425 struct mmap_region
*r
;
4426 char *s
= (char *) start
, *e
= (char *) end
;
4428 for (r
= mmap_regions
; r
; r
= r
->next
)
4430 char *rstart
= (char *) r
;
4431 char *rend
= rstart
+ r
->nbytes_mapped
;
4433 if (/* First byte of range, i.e. START, in this region? */
4434 (s
>= rstart
&& s
< rend
)
4435 /* Last byte of range, i.e. END - 1, in this region? */
4436 || (e
> rstart
&& e
<= rend
)
4437 /* First byte of this region in the range? */
4438 || (rstart
>= s
&& rstart
< e
)
4439 /* Last byte of this region in the range? */
4440 || (rend
> s
&& rend
<= e
))
4448 /* Unmap a region. P is a pointer to the start of the user-araa of
4449 the region. Value is non-zero if successful. */
4453 struct mmap_region
*r
;
4456 r
->next
->prev
= r
->prev
;
4458 r
->prev
->next
= r
->next
;
4460 mmap_regions
= r
->next
;
4462 if (munmap ((POINTER_TYPE
*) r
, r
->nbytes_mapped
) == -1)
4464 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4472 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4473 Value is non-zero if successful. */
4476 mmap_enlarge (r
, npages
)
4477 struct mmap_region
*r
;
4480 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4486 /* Unmap pages at the end of the region. */
4487 nbytes
= - npages
* mmap_page_size
;
4488 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4489 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4492 r
->nbytes_mapped
-= nbytes
;
4496 else if (npages
> 0)
4498 nbytes
= npages
* mmap_page_size
;
4500 /* Try to map additional pages at the end of the region. We
4501 cannot do this if the address range is already occupied by
4502 something else because mmap deletes any previous mapping.
4503 I'm not sure this is worth doing, let's see. */
4504 if (!MMAP_ALLOCATED_P (region_end
, region_end
+ nbytes
))
4508 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4509 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4510 if (p
== MAP_FAILED
)
4511 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4512 else if (p
!= (POINTER_TYPE
*) region_end
)
4514 /* Kernels are free to choose a different address. In
4515 that case, unmap what we've mapped above; we have
4517 if (munmap (p
, nbytes
) == -1)
4518 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4522 r
->nbytes_mapped
+= nbytes
;
4532 /* Set or reset variables holding references to mapped regions. If
4533 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4534 non-zero, set all variables to the start of the user-areas
4537 This function is called from Fdump_emacs to ensure that the dumped
4538 Emacs doesn't contain references to memory that won't be mapped
4539 when Emacs starts. */
4542 mmap_set_vars (restore_p
)
4545 struct mmap_region
*r
;
4549 mmap_regions
= mmap_regions_1
;
4550 mmap_fd
= mmap_fd_1
;
4551 for (r
= mmap_regions
; r
; r
= r
->next
)
4552 *r
->var
= MMAP_USER_AREA (r
);
4556 for (r
= mmap_regions
; r
; r
= r
->next
)
4558 mmap_regions_1
= mmap_regions
;
4559 mmap_regions
= NULL
;
4560 mmap_fd_1
= mmap_fd
;
4566 /* Allocate a block of storage large enough to hold NBYTES bytes of
4567 data. A pointer to the data is returned in *VAR. VAR is thus the
4568 address of some variable which will use the data area.
4570 The allocation of 0 bytes is valid.
4572 If we can't allocate the necessary memory, set *VAR to null, and
4575 static POINTER_TYPE
*
4576 mmap_alloc (var
, nbytes
)
4585 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4586 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4589 if (p
== MAP_FAILED
)
4591 if (errno
!= ENOMEM
)
4592 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4597 struct mmap_region
*r
= (struct mmap_region
*) p
;
4599 r
->nbytes_specified
= nbytes
;
4600 r
->nbytes_mapped
= map
;
4603 r
->next
= mmap_regions
;
4608 p
= MMAP_USER_AREA (p
);
4615 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4616 resize it to size NBYTES. Change *VAR to reflect the new block,
4617 and return this value. If more memory cannot be allocated, then
4618 leave *VAR unchanged, and return null. */
4620 static POINTER_TYPE
*
4621 mmap_realloc (var
, nbytes
)
4625 POINTER_TYPE
*result
;
4630 result
= mmap_alloc (var
, nbytes
);
4631 else if (nbytes
== 0)
4634 result
= mmap_alloc (var
, nbytes
);
4638 struct mmap_region
*r
= MMAP_REGION (*var
);
4639 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4644 POINTER_TYPE
*old_ptr
= *var
;
4646 /* Try to map additional pages at the end of the region.
4647 If that fails, allocate a new region, copy data
4648 from the old region, then free it. */
4649 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4652 r
->nbytes_specified
= nbytes
;
4653 *var
= result
= old_ptr
;
4655 else if (mmap_alloc (var
, nbytes
))
4657 bcopy (old_ptr
, *var
, r
->nbytes_specified
);
4658 mmap_free_1 (MMAP_REGION (old_ptr
));
4660 r
= MMAP_REGION (result
);
4661 r
->nbytes_specified
= nbytes
;
4669 else if (room
- nbytes
>= mmap_page_size
)
4671 /* Shrinking by at least a page. Let's give some
4672 memory back to the system. */
4673 mmap_enlarge (r
, - (room
- nbytes
) / mmap_page_size
);
4675 r
->nbytes_specified
= nbytes
;
4679 /* Leave it alone. */
4681 r
->nbytes_specified
= nbytes
;
4689 /* Free a block of relocatable storage whose data is pointed to by
4690 PTR. Store 0 in *PTR to show there's no block allocated. */
4700 mmap_free_1 (MMAP_REGION (*var
));
4706 /* Perform necessary intializations for the use of mmap. */
4712 /* The value of mmap_fd is initially 0 in temacs, and -1
4713 in a dumped Emacs. */
4716 /* No anonymous mmap -- we need the file descriptor. */
4717 mmap_fd
= open ("/dev/zero", O_RDONLY
);
4719 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4721 #endif /* MAP_ANON == 0 */
4723 if (mmap_initialized_p
)
4725 mmap_initialized_p
= 1;
4731 mmap_page_size
= getpagesize ();
4734 #endif /* USE_MMAP_FOR_BUFFERS */
4738 /***********************************************************************
4739 Buffer-text Allocation
4740 ***********************************************************************/
4743 extern POINTER_TYPE
*r_alloc
P_ ((POINTER_TYPE
**, size_t));
4744 extern POINTER_TYPE
*r_re_alloc
P_ ((POINTER_TYPE
**, size_t));
4745 extern void r_alloc_free
P_ ((POINTER_TYPE
**ptr
));
4746 #endif /* REL_ALLOC */
4749 /* Allocate NBYTES bytes for buffer B's text buffer. */
4752 alloc_buffer_text (b
, nbytes
)
4759 #if defined USE_MMAP_FOR_BUFFERS
4760 p
= mmap_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4761 #elif defined REL_ALLOC
4762 p
= r_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4764 p
= xmalloc (nbytes
);
4773 b
->text
->beg
= (unsigned char *) p
;
4777 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4781 enlarge_buffer_text (b
, delta
)
4786 size_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4789 #if defined USE_MMAP_FOR_BUFFERS
4790 p
= mmap_realloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4791 #elif defined REL_ALLOC
4792 p
= r_re_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4794 p
= xrealloc (b
->text
->beg
, nbytes
);
4803 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
4808 /* Free buffer B's text buffer. */
4811 free_buffer_text (b
)
4816 #if defined USE_MMAP_FOR_BUFFERS
4817 mmap_free ((POINTER_TYPE
**) &b
->text
->beg
);
4818 #elif defined REL_ALLOC
4819 r_alloc_free ((POINTER_TYPE
**) &b
->text
->beg
);
4821 xfree (b
->text
->beg
);
4824 BUF_BEG_ADDR (b
) = NULL
;
4830 /***********************************************************************
4832 ***********************************************************************/
4839 bzero (buffer_permanent_local_flags
, sizeof buffer_permanent_local_flags
);
4841 /* Make sure all markable slots in buffer_defaults
4842 are initialized reasonably, so mark_buffer won't choke. */
4843 reset_buffer (&buffer_defaults
);
4844 reset_buffer_local_variables (&buffer_defaults
, 1);
4845 reset_buffer (&buffer_local_symbols
);
4846 reset_buffer_local_variables (&buffer_local_symbols
, 1);
4847 /* Prevent GC from getting confused. */
4848 buffer_defaults
.text
= &buffer_defaults
.own_text
;
4849 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
4850 BUF_INTERVALS (&buffer_defaults
) = 0;
4851 BUF_INTERVALS (&buffer_local_symbols
) = 0;
4852 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
4853 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
4855 /* Set up the default values of various buffer slots. */
4856 /* Must do these before making the first buffer! */
4858 /* real setup is done in bindings.el */
4859 buffer_defaults
.mode_line_format
= build_string ("%-");
4860 buffer_defaults
.header_line_format
= Qnil
;
4861 buffer_defaults
.abbrev_mode
= Qnil
;
4862 buffer_defaults
.overwrite_mode
= Qnil
;
4863 buffer_defaults
.case_fold_search
= Qt
;
4864 buffer_defaults
.auto_fill_function
= Qnil
;
4865 buffer_defaults
.selective_display
= Qnil
;
4867 buffer_defaults
.selective_display_ellipses
= Qt
;
4869 buffer_defaults
.abbrev_table
= Qnil
;
4870 buffer_defaults
.display_table
= Qnil
;
4871 buffer_defaults
.undo_list
= Qnil
;
4872 buffer_defaults
.mark_active
= Qnil
;
4873 buffer_defaults
.file_format
= Qnil
;
4874 buffer_defaults
.overlays_before
= Qnil
;
4875 buffer_defaults
.overlays_after
= Qnil
;
4876 XSETFASTINT (buffer_defaults
.overlay_center
, BEG
);
4878 XSETFASTINT (buffer_defaults
.tab_width
, 8);
4879 buffer_defaults
.truncate_lines
= Qnil
;
4880 buffer_defaults
.ctl_arrow
= Qt
;
4881 buffer_defaults
.direction_reversed
= Qnil
;
4882 buffer_defaults
.cursor_type
= Qt
;
4883 buffer_defaults
.extra_line_spacing
= Qnil
;
4886 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
4888 buffer_defaults
.enable_multibyte_characters
= Qt
;
4889 buffer_defaults
.buffer_file_coding_system
= Qnil
;
4890 XSETFASTINT (buffer_defaults
.fill_column
, 70);
4891 XSETFASTINT (buffer_defaults
.left_margin
, 0);
4892 buffer_defaults
.cache_long_line_scans
= Qnil
;
4893 buffer_defaults
.file_truename
= Qnil
;
4894 XSETFASTINT (buffer_defaults
.display_count
, 0);
4895 buffer_defaults
.indicate_empty_lines
= Qnil
;
4896 buffer_defaults
.scroll_up_aggressively
= Qnil
;
4897 buffer_defaults
.scroll_down_aggressively
= Qnil
;
4898 buffer_defaults
.display_time
= Qnil
;
4900 /* Assign the local-flags to the slots that have default values.
4901 The local flag is a bit that is used in the buffer
4902 to say that it has its own local value for the slot.
4903 The local flag bits are in the local_var_flags slot of the buffer. */
4905 /* Nothing can work if this isn't true */
4906 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
4908 /* 0 means not a lisp var, -1 means always local, else mask */
4909 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
4910 XSETINT (buffer_local_flags
.filename
, -1);
4911 XSETINT (buffer_local_flags
.directory
, -1);
4912 XSETINT (buffer_local_flags
.backed_up
, -1);
4913 XSETINT (buffer_local_flags
.save_length
, -1);
4914 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
4915 XSETINT (buffer_local_flags
.read_only
, -1);
4916 XSETINT (buffer_local_flags
.major_mode
, -1);
4917 XSETINT (buffer_local_flags
.mode_name
, -1);
4918 XSETINT (buffer_local_flags
.undo_list
, -1);
4919 XSETINT (buffer_local_flags
.mark_active
, -1);
4920 XSETINT (buffer_local_flags
.point_before_scroll
, -1);
4921 XSETINT (buffer_local_flags
.file_truename
, -1);
4922 XSETINT (buffer_local_flags
.invisibility_spec
, -1);
4923 XSETINT (buffer_local_flags
.file_format
, -1);
4924 XSETINT (buffer_local_flags
.display_count
, -1);
4925 XSETINT (buffer_local_flags
.display_time
, -1);
4926 XSETINT (buffer_local_flags
.enable_multibyte_characters
, -1);
4929 XSETFASTINT (buffer_local_flags
.mode_line_format
, idx
); ++idx
;
4930 XSETFASTINT (buffer_local_flags
.abbrev_mode
, idx
); ++idx
;
4931 XSETFASTINT (buffer_local_flags
.overwrite_mode
, idx
); ++idx
;
4932 XSETFASTINT (buffer_local_flags
.case_fold_search
, idx
); ++idx
;
4933 XSETFASTINT (buffer_local_flags
.auto_fill_function
, idx
); ++idx
;
4934 XSETFASTINT (buffer_local_flags
.selective_display
, idx
); ++idx
;
4936 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, idx
); ++idx
;
4938 XSETFASTINT (buffer_local_flags
.tab_width
, idx
); ++idx
;
4939 XSETFASTINT (buffer_local_flags
.truncate_lines
, idx
); ++idx
;
4940 XSETFASTINT (buffer_local_flags
.ctl_arrow
, idx
); ++idx
;
4941 XSETFASTINT (buffer_local_flags
.fill_column
, idx
); ++idx
;
4942 XSETFASTINT (buffer_local_flags
.left_margin
, idx
); ++idx
;
4943 XSETFASTINT (buffer_local_flags
.abbrev_table
, idx
); ++idx
;
4944 XSETFASTINT (buffer_local_flags
.display_table
, idx
); ++idx
;
4946 XSETFASTINT (buffer_local_flags
.buffer_file_type
, idx
);
4947 /* Make this one a permanent local. */
4948 buffer_permanent_local_flags
[idx
++] = 1;
4950 XSETFASTINT (buffer_local_flags
.syntax_table
, idx
); ++idx
;
4951 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, idx
); ++idx
;
4952 XSETFASTINT (buffer_local_flags
.category_table
, idx
); ++idx
;
4953 XSETFASTINT (buffer_local_flags
.direction_reversed
, idx
); ++idx
;
4954 XSETFASTINT (buffer_local_flags
.buffer_file_coding_system
, idx
);
4955 /* Make this one a permanent local. */
4956 buffer_permanent_local_flags
[idx
++] = 1;
4957 XSETFASTINT (buffer_local_flags
.left_margin_width
, idx
); ++idx
;
4958 XSETFASTINT (buffer_local_flags
.right_margin_width
, idx
); ++idx
;
4959 XSETFASTINT (buffer_local_flags
.indicate_empty_lines
, idx
); ++idx
;
4960 XSETFASTINT (buffer_local_flags
.scroll_up_aggressively
, idx
); ++idx
;
4961 XSETFASTINT (buffer_local_flags
.scroll_down_aggressively
, idx
); ++idx
;
4962 XSETFASTINT (buffer_local_flags
.header_line_format
, idx
); ++idx
;
4963 XSETFASTINT (buffer_local_flags
.cursor_type
, idx
); ++idx
;
4964 XSETFASTINT (buffer_local_flags
.extra_line_spacing
, idx
); ++idx
;
4966 /* Need more room? */
4967 if (idx
>= MAX_PER_BUFFER_VARS
)
4969 last_per_buffer_idx
= idx
;
4971 Vbuffer_alist
= Qnil
;
4975 QSFundamental
= build_string ("Fundamental");
4977 Qfundamental_mode
= intern ("fundamental-mode");
4978 buffer_defaults
.major_mode
= Qfundamental_mode
;
4980 Qmode_class
= intern ("mode-class");
4982 Qprotected_field
= intern ("protected-field");
4984 Qpermanent_local
= intern ("permanent-local");
4986 Qkill_buffer_hook
= intern ("kill-buffer-hook");
4988 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
4990 /* super-magic invisible buffer */
4991 Vbuffer_alist
= Qnil
;
4993 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
4995 inhibit_modification_hooks
= 0;
5001 char buf
[MAXPATHLEN
+ 1];
5003 struct stat dotstat
, pwdstat
;
5007 #ifdef USE_MMAP_FOR_BUFFERS
5009 /* When using the ralloc implementation based on mmap(2), buffer
5010 text pointers will have been set to null in the dumped Emacs.
5014 for (b
= all_buffers
; b
; b
= b
->next
)
5015 if (b
->text
->beg
== NULL
)
5016 enlarge_buffer_text (b
, 0);
5018 #endif /* USE_MMAP_FOR_BUFFERS */
5020 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5021 if (NILP (buffer_defaults
.enable_multibyte_characters
))
5022 Fset_buffer_multibyte (Qnil
);
5024 /* If PWD is accurate, use it instead of calling getwd. PWD is
5025 sometimes a nicer name, and using it may avoid a fatal error if a
5026 parent directory is searchable but not readable. */
5027 if ((pwd
= getenv ("PWD")) != 0
5028 && (IS_DIRECTORY_SEP (*pwd
) || (*pwd
&& IS_DEVICE_SEP (pwd
[1])))
5029 && stat (pwd
, &pwdstat
) == 0
5030 && stat (".", &dotstat
) == 0
5031 && dotstat
.st_ino
== pwdstat
.st_ino
5032 && dotstat
.st_dev
== pwdstat
.st_dev
5033 && strlen (pwd
) < MAXPATHLEN
)
5036 else if (getcwd (buf
, MAXPATHLEN
+1) == 0)
5037 fatal ("`getcwd' failed: %s\n", strerror (errno
));
5039 else if (getwd (buf
) == 0)
5040 fatal ("`getwd' failed: %s\n", buf
);
5044 /* Maybe this should really use some standard subroutine
5045 whose definition is filename syntax dependent. */
5047 if (!(IS_DIRECTORY_SEP (buf
[rc
- 1])))
5049 buf
[rc
] = DIRECTORY_SEP
;
5052 #endif /* not VMS */
5054 current_buffer
->directory
= build_string (buf
);
5056 /* Add /: to the front of the name
5057 if it would otherwise be treated as magic. */
5058 temp
= Ffind_file_name_handler (current_buffer
->directory
, Qt
);
5060 /* If the default dir is just /, TEMP is non-nil
5061 because of the ange-ftp completion handler.
5062 However, it is not necessary to turn / into /:/.
5063 So avoid doing that. */
5064 && strcmp ("/", SDATA (current_buffer
->directory
)))
5065 current_buffer
->directory
5066 = concat2 (build_string ("/:"), current_buffer
->directory
);
5068 temp
= get_minibuffer (0);
5069 XBUFFER (temp
)->directory
= current_buffer
->directory
;
5072 /* initialize the buffer routines */
5076 staticpro (&last_overlay_modification_hooks
);
5077 last_overlay_modification_hooks
5078 = Fmake_vector (make_number (10), Qnil
);
5080 staticpro (&Vbuffer_defaults
);
5081 staticpro (&Vbuffer_local_symbols
);
5082 staticpro (&Qfundamental_mode
);
5083 staticpro (&Qmode_class
);
5084 staticpro (&QSFundamental
);
5085 staticpro (&Vbuffer_alist
);
5086 staticpro (&Qprotected_field
);
5087 staticpro (&Qpermanent_local
);
5088 staticpro (&Qkill_buffer_hook
);
5089 Qoverlayp
= intern ("overlayp");
5090 staticpro (&Qoverlayp
);
5091 Qevaporate
= intern ("evaporate");
5092 staticpro (&Qevaporate
);
5093 Qmodification_hooks
= intern ("modification-hooks");
5094 staticpro (&Qmodification_hooks
);
5095 Qinsert_in_front_hooks
= intern ("insert-in-front-hooks");
5096 staticpro (&Qinsert_in_front_hooks
);
5097 Qinsert_behind_hooks
= intern ("insert-behind-hooks");
5098 staticpro (&Qinsert_behind_hooks
);
5099 Qget_file_buffer
= intern ("get-file-buffer");
5100 staticpro (&Qget_file_buffer
);
5101 Qpriority
= intern ("priority");
5102 staticpro (&Qpriority
);
5103 Qwindow
= intern ("window");
5104 staticpro (&Qwindow
);
5105 Qbefore_string
= intern ("before-string");
5106 staticpro (&Qbefore_string
);
5107 Qafter_string
= intern ("after-string");
5108 staticpro (&Qafter_string
);
5109 Qfirst_change_hook
= intern ("first-change-hook");
5110 staticpro (&Qfirst_change_hook
);
5111 Qbefore_change_functions
= intern ("before-change-functions");
5112 staticpro (&Qbefore_change_functions
);
5113 Qafter_change_functions
= intern ("after-change-functions");
5114 staticpro (&Qafter_change_functions
);
5116 Fput (Qprotected_field
, Qerror_conditions
,
5117 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
5118 Fput (Qprotected_field
, Qerror_message
,
5119 build_string ("Attempt to modify a protected field"));
5121 /* All these use DEFVAR_LISP_NOPRO because the slots in
5122 buffer_defaults will all be marked via Vbuffer_defaults. */
5124 DEFVAR_LISP_NOPRO ("default-mode-line-format",
5125 &buffer_defaults
.mode_line_format
,
5126 doc
: /* Default value of `mode-line-format' for buffers that don't override it.
5127 This is the same as (default-value 'mode-line-format). */);
5129 DEFVAR_LISP_NOPRO ("default-header-line-format",
5130 &buffer_defaults
.header_line_format
,
5131 doc
: /* Default value of `header-line-format' for buffers that don't override it.
5132 This is the same as (default-value 'header-line-format). */);
5134 DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults
.cursor_type
,
5135 doc
: /* Default value of `cursor-type' for buffers that don't override it.
5136 This is the same as (default-value 'cursor-type). */);
5138 DEFVAR_LISP_NOPRO ("default-line-spacing",
5139 &buffer_defaults
.extra_line_spacing
,
5140 doc
: /* Default value of `line-spacing' for buffers that don't override it.
5141 This is the same as (default-value 'line-spacing). */);
5143 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
5144 &buffer_defaults
.abbrev_mode
,
5145 doc
: /* Default value of `abbrev-mode' for buffers that do not override it.
5146 This is the same as (default-value 'abbrev-mode). */);
5148 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
5149 &buffer_defaults
.ctl_arrow
,
5150 doc
: /* Default value of `ctl-arrow' for buffers that do not override it.
5151 This is the same as (default-value 'ctl-arrow). */);
5153 DEFVAR_LISP_NOPRO ("default-direction-reversed",
5154 &buffer_defaults
.direction_reversed
,
5155 doc
: /* Default value of `direction_reversed' for buffers that do not override it.
5156 This is the same as (default-value 'direction-reversed). */);
5158 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
5159 &buffer_defaults
.enable_multibyte_characters
,
5160 doc
: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
5161 This is the same as (default-value 'enable-multibyte-characters). */);
5163 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
5164 &buffer_defaults
.buffer_file_coding_system
,
5165 doc
: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5166 This is the same as (default-value 'buffer-file-coding-system). */);
5168 DEFVAR_LISP_NOPRO ("default-truncate-lines",
5169 &buffer_defaults
.truncate_lines
,
5170 doc
: /* Default value of `truncate-lines' for buffers that do not override it.
5171 This is the same as (default-value 'truncate-lines). */);
5173 DEFVAR_LISP_NOPRO ("default-fill-column",
5174 &buffer_defaults
.fill_column
,
5175 doc
: /* Default value of `fill-column' for buffers that do not override it.
5176 This is the same as (default-value 'fill-column). */);
5178 DEFVAR_LISP_NOPRO ("default-left-margin",
5179 &buffer_defaults
.left_margin
,
5180 doc
: /* Default value of `left-margin' for buffers that do not override it.
5181 This is the same as (default-value 'left-margin). */);
5183 DEFVAR_LISP_NOPRO ("default-tab-width",
5184 &buffer_defaults
.tab_width
,
5185 doc
: /* Default value of `tab-width' for buffers that do not override it.
5186 This is the same as (default-value 'tab-width). */);
5188 DEFVAR_LISP_NOPRO ("default-case-fold-search",
5189 &buffer_defaults
.case_fold_search
,
5190 doc
: /* Default value of `case-fold-search' for buffers that don't override it.
5191 This is the same as (default-value 'case-fold-search). */);
5194 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
5195 &buffer_defaults
.buffer_file_type
,
5196 doc
: /* Default file type for buffers that do not override it.
5197 This is the same as (default-value 'buffer-file-type).
5198 The file type is nil for text, t for binary. */);
5201 DEFVAR_LISP_NOPRO ("default-left-margin-width",
5202 &buffer_defaults
.left_margin_width
,
5203 doc
: /* Default value of `left-margin-width' for buffers that don't override it.
5204 This is the same as (default-value 'left-margin-width). */);
5206 DEFVAR_LISP_NOPRO ("default-right-margin-width",
5207 &buffer_defaults
.right_margin_width
,
5208 doc
: /* Default value of `right_margin_width' for buffers that don't override it.
5209 This is the same as (default-value 'right-margin-width). */);
5211 DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
5212 &buffer_defaults
.indicate_empty_lines
,
5213 doc
: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5214 This is the same as (default-value 'indicate-empty-lines). */);
5216 DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
5217 &buffer_defaults
.scroll_up_aggressively
,
5218 doc
: /* Default value of `scroll-up-aggressively'.
5219 This value applies in buffers that don't have their own local values.
5220 This variable is an alias for (default-value 'scroll-up-aggressively). */);
5222 DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
5223 &buffer_defaults
.scroll_down_aggressively
,
5224 doc
: /* Default value of `scroll-down-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-down-aggressively). */);
5228 DEFVAR_PER_BUFFER ("header-line-format",
5229 ¤t_buffer
->header_line_format
,
5231 doc
: /* Analogous to `mode-line-format', but controls the header line.
5232 The header line appears, optionally, at the top of a window;
5233 the mode line appears at the bottom. */);
5235 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
5237 doc
: /* Template for displaying mode line for current buffer.
5238 Each buffer has its own value of this variable.
5239 Value may be nil, a string, a symbol or a list or cons cell.
5240 A value of nil means don't display a mode line.
5241 For a symbol, its value is used (but it is ignored if t or nil).
5242 A string appearing directly as the value of a symbol is processed verbatim
5243 in that the %-constructs below are not recognized.
5244 For a list of the form `(:eval FORM)', FORM is evaluated and the result
5245 is used as a mode line element.
5246 For a list whose car is a symbol, the symbol's value is taken,
5247 and if that is non-nil, the cadr of the list is processed recursively.
5248 Otherwise, the caddr of the list (if there is one) is processed.
5249 For a list whose car is a string or list, each element is processed
5250 recursively and the results are effectively concatenated.
5251 For a list whose car is an integer, the cdr of the list is processed
5252 and padded (if the number is positive) or truncated (if negative)
5253 to the width specified by that number.
5254 A string is printed verbatim in the mode line except for %-constructs:
5255 (%-constructs are allowed when the string is the entire mode-line-format
5256 or when it is found in a cons-cell or a list)
5257 %b -- print buffer name. %f -- print visited file name.
5258 %F -- print frame name.
5259 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5260 %& is like %*, but ignore read-only-ness.
5261 % means buffer is read-only and * means it is modified.
5262 For a modified read-only buffer, %* gives % and %+ gives *.
5263 %s -- print process status. %l -- print the current line number.
5264 %c -- print the current column number (this makes editing slower).
5265 To make the column number update correctly in all cases,
5266 `column-number-mode' must be non-nil.
5267 %p -- print percent of buffer above top of window, or Top, Bot or All.
5268 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5269 or print Bottom or All.
5270 %m -- print the mode name.
5271 %n -- print Narrow if appropriate.
5272 %z -- print mnemonics of buffer, terminal, and keyboard coding systems.
5273 %Z -- like %z, but including the end-of-line format.
5274 %[ -- print one [ for each recursive editing level. %] similar.
5275 %% -- print %. %- -- print infinitely many dashes.
5276 Decimal digits after the % specify field width to which to pad. */);
5278 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
5279 doc
: /* *Major mode for new buffers. Defaults to `fundamental-mode'.
5280 nil here means use current buffer's major mode. */);
5282 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
5283 make_number (Lisp_Symbol
),
5284 doc
: /* Symbol for current buffer's major mode. */);
5286 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
5288 doc
: /* Pretty name of current buffer's major mode (a string). */);
5290 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
5291 doc
: /* Non-nil turns on automatic expansion of abbrevs as they are inserted. */);
5293 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
5295 doc
: /* *Non-nil if searches and matches should ignore case. */);
5297 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
5298 make_number (Lisp_Int
),
5299 doc
: /* *Column beyond which automatic line-wrapping should happen. */);
5301 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
5302 make_number (Lisp_Int
),
5303 doc
: /* *Column for the default indent-line-function to indent to.
5304 Linefeed indents to this column in Fundamental mode. */);
5306 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
5307 make_number (Lisp_Int
),
5308 doc
: /* *Distance between tab stops (for display of tab characters), in columns. */);
5310 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
5311 doc
: /* *Non-nil means display control chars with uparrow.
5312 A value of nil means use backslash and octal digits.
5313 This variable does not apply to characters whose display is specified
5314 in the current display table (if there is one). */);
5316 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5317 ¤t_buffer
->enable_multibyte_characters
,
5319 doc
: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5320 Otherwise they are regarded as unibyte. This affects the display,
5321 file I/O and the behavior of various editing commands.
5323 This variable is buffer-local but you cannot set it directly;
5324 use the function `set-buffer-multibyte' to change a buffer's representation.
5325 Changing its default value with `setq-default' is supported.
5326 See also variable `default-enable-multibyte-characters' and Info node
5327 `(elisp)Text Representations'. */);
5329 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5330 ¤t_buffer
->buffer_file_coding_system
, Qnil
,
5331 doc
: /* Coding system to be used for encoding the buffer contents on saving.
5332 This variable applies to saving the buffer, and also to `write-region'
5333 and other functions that use `write-region'.
5334 It does not apply to sending output to subprocesses, however.
5336 If this is nil, the buffer is saved without any code conversion
5337 unless some coding system is specified in `file-coding-system-alist'
5338 for the buffer file.
5340 If the text to be saved cannot be encoded as specified by this variable,
5341 an alternative encoding is selected by `select-safe-coding-system', which see.
5343 The variable `coding-system-for-write', if non-nil, overrides this variable.
5345 This variable is never applied to a way of decoding a file while reading it. */);
5347 DEFVAR_PER_BUFFER ("direction-reversed", ¤t_buffer
->direction_reversed
,
5349 doc
: /* *Non-nil means lines in the buffer are displayed right to left. */);
5351 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
5352 doc
: /* *Non-nil means do not display continuation lines.
5353 Instead, give each line of text just one screen line.
5355 Note that this is overridden by the variable
5356 `truncate-partial-width-windows' if that variable is non-nil
5357 and this buffer is not full-frame width. */);
5360 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
5362 doc
: /* Non-nil if the visited file is a binary file.
5363 This variable is meaningful on MS-DOG and Windows NT.
5364 On those systems, it is automatically local in every buffer.
5365 On other systems, this variable is normally always nil. */);
5368 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
5369 make_number (Lisp_String
),
5370 doc
: /* Name of default directory of current buffer. Should end with slash.
5371 To interactively change the default directory, use command `cd'. */);
5373 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
5375 doc
: /* Function called (if non-nil) to perform auto-fill.
5376 It is called after self-inserting any character specified in
5377 the `auto-fill-chars' table.
5378 NOTE: This variable is not a hook;
5379 its value may not be a list of functions. */);
5381 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
5382 make_number (Lisp_String
),
5383 doc
: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5385 DEFVAR_PER_BUFFER ("buffer-file-truename", ¤t_buffer
->file_truename
,
5386 make_number (Lisp_String
),
5387 doc
: /* Abbreviated truename of file visited in current buffer, or nil if none.
5388 The truename of a file is calculated by `file-truename'
5389 and then abbreviated with `abbreviate-file-name'. */);
5391 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5392 ¤t_buffer
->auto_save_file_name
,
5393 make_number (Lisp_String
),
5394 doc
: /* Name of file for auto-saving current buffer.
5395 If it is nil, that means don't auto-save this buffer. */);
5397 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
5398 doc
: /* Non-nil if this buffer is read-only. */);
5400 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
5401 doc
: /* Non-nil if this buffer's file has been backed up.
5402 Backing up is done before the first time the file is saved. */);
5404 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
5405 make_number (Lisp_Int
),
5406 doc
: /* Length of current buffer when last read in, saved or auto-saved.
5409 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
5411 doc
: /* Non-nil enables selective display.
5412 An Integer N as value means display only lines
5413 that start with less than n columns of space.
5414 A value of t means that the character ^M makes itself and
5415 all the rest of the line invisible; also, when saving the buffer
5416 in a file, save the ^M as a newline. */);
5419 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5420 ¤t_buffer
->selective_display_ellipses
,
5422 doc
: /* Non-nil means display ... on previous line when a line is invisible. */);
5425 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
5426 doc
: /* Non-nil if self-insertion should replace existing text.
5427 The value should be one of `overwrite-mode-textual',
5428 `overwrite-mode-binary', or nil.
5429 If it is `overwrite-mode-textual', self-insertion still
5430 inserts at the end of a line, and inserts when point is before a tab,
5431 until the tab is filled in.
5432 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5434 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
5436 doc
: /* Display table that controls display of the contents of current buffer.
5438 If this variable is nil, the value of `standard-display-table' is used.
5439 Each window can have its own, overriding display table, see
5440 `set-window-display-table' and `window-display-table'.
5442 The display table is a char-table created with `make-display-table'.
5443 A char-table is an array indexed by character codes. Normal array
5444 primitives `aref' and `aset' can be used to access elements of a char-table.
5446 Each of the char-table elements control how to display the corresponding
5447 text character: the element at index C in the table says how to display
5448 the character whose code is C. Each element should be a vector of
5449 characters or nil. nil means display the character in the default fashion;
5450 otherwise, the characters from the vector are delivered to the screen
5451 instead of the original character.
5453 For example, (aset buffer-display-table ?X ?Y) will cause Emacs to display
5454 a capital Y instead of each X character.
5456 In addition, a char-table has six extra slots to control the display of:
5458 the end of a truncated screen line (extra-slot 0, a single character);
5459 the end of a continued line (extra-slot 1, a single character);
5460 the escape character used to display character codes in octal
5461 (extra-slot 2, a single character);
5462 the character used as an arrow for control characters (extra-slot 3,
5463 a single character);
5464 the decoration indicating the presence of invisible lines (extra-slot 4,
5465 a vector of characters);
5466 the character used to draw the border between side-by-side windows
5467 (extra-slot 5, a single character).
5469 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5471 DEFVAR_PER_BUFFER ("left-margin-width", ¤t_buffer
->left_margin_width
,
5473 doc
: /* *Width of left marginal area for display of a buffer.
5474 A value of nil means no marginal area. */);
5476 DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer
->right_margin_width
,
5478 doc
: /* *Width of right marginal area for display of a buffer.
5479 A value of nil means no marginal area. */);
5481 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5482 ¤t_buffer
->indicate_empty_lines
, Qnil
,
5483 doc
: /* *Visually indicate empty lines after the buffer end.
5484 If non-nil, a bitmap is displayed in the left fringe of a window on
5485 window-systems. */);
5487 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5488 ¤t_buffer
->scroll_up_aggressively
, Qnil
,
5489 doc
: /* *If a number, scroll display up aggressively.
5490 If scrolling a window because point is below the window end, choose
5491 a new window start so that point ends up that fraction of the window's
5492 height from the bottom of the window. */);
5494 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
5495 ¤t_buffer
->scroll_down_aggressively
, Qnil
,
5496 doc
: /* *If a number, scroll display down aggressively.
5497 If scrolling a window because point is above the window start, choose
5498 a new window start so that point ends up that fraction of the window's
5499 height from the top of the window. */);
5501 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
5505 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
5506 doc
: /* List of functions to call before each text change.
5507 Two arguments are passed to each function: the positions of
5508 the beginning and end of the range of old text to be changed.
5509 \(For an insertion, the beginning and end are at the same place.)
5510 No information is given about the length of the text after the change.
5512 Buffer changes made while executing the `before-change-functions'
5513 don't call any before-change or after-change functions.
5514 That's because these variables are temporarily set to nil.
5515 As a result, a hook function cannot straightforwardly alter the value of
5516 these variables. See the Emacs Lisp manual for a way of
5517 accomplishing an equivalent result by using other variables.
5519 If an unhandled error happens in running these functions,
5520 the variable's value remains nil. That prevents the error
5521 from happening repeatedly and making Emacs nonfunctional. */);
5522 Vbefore_change_functions
= Qnil
;
5524 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
5525 doc
: /* List of functions to call after each text change.
5526 Three arguments are passed to each function: the positions of
5527 the beginning and end of the range of changed text,
5528 and the length in bytes of the pre-change text replaced by that range.
5529 \(For an insertion, the pre-change length is zero;
5530 for a deletion, that length is the number of bytes deleted,
5531 and the post-change beginning and end are at the same place.)
5533 Buffer changes made while executing the `after-change-functions'
5534 don't call any before-change or after-change functions.
5535 That's because these variables are temporarily set to nil.
5536 As a result, a hook function cannot straightforwardly alter the value of
5537 these variables. See the Emacs Lisp manual for a way of
5538 accomplishing an equivalent result by using other variables.
5540 If an unhandled error happens in running these functions,
5541 the variable's value remains nil. That prevents the error
5542 from happening repeatedly and making Emacs nonfunctional. */);
5543 Vafter_change_functions
= Qnil
;
5545 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
5546 doc
: /* A list of functions to call before changing a buffer which is unmodified.
5547 The functions are run using the `run-hooks' function. */);
5548 Vfirst_change_hook
= Qnil
;
5550 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
5551 doc
: /* List of undo entries in current buffer.
5552 Recent changes come first; older changes follow newer.
5554 An entry (BEG . END) represents an insertion which begins at
5555 position BEG and ends at position END.
5557 An entry (TEXT . POSITION) represents the deletion of the string TEXT
5558 from (abs POSITION). If POSITION is positive, point was at the front
5559 of the text being deleted; if negative, point was at the end.
5561 An entry (t HIGH . LOW) indicates that the buffer previously had
5562 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions
5563 of the visited file's modification time, as of that time. If the
5564 modification time of the most recent save is different, this entry is
5567 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
5568 was modified between BEG and END. PROPERTY is the property name,
5569 and VALUE is the old value.
5571 An entry (MARKER . DISTANCE) indicates that the marker MARKER
5572 was adjusted in position by the offset DISTANCE (an integer).
5574 An entry of the form POSITION indicates that point was at the buffer
5575 location given by the integer. Undoing an entry of this form places
5578 nil marks undo boundaries. The undo command treats the changes
5579 between two undo boundaries as a single step to be undone.
5581 If the value of the variable is t, undo information is not recorded. */);
5583 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
5584 doc
: /* Non-nil means the mark and region are currently active in this buffer. */);
5586 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
5587 doc
: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
5589 Normally, the line-motion functions work by scanning the buffer for
5590 newlines. Columnar operations (like move-to-column and
5591 compute-motion) also work by scanning the buffer, summing character
5592 widths as they go. This works well for ordinary text, but if the
5593 buffer's lines are very long (say, more than 500 characters), these
5594 motion functions will take longer to execute. Emacs may also take
5595 longer to update the display.
5597 If cache-long-line-scans is non-nil, these motion functions cache the
5598 results of their scans, and consult the cache to avoid rescanning
5599 regions of the buffer until the text is modified. The caches are most
5600 beneficial when they prevent the most searching---that is, when the
5601 buffer contains long lines and large regions of characters with the
5602 same, fixed screen width.
5604 When cache-long-line-scans is non-nil, processing short lines will
5605 become slightly slower (because of the overhead of consulting the
5606 cache), and the caches will use memory roughly proportional to the
5607 number of newlines and characters whose screen width varies.
5609 The caches require no explicit maintenance; their accuracy is
5610 maintained internally by the Emacs primitives. Enabling or disabling
5611 the cache should not affect the behavior of any of the motion
5612 functions; it should only affect their performance. */);
5614 DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer
->point_before_scroll
, Qnil
,
5615 doc
: /* Value of point before the last series of scroll operations, or nil. */);
5617 DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer
->file_format
, Qnil
,
5618 doc
: /* List of formats to use when saving this buffer.
5619 Formats are defined by `format-alist'. This variable is
5620 set when a file is visited. Automatically local in all buffers. */);
5622 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
5623 ¤t_buffer
->invisibility_spec
, Qnil
,
5624 doc
: /* Invisibility spec of this buffer.
5625 The default is t, which means that text is invisible
5626 if it has a non-nil `invisible' property.
5627 If the value is a list, a text character is invisible if its `invisible'
5628 property is an element in that list.
5629 If an element is a cons cell of the form (PROP . ELLIPSIS),
5630 then characters with property value PROP are invisible,
5631 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
5633 DEFVAR_PER_BUFFER ("buffer-display-count",
5634 ¤t_buffer
->display_count
, Qnil
,
5635 doc
: /* A number incremented each time this buffer is displayed in a window.
5636 The function `set-window-buffer' increments it. */);
5638 DEFVAR_PER_BUFFER ("buffer-display-time",
5639 ¤t_buffer
->display_time
, Qnil
,
5640 doc
: /* Time stamp updated each time this buffer is displayed in a window.
5641 The function `set-window-buffer' updates this variable
5642 to the value obtained by calling `current-time'.
5643 If the buffer has never been shown in a window, the value is nil. */);
5645 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
5646 doc
: /* *Non-nil means deactivate the mark when the buffer contents change.
5647 Non-nil also enables highlighting of the region whenever the mark is active.
5648 The variable `highlight-nonselected-windows' controls whether to highlight
5649 all windows or just the selected window. */);
5650 Vtransient_mark_mode
= Qnil
;
5652 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
5653 doc
: /* *Non-nil means disregard read-only status of buffers or characters.
5654 If the value is t, disregard `buffer-read-only' and all `read-only'
5655 text properties. If the value is a list, disregard `buffer-read-only'
5656 and disregard a `read-only' text property if the property value
5657 is a member of the list. */);
5658 Vinhibit_read_only
= Qnil
;
5660 DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer
->cursor_type
, Qnil
,
5661 doc
: /* Cursor to use when this buffer is in the selected window.
5662 Values are interpreted as follows:
5664 t use the cursor specified for the frame
5665 nil don't display a cursor
5666 bar display a bar cursor with default width
5667 (bar . WIDTH) display a bar cursor with width WIDTH
5668 ANYTHING ELSE display a box cursor.
5670 When the buffer is displayed in a nonselected window,
5671 this variable has no effect; the cursor appears as a hollow box. */);
5673 DEFVAR_PER_BUFFER ("line-spacing",
5674 ¤t_buffer
->extra_line_spacing
, Qnil
,
5675 doc
: /* Additional space to put between lines when displaying a buffer.
5676 The space is measured in pixels, and put below lines on window systems. */);
5678 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
5679 doc
: /* List of functions called with no args to query before killing a buffer. */);
5680 Vkill_buffer_query_functions
= Qnil
;
5682 defsubr (&Sbuffer_live_p
);
5683 defsubr (&Sbuffer_list
);
5684 defsubr (&Sget_buffer
);
5685 defsubr (&Sget_file_buffer
);
5686 defsubr (&Sget_buffer_create
);
5687 defsubr (&Smake_indirect_buffer
);
5688 defsubr (&Sgenerate_new_buffer_name
);
5689 defsubr (&Sbuffer_name
);
5690 /*defsubr (&Sbuffer_number);*/
5691 defsubr (&Sbuffer_file_name
);
5692 defsubr (&Sbuffer_base_buffer
);
5693 defsubr (&Sbuffer_local_value
);
5694 defsubr (&Sbuffer_local_variables
);
5695 defsubr (&Sbuffer_modified_p
);
5696 defsubr (&Sset_buffer_modified_p
);
5697 defsubr (&Sbuffer_modified_tick
);
5698 defsubr (&Srename_buffer
);
5699 defsubr (&Sother_buffer
);
5700 defsubr (&Sbuffer_disable_undo
);
5701 defsubr (&Sbuffer_enable_undo
);
5702 defsubr (&Skill_buffer
);
5703 defsubr (&Sset_buffer_major_mode
);
5704 defsubr (&Sswitch_to_buffer
);
5705 defsubr (&Spop_to_buffer
);
5706 defsubr (&Scurrent_buffer
);
5707 defsubr (&Sset_buffer
);
5708 defsubr (&Sbarf_if_buffer_read_only
);
5709 defsubr (&Sbury_buffer
);
5710 defsubr (&Serase_buffer
);
5711 defsubr (&Sset_buffer_multibyte
);
5712 defsubr (&Skill_all_local_variables
);
5714 defsubr (&Soverlayp
);
5715 defsubr (&Smake_overlay
);
5716 defsubr (&Sdelete_overlay
);
5717 defsubr (&Smove_overlay
);
5718 defsubr (&Soverlay_start
);
5719 defsubr (&Soverlay_end
);
5720 defsubr (&Soverlay_buffer
);
5721 defsubr (&Soverlay_properties
);
5722 defsubr (&Soverlays_at
);
5723 defsubr (&Soverlays_in
);
5724 defsubr (&Snext_overlay_change
);
5725 defsubr (&Sprevious_overlay_change
);
5726 defsubr (&Soverlay_recenter
);
5727 defsubr (&Soverlay_lists
);
5728 defsubr (&Soverlay_get
);
5729 defsubr (&Soverlay_put
);
5730 defsubr (&Srestore_buffer_modified_p
);
5736 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
5737 initial_define_key (control_x_map
, 'k', "kill-buffer");
5739 /* This must not be in syms_of_buffer, because Qdisabled is not
5740 initialized when that function gets called. */
5741 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);