1 /* Buffer manipulation primitives for GNU Emacs.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994, 1995, 1997
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. */
23 #include <sys/types.h>
25 #include <sys/param.h>
31 /* in 4.1, param.h fails to define this. */
32 #define MAXPATHLEN 1024
33 #endif /* not MAXPATHLEN */
37 #include "intervals.h"
42 #include "region-cache.h"
44 #include "blockinput.h"
47 struct buffer
*current_buffer
; /* the current buffer */
49 /* First buffer in chain of all buffers (in reverse order of creation).
50 Threaded through ->next. */
52 struct buffer
*all_buffers
;
54 /* This structure holds the default values of the buffer-local variables
55 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
56 The default value occupies the same slot in this structure
57 as an individual buffer's value occupies in that buffer.
58 Setting the default value also goes through the alist of buffers
59 and stores into each buffer that does not say it has a local value. */
61 struct buffer buffer_defaults
;
63 /* A Lisp_Object pointer to the above, used for staticpro */
65 static Lisp_Object Vbuffer_defaults
;
67 /* This structure marks which slots in a buffer have corresponding
68 default values in buffer_defaults.
69 Each such slot has a nonzero value in this structure.
70 The value has only one nonzero bit.
72 When a buffer has its own local value for a slot,
73 the bit for that slot (found in the same slot in this structure)
74 is turned on in the buffer's local_var_flags slot.
76 If a slot in this structure is -1, then even though there may
77 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
78 and the corresponding slot in buffer_defaults is not used.
80 If a slot is -2, then there is no DEFVAR_PER_BUFFER for it,
81 but there is a default value which is copied into each buffer.
83 If a slot in this structure is negative, then even though there may
84 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
85 and the corresponding slot in buffer_defaults is not used.
87 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
88 zero, that is a bug */
90 struct buffer buffer_local_flags
;
92 /* This structure holds the names of symbols whose values may be
93 buffer-local. It is indexed and accessed in the same way as the above. */
95 struct buffer buffer_local_symbols
;
96 /* A Lisp_Object pointer to the above, used for staticpro */
97 static Lisp_Object Vbuffer_local_symbols
;
99 /* This structure holds the required types for the values in the
100 buffer-local slots. If a slot contains Qnil, then the
101 corresponding buffer slot may contain a value of any type. If a
102 slot contains an integer, then prospective values' tags must be
103 equal to that integer. When a tag does not match, the function
104 buffer_slot_type_mismatch will signal an error. */
105 struct buffer buffer_local_types
;
107 /* Flags indicating which built-in buffer-local variables
108 are permanent locals. */
109 static int buffer_permanent_local_flags
;
111 Lisp_Object
Fset_buffer ();
112 void set_buffer_internal ();
113 void set_buffer_internal_1 ();
114 static void call_overlay_mod_hooks ();
115 static void swap_out_buffer_local_variables ();
116 static void reset_buffer_local_variables ();
118 /* Alist of all buffer names vs the buffers. */
119 /* This used to be a variable, but is no longer,
120 to prevent lossage due to user rplac'ing this alist or its elements. */
121 Lisp_Object Vbuffer_alist
;
123 /* Functions to call before and after each text change. */
124 Lisp_Object Vbefore_change_function
;
125 Lisp_Object Vafter_change_function
;
126 Lisp_Object Vbefore_change_functions
;
127 Lisp_Object Vafter_change_functions
;
129 Lisp_Object Vtransient_mark_mode
;
131 /* t means ignore all read-only text properties.
132 A list means ignore such a property if its value is a member of the list.
133 Any non-nil value means ignore buffer-read-only. */
134 Lisp_Object Vinhibit_read_only
;
136 /* List of functions to call that can query about killing a buffer.
137 If any of these functions returns nil, we don't kill it. */
138 Lisp_Object Vkill_buffer_query_functions
;
140 /* List of functions to call before changing an unmodified buffer. */
141 Lisp_Object Vfirst_change_hook
;
143 Lisp_Object Qfirst_change_hook
;
144 Lisp_Object Qbefore_change_functions
;
145 Lisp_Object Qafter_change_functions
;
147 Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
149 Lisp_Object Qprotected_field
;
151 Lisp_Object QSFundamental
; /* A string "Fundamental" */
153 Lisp_Object Qkill_buffer_hook
;
155 Lisp_Object Qget_file_buffer
;
157 Lisp_Object Qoverlayp
;
159 Lisp_Object Qpriority
, Qwindow
, Qevaporate
, Qbefore_string
, Qafter_string
;
161 Lisp_Object Qmodification_hooks
;
162 Lisp_Object Qinsert_in_front_hooks
;
163 Lisp_Object Qinsert_behind_hooks
;
165 /* For debugging; temporary. See set_buffer_internal. */
166 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
172 error ("No buffer named %s", XSTRING (spec
)->data
);
173 error ("Invalid buffer argument");
176 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
177 "Return non-nil if OBJECT is a buffer which has not been killed.\n\
178 Value is nil if OBJECT is not a buffer or if it has been killed.")
182 return ((BUFFERP (object
) && ! NILP (XBUFFER (object
)->name
))
186 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
187 "Return a list of all existing live buffers.\n\
188 If the optional arg FRAME is a frame, we return that frame's buffer list.")
192 Lisp_Object framelist
, general
;
193 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
199 CHECK_FRAME (frame
, 1);
201 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
203 /* Remove from GENERAL any buffer that duplicates one in FRAMELIST. */
205 while (! NILP (tail
))
207 general
= Fdelq (XCONS (tail
)->car
, general
);
208 tail
= XCONS (tail
)->cdr
;
210 return nconc2 (framelist
, general
);
216 /* Like Fassoc, but use Fstring_equal to compare
217 (which ignores text properties),
218 and don't ever QUIT. */
221 assoc_ignore_text_properties (key
, list
)
222 register Lisp_Object key
;
225 register Lisp_Object tail
;
226 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
228 register Lisp_Object elt
, tem
;
230 tem
= Fstring_equal (Fcar (elt
), key
);
237 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
238 "Return the buffer named NAME (a string).\n\
239 If there is no live buffer named NAME, return nil.\n\
240 NAME may also be a buffer; if so, the value is that buffer.")
242 register Lisp_Object name
;
246 CHECK_STRING (name
, 0);
248 return Fcdr (assoc_ignore_text_properties (name
, Vbuffer_alist
));
251 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
252 "Return the buffer visiting file FILENAME (a string).\n\
253 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.\n\
254 If there is no such live buffer, return nil.\n\
255 See also `find-buffer-visiting'.")
257 register Lisp_Object filename
;
259 register Lisp_Object tail
, buf
, tem
;
262 CHECK_STRING (filename
, 0);
263 filename
= Fexpand_file_name (filename
, Qnil
);
265 /* If the file name has special constructs in it,
266 call the corresponding file handler. */
267 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
269 return call2 (handler
, Qget_file_buffer
, filename
);
271 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
273 buf
= Fcdr (XCONS (tail
)->car
);
274 if (!BUFFERP (buf
)) continue;
275 if (!STRINGP (XBUFFER (buf
)->filename
)) continue;
276 tem
= Fstring_equal (XBUFFER (buf
)->filename
, filename
);
284 get_truename_buffer (filename
)
285 register Lisp_Object filename
;
287 register Lisp_Object tail
, buf
, tem
;
289 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
291 buf
= Fcdr (XCONS (tail
)->car
);
292 if (!BUFFERP (buf
)) continue;
293 if (!STRINGP (XBUFFER (buf
)->file_truename
)) continue;
294 tem
= Fstring_equal (XBUFFER (buf
)->file_truename
, filename
);
301 /* Incremented for each buffer created, to assign the buffer number. */
304 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
305 "Return the buffer named NAME, or create such a buffer and return it.\n\
306 A new buffer is created if there is no live buffer named NAME.\n\
307 If NAME starts with a space, the new buffer does not keep undo information.\n\
308 If NAME is a buffer instead of a string, then it is the value returned.\n\
309 The value is never nil.")
311 register Lisp_Object name
;
313 register Lisp_Object buf
;
314 register struct buffer
*b
;
316 buf
= Fget_buffer (name
);
320 if (XSTRING (name
)->size
== 0)
321 error ("Empty string for buffer name is not allowed");
323 b
= (struct buffer
*) xmalloc (sizeof (struct buffer
));
325 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
327 /* An ordinary buffer uses its own struct buffer_text. */
328 b
->text
= &b
->own_text
;
331 BUF_GAP_SIZE (b
) = 20;
333 /* We allocate extra 1-byte at the tail and keep it always '\0' for
334 anchoring a search. */
335 BUFFER_ALLOC (BUF_BEG_ADDR (b
), (BUF_GAP_SIZE (b
) + 1));
337 if (! BUF_BEG_ADDR (b
))
338 buffer_memory_full ();
346 BUF_OVERLAY_MODIFF (b
) = 1;
347 BUF_SAVE_MODIFF (b
) = 1;
348 BUF_INTERVALS (b
) = 0;
349 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
351 b
->newline_cache
= 0;
352 b
->width_run_cache
= 0;
353 b
->width_table
= Qnil
;
355 /* Put this on the chain of all buffers including killed ones. */
356 b
->next
= all_buffers
;
359 /* An ordinary buffer normally doesn't need markers
360 to handle BEGV and ZV. */
362 b
->begv_marker
= Qnil
;
365 name
= Fcopy_sequence (name
);
366 INITIALIZE_INTERVAL (XSTRING (name
), NULL_INTERVAL
);
369 if (XSTRING (name
)->data
[0] != ' ')
375 reset_buffer_local_variables (b
, 1);
377 /* Put this in the alist of all live buffers. */
379 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
381 b
->mark
= Fmake_marker ();
382 BUF_MARKERS (b
) = Qnil
;
387 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
, 2, 2,
388 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
389 "Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.\n\
390 BASE-BUFFER should be an existing buffer (or buffer name).\n\
391 NAME should be a string which is not the name of an existing buffer.")
393 register Lisp_Object base_buffer
, name
;
395 register Lisp_Object buf
;
396 register struct buffer
*b
;
398 buf
= Fget_buffer (name
);
400 error ("Buffer name `%s' is in use", XSTRING (name
)->data
);
402 base_buffer
= Fget_buffer (base_buffer
);
403 if (NILP (base_buffer
))
404 error ("No such buffer: `%s'",
405 XSTRING (XBUFFER (base_buffer
)->name
)->data
);
407 if (XSTRING (name
)->size
== 0)
408 error ("Empty string for buffer name is not allowed");
410 b
= (struct buffer
*) xmalloc (sizeof (struct buffer
));
412 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
414 if (XBUFFER (base_buffer
)->base_buffer
)
415 b
->base_buffer
= XBUFFER (base_buffer
)->base_buffer
;
417 b
->base_buffer
= XBUFFER (base_buffer
);
419 /* Use the base buffer's text object. */
420 b
->text
= b
->base_buffer
->text
;
422 BUF_BEGV (b
) = BUF_BEGV (b
->base_buffer
);
423 BUF_ZV (b
) = BUF_ZV (b
->base_buffer
);
424 BUF_PT (b
) = BUF_PT (b
->base_buffer
);
426 b
->newline_cache
= 0;
427 b
->width_run_cache
= 0;
428 b
->width_table
= Qnil
;
430 /* Put this on the chain of all buffers including killed ones. */
431 b
->next
= all_buffers
;
434 name
= Fcopy_sequence (name
);
435 INITIALIZE_INTERVAL (XSTRING (name
), NULL_INTERVAL
);
439 reset_buffer_local_variables (b
, 1);
441 /* Put this in the alist of all live buffers. */
443 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
445 b
->mark
= Fmake_marker ();
448 /* Make sure the base buffer has markers for its narrowing. */
449 if (NILP (b
->base_buffer
->pt_marker
))
451 b
->base_buffer
->pt_marker
= Fmake_marker ();
452 Fset_marker (b
->base_buffer
->pt_marker
,
453 make_number (BUF_PT (b
->base_buffer
)), base_buffer
);
455 if (NILP (b
->base_buffer
->begv_marker
))
457 b
->base_buffer
->begv_marker
= Fmake_marker ();
458 Fset_marker (b
->base_buffer
->begv_marker
,
459 make_number (BUF_BEGV (b
->base_buffer
)), base_buffer
);
461 if (NILP (b
->base_buffer
->zv_marker
))
463 b
->base_buffer
->zv_marker
= Fmake_marker ();
464 Fset_marker (b
->base_buffer
->zv_marker
,
465 make_number (BUF_ZV (b
->base_buffer
)), base_buffer
);
466 XMARKER (b
->base_buffer
->zv_marker
)->insertion_type
= 1;
469 /* Give the indirect buffer markers for its narrowing. */
470 b
->pt_marker
= Fmake_marker ();
471 Fset_marker (b
->pt_marker
, make_number (BUF_PT (b
)), buf
);
472 b
->begv_marker
= Fmake_marker ();
473 Fset_marker (b
->begv_marker
, make_number (BUF_BEGV (b
)), buf
);
474 b
->zv_marker
= Fmake_marker ();
475 Fset_marker (b
->zv_marker
, make_number (BUF_ZV (b
)), buf
);
477 XMARKER (b
->zv_marker
)->insertion_type
= 1;
482 /* Reinitialize everything about a buffer except its name and contents
483 and local variables. */
487 register struct buffer
*b
;
490 b
->file_truename
= Qnil
;
491 b
->directory
= (current_buffer
) ? current_buffer
->directory
: Qnil
;
493 XSETFASTINT (b
->save_length
, 0);
494 b
->last_window_start
= 1;
495 /* It is more conservative to start out "changed" than "unchanged". */
498 b
->auto_save_modified
= 0;
499 b
->auto_save_failure_time
= -1;
500 b
->auto_save_file_name
= Qnil
;
502 b
->overlays_before
= Qnil
;
503 b
->overlays_after
= Qnil
;
504 XSETFASTINT (b
->overlay_center
, 1);
505 b
->mark_active
= Qnil
;
506 b
->point_before_scroll
= Qnil
;
507 b
->file_format
= Qnil
;
508 b
->last_selected_window
= Qnil
;
509 XSETINT (b
->display_count
, 0);
514 /* Reset buffer B's local variables info.
515 Don't use this on a buffer that has already been in use;
516 it does not treat permanent locals consistently.
517 Instead, use Fkill_all_local_variables.
519 If PERMANENT_TOO is 1, then we reset permanent built-in
520 buffer-local variables. If PERMANENT_TOO is 0,
521 we preserve those. */
524 reset_buffer_local_variables (b
, permanent_too
)
525 register struct buffer
*b
;
531 /* Decide which built-in local variables to reset. */
535 dont_reset
= buffer_permanent_local_flags
;
537 /* Reset the major mode to Fundamental, together with all the
538 things that depend on the major mode.
539 default-major-mode is handled at a higher level.
540 We ignore it here. */
541 b
->major_mode
= Qfundamental_mode
;
543 b
->abbrev_table
= Vfundamental_mode_abbrev_table
;
544 b
->mode_name
= QSFundamental
;
545 b
->minor_modes
= Qnil
;
547 /* If the standard case table has been altered and invalidated,
548 fix up its insides first. */
549 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
550 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
551 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
552 Fset_standard_case_table (Vascii_downcase_table
);
554 b
->downcase_table
= Vascii_downcase_table
;
555 b
->upcase_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
556 b
->case_canon_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
557 b
->case_eqv_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
558 b
->invisibility_spec
= Qt
;
560 b
->buffer_file_type
= Qnil
;
564 b
->sort_table
= XSTRING (Vascii_sort_table
);
565 b
->folding_sort_table
= XSTRING (Vascii_folding_sort_table
);
568 /* Reset all (or most) per-buffer variables to their defaults. */
569 b
->local_var_alist
= Qnil
;
570 b
->local_var_flags
&= dont_reset
;
572 /* For each slot that has a default value,
573 copy that into the slot. */
575 for (offset
= (char *)&buffer_local_flags
.name
- (char *)&buffer_local_flags
;
576 offset
< sizeof (struct buffer
);
577 offset
+= sizeof (Lisp_Object
)) /* sizeof EMACS_INT == sizeof Lisp_Object */
579 int flag
= XINT (*(Lisp_Object
*)(offset
+ (char *)&buffer_local_flags
));
581 /* Don't reset a permanent local. */
582 && ! (dont_reset
& flag
))
584 *(Lisp_Object
*)(offset
+ (char *)b
)
585 = *(Lisp_Object
*)(offset
+ (char *)&buffer_defaults
);
589 /* We split this away from generate-new-buffer, because rename-buffer
590 and set-visited-file-name ought to be able to use this to really
591 rename the buffer properly. */
593 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
595 "Return a string that is the name of no existing buffer based on NAME.\n\
596 If there is no live buffer named NAME, then return NAME.\n\
597 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER\n\
598 until an unused name is found, and then return that name.\n\
599 Optional second argument IGNORE specifies a name that is okay to use\n\
600 \(if it is in the sequence to be tried)\n\
601 even if a buffer with that name exists.")
603 register Lisp_Object name
, ignore
;
605 register Lisp_Object gentemp
, tem
;
609 CHECK_STRING (name
, 0);
611 tem
= Fget_buffer (name
);
618 sprintf (number
, "<%d>", ++count
);
619 gentemp
= concat2 (name
, build_string (number
));
620 tem
= Fstring_equal (gentemp
, ignore
);
623 tem
= Fget_buffer (gentemp
);
630 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
631 "Return the name of BUFFER, as a string.\n\
632 With no argument or nil as argument, return the name of the current buffer.")
634 register Lisp_Object buffer
;
637 return current_buffer
->name
;
638 CHECK_BUFFER (buffer
, 0);
639 return XBUFFER (buffer
)->name
;
642 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
643 "Return name of file BUFFER is visiting, or nil if none.\n\
644 No argument or nil as argument means use the current buffer.")
646 register Lisp_Object buffer
;
649 return current_buffer
->filename
;
650 CHECK_BUFFER (buffer
, 0);
651 return XBUFFER (buffer
)->filename
;
654 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
656 "Return the base buffer of indirect buffer BUFFER.\n\
657 If BUFFER is not indirect, return nil.")
659 register Lisp_Object buffer
;
662 Lisp_Object base_buffer
;
665 base
= current_buffer
->base_buffer
;
668 CHECK_BUFFER (buffer
, 0);
669 base
= XBUFFER (buffer
)->base_buffer
;
674 XSETBUFFER (base_buffer
, base
);
678 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
679 Sbuffer_local_variables
, 0, 1, 0,
680 "Return an alist of variables that are buffer-local in BUFFER.\n\
681 Most elements look like (SYMBOL . VALUE), describing one variable.\n\
682 For a symbol that is locally unbound, just the symbol appears in the value.\n\
683 Note that storing new VALUEs in these elements doesn't change the variables.\n\
684 No argument or nil as argument means use current buffer as BUFFER.")
686 register Lisp_Object buffer
;
688 register struct buffer
*buf
;
689 register Lisp_Object result
;
692 buf
= current_buffer
;
695 CHECK_BUFFER (buffer
, 0);
696 buf
= XBUFFER (buffer
);
702 register Lisp_Object tail
;
703 for (tail
= buf
->local_var_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
705 Lisp_Object val
, elt
;
707 elt
= XCONS (tail
)->car
;
709 /* Reference each variable in the alist in buf.
710 If inquiring about the current buffer, this gets the current values,
711 so store them into the alist so the alist is up to date.
712 If inquiring about some other buffer, this swaps out any values
713 for that buffer, making the alist up to date automatically. */
714 val
= find_symbol_value (XCONS (elt
)->car
);
715 /* Use the current buffer value only if buf is the current buffer. */
716 if (buf
!= current_buffer
)
717 val
= XCONS (elt
)->cdr
;
719 /* If symbol is unbound, put just the symbol in the list. */
720 if (EQ (val
, Qunbound
))
721 result
= Fcons (XCONS (elt
)->car
, result
);
722 /* Otherwise, put (symbol . value) in the list. */
724 result
= Fcons (Fcons (XCONS (elt
)->car
, val
), result
);
728 /* Add on all the variables stored in special slots. */
730 register int offset
, mask
;
732 for (offset
= (char *)&buffer_local_symbols
.name
- (char *)&buffer_local_symbols
;
733 offset
< sizeof (struct buffer
);
734 offset
+= (sizeof (EMACS_INT
))) /* sizeof EMACS_INT == sizeof Lisp_Object */
736 mask
= XINT (*(Lisp_Object
*)(offset
+ (char *)&buffer_local_flags
));
737 if (mask
== -1 || (buf
->local_var_flags
& mask
))
738 if (SYMBOLP (*(Lisp_Object
*)(offset
739 + (char *)&buffer_local_symbols
)))
740 result
= Fcons (Fcons (*((Lisp_Object
*)
741 (offset
+ (char *)&buffer_local_symbols
)),
742 *(Lisp_Object
*)(offset
+ (char *)buf
)),
751 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
753 "Return t if BUFFER was modified since its file was last read or saved.\n\
754 No argument or nil as argument means use current buffer as BUFFER.")
756 register Lisp_Object buffer
;
758 register struct buffer
*buf
;
760 buf
= current_buffer
;
763 CHECK_BUFFER (buffer
, 0);
764 buf
= XBUFFER (buffer
);
767 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
770 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
772 "Mark current buffer as modified or unmodified according to FLAG.\n\
773 A non-nil FLAG means mark the buffer modified.")
775 register Lisp_Object flag
;
777 register int already
;
778 register Lisp_Object fn
;
780 #ifdef CLASH_DETECTION
781 /* If buffer becoming modified, lock the file.
782 If buffer becoming unmodified, unlock the file. */
784 fn
= current_buffer
->file_truename
;
787 already
= SAVE_MODIFF
< MODIFF
;
788 if (!already
&& !NILP (flag
))
790 else if (already
&& NILP (flag
))
793 #endif /* CLASH_DETECTION */
795 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
800 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
802 "Return BUFFER's tick counter, incremented for each change in text.\n\
803 Each buffer has a tick counter which is incremented each time the text in\n\
804 that buffer is changed. It wraps around occasionally.\n\
805 No argument or nil as argument means use current buffer as BUFFER.")
807 register Lisp_Object buffer
;
809 register struct buffer
*buf
;
811 buf
= current_buffer
;
814 CHECK_BUFFER (buffer
, 0);
815 buf
= XBUFFER (buffer
);
818 return make_number (BUF_MODIFF (buf
));
821 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
822 "sRename buffer (to new name): \nP",
823 "Change current buffer's name to NEWNAME (a string).\n\
824 If second arg UNIQUE is nil or omitted, it is an error if a\n\
825 buffer named NEWNAME already exists.\n\
826 If UNIQUE is non-nil, come up with a new name using\n\
827 `generate-new-buffer-name'.\n\
828 Interactively, you can set UNIQUE with a prefix argument.\n\
829 We return the name we actually gave the buffer.\n\
830 This does not change the name of the visited file (if any).")
832 register Lisp_Object newname
, unique
;
834 register Lisp_Object tem
, buf
;
836 CHECK_STRING (newname
, 0);
838 if (XSTRING (newname
)->size
== 0)
839 error ("Empty string is invalid as a buffer name");
841 tem
= Fget_buffer (newname
);
842 /* Don't short-circuit if UNIQUE is t. That is a useful way to rename
843 the buffer automatically so you can create another with the original name.
844 It makes UNIQUE equivalent to
845 (rename-buffer (generate-new-buffer-name NEWNAME)). */
846 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
847 return current_buffer
->name
;
851 newname
= Fgenerate_new_buffer_name (newname
, current_buffer
->name
);
853 error ("Buffer name `%s' is in use", XSTRING (newname
)->data
);
856 current_buffer
->name
= newname
;
858 /* Catch redisplay's attention. Unless we do this, the mode lines for
859 any windows displaying current_buffer will stay unchanged. */
862 XSETBUFFER (buf
, current_buffer
);
863 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
864 if (NILP (current_buffer
->filename
)
865 && !NILP (current_buffer
->auto_save_file_name
))
866 call0 (intern ("rename-auto-save-file"));
867 /* Refetch since that last call may have done GC. */
868 return current_buffer
->name
;
871 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 2, 0,
872 "Return most recently selected buffer other than BUFFER.\n\
873 Buffers not visible in windows are preferred to visible buffers,\n\
874 unless optional second argument VISIBLE-OK is non-nil.\n\
875 If no other buffer exists, the buffer `*scratch*' is returned.\n\
876 If BUFFER is omitted or nil, some interesting buffer is returned.")
878 register Lisp_Object buffer
, visible_ok
;
880 Lisp_Object
Fset_buffer_major_mode ();
881 register Lisp_Object tail
, buf
, notsogood
, tem
, pred
, add_ons
;
884 tail
= Vbuffer_alist
;
885 pred
= frame_buffer_predicate ();
887 /* Consider buffers that have been seen in the selected frame
888 before other buffers. */
890 tem
= frame_buffer_list ();
894 if (BUFFERP (XCONS (tem
)->car
))
895 add_ons
= Fcons (Fcons (Qnil
, XCONS (tem
)->car
), add_ons
);
896 tem
= XCONS (tem
)->cdr
;
898 tail
= nconc2 (Fnreverse (add_ons
), tail
);
900 for (; !NILP (tail
); tail
= Fcdr (tail
))
902 buf
= Fcdr (Fcar (tail
));
903 if (EQ (buf
, buffer
))
905 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
907 /* If the selected frame has a buffer_predicate,
908 disregard buffers that don't fit the predicate. */
911 tem
= call1 (pred
, buf
);
916 if (NILP (visible_ok
))
917 tem
= Fget_buffer_window (buf
, Qt
);
922 if (NILP (notsogood
))
925 if (!NILP (notsogood
))
927 buf
= Fget_buffer_create (build_string ("*scratch*"));
928 Fset_buffer_major_mode (buf
);
932 DEFUN ("buffer-disable-undo", Fbuffer_disable_undo
, Sbuffer_disable_undo
,
934 "Make BUFFER stop keeping undo information.\n\
935 No argument or nil as argument means do this for the current buffer.")
937 register Lisp_Object buffer
;
939 Lisp_Object real_buffer
;
942 XSETBUFFER (real_buffer
, current_buffer
);
945 real_buffer
= Fget_buffer (buffer
);
946 if (NILP (real_buffer
))
950 XBUFFER (real_buffer
)->undo_list
= Qt
;
955 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
957 "Start keeping undo information for buffer BUFFER.\n\
958 No argument or nil as argument means do this for the current buffer.")
960 register Lisp_Object buffer
;
962 Lisp_Object real_buffer
;
965 XSETBUFFER (real_buffer
, current_buffer
);
968 real_buffer
= Fget_buffer (buffer
);
969 if (NILP (real_buffer
))
973 if (EQ (XBUFFER (real_buffer
)->undo_list
, Qt
))
974 XBUFFER (real_buffer
)->undo_list
= Qnil
;
980 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
981 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
982 The buffer being killed will be current while the hook is running.\n\
985 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 1, 1, "bKill buffer: ",
986 "Kill the buffer BUFFER.\n\
987 The argument may be a buffer or may be the name of a buffer.\n\
988 An argument of nil means kill the current buffer.\n\n\
989 Value is t if the buffer is actually killed, nil if user says no.\n\n\
990 The value of `kill-buffer-hook' (which may be local to that buffer),\n\
991 if not void, is a list of functions to be called, with no arguments,\n\
992 before the buffer is actually killed. The buffer to be killed is current\n\
993 when the hook functions are called.\n\n\
994 Any processes that have this buffer as the `process-buffer' are killed\n\
1000 register struct buffer
*b
;
1001 register Lisp_Object tem
;
1002 register struct Lisp_Marker
*m
;
1003 struct gcpro gcpro1
, gcpro2
;
1006 buf
= Fcurrent_buffer ();
1008 buf
= Fget_buffer (buffer
);
1014 /* Avoid trouble for buffer already dead. */
1018 /* Query if the buffer is still modified. */
1019 if (INTERACTIVE
&& !NILP (b
->filename
)
1020 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1023 tem
= do_yes_or_no_p (format1 ("Buffer %s modified; kill anyway? ",
1024 XSTRING (b
->name
)->data
));
1030 /* Run hooks with the buffer to be killed the current buffer. */
1032 register Lisp_Object val
;
1033 int count
= specpdl_ptr
- specpdl
;
1036 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1037 set_buffer_internal (b
);
1039 /* First run the query functions; if any query is answered no,
1040 don't kill the buffer. */
1041 for (list
= Vkill_buffer_query_functions
; !NILP (list
); list
= Fcdr (list
))
1043 tem
= call0 (Fcar (list
));
1045 return unbind_to (count
, Qnil
);
1048 /* Then run the hooks. */
1049 if (!NILP (Vrun_hooks
))
1050 call1 (Vrun_hooks
, Qkill_buffer_hook
);
1051 unbind_to (count
, Qnil
);
1054 /* We have no more questions to ask. Verify that it is valid
1055 to kill the buffer. This must be done after the questions
1056 since anything can happen within do_yes_or_no_p. */
1058 /* Don't kill the minibuffer now current. */
1059 if (EQ (buf
, XWINDOW (minibuf_window
)->buffer
))
1065 /* When we kill a base buffer, kill all its indirect buffers.
1066 We do it at this stage so nothing terrible happens if they
1067 ask questions or their hooks get errors. */
1068 if (! b
->base_buffer
)
1070 struct buffer
*other
;
1074 for (other
= all_buffers
; other
; other
= other
->next
)
1075 /* all_buffers contains dead buffers too;
1076 don't re-kill them. */
1077 if (other
->base_buffer
== b
&& !NILP (other
->name
))
1080 XSETBUFFER (buf
, other
);
1087 /* Make this buffer not be current.
1088 In the process, notice if this is the sole visible buffer
1089 and give up if so. */
1090 if (b
== current_buffer
)
1092 tem
= Fother_buffer (buf
, Qnil
);
1094 if (b
== current_buffer
)
1098 /* Now there is no question: we can kill the buffer. */
1100 #ifdef CLASH_DETECTION
1101 /* Unlock this buffer's file, if it is locked. */
1103 #endif /* CLASH_DETECTION */
1105 kill_buffer_processes (buf
);
1107 tem
= Vinhibit_quit
;
1109 replace_buffer_in_all_windows (buf
);
1110 Vbuffer_alist
= Fdelq (Frassq (buf
, Vbuffer_alist
), Vbuffer_alist
);
1111 frames_discard_buffer (buf
);
1112 Vinhibit_quit
= tem
;
1114 /* Delete any auto-save file, if we saved it in this session. */
1115 if (STRINGP (b
->auto_save_file_name
)
1116 && b
->auto_save_modified
!= 0
1117 && SAVE_MODIFF
< b
->auto_save_modified
)
1120 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
1122 internal_delete_file (b
->auto_save_file_name
);
1127 /* Unchain all markers that belong to this indirect buffer.
1128 Don't unchain the markers that belong to the base buffer
1129 or its other indirect buffers. */
1130 for (tem
= BUF_MARKERS (b
); !NILP (tem
); )
1136 unchain_marker (tem
);
1142 /* Unchain all markers of this buffer and its indirect buffers.
1143 and leave them pointing nowhere. */
1144 for (tem
= BUF_MARKERS (b
); !NILP (tem
); )
1151 BUF_MARKERS (b
) = Qnil
;
1153 #ifdef USE_TEXT_PROPERTIES
1154 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1157 /* Perhaps we should explicitly free the interval tree here... */
1160 /* Reset the local variables, so that this buffer's local values
1161 won't be protected from GC. They would be protected
1162 if they happened to remain encached in their symbols.
1163 This gets rid of them for certain. */
1164 swap_out_buffer_local_variables (b
);
1165 reset_buffer_local_variables (b
, 1);
1170 if (! b
->base_buffer
)
1171 BUFFER_FREE (BUF_BEG_ADDR (b
));
1173 if (b
->newline_cache
)
1175 free_region_cache (b
->newline_cache
);
1176 b
->newline_cache
= 0;
1178 if (b
->width_run_cache
)
1180 free_region_cache (b
->width_run_cache
);
1181 b
->width_run_cache
= 0;
1183 b
->width_table
= Qnil
;
1185 b
->undo_list
= Qnil
;
1190 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
1191 we do this each time BUF is selected visibly, the more recently
1192 selected buffers are always closer to the front of the list. This
1193 means that other_buffer is more likely to choose a relevant buffer. */
1198 register Lisp_Object link
, prev
;
1201 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCONS (link
)->cdr
)
1203 if (EQ (XCONS (XCONS (link
)->car
)->cdr
, buf
))
1208 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
1209 we cannot use Fdelq itself here because it allows quitting. */
1212 Vbuffer_alist
= XCONS (Vbuffer_alist
)->cdr
;
1214 XCONS (prev
)->cdr
= XCONS (XCONS (prev
)->cdr
)->cdr
;
1216 XCONS (link
)->cdr
= Vbuffer_alist
;
1217 Vbuffer_alist
= link
;
1219 /* Now move this buffer to the front of frame_buffer_list also. */
1222 for (link
= frame_buffer_list (); CONSP (link
); link
= XCONS (link
)->cdr
)
1224 if (EQ (XCONS (link
)->car
, buf
))
1229 /* Effectively do delq. */
1234 set_frame_buffer_list (XCONS (frame_buffer_list ())->cdr
);
1236 XCONS (prev
)->cdr
= XCONS (XCONS (prev
)->cdr
)->cdr
;
1238 XCONS (link
)->cdr
= frame_buffer_list ();
1239 set_frame_buffer_list (link
);
1242 set_frame_buffer_list (Fcons (buf
, frame_buffer_list ()));
1245 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1246 "Set an appropriate major mode for BUFFER, according to `default-major-mode'.\n\
1247 Use this function before selecting the buffer, since it may need to inspect\n\
1248 the current buffer's major mode.")
1253 Lisp_Object function
;
1255 function
= buffer_defaults
.major_mode
;
1256 if (NILP (function
) && NILP (Fget (current_buffer
->major_mode
, Qmode_class
)))
1257 function
= current_buffer
->major_mode
;
1259 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1262 count
= specpdl_ptr
- specpdl
;
1264 /* To select a nonfundamental mode,
1265 select the buffer temporarily and then call the mode function. */
1267 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1269 Fset_buffer (buffer
);
1272 return unbind_to (count
, Qnil
);
1275 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2, "BSwitch to buffer: ",
1276 "Select buffer BUFFER in the current window.\n\
1277 BUFFER may be a buffer or a buffer name.\n\
1278 Optional second arg NORECORD non-nil means\n\
1279 do not put this buffer at the front of the list of recently selected ones.\n\
1281 WARNING: This is NOT the way to work on another buffer temporarily\n\
1282 within a Lisp program! Use `set-buffer' instead. That avoids messing with\n\
1283 the window-buffer correspondences.")
1285 Lisp_Object buffer
, norecord
;
1287 register Lisp_Object buf
;
1290 if (EQ (minibuf_window
, selected_window
))
1291 error ("Cannot switch buffers in minibuffer window");
1292 tem
= Fwindow_dedicated_p (selected_window
);
1294 error ("Cannot switch buffers in a dedicated window");
1297 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
);
1300 buf
= Fget_buffer (buffer
);
1303 buf
= Fget_buffer_create (buffer
);
1304 Fset_buffer_major_mode (buf
);
1308 if (NILP (norecord
))
1309 record_buffer (buf
);
1311 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
1312 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
1319 DEFUN ("pop-to-buffer", Fpop_to_buffer
, Spop_to_buffer
, 1, 3, 0,
1320 "Select buffer BUFFER in some window, preferably a different one.\n\
1321 If BUFFER is nil, then some other buffer is chosen.\n\
1322 If `pop-up-windows' is non-nil, windows can be split to do this.\n\
1323 If optional second arg OTHER-WINDOW is non-nil, insist on finding another\n\
1324 window even if BUFFER is already visible in the selected window.\n\
1325 This uses the function `display-buffer' as a subroutine; see the documentation\n\
1326 of `display-buffer' for additional customization information.\n\
1328 Optional third arg NORECORD non-nil means\n\
1329 do not put this buffer at the front of the list of recently selected ones.")
1330 (buffer
, other_window
, norecord
)
1331 Lisp_Object buffer
, other_window
, norecord
;
1333 register Lisp_Object buf
;
1335 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
);
1338 buf
= Fget_buffer (buffer
);
1341 buf
= Fget_buffer_create (buffer
);
1342 Fset_buffer_major_mode (buf
);
1346 if (NILP (norecord
))
1347 record_buffer (buf
);
1348 Fselect_window (Fdisplay_buffer (buf
, other_window
));
1352 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1353 "Return the current buffer as a Lisp object.")
1356 register Lisp_Object buf
;
1357 XSETBUFFER (buf
, current_buffer
);
1361 /* Set the current buffer to B. */
1364 set_buffer_internal (b
)
1365 register struct buffer
*b
;
1367 register struct buffer
*old_buf
;
1368 register Lisp_Object tail
, valcontents
;
1371 if (current_buffer
== b
)
1374 windows_or_buffers_changed
= 1;
1375 set_buffer_internal_1 (b
);
1378 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1379 This is used by redisplay. */
1382 set_buffer_internal_1 (b
)
1383 register struct buffer
*b
;
1385 register struct buffer
*old_buf
;
1386 register Lisp_Object tail
, valcontents
;
1389 if (current_buffer
== b
)
1392 old_buf
= current_buffer
;
1394 last_known_column_point
= -1; /* invalidate indentation cache */
1398 /* Put the undo list back in the base buffer, so that it appears
1399 that an indirect buffer shares the undo list of its base. */
1400 if (old_buf
->base_buffer
)
1401 old_buf
->base_buffer
->undo_list
= old_buf
->undo_list
;
1403 /* If the old current buffer has markers to record PT, BEGV and ZV
1404 when it is not current, update them now. */
1405 if (! NILP (old_buf
->pt_marker
))
1408 XSETBUFFER (obuf
, old_buf
);
1409 Fset_marker (old_buf
->pt_marker
, make_number (BUF_PT (old_buf
)),
1412 if (! NILP (old_buf
->begv_marker
))
1415 XSETBUFFER (obuf
, old_buf
);
1416 Fset_marker (old_buf
->begv_marker
, make_number (BUF_BEGV (old_buf
)),
1419 if (! NILP (old_buf
->zv_marker
))
1422 XSETBUFFER (obuf
, old_buf
);
1423 Fset_marker (old_buf
->zv_marker
, make_number (BUF_ZV (old_buf
)),
1428 /* Get the undo list from the base buffer, so that it appears
1429 that an indirect buffer shares the undo list of its base. */
1431 b
->undo_list
= b
->base_buffer
->undo_list
;
1433 /* If the new current buffer has markers to record PT, BEGV and ZV
1434 when it is not current, fetch them now. */
1435 if (! NILP (b
->pt_marker
))
1436 BUF_PT (b
) = marker_position (b
->pt_marker
);
1437 if (! NILP (b
->begv_marker
))
1438 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1439 if (! NILP (b
->zv_marker
))
1440 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1442 /* Look down buffer's list of local Lisp variables
1443 to find and update any that forward into C variables. */
1445 for (tail
= b
->local_var_alist
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
1447 valcontents
= XSYMBOL (XCONS (XCONS (tail
)->car
)->car
)->value
;
1448 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1449 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1450 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->car
,
1451 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1452 /* Just reference the variable
1453 to cause it to become set for this buffer. */
1454 Fsymbol_value (XCONS (XCONS (tail
)->car
)->car
);
1457 /* Do the same with any others that were local to the previous buffer */
1460 for (tail
= old_buf
->local_var_alist
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
1462 valcontents
= XSYMBOL (XCONS (XCONS (tail
)->car
)->car
)->value
;
1463 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1464 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1465 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->car
,
1466 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1467 /* Just reference the variable
1468 to cause it to become set for this buffer. */
1469 Fsymbol_value (XCONS (XCONS (tail
)->car
)->car
);
1473 /* Switch to buffer B temporarily for redisplay purposes.
1474 This avoids certain things that don't need to be done within redisplay. */
1480 register struct buffer
*old_buf
;
1482 if (current_buffer
== b
)
1485 old_buf
= current_buffer
;
1490 /* If the old current buffer has markers to record PT, BEGV and ZV
1491 when it is not current, update them now. */
1492 if (! NILP (old_buf
->pt_marker
))
1495 XSETBUFFER (obuf
, old_buf
);
1496 Fset_marker (old_buf
->pt_marker
, make_number (BUF_PT (old_buf
)),
1499 if (! NILP (old_buf
->begv_marker
))
1502 XSETBUFFER (obuf
, old_buf
);
1503 Fset_marker (old_buf
->begv_marker
, make_number (BUF_BEGV (old_buf
)),
1506 if (! NILP (old_buf
->zv_marker
))
1509 XSETBUFFER (obuf
, old_buf
);
1510 Fset_marker (old_buf
->zv_marker
, make_number (BUF_ZV (old_buf
)),
1515 /* If the new current buffer has markers to record PT, BEGV and ZV
1516 when it is not current, fetch them now. */
1517 if (! NILP (b
->pt_marker
))
1518 BUF_PT (b
) = marker_position (b
->pt_marker
);
1519 if (! NILP (b
->begv_marker
))
1520 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1521 if (! NILP (b
->zv_marker
))
1522 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1525 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
1526 "Make the buffer BUFFER current for editing operations.\n\
1527 BUFFER may be a buffer or the name of an existing buffer.\n\
1528 See also `save-excursion' when you want to make a buffer current temporarily.\n\
1529 This function does not display the buffer, so its effect ends\n\
1530 when the current command terminates.\n\
1531 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.")
1533 register Lisp_Object buffer
;
1535 register Lisp_Object buf
;
1536 buf
= Fget_buffer (buffer
);
1539 if (NILP (XBUFFER (buf
)->name
))
1540 error ("Selecting deleted buffer");
1541 set_buffer_internal (XBUFFER (buf
));
1545 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
1546 Sbarf_if_buffer_read_only
, 0, 0, 0,
1547 "Signal a `buffer-read-only' error if the current buffer is read-only.")
1550 if (!NILP (current_buffer
->read_only
)
1551 && NILP (Vinhibit_read_only
))
1552 Fsignal (Qbuffer_read_only
, (Fcons (Fcurrent_buffer (), Qnil
)));
1556 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
1557 "Put BUFFER at the end of the list of all buffers.\n\
1558 There it is the least likely candidate for `other-buffer' to return;\n\
1559 thus, the least likely buffer for \\[switch-to-buffer] to select by default.\n\
1560 If BUFFER is nil or omitted, bury the current buffer.\n\
1561 Also, if BUFFER is nil or omitted, remove the current buffer from the\n\
1562 selected window if it is displayed there.")
1564 register Lisp_Object buffer
;
1566 /* Figure out what buffer we're going to bury. */
1569 XSETBUFFER (buffer
, current_buffer
);
1571 /* If we're burying the current buffer, unshow it. */
1572 Fswitch_to_buffer (Fother_buffer (buffer
, Qnil
), Qnil
);
1578 buf1
= Fget_buffer (buffer
);
1584 /* Move buffer to the end of the buffer list. */
1586 register Lisp_Object aelt
, link
;
1588 aelt
= Frassq (buffer
, Vbuffer_alist
);
1589 link
= Fmemq (aelt
, Vbuffer_alist
);
1590 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1591 XCONS (link
)->cdr
= Qnil
;
1592 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
1595 frames_bury_buffer (buffer
);
1600 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
1601 "Delete the entire contents of the current buffer.\n\
1602 Any narrowing restriction in effect (see `narrow-to-region') is removed,\n\
1603 so the buffer is truly empty after this.")
1608 current_buffer
->last_window_start
= 1;
1609 /* Prevent warnings, or suspension of auto saving, that would happen
1610 if future size is less than past size. Use of erase-buffer
1611 implies that the future text is not really related to the past text. */
1612 XSETFASTINT (current_buffer
->save_length
, 0);
1616 validate_region (b
, e
)
1617 register Lisp_Object
*b
, *e
;
1619 CHECK_NUMBER_COERCE_MARKER (*b
, 0);
1620 CHECK_NUMBER_COERCE_MARKER (*e
, 1);
1622 if (XINT (*b
) > XINT (*e
))
1625 tem
= *b
; *b
= *e
; *e
= tem
;
1628 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
1629 && XINT (*e
) <= ZV
))
1630 args_out_of_range (*b
, *e
);
1633 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
1635 "Switch to Fundamental mode by killing current buffer's local variables.\n\
1636 Most local variable bindings are eliminated so that the default values\n\
1637 become effective once more. Also, the syntax table is set from\n\
1638 `standard-syntax-table', the local keymap is set to nil,\n\
1639 and the abbrev table from `fundamental-mode-abbrev-table'.\n\
1640 This function also forces redisplay of the mode line.\n\
1642 Every function to select a new major mode starts by\n\
1643 calling this function.\n\n\
1644 As a special exception, local variables whose names have\n\
1645 a non-nil `permanent-local' property are not eliminated by this function.\n\
1647 The first thing this function does is run\n\
1648 the normal hook `change-major-mode-hook'.")
1651 register Lisp_Object alist
, sym
, tem
;
1654 if (!NILP (Vrun_hooks
))
1655 call1 (Vrun_hooks
, intern ("change-major-mode-hook"));
1656 oalist
= current_buffer
->local_var_alist
;
1658 /* Make sure none of the bindings in oalist
1659 remain swapped in, in their symbols. */
1661 swap_out_buffer_local_variables (current_buffer
);
1663 /* Actually eliminate all local bindings of this buffer. */
1665 reset_buffer_local_variables (current_buffer
, 0);
1667 /* Redisplay mode lines; we are changing major mode. */
1669 update_mode_lines
++;
1671 /* Any which are supposed to be permanent,
1672 make local again, with the same values they had. */
1674 for (alist
= oalist
; !NILP (alist
); alist
= XCONS (alist
)->cdr
)
1676 sym
= XCONS (XCONS (alist
)->car
)->car
;
1677 tem
= Fget (sym
, Qpermanent_local
);
1680 Fmake_local_variable (sym
);
1681 Fset (sym
, XCONS (XCONS (alist
)->car
)->cdr
);
1685 /* Force mode-line redisplay. Useful here because all major mode
1686 commands call this function. */
1687 update_mode_lines
++;
1692 /* Make sure no local variables remain set up with buffer B
1693 for their current values. */
1696 swap_out_buffer_local_variables (b
)
1699 Lisp_Object oalist
, alist
, sym
, tem
, buffer
;
1701 XSETBUFFER (buffer
, b
);
1702 oalist
= b
->local_var_alist
;
1704 for (alist
= oalist
; !NILP (alist
); alist
= XCONS (alist
)->cdr
)
1706 sym
= XCONS (XCONS (alist
)->car
)->car
;
1708 /* Need not do anything if some other buffer's binding is now encached. */
1709 tem
= XCONS (XBUFFER_LOCAL_VALUE (XSYMBOL (sym
)->value
)->cdr
)->car
;
1710 if (XBUFFER (tem
) == current_buffer
)
1712 /* Symbol is set up for this buffer's old local value.
1713 Set it up for the current buffer with the default value. */
1715 tem
= XCONS (XBUFFER_LOCAL_VALUE (XSYMBOL (sym
)->value
)->cdr
)->cdr
;
1716 /* Store the symbol's current value into the alist entry
1717 it is currently set up for. This is so that, if the
1718 local is marked permanent, and we make it local again
1719 later in Fkill_all_local_variables, we don't lose the value. */
1720 XCONS (XCONS (tem
)->car
)->cdr
1721 = do_symval_forwarding (XBUFFER_LOCAL_VALUE (XSYMBOL (sym
)->value
)->car
);
1722 /* Switch to the symbol's default-value alist entry. */
1723 XCONS (tem
)->car
= tem
;
1724 /* Mark it as current for buffer B. */
1725 XCONS (XBUFFER_LOCAL_VALUE (XSYMBOL (sym
)->value
)->cdr
)->car
1727 /* Store the current value into any forwarding in the symbol. */
1728 store_symval_forwarding (sym
, XBUFFER_LOCAL_VALUE (XSYMBOL (sym
)->value
)->car
,
1734 /* Find all the overlays in the current buffer that contain position POS.
1735 Return the number found, and store them in a vector in *VEC_PTR.
1736 Store in *LEN_PTR the size allocated for the vector.
1737 Store in *NEXT_PTR the next position after POS where an overlay starts,
1738 or ZV if there are no more overlays.
1739 Store in *PREV_PTR the previous position before POS where an overlay ends,
1740 or BEGV if there are no previous overlays.
1741 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
1743 *VEC_PTR and *LEN_PTR should contain a valid vector and size
1744 when this function is called.
1746 If EXTEND is non-zero, we make the vector bigger if necessary.
1747 If EXTEND is zero, we never extend the vector,
1748 and we store only as many overlays as will fit.
1749 But we still return the total number of overlays. */
1752 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
1755 Lisp_Object
**vec_ptr
;
1760 Lisp_Object tail
, overlay
, start
, end
, result
;
1763 Lisp_Object
*vec
= *vec_ptr
;
1766 int inhibit_storing
= 0;
1768 for (tail
= current_buffer
->overlays_before
;
1770 tail
= XCONS (tail
)->cdr
)
1772 int startpos
, endpos
;
1774 overlay
= XCONS (tail
)->car
;
1776 start
= OVERLAY_START (overlay
);
1777 end
= OVERLAY_END (overlay
);
1778 endpos
= OVERLAY_POSITION (end
);
1787 startpos
= OVERLAY_POSITION (start
);
1788 if (startpos
<= pos
)
1792 /* The supplied vector is full.
1793 Either make it bigger, or don't store any more in it. */
1796 *len_ptr
= len
*= 2;
1797 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
1801 inhibit_storing
= 1;
1804 if (!inhibit_storing
)
1806 /* Keep counting overlays even if we can't return them all. */
1809 else if (startpos
< next
)
1813 for (tail
= current_buffer
->overlays_after
;
1815 tail
= XCONS (tail
)->cdr
)
1817 int startpos
, endpos
;
1819 overlay
= XCONS (tail
)->car
;
1821 start
= OVERLAY_START (overlay
);
1822 end
= OVERLAY_END (overlay
);
1823 startpos
= OVERLAY_POSITION (start
);
1826 if (startpos
< next
)
1830 endpos
= OVERLAY_POSITION (end
);
1837 *len_ptr
= len
*= 2;
1838 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
1842 inhibit_storing
= 1;
1845 if (!inhibit_storing
)
1849 else if (endpos
< pos
&& endpos
> prev
)
1860 /* Find all the overlays in the current buffer that overlap the range BEG-END
1861 or are empty at BEG.
1863 Return the number found, and store them in a vector in *VEC_PTR.
1864 Store in *LEN_PTR the size allocated for the vector.
1865 Store in *NEXT_PTR the next position after POS where an overlay starts,
1866 or ZV if there are no more overlays.
1867 Store in *PREV_PTR the previous position before POS where an overlay ends,
1868 or BEGV if there are no previous overlays.
1869 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
1871 *VEC_PTR and *LEN_PTR should contain a valid vector and size
1872 when this function is called.
1874 If EXTEND is non-zero, we make the vector bigger if necessary.
1875 If EXTEND is zero, we never extend the vector,
1876 and we store only as many overlays as will fit.
1877 But we still return the total number of overlays. */
1880 overlays_in (beg
, end
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
1883 Lisp_Object
**vec_ptr
;
1888 Lisp_Object tail
, overlay
, ostart
, oend
, result
;
1891 Lisp_Object
*vec
= *vec_ptr
;
1894 int inhibit_storing
= 0;
1896 for (tail
= current_buffer
->overlays_before
;
1898 tail
= XCONS (tail
)->cdr
)
1900 int startpos
, endpos
;
1902 overlay
= XCONS (tail
)->car
;
1904 ostart
= OVERLAY_START (overlay
);
1905 oend
= OVERLAY_END (overlay
);
1906 endpos
= OVERLAY_POSITION (oend
);
1913 startpos
= OVERLAY_POSITION (ostart
);
1914 /* Count an interval if it either overlaps the range
1915 or is empty at the start of the range. */
1916 if ((beg
< endpos
&& startpos
< end
)
1917 || (startpos
== endpos
&& beg
== endpos
))
1921 /* The supplied vector is full.
1922 Either make it bigger, or don't store any more in it. */
1925 *len_ptr
= len
*= 2;
1926 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
1930 inhibit_storing
= 1;
1933 if (!inhibit_storing
)
1935 /* Keep counting overlays even if we can't return them all. */
1938 else if (startpos
< next
)
1942 for (tail
= current_buffer
->overlays_after
;
1944 tail
= XCONS (tail
)->cdr
)
1946 int startpos
, endpos
;
1948 overlay
= XCONS (tail
)->car
;
1950 ostart
= OVERLAY_START (overlay
);
1951 oend
= OVERLAY_END (overlay
);
1952 startpos
= OVERLAY_POSITION (ostart
);
1955 if (startpos
< next
)
1959 endpos
= OVERLAY_POSITION (oend
);
1960 /* Count an interval if it either overlaps the range
1961 or is empty at the start of the range. */
1962 if ((beg
< endpos
&& startpos
< end
)
1963 || (startpos
== endpos
&& beg
== endpos
))
1969 *len_ptr
= len
*= 2;
1970 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
1974 inhibit_storing
= 1;
1977 if (!inhibit_storing
)
1981 else if (endpos
< beg
&& endpos
> prev
)
1992 /* Fast function to just test if we're at an overlay boundary. */
1994 overlay_touches_p (pos
)
1997 Lisp_Object tail
, overlay
;
1999 for (tail
= current_buffer
->overlays_before
; GC_CONSP (tail
);
2000 tail
= XCONS (tail
)->cdr
)
2004 overlay
= XCONS (tail
)->car
;
2005 if (!GC_OVERLAYP (overlay
))
2008 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2011 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
2015 for (tail
= current_buffer
->overlays_after
; GC_CONSP (tail
);
2016 tail
= XCONS (tail
)->cdr
)
2020 overlay
= XCONS (tail
)->car
;
2021 if (!GC_OVERLAYP (overlay
))
2024 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2027 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
2035 Lisp_Object overlay
;
2041 compare_overlays (s1
, s2
)
2042 struct sortvec
*s1
, *s2
;
2044 if (s1
->priority
!= s2
->priority
)
2045 return s1
->priority
- s2
->priority
;
2046 if (s1
->beg
!= s2
->beg
)
2047 return s1
->beg
- s2
->beg
;
2048 if (s1
->end
!= s2
->end
)
2049 return s2
->end
- s1
->end
;
2053 /* Sort an array of overlays by priority. The array is modified in place.
2054 The return value is the new size; this may be smaller than the original
2055 size if some of the overlays were invalid or were window-specific. */
2057 sort_overlays (overlay_vec
, noverlays
, w
)
2058 Lisp_Object
*overlay_vec
;
2063 struct sortvec
*sortvec
;
2064 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
2066 /* Put the valid and relevant overlays into sortvec. */
2068 for (i
= 0, j
= 0; i
< noverlays
; i
++)
2071 Lisp_Object overlay
;
2073 overlay
= overlay_vec
[i
];
2074 if (OVERLAY_VALID (overlay
)
2075 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
2076 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
2078 /* If we're interested in a specific window, then ignore
2079 overlays that are limited to some other window. */
2084 window
= Foverlay_get (overlay
, Qwindow
);
2085 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2089 /* This overlay is good and counts: put it into sortvec. */
2090 sortvec
[j
].overlay
= overlay
;
2091 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2092 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2093 tem
= Foverlay_get (overlay
, Qpriority
);
2095 sortvec
[j
].priority
= XINT (tem
);
2097 sortvec
[j
].priority
= 0;
2103 /* Sort the overlays into the proper order: increasing priority. */
2106 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
2108 for (i
= 0; i
< noverlays
; i
++)
2109 overlay_vec
[i
] = sortvec
[i
].overlay
;
2115 Lisp_Object string
, string2
;
2122 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
2123 int size
; /* Allocated length of that array. */
2124 int used
; /* How much of the array is currently in use. */
2125 int bytes
; /* Total length of the strings in buf. */
2128 /* Buffers for storing information about the overlays touching a given
2129 position. These could be automatic variables in overlay_strings, but
2130 it's more efficient to hold onto the memory instead of repeatedly
2131 allocating and freeing it. */
2132 static struct sortstrlist overlay_heads
, overlay_tails
;
2133 static unsigned char *overlay_str_buf
;
2135 /* Allocated length of overlay_str_buf. */
2136 static int overlay_str_len
;
2138 /* A comparison function suitable for passing to qsort. */
2140 cmp_for_strings (as1
, as2
)
2143 struct sortstr
*s1
= (struct sortstr
*)as1
;
2144 struct sortstr
*s2
= (struct sortstr
*)as2
;
2145 if (s1
->size
!= s2
->size
)
2146 return s2
->size
- s1
->size
;
2147 if (s1
->priority
!= s2
->priority
)
2148 return s1
->priority
- s2
->priority
;
2153 record_overlay_string (ssl
, str
, str2
, pri
, size
)
2154 struct sortstrlist
*ssl
;
2155 Lisp_Object str
, str2
, pri
;
2158 if (ssl
->used
== ssl
->size
)
2164 ssl
->buf
= ((struct sortstr
*)
2165 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
2167 ssl
->buf
[ssl
->used
].string
= str
;
2168 ssl
->buf
[ssl
->used
].string2
= str2
;
2169 ssl
->buf
[ssl
->used
].size
= size
;
2170 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
2172 ssl
->bytes
+= XSTRING (str
)->size
;
2174 ssl
->bytes
+= XSTRING (str2
)->size
;
2177 /* Return the concatenation of the strings associated with overlays that
2178 begin or end at POS, ignoring overlays that are specific to a window
2179 other than W. The strings are concatenated in the appropriate order:
2180 shorter overlays nest inside longer ones, and higher priority inside
2181 lower. Normally all of the after-strings come first, but zero-sized
2182 overlays have their after-strings ride along with the before-strings
2183 because it would look strange to print them inside-out.
2185 Returns the string length, and stores the contents indirectly through
2186 PSTR, if that variable is non-null. The string may be overwritten by
2187 subsequent calls. */
2190 overlay_strings (pos
, w
, pstr
)
2193 unsigned char **pstr
;
2195 Lisp_Object ov
, overlay
, window
, str
;
2196 int startpos
, endpos
;
2198 overlay_heads
.used
= overlay_heads
.bytes
= 0;
2199 overlay_tails
.used
= overlay_tails
.bytes
= 0;
2200 for (ov
= current_buffer
->overlays_before
; CONSP (ov
); ov
= XCONS (ov
)->cdr
)
2202 overlay
= XCONS (ov
)->car
;
2203 if (!OVERLAYP (overlay
))
2206 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2207 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2210 if (endpos
!= pos
&& startpos
!= pos
)
2212 window
= Foverlay_get (overlay
, Qwindow
);
2213 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2216 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
2217 record_overlay_string (&overlay_heads
, str
,
2219 ? Foverlay_get (overlay
, Qafter_string
)
2221 Foverlay_get (overlay
, Qpriority
),
2223 else if (endpos
== pos
2224 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
2225 record_overlay_string (&overlay_tails
, str
, Qnil
,
2226 Foverlay_get (overlay
, Qpriority
),
2229 for (ov
= current_buffer
->overlays_after
; CONSP (ov
); ov
= XCONS (ov
)->cdr
)
2231 overlay
= XCONS (ov
)->car
;
2232 if (!OVERLAYP (overlay
))
2235 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2236 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2239 if (endpos
!= pos
&& startpos
!= pos
)
2241 window
= Foverlay_get (overlay
, Qwindow
);
2242 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2245 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
2246 record_overlay_string (&overlay_heads
, str
,
2248 ? Foverlay_get (overlay
, Qafter_string
)
2250 Foverlay_get (overlay
, Qpriority
),
2252 else if (endpos
== pos
2253 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
2254 record_overlay_string (&overlay_tails
, str
, Qnil
,
2255 Foverlay_get (overlay
, Qpriority
),
2258 if (overlay_tails
.used
> 1)
2259 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
2261 if (overlay_heads
.used
> 1)
2262 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
2264 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
2269 int total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
2271 if (total
> overlay_str_len
)
2273 overlay_str_len
= total
;
2274 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
2277 p
= overlay_str_buf
;
2278 for (i
= overlay_tails
.used
; --i
>= 0;)
2280 tem
= overlay_tails
.buf
[i
].string
;
2281 bcopy (XSTRING (tem
)->data
, p
, XSTRING (tem
)->size
);
2282 p
+= XSTRING (tem
)->size
;
2284 for (i
= 0; i
< overlay_heads
.used
; ++i
)
2286 tem
= overlay_heads
.buf
[i
].string
;
2287 bcopy (XSTRING (tem
)->data
, p
, XSTRING (tem
)->size
);
2288 p
+= XSTRING (tem
)->size
;
2289 tem
= overlay_heads
.buf
[i
].string2
;
2292 bcopy (XSTRING (tem
)->data
, p
, XSTRING (tem
)->size
);
2293 p
+= XSTRING (tem
)->size
;
2296 if (p
!= overlay_str_buf
+ total
)
2299 *pstr
= overlay_str_buf
;
2305 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
2308 recenter_overlay_lists (buf
, pos
)
2312 Lisp_Object overlay
, tail
, next
, prev
, beg
, end
;
2314 /* See if anything in overlays_before should move to overlays_after. */
2316 /* We don't strictly need prev in this loop; it should always be nil.
2317 But we use it for symmetry and in case that should cease to be true
2318 with some future change. */
2320 for (tail
= buf
->overlays_before
;
2322 prev
= tail
, tail
= next
)
2324 next
= XCONS (tail
)->cdr
;
2325 overlay
= XCONS (tail
)->car
;
2327 /* If the overlay is not valid, get rid of it. */
2328 if (!OVERLAY_VALID (overlay
))
2333 /* Splice the cons cell TAIL out of overlays_before. */
2335 XCONS (prev
)->cdr
= next
;
2337 buf
->overlays_before
= next
;
2343 beg
= OVERLAY_START (overlay
);
2344 end
= OVERLAY_END (overlay
);
2346 if (OVERLAY_POSITION (end
) > pos
)
2348 /* OVERLAY needs to be moved. */
2349 int where
= OVERLAY_POSITION (beg
);
2350 Lisp_Object other
, other_prev
;
2352 /* Splice the cons cell TAIL out of overlays_before. */
2354 XCONS (prev
)->cdr
= next
;
2356 buf
->overlays_before
= next
;
2358 /* Search thru overlays_after for where to put it. */
2360 for (other
= buf
->overlays_after
;
2362 other_prev
= other
, other
= XCONS (other
)->cdr
)
2364 Lisp_Object otherbeg
, otheroverlay
, follower
;
2367 otheroverlay
= XCONS (other
)->car
;
2368 if (! OVERLAY_VALID (otheroverlay
))
2371 otherbeg
= OVERLAY_START (otheroverlay
);
2372 if (OVERLAY_POSITION (otherbeg
) >= where
)
2376 /* Add TAIL to overlays_after before OTHER. */
2377 XCONS (tail
)->cdr
= other
;
2378 if (!NILP (other_prev
))
2379 XCONS (other_prev
)->cdr
= tail
;
2381 buf
->overlays_after
= tail
;
2385 /* We've reached the things that should stay in overlays_before.
2386 All the rest of overlays_before must end even earlier,
2391 /* See if anything in overlays_after should be in overlays_before. */
2393 for (tail
= buf
->overlays_after
;
2395 prev
= tail
, tail
= next
)
2397 next
= XCONS (tail
)->cdr
;
2398 overlay
= XCONS (tail
)->car
;
2400 /* If the overlay is not valid, get rid of it. */
2401 if (!OVERLAY_VALID (overlay
))
2406 /* Splice the cons cell TAIL out of overlays_after. */
2408 XCONS (prev
)->cdr
= next
;
2410 buf
->overlays_after
= next
;
2416 beg
= OVERLAY_START (overlay
);
2417 end
= OVERLAY_END (overlay
);
2419 /* Stop looking, when we know that nothing further
2420 can possibly end before POS. */
2421 if (OVERLAY_POSITION (beg
) > pos
)
2424 if (OVERLAY_POSITION (end
) <= pos
)
2426 /* OVERLAY needs to be moved. */
2427 int where
= OVERLAY_POSITION (end
);
2428 Lisp_Object other
, other_prev
;
2430 /* Splice the cons cell TAIL out of overlays_after. */
2432 XCONS (prev
)->cdr
= next
;
2434 buf
->overlays_after
= next
;
2436 /* Search thru overlays_before for where to put it. */
2438 for (other
= buf
->overlays_before
;
2440 other_prev
= other
, other
= XCONS (other
)->cdr
)
2442 Lisp_Object otherend
, otheroverlay
;
2445 otheroverlay
= XCONS (other
)->car
;
2446 if (! OVERLAY_VALID (otheroverlay
))
2449 otherend
= OVERLAY_END (otheroverlay
);
2450 if (OVERLAY_POSITION (otherend
) <= where
)
2454 /* Add TAIL to overlays_before before OTHER. */
2455 XCONS (tail
)->cdr
= other
;
2456 if (!NILP (other_prev
))
2457 XCONS (other_prev
)->cdr
= tail
;
2459 buf
->overlays_before
= tail
;
2464 XSETFASTINT (buf
->overlay_center
, pos
);
2468 adjust_overlays_for_insert (pos
, length
)
2472 /* After an insertion, the lists are still sorted properly,
2473 but we may need to update the value of the overlay center. */
2474 if (XFASTINT (current_buffer
->overlay_center
) >= pos
)
2475 XSETFASTINT (current_buffer
->overlay_center
,
2476 XFASTINT (current_buffer
->overlay_center
) + length
);
2480 adjust_overlays_for_delete (pos
, length
)
2484 if (XFASTINT (current_buffer
->overlay_center
) < pos
)
2485 /* The deletion was to our right. No change needed; the before- and
2486 after-lists are still consistent. */
2488 else if (XFASTINT (current_buffer
->overlay_center
) > pos
+ length
)
2489 /* The deletion was to our left. We need to adjust the center value
2490 to account for the change in position, but the lists are consistent
2491 given the new value. */
2492 XSETFASTINT (current_buffer
->overlay_center
,
2493 XFASTINT (current_buffer
->overlay_center
) - length
);
2495 /* We're right in the middle. There might be things on the after-list
2496 that now belong on the before-list. Recentering will move them,
2497 and also update the center point. */
2498 recenter_overlay_lists (current_buffer
, pos
);
2501 /* Fix up overlays that were garbled as a result of permuting markers
2502 in the range START through END. Any overlay with at least one
2503 endpoint in this range will need to be unlinked from the overlay
2504 list and reinserted in its proper place.
2505 Such an overlay might even have negative size at this point.
2506 If so, we'll reverse the endpoints. Can you think of anything
2507 better to do in this situation? */
2509 fix_overlays_in_range (start
, end
)
2510 register int start
, end
;
2512 Lisp_Object tem
, overlay
;
2513 Lisp_Object before_list
, after_list
;
2514 Lisp_Object
*ptail
, *pbefore
= &before_list
, *pafter
= &after_list
;
2515 int startpos
, endpos
;
2517 /* This algorithm shifts links around instead of consing and GCing.
2518 The loop invariant is that before_list (resp. after_list) is a
2519 well-formed list except that its last element, the one that
2520 *pbefore (resp. *pafter) points to, is still uninitialized.
2521 So it's not a bug that before_list isn't initialized, although
2522 it may look strange. */
2523 for (ptail
= ¤t_buffer
->overlays_before
; CONSP (*ptail
);)
2525 overlay
= XCONS (*ptail
)->car
;
2526 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2529 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2531 || (startpos
>= start
&& startpos
< end
))
2533 /* If the overlay is backwards, fix that now. */
2534 if (startpos
> endpos
)
2537 Fset_marker (OVERLAY_START (overlay
), make_number (endpos
),
2539 Fset_marker (OVERLAY_END (overlay
), make_number (startpos
),
2541 tem
= startpos
; startpos
= endpos
; endpos
= tem
;
2543 /* Add it to the end of the wrong list. Later on,
2544 recenter_overlay_lists will move it to the right place. */
2545 if (endpos
< XINT (current_buffer
->overlay_center
))
2548 pafter
= &XCONS (*ptail
)->cdr
;
2553 pbefore
= &XCONS (*ptail
)->cdr
;
2555 *ptail
= XCONS (*ptail
)->cdr
;
2558 ptail
= &XCONS (*ptail
)->cdr
;
2560 for (ptail
= ¤t_buffer
->overlays_after
; CONSP (*ptail
);)
2562 overlay
= XCONS (*ptail
)->car
;
2563 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2564 if (startpos
>= end
)
2566 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2567 if (startpos
>= start
2568 || (endpos
>= start
&& endpos
< end
))
2570 if (startpos
> endpos
)
2573 Fset_marker (OVERLAY_START (overlay
), make_number (endpos
),
2575 Fset_marker (OVERLAY_END (overlay
), make_number (startpos
),
2577 tem
= startpos
; startpos
= endpos
; endpos
= tem
;
2579 if (endpos
< XINT (current_buffer
->overlay_center
))
2582 pafter
= &XCONS (*ptail
)->cdr
;
2587 pbefore
= &XCONS (*ptail
)->cdr
;
2589 *ptail
= XCONS (*ptail
)->cdr
;
2592 ptail
= &XCONS (*ptail
)->cdr
;
2595 /* Splice the constructed (wrong) lists into the buffer's lists,
2596 and let the recenter function make it sane again. */
2597 *pbefore
= current_buffer
->overlays_before
;
2598 current_buffer
->overlays_before
= before_list
;
2599 recenter_overlay_lists (current_buffer
,
2600 XINT (current_buffer
->overlay_center
));
2602 *pafter
= current_buffer
->overlays_after
;
2603 current_buffer
->overlays_after
= after_list
;
2604 recenter_overlay_lists (current_buffer
,
2605 XINT (current_buffer
->overlay_center
));
2608 /* We have two types of overlay: the one whose ending marker is
2609 after-insertion-marker (this is the usual case) and the one whose
2610 ending marker is before-insertion-marker. When `overlays_before'
2611 contains overlays of the latter type and the former type in this
2612 order and both overlays end at inserting position, inserting a text
2613 increases only the ending marker of the latter type, which results
2614 in incorrect ordering of `overlays_before'.
2616 This function fixes ordering of overlays in the slot
2617 `overlays_before' of the buffer *BP. Before the insertion, `point'
2618 was at PREV, and now is at POS. */
2620 fix_overlays_before (bp
, prev
, pos
)
2624 Lisp_Object
*tailp
= &bp
->overlays_before
;
2625 Lisp_Object
*right_place
;
2628 /* After the insertion, the several overlays may be in incorrect
2629 order. The possibility is that, in the list `overlays_before',
2630 an overlay which ends at POS appears after an overlay which ends
2631 at PREV. Since POS is greater than PREV, we must fix the
2632 ordering of these overlays, by moving overlays ends at POS before
2633 the overlays ends at PREV. */
2635 /* At first, find a place where disordered overlays should be linked
2636 in. It is where an overlay which end before POS exists. (i.e. an
2637 overlay whose ending marker is after-insertion-marker if disorder
2639 while (!NILP (*tailp
)
2640 && ((end
= OVERLAY_POSITION (OVERLAY_END (XCONS (*tailp
)->car
)))
2642 tailp
= &XCONS (*tailp
)->cdr
;
2644 /* If we don't find such an overlay,
2645 or the found one ends before PREV,
2646 or the found one is the last one in the list,
2647 we don't have to fix anything. */
2650 || NILP (XCONS (*tailp
)->cdr
))
2653 right_place
= tailp
;
2654 tailp
= &XCONS (*tailp
)->cdr
;
2656 /* Now, end position of overlays in the list *TAILP should be before
2657 or equal to PREV. In the loop, an overlay which ends at POS is
2658 moved ahead to the place pointed by RIGHT_PLACE. If we found an
2659 overlay which ends before PREV, the remaining overlays are in
2661 while (!NILP (*tailp
))
2663 end
= OVERLAY_POSITION (OVERLAY_END (XCONS (*tailp
)->car
));
2666 { /* This overlay is disordered. */
2667 Lisp_Object found
= *tailp
;
2669 /* Unlink the found overlay. */
2670 *tailp
= XCONS (found
)->cdr
;
2671 /* Move an overlay at RIGHT_PLACE to the next of the found one. */
2672 XCONS (found
)->cdr
= *right_place
;
2673 /* Link it into the right place. */
2674 *right_place
= found
;
2676 else if (end
== prev
)
2677 tailp
= &XCONS (*tailp
)->cdr
;
2678 else /* No more disordered overlay. */
2683 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
2684 "Return t if OBJECT is an overlay.")
2688 return (OVERLAYP (object
) ? Qt
: Qnil
);
2691 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
2692 "Create a new overlay with range BEG to END in BUFFER.\n\
2693 If omitted, BUFFER defaults to the current buffer.\n\
2694 BEG and END may be integers or markers.\n\
2695 The fourth arg FRONT-ADVANCE, if non-nil, makes the\n\
2696 front delimiter advance when text is inserted there.\n\
2697 The fifth arg REAR-ADVANCE, if non-nil, makes the\n\
2698 rear delimiter advance when text is inserted there.")
2699 (beg
, end
, buffer
, front_advance
, rear_advance
)
2700 Lisp_Object beg
, end
, buffer
;
2701 Lisp_Object front_advance
, rear_advance
;
2703 Lisp_Object overlay
;
2707 XSETBUFFER (buffer
, current_buffer
);
2709 CHECK_BUFFER (buffer
, 2);
2711 && ! EQ (Fmarker_buffer (beg
), buffer
))
2712 error ("Marker points into wrong buffer");
2714 && ! EQ (Fmarker_buffer (end
), buffer
))
2715 error ("Marker points into wrong buffer");
2717 CHECK_NUMBER_COERCE_MARKER (beg
, 1);
2718 CHECK_NUMBER_COERCE_MARKER (end
, 1);
2720 if (XINT (beg
) > XINT (end
))
2723 temp
= beg
; beg
= end
; end
= temp
;
2726 b
= XBUFFER (buffer
);
2728 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
2729 end
= Fset_marker (Fmake_marker (), end
, buffer
);
2731 if (!NILP (front_advance
))
2732 XMARKER (beg
)->insertion_type
= 1;
2733 if (!NILP (rear_advance
))
2734 XMARKER (end
)->insertion_type
= 1;
2736 overlay
= allocate_misc ();
2737 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
2738 XOVERLAY (overlay
)->start
= beg
;
2739 XOVERLAY (overlay
)->end
= end
;
2740 XOVERLAY (overlay
)->plist
= Qnil
;
2742 /* Put the new overlay on the wrong list. */
2743 end
= OVERLAY_END (overlay
);
2744 if (OVERLAY_POSITION (end
) < XINT (b
->overlay_center
))
2745 b
->overlays_after
= Fcons (overlay
, b
->overlays_after
);
2747 b
->overlays_before
= Fcons (overlay
, b
->overlays_before
);
2749 /* This puts it in the right list, and in the right order. */
2750 recenter_overlay_lists (b
, XINT (b
->overlay_center
));
2752 /* We don't need to redisplay the region covered by the overlay, because
2753 the overlay has no properties at the moment. */
2758 /* Mark a section of BUF as needing redisplay because of overlays changes. */
2761 modify_overlay (buf
, start
, end
)
2771 start
= end
; end
= temp
;
2774 /* If this is a buffer not in the selected window,
2775 we must do other windows. */
2776 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
2777 windows_or_buffers_changed
= 1;
2778 /* If it's not current, we can't use beg_unchanged, end_unchanged for it. */
2779 else if (buf
!= current_buffer
)
2780 windows_or_buffers_changed
= 1;
2781 /* If multiple windows show this buffer, we must do other windows. */
2782 else if (buffer_shared
> 1)
2783 windows_or_buffers_changed
= 1;
2786 if (unchanged_modified
== MODIFF
2787 && overlay_unchanged_modified
== OVERLAY_MODIFF
)
2789 beg_unchanged
= start
- BEG
;
2790 end_unchanged
= Z
- end
;
2794 if (Z
- end
< end_unchanged
)
2795 end_unchanged
= Z
- end
;
2796 if (start
- BEG
< beg_unchanged
)
2797 beg_unchanged
= start
- BEG
;
2801 ++BUF_OVERLAY_MODIFF (buf
);
2805 Lisp_Object
Fdelete_overlay ();
2807 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
2808 "Set the endpoints of OVERLAY to BEG and END in BUFFER.\n\
2809 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.\n\
2810 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current\n\
2812 (overlay
, beg
, end
, buffer
)
2813 Lisp_Object overlay
, beg
, end
, buffer
;
2815 struct buffer
*b
, *ob
;
2816 Lisp_Object obuffer
;
2817 int count
= specpdl_ptr
- specpdl
;
2819 CHECK_OVERLAY (overlay
, 0);
2821 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
2823 XSETBUFFER (buffer
, current_buffer
);
2824 CHECK_BUFFER (buffer
, 3);
2827 && ! EQ (Fmarker_buffer (beg
), buffer
))
2828 error ("Marker points into wrong buffer");
2830 && ! EQ (Fmarker_buffer (end
), buffer
))
2831 error ("Marker points into wrong buffer");
2833 CHECK_NUMBER_COERCE_MARKER (beg
, 1);
2834 CHECK_NUMBER_COERCE_MARKER (end
, 1);
2836 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
2837 return Fdelete_overlay (overlay
);
2839 if (XINT (beg
) > XINT (end
))
2842 temp
= beg
; beg
= end
; end
= temp
;
2845 specbind (Qinhibit_quit
, Qt
);
2847 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
2848 b
= XBUFFER (buffer
);
2849 ob
= XBUFFER (obuffer
);
2851 /* If the overlay has changed buffers, do a thorough redisplay. */
2852 if (!EQ (buffer
, obuffer
))
2854 /* Redisplay where the overlay was. */
2855 if (!NILP (obuffer
))
2860 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2861 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2863 modify_overlay (ob
, o_beg
, o_end
);
2866 /* Redisplay where the overlay is going to be. */
2867 modify_overlay (b
, XINT (beg
), XINT (end
));
2870 /* Redisplay the area the overlay has just left, or just enclosed. */
2873 int change_beg
, change_end
;
2875 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2876 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2878 if (o_beg
== XINT (beg
))
2879 modify_overlay (b
, o_end
, XINT (end
));
2880 else if (o_end
== XINT (end
))
2881 modify_overlay (b
, o_beg
, XINT (beg
));
2884 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
2885 if (XINT (end
) > o_end
) o_end
= XINT (end
);
2886 modify_overlay (b
, o_beg
, o_end
);
2890 if (!NILP (obuffer
))
2892 ob
->overlays_before
= Fdelq (overlay
, ob
->overlays_before
);
2893 ob
->overlays_after
= Fdelq (overlay
, ob
->overlays_after
);
2896 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
2897 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
2899 /* Put the overlay on the wrong list. */
2900 end
= OVERLAY_END (overlay
);
2901 if (OVERLAY_POSITION (end
) < XINT (b
->overlay_center
))
2902 b
->overlays_after
= Fcons (overlay
, b
->overlays_after
);
2904 b
->overlays_before
= Fcons (overlay
, b
->overlays_before
);
2906 /* This puts it in the right list, and in the right order. */
2907 recenter_overlay_lists (b
, XINT (b
->overlay_center
));
2909 return unbind_to (count
, overlay
);
2912 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
2913 "Delete the overlay OVERLAY from its buffer.")
2915 Lisp_Object overlay
;
2919 int count
= specpdl_ptr
- specpdl
;
2921 CHECK_OVERLAY (overlay
, 0);
2923 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
2927 b
= XBUFFER (buffer
);
2929 specbind (Qinhibit_quit
, Qt
);
2931 b
->overlays_before
= Fdelq (overlay
, b
->overlays_before
);
2932 b
->overlays_after
= Fdelq (overlay
, b
->overlays_after
);
2935 marker_position (OVERLAY_START (overlay
)),
2936 marker_position (OVERLAY_END (overlay
)));
2938 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
2939 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
2941 return unbind_to (count
, Qnil
);
2944 /* Overlay dissection functions. */
2946 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
2947 "Return the position at which OVERLAY starts.")
2949 Lisp_Object overlay
;
2951 CHECK_OVERLAY (overlay
, 0);
2953 return (Fmarker_position (OVERLAY_START (overlay
)));
2956 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
2957 "Return the position at which OVERLAY ends.")
2959 Lisp_Object overlay
;
2961 CHECK_OVERLAY (overlay
, 0);
2963 return (Fmarker_position (OVERLAY_END (overlay
)));
2966 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
2967 "Return the buffer OVERLAY belongs to.")
2969 Lisp_Object overlay
;
2971 CHECK_OVERLAY (overlay
, 0);
2973 return Fmarker_buffer (OVERLAY_START (overlay
));
2976 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
2977 "Return a list of the properties on OVERLAY.\n\
2978 This is a copy of OVERLAY's plist; modifying its conses has no effect on\n\
2981 Lisp_Object overlay
;
2983 CHECK_OVERLAY (overlay
, 0);
2985 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
2989 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
2990 "Return a list of the overlays that contain position POS.")
2995 Lisp_Object
*overlay_vec
;
2999 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
3002 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3004 /* Put all the overlays we want in a vector in overlay_vec.
3005 Store the length in len. */
3006 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3007 (int *) 0, (int *) 0);
3009 /* Make a list of them all. */
3010 result
= Flist (noverlays
, overlay_vec
);
3012 xfree (overlay_vec
);
3016 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
3017 "Return a list of the overlays that overlap the region BEG ... END.\n\
3018 Overlap means that at least one character is contained within the overlay\n\
3019 and also contained within the specified region.\n\
3020 Empty overlays are included in the result if they are located at BEG\n\
3021 or between BEG and END.")
3023 Lisp_Object beg
, end
;
3026 Lisp_Object
*overlay_vec
;
3030 CHECK_NUMBER_COERCE_MARKER (beg
, 0);
3031 CHECK_NUMBER_COERCE_MARKER (end
, 0);
3034 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3036 /* Put all the overlays we want in a vector in overlay_vec.
3037 Store the length in len. */
3038 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
3039 (int *) 0, (int *) 0);
3041 /* Make a list of them all. */
3042 result
= Flist (noverlays
, overlay_vec
);
3044 xfree (overlay_vec
);
3048 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
3050 "Return the next position after POS where an overlay starts or ends.\n\
3051 If there are no more overlay boundaries after POS, return (point-max).")
3057 Lisp_Object
*overlay_vec
;
3061 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
3064 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3066 /* Put all the overlays we want in a vector in overlay_vec.
3067 Store the length in len.
3068 endpos gets the position where the next overlay starts. */
3069 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3070 &endpos
, (int *) 0);
3072 /* If any of these overlays ends before endpos,
3073 use its ending point instead. */
3074 for (i
= 0; i
< noverlays
; i
++)
3079 oend
= OVERLAY_END (overlay_vec
[i
]);
3080 oendpos
= OVERLAY_POSITION (oend
);
3081 if (oendpos
< endpos
)
3085 xfree (overlay_vec
);
3086 return make_number (endpos
);
3089 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
3090 Sprevious_overlay_change
, 1, 1, 0,
3091 "Return the previous position before POS where an overlay starts or ends.\n\
3092 If there are no more overlay boundaries before POS, return (point-min).")
3098 Lisp_Object
*overlay_vec
;
3103 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
3106 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3108 /* At beginning of buffer, we know the answer;
3109 avoid bug subtracting 1 below. */
3110 if (XINT (pos
) == BEGV
)
3113 /* Put all the overlays we want in a vector in overlay_vec.
3114 Store the length in len.
3115 prevpos gets the position of an overlay end. */
3116 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3117 (int *) 0, &prevpos
);
3119 /* If any of these overlays starts after prevpos,
3120 maybe use its starting point instead. */
3121 for (i
= 0; i
< noverlays
; i
++)
3126 ostart
= OVERLAY_START (overlay_vec
[i
]);
3127 ostartpos
= OVERLAY_POSITION (ostart
);
3128 if (ostartpos
> prevpos
&& ostartpos
< XINT (pos
))
3129 prevpos
= ostartpos
;
3132 /* If any overlay ends at pos, consider its starting point too. */
3133 for (tail
= current_buffer
->overlays_before
;
3135 tail
= XCONS (tail
)->cdr
)
3137 Lisp_Object overlay
, ostart
;
3140 overlay
= XCONS (tail
)->car
;
3142 ostart
= OVERLAY_START (overlay
);
3143 ostartpos
= OVERLAY_POSITION (ostart
);
3144 if (ostartpos
> prevpos
&& ostartpos
< XINT (pos
))
3145 prevpos
= ostartpos
;
3148 xfree (overlay_vec
);
3149 return make_number (prevpos
);
3152 /* These functions are for debugging overlays. */
3154 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
3155 "Return a pair of lists giving all the overlays of the current buffer.\n\
3156 The car has all the overlays before the overlay center;\n\
3157 the cdr has all the overlays after the overlay center.\n\
3158 Recentering overlays moves overlays between these lists.\n\
3159 The lists you get are copies, so that changing them has no effect.\n\
3160 However, the overlays you get are the real objects that the buffer uses.")
3163 Lisp_Object before
, after
;
3164 before
= current_buffer
->overlays_before
;
3166 before
= Fcopy_sequence (before
);
3167 after
= current_buffer
->overlays_after
;
3169 after
= Fcopy_sequence (after
);
3171 return Fcons (before
, after
);
3174 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
3175 "Recenter the overlays of the current buffer around position POS.")
3179 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
3181 recenter_overlay_lists (current_buffer
, XINT (pos
));
3185 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
3186 "Get the property of overlay OVERLAY with property name PROP.")
3188 Lisp_Object overlay
, prop
;
3190 Lisp_Object plist
, fallback
;
3192 CHECK_OVERLAY (overlay
, 0);
3196 for (plist
= XOVERLAY (overlay
)->plist
;
3197 CONSP (plist
) && CONSP (XCONS (plist
)->cdr
);
3198 plist
= XCONS (XCONS (plist
)->cdr
)->cdr
)
3200 if (EQ (XCONS (plist
)->car
, prop
))
3201 return XCONS (XCONS (plist
)->cdr
)->car
;
3202 else if (EQ (XCONS (plist
)->car
, Qcategory
))
3205 tem
= Fcar (Fcdr (plist
));
3207 fallback
= Fget (tem
, prop
);
3214 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
3215 "Set one property of overlay OVERLAY: give property PROP value VALUE.")
3216 (overlay
, prop
, value
)
3217 Lisp_Object overlay
, prop
, value
;
3219 Lisp_Object tail
, buffer
;
3222 CHECK_OVERLAY (overlay
, 0);
3224 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3226 for (tail
= XOVERLAY (overlay
)->plist
;
3227 CONSP (tail
) && CONSP (XCONS (tail
)->cdr
);
3228 tail
= XCONS (XCONS (tail
)->cdr
)->cdr
)
3229 if (EQ (XCONS (tail
)->car
, prop
))
3231 changed
= !EQ (XCONS (XCONS (tail
)->cdr
)->car
, value
);
3232 XCONS (XCONS (tail
)->cdr
)->car
= value
;
3235 /* It wasn't in the list, so add it to the front. */
3236 changed
= !NILP (value
);
3237 XOVERLAY (overlay
)->plist
3238 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
3240 if (! NILP (buffer
))
3243 modify_overlay (XBUFFER (buffer
),
3244 marker_position (OVERLAY_START (overlay
)),
3245 marker_position (OVERLAY_END (overlay
)));
3246 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
3247 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
3248 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
3249 Fdelete_overlay (overlay
);
3254 /* Subroutine of report_overlay_modification. */
3256 /* Lisp vector holding overlay hook functions to call.
3257 Vector elements come in pairs.
3258 Each even-index element is a list of hook functions.
3259 The following odd-index element is the overlay they came from.
3261 Before the buffer change, we fill in this vector
3262 as we call overlay hook functions.
3263 After the buffer change, we get the functions to call from this vector.
3264 This way we always call the same functions before and after the change. */
3265 static Lisp_Object last_overlay_modification_hooks
;
3267 /* Number of elements actually used in last_overlay_modification_hooks. */
3268 static int last_overlay_modification_hooks_used
;
3270 /* Add one functionlist/overlay pair
3271 to the end of last_overlay_modification_hooks. */
3274 add_overlay_mod_hooklist (functionlist
, overlay
)
3275 Lisp_Object functionlist
, overlay
;
3277 int oldsize
= XVECTOR (last_overlay_modification_hooks
)->size
;
3279 if (last_overlay_modification_hooks_used
== oldsize
)
3282 old
= last_overlay_modification_hooks
;
3283 last_overlay_modification_hooks
3284 = Fmake_vector (make_number (oldsize
* 2), Qnil
);
3285 bcopy (XVECTOR (old
)->contents
,
3286 XVECTOR (last_overlay_modification_hooks
)->contents
,
3287 sizeof (Lisp_Object
) * oldsize
);
3289 XVECTOR (last_overlay_modification_hooks
)->contents
[last_overlay_modification_hooks_used
++] = functionlist
;
3290 XVECTOR (last_overlay_modification_hooks
)->contents
[last_overlay_modification_hooks_used
++] = overlay
;
3293 /* Run the modification-hooks of overlays that include
3294 any part of the text in START to END.
3295 If this change is an insertion, also
3296 run the insert-before-hooks of overlay starting at END,
3297 and the insert-after-hooks of overlay ending at START.
3299 This is called both before and after the modification.
3300 AFTER is nonzero when we call after the modification.
3302 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
3303 When AFTER is nonzero, they are the start position,
3304 the position after the inserted new text,
3305 and the length of deleted or replaced old text. */
3308 report_overlay_modification (start
, end
, after
, arg1
, arg2
, arg3
)
3309 Lisp_Object start
, end
;
3311 Lisp_Object arg1
, arg2
, arg3
;
3313 Lisp_Object prop
, overlay
, tail
;
3314 /* 1 if this change is an insertion. */
3315 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
3317 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
3321 GCPRO5 (overlay
, tail
, arg1
, arg2
, arg3
);
3325 /* Call the functions recorded in last_overlay_modification_hooks
3326 rather than scanning the overlays again.
3327 First copy the vector contents, in case some of these hooks
3328 do subsequent modification of the buffer. */
3329 int size
= last_overlay_modification_hooks_used
;
3330 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
3333 bcopy (XVECTOR (last_overlay_modification_hooks
)->contents
,
3334 copy
, size
* sizeof (Lisp_Object
));
3336 gcpro1
.nvars
= size
;
3338 for (i
= 0; i
< size
;)
3340 Lisp_Object prop
, overlay
;
3342 overlay
= copy
[i
++];
3343 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3349 /* We are being called before a change.
3350 Scan the overlays to find the functions to call. */
3351 last_overlay_modification_hooks_used
= 0;
3353 for (tail
= current_buffer
->overlays_before
;
3355 tail
= XCONS (tail
)->cdr
)
3357 int startpos
, endpos
;
3358 Lisp_Object ostart
, oend
;
3360 overlay
= XCONS (tail
)->car
;
3362 ostart
= OVERLAY_START (overlay
);
3363 oend
= OVERLAY_END (overlay
);
3364 endpos
= OVERLAY_POSITION (oend
);
3365 if (XFASTINT (start
) > endpos
)
3367 startpos
= OVERLAY_POSITION (ostart
);
3368 if (insertion
&& (XFASTINT (start
) == startpos
3369 || XFASTINT (end
) == startpos
))
3371 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
3374 /* Copy TAIL in case the hook recenters the overlay lists. */
3376 tail
= Fcopy_sequence (tail
);
3378 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3381 if (insertion
&& (XFASTINT (start
) == endpos
3382 || XFASTINT (end
) == endpos
))
3384 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
3388 tail
= Fcopy_sequence (tail
);
3390 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3393 /* Test for intersecting intervals. This does the right thing
3394 for both insertion and deletion. */
3395 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
3397 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
3401 tail
= Fcopy_sequence (tail
);
3403 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3409 for (tail
= current_buffer
->overlays_after
;
3411 tail
= XCONS (tail
)->cdr
)
3413 int startpos
, endpos
;
3414 Lisp_Object ostart
, oend
;
3416 overlay
= XCONS (tail
)->car
;
3418 ostart
= OVERLAY_START (overlay
);
3419 oend
= OVERLAY_END (overlay
);
3420 startpos
= OVERLAY_POSITION (ostart
);
3421 endpos
= OVERLAY_POSITION (oend
);
3422 if (XFASTINT (end
) < startpos
)
3424 if (insertion
&& (XFASTINT (start
) == startpos
3425 || XFASTINT (end
) == startpos
))
3427 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
3431 tail
= Fcopy_sequence (tail
);
3433 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3436 if (insertion
&& (XFASTINT (start
) == endpos
3437 || XFASTINT (end
) == endpos
))
3439 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
3443 tail
= Fcopy_sequence (tail
);
3445 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3448 /* Test for intersecting intervals. This does the right thing
3449 for both insertion and deletion. */
3450 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
3452 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
3456 tail
= Fcopy_sequence (tail
);
3458 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3467 call_overlay_mod_hooks (list
, overlay
, after
, arg1
, arg2
, arg3
)
3468 Lisp_Object list
, overlay
;
3470 Lisp_Object arg1
, arg2
, arg3
;
3472 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3474 GCPRO4 (list
, arg1
, arg2
, arg3
);
3476 add_overlay_mod_hooklist (list
, overlay
);
3478 while (!NILP (list
))
3481 call4 (Fcar (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
3483 call5 (Fcar (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
3489 /* Delete any zero-sized overlays at position POS, if the `evaporate'
3492 evaporate_overlays (pos
)
3495 Lisp_Object tail
, overlay
, hit_list
;
3498 if (pos
<= XFASTINT (current_buffer
->overlay_center
))
3499 for (tail
= current_buffer
->overlays_before
; CONSP (tail
);
3500 tail
= XCONS (tail
)->cdr
)
3503 overlay
= XCONS (tail
)->car
;
3504 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3507 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
3508 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3509 hit_list
= Fcons (overlay
, hit_list
);
3512 for (tail
= current_buffer
->overlays_after
; CONSP (tail
);
3513 tail
= XCONS (tail
)->cdr
)
3516 overlay
= XCONS (tail
)->car
;
3517 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3520 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
3521 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3522 hit_list
= Fcons (overlay
, hit_list
);
3524 for (; CONSP (hit_list
); hit_list
= XCONS (hit_list
)->cdr
)
3525 Fdelete_overlay (XCONS (hit_list
)->car
);
3528 /* Somebody has tried to store a value with an unacceptable type
3529 into the buffer-local slot with offset OFFSET. */
3531 buffer_slot_type_mismatch (offset
)
3536 sym
= *(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
);
3537 switch (XINT (*(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
)))
3539 case Lisp_Int
: type_name
= "integers"; break;
3540 case Lisp_String
: type_name
= "strings"; break;
3541 case Lisp_Symbol
: type_name
= "symbols"; break;
3546 error ("only %s should be stored in the buffer-local variable %s",
3547 type_name
, XSYMBOL (sym
)->name
->data
);
3552 register Lisp_Object tem
;
3554 buffer_permanent_local_flags
= 0;
3556 /* Make sure all markable slots in buffer_defaults
3557 are initialized reasonably, so mark_buffer won't choke. */
3558 reset_buffer (&buffer_defaults
);
3559 reset_buffer_local_variables (&buffer_defaults
, 1);
3560 reset_buffer (&buffer_local_symbols
);
3561 reset_buffer_local_variables (&buffer_local_symbols
, 1);
3562 /* Prevent GC from getting confused. */
3563 buffer_defaults
.text
= &buffer_defaults
.own_text
;
3564 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
3565 #ifdef USE_TEXT_PROPERTIES
3566 BUF_INTERVALS (&buffer_defaults
) = 0;
3567 BUF_INTERVALS (&buffer_local_symbols
) = 0;
3569 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
3570 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
3572 /* Set up the default values of various buffer slots. */
3573 /* Must do these before making the first buffer! */
3575 /* real setup is done in loaddefs.el */
3576 buffer_defaults
.mode_line_format
= build_string ("%-");
3577 buffer_defaults
.abbrev_mode
= Qnil
;
3578 buffer_defaults
.overwrite_mode
= Qnil
;
3579 buffer_defaults
.case_fold_search
= Qt
;
3580 buffer_defaults
.auto_fill_function
= Qnil
;
3581 buffer_defaults
.selective_display
= Qnil
;
3583 buffer_defaults
.selective_display_ellipses
= Qt
;
3585 buffer_defaults
.abbrev_table
= Qnil
;
3586 buffer_defaults
.display_table
= Qnil
;
3587 buffer_defaults
.undo_list
= Qnil
;
3588 buffer_defaults
.mark_active
= Qnil
;
3589 buffer_defaults
.file_format
= Qnil
;
3590 buffer_defaults
.overlays_before
= Qnil
;
3591 buffer_defaults
.overlays_after
= Qnil
;
3592 XSETFASTINT (buffer_defaults
.overlay_center
, BEG
);
3594 XSETFASTINT (buffer_defaults
.tab_width
, 8);
3595 buffer_defaults
.truncate_lines
= Qnil
;
3596 buffer_defaults
.ctl_arrow
= Qt
;
3597 buffer_defaults
.direction_reversed
= Qnil
;
3600 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
3602 buffer_defaults
.enable_multibyte_characters
= Qt
;
3603 buffer_defaults
.buffer_file_coding_system
= Qnil
;
3604 XSETFASTINT (buffer_defaults
.fill_column
, 70);
3605 XSETFASTINT (buffer_defaults
.left_margin
, 0);
3606 buffer_defaults
.cache_long_line_scans
= Qnil
;
3607 buffer_defaults
.file_truename
= Qnil
;
3608 XSETFASTINT (buffer_defaults
.display_count
, 0);
3610 /* Assign the local-flags to the slots that have default values.
3611 The local flag is a bit that is used in the buffer
3612 to say that it has its own local value for the slot.
3613 The local flag bits are in the local_var_flags slot of the buffer. */
3615 /* Nothing can work if this isn't true */
3616 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
3618 /* 0 means not a lisp var, -1 means always local, else mask */
3619 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
3620 XSETINT (buffer_local_flags
.filename
, -1);
3621 XSETINT (buffer_local_flags
.directory
, -1);
3622 XSETINT (buffer_local_flags
.backed_up
, -1);
3623 XSETINT (buffer_local_flags
.save_length
, -1);
3624 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
3625 XSETINT (buffer_local_flags
.read_only
, -1);
3626 XSETINT (buffer_local_flags
.major_mode
, -1);
3627 XSETINT (buffer_local_flags
.mode_name
, -1);
3628 XSETINT (buffer_local_flags
.undo_list
, -1);
3629 XSETINT (buffer_local_flags
.mark_active
, -1);
3630 XSETINT (buffer_local_flags
.point_before_scroll
, -1);
3631 XSETINT (buffer_local_flags
.file_truename
, -1);
3632 XSETINT (buffer_local_flags
.invisibility_spec
, -1);
3633 XSETINT (buffer_local_flags
.file_format
, -1);
3634 XSETINT (buffer_local_flags
.display_count
, -1);
3636 XSETFASTINT (buffer_local_flags
.mode_line_format
, 1);
3637 XSETFASTINT (buffer_local_flags
.abbrev_mode
, 2);
3638 XSETFASTINT (buffer_local_flags
.overwrite_mode
, 4);
3639 XSETFASTINT (buffer_local_flags
.case_fold_search
, 8);
3640 XSETFASTINT (buffer_local_flags
.auto_fill_function
, 0x10);
3641 XSETFASTINT (buffer_local_flags
.selective_display
, 0x20);
3643 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, 0x40);
3645 XSETFASTINT (buffer_local_flags
.tab_width
, 0x80);
3646 XSETFASTINT (buffer_local_flags
.truncate_lines
, 0x100);
3647 XSETFASTINT (buffer_local_flags
.ctl_arrow
, 0x200);
3648 XSETFASTINT (buffer_local_flags
.fill_column
, 0x400);
3649 XSETFASTINT (buffer_local_flags
.left_margin
, 0x800);
3650 XSETFASTINT (buffer_local_flags
.abbrev_table
, 0x1000);
3651 XSETFASTINT (buffer_local_flags
.display_table
, 0x2000);
3653 XSETFASTINT (buffer_local_flags
.buffer_file_type
, 0x4000);
3654 /* Make this one a permanent local. */
3655 buffer_permanent_local_flags
|= 0x4000;
3657 XSETFASTINT (buffer_local_flags
.syntax_table
, 0x8000);
3658 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, 0x10000);
3659 XSETFASTINT (buffer_local_flags
.category_table
, 0x20000);
3660 XSETFASTINT (buffer_local_flags
.direction_reversed
, 0x40000);
3661 XSETFASTINT (buffer_local_flags
.enable_multibyte_characters
, 0x80000);
3662 /* Make this one a permanent local. */
3663 buffer_permanent_local_flags
|= 0x80000;
3664 XSETFASTINT (buffer_local_flags
.buffer_file_coding_system
, 0x100000);
3665 /* Make this one a permanent local. */
3666 buffer_permanent_local_flags
|= 0x100000;
3668 Vbuffer_alist
= Qnil
;
3672 QSFundamental
= build_string ("Fundamental");
3674 Qfundamental_mode
= intern ("fundamental-mode");
3675 buffer_defaults
.major_mode
= Qfundamental_mode
;
3677 Qmode_class
= intern ("mode-class");
3679 Qprotected_field
= intern ("protected-field");
3681 Qpermanent_local
= intern ("permanent-local");
3683 Qkill_buffer_hook
= intern ("kill-buffer-hook");
3685 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
3687 /* super-magic invisible buffer */
3688 Vbuffer_alist
= Qnil
;
3690 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
3695 char buf
[MAXPATHLEN
+1];
3697 struct stat dotstat
, pwdstat
;
3701 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
3703 /* If PWD is accurate, use it instead of calling getwd. This is faster
3704 when PWD is right, and may avoid a fatal error. */
3705 if ((pwd
= getenv ("PWD")) != 0 && IS_DIRECTORY_SEP (*pwd
)
3706 && stat (pwd
, &pwdstat
) == 0
3707 && stat (".", &dotstat
) == 0
3708 && dotstat
.st_ino
== pwdstat
.st_ino
3709 && dotstat
.st_dev
== pwdstat
.st_dev
3710 && strlen (pwd
) < MAXPATHLEN
)
3713 else if (getcwd (buf
, MAXPATHLEN
+1) == 0)
3714 fatal ("`getcwd' failed: %s\n", strerror (errno
));
3716 else if (getwd (buf
) == 0)
3717 fatal ("`getwd' failed: %s\n", buf
);
3721 /* Maybe this should really use some standard subroutine
3722 whose definition is filename syntax dependent. */
3724 if (!(IS_DIRECTORY_SEP (buf
[rc
- 1])))
3726 buf
[rc
] = DIRECTORY_SEP
;
3729 #endif /* not VMS */
3731 current_buffer
->directory
= build_string (buf
);
3733 /* Add /: to the front of the name
3734 if it would otherwise be treated as magic. */
3735 temp
= Ffind_file_name_handler (current_buffer
->directory
, Qt
);
3737 /* If the default dir is just /, TEMP is non-nil
3738 because of the ange-ftp completion handler.
3739 However, it is not necessary to turn / into /:/.
3740 So avoid doing that. */
3741 && strcmp ("/", XSTRING (current_buffer
->directory
)->data
))
3742 current_buffer
->directory
3743 = concat2 (build_string ("/:"), current_buffer
->directory
);
3745 temp
= get_minibuffer (0);
3746 XBUFFER (temp
)->directory
= current_buffer
->directory
;
3749 /* initialize the buffer routines */
3752 extern Lisp_Object Qdisabled
;
3754 staticpro (&last_overlay_modification_hooks
);
3755 last_overlay_modification_hooks
3756 = Fmake_vector (make_number (10), Qnil
);
3758 staticpro (&Vbuffer_defaults
);
3759 staticpro (&Vbuffer_local_symbols
);
3760 staticpro (&Qfundamental_mode
);
3761 staticpro (&Qmode_class
);
3762 staticpro (&QSFundamental
);
3763 staticpro (&Vbuffer_alist
);
3764 staticpro (&Qprotected_field
);
3765 staticpro (&Qpermanent_local
);
3766 staticpro (&Qkill_buffer_hook
);
3767 Qoverlayp
= intern ("overlayp");
3768 staticpro (&Qoverlayp
);
3769 Qevaporate
= intern ("evaporate");
3770 staticpro (&Qevaporate
);
3771 Qmodification_hooks
= intern ("modification-hooks");
3772 staticpro (&Qmodification_hooks
);
3773 Qinsert_in_front_hooks
= intern ("insert-in-front-hooks");
3774 staticpro (&Qinsert_in_front_hooks
);
3775 Qinsert_behind_hooks
= intern ("insert-behind-hooks");
3776 staticpro (&Qinsert_behind_hooks
);
3777 Qget_file_buffer
= intern ("get-file-buffer");
3778 staticpro (&Qget_file_buffer
);
3779 Qpriority
= intern ("priority");
3780 staticpro (&Qpriority
);
3781 Qwindow
= intern ("window");
3782 staticpro (&Qwindow
);
3783 Qbefore_string
= intern ("before-string");
3784 staticpro (&Qbefore_string
);
3785 Qafter_string
= intern ("after-string");
3786 staticpro (&Qafter_string
);
3787 Qfirst_change_hook
= intern ("first-change-hook");
3788 staticpro (&Qfirst_change_hook
);
3789 Qbefore_change_functions
= intern ("before-change-functions");
3790 staticpro (&Qbefore_change_functions
);
3791 Qafter_change_functions
= intern ("after-change-functions");
3792 staticpro (&Qafter_change_functions
);
3794 Fput (Qprotected_field
, Qerror_conditions
,
3795 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
3796 Fput (Qprotected_field
, Qerror_message
,
3797 build_string ("Attempt to modify a protected field"));
3799 /* All these use DEFVAR_LISP_NOPRO because the slots in
3800 buffer_defaults will all be marked via Vbuffer_defaults. */
3802 DEFVAR_LISP_NOPRO ("default-mode-line-format",
3803 &buffer_defaults
.mode_line_format
,
3804 "Default value of `mode-line-format' for buffers that don't override it.\n\
3805 This is the same as (default-value 'mode-line-format).");
3807 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
3808 &buffer_defaults
.abbrev_mode
,
3809 "Default value of `abbrev-mode' for buffers that do not override it.\n\
3810 This is the same as (default-value 'abbrev-mode).");
3812 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
3813 &buffer_defaults
.ctl_arrow
,
3814 "Default value of `ctl-arrow' for buffers that do not override it.\n\
3815 This is the same as (default-value 'ctl-arrow).");
3817 DEFVAR_LISP_NOPRO ("default-direction-reversed",
3818 &buffer_defaults
.direction_reversed
,
3819 "Default value of `direction_reversed' for buffers that do not override it.\n\
3820 This is the same as (default-value 'direction-reversed).");
3822 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
3823 &buffer_defaults
.enable_multibyte_characters
,
3824 "Default value of `enable-multibyte-characters' for buffers not overriding it.\n\
3825 This is the same as (default-value 'enable-multibyte-characters).");
3827 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
3828 &buffer_defaults
.buffer_file_coding_system
,
3829 "Default value of `buffer-file-coding-system' for buffers not overriding it.\n\
3830 This is the same as (default-value 'buffer-file-coding-system).");
3832 DEFVAR_LISP_NOPRO ("default-truncate-lines",
3833 &buffer_defaults
.truncate_lines
,
3834 "Default value of `truncate-lines' for buffers that do not override it.\n\
3835 This is the same as (default-value 'truncate-lines).");
3837 DEFVAR_LISP_NOPRO ("default-fill-column",
3838 &buffer_defaults
.fill_column
,
3839 "Default value of `fill-column' for buffers that do not override it.\n\
3840 This is the same as (default-value 'fill-column).");
3842 DEFVAR_LISP_NOPRO ("default-left-margin",
3843 &buffer_defaults
.left_margin
,
3844 "Default value of `left-margin' for buffers that do not override it.\n\
3845 This is the same as (default-value 'left-margin).");
3847 DEFVAR_LISP_NOPRO ("default-tab-width",
3848 &buffer_defaults
.tab_width
,
3849 "Default value of `tab-width' for buffers that do not override it.\n\
3850 This is the same as (default-value 'tab-width).");
3852 DEFVAR_LISP_NOPRO ("default-case-fold-search",
3853 &buffer_defaults
.case_fold_search
,
3854 "Default value of `case-fold-search' for buffers that don't override it.\n\
3855 This is the same as (default-value 'case-fold-search).");
3858 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
3859 &buffer_defaults
.buffer_file_type
,
3860 "Default file type for buffers that do not override it.\n\
3861 This is the same as (default-value 'buffer-file-type).\n\
3862 The file type is nil for text, t for binary.");
3865 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
3868 /* This doc string is too long for cpp; cpp dies if it isn't in a comment.
3869 But make-docfile finds it!
3870 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer->mode_line_format,
3872 "Template for displaying mode line for current buffer.\n\
3873 Each buffer has its own value of this variable.\n\
3874 Value may be a string, a symbol or a list or cons cell.\n\
3875 For a symbol, its value is used (but it is ignored if t or nil).\n\
3876 A string appearing directly as the value of a symbol is processed verbatim\n\
3877 in that the %-constructs below are not recognized.\n\
3878 For a list whose car is a symbol, the symbol's value is taken,\n\
3879 and if that is non-nil, the cadr of the list is processed recursively.\n\
3880 Otherwise, the caddr of the list (if there is one) is processed.\n\
3881 For a list whose car is a string or list, each element is processed\n\
3882 recursively and the results are effectively concatenated.\n\
3883 For a list whose car is an integer, the cdr of the list is processed\n\
3884 and padded (if the number is positive) or truncated (if negative)\n\
3885 to the width specified by that number.\n\
3886 A string is printed verbatim in the mode line except for %-constructs:\n\
3887 (%-constructs are allowed when the string is the entire mode-line-format\n\
3888 or when it is found in a cons-cell or a list)\n\
3889 %b -- print buffer name. %f -- print visited file name.\n\
3890 %F -- print frame name.\n\
3891 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.\n\
3892 % means buffer is read-only and * means it is modified.\n\
3893 For a modified read-only buffer, %* gives % and %+ gives *.\n\
3894 %s -- print process status. %l -- print the current line number.\n\
3895 %c -- print the current column number (this makes editing slower).\n\
3896 To make the column number update correctly in all cases,\n\
3897 `column-number-mode' must be non-nil.\n\
3898 %p -- print percent of buffer above top of window, or Top, Bot or All.\n\
3899 %P -- print percent of buffer above bottom of window, perhaps plus Top,\n\
3900 or print Bottom or All.\n\
3901 %n -- print Narrow if appropriate.\n\
3902 %t -- print T if file is text, B if binary.\n\
3903 %[ -- print one [ for each recursive editing level. %] similar.\n\
3904 %% -- print %. %- -- print infinitely many dashes.\n\
3905 Decimal digits after the % specify field width to which to pad.");
3908 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
3909 "*Major mode for new buffers. Defaults to `fundamental-mode'.\n\
3910 nil here means use current buffer's major mode.");
3912 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
3913 make_number (Lisp_Symbol
),
3914 "Symbol for current buffer's major mode.");
3916 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
3917 make_number (Lisp_String
),
3918 "Pretty name of current buffer's major mode (a string).");
3920 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
3921 "Non-nil turns on automatic expansion of abbrevs as they are inserted.\n\
3922 Automatically becomes buffer-local when set in any fashion.");
3924 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
3926 "*Non-nil if searches should ignore case.\n\
3927 Automatically becomes buffer-local when set in any fashion.");
3929 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
3930 make_number (Lisp_Int
),
3931 "*Column beyond which automatic line-wrapping should happen.\n\
3932 Automatically becomes buffer-local when set in any fashion.");
3934 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
3935 make_number (Lisp_Int
),
3936 "*Column for the default indent-line-function to indent to.\n\
3937 Linefeed indents to this column in Fundamental mode.\n\
3938 Automatically becomes buffer-local when set in any fashion.");
3940 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
3941 make_number (Lisp_Int
),
3942 "*Distance between tab stops (for display of tab characters), in columns.\n\
3943 Automatically becomes buffer-local when set in any fashion.");
3945 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
3946 "*Non-nil means display control chars with uparrow.\n\
3947 A value of nil means use backslash and octal digits.\n\
3948 Automatically becomes buffer-local when set in any fashion.\n\
3949 This variable does not apply to characters whose display is specified\n\
3950 in the current display table (if there is one).");
3952 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
3953 ¤t_buffer
->enable_multibyte_characters
, Qnil
,
3954 "*Non-nil means the buffer contents are regarded as multi-byte form\n\
3955 of characters, not a binary code. This affects the display, file I/O,\n\
3956 and behaviors of various editing commands.");
3958 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
3959 ¤t_buffer
->buffer_file_coding_system
, Qnil
,
3960 "Coding system to be used for encoding the buffer contents on saving.\n\
3961 If it is nil, the buffer is saved without any code conversion unless\n\
3962 some coding system is specified in file-coding-system-alist\n\
3963 for the buffer file.\n\
3965 This variable is never applied to a way of decoding\n\
3966 a file while reading it.");
3968 DEFVAR_PER_BUFFER ("direction-reversed", ¤t_buffer
->direction_reversed
,
3970 "*Non-nil means lines in the buffer are displayed right to left.");
3972 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
3973 "*Non-nil means do not display continuation lines;\n\
3974 give each line of text one screen line.\n\
3975 Automatically becomes buffer-local when set in any fashion.\n\
3977 Note that this is overridden by the variable\n\
3978 `truncate-partial-width-windows' if that variable is non-nil\n\
3979 and this buffer is not full-frame width.");
3982 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
3984 "Non-nil if the visited file is a binary file.\n\
3985 This variable is meaningful on MS-DOG and Windows NT.\n\
3986 On those systems, it is automatically local in every buffer.\n\
3987 On other systems, this variable is normally always nil.");
3990 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
3991 make_number (Lisp_String
),
3992 "Name of default directory of current buffer. Should end with slash.\n\
3993 Each buffer has its own value of this variable.");
3995 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
3997 "Function called (if non-nil) to perform auto-fill.\n\
3998 It is called after self-inserting a space or newline.\n\
3999 Each buffer has its own value of this variable.\n\
4000 NOTE: This variable is not a hook;\n\
4001 its value may not be a list of functions.");
4003 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
4004 make_number (Lisp_String
),
4005 "Name of file visited in current buffer, or nil if not visiting a file.\n\
4006 Each buffer has its own value of this variable.");
4008 DEFVAR_PER_BUFFER ("buffer-file-truename", ¤t_buffer
->file_truename
,
4009 make_number (Lisp_String
),
4010 "Abbreviated truename of file visited in current buffer, or nil if none.\n\
4011 The truename of a file is calculated by `file-truename'\n\
4012 and then abbreviated with `abbreviate-file-name'.\n\
4013 Each buffer has its own value of this variable.");
4015 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
4016 ¤t_buffer
->auto_save_file_name
,
4017 make_number (Lisp_String
),
4018 "Name of file for auto-saving current buffer,\n\
4019 or nil if buffer should not be auto-saved.\n\
4020 Each buffer has its own value of this variable.");
4022 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
4023 "Non-nil if this buffer is read-only.\n\
4024 Each buffer has its own value of this variable.");
4026 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
4027 "Non-nil if this buffer's file has been backed up.\n\
4028 Backing up is done before the first time the file is saved.\n\
4029 Each buffer has its own value of this variable.");
4031 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
4032 make_number (Lisp_Int
),
4033 "Length of current buffer when last read in, saved or auto-saved.\n\
4035 Each buffer has its own value of this variable.");
4037 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
4039 "Non-nil enables selective display:\n\
4040 Integer N as value means display only lines\n\
4041 that start with less than n columns of space.\n\
4042 A value of t means, after a ^M, all the rest of the line is invisible.\n\
4043 Then ^M's in the file are written into files as newlines.\n\n\
4044 Automatically becomes buffer-local when set in any fashion.");
4047 DEFVAR_PER_BUFFER ("selective-display-ellipses",
4048 ¤t_buffer
->selective_display_ellipses
,
4050 "t means display ... on previous line when a line is invisible.\n\
4051 Automatically becomes buffer-local when set in any fashion.");
4054 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
4055 "Non-nil if self-insertion should replace existing text.\n\
4056 The value should be one of `overwrite-mode-textual',\n\
4057 `overwrite-mode-binary', or nil.\n\
4058 If it is `overwrite-mode-textual', self-insertion still\n\
4059 inserts at the end of a line, and inserts when point is before a tab,\n\
4060 until the tab is filled in.\n\
4061 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.\n\
4062 Automatically becomes buffer-local when set in any fashion.");
4064 #if 0 /* The doc string is too long for some compilers,
4065 but make-docfile can find it in this comment. */
4066 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
4068 "Display table that controls display of the contents of current buffer.\n\
4069 Automatically becomes buffer-local when set in any fashion.\n\
4070 The display table is a char-table created with `make-display-table'.\n\
4071 The ordinary char-table elements control how to display each possible text\n\
4072 character. Each value should be a vector of characters or nil;\n\
4073 nil means display the character in the default fashion.\n\
4074 There are six extra slots to control the display of\n\
4075 the end of a truncated screen line (extra-slot 0, a single character);\n\
4076 the end of a continued line (extra-slot 1, a single character);\n\
4077 the escape character used to display character codes in octal\n\
4078 (extra-slot 2, a single character);\n\
4079 the character used as an arrow for control characters (extra-slot 3,\n\
4080 a single character);\n\
4081 the decoration indicating the presence of invisible lines (extra-slot 4,\n\
4082 a vector of characters);\n\
4083 the character used to draw the border between side-by-side windows\n\
4084 (extra-slot 5, a single character).\n\
4085 See also the functions `display-table-slot' and `set-display-table-slot'.\n\
4086 If this variable is nil, the value of `standard-display-table' is used.\n\
4087 Each window can have its own, overriding display table.");
4089 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
4092 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
4095 DEFVAR_LISP ("before-change-function", &Vbefore_change_function
,
4096 "If non-nil, a function to call before each text change (obsolete).\n\
4097 Two arguments are passed to the function: the positions of\n\
4098 the beginning and end of the range of old text to be changed.\n\
4099 \(For an insertion, the beginning and end are at the same place.)\n\
4100 No information is given about the length of the text after the change.\n\
4102 Buffer changes made while executing the `before-change-function'\n\
4103 don't call any before-change or after-change functions.\n\
4104 That's because these variables are temporarily set to nil.\n\
4105 As a result, a hook function cannot straightforwardly alter the value of\n\
4106 these variables. See the Emacs Lisp manual for a way of\n\
4107 accomplishing an equivalent result by using other variables.\n\n\
4108 This variable is obsolete; use `before-change-functions' instead.");
4109 Vbefore_change_function
= Qnil
;
4111 DEFVAR_LISP ("after-change-function", &Vafter_change_function
,
4112 "If non-nil, a Function to call after each text change (obsolete).\n\
4113 Three arguments are passed to the function: the positions of\n\
4114 the beginning and end of the range of changed text,\n\
4115 and the length of the pre-change text replaced by that range.\n\
4116 \(For an insertion, the pre-change length is zero;\n\
4117 for a deletion, that length is the number of bytes deleted,\n\
4118 and the post-change beginning and end are at the same place.)\n\
4120 Buffer changes made while executing the `after-change-function'\n\
4121 don't call any before-change or after-change functions.\n\
4122 That's because these variables are temporarily set to nil.\n\
4123 As a result, a hook function cannot straightforwardly alter the value of\n\
4124 these variables. See the Emacs Lisp manual for a way of\n\
4125 accomplishing an equivalent result by using other variables.\n\n\
4126 This variable is obsolete; use `after-change-functions' instead.");
4127 Vafter_change_function
= Qnil
;
4129 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
4130 "List of functions to call before each text change.\n\
4131 Two arguments are passed to each function: the positions of\n\
4132 the beginning and end of the range of old text to be changed.\n\
4133 \(For an insertion, the beginning and end are at the same place.)\n\
4134 No information is given about the length of the text after the change.\n\
4136 Buffer changes made while executing the `before-change-functions'\n\
4137 don't call any before-change or after-change functions.\n\
4138 That's because these variables are temporarily set to nil.\n\
4139 As a result, a hook function cannot straightforwardly alter the value of\n\
4140 these variables. See the Emacs Lisp manual for a way of\n\
4141 accomplishing an equivalent result by using other variables.");
4142 Vbefore_change_functions
= Qnil
;
4144 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
4145 "List of function to call after each text change.\n\
4146 Three arguments are passed to each function: the positions of\n\
4147 the beginning and end of the range of changed text,\n\
4148 and the length in bytes of the pre-change text replaced by that range.\n\
4149 \(For an insertion, the pre-change length is zero;\n\
4150 for a deletion, that length is the number of bytes deleted,\n\
4151 and the post-change beginning and end are at the same place.)\n\
4153 Buffer changes made while executing the `after-change-functions'\n\
4154 don't call any before-change or after-change functions.\n\
4155 That's because these variables are temporarily set to nil.\n\
4156 As a result, a hook function cannot straightforwardly alter the value of\n\
4157 these variables. See the Emacs Lisp manual for a way of\n\
4158 accomplishing an equivalent result by using other variables.");
4160 Vafter_change_functions
= Qnil
;
4162 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
4163 "A list of functions to call before changing a buffer which is unmodified.\n\
4164 The functions are run using the `run-hooks' function.");
4165 Vfirst_change_hook
= Qnil
;
4167 #if 0 /* The doc string is too long for some compilers,
4168 but make-docfile can find it in this comment. */
4169 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
4170 "List of undo entries in current buffer.\n\
4171 Recent changes come first; older changes follow newer.\n\
4173 An entry (BEG . END) represents an insertion which begins at\n\
4174 position BEG and ends at position END.\n\
4176 An entry (TEXT . POSITION) represents the deletion of the string TEXT\n\
4177 from (abs POSITION). If POSITION is positive, point was at the front\n\
4178 of the text being deleted; if negative, point was at the end.\n\
4180 An entry (t HIGH . LOW) indicates that the buffer previously had\n\
4181 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions\n\
4182 of the visited file's modification time, as of that time. If the\n\
4183 modification time of the most recent save is different, this entry is\n\
4186 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property\n\
4187 was modified between BEG and END. PROPERTY is the property name,\n\
4188 and VALUE is the old value.\n\
4190 An entry (MARKER . DISTANCE) indicates that the marker MARKER\n\
4191 was adjusted in position by the offset DISTANCE (an integer).\n\
4193 An entry of the form POSITION indicates that point was at the buffer\n\
4194 location given by the integer. Undoing an entry of this form places\n\
4195 point at POSITION.\n\
4197 nil marks undo boundaries. The undo command treats the changes\n\
4198 between two undo boundaries as a single step to be undone.\n\
4200 If the value of the variable is t, undo information is not recorded.");
4202 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
4205 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
4206 "Non-nil means the mark and region are currently active in this buffer.\n\
4207 Automatically local in all buffers.");
4209 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
4210 "Non-nil means that Emacs should use caches to handle long lines more quickly.\n\
4211 This variable is buffer-local, in all buffers.\n\
4213 Normally, the line-motion functions work by scanning the buffer for\n\
4214 newlines. Columnar operations (like move-to-column and\n\
4215 compute-motion) also work by scanning the buffer, summing character\n\
4216 widths as they go. This works well for ordinary text, but if the\n\
4217 buffer's lines are very long (say, more than 500 characters), these\n\
4218 motion functions will take longer to execute. Emacs may also take\n\
4219 longer to update the display.\n\
4221 If cache-long-line-scans is non-nil, these motion functions cache the\n\
4222 results of their scans, and consult the cache to avoid rescanning\n\
4223 regions of the buffer until the text is modified. The caches are most\n\
4224 beneficial when they prevent the most searching---that is, when the\n\
4225 buffer contains long lines and large regions of characters with the\n\
4226 same, fixed screen width.\n\
4228 When cache-long-line-scans is non-nil, processing short lines will\n\
4229 become slightly slower (because of the overhead of consulting the\n\
4230 cache), and the caches will use memory roughly proportional to the\n\
4231 number of newlines and characters whose screen width varies.\n\
4233 The caches require no explicit maintenance; their accuracy is\n\
4234 maintained internally by the Emacs primitives. Enabling or disabling\n\
4235 the cache should not affect the behavior of any of the motion\n\
4236 functions; it should only affect their performance.");
4238 DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer
->point_before_scroll
, Qnil
,
4239 "Value of point before the last series of scroll operations, or nil.");
4241 DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer
->file_format
, Qnil
,
4242 "List of formats to use when saving this buffer.\n\
4243 Formats are defined by `format-alist'. This variable is\n\
4244 set when a file is visited. Automatically local in all buffers.");
4246 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
4247 ¤t_buffer
->invisibility_spec
, Qnil
,
4248 "Invisibility spec of this buffer.\n\
4249 The default is t, which means that text is invisible\n\
4250 if it has a non-nil `invisible' property.\n\
4251 If the value is a list, a text character is invisible if its `invisible'\n\
4252 property is an element in that list.\n\
4253 If an element is a cons cell of the form (PROP . ELLIPSIS),\n\
4254 then characters with property value PROP are invisible,\n\
4255 and they have an ellipsis as well if ELLIPSIS is non-nil.");
4257 DEFVAR_PER_BUFFER ("buffer-display-count",
4258 ¤t_buffer
->display_count
, Qnil
,
4259 "A number incremented each time the buffer is displayed in a window.");
4261 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
4262 "*Non-nil means deactivate the mark when the buffer contents change.\n\
4263 Non-nil also enables highlighting of the region whenever the mark is active.\n\
4264 The variable `highlight-nonselected-windows' controls whether to highlight\n\
4265 all windows or just the selected window.");
4266 Vtransient_mark_mode
= Qnil
;
4268 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
4269 "*Non-nil means disregard read-only status of buffers or characters.\n\
4270 If the value is t, disregard `buffer-read-only' and all `read-only'\n\
4271 text properties. If the value is a list, disregard `buffer-read-only'\n\
4272 and disregard a `read-only' text property if the property value\n\
4273 is a member of the list.");
4274 Vinhibit_read_only
= Qnil
;
4276 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
4277 "List of functions called with no args to query before killing a buffer.");
4278 Vkill_buffer_query_functions
= Qnil
;
4280 defsubr (&Sbuffer_live_p
);
4281 defsubr (&Sbuffer_list
);
4282 defsubr (&Sget_buffer
);
4283 defsubr (&Sget_file_buffer
);
4284 defsubr (&Sget_buffer_create
);
4285 defsubr (&Smake_indirect_buffer
);
4286 defsubr (&Sgenerate_new_buffer_name
);
4287 defsubr (&Sbuffer_name
);
4288 /*defsubr (&Sbuffer_number);*/
4289 defsubr (&Sbuffer_file_name
);
4290 defsubr (&Sbuffer_base_buffer
);
4291 defsubr (&Sbuffer_local_variables
);
4292 defsubr (&Sbuffer_modified_p
);
4293 defsubr (&Sset_buffer_modified_p
);
4294 defsubr (&Sbuffer_modified_tick
);
4295 defsubr (&Srename_buffer
);
4296 defsubr (&Sother_buffer
);
4297 defsubr (&Sbuffer_disable_undo
);
4298 defsubr (&Sbuffer_enable_undo
);
4299 defsubr (&Skill_buffer
);
4300 defsubr (&Serase_buffer
);
4301 defsubr (&Sset_buffer_major_mode
);
4302 defsubr (&Sswitch_to_buffer
);
4303 defsubr (&Spop_to_buffer
);
4304 defsubr (&Scurrent_buffer
);
4305 defsubr (&Sset_buffer
);
4306 defsubr (&Sbarf_if_buffer_read_only
);
4307 defsubr (&Sbury_buffer
);
4308 defsubr (&Skill_all_local_variables
);
4310 defsubr (&Soverlayp
);
4311 defsubr (&Smake_overlay
);
4312 defsubr (&Sdelete_overlay
);
4313 defsubr (&Smove_overlay
);
4314 defsubr (&Soverlay_start
);
4315 defsubr (&Soverlay_end
);
4316 defsubr (&Soverlay_buffer
);
4317 defsubr (&Soverlay_properties
);
4318 defsubr (&Soverlays_at
);
4319 defsubr (&Soverlays_in
);
4320 defsubr (&Snext_overlay_change
);
4321 defsubr (&Sprevious_overlay_change
);
4322 defsubr (&Soverlay_recenter
);
4323 defsubr (&Soverlay_lists
);
4324 defsubr (&Soverlay_get
);
4325 defsubr (&Soverlay_put
);
4330 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
4331 initial_define_key (control_x_map
, 'k', "kill-buffer");
4333 /* This must not be in syms_of_buffer, because Qdisabled is not
4334 initialized when that function gets called. */
4335 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);