1 /* Buffer manipulation primitives for GNU Emacs.
2 Copyright (C) 1985,86,87,88,89,93,94,95,97,98, 1999, 2000
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include <sys/types.h>
26 #include <sys/param.h>
35 /* in 4.1, param.h fails to define this. */
36 #define MAXPATHLEN 1024
37 #endif /* not MAXPATHLEN */
43 #include "intervals.h"
48 #include "region-cache.h"
50 #include "blockinput.h"
54 struct buffer
*current_buffer
; /* the current buffer */
56 /* First buffer in chain of all buffers (in reverse order of creation).
57 Threaded through ->next. */
59 struct buffer
*all_buffers
;
61 /* This structure holds the default values of the buffer-local variables
62 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
63 The default value occupies the same slot in this structure
64 as an individual buffer's value occupies in that buffer.
65 Setting the default value also goes through the alist of buffers
66 and stores into each buffer that does not say it has a local value. */
68 struct buffer buffer_defaults
;
70 /* A Lisp_Object pointer to the above, used for staticpro */
72 static Lisp_Object Vbuffer_defaults
;
74 /* This structure marks which slots in a buffer have corresponding
75 default values in buffer_defaults.
76 Each such slot has a nonzero value in this structure.
77 The value has only one nonzero bit.
79 When a buffer has its own local value for a slot,
80 the entry for that slot (found in the same slot in this structure)
81 is turned on in the buffer's local_flags array.
83 If a slot in this structure is -1, 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 is -2, then there is no DEFVAR_PER_BUFFER for it,
88 but there is a default value which is copied into each buffer.
90 If a slot in this structure is negative, then even though there may
91 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
92 and the corresponding slot in buffer_defaults is not used.
94 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
95 zero, that is a bug */
97 struct buffer buffer_local_flags
;
99 /* This structure holds the names of symbols whose values may be
100 buffer-local. It is indexed and accessed in the same way as the above. */
102 struct buffer buffer_local_symbols
;
103 /* A Lisp_Object pointer to the above, used for staticpro */
104 static Lisp_Object Vbuffer_local_symbols
;
106 /* This structure holds the required types for the values in the
107 buffer-local slots. If a slot contains Qnil, then the
108 corresponding buffer slot may contain a value of any type. If a
109 slot contains an integer, then prospective values' tags must be
110 equal to that integer (except nil is always allowed).
111 When a tag does not match, the function
112 buffer_slot_type_mismatch will signal an error.
114 If a slot here contains -1, the corresponding variable is read-only. */
115 struct buffer buffer_local_types
;
117 /* Flags indicating which built-in buffer-local variables
118 are permanent locals. */
119 static char buffer_permanent_local_flags
[MAX_PER_BUFFER_VARS
];
121 /* Number of per-buffer variables used. */
123 int last_per_buffer_idx
;
125 Lisp_Object
Fset_buffer ();
126 void set_buffer_internal ();
127 void set_buffer_internal_1 ();
128 static void call_overlay_mod_hooks ();
129 static void swap_out_buffer_local_variables ();
130 static void reset_buffer_local_variables ();
132 /* Alist of all buffer names vs the buffers. */
133 /* This used to be a variable, but is no longer,
134 to prevent lossage due to user rplac'ing this alist or its elements. */
135 Lisp_Object Vbuffer_alist
;
137 /* Functions to call before and after each text change. */
138 Lisp_Object Vbefore_change_functions
;
139 Lisp_Object Vafter_change_functions
;
141 Lisp_Object Vtransient_mark_mode
;
143 /* t means ignore all read-only text properties.
144 A list means ignore such a property if its value is a member of the list.
145 Any non-nil value means ignore buffer-read-only. */
146 Lisp_Object Vinhibit_read_only
;
148 /* List of functions to call that can query about killing a buffer.
149 If any of these functions returns nil, we don't kill it. */
150 Lisp_Object Vkill_buffer_query_functions
;
152 /* List of functions to call before changing an unmodified buffer. */
153 Lisp_Object Vfirst_change_hook
;
155 Lisp_Object Qfirst_change_hook
;
156 Lisp_Object Qbefore_change_functions
;
157 Lisp_Object Qafter_change_functions
;
159 /* If nonzero, all modification hooks are suppressed. */
160 int inhibit_modification_hooks
;
162 Lisp_Object Qfundamental_mode
, Qmode_class
, Qpermanent_local
;
164 Lisp_Object Qprotected_field
;
166 Lisp_Object QSFundamental
; /* A string "Fundamental" */
168 Lisp_Object Qkill_buffer_hook
;
170 Lisp_Object Qget_file_buffer
;
172 Lisp_Object Qoverlayp
;
174 Lisp_Object Qpriority
, Qwindow
, Qevaporate
, Qbefore_string
, Qafter_string
;
176 Lisp_Object Qmodification_hooks
;
177 Lisp_Object Qinsert_in_front_hooks
;
178 Lisp_Object Qinsert_behind_hooks
;
180 static void alloc_buffer_text
P_ ((struct buffer
*, size_t));
181 static void free_buffer_text
P_ ((struct buffer
*b
));
184 /* For debugging; temporary. See set_buffer_internal. */
185 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
192 error ("No buffer named %s", XSTRING (spec
)->data
);
193 error ("Invalid buffer argument");
196 DEFUN ("buffer-live-p", Fbuffer_live_p
, Sbuffer_live_p
, 1, 1, 0,
197 "Return non-nil if OBJECT is a buffer which has not been killed.\n\
198 Value is nil if OBJECT is not a buffer or if it has been killed.")
202 return ((BUFFERP (object
) && ! NILP (XBUFFER (object
)->name
))
206 DEFUN ("buffer-list", Fbuffer_list
, Sbuffer_list
, 0, 1, 0,
207 "Return a list of all existing live buffers.\n\
208 If the optional arg FRAME is a frame, we return that frame's buffer list.")
212 Lisp_Object framelist
, general
;
213 general
= Fmapcar (Qcdr
, Vbuffer_alist
);
219 CHECK_FRAME (frame
, 1);
221 framelist
= Fcopy_sequence (XFRAME (frame
)->buffer_list
);
223 /* Remove from GENERAL any buffer that duplicates one in FRAMELIST. */
225 while (! NILP (tail
))
227 general
= Fdelq (XCAR (tail
), general
);
230 return nconc2 (framelist
, general
);
236 /* Like Fassoc, but use Fstring_equal to compare
237 (which ignores text properties),
238 and don't ever QUIT. */
241 assoc_ignore_text_properties (key
, list
)
242 register Lisp_Object key
;
245 register Lisp_Object tail
;
246 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
248 register Lisp_Object elt
, tem
;
250 tem
= Fstring_equal (Fcar (elt
), key
);
257 DEFUN ("get-buffer", Fget_buffer
, Sget_buffer
, 1, 1, 0,
258 "Return the buffer named NAME (a string).\n\
259 If there is no live buffer named NAME, return nil.\n\
260 NAME may also be a buffer; if so, the value is that buffer.")
262 register Lisp_Object name
;
266 CHECK_STRING (name
, 0);
268 return Fcdr (assoc_ignore_text_properties (name
, Vbuffer_alist
));
271 DEFUN ("get-file-buffer", Fget_file_buffer
, Sget_file_buffer
, 1, 1, 0,
272 "Return the buffer visiting file FILENAME (a string).\n\
273 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.\n\
274 If there is no such live buffer, return nil.\n\
275 See also `find-buffer-visiting'.")
277 register Lisp_Object filename
;
279 register Lisp_Object tail
, buf
, tem
;
282 CHECK_STRING (filename
, 0);
283 filename
= Fexpand_file_name (filename
, Qnil
);
285 /* If the file name has special constructs in it,
286 call the corresponding file handler. */
287 handler
= Ffind_file_name_handler (filename
, Qget_file_buffer
);
289 return call2 (handler
, Qget_file_buffer
, filename
);
291 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
293 buf
= Fcdr (XCAR (tail
));
294 if (!BUFFERP (buf
)) continue;
295 if (!STRINGP (XBUFFER (buf
)->filename
)) continue;
296 tem
= Fstring_equal (XBUFFER (buf
)->filename
, filename
);
304 get_truename_buffer (filename
)
305 register Lisp_Object filename
;
307 register Lisp_Object tail
, buf
, tem
;
309 for (tail
= Vbuffer_alist
; CONSP (tail
); tail
= XCDR (tail
))
311 buf
= Fcdr (XCAR (tail
));
312 if (!BUFFERP (buf
)) continue;
313 if (!STRINGP (XBUFFER (buf
)->file_truename
)) continue;
314 tem
= Fstring_equal (XBUFFER (buf
)->file_truename
, filename
);
321 /* Incremented for each buffer created, to assign the buffer number. */
324 DEFUN ("get-buffer-create", Fget_buffer_create
, Sget_buffer_create
, 1, 1, 0,
325 "Return the buffer named NAME, or create such a buffer and return it.\n\
326 A new buffer is created if there is no live buffer named NAME.\n\
327 If NAME starts with a space, the new buffer does not keep undo information.\n\
328 If NAME is a buffer instead of a string, then it is the value returned.\n\
329 The value is never nil.")
331 register Lisp_Object name
;
333 register Lisp_Object buf
;
334 register struct buffer
*b
;
336 buf
= Fget_buffer (name
);
340 if (XSTRING (name
)->size
== 0)
341 error ("Empty string for buffer name is not allowed");
343 b
= (struct buffer
*) allocate_buffer ();
345 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
347 /* An ordinary buffer uses its own struct buffer_text. */
348 b
->text
= &b
->own_text
;
351 BUF_GAP_SIZE (b
) = 20;
353 /* We allocate extra 1-byte at the tail and keep it always '\0' for
354 anchoring a search. */
355 alloc_buffer_text (b
, BUF_GAP_SIZE (b
) + 1);
357 if (! BUF_BEG_ADDR (b
))
358 buffer_memory_full ();
366 BUF_GPT_BYTE (b
) = 1;
367 BUF_BEGV_BYTE (b
) = 1;
371 BUF_OVERLAY_MODIFF (b
) = 1;
372 BUF_SAVE_MODIFF (b
) = 1;
373 BUF_INTERVALS (b
) = 0;
374 BUF_UNCHANGED_MODIFIED (b
) = 1;
375 BUF_OVERLAY_UNCHANGED_MODIFIED (b
) = 1;
376 BUF_END_UNCHANGED (b
) = 0;
377 BUF_BEG_UNCHANGED (b
) = 0;
378 *(BUF_GPT_ADDR (b
)) = *(BUF_Z_ADDR (b
)) = 0; /* Put an anchor '\0'. */
380 b
->newline_cache
= 0;
381 b
->width_run_cache
= 0;
382 b
->width_table
= Qnil
;
383 b
->prevent_redisplay_optimizations_p
= 1;
385 /* Put this on the chain of all buffers including killed ones. */
386 b
->next
= all_buffers
;
389 /* An ordinary buffer normally doesn't need markers
390 to handle BEGV and ZV. */
392 b
->begv_marker
= Qnil
;
395 name
= Fcopy_sequence (name
);
396 XSTRING (name
)->intervals
= NULL_INTERVAL
;
399 if (XSTRING (name
)->data
[0] != ' ')
405 reset_buffer_local_variables (b
, 1);
407 /* Put this in the alist of all live buffers. */
409 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
411 b
->mark
= Fmake_marker ();
412 BUF_MARKERS (b
) = Qnil
;
418 /* Clone per-buffer values of buffer FROM.
420 Buffer TO gets the same per-buffer values as FROM, with the
421 following exceptions: (1) TO's name is left untouched, (2) markers
422 are copied and made to refer to TO, and (3) overlay lists are
426 clone_per_buffer_values (from
, to
)
427 struct buffer
*from
, *to
;
429 Lisp_Object to_buffer
;
432 XSETBUFFER (to_buffer
, to
);
434 for (offset
= PER_BUFFER_VAR_OFFSET (name
) + sizeof (Lisp_Object
);
436 offset
+= sizeof (Lisp_Object
))
440 obj
= PER_BUFFER_VALUE (from
, offset
);
443 struct Lisp_Marker
*m
= XMARKER (obj
);
444 obj
= Fmake_marker ();
445 XMARKER (obj
)->insertion_type
= m
->insertion_type
;
446 set_marker_both (obj
, to_buffer
, m
->charpos
, m
->bytepos
);
449 PER_BUFFER_VALUE (to
, offset
) = obj
;
452 to
->overlays_after
= Fcopy_sequence (from
->overlays_after
);
453 to
->overlays_before
= Fcopy_sequence (to
->overlays_before
);
454 bcopy (from
->local_flags
, to
->local_flags
, sizeof to
->local_flags
);
458 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer
, Smake_indirect_buffer
,
460 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
461 "Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.\n\
462 BASE-BUFFER should be an existing buffer (or buffer name).\n\
463 NAME should be a string which is not the name of an existing buffer.\n\
464 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,\n\
465 such as major and minor modes, in the indirect buffer.\n\
466 CLONE nil means the indirect buffer's state is reset to default values.")
467 (base_buffer
, name
, clone
)
468 Lisp_Object base_buffer
, name
, clone
;
473 buf
= Fget_buffer (name
);
475 error ("Buffer name `%s' is in use", XSTRING (name
)->data
);
477 base_buffer
= Fget_buffer (base_buffer
);
478 if (NILP (base_buffer
))
479 error ("No such buffer: `%s'",
480 XSTRING (XBUFFER (base_buffer
)->name
)->data
);
482 if (XSTRING (name
)->size
== 0)
483 error ("Empty string for buffer name is not allowed");
485 b
= (struct buffer
*) allocate_buffer ();
486 b
->size
= sizeof (struct buffer
) / sizeof (EMACS_INT
);
488 if (XBUFFER (base_buffer
)->base_buffer
)
489 b
->base_buffer
= XBUFFER (base_buffer
)->base_buffer
;
491 b
->base_buffer
= XBUFFER (base_buffer
);
493 /* Use the base buffer's text object. */
494 b
->text
= b
->base_buffer
->text
;
496 BUF_BEGV (b
) = BUF_BEGV (b
->base_buffer
);
497 BUF_ZV (b
) = BUF_ZV (b
->base_buffer
);
498 BUF_PT (b
) = BUF_PT (b
->base_buffer
);
499 BUF_BEGV_BYTE (b
) = BUF_BEGV_BYTE (b
->base_buffer
);
500 BUF_ZV_BYTE (b
) = BUF_ZV_BYTE (b
->base_buffer
);
501 BUF_PT_BYTE (b
) = BUF_PT_BYTE (b
->base_buffer
);
503 b
->newline_cache
= 0;
504 b
->width_run_cache
= 0;
505 b
->width_table
= Qnil
;
507 /* Put this on the chain of all buffers including killed ones. */
508 b
->next
= all_buffers
;
511 name
= Fcopy_sequence (name
);
512 XSTRING (name
)->intervals
= NULL_INTERVAL
;
516 reset_buffer_local_variables (b
, 1);
518 /* Put this in the alist of all live buffers. */
520 Vbuffer_alist
= nconc2 (Vbuffer_alist
, Fcons (Fcons (name
, buf
), Qnil
));
522 b
->mark
= Fmake_marker ();
525 /* The multibyte status belongs to the base buffer. */
526 b
->enable_multibyte_characters
= b
->base_buffer
->enable_multibyte_characters
;
528 /* Make sure the base buffer has markers for its narrowing. */
529 if (NILP (b
->base_buffer
->pt_marker
))
531 b
->base_buffer
->pt_marker
= Fmake_marker ();
532 set_marker_both (b
->base_buffer
->pt_marker
, base_buffer
,
533 BUF_PT (b
->base_buffer
),
534 BUF_PT_BYTE (b
->base_buffer
));
536 if (NILP (b
->base_buffer
->begv_marker
))
538 b
->base_buffer
->begv_marker
= Fmake_marker ();
539 set_marker_both (b
->base_buffer
->begv_marker
, base_buffer
,
540 BUF_BEGV (b
->base_buffer
),
541 BUF_BEGV_BYTE (b
->base_buffer
));
543 if (NILP (b
->base_buffer
->zv_marker
))
545 b
->base_buffer
->zv_marker
= Fmake_marker ();
546 set_marker_both (b
->base_buffer
->zv_marker
, base_buffer
,
547 BUF_ZV (b
->base_buffer
),
548 BUF_ZV_BYTE (b
->base_buffer
));
549 XMARKER (b
->base_buffer
->zv_marker
)->insertion_type
= 1;
554 /* Give the indirect buffer markers for its narrowing. */
555 b
->pt_marker
= Fmake_marker ();
556 set_marker_both (b
->pt_marker
, buf
, BUF_PT (b
), BUF_PT_BYTE (b
));
557 b
->begv_marker
= Fmake_marker ();
558 set_marker_both (b
->begv_marker
, buf
, BUF_BEGV (b
), BUF_BEGV_BYTE (b
));
559 b
->zv_marker
= Fmake_marker ();
560 set_marker_both (b
->zv_marker
, buf
, BUF_ZV (b
), BUF_ZV_BYTE (b
));
561 XMARKER (b
->zv_marker
)->insertion_type
= 1;
564 clone_per_buffer_values (b
->base_buffer
, b
);
569 /* Reinitialize everything about a buffer except its name and contents
570 and local variables. */
574 register struct buffer
*b
;
577 b
->file_truename
= Qnil
;
578 b
->directory
= (current_buffer
) ? current_buffer
->directory
: Qnil
;
580 XSETFASTINT (b
->save_length
, 0);
581 b
->last_window_start
= 1;
582 /* It is more conservative to start out "changed" than "unchanged". */
584 b
->prevent_redisplay_optimizations_p
= 1;
586 b
->auto_save_modified
= 0;
587 b
->auto_save_failure_time
= -1;
588 b
->auto_save_file_name
= Qnil
;
590 b
->overlays_before
= Qnil
;
591 b
->overlays_after
= Qnil
;
592 XSETFASTINT (b
->overlay_center
, 1);
593 b
->mark_active
= Qnil
;
594 b
->point_before_scroll
= Qnil
;
595 b
->file_format
= Qnil
;
596 b
->last_selected_window
= Qnil
;
597 XSETINT (b
->display_count
, 0);
598 b
->display_time
= Qnil
;
599 b
->enable_multibyte_characters
= buffer_defaults
.enable_multibyte_characters
;
600 b
->cursor_type
= buffer_defaults
.cursor_type
;
601 b
->extra_line_spacing
= buffer_defaults
.extra_line_spacing
;
604 /* Reset buffer B's local variables info.
605 Don't use this on a buffer that has already been in use;
606 it does not treat permanent locals consistently.
607 Instead, use Fkill_all_local_variables.
609 If PERMANENT_TOO is 1, then we reset permanent built-in
610 buffer-local variables. If PERMANENT_TOO is 0,
611 we preserve those. */
614 reset_buffer_local_variables (b
, permanent_too
)
615 register struct buffer
*b
;
621 /* Reset the major mode to Fundamental, together with all the
622 things that depend on the major mode.
623 default-major-mode is handled at a higher level.
624 We ignore it here. */
625 b
->major_mode
= Qfundamental_mode
;
627 b
->abbrev_table
= Vfundamental_mode_abbrev_table
;
628 b
->mode_name
= QSFundamental
;
629 b
->minor_modes
= Qnil
;
631 /* If the standard case table has been altered and invalidated,
632 fix up its insides first. */
633 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[0])
634 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[1])
635 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table
)->extras
[2])))
636 Fset_standard_case_table (Vascii_downcase_table
);
638 b
->downcase_table
= Vascii_downcase_table
;
639 b
->upcase_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[0];
640 b
->case_canon_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[1];
641 b
->case_eqv_table
= XCHAR_TABLE (Vascii_downcase_table
)->extras
[2];
642 b
->invisibility_spec
= Qt
;
644 b
->buffer_file_type
= Qnil
;
648 b
->sort_table
= XSTRING (Vascii_sort_table
);
649 b
->folding_sort_table
= XSTRING (Vascii_folding_sort_table
);
652 /* Reset all (or most) per-buffer variables to their defaults. */
653 b
->local_var_alist
= Qnil
;
654 for (i
= 0; i
< last_per_buffer_idx
; ++i
)
655 if (permanent_too
|| buffer_permanent_local_flags
[i
] == 0)
656 SET_PER_BUFFER_VALUE_P (b
, i
, 0);
658 /* For each slot that has a default value,
659 copy that into the slot. */
661 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
663 offset
+= sizeof (Lisp_Object
))
665 int idx
= PER_BUFFER_IDX (offset
);
668 || buffer_permanent_local_flags
[idx
] == 0))
669 /* Is -2 used anywhere? */
671 PER_BUFFER_VALUE (b
, offset
) = PER_BUFFER_DEFAULT (offset
);
675 /* We split this away from generate-new-buffer, because rename-buffer
676 and set-visited-file-name ought to be able to use this to really
677 rename the buffer properly. */
679 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name
, Sgenerate_new_buffer_name
,
681 "Return a string that is the name of no existing buffer based on NAME.\n\
682 If there is no live buffer named NAME, then return NAME.\n\
683 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER\n\
684 until an unused name is found, and then return that name.\n\
685 Optional second argument IGNORE specifies a name that is okay to use\n\
686 \(if it is in the sequence to be tried)\n\
687 even if a buffer with that name exists.")
689 register Lisp_Object name
, ignore
;
691 register Lisp_Object gentemp
, tem
;
695 CHECK_STRING (name
, 0);
697 tem
= Fget_buffer (name
);
704 sprintf (number
, "<%d>", ++count
);
705 gentemp
= concat2 (name
, build_string (number
));
706 tem
= Fstring_equal (gentemp
, ignore
);
709 tem
= Fget_buffer (gentemp
);
716 DEFUN ("buffer-name", Fbuffer_name
, Sbuffer_name
, 0, 1, 0,
717 "Return the name of BUFFER, as a string.\n\
718 With no argument or nil as argument, return the name of the current buffer.")
720 register Lisp_Object buffer
;
723 return current_buffer
->name
;
724 CHECK_BUFFER (buffer
, 0);
725 return XBUFFER (buffer
)->name
;
728 DEFUN ("buffer-file-name", Fbuffer_file_name
, Sbuffer_file_name
, 0, 1, 0,
729 "Return name of file BUFFER is visiting, or nil if none.\n\
730 No argument or nil as argument means use the current buffer.")
732 register Lisp_Object buffer
;
735 return current_buffer
->filename
;
736 CHECK_BUFFER (buffer
, 0);
737 return XBUFFER (buffer
)->filename
;
740 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer
, Sbuffer_base_buffer
,
742 "Return the base buffer of indirect buffer BUFFER.\n\
743 If BUFFER is not indirect, return nil.")
745 register Lisp_Object buffer
;
748 Lisp_Object base_buffer
;
751 base
= current_buffer
->base_buffer
;
754 CHECK_BUFFER (buffer
, 0);
755 base
= XBUFFER (buffer
)->base_buffer
;
760 XSETBUFFER (base_buffer
, base
);
764 DEFUN ("buffer-local-variables", Fbuffer_local_variables
,
765 Sbuffer_local_variables
, 0, 1, 0,
766 "Return an alist of variables that are buffer-local in BUFFER.\n\
767 Most elements look like (SYMBOL . VALUE), describing one variable.\n\
768 For a symbol that is locally unbound, just the symbol appears in the value.\n\
769 Note that storing new VALUEs in these elements doesn't change the variables.\n\
770 No argument or nil as argument means use current buffer as BUFFER.")
772 register Lisp_Object buffer
;
774 register struct buffer
*buf
;
775 register Lisp_Object result
;
778 buf
= current_buffer
;
781 CHECK_BUFFER (buffer
, 0);
782 buf
= XBUFFER (buffer
);
788 register Lisp_Object tail
;
789 for (tail
= buf
->local_var_alist
; CONSP (tail
); tail
= XCDR (tail
))
791 Lisp_Object val
, elt
;
795 /* Reference each variable in the alist in buf.
796 If inquiring about the current buffer, this gets the current values,
797 so store them into the alist so the alist is up to date.
798 If inquiring about some other buffer, this swaps out any values
799 for that buffer, making the alist up to date automatically. */
800 val
= find_symbol_value (XCAR (elt
));
801 /* Use the current buffer value only if buf is the current buffer. */
802 if (buf
!= current_buffer
)
805 /* If symbol is unbound, put just the symbol in the list. */
806 if (EQ (val
, Qunbound
))
807 result
= Fcons (XCAR (elt
), result
);
808 /* Otherwise, put (symbol . value) in the list. */
810 result
= Fcons (Fcons (XCAR (elt
), val
), result
);
814 /* Add on all the variables stored in special slots. */
818 for (offset
= PER_BUFFER_VAR_OFFSET (name
);
819 offset
< sizeof (struct buffer
);
820 /* sizeof EMACS_INT == sizeof Lisp_Object */
821 offset
+= (sizeof (EMACS_INT
)))
823 idx
= PER_BUFFER_IDX (offset
);
824 if ((idx
== -1 || PER_BUFFER_VALUE_P (buf
, idx
))
825 && SYMBOLP (PER_BUFFER_SYMBOL (offset
)))
826 result
= Fcons (Fcons (PER_BUFFER_SYMBOL (offset
),
827 PER_BUFFER_VALUE (buf
, offset
)),
836 DEFUN ("buffer-modified-p", Fbuffer_modified_p
, Sbuffer_modified_p
,
838 "Return t if BUFFER was modified since its file was last read or saved.\n\
839 No argument or nil as argument means use current buffer as BUFFER.")
841 register Lisp_Object buffer
;
843 register struct buffer
*buf
;
845 buf
= current_buffer
;
848 CHECK_BUFFER (buffer
, 0);
849 buf
= XBUFFER (buffer
);
852 return BUF_SAVE_MODIFF (buf
) < BUF_MODIFF (buf
) ? Qt
: Qnil
;
855 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p
, Sset_buffer_modified_p
,
857 "Mark current buffer as modified or unmodified according to FLAG.\n\
858 A non-nil FLAG means mark the buffer modified.")
860 register Lisp_Object flag
;
862 register int already
;
863 register Lisp_Object fn
;
864 Lisp_Object buffer
, window
;
866 #ifdef CLASH_DETECTION
867 /* If buffer becoming modified, lock the file.
868 If buffer becoming unmodified, unlock the file. */
870 fn
= current_buffer
->file_truename
;
871 /* Test buffer-file-name so that binding it to nil is effective. */
872 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
874 already
= SAVE_MODIFF
< MODIFF
;
875 if (!already
&& !NILP (flag
))
877 else if (already
&& NILP (flag
))
880 #endif /* CLASH_DETECTION */
882 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
884 /* Set update_mode_lines only if buffer is displayed in some window.
885 Packages like jit-lock or lazy-lock preserve a buffer's modified
886 state by recording/restoring the state around blocks of code.
887 Setting update_mode_lines makes redisplay consider all windows
888 (on all frames). Stealth fontification of buffers not displayed
889 would incur additional redisplay costs if we'd set
890 update_modes_lines unconditionally.
892 Ideally, I think there should be another mechanism for fontifying
893 buffers without "modifying" buffers, or redisplay should be
894 smarter about updating the `*' in mode lines. --gerd */
895 XSETBUFFER (buffer
, current_buffer
);
896 window
= Fget_buffer_window (buffer
, Qt
);
897 if (WINDOWP (window
))
903 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p
,
904 Srestore_buffer_modified_p
, 1, 1, 0,
905 "Like `set-buffer-modified-p', with a differences concerning redisplay.\n\
906 It is not ensured that mode lines will be updated to show the modified\n\
907 state of the current buffer. Use with care.")
911 #ifdef CLASH_DETECTION
914 /* If buffer becoming modified, lock the file.
915 If buffer becoming unmodified, unlock the file. */
917 fn
= current_buffer
->file_truename
;
918 /* Test buffer-file-name so that binding it to nil is effective. */
919 if (!NILP (fn
) && ! NILP (current_buffer
->filename
))
921 int already
= SAVE_MODIFF
< MODIFF
;
922 if (!already
&& !NILP (flag
))
924 else if (already
&& NILP (flag
))
927 #endif /* CLASH_DETECTION */
929 SAVE_MODIFF
= NILP (flag
) ? MODIFF
: 0;
933 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick
, Sbuffer_modified_tick
,
935 "Return BUFFER's tick counter, incremented for each change in text.\n\
936 Each buffer has a tick counter which is incremented each time the text in\n\
937 that buffer is changed. It wraps around occasionally.\n\
938 No argument or nil as argument means use current buffer as BUFFER.")
940 register Lisp_Object buffer
;
942 register struct buffer
*buf
;
944 buf
= current_buffer
;
947 CHECK_BUFFER (buffer
, 0);
948 buf
= XBUFFER (buffer
);
951 return make_number (BUF_MODIFF (buf
));
954 DEFUN ("rename-buffer", Frename_buffer
, Srename_buffer
, 1, 2,
955 "sRename buffer (to new name): \nP",
956 "Change current buffer's name to NEWNAME (a string).\n\
957 If second arg UNIQUE is nil or omitted, it is an error if a\n\
958 buffer named NEWNAME already exists.\n\
959 If UNIQUE is non-nil, come up with a new name using\n\
960 `generate-new-buffer-name'.\n\
961 Interactively, you can set UNIQUE with a prefix argument.\n\
962 We return the name we actually gave the buffer.\n\
963 This does not change the name of the visited file (if any).")
965 register Lisp_Object newname
, unique
;
967 register Lisp_Object tem
, buf
;
969 CHECK_STRING (newname
, 0);
971 if (XSTRING (newname
)->size
== 0)
972 error ("Empty string is invalid as a buffer name");
974 tem
= Fget_buffer (newname
);
977 /* Don't short-circuit if UNIQUE is t. That is a useful way to
978 rename the buffer automatically so you can create another
979 with the original name. It makes UNIQUE equivalent to
980 (rename-buffer (generate-new-buffer-name NEWNAME)). */
981 if (NILP (unique
) && XBUFFER (tem
) == current_buffer
)
982 return current_buffer
->name
;
984 newname
= Fgenerate_new_buffer_name (newname
, current_buffer
->name
);
986 error ("Buffer name `%s' is in use", XSTRING (newname
)->data
);
989 current_buffer
->name
= newname
;
991 /* Catch redisplay's attention. Unless we do this, the mode lines for
992 any windows displaying current_buffer will stay unchanged. */
995 XSETBUFFER (buf
, current_buffer
);
996 Fsetcar (Frassq (buf
, Vbuffer_alist
), newname
);
997 if (NILP (current_buffer
->filename
)
998 && !NILP (current_buffer
->auto_save_file_name
))
999 call0 (intern ("rename-auto-save-file"));
1000 /* Refetch since that last call may have done GC. */
1001 return current_buffer
->name
;
1004 DEFUN ("other-buffer", Fother_buffer
, Sother_buffer
, 0, 3, 0,
1005 "Return most recently selected buffer other than BUFFER.\n\
1006 Buffers not visible in windows are preferred to visible buffers,\n\
1007 unless optional second argument VISIBLE-OK is non-nil.\n\
1008 If the optional third argument FRAME is non-nil, use that frame's\n\
1009 buffer list instead of the selected frame's buffer list.\n\
1010 If no other buffer exists, the buffer `*scratch*' is returned.\n\
1011 If BUFFER is omitted or nil, some interesting buffer is returned.")
1012 (buffer
, visible_ok
, frame
)
1013 register Lisp_Object buffer
, visible_ok
, frame
;
1015 Lisp_Object
Fset_buffer_major_mode ();
1016 register Lisp_Object tail
, buf
, notsogood
, tem
, pred
, add_ons
;
1020 frame
= selected_frame
;
1022 tail
= Vbuffer_alist
;
1023 pred
= frame_buffer_predicate (frame
);
1025 /* Consider buffers that have been seen in the selected frame
1026 before other buffers. */
1028 tem
= frame_buffer_list (frame
);
1032 if (BUFFERP (XCAR (tem
)))
1033 add_ons
= Fcons (Fcons (Qnil
, XCAR (tem
)), add_ons
);
1036 tail
= nconc2 (Fnreverse (add_ons
), tail
);
1038 for (; !NILP (tail
); tail
= Fcdr (tail
))
1040 buf
= Fcdr (Fcar (tail
));
1041 if (EQ (buf
, buffer
))
1043 if (XSTRING (XBUFFER (buf
)->name
)->data
[0] == ' ')
1045 /* If the selected frame has a buffer_predicate,
1046 disregard buffers that don't fit the predicate. */
1049 tem
= call1 (pred
, buf
);
1054 if (NILP (visible_ok
))
1055 tem
= Fget_buffer_window (buf
, Qvisible
);
1060 if (NILP (notsogood
))
1063 if (!NILP (notsogood
))
1065 buf
= Fget_buffer (build_string ("*scratch*"));
1068 buf
= Fget_buffer_create (build_string ("*scratch*"));
1069 Fset_buffer_major_mode (buf
);
1074 DEFUN ("buffer-disable-undo", Fbuffer_disable_undo
, Sbuffer_disable_undo
,
1076 "Make BUFFER stop keeping undo information.\n\
1077 No argument or nil as argument means do this for the current buffer.")
1079 register Lisp_Object buffer
;
1081 Lisp_Object real_buffer
;
1084 XSETBUFFER (real_buffer
, current_buffer
);
1087 real_buffer
= Fget_buffer (buffer
);
1088 if (NILP (real_buffer
))
1092 XBUFFER (real_buffer
)->undo_list
= Qt
;
1097 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo
, Sbuffer_enable_undo
,
1099 "Start keeping undo information for buffer BUFFER.\n\
1100 No argument or nil as argument means do this for the current buffer.")
1102 register Lisp_Object buffer
;
1104 Lisp_Object real_buffer
;
1107 XSETBUFFER (real_buffer
, current_buffer
);
1110 real_buffer
= Fget_buffer (buffer
);
1111 if (NILP (real_buffer
))
1115 if (EQ (XBUFFER (real_buffer
)->undo_list
, Qt
))
1116 XBUFFER (real_buffer
)->undo_list
= Qnil
;
1122 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
1123 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
1124 The buffer being killed will be current while the hook is running.\n\
1127 DEFUN ("kill-buffer", Fkill_buffer
, Skill_buffer
, 1, 1, "bKill buffer: ",
1128 "Kill the buffer BUFFER.\n\
1129 The argument may be a buffer or may be the name of a buffer.\n\
1130 An argument of nil means kill the current buffer.\n\n\
1131 Value is t if the buffer is actually killed, nil if user says no.\n\n\
1132 The value of `kill-buffer-hook' (which may be local to that buffer),\n\
1133 if not void, is a list of functions to be called, with no arguments,\n\
1134 before the buffer is actually killed. The buffer to be killed is current\n\
1135 when the hook functions are called.\n\n\
1136 Any processes that have this buffer as the `process-buffer' are killed\n\
1142 register struct buffer
*b
;
1143 register Lisp_Object tem
;
1144 register struct Lisp_Marker
*m
;
1145 struct gcpro gcpro1
;
1148 buf
= Fcurrent_buffer ();
1150 buf
= Fget_buffer (buffer
);
1156 /* Avoid trouble for buffer already dead. */
1160 /* Query if the buffer is still modified. */
1161 if (INTERACTIVE
&& !NILP (b
->filename
)
1162 && BUF_MODIFF (b
) > BUF_SAVE_MODIFF (b
))
1165 tem
= do_yes_or_no_p (format1 ("Buffer %s modified; kill anyway? ",
1166 XSTRING (b
->name
)->data
));
1172 /* Run hooks with the buffer to be killed the current buffer. */
1174 int count
= specpdl_ptr
- specpdl
;
1177 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1178 set_buffer_internal (b
);
1180 /* First run the query functions; if any query is answered no,
1181 don't kill the buffer. */
1182 for (list
= Vkill_buffer_query_functions
; !NILP (list
); list
= Fcdr (list
))
1184 tem
= call0 (Fcar (list
));
1186 return unbind_to (count
, Qnil
);
1189 /* Then run the hooks. */
1190 if (!NILP (Vrun_hooks
))
1191 call1 (Vrun_hooks
, Qkill_buffer_hook
);
1192 unbind_to (count
, Qnil
);
1195 /* We have no more questions to ask. Verify that it is valid
1196 to kill the buffer. This must be done after the questions
1197 since anything can happen within do_yes_or_no_p. */
1199 /* Don't kill the minibuffer now current. */
1200 if (EQ (buf
, XWINDOW (minibuf_window
)->buffer
))
1206 /* When we kill a base buffer, kill all its indirect buffers.
1207 We do it at this stage so nothing terrible happens if they
1208 ask questions or their hooks get errors. */
1209 if (! b
->base_buffer
)
1211 struct buffer
*other
;
1215 for (other
= all_buffers
; other
; other
= other
->next
)
1216 /* all_buffers contains dead buffers too;
1217 don't re-kill them. */
1218 if (other
->base_buffer
== b
&& !NILP (other
->name
))
1221 XSETBUFFER (buf
, other
);
1228 /* Make this buffer not be current.
1229 In the process, notice if this is the sole visible buffer
1230 and give up if so. */
1231 if (b
== current_buffer
)
1233 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1235 if (b
== current_buffer
)
1239 /* Notice if the buffer to kill is the sole visible buffer
1240 when we're currently in the mini-buffer, and give up if so. */
1241 XSETBUFFER (tem
, current_buffer
);
1242 if (EQ (tem
, XWINDOW (minibuf_window
)->buffer
))
1244 tem
= Fother_buffer (buf
, Qnil
, Qnil
);
1250 /* Now there is no question: we can kill the buffer. */
1252 #ifdef CLASH_DETECTION
1253 /* Unlock this buffer's file, if it is locked. */
1255 #endif /* CLASH_DETECTION */
1257 kill_buffer_processes (buf
);
1259 tem
= Vinhibit_quit
;
1261 replace_buffer_in_all_windows (buf
);
1262 Vbuffer_alist
= Fdelq (Frassq (buf
, Vbuffer_alist
), Vbuffer_alist
);
1263 frames_discard_buffer (buf
);
1264 Vinhibit_quit
= tem
;
1266 /* Delete any auto-save file, if we saved it in this session. */
1267 if (STRINGP (b
->auto_save_file_name
)
1268 && b
->auto_save_modified
!= 0
1269 && BUF_SAVE_MODIFF (b
) < b
->auto_save_modified
)
1272 tem
= Fsymbol_value (intern ("delete-auto-save-files"));
1274 internal_delete_file (b
->auto_save_file_name
);
1279 /* Unchain all markers that belong to this indirect buffer.
1280 Don't unchain the markers that belong to the base buffer
1281 or its other indirect buffers. */
1282 for (tem
= BUF_MARKERS (b
); !NILP (tem
); )
1288 unchain_marker (tem
);
1294 /* Unchain all markers of this buffer and its indirect buffers.
1295 and leave them pointing nowhere. */
1296 for (tem
= BUF_MARKERS (b
); !NILP (tem
); )
1303 BUF_MARKERS (b
) = Qnil
;
1304 BUF_INTERVALS (b
) = NULL_INTERVAL
;
1306 /* Perhaps we should explicitly free the interval tree here... */
1309 /* Reset the local variables, so that this buffer's local values
1310 won't be protected from GC. They would be protected
1311 if they happened to remain encached in their symbols.
1312 This gets rid of them for certain. */
1313 swap_out_buffer_local_variables (b
);
1314 reset_buffer_local_variables (b
, 1);
1319 if (! b
->base_buffer
)
1320 free_buffer_text (b
);
1322 if (b
->newline_cache
)
1324 free_region_cache (b
->newline_cache
);
1325 b
->newline_cache
= 0;
1327 if (b
->width_run_cache
)
1329 free_region_cache (b
->width_run_cache
);
1330 b
->width_run_cache
= 0;
1332 b
->width_table
= Qnil
;
1334 b
->undo_list
= Qnil
;
1339 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
1340 we do this each time BUF is selected visibly, the more recently
1341 selected buffers are always closer to the front of the list. This
1342 means that other_buffer is more likely to choose a relevant buffer. */
1348 register Lisp_Object link
, prev
;
1350 frame
= selected_frame
;
1353 for (link
= Vbuffer_alist
; CONSP (link
); link
= XCDR (link
))
1355 if (EQ (XCDR (XCAR (link
)), buf
))
1360 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
1361 we cannot use Fdelq itself here because it allows quitting. */
1364 Vbuffer_alist
= XCDR (Vbuffer_alist
);
1366 XCDR (prev
) = XCDR (XCDR (prev
));
1368 XCDR (link
) = Vbuffer_alist
;
1369 Vbuffer_alist
= link
;
1371 /* Now move this buffer to the front of frame_buffer_list also. */
1374 for (link
= frame_buffer_list (frame
); CONSP (link
);
1377 if (EQ (XCAR (link
), buf
))
1382 /* Effectively do delq. */
1387 set_frame_buffer_list (frame
,
1388 XCDR (frame_buffer_list (frame
)));
1390 XCDR (prev
) = XCDR (XCDR (prev
));
1392 XCDR (link
) = frame_buffer_list (frame
);
1393 set_frame_buffer_list (frame
, link
);
1396 set_frame_buffer_list (frame
, Fcons (buf
, frame_buffer_list (frame
)));
1399 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode
, Sset_buffer_major_mode
, 1, 1, 0,
1400 "Set an appropriate major mode for BUFFER, according to `default-major-mode'.\n\
1401 Use this function before selecting the buffer, since it may need to inspect\n\
1402 the current buffer's major mode.")
1407 Lisp_Object function
;
1409 function
= buffer_defaults
.major_mode
;
1410 if (NILP (function
) && NILP (Fget (current_buffer
->major_mode
, Qmode_class
)))
1411 function
= current_buffer
->major_mode
;
1413 if (NILP (function
) || EQ (function
, Qfundamental_mode
))
1416 count
= specpdl_ptr
- specpdl
;
1418 /* To select a nonfundamental mode,
1419 select the buffer temporarily and then call the mode function. */
1421 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1423 Fset_buffer (buffer
);
1426 return unbind_to (count
, Qnil
);
1429 /* If switching buffers in WINDOW would be an error, return
1430 a C string saying what the error would be. */
1433 no_switch_window (window
)
1437 if (EQ (minibuf_window
, window
))
1438 return "Cannot switch buffers in minibuffer window";
1439 tem
= Fwindow_dedicated_p (window
);
1441 return "Cannot switch buffers in a dedicated window";
1445 /* Switch to buffer BUFFER in the selected window.
1446 If NORECORD is non-nil, don't call record_buffer. */
1449 switch_to_buffer_1 (buffer
, norecord
)
1450 Lisp_Object buffer
, norecord
;
1452 register Lisp_Object buf
;
1455 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1458 buf
= Fget_buffer (buffer
);
1461 buf
= Fget_buffer_create (buffer
);
1462 Fset_buffer_major_mode (buf
);
1466 if (NILP (norecord
))
1467 record_buffer (buf
);
1469 Fset_window_buffer (EQ (selected_window
, minibuf_window
)
1470 ? Fnext_window (minibuf_window
, Qnil
, Qnil
)
1477 DEFUN ("switch-to-buffer", Fswitch_to_buffer
, Sswitch_to_buffer
, 1, 2, "BSwitch to buffer: ",
1478 "Select buffer BUFFER in the current window.\n\
1479 BUFFER may be a buffer or a buffer name.\n\
1480 Optional second arg NORECORD non-nil means\n\
1481 do not put this buffer at the front of the list of recently selected ones.\n\
1483 WARNING: This is NOT the way to work on another buffer temporarily\n\
1484 within a Lisp program! Use `set-buffer' instead. That avoids messing with\n\
1485 the window-buffer correspondences.")
1487 Lisp_Object buffer
, norecord
;
1491 err
= no_switch_window (selected_window
);
1492 if (err
) error (err
);
1494 return switch_to_buffer_1 (buffer
, norecord
);
1497 DEFUN ("pop-to-buffer", Fpop_to_buffer
, Spop_to_buffer
, 1, 3, 0,
1498 "Select buffer BUFFER in some window, preferably a different one.\n\
1499 If BUFFER is nil, then some other buffer is chosen.\n\
1500 If `pop-up-windows' is non-nil, windows can be split to do this.\n\
1501 If optional second arg OTHER-WINDOW is non-nil, insist on finding another\n\
1502 window even if BUFFER is already visible in the selected window.\n\
1503 This uses the function `display-buffer' as a subroutine; see the documentation\n\
1504 of `display-buffer' for additional customization information.\n\
1506 Optional third arg NORECORD non-nil means\n\
1507 do not put this buffer at the front of the list of recently selected ones.")
1508 (buffer
, other_window
, norecord
)
1509 Lisp_Object buffer
, other_window
, norecord
;
1511 register Lisp_Object buf
;
1513 buf
= Fother_buffer (Fcurrent_buffer (), Qnil
, Qnil
);
1516 buf
= Fget_buffer (buffer
);
1519 buf
= Fget_buffer_create (buffer
);
1520 Fset_buffer_major_mode (buf
);
1524 if (NILP (norecord
))
1525 record_buffer (buf
);
1526 Fselect_window (Fdisplay_buffer (buf
, other_window
, Qnil
));
1530 DEFUN ("current-buffer", Fcurrent_buffer
, Scurrent_buffer
, 0, 0, 0,
1531 "Return the current buffer as a Lisp object.")
1534 register Lisp_Object buf
;
1535 XSETBUFFER (buf
, current_buffer
);
1539 /* Set the current buffer to B.
1541 We previously set windows_or_buffers_changed here to invalidate
1542 global unchanged information in beg_unchanged and end_unchanged.
1543 This is no longer necessary because we now compute unchanged
1544 information on a buffer-basis. Every action affecting other
1545 windows than the selected one requires a select_window at some
1546 time, and that increments windows_or_buffers_changed. */
1549 set_buffer_internal (b
)
1550 register struct buffer
*b
;
1552 if (current_buffer
!= b
)
1553 set_buffer_internal_1 (b
);
1556 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1557 This is used by redisplay. */
1560 set_buffer_internal_1 (b
)
1561 register struct buffer
*b
;
1563 register struct buffer
*old_buf
;
1564 register Lisp_Object tail
, valcontents
;
1567 #ifdef USE_MMAP_FOR_BUFFERS
1568 if (b
->text
->beg
== NULL
)
1569 enlarge_buffer_text (b
, 0);
1570 #endif /* USE_MMAP_FOR_BUFFERS */
1572 if (current_buffer
== b
)
1575 old_buf
= current_buffer
;
1577 last_known_column_point
= -1; /* invalidate indentation cache */
1581 /* Put the undo list back in the base buffer, so that it appears
1582 that an indirect buffer shares the undo list of its base. */
1583 if (old_buf
->base_buffer
)
1584 old_buf
->base_buffer
->undo_list
= old_buf
->undo_list
;
1586 /* If the old current buffer has markers to record PT, BEGV and ZV
1587 when it is not current, update them now. */
1588 if (! NILP (old_buf
->pt_marker
))
1591 XSETBUFFER (obuf
, old_buf
);
1592 set_marker_both (old_buf
->pt_marker
, obuf
,
1593 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1595 if (! NILP (old_buf
->begv_marker
))
1598 XSETBUFFER (obuf
, old_buf
);
1599 set_marker_both (old_buf
->begv_marker
, obuf
,
1600 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1602 if (! NILP (old_buf
->zv_marker
))
1605 XSETBUFFER (obuf
, old_buf
);
1606 set_marker_both (old_buf
->zv_marker
, obuf
,
1607 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1611 /* Get the undo list from the base buffer, so that it appears
1612 that an indirect buffer shares the undo list of its base. */
1614 b
->undo_list
= b
->base_buffer
->undo_list
;
1616 /* If the new current buffer has markers to record PT, BEGV and ZV
1617 when it is not current, fetch them now. */
1618 if (! NILP (b
->pt_marker
))
1620 BUF_PT (b
) = marker_position (b
->pt_marker
);
1621 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1623 if (! NILP (b
->begv_marker
))
1625 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1626 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1628 if (! NILP (b
->zv_marker
))
1630 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1631 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1634 /* Look down buffer's list of local Lisp variables
1635 to find and update any that forward into C variables. */
1637 for (tail
= b
->local_var_alist
; !NILP (tail
); tail
= XCDR (tail
))
1639 valcontents
= XSYMBOL (XCAR (XCAR (tail
)))->value
;
1640 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1641 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1642 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1643 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1644 /* Just reference the variable
1645 to cause it to become set for this buffer. */
1646 Fsymbol_value (XCAR (XCAR (tail
)));
1649 /* Do the same with any others that were local to the previous buffer */
1652 for (tail
= old_buf
->local_var_alist
; !NILP (tail
); tail
= XCDR (tail
))
1654 valcontents
= XSYMBOL (XCAR (XCAR (tail
)))->value
;
1655 if ((BUFFER_LOCAL_VALUEP (valcontents
)
1656 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
1657 && (tem
= XBUFFER_LOCAL_VALUE (valcontents
)->realvalue
,
1658 (BOOLFWDP (tem
) || INTFWDP (tem
) || OBJFWDP (tem
))))
1659 /* Just reference the variable
1660 to cause it to become set for this buffer. */
1661 Fsymbol_value (XCAR (XCAR (tail
)));
1665 /* Switch to buffer B temporarily for redisplay purposes.
1666 This avoids certain things that don't need to be done within redisplay. */
1672 register struct buffer
*old_buf
;
1674 if (current_buffer
== b
)
1677 old_buf
= current_buffer
;
1682 /* If the old current buffer has markers to record PT, BEGV and ZV
1683 when it is not current, update them now. */
1684 if (! NILP (old_buf
->pt_marker
))
1687 XSETBUFFER (obuf
, old_buf
);
1688 set_marker_both (old_buf
->pt_marker
, obuf
,
1689 BUF_PT (old_buf
), BUF_PT_BYTE (old_buf
));
1691 if (! NILP (old_buf
->begv_marker
))
1694 XSETBUFFER (obuf
, old_buf
);
1695 set_marker_both (old_buf
->begv_marker
, obuf
,
1696 BUF_BEGV (old_buf
), BUF_BEGV_BYTE (old_buf
));
1698 if (! NILP (old_buf
->zv_marker
))
1701 XSETBUFFER (obuf
, old_buf
);
1702 set_marker_both (old_buf
->zv_marker
, obuf
,
1703 BUF_ZV (old_buf
), BUF_ZV_BYTE (old_buf
));
1707 /* If the new current buffer has markers to record PT, BEGV and ZV
1708 when it is not current, fetch them now. */
1709 if (! NILP (b
->pt_marker
))
1711 BUF_PT (b
) = marker_position (b
->pt_marker
);
1712 BUF_PT_BYTE (b
) = marker_byte_position (b
->pt_marker
);
1714 if (! NILP (b
->begv_marker
))
1716 BUF_BEGV (b
) = marker_position (b
->begv_marker
);
1717 BUF_BEGV_BYTE (b
) = marker_byte_position (b
->begv_marker
);
1719 if (! NILP (b
->zv_marker
))
1721 BUF_ZV (b
) = marker_position (b
->zv_marker
);
1722 BUF_ZV_BYTE (b
) = marker_byte_position (b
->zv_marker
);
1726 DEFUN ("set-buffer", Fset_buffer
, Sset_buffer
, 1, 1, 0,
1727 "Make the buffer BUFFER current for editing operations.\n\
1728 BUFFER may be a buffer or the name of an existing buffer.\n\
1729 See also `save-excursion' when you want to make a buffer current temporarily.\n\
1730 This function does not display the buffer, so its effect ends\n\
1731 when the current command terminates.\n\
1732 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.")
1734 register Lisp_Object buffer
;
1736 register Lisp_Object buf
;
1737 buf
= Fget_buffer (buffer
);
1740 if (NILP (XBUFFER (buf
)->name
))
1741 error ("Selecting deleted buffer");
1742 set_buffer_internal (XBUFFER (buf
));
1746 /* Set the current buffer to BUFFER provided it is alive. */
1749 set_buffer_if_live (buffer
)
1752 if (! NILP (XBUFFER (buffer
)->name
))
1753 Fset_buffer (buffer
);
1757 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only
,
1758 Sbarf_if_buffer_read_only
, 0, 0, 0,
1759 "Signal a `buffer-read-only' error if the current buffer is read-only.")
1762 if (!NILP (current_buffer
->read_only
)
1763 && NILP (Vinhibit_read_only
))
1764 Fsignal (Qbuffer_read_only
, (Fcons (Fcurrent_buffer (), Qnil
)));
1768 DEFUN ("bury-buffer", Fbury_buffer
, Sbury_buffer
, 0, 1, "",
1769 "Put BUFFER at the end of the list of all buffers.\n\
1770 There it is the least likely candidate for `other-buffer' to return;\n\
1771 thus, the least likely buffer for \\[switch-to-buffer] to select by default.\n\
1772 If BUFFER is nil or omitted, bury the current buffer.\n\
1773 Also, if BUFFER is nil or omitted, remove the current buffer from the\n\
1774 selected window if it is displayed there.")
1776 register Lisp_Object buffer
;
1778 /* Figure out what buffer we're going to bury. */
1781 XSETBUFFER (buffer
, current_buffer
);
1783 /* If we're burying the current buffer, unshow it. */
1784 Fswitch_to_buffer (Fother_buffer (buffer
, Qnil
, Qnil
), Qnil
);
1790 buf1
= Fget_buffer (buffer
);
1796 /* Move buffer to the end of the buffer list. Do nothing if the
1797 buffer is killed. */
1798 if (!NILP (XBUFFER (buffer
)->name
))
1800 Lisp_Object aelt
, link
;
1802 aelt
= Frassq (buffer
, Vbuffer_alist
);
1803 link
= Fmemq (aelt
, Vbuffer_alist
);
1804 Vbuffer_alist
= Fdelq (aelt
, Vbuffer_alist
);
1806 Vbuffer_alist
= nconc2 (Vbuffer_alist
, link
);
1808 frames_bury_buffer (buffer
);
1814 DEFUN ("erase-buffer", Ferase_buffer
, Serase_buffer
, 0, 0, "*",
1815 "Delete the entire contents of the current buffer.\n\
1816 Any narrowing restriction in effect (see `narrow-to-region') is removed,\n\
1817 so the buffer is truly empty after this.")
1824 current_buffer
->last_window_start
= 1;
1825 /* Prevent warnings, or suspension of auto saving, that would happen
1826 if future size is less than past size. Use of erase-buffer
1827 implies that the future text is not really related to the past text. */
1828 XSETFASTINT (current_buffer
->save_length
, 0);
1833 validate_region (b
, e
)
1834 register Lisp_Object
*b
, *e
;
1836 CHECK_NUMBER_COERCE_MARKER (*b
, 0);
1837 CHECK_NUMBER_COERCE_MARKER (*e
, 1);
1839 if (XINT (*b
) > XINT (*e
))
1842 tem
= *b
; *b
= *e
; *e
= tem
;
1845 if (!(BEGV
<= XINT (*b
) && XINT (*b
) <= XINT (*e
)
1846 && XINT (*e
) <= ZV
))
1847 args_out_of_range (*b
, *e
);
1850 /* Advance BYTE_POS up to a character boundary
1851 and return the adjusted position. */
1854 advance_to_char_boundary (byte_pos
)
1859 if (byte_pos
== BEG
)
1860 /* Beginning of buffer is always a character boundary. */
1863 c
= FETCH_BYTE (byte_pos
);
1864 if (! CHAR_HEAD_P (c
))
1866 /* We should advance BYTE_POS only when C is a constituent of a
1867 multibyte sequence. */
1868 int orig_byte_pos
= byte_pos
;
1873 c
= FETCH_BYTE (byte_pos
);
1875 while (! CHAR_HEAD_P (c
) && byte_pos
> BEG
);
1877 if (byte_pos
< orig_byte_pos
)
1878 byte_pos
= orig_byte_pos
;
1879 /* If C is a constituent of a multibyte sequence, BYTE_POS was
1880 surely advance to the correct character boundary. If C is
1881 not, BYTE_POS was unchanged. */
1887 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte
, Sset_buffer_multibyte
,
1889 "Set the multibyte flag of the current buffer to FLAG.\n\
1890 If FLAG is t, this makes the buffer a multibyte buffer.\n\
1891 If FLAG is nil, this makes the buffer a single-byte buffer.\n\
1892 The buffer contents remain unchanged as a sequence of bytes\n\
1893 but the contents viewed as characters do change.")
1897 Lisp_Object tail
, markers
;
1898 struct buffer
*other
;
1899 int undo_enabled_p
= !EQ (current_buffer
->undo_list
, Qt
);
1900 int begv
= BEGV
, zv
= ZV
;
1901 int narrowed
= (BEG
!= begv
|| Z
!= zv
);
1902 int modified_p
= !NILP (Fbuffer_modified_p (Qnil
));
1904 if (current_buffer
->base_buffer
)
1905 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
1907 /* Do nothing if nothing actually changes. */
1908 if (NILP (flag
) == NILP (current_buffer
->enable_multibyte_characters
))
1911 /* It would be better to update the list,
1912 but this is good enough for now. */
1914 current_buffer
->undo_list
= Qt
;
1916 /* If the cached position is for this buffer, clear it out. */
1917 clear_charpos_cache (current_buffer
);
1927 /* Do this first, so it can use CHAR_TO_BYTE
1928 to calculate the old correspondences. */
1929 set_intervals_multibyte (0);
1931 current_buffer
->enable_multibyte_characters
= Qnil
;
1937 TEMP_SET_PT_BOTH (PT_BYTE
, PT_BYTE
);
1939 tail
= BUF_MARKERS (current_buffer
);
1940 while (! NILP (tail
))
1942 XMARKER (tail
)->charpos
= XMARKER (tail
)->bytepos
;
1943 tail
= XMARKER (tail
)->chain
;
1946 /* Convert multibyte form of 8-bit characters to unibyte. */
1961 if (MULTIBYTE_STR_AS_UNIBYTE_P (p
, bytes
))
1962 p
+= bytes
, pos
+= bytes
;
1965 c
= STRING_CHAR (p
, stop
- pos
);
1966 /* Delete all bytes for this 8-bit character but the
1967 last one, and change the last one to the charcter
1970 del_range_2 (pos
, pos
, pos
+ bytes
, pos
+ bytes
, 0);
1982 Fnarrow_to_region (make_number (begv
), make_number (zv
));
1990 /* Be sure not to have a multibyte sequence striding over the GAP.
1991 Ex: We change this: "...abc\201 _GAP_ \241def..."
1992 to: "...abc _GAP_ \201\241def..." */
1994 if (GPT_BYTE
> 1 && GPT_BYTE
< Z_BYTE
1995 && ! CHAR_HEAD_P (*(GAP_END_ADDR
)))
1997 unsigned char *p
= GPT_ADDR
- 1;
1999 while (! CHAR_HEAD_P (*p
) && p
> BEG_ADDR
) p
--;
2000 if (BASE_LEADING_CODE_P (*p
))
2002 int new_gpt
= GPT_BYTE
- (GPT_ADDR
- p
);
2004 move_gap_both (new_gpt
, new_gpt
);
2008 /* Make the buffer contents valid as multibyte by converting
2009 8-bit characters to multibyte form. */
2025 if (UNIBYTE_STR_AS_MULTIBYTE_P (p
, stop
- pos
, bytes
))
2026 p
+= bytes
, pos
+= bytes
;
2029 unsigned char tmp
[MAX_MULTIBYTE_LENGTH
];
2031 bytes
= CHAR_STRING (*p
, tmp
);
2033 TEMP_SET_PT_BOTH (pos
+ 1, pos
+ 1);
2035 insert_1_both (tmp
+ 1, bytes
, bytes
, 1, 0, 0);
2036 /* Now the gap is after the just inserted data. */
2053 Fnarrow_to_region (make_number (begv
), make_number (zv
));
2055 /* Do this first, so that chars_in_text asks the right question.
2056 set_intervals_multibyte needs it too. */
2057 current_buffer
->enable_multibyte_characters
= Qt
;
2059 GPT_BYTE
= advance_to_char_boundary (GPT_BYTE
);
2060 GPT
= chars_in_text (BEG_ADDR
, GPT_BYTE
- BEG_BYTE
) + BEG
;
2062 Z
= chars_in_text (GAP_END_ADDR
, Z_BYTE
- GPT_BYTE
) + GPT
;
2064 BEGV_BYTE
= advance_to_char_boundary (BEGV_BYTE
);
2065 if (BEGV_BYTE
> GPT_BYTE
)
2066 BEGV
= chars_in_text (GAP_END_ADDR
, BEGV_BYTE
- GPT_BYTE
) + GPT
;
2068 BEGV
= chars_in_text (BEG_ADDR
, BEGV_BYTE
- BEG_BYTE
) + BEG
;
2070 ZV_BYTE
= advance_to_char_boundary (ZV_BYTE
);
2071 if (ZV_BYTE
> GPT_BYTE
)
2072 ZV
= chars_in_text (GAP_END_ADDR
, ZV_BYTE
- GPT_BYTE
) + GPT
;
2074 ZV
= chars_in_text (BEG_ADDR
, ZV_BYTE
- BEG_BYTE
) + BEG
;
2077 int pt_byte
= advance_to_char_boundary (PT_BYTE
);
2080 if (pt_byte
> GPT_BYTE
)
2081 pt
= chars_in_text (GAP_END_ADDR
, pt_byte
- GPT_BYTE
) + GPT
;
2083 pt
= chars_in_text (BEG_ADDR
, pt_byte
- BEG_BYTE
) + BEG
;
2084 TEMP_SET_PT_BOTH (pt
, pt_byte
);
2087 tail
= markers
= BUF_MARKERS (current_buffer
);
2089 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2090 getting confused by the markers that have not yet been updated.
2091 It is also a signal that it should never create a marker. */
2092 BUF_MARKERS (current_buffer
) = Qnil
;
2094 while (! NILP (tail
))
2096 XMARKER (tail
)->bytepos
2097 = advance_to_char_boundary (XMARKER (tail
)->bytepos
);
2098 XMARKER (tail
)->charpos
= BYTE_TO_CHAR (XMARKER (tail
)->bytepos
);
2100 tail
= XMARKER (tail
)->chain
;
2103 /* Make sure no markers were put on the chain
2104 while the chain value was incorrect. */
2105 if (! EQ (BUF_MARKERS (current_buffer
), Qnil
))
2108 BUF_MARKERS (current_buffer
) = markers
;
2110 /* Do this last, so it can calculate the new correspondences
2111 between chars and bytes. */
2112 set_intervals_multibyte (1);
2116 current_buffer
->undo_list
= Qnil
;
2118 /* Changing the multibyteness of a buffer means that all windows
2119 showing that buffer must be updated thoroughly. */
2120 current_buffer
->prevent_redisplay_optimizations_p
= 1;
2121 ++windows_or_buffers_changed
;
2123 /* Copy this buffer's new multibyte status
2124 into all of its indirect buffers. */
2125 for (other
= all_buffers
; other
; other
= other
->next
)
2126 if (other
->base_buffer
== current_buffer
&& !NILP (other
->name
))
2128 other
->enable_multibyte_characters
2129 = current_buffer
->enable_multibyte_characters
;
2130 other
->prevent_redisplay_optimizations_p
= 1;
2133 /* Restore the modifiedness of the buffer. */
2134 if (!modified_p
&& !NILP (Fbuffer_modified_p (Qnil
)))
2135 Fset_buffer_modified_p (Qnil
);
2140 DEFUN ("kill-all-local-variables", Fkill_all_local_variables
, Skill_all_local_variables
,
2142 "Switch to Fundamental mode by killing current buffer's local variables.\n\
2143 Most local variable bindings are eliminated so that the default values\n\
2144 become effective once more. Also, the syntax table is set from\n\
2145 `standard-syntax-table', the local keymap is set to nil,\n\
2146 and the abbrev table from `fundamental-mode-abbrev-table'.\n\
2147 This function also forces redisplay of the mode line.\n\
2149 Every function to select a new major mode starts by\n\
2150 calling this function.\n\n\
2151 As a special exception, local variables whose names have\n\
2152 a non-nil `permanent-local' property are not eliminated by this function.\n\
2154 The first thing this function does is run\n\
2155 the normal hook `change-major-mode-hook'.")
2158 register Lisp_Object alist
, sym
, tem
;
2161 if (!NILP (Vrun_hooks
))
2162 call1 (Vrun_hooks
, intern ("change-major-mode-hook"));
2163 oalist
= current_buffer
->local_var_alist
;
2165 /* Make sure none of the bindings in oalist
2166 remain swapped in, in their symbols. */
2168 swap_out_buffer_local_variables (current_buffer
);
2170 /* Actually eliminate all local bindings of this buffer. */
2172 reset_buffer_local_variables (current_buffer
, 0);
2174 /* Redisplay mode lines; we are changing major mode. */
2176 update_mode_lines
++;
2178 /* Any which are supposed to be permanent,
2179 make local again, with the same values they had. */
2181 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2183 sym
= XCAR (XCAR (alist
));
2184 tem
= Fget (sym
, Qpermanent_local
);
2187 Fmake_local_variable (sym
);
2188 Fset (sym
, XCDR (XCAR (alist
)));
2192 /* Force mode-line redisplay. Useful here because all major mode
2193 commands call this function. */
2194 update_mode_lines
++;
2199 /* Make sure no local variables remain set up with buffer B
2200 for their current values. */
2203 swap_out_buffer_local_variables (b
)
2206 Lisp_Object oalist
, alist
, sym
, tem
, buffer
;
2208 XSETBUFFER (buffer
, b
);
2209 oalist
= b
->local_var_alist
;
2211 for (alist
= oalist
; !NILP (alist
); alist
= XCDR (alist
))
2213 sym
= XCAR (XCAR (alist
));
2215 /* Need not do anything if some other buffer's binding is now encached. */
2216 tem
= XBUFFER_LOCAL_VALUE (XSYMBOL (sym
)->value
)->buffer
;
2217 if (BUFFERP (tem
) && XBUFFER (tem
) == current_buffer
)
2219 /* Symbol is set up for this buffer's old local value.
2220 Set it up for the current buffer with the default value. */
2222 tem
= XBUFFER_LOCAL_VALUE (XSYMBOL (sym
)->value
)->cdr
;
2223 /* Store the symbol's current value into the alist entry
2224 it is currently set up for. This is so that, if the
2225 local is marked permanent, and we make it local again
2226 later in Fkill_all_local_variables, we don't lose the value. */
2228 = do_symval_forwarding (XBUFFER_LOCAL_VALUE (XSYMBOL (sym
)->value
)->realvalue
);
2229 /* Switch to the symbol's default-value alist entry. */
2231 /* Mark it as current for buffer B. */
2232 XBUFFER_LOCAL_VALUE (XSYMBOL (sym
)->value
)->buffer
= buffer
;
2233 /* Store the current value into any forwarding in the symbol. */
2234 store_symval_forwarding (sym
,
2235 XBUFFER_LOCAL_VALUE (XSYMBOL (sym
)->value
)->realvalue
,
2241 /* Find all the overlays in the current buffer that contain position POS.
2242 Return the number found, and store them in a vector in *VEC_PTR.
2243 Store in *LEN_PTR the size allocated for the vector.
2244 Store in *NEXT_PTR the next position after POS where an overlay starts,
2245 or ZV if there are no more overlays.
2246 Store in *PREV_PTR the previous position before POS where an overlay ends,
2247 or where an overlay starts which ends at or after POS;
2248 or BEGV if there are no such overlays.
2249 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2251 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2252 when this function is called.
2254 If EXTEND is non-zero, we make the vector bigger if necessary.
2255 If EXTEND is zero, we never extend the vector,
2256 and we store only as many overlays as will fit.
2257 But we still return the total number of overlays.
2259 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2260 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2261 default (BEGV or ZV). */
2264 overlays_at (pos
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
, change_req
)
2267 Lisp_Object
**vec_ptr
;
2273 Lisp_Object tail
, overlay
, start
, end
;
2276 Lisp_Object
*vec
= *vec_ptr
;
2279 int inhibit_storing
= 0;
2281 for (tail
= current_buffer
->overlays_before
;
2285 int startpos
, endpos
;
2287 overlay
= XCAR (tail
);
2289 start
= OVERLAY_START (overlay
);
2290 end
= OVERLAY_END (overlay
);
2291 endpos
= OVERLAY_POSITION (end
);
2298 startpos
= OVERLAY_POSITION (start
);
2299 /* This one ends at or after POS
2300 so its start counts for PREV_PTR if it's before POS. */
2301 if (prev
< startpos
&& startpos
< pos
)
2305 if (startpos
<= pos
)
2309 /* The supplied vector is full.
2310 Either make it bigger, or don't store any more in it. */
2313 /* Make it work with an initial len == 0. */
2318 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2322 inhibit_storing
= 1;
2325 if (!inhibit_storing
)
2327 /* Keep counting overlays even if we can't return them all. */
2330 else if (startpos
< next
)
2334 for (tail
= current_buffer
->overlays_after
;
2338 int startpos
, endpos
;
2340 overlay
= XCAR (tail
);
2342 start
= OVERLAY_START (overlay
);
2343 end
= OVERLAY_END (overlay
);
2344 startpos
= OVERLAY_POSITION (start
);
2347 if (startpos
< next
)
2351 endpos
= OVERLAY_POSITION (end
);
2358 *len_ptr
= len
*= 2;
2361 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2365 inhibit_storing
= 1;
2368 if (!inhibit_storing
)
2372 if (startpos
< pos
&& startpos
> prev
)
2375 else if (endpos
< pos
&& endpos
> prev
)
2377 else if (endpos
== pos
&& startpos
> prev
2378 && (!change_req
|| startpos
< pos
))
2389 /* Find all the overlays in the current buffer that overlap the range BEG-END
2390 or are empty at BEG.
2392 Return the number found, and store them in a vector in *VEC_PTR.
2393 Store in *LEN_PTR the size allocated for the vector.
2394 Store in *NEXT_PTR the next position after POS where an overlay starts,
2395 or ZV if there are no more overlays.
2396 Store in *PREV_PTR the previous position before POS where an overlay ends,
2397 or BEGV if there are no previous overlays.
2398 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2400 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2401 when this function is called.
2403 If EXTEND is non-zero, we make the vector bigger if necessary.
2404 If EXTEND is zero, we never extend the vector,
2405 and we store only as many overlays as will fit.
2406 But we still return the total number of overlays. */
2409 overlays_in (beg
, end
, extend
, vec_ptr
, len_ptr
, next_ptr
, prev_ptr
)
2412 Lisp_Object
**vec_ptr
;
2417 Lisp_Object tail
, overlay
, ostart
, oend
;
2420 Lisp_Object
*vec
= *vec_ptr
;
2423 int inhibit_storing
= 0;
2425 for (tail
= current_buffer
->overlays_before
;
2429 int startpos
, endpos
;
2431 overlay
= XCAR (tail
);
2433 ostart
= OVERLAY_START (overlay
);
2434 oend
= OVERLAY_END (overlay
);
2435 endpos
= OVERLAY_POSITION (oend
);
2442 startpos
= OVERLAY_POSITION (ostart
);
2443 /* Count an interval if it either overlaps the range
2444 or is empty at the start of the range. */
2445 if ((beg
< endpos
&& startpos
< end
)
2446 || (startpos
== endpos
&& beg
== endpos
))
2450 /* The supplied vector is full.
2451 Either make it bigger, or don't store any more in it. */
2454 *len_ptr
= len
*= 2;
2455 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2459 inhibit_storing
= 1;
2462 if (!inhibit_storing
)
2464 /* Keep counting overlays even if we can't return them all. */
2467 else if (startpos
< next
)
2471 for (tail
= current_buffer
->overlays_after
;
2475 int startpos
, endpos
;
2477 overlay
= XCAR (tail
);
2479 ostart
= OVERLAY_START (overlay
);
2480 oend
= OVERLAY_END (overlay
);
2481 startpos
= OVERLAY_POSITION (ostart
);
2484 if (startpos
< next
)
2488 endpos
= OVERLAY_POSITION (oend
);
2489 /* Count an interval if it either overlaps the range
2490 or is empty at the start of the range. */
2491 if ((beg
< endpos
&& startpos
< end
)
2492 || (startpos
== endpos
&& beg
== endpos
))
2498 *len_ptr
= len
*= 2;
2499 vec
= (Lisp_Object
*) xrealloc (vec
, len
* sizeof (Lisp_Object
));
2503 inhibit_storing
= 1;
2506 if (!inhibit_storing
)
2510 else if (endpos
< beg
&& endpos
> prev
)
2521 /* Fast function to just test if we're at an overlay boundary. */
2523 overlay_touches_p (pos
)
2526 Lisp_Object tail
, overlay
;
2528 for (tail
= current_buffer
->overlays_before
; GC_CONSP (tail
);
2533 overlay
= XCAR (tail
);
2534 if (!GC_OVERLAYP (overlay
))
2537 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2540 if (endpos
== pos
|| OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
)
2544 for (tail
= current_buffer
->overlays_after
; GC_CONSP (tail
);
2549 overlay
= XCAR (tail
);
2550 if (!GC_OVERLAYP (overlay
))
2553 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2556 if (startpos
== pos
|| OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
)
2564 Lisp_Object overlay
;
2570 compare_overlays (v1
, v2
)
2571 const void *v1
, *v2
;
2573 const struct sortvec
*s1
= (const struct sortvec
*) v1
;
2574 const struct sortvec
*s2
= (const struct sortvec
*) v2
;
2575 if (s1
->priority
!= s2
->priority
)
2576 return s1
->priority
- s2
->priority
;
2577 if (s1
->beg
!= s2
->beg
)
2578 return s1
->beg
- s2
->beg
;
2579 if (s1
->end
!= s2
->end
)
2580 return s2
->end
- s1
->end
;
2584 /* Sort an array of overlays by priority. The array is modified in place.
2585 The return value is the new size; this may be smaller than the original
2586 size if some of the overlays were invalid or were window-specific. */
2588 sort_overlays (overlay_vec
, noverlays
, w
)
2589 Lisp_Object
*overlay_vec
;
2594 struct sortvec
*sortvec
;
2595 sortvec
= (struct sortvec
*) alloca (noverlays
* sizeof (struct sortvec
));
2597 /* Put the valid and relevant overlays into sortvec. */
2599 for (i
= 0, j
= 0; i
< noverlays
; i
++)
2602 Lisp_Object overlay
;
2604 overlay
= overlay_vec
[i
];
2605 if (OVERLAY_VALID (overlay
)
2606 && OVERLAY_POSITION (OVERLAY_START (overlay
)) > 0
2607 && OVERLAY_POSITION (OVERLAY_END (overlay
)) > 0)
2609 /* If we're interested in a specific window, then ignore
2610 overlays that are limited to some other window. */
2615 window
= Foverlay_get (overlay
, Qwindow
);
2616 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2620 /* This overlay is good and counts: put it into sortvec. */
2621 sortvec
[j
].overlay
= overlay
;
2622 sortvec
[j
].beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2623 sortvec
[j
].end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2624 tem
= Foverlay_get (overlay
, Qpriority
);
2626 sortvec
[j
].priority
= XINT (tem
);
2628 sortvec
[j
].priority
= 0;
2634 /* Sort the overlays into the proper order: increasing priority. */
2637 qsort (sortvec
, noverlays
, sizeof (struct sortvec
), compare_overlays
);
2639 for (i
= 0; i
< noverlays
; i
++)
2640 overlay_vec
[i
] = sortvec
[i
].overlay
;
2646 Lisp_Object string
, string2
;
2653 struct sortstr
*buf
; /* An array that expands as needed; never freed. */
2654 int size
; /* Allocated length of that array. */
2655 int used
; /* How much of the array is currently in use. */
2656 int bytes
; /* Total length of the strings in buf. */
2659 /* Buffers for storing information about the overlays touching a given
2660 position. These could be automatic variables in overlay_strings, but
2661 it's more efficient to hold onto the memory instead of repeatedly
2662 allocating and freeing it. */
2663 static struct sortstrlist overlay_heads
, overlay_tails
;
2664 static unsigned char *overlay_str_buf
;
2666 /* Allocated length of overlay_str_buf. */
2667 static int overlay_str_len
;
2669 /* A comparison function suitable for passing to qsort. */
2671 cmp_for_strings (as1
, as2
)
2674 struct sortstr
*s1
= (struct sortstr
*)as1
;
2675 struct sortstr
*s2
= (struct sortstr
*)as2
;
2676 if (s1
->size
!= s2
->size
)
2677 return s2
->size
- s1
->size
;
2678 if (s1
->priority
!= s2
->priority
)
2679 return s1
->priority
- s2
->priority
;
2684 record_overlay_string (ssl
, str
, str2
, pri
, size
)
2685 struct sortstrlist
*ssl
;
2686 Lisp_Object str
, str2
, pri
;
2691 if (ssl
->used
== ssl
->size
)
2697 ssl
->buf
= ((struct sortstr
*)
2698 xrealloc (ssl
->buf
, ssl
->size
* sizeof (struct sortstr
)));
2700 ssl
->buf
[ssl
->used
].string
= str
;
2701 ssl
->buf
[ssl
->used
].string2
= str2
;
2702 ssl
->buf
[ssl
->used
].size
= size
;
2703 ssl
->buf
[ssl
->used
].priority
= (INTEGERP (pri
) ? XINT (pri
) : 0);
2706 if (NILP (current_buffer
->enable_multibyte_characters
))
2707 nbytes
= XSTRING (str
)->size
;
2708 else if (! STRING_MULTIBYTE (str
))
2709 nbytes
= count_size_as_multibyte (XSTRING (str
)->data
,
2710 STRING_BYTES (XSTRING (str
)));
2712 nbytes
= STRING_BYTES (XSTRING (str
));
2714 ssl
->bytes
+= nbytes
;
2718 if (NILP (current_buffer
->enable_multibyte_characters
))
2719 nbytes
= XSTRING (str2
)->size
;
2720 else if (! STRING_MULTIBYTE (str2
))
2721 nbytes
= count_size_as_multibyte (XSTRING (str2
)->data
,
2722 STRING_BYTES (XSTRING (str2
)));
2724 nbytes
= STRING_BYTES (XSTRING (str2
));
2726 ssl
->bytes
+= nbytes
;
2730 /* Return the concatenation of the strings associated with overlays that
2731 begin or end at POS, ignoring overlays that are specific to a window
2732 other than W. The strings are concatenated in the appropriate order:
2733 shorter overlays nest inside longer ones, and higher priority inside
2734 lower. Normally all of the after-strings come first, but zero-sized
2735 overlays have their after-strings ride along with the before-strings
2736 because it would look strange to print them inside-out.
2738 Returns the string length, and stores the contents indirectly through
2739 PSTR, if that variable is non-null. The string may be overwritten by
2740 subsequent calls. */
2743 overlay_strings (pos
, w
, pstr
)
2746 unsigned char **pstr
;
2748 Lisp_Object ov
, overlay
, window
, str
;
2749 int startpos
, endpos
;
2750 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
2752 overlay_heads
.used
= overlay_heads
.bytes
= 0;
2753 overlay_tails
.used
= overlay_tails
.bytes
= 0;
2754 for (ov
= current_buffer
->overlays_before
; CONSP (ov
); ov
= XCDR (ov
))
2756 overlay
= XCAR (ov
);
2757 if (!OVERLAYP (overlay
))
2760 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2761 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2764 if (endpos
!= pos
&& startpos
!= pos
)
2766 window
= Foverlay_get (overlay
, Qwindow
);
2767 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2770 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
2771 record_overlay_string (&overlay_heads
, str
,
2773 ? Foverlay_get (overlay
, Qafter_string
)
2775 Foverlay_get (overlay
, Qpriority
),
2777 else if (endpos
== pos
2778 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
2779 record_overlay_string (&overlay_tails
, str
, Qnil
,
2780 Foverlay_get (overlay
, Qpriority
),
2783 for (ov
= current_buffer
->overlays_after
; CONSP (ov
); ov
= XCDR (ov
))
2785 overlay
= XCAR (ov
);
2786 if (!OVERLAYP (overlay
))
2789 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
2790 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
2793 if (endpos
!= pos
&& startpos
!= pos
)
2795 window
= Foverlay_get (overlay
, Qwindow
);
2796 if (WINDOWP (window
) && XWINDOW (window
) != w
)
2799 && (str
= Foverlay_get (overlay
, Qbefore_string
), STRINGP (str
)))
2800 record_overlay_string (&overlay_heads
, str
,
2802 ? Foverlay_get (overlay
, Qafter_string
)
2804 Foverlay_get (overlay
, Qpriority
),
2806 else if (endpos
== pos
2807 && (str
= Foverlay_get (overlay
, Qafter_string
), STRINGP (str
)))
2808 record_overlay_string (&overlay_tails
, str
, Qnil
,
2809 Foverlay_get (overlay
, Qpriority
),
2812 if (overlay_tails
.used
> 1)
2813 qsort (overlay_tails
.buf
, overlay_tails
.used
, sizeof (struct sortstr
),
2815 if (overlay_heads
.used
> 1)
2816 qsort (overlay_heads
.buf
, overlay_heads
.used
, sizeof (struct sortstr
),
2818 if (overlay_heads
.bytes
|| overlay_tails
.bytes
)
2823 int total
= overlay_heads
.bytes
+ overlay_tails
.bytes
;
2825 if (total
> overlay_str_len
)
2827 overlay_str_len
= total
;
2828 overlay_str_buf
= (unsigned char *)xrealloc (overlay_str_buf
,
2831 p
= overlay_str_buf
;
2832 for (i
= overlay_tails
.used
; --i
>= 0;)
2835 tem
= overlay_tails
.buf
[i
].string
;
2836 nbytes
= copy_text (XSTRING (tem
)->data
, p
,
2837 STRING_BYTES (XSTRING (tem
)),
2838 STRING_MULTIBYTE (tem
), multibyte
);
2841 for (i
= 0; i
< overlay_heads
.used
; ++i
)
2844 tem
= overlay_heads
.buf
[i
].string
;
2845 nbytes
= copy_text (XSTRING (tem
)->data
, p
,
2846 STRING_BYTES (XSTRING (tem
)),
2847 STRING_MULTIBYTE (tem
), multibyte
);
2849 tem
= overlay_heads
.buf
[i
].string2
;
2852 nbytes
= copy_text (XSTRING (tem
)->data
, p
,
2853 STRING_BYTES (XSTRING (tem
)),
2854 STRING_MULTIBYTE (tem
), multibyte
);
2858 if (p
!= overlay_str_buf
+ total
)
2861 *pstr
= overlay_str_buf
;
2867 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
2870 recenter_overlay_lists (buf
, pos
)
2874 Lisp_Object overlay
, tail
, next
, prev
, beg
, end
;
2876 /* See if anything in overlays_before should move to overlays_after. */
2878 /* We don't strictly need prev in this loop; it should always be nil.
2879 But we use it for symmetry and in case that should cease to be true
2880 with some future change. */
2882 for (tail
= buf
->overlays_before
;
2884 prev
= tail
, tail
= next
)
2887 overlay
= XCAR (tail
);
2889 /* If the overlay is not valid, get rid of it. */
2890 if (!OVERLAY_VALID (overlay
))
2895 /* Splice the cons cell TAIL out of overlays_before. */
2899 buf
->overlays_before
= next
;
2905 beg
= OVERLAY_START (overlay
);
2906 end
= OVERLAY_END (overlay
);
2908 if (OVERLAY_POSITION (end
) > pos
)
2910 /* OVERLAY needs to be moved. */
2911 int where
= OVERLAY_POSITION (beg
);
2912 Lisp_Object other
, other_prev
;
2914 /* Splice the cons cell TAIL out of overlays_before. */
2918 buf
->overlays_before
= next
;
2920 /* Search thru overlays_after for where to put it. */
2922 for (other
= buf
->overlays_after
;
2924 other_prev
= other
, other
= XCDR (other
))
2926 Lisp_Object otherbeg
, otheroverlay
;
2928 otheroverlay
= XCAR (other
);
2929 if (! OVERLAY_VALID (otheroverlay
))
2932 otherbeg
= OVERLAY_START (otheroverlay
);
2933 if (OVERLAY_POSITION (otherbeg
) >= where
)
2937 /* Add TAIL to overlays_after before OTHER. */
2938 XCDR (tail
) = other
;
2939 if (!NILP (other_prev
))
2940 XCDR (other_prev
) = tail
;
2942 buf
->overlays_after
= tail
;
2946 /* We've reached the things that should stay in overlays_before.
2947 All the rest of overlays_before must end even earlier,
2952 /* See if anything in overlays_after should be in overlays_before. */
2954 for (tail
= buf
->overlays_after
;
2956 prev
= tail
, tail
= next
)
2959 overlay
= XCAR (tail
);
2961 /* If the overlay is not valid, get rid of it. */
2962 if (!OVERLAY_VALID (overlay
))
2967 /* Splice the cons cell TAIL out of overlays_after. */
2971 buf
->overlays_after
= next
;
2977 beg
= OVERLAY_START (overlay
);
2978 end
= OVERLAY_END (overlay
);
2980 /* Stop looking, when we know that nothing further
2981 can possibly end before POS. */
2982 if (OVERLAY_POSITION (beg
) > pos
)
2985 if (OVERLAY_POSITION (end
) <= pos
)
2987 /* OVERLAY needs to be moved. */
2988 int where
= OVERLAY_POSITION (end
);
2989 Lisp_Object other
, other_prev
;
2991 /* Splice the cons cell TAIL out of overlays_after. */
2995 buf
->overlays_after
= next
;
2997 /* Search thru overlays_before for where to put it. */
2999 for (other
= buf
->overlays_before
;
3001 other_prev
= other
, other
= XCDR (other
))
3003 Lisp_Object otherend
, otheroverlay
;
3005 otheroverlay
= XCAR (other
);
3006 if (! OVERLAY_VALID (otheroverlay
))
3009 otherend
= OVERLAY_END (otheroverlay
);
3010 if (OVERLAY_POSITION (otherend
) <= where
)
3014 /* Add TAIL to overlays_before before OTHER. */
3015 XCDR (tail
) = other
;
3016 if (!NILP (other_prev
))
3017 XCDR (other_prev
) = tail
;
3019 buf
->overlays_before
= tail
;
3024 XSETFASTINT (buf
->overlay_center
, pos
);
3028 adjust_overlays_for_insert (pos
, length
)
3032 /* After an insertion, the lists are still sorted properly,
3033 but we may need to update the value of the overlay center. */
3034 if (XFASTINT (current_buffer
->overlay_center
) >= pos
)
3035 XSETFASTINT (current_buffer
->overlay_center
,
3036 XFASTINT (current_buffer
->overlay_center
) + length
);
3040 adjust_overlays_for_delete (pos
, length
)
3044 if (XFASTINT (current_buffer
->overlay_center
) < pos
)
3045 /* The deletion was to our right. No change needed; the before- and
3046 after-lists are still consistent. */
3048 else if (XFASTINT (current_buffer
->overlay_center
) > pos
+ length
)
3049 /* The deletion was to our left. We need to adjust the center value
3050 to account for the change in position, but the lists are consistent
3051 given the new value. */
3052 XSETFASTINT (current_buffer
->overlay_center
,
3053 XFASTINT (current_buffer
->overlay_center
) - length
);
3055 /* We're right in the middle. There might be things on the after-list
3056 that now belong on the before-list. Recentering will move them,
3057 and also update the center point. */
3058 recenter_overlay_lists (current_buffer
, pos
);
3061 /* Fix up overlays that were garbled as a result of permuting markers
3062 in the range START through END. Any overlay with at least one
3063 endpoint in this range will need to be unlinked from the overlay
3064 list and reinserted in its proper place.
3065 Such an overlay might even have negative size at this point.
3066 If so, we'll reverse the endpoints. Can you think of anything
3067 better to do in this situation? */
3069 fix_overlays_in_range (start
, end
)
3070 register int start
, end
;
3072 Lisp_Object overlay
;
3073 Lisp_Object before_list
, after_list
;
3074 Lisp_Object
*ptail
, *pbefore
= &before_list
, *pafter
= &after_list
;
3075 int startpos
, endpos
;
3077 /* This algorithm shifts links around instead of consing and GCing.
3078 The loop invariant is that before_list (resp. after_list) is a
3079 well-formed list except that its last element, the one that
3080 *pbefore (resp. *pafter) points to, is still uninitialized.
3081 So it's not a bug that before_list isn't initialized, although
3082 it may look strange. */
3083 for (ptail
= ¤t_buffer
->overlays_before
; CONSP (*ptail
);)
3085 overlay
= XCAR (*ptail
);
3086 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3089 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3091 || (startpos
>= start
&& startpos
< end
))
3093 /* If the overlay is backwards, fix that now. */
3094 if (startpos
> endpos
)
3097 Fset_marker (OVERLAY_START (overlay
), make_number (endpos
),
3099 Fset_marker (OVERLAY_END (overlay
), make_number (startpos
),
3101 tem
= startpos
; startpos
= endpos
; endpos
= tem
;
3103 /* Add it to the end of the wrong list. Later on,
3104 recenter_overlay_lists will move it to the right place. */
3105 if (endpos
< XINT (current_buffer
->overlay_center
))
3108 pafter
= &XCDR (*ptail
);
3113 pbefore
= &XCDR (*ptail
);
3115 *ptail
= XCDR (*ptail
);
3118 ptail
= &XCDR (*ptail
);
3120 for (ptail
= ¤t_buffer
->overlays_after
; CONSP (*ptail
);)
3122 overlay
= XCAR (*ptail
);
3123 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3124 if (startpos
>= end
)
3126 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3127 if (startpos
>= start
3128 || (endpos
>= start
&& endpos
< end
))
3130 if (startpos
> endpos
)
3133 Fset_marker (OVERLAY_START (overlay
), make_number (endpos
),
3135 Fset_marker (OVERLAY_END (overlay
), make_number (startpos
),
3137 tem
= startpos
; startpos
= endpos
; endpos
= tem
;
3139 if (endpos
< XINT (current_buffer
->overlay_center
))
3142 pafter
= &XCDR (*ptail
);
3147 pbefore
= &XCDR (*ptail
);
3149 *ptail
= XCDR (*ptail
);
3152 ptail
= &XCDR (*ptail
);
3155 /* Splice the constructed (wrong) lists into the buffer's lists,
3156 and let the recenter function make it sane again. */
3157 *pbefore
= current_buffer
->overlays_before
;
3158 current_buffer
->overlays_before
= before_list
;
3159 recenter_overlay_lists (current_buffer
,
3160 XINT (current_buffer
->overlay_center
));
3162 *pafter
= current_buffer
->overlays_after
;
3163 current_buffer
->overlays_after
= after_list
;
3164 recenter_overlay_lists (current_buffer
,
3165 XINT (current_buffer
->overlay_center
));
3168 /* We have two types of overlay: the one whose ending marker is
3169 after-insertion-marker (this is the usual case) and the one whose
3170 ending marker is before-insertion-marker. When `overlays_before'
3171 contains overlays of the latter type and the former type in this
3172 order and both overlays end at inserting position, inserting a text
3173 increases only the ending marker of the latter type, which results
3174 in incorrect ordering of `overlays_before'.
3176 This function fixes ordering of overlays in the slot
3177 `overlays_before' of the buffer *BP. Before the insertion, `point'
3178 was at PREV, and now is at POS. */
3181 fix_overlays_before (bp
, prev
, pos
)
3185 Lisp_Object
*tailp
= &bp
->overlays_before
;
3186 Lisp_Object
*right_place
;
3189 /* After the insertion, the several overlays may be in incorrect
3190 order. The possibility is that, in the list `overlays_before',
3191 an overlay which ends at POS appears after an overlay which ends
3192 at PREV. Since POS is greater than PREV, we must fix the
3193 ordering of these overlays, by moving overlays ends at POS before
3194 the overlays ends at PREV. */
3196 /* At first, find a place where disordered overlays should be linked
3197 in. It is where an overlay which end before POS exists. (i.e. an
3198 overlay whose ending marker is after-insertion-marker if disorder
3200 while (!NILP (*tailp
)
3201 && ((end
= OVERLAY_POSITION (OVERLAY_END (XCAR (*tailp
))))
3203 tailp
= &XCDR (*tailp
);
3205 /* If we don't find such an overlay,
3206 or the found one ends before PREV,
3207 or the found one is the last one in the list,
3208 we don't have to fix anything. */
3211 || NILP (XCDR (*tailp
)))
3214 right_place
= tailp
;
3215 tailp
= &XCDR (*tailp
);
3217 /* Now, end position of overlays in the list *TAILP should be before
3218 or equal to PREV. In the loop, an overlay which ends at POS is
3219 moved ahead to the place pointed by RIGHT_PLACE. If we found an
3220 overlay which ends before PREV, the remaining overlays are in
3222 while (!NILP (*tailp
))
3224 end
= OVERLAY_POSITION (OVERLAY_END (XCAR (*tailp
)));
3227 { /* This overlay is disordered. */
3228 Lisp_Object found
= *tailp
;
3230 /* Unlink the found overlay. */
3231 *tailp
= XCDR (found
);
3232 /* Move an overlay at RIGHT_PLACE to the next of the found one. */
3233 XCDR (found
) = *right_place
;
3234 /* Link it into the right place. */
3235 *right_place
= found
;
3237 else if (end
== prev
)
3238 tailp
= &XCDR (*tailp
);
3239 else /* No more disordered overlay. */
3244 DEFUN ("overlayp", Foverlayp
, Soverlayp
, 1, 1, 0,
3245 "Return t if OBJECT is an overlay.")
3249 return (OVERLAYP (object
) ? Qt
: Qnil
);
3252 DEFUN ("make-overlay", Fmake_overlay
, Smake_overlay
, 2, 5, 0,
3253 "Create a new overlay with range BEG to END in BUFFER.\n\
3254 If omitted, BUFFER defaults to the current buffer.\n\
3255 BEG and END may be integers or markers.\n\
3256 The fourth arg FRONT-ADVANCE, if non-nil, makes the\n\
3257 front delimiter advance when text is inserted there.\n\
3258 The fifth arg REAR-ADVANCE, if non-nil, makes the\n\
3259 rear delimiter advance when text is inserted there.")
3260 (beg
, end
, buffer
, front_advance
, rear_advance
)
3261 Lisp_Object beg
, end
, buffer
;
3262 Lisp_Object front_advance
, rear_advance
;
3264 Lisp_Object overlay
;
3268 XSETBUFFER (buffer
, current_buffer
);
3270 CHECK_BUFFER (buffer
, 2);
3272 && ! EQ (Fmarker_buffer (beg
), buffer
))
3273 error ("Marker points into wrong buffer");
3275 && ! EQ (Fmarker_buffer (end
), buffer
))
3276 error ("Marker points into wrong buffer");
3278 CHECK_NUMBER_COERCE_MARKER (beg
, 1);
3279 CHECK_NUMBER_COERCE_MARKER (end
, 1);
3281 if (XINT (beg
) > XINT (end
))
3284 temp
= beg
; beg
= end
; end
= temp
;
3287 b
= XBUFFER (buffer
);
3289 beg
= Fset_marker (Fmake_marker (), beg
, buffer
);
3290 end
= Fset_marker (Fmake_marker (), end
, buffer
);
3292 if (!NILP (front_advance
))
3293 XMARKER (beg
)->insertion_type
= 1;
3294 if (!NILP (rear_advance
))
3295 XMARKER (end
)->insertion_type
= 1;
3297 overlay
= allocate_misc ();
3298 XMISCTYPE (overlay
) = Lisp_Misc_Overlay
;
3299 XOVERLAY (overlay
)->start
= beg
;
3300 XOVERLAY (overlay
)->end
= end
;
3301 XOVERLAY (overlay
)->plist
= Qnil
;
3303 /* Put the new overlay on the wrong list. */
3304 end
= OVERLAY_END (overlay
);
3305 if (OVERLAY_POSITION (end
) < XINT (b
->overlay_center
))
3306 b
->overlays_after
= Fcons (overlay
, b
->overlays_after
);
3308 b
->overlays_before
= Fcons (overlay
, b
->overlays_before
);
3310 /* This puts it in the right list, and in the right order. */
3311 recenter_overlay_lists (b
, XINT (b
->overlay_center
));
3313 /* We don't need to redisplay the region covered by the overlay, because
3314 the overlay has no properties at the moment. */
3319 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3322 modify_overlay (buf
, start
, end
)
3332 start
= end
; end
= temp
;
3335 BUF_COMPUTE_UNCHANGED (buf
, start
, end
);
3337 /* If this is a buffer not in the selected window,
3338 we must do other windows. */
3339 if (buf
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
3340 windows_or_buffers_changed
= 1;
3341 /* If multiple windows show this buffer, we must do other windows. */
3342 else if (buffer_shared
> 1)
3343 windows_or_buffers_changed
= 1;
3345 ++BUF_OVERLAY_MODIFF (buf
);
3349 Lisp_Object
Fdelete_overlay ();
3351 DEFUN ("move-overlay", Fmove_overlay
, Smove_overlay
, 3, 4, 0,
3352 "Set the endpoints of OVERLAY to BEG and END in BUFFER.\n\
3353 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.\n\
3354 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current\n\
3356 (overlay
, beg
, end
, buffer
)
3357 Lisp_Object overlay
, beg
, end
, buffer
;
3359 struct buffer
*b
, *ob
;
3360 Lisp_Object obuffer
;
3361 int count
= specpdl_ptr
- specpdl
;
3363 CHECK_OVERLAY (overlay
, 0);
3365 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3367 XSETBUFFER (buffer
, current_buffer
);
3368 CHECK_BUFFER (buffer
, 3);
3371 && ! EQ (Fmarker_buffer (beg
), buffer
))
3372 error ("Marker points into wrong buffer");
3374 && ! EQ (Fmarker_buffer (end
), buffer
))
3375 error ("Marker points into wrong buffer");
3377 CHECK_NUMBER_COERCE_MARKER (beg
, 1);
3378 CHECK_NUMBER_COERCE_MARKER (end
, 1);
3380 if (XINT (beg
) == XINT (end
) && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
3381 return Fdelete_overlay (overlay
);
3383 if (XINT (beg
) > XINT (end
))
3386 temp
= beg
; beg
= end
; end
= temp
;
3389 specbind (Qinhibit_quit
, Qt
);
3391 obuffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3392 b
= XBUFFER (buffer
);
3393 ob
= BUFFERP (obuffer
) ? XBUFFER (obuffer
) : (struct buffer
*) 0;
3395 /* If the overlay has changed buffers, do a thorough redisplay. */
3396 if (!EQ (buffer
, obuffer
))
3398 /* Redisplay where the overlay was. */
3399 if (!NILP (obuffer
))
3404 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3405 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3407 modify_overlay (ob
, o_beg
, o_end
);
3410 /* Redisplay where the overlay is going to be. */
3411 modify_overlay (b
, XINT (beg
), XINT (end
));
3414 /* Redisplay the area the overlay has just left, or just enclosed. */
3418 o_beg
= OVERLAY_POSITION (OVERLAY_START (overlay
));
3419 o_end
= OVERLAY_POSITION (OVERLAY_END (overlay
));
3421 if (o_beg
== XINT (beg
))
3422 modify_overlay (b
, o_end
, XINT (end
));
3423 else if (o_end
== XINT (end
))
3424 modify_overlay (b
, o_beg
, XINT (beg
));
3427 if (XINT (beg
) < o_beg
) o_beg
= XINT (beg
);
3428 if (XINT (end
) > o_end
) o_end
= XINT (end
);
3429 modify_overlay (b
, o_beg
, o_end
);
3433 if (!NILP (obuffer
))
3435 ob
->overlays_before
= Fdelq (overlay
, ob
->overlays_before
);
3436 ob
->overlays_after
= Fdelq (overlay
, ob
->overlays_after
);
3439 Fset_marker (OVERLAY_START (overlay
), beg
, buffer
);
3440 Fset_marker (OVERLAY_END (overlay
), end
, buffer
);
3442 /* Put the overlay on the wrong list. */
3443 end
= OVERLAY_END (overlay
);
3444 if (OVERLAY_POSITION (end
) < XINT (b
->overlay_center
))
3445 b
->overlays_after
= Fcons (overlay
, b
->overlays_after
);
3447 b
->overlays_before
= Fcons (overlay
, b
->overlays_before
);
3449 /* This puts it in the right list, and in the right order. */
3450 recenter_overlay_lists (b
, XINT (b
->overlay_center
));
3452 return unbind_to (count
, overlay
);
3455 DEFUN ("delete-overlay", Fdelete_overlay
, Sdelete_overlay
, 1, 1, 0,
3456 "Delete the overlay OVERLAY from its buffer.")
3458 Lisp_Object overlay
;
3462 int count
= specpdl_ptr
- specpdl
;
3464 CHECK_OVERLAY (overlay
, 0);
3466 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3470 b
= XBUFFER (buffer
);
3472 specbind (Qinhibit_quit
, Qt
);
3474 b
->overlays_before
= Fdelq (overlay
, b
->overlays_before
);
3475 b
->overlays_after
= Fdelq (overlay
, b
->overlays_after
);
3478 marker_position (OVERLAY_START (overlay
)),
3479 marker_position (OVERLAY_END (overlay
)));
3481 Fset_marker (OVERLAY_START (overlay
), Qnil
, Qnil
);
3482 Fset_marker (OVERLAY_END (overlay
), Qnil
, Qnil
);
3484 return unbind_to (count
, Qnil
);
3487 /* Overlay dissection functions. */
3489 DEFUN ("overlay-start", Foverlay_start
, Soverlay_start
, 1, 1, 0,
3490 "Return the position at which OVERLAY starts.")
3492 Lisp_Object overlay
;
3494 CHECK_OVERLAY (overlay
, 0);
3496 return (Fmarker_position (OVERLAY_START (overlay
)));
3499 DEFUN ("overlay-end", Foverlay_end
, Soverlay_end
, 1, 1, 0,
3500 "Return the position at which OVERLAY ends.")
3502 Lisp_Object overlay
;
3504 CHECK_OVERLAY (overlay
, 0);
3506 return (Fmarker_position (OVERLAY_END (overlay
)));
3509 DEFUN ("overlay-buffer", Foverlay_buffer
, Soverlay_buffer
, 1, 1, 0,
3510 "Return the buffer OVERLAY belongs to.")
3512 Lisp_Object overlay
;
3514 CHECK_OVERLAY (overlay
, 0);
3516 return Fmarker_buffer (OVERLAY_START (overlay
));
3519 DEFUN ("overlay-properties", Foverlay_properties
, Soverlay_properties
, 1, 1, 0,
3520 "Return a list of the properties on OVERLAY.\n\
3521 This is a copy of OVERLAY's plist; modifying its conses has no effect on\n\
3524 Lisp_Object overlay
;
3526 CHECK_OVERLAY (overlay
, 0);
3528 return Fcopy_sequence (XOVERLAY (overlay
)->plist
);
3532 DEFUN ("overlays-at", Foverlays_at
, Soverlays_at
, 1, 1, 0,
3533 "Return a list of the overlays that contain position POS.")
3538 Lisp_Object
*overlay_vec
;
3542 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
3545 /* We can't use alloca here because overlays_at can call xrealloc. */
3546 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3548 /* Put all the overlays we want in a vector in overlay_vec.
3549 Store the length in len. */
3550 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3551 (int *) 0, (int *) 0, 0);
3553 /* Make a list of them all. */
3554 result
= Flist (noverlays
, overlay_vec
);
3556 xfree (overlay_vec
);
3560 DEFUN ("overlays-in", Foverlays_in
, Soverlays_in
, 2, 2, 0,
3561 "Return a list of the overlays that overlap the region BEG ... END.\n\
3562 Overlap means that at least one character is contained within the overlay\n\
3563 and also contained within the specified region.\n\
3564 Empty overlays are included in the result if they are located at BEG\n\
3565 or between BEG and END.")
3567 Lisp_Object beg
, end
;
3570 Lisp_Object
*overlay_vec
;
3574 CHECK_NUMBER_COERCE_MARKER (beg
, 0);
3575 CHECK_NUMBER_COERCE_MARKER (end
, 0);
3578 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3580 /* Put all the overlays we want in a vector in overlay_vec.
3581 Store the length in len. */
3582 noverlays
= overlays_in (XINT (beg
), XINT (end
), 1, &overlay_vec
, &len
,
3583 (int *) 0, (int *) 0);
3585 /* Make a list of them all. */
3586 result
= Flist (noverlays
, overlay_vec
);
3588 xfree (overlay_vec
);
3592 DEFUN ("next-overlay-change", Fnext_overlay_change
, Snext_overlay_change
,
3594 "Return the next position after POS where an overlay starts or ends.\n\
3595 If there are no more overlay boundaries after POS, return (point-max).")
3601 Lisp_Object
*overlay_vec
;
3605 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
3608 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3610 /* Put all the overlays we want in a vector in overlay_vec.
3611 Store the length in len.
3612 endpos gets the position where the next overlay starts. */
3613 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3614 &endpos
, (int *) 0, 1);
3616 /* If any of these overlays ends before endpos,
3617 use its ending point instead. */
3618 for (i
= 0; i
< noverlays
; i
++)
3623 oend
= OVERLAY_END (overlay_vec
[i
]);
3624 oendpos
= OVERLAY_POSITION (oend
);
3625 if (oendpos
< endpos
)
3629 xfree (overlay_vec
);
3630 return make_number (endpos
);
3633 DEFUN ("previous-overlay-change", Fprevious_overlay_change
,
3634 Sprevious_overlay_change
, 1, 1, 0,
3635 "Return the previous position before POS where an overlay starts or ends.\n\
3636 If there are no more overlay boundaries before POS, return (point-min).")
3642 Lisp_Object
*overlay_vec
;
3645 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
3647 /* At beginning of buffer, we know the answer;
3648 avoid bug subtracting 1 below. */
3649 if (XINT (pos
) == BEGV
)
3653 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
3655 /* Put all the overlays we want in a vector in overlay_vec.
3656 Store the length in len.
3657 prevpos gets the position of the previous change. */
3658 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
3659 (int *) 0, &prevpos
, 1);
3661 xfree (overlay_vec
);
3662 return make_number (prevpos
);
3665 /* These functions are for debugging overlays. */
3667 DEFUN ("overlay-lists", Foverlay_lists
, Soverlay_lists
, 0, 0, 0,
3668 "Return a pair of lists giving all the overlays of the current buffer.\n\
3669 The car has all the overlays before the overlay center;\n\
3670 the cdr has all the overlays after the overlay center.\n\
3671 Recentering overlays moves overlays between these lists.\n\
3672 The lists you get are copies, so that changing them has no effect.\n\
3673 However, the overlays you get are the real objects that the buffer uses.")
3676 Lisp_Object before
, after
;
3677 before
= current_buffer
->overlays_before
;
3679 before
= Fcopy_sequence (before
);
3680 after
= current_buffer
->overlays_after
;
3682 after
= Fcopy_sequence (after
);
3684 return Fcons (before
, after
);
3687 DEFUN ("overlay-recenter", Foverlay_recenter
, Soverlay_recenter
, 1, 1, 0,
3688 "Recenter the overlays of the current buffer around position POS.")
3692 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
3694 recenter_overlay_lists (current_buffer
, XINT (pos
));
3698 DEFUN ("overlay-get", Foverlay_get
, Soverlay_get
, 2, 2, 0,
3699 "Get the property of overlay OVERLAY with property name PROP.")
3701 Lisp_Object overlay
, prop
;
3703 Lisp_Object plist
, fallback
;
3705 CHECK_OVERLAY (overlay
, 0);
3709 for (plist
= XOVERLAY (overlay
)->plist
;
3710 CONSP (plist
) && CONSP (XCDR (plist
));
3711 plist
= XCDR (XCDR (plist
)))
3713 if (EQ (XCAR (plist
), prop
))
3714 return XCAR (XCDR (plist
));
3715 else if (EQ (XCAR (plist
), Qcategory
))
3718 tem
= Fcar (Fcdr (plist
));
3720 fallback
= Fget (tem
, prop
);
3727 DEFUN ("overlay-put", Foverlay_put
, Soverlay_put
, 3, 3, 0,
3728 "Set one property of overlay OVERLAY: give property PROP value VALUE.")
3729 (overlay
, prop
, value
)
3730 Lisp_Object overlay
, prop
, value
;
3732 Lisp_Object tail
, buffer
;
3735 CHECK_OVERLAY (overlay
, 0);
3737 buffer
= Fmarker_buffer (OVERLAY_START (overlay
));
3739 for (tail
= XOVERLAY (overlay
)->plist
;
3740 CONSP (tail
) && CONSP (XCDR (tail
));
3741 tail
= XCDR (XCDR (tail
)))
3742 if (EQ (XCAR (tail
), prop
))
3744 changed
= !EQ (XCAR (XCDR (tail
)), value
);
3745 XCAR (XCDR (tail
)) = value
;
3748 /* It wasn't in the list, so add it to the front. */
3749 changed
= !NILP (value
);
3750 XOVERLAY (overlay
)->plist
3751 = Fcons (prop
, Fcons (value
, XOVERLAY (overlay
)->plist
));
3753 if (! NILP (buffer
))
3756 modify_overlay (XBUFFER (buffer
),
3757 marker_position (OVERLAY_START (overlay
)),
3758 marker_position (OVERLAY_END (overlay
)));
3759 if (EQ (prop
, Qevaporate
) && ! NILP (value
)
3760 && (OVERLAY_POSITION (OVERLAY_START (overlay
))
3761 == OVERLAY_POSITION (OVERLAY_END (overlay
))))
3762 Fdelete_overlay (overlay
);
3767 /* Subroutine of report_overlay_modification. */
3769 /* Lisp vector holding overlay hook functions to call.
3770 Vector elements come in pairs.
3771 Each even-index element is a list of hook functions.
3772 The following odd-index element is the overlay they came from.
3774 Before the buffer change, we fill in this vector
3775 as we call overlay hook functions.
3776 After the buffer change, we get the functions to call from this vector.
3777 This way we always call the same functions before and after the change. */
3778 static Lisp_Object last_overlay_modification_hooks
;
3780 /* Number of elements actually used in last_overlay_modification_hooks. */
3781 static int last_overlay_modification_hooks_used
;
3783 /* Add one functionlist/overlay pair
3784 to the end of last_overlay_modification_hooks. */
3787 add_overlay_mod_hooklist (functionlist
, overlay
)
3788 Lisp_Object functionlist
, overlay
;
3790 int oldsize
= XVECTOR (last_overlay_modification_hooks
)->size
;
3792 if (last_overlay_modification_hooks_used
== oldsize
)
3795 old
= last_overlay_modification_hooks
;
3796 last_overlay_modification_hooks
3797 = Fmake_vector (make_number (oldsize
* 2), Qnil
);
3798 bcopy (XVECTOR (old
)->contents
,
3799 XVECTOR (last_overlay_modification_hooks
)->contents
,
3800 sizeof (Lisp_Object
) * oldsize
);
3802 XVECTOR (last_overlay_modification_hooks
)->contents
[last_overlay_modification_hooks_used
++] = functionlist
;
3803 XVECTOR (last_overlay_modification_hooks
)->contents
[last_overlay_modification_hooks_used
++] = overlay
;
3806 /* Run the modification-hooks of overlays that include
3807 any part of the text in START to END.
3808 If this change is an insertion, also
3809 run the insert-before-hooks of overlay starting at END,
3810 and the insert-after-hooks of overlay ending at START.
3812 This is called both before and after the modification.
3813 AFTER is nonzero when we call after the modification.
3815 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
3816 When AFTER is nonzero, they are the start position,
3817 the position after the inserted new text,
3818 and the length of deleted or replaced old text. */
3821 report_overlay_modification (start
, end
, after
, arg1
, arg2
, arg3
)
3822 Lisp_Object start
, end
;
3824 Lisp_Object arg1
, arg2
, arg3
;
3826 Lisp_Object prop
, overlay
, tail
;
3827 /* 1 if this change is an insertion. */
3828 int insertion
= (after
? XFASTINT (arg3
) == 0 : EQ (start
, end
));
3830 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
3834 GCPRO5 (overlay
, tail
, arg1
, arg2
, arg3
);
3838 /* Call the functions recorded in last_overlay_modification_hooks
3839 rather than scanning the overlays again.
3840 First copy the vector contents, in case some of these hooks
3841 do subsequent modification of the buffer. */
3842 int size
= last_overlay_modification_hooks_used
;
3843 Lisp_Object
*copy
= (Lisp_Object
*) alloca (size
* sizeof (Lisp_Object
));
3846 bcopy (XVECTOR (last_overlay_modification_hooks
)->contents
,
3847 copy
, size
* sizeof (Lisp_Object
));
3849 gcpro1
.nvars
= size
;
3851 for (i
= 0; i
< size
;)
3853 Lisp_Object prop
, overlay
;
3855 overlay
= copy
[i
++];
3856 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3862 /* We are being called before a change.
3863 Scan the overlays to find the functions to call. */
3864 last_overlay_modification_hooks_used
= 0;
3866 for (tail
= current_buffer
->overlays_before
;
3870 int startpos
, endpos
;
3871 Lisp_Object ostart
, oend
;
3873 overlay
= XCAR (tail
);
3875 ostart
= OVERLAY_START (overlay
);
3876 oend
= OVERLAY_END (overlay
);
3877 endpos
= OVERLAY_POSITION (oend
);
3878 if (XFASTINT (start
) > endpos
)
3880 startpos
= OVERLAY_POSITION (ostart
);
3881 if (insertion
&& (XFASTINT (start
) == startpos
3882 || XFASTINT (end
) == startpos
))
3884 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
3887 /* Copy TAIL in case the hook recenters the overlay lists. */
3889 tail
= Fcopy_sequence (tail
);
3891 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3894 if (insertion
&& (XFASTINT (start
) == endpos
3895 || XFASTINT (end
) == endpos
))
3897 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
3901 tail
= Fcopy_sequence (tail
);
3903 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3906 /* Test for intersecting intervals. This does the right thing
3907 for both insertion and deletion. */
3908 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
3910 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
3914 tail
= Fcopy_sequence (tail
);
3916 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3922 for (tail
= current_buffer
->overlays_after
;
3926 int startpos
, endpos
;
3927 Lisp_Object ostart
, oend
;
3929 overlay
= XCAR (tail
);
3931 ostart
= OVERLAY_START (overlay
);
3932 oend
= OVERLAY_END (overlay
);
3933 startpos
= OVERLAY_POSITION (ostart
);
3934 endpos
= OVERLAY_POSITION (oend
);
3935 if (XFASTINT (end
) < startpos
)
3937 if (insertion
&& (XFASTINT (start
) == startpos
3938 || XFASTINT (end
) == startpos
))
3940 prop
= Foverlay_get (overlay
, Qinsert_in_front_hooks
);
3944 tail
= Fcopy_sequence (tail
);
3946 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3949 if (insertion
&& (XFASTINT (start
) == endpos
3950 || XFASTINT (end
) == endpos
))
3952 prop
= Foverlay_get (overlay
, Qinsert_behind_hooks
);
3956 tail
= Fcopy_sequence (tail
);
3958 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3961 /* Test for intersecting intervals. This does the right thing
3962 for both insertion and deletion. */
3963 if (XFASTINT (end
) > startpos
&& XFASTINT (start
) < endpos
)
3965 prop
= Foverlay_get (overlay
, Qmodification_hooks
);
3969 tail
= Fcopy_sequence (tail
);
3971 call_overlay_mod_hooks (prop
, overlay
, after
, arg1
, arg2
, arg3
);
3980 call_overlay_mod_hooks (list
, overlay
, after
, arg1
, arg2
, arg3
)
3981 Lisp_Object list
, overlay
;
3983 Lisp_Object arg1
, arg2
, arg3
;
3985 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3987 GCPRO4 (list
, arg1
, arg2
, arg3
);
3989 add_overlay_mod_hooklist (list
, overlay
);
3991 while (!NILP (list
))
3994 call4 (Fcar (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
);
3996 call5 (Fcar (list
), overlay
, after
? Qt
: Qnil
, arg1
, arg2
, arg3
);
4002 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4005 evaporate_overlays (pos
)
4008 Lisp_Object tail
, overlay
, hit_list
;
4011 if (pos
<= XFASTINT (current_buffer
->overlay_center
))
4012 for (tail
= current_buffer
->overlays_before
; CONSP (tail
);
4016 overlay
= XCAR (tail
);
4017 endpos
= OVERLAY_POSITION (OVERLAY_END (overlay
));
4020 if (endpos
== pos
&& OVERLAY_POSITION (OVERLAY_START (overlay
)) == pos
4021 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4022 hit_list
= Fcons (overlay
, hit_list
);
4025 for (tail
= current_buffer
->overlays_after
; CONSP (tail
);
4029 overlay
= XCAR (tail
);
4030 startpos
= OVERLAY_POSITION (OVERLAY_START (overlay
));
4033 if (startpos
== pos
&& OVERLAY_POSITION (OVERLAY_END (overlay
)) == pos
4034 && ! NILP (Foverlay_get (overlay
, Qevaporate
)))
4035 hit_list
= Fcons (overlay
, hit_list
);
4037 for (; CONSP (hit_list
); hit_list
= XCDR (hit_list
))
4038 Fdelete_overlay (XCAR (hit_list
));
4041 /* Somebody has tried to store a value with an unacceptable type
4042 in the slot with offset OFFSET. */
4045 buffer_slot_type_mismatch (offset
)
4051 switch (XINT (PER_BUFFER_TYPE (offset
)))
4054 type_name
= "integers";
4058 type_name
= "strings";
4062 type_name
= "symbols";
4069 sym
= PER_BUFFER_SYMBOL (offset
);
4070 error ("Only %s should be stored in the buffer-local variable %s",
4071 type_name
, XSYMBOL (sym
)->name
->data
);
4075 /***********************************************************************
4076 Allocation with mmap
4077 ***********************************************************************/
4079 #ifdef USE_MMAP_FOR_BUFFERS
4081 #include <sys/types.h>
4082 #include <sys/mman.h>
4085 #ifdef MAP_ANONYMOUS
4086 #define MAP_ANON MAP_ANONYMOUS
4093 #define MAP_FAILED ((void *) -1)
4106 /* Memory is allocated in regions which are mapped using mmap(2).
4107 The current implementation lets the system select mapped
4108 addresses; we're not using MAP_FIXED in general, except when
4109 trying to enlarge regions.
4111 Each mapped region starts with a mmap_region structure, the user
4112 area starts after that structure, aligned to MEM_ALIGN.
4114 +-----------------------+
4115 | struct mmap_info + |
4117 +-----------------------+
4121 +-----------------------+ */
4125 /* User-specified size. */
4126 size_t nbytes_specified
;
4128 /* Number of bytes mapped */
4129 size_t nbytes_mapped
;
4131 /* Pointer to the location holding the address of the memory
4132 allocated with the mmap'd block. The variable actually points
4133 after this structure. */
4136 /* Next and previous in list of all mmap'd regions. */
4137 struct mmap_region
*next
, *prev
;
4140 /* Doubly-linked list of mmap'd regions. */
4142 static struct mmap_region
*mmap_regions
;
4144 /* File descriptor for mmap. If we don't have anonymous mapping,
4145 /dev/zero will be opened on it. */
4149 /* Temporary storage for mmap_set_vars, see there. */
4151 static struct mmap_region
*mmap_regions_1
;
4152 static int mmap_fd_1
;
4154 /* Page size on this system. */
4156 static int mmap_page_size
;
4158 /* 1 means mmap has been intialized. */
4160 static int mmap_initialized_p
;
4162 /* Value is X rounded up to the next multiple of N. */
4164 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4166 /* Size of mmap_region structure plus padding. */
4168 #define MMAP_REGION_STRUCT_SIZE \
4169 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4171 /* Given a pointer P to the start of the user-visible part of a mapped
4172 region, return a pointer to the start of the region. */
4174 #define MMAP_REGION(P) \
4175 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4177 /* Given a pointer P to the start of a mapped region, return a pointer
4178 to the start of the user-visible part of the region. */
4180 #define MMAP_USER_AREA(P) \
4181 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4183 #define MEM_ALIGN sizeof (double)
4185 /* Function prototypes. */
4187 static int mmap_free_1
P_ ((struct mmap_region
*));
4188 static int mmap_enlarge
P_ ((struct mmap_region
*, int));
4189 static struct mmap_region
*mmap_find
P_ ((POINTER_TYPE
*, POINTER_TYPE
*));
4190 static POINTER_TYPE
*mmap_alloc
P_ ((POINTER_TYPE
**, size_t));
4191 static POINTER_TYPE
*mmap_realloc
P_ ((POINTER_TYPE
**, size_t));
4192 static void mmap_free
P_ ((POINTER_TYPE
**ptr
));
4193 static void mmap_init
P_ ((void));
4196 /* Return a region overlapping address range START...END, or null if
4197 none. END is not including, i.e. the last byte in the range
4200 static struct mmap_region
*
4201 mmap_find (start
, end
)
4202 POINTER_TYPE
*start
, *end
;
4204 struct mmap_region
*r
;
4205 char *s
= (char *) start
, *e
= (char *) end
;
4207 for (r
= mmap_regions
; r
; r
= r
->next
)
4209 char *rstart
= (char *) r
;
4210 char *rend
= rstart
+ r
->nbytes_mapped
;
4212 if (/* First byte of range, i.e. START, in this region? */
4213 (s
>= rstart
&& s
< rend
)
4214 /* Last byte of range, i.e. END - 1, in this region? */
4215 || (e
> rstart
&& e
<= rend
)
4216 /* First byte of this region in the range? */
4217 || (rstart
>= s
&& rstart
< e
)
4218 /* Last byte of this region in the range? */
4219 || (rend
> s
&& rend
<= e
))
4227 /* Unmap a region. P is a pointer to the start of the user-araa of
4228 the region. Value is non-zero if successful. */
4232 struct mmap_region
*r
;
4235 r
->next
->prev
= r
->prev
;
4237 r
->prev
->next
= r
->next
;
4239 mmap_regions
= r
->next
;
4241 if (munmap ((POINTER_TYPE
*) r
, r
->nbytes_mapped
) == -1)
4243 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4251 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4252 Value is non-zero if successful. */
4255 mmap_enlarge (r
, npages
)
4256 struct mmap_region
*r
;
4259 char *region_end
= (char *) r
+ r
->nbytes_mapped
;
4265 /* Unmap pages at the end of the region. */
4266 nbytes
= - npages
* mmap_page_size
;
4267 if (munmap (region_end
- nbytes
, nbytes
) == -1)
4268 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4271 r
->nbytes_mapped
-= nbytes
;
4275 else if (npages
> 0)
4277 struct mmap_region
*r2
;
4279 nbytes
= npages
* mmap_page_size
;
4281 /* Try to map additional pages at the end of the region. We
4282 cannot do this if the address range is already occupied by
4283 something else because mmap deletes any previous mapping.
4284 I'm not sure this is worth doing, let's see. */
4285 r2
= mmap_find (region_end
, region_end
+ nbytes
);
4290 p
= mmap (region_end
, nbytes
, PROT_READ
| PROT_WRITE
,
4291 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
, mmap_fd
, 0);
4292 if (p
== MAP_FAILED
)
4293 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4294 else if (p
!= (POINTER_TYPE
*) region_end
)
4296 /* Kernels are free to choose a different address. In
4297 that case, unmap what we've mapped above; we have
4299 if (munmap (p
, nbytes
) == -1)
4300 fprintf (stderr
, "munmap: %s\n", emacs_strerror (errno
));
4304 r
->nbytes_mapped
+= nbytes
;
4314 /* Set or reset variables holding references to mapped regions. If
4315 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4316 non-zero, set all variables to the start of the user-areas
4319 This function is called from Fdump_emacs to ensure that the dumped
4320 Emacs doesn't contain references to memory that won't be mapped
4321 when Emacs starts. */
4324 mmap_set_vars (restore_p
)
4327 struct mmap_region
*r
;
4331 mmap_regions
= mmap_regions_1
;
4332 mmap_fd
= mmap_fd_1
;
4333 for (r
= mmap_regions
; r
; r
= r
->next
)
4334 *r
->var
= MMAP_USER_AREA (r
);
4338 for (r
= mmap_regions
; r
; r
= r
->next
)
4340 mmap_regions_1
= mmap_regions
;
4341 mmap_regions
= NULL
;
4342 mmap_fd_1
= mmap_fd
;
4348 /* Allocate a block of storage large enough to hold NBYTES bytes of
4349 data. A pointer to the data is returned in *VAR. VAR is thus the
4350 address of some variable which will use the data area.
4352 The allocation of 0 bytes is valid.
4354 If we can't allocate the necessary memory, set *VAR to null, and
4357 static POINTER_TYPE
*
4358 mmap_alloc (var
, nbytes
)
4367 map
= ROUND (nbytes
+ MMAP_REGION_STRUCT_SIZE
, mmap_page_size
);
4368 p
= mmap (NULL
, map
, PROT_READ
| PROT_WRITE
, MAP_ANON
| MAP_PRIVATE
,
4371 if (p
== MAP_FAILED
)
4373 if (errno
!= ENOMEM
)
4374 fprintf (stderr
, "mmap: %s\n", emacs_strerror (errno
));
4379 struct mmap_region
*r
= (struct mmap_region
*) p
;
4381 r
->nbytes_specified
= nbytes
;
4382 r
->nbytes_mapped
= map
;
4385 r
->next
= mmap_regions
;
4390 p
= MMAP_USER_AREA (p
);
4397 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4398 resize it to size NBYTES. Change *VAR to reflect the new block,
4399 and return this value. If more memory cannot be allocated, then
4400 leave *VAR unchanged, and return null. */
4402 static POINTER_TYPE
*
4403 mmap_realloc (var
, nbytes
)
4407 POINTER_TYPE
*result
;
4412 result
= mmap_alloc (var
, nbytes
);
4413 else if (nbytes
== 0)
4416 result
= mmap_alloc (var
, nbytes
);
4420 struct mmap_region
*r
= MMAP_REGION (*var
);
4421 size_t room
= r
->nbytes_mapped
- MMAP_REGION_STRUCT_SIZE
;
4426 POINTER_TYPE
*old_ptr
= *var
;
4428 /* Try to map additional pages at the end of the region.
4429 If that fails, allocate a new region, copy data
4430 from the old region, then free it. */
4431 if (mmap_enlarge (r
, (ROUND (nbytes
- room
, mmap_page_size
)
4434 r
->nbytes_specified
= nbytes
;
4435 *var
= result
= old_ptr
;
4437 else if (mmap_alloc (var
, nbytes
))
4439 bcopy (old_ptr
, *var
, r
->nbytes_specified
);
4440 mmap_free_1 (MMAP_REGION (old_ptr
));
4442 r
= MMAP_REGION (result
);
4443 r
->nbytes_specified
= nbytes
;
4451 else if (room
- nbytes
>= mmap_page_size
)
4453 /* Shrinking by at least a page. Let's give some
4454 memory back to the system. */
4455 mmap_enlarge (r
, - (room
- nbytes
) / mmap_page_size
);
4457 r
->nbytes_specified
= nbytes
;
4461 /* Leave it alone. */
4463 r
->nbytes_specified
= nbytes
;
4471 /* Free a block of relocatable storage whose data is pointed to by
4472 PTR. Store 0 in *PTR to show there's no block allocated. */
4482 mmap_free_1 (MMAP_REGION (*var
));
4488 /* Perform necessary intializations for the use of mmap. */
4494 /* The value of mmap_fd is initially 0 in temacs, and -1
4495 in a dumped Emacs. */
4498 /* No anonymous mmap -- we need the file descriptor. */
4499 mmap_fd
= open ("/dev/zero", O_RDONLY
);
4501 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno
));
4503 #endif /* MAP_ANON == 0 */
4505 if (mmap_initialized_p
)
4507 mmap_initialized_p
= 1;
4513 mmap_page_size
= getpagesize ();
4516 #endif /* USE_MMAP_FOR_BUFFERS */
4520 /***********************************************************************
4521 Buffer-text Allocation
4522 ***********************************************************************/
4525 extern POINTER_TYPE
*r_alloc
P_ ((POINTER_TYPE
**, size_t));
4526 extern POINTER_TYPE
*r_re_alloc
P_ ((POINTER_TYPE
**, size_t));
4527 extern void r_alloc_free
P_ ((POINTER_TYPE
**ptr
));
4528 #endif /* REL_ALLOC */
4531 /* Allocate NBYTES bytes for buffer B's text buffer. */
4534 alloc_buffer_text (b
, nbytes
)
4541 #if defined USE_MMAP_FOR_BUFFERS
4542 p
= mmap_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4543 #elif defined REL_ALLOC
4544 p
= r_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4546 p
= xmalloc (nbytes
);
4555 b
->text
->beg
= (unsigned char *) p
;
4559 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4563 enlarge_buffer_text (b
, delta
)
4568 size_t nbytes
= (BUF_Z_BYTE (b
) - BUF_BEG_BYTE (b
) + BUF_GAP_SIZE (b
) + 1
4571 #if defined USE_MMAP_FOR_BUFFERS
4572 p
= mmap_realloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4573 #elif defined REL_ALLOC
4574 p
= r_re_alloc ((POINTER_TYPE
**) &b
->text
->beg
, nbytes
);
4576 p
= xrealloc (b
->text
->beg
, nbytes
);
4585 BUF_BEG_ADDR (b
) = (unsigned char *) p
;
4590 /* Free buffer B's text buffer. */
4593 free_buffer_text (b
)
4598 #if defined USE_MMAP_FOR_BUFFERS
4599 mmap_free ((POINTER_TYPE
**) &b
->text
->beg
);
4600 #elif defined REL_ALLOC
4601 r_alloc_free ((POINTER_TYPE
**) &b
->text
->beg
);
4603 xfree (b
->text
->beg
);
4606 BUF_BEG_ADDR (b
) = NULL
;
4612 /***********************************************************************
4614 ***********************************************************************/
4621 bzero (buffer_permanent_local_flags
, sizeof buffer_permanent_local_flags
);
4623 /* Make sure all markable slots in buffer_defaults
4624 are initialized reasonably, so mark_buffer won't choke. */
4625 reset_buffer (&buffer_defaults
);
4626 reset_buffer_local_variables (&buffer_defaults
, 1);
4627 reset_buffer (&buffer_local_symbols
);
4628 reset_buffer_local_variables (&buffer_local_symbols
, 1);
4629 /* Prevent GC from getting confused. */
4630 buffer_defaults
.text
= &buffer_defaults
.own_text
;
4631 buffer_local_symbols
.text
= &buffer_local_symbols
.own_text
;
4632 BUF_INTERVALS (&buffer_defaults
) = 0;
4633 BUF_INTERVALS (&buffer_local_symbols
) = 0;
4634 XSETBUFFER (Vbuffer_defaults
, &buffer_defaults
);
4635 XSETBUFFER (Vbuffer_local_symbols
, &buffer_local_symbols
);
4637 /* Set up the default values of various buffer slots. */
4638 /* Must do these before making the first buffer! */
4640 /* real setup is done in bindings.el */
4641 buffer_defaults
.mode_line_format
= build_string ("%-");
4642 buffer_defaults
.header_line_format
= Qnil
;
4643 buffer_defaults
.abbrev_mode
= Qnil
;
4644 buffer_defaults
.overwrite_mode
= Qnil
;
4645 buffer_defaults
.case_fold_search
= Qt
;
4646 buffer_defaults
.auto_fill_function
= Qnil
;
4647 buffer_defaults
.selective_display
= Qnil
;
4649 buffer_defaults
.selective_display_ellipses
= Qt
;
4651 buffer_defaults
.abbrev_table
= Qnil
;
4652 buffer_defaults
.display_table
= Qnil
;
4653 buffer_defaults
.undo_list
= Qnil
;
4654 buffer_defaults
.mark_active
= Qnil
;
4655 buffer_defaults
.file_format
= Qnil
;
4656 buffer_defaults
.overlays_before
= Qnil
;
4657 buffer_defaults
.overlays_after
= Qnil
;
4658 XSETFASTINT (buffer_defaults
.overlay_center
, BEG
);
4660 XSETFASTINT (buffer_defaults
.tab_width
, 8);
4661 buffer_defaults
.truncate_lines
= Qnil
;
4662 buffer_defaults
.ctl_arrow
= Qt
;
4663 buffer_defaults
.direction_reversed
= Qnil
;
4664 buffer_defaults
.cursor_type
= Qt
;
4665 buffer_defaults
.extra_line_spacing
= Qnil
;
4668 buffer_defaults
.buffer_file_type
= Qnil
; /* TEXT */
4670 buffer_defaults
.enable_multibyte_characters
= Qt
;
4671 buffer_defaults
.buffer_file_coding_system
= Qnil
;
4672 XSETFASTINT (buffer_defaults
.fill_column
, 70);
4673 XSETFASTINT (buffer_defaults
.left_margin
, 0);
4674 buffer_defaults
.cache_long_line_scans
= Qnil
;
4675 buffer_defaults
.file_truename
= Qnil
;
4676 XSETFASTINT (buffer_defaults
.display_count
, 0);
4677 buffer_defaults
.indicate_empty_lines
= Qnil
;
4678 buffer_defaults
.scroll_up_aggressively
= Qnil
;
4679 buffer_defaults
.scroll_down_aggressively
= Qnil
;
4680 buffer_defaults
.display_time
= Qnil
;
4682 /* Assign the local-flags to the slots that have default values.
4683 The local flag is a bit that is used in the buffer
4684 to say that it has its own local value for the slot.
4685 The local flag bits are in the local_var_flags slot of the buffer. */
4687 /* Nothing can work if this isn't true */
4688 if (sizeof (EMACS_INT
) != sizeof (Lisp_Object
)) abort ();
4690 /* 0 means not a lisp var, -1 means always local, else mask */
4691 bzero (&buffer_local_flags
, sizeof buffer_local_flags
);
4692 XSETINT (buffer_local_flags
.filename
, -1);
4693 XSETINT (buffer_local_flags
.directory
, -1);
4694 XSETINT (buffer_local_flags
.backed_up
, -1);
4695 XSETINT (buffer_local_flags
.save_length
, -1);
4696 XSETINT (buffer_local_flags
.auto_save_file_name
, -1);
4697 XSETINT (buffer_local_flags
.read_only
, -1);
4698 XSETINT (buffer_local_flags
.major_mode
, -1);
4699 XSETINT (buffer_local_flags
.mode_name
, -1);
4700 XSETINT (buffer_local_flags
.undo_list
, -1);
4701 XSETINT (buffer_local_flags
.mark_active
, -1);
4702 XSETINT (buffer_local_flags
.point_before_scroll
, -1);
4703 XSETINT (buffer_local_flags
.file_truename
, -1);
4704 XSETINT (buffer_local_flags
.invisibility_spec
, -1);
4705 XSETINT (buffer_local_flags
.file_format
, -1);
4706 XSETINT (buffer_local_flags
.display_count
, -1);
4707 XSETINT (buffer_local_flags
.display_time
, -1);
4708 XSETINT (buffer_local_flags
.enable_multibyte_characters
, -1);
4711 XSETFASTINT (buffer_local_flags
.mode_line_format
, idx
); ++idx
;
4712 XSETFASTINT (buffer_local_flags
.abbrev_mode
, idx
); ++idx
;
4713 XSETFASTINT (buffer_local_flags
.overwrite_mode
, idx
); ++idx
;
4714 XSETFASTINT (buffer_local_flags
.case_fold_search
, idx
); ++idx
;
4715 XSETFASTINT (buffer_local_flags
.auto_fill_function
, idx
); ++idx
;
4716 XSETFASTINT (buffer_local_flags
.selective_display
, idx
); ++idx
;
4718 XSETFASTINT (buffer_local_flags
.selective_display_ellipses
, idx
); ++idx
;
4720 XSETFASTINT (buffer_local_flags
.tab_width
, idx
); ++idx
;
4721 XSETFASTINT (buffer_local_flags
.truncate_lines
, idx
); ++idx
;
4722 XSETFASTINT (buffer_local_flags
.ctl_arrow
, idx
); ++idx
;
4723 XSETFASTINT (buffer_local_flags
.fill_column
, idx
); ++idx
;
4724 XSETFASTINT (buffer_local_flags
.left_margin
, idx
); ++idx
;
4725 XSETFASTINT (buffer_local_flags
.abbrev_table
, idx
); ++idx
;
4726 XSETFASTINT (buffer_local_flags
.display_table
, idx
); ++idx
;
4728 XSETFASTINT (buffer_local_flags
.buffer_file_type
, idx
);
4729 /* Make this one a permanent local. */
4730 buffer_permanent_local_flags
[idx
++] = 1;
4732 XSETFASTINT (buffer_local_flags
.syntax_table
, idx
); ++idx
;
4733 XSETFASTINT (buffer_local_flags
.cache_long_line_scans
, idx
); ++idx
;
4734 XSETFASTINT (buffer_local_flags
.category_table
, idx
); ++idx
;
4735 XSETFASTINT (buffer_local_flags
.direction_reversed
, idx
); ++idx
;
4736 XSETFASTINT (buffer_local_flags
.buffer_file_coding_system
, idx
);
4737 /* Make this one a permanent local. */
4738 buffer_permanent_local_flags
[idx
++] = 1;
4739 XSETFASTINT (buffer_local_flags
.left_margin_width
, idx
); ++idx
;
4740 XSETFASTINT (buffer_local_flags
.right_margin_width
, idx
); ++idx
;
4741 XSETFASTINT (buffer_local_flags
.indicate_empty_lines
, idx
); ++idx
;
4742 XSETFASTINT (buffer_local_flags
.scroll_up_aggressively
, idx
); ++idx
;
4743 XSETFASTINT (buffer_local_flags
.scroll_down_aggressively
, idx
); ++idx
;
4744 XSETFASTINT (buffer_local_flags
.header_line_format
, idx
); ++idx
;
4745 XSETFASTINT (buffer_local_flags
.cursor_type
, idx
); ++idx
;
4746 XSETFASTINT (buffer_local_flags
.extra_line_spacing
, idx
); ++idx
;
4748 /* Need more room? */
4749 if (idx
>= MAX_PER_BUFFER_VARS
)
4751 last_per_buffer_idx
= idx
;
4753 Vbuffer_alist
= Qnil
;
4757 QSFundamental
= build_string ("Fundamental");
4759 Qfundamental_mode
= intern ("fundamental-mode");
4760 buffer_defaults
.major_mode
= Qfundamental_mode
;
4762 Qmode_class
= intern ("mode-class");
4764 Qprotected_field
= intern ("protected-field");
4766 Qpermanent_local
= intern ("permanent-local");
4768 Qkill_buffer_hook
= intern ("kill-buffer-hook");
4770 Vprin1_to_string_buffer
= Fget_buffer_create (build_string (" prin1"));
4772 /* super-magic invisible buffer */
4773 Vbuffer_alist
= Qnil
;
4775 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
4777 inhibit_modification_hooks
= 0;
4783 char buf
[MAXPATHLEN
+ 1];
4785 struct stat dotstat
, pwdstat
;
4789 #ifdef USE_MMAP_FOR_BUFFERS
4791 /* When using the ralloc implementation based on mmap(2), buffer
4792 text pointers will have been set to null in the dumped Emacs.
4796 for (b
= all_buffers
; b
; b
= b
->next
)
4797 if (b
->text
->beg
== NULL
)
4798 enlarge_buffer_text (b
, 0);
4800 #endif /* USE_MMAP_FOR_BUFFERS */
4802 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
4803 if (NILP (buffer_defaults
.enable_multibyte_characters
))
4804 Fset_buffer_multibyte (Qnil
);
4806 /* If PWD is accurate, use it instead of calling getwd. This is faster
4807 when PWD is right, and may avoid a fatal error. */
4808 if ((pwd
= getenv ("PWD")) != 0
4809 && (IS_DIRECTORY_SEP (*pwd
) || (*pwd
&& IS_DEVICE_SEP (pwd
[1])))
4810 && stat (pwd
, &pwdstat
) == 0
4811 && stat (".", &dotstat
) == 0
4812 && dotstat
.st_ino
== pwdstat
.st_ino
4813 && dotstat
.st_dev
== pwdstat
.st_dev
4814 && strlen (pwd
) < MAXPATHLEN
)
4817 else if (getcwd (buf
, MAXPATHLEN
+1) == 0)
4818 fatal ("`getcwd' failed: %s\n", strerror (errno
));
4820 else if (getwd (buf
) == 0)
4821 fatal ("`getwd' failed: %s\n", buf
);
4825 /* Maybe this should really use some standard subroutine
4826 whose definition is filename syntax dependent. */
4828 if (!(IS_DIRECTORY_SEP (buf
[rc
- 1])))
4830 buf
[rc
] = DIRECTORY_SEP
;
4833 #endif /* not VMS */
4835 current_buffer
->directory
= build_string (buf
);
4837 /* Add /: to the front of the name
4838 if it would otherwise be treated as magic. */
4839 temp
= Ffind_file_name_handler (current_buffer
->directory
, Qt
);
4841 /* If the default dir is just /, TEMP is non-nil
4842 because of the ange-ftp completion handler.
4843 However, it is not necessary to turn / into /:/.
4844 So avoid doing that. */
4845 && strcmp ("/", XSTRING (current_buffer
->directory
)->data
))
4846 current_buffer
->directory
4847 = concat2 (build_string ("/:"), current_buffer
->directory
);
4849 temp
= get_minibuffer (0);
4850 XBUFFER (temp
)->directory
= current_buffer
->directory
;
4853 /* initialize the buffer routines */
4857 staticpro (&last_overlay_modification_hooks
);
4858 last_overlay_modification_hooks
4859 = Fmake_vector (make_number (10), Qnil
);
4861 staticpro (&Vbuffer_defaults
);
4862 staticpro (&Vbuffer_local_symbols
);
4863 staticpro (&Qfundamental_mode
);
4864 staticpro (&Qmode_class
);
4865 staticpro (&QSFundamental
);
4866 staticpro (&Vbuffer_alist
);
4867 staticpro (&Qprotected_field
);
4868 staticpro (&Qpermanent_local
);
4869 staticpro (&Qkill_buffer_hook
);
4870 Qoverlayp
= intern ("overlayp");
4871 staticpro (&Qoverlayp
);
4872 Qevaporate
= intern ("evaporate");
4873 staticpro (&Qevaporate
);
4874 Qmodification_hooks
= intern ("modification-hooks");
4875 staticpro (&Qmodification_hooks
);
4876 Qinsert_in_front_hooks
= intern ("insert-in-front-hooks");
4877 staticpro (&Qinsert_in_front_hooks
);
4878 Qinsert_behind_hooks
= intern ("insert-behind-hooks");
4879 staticpro (&Qinsert_behind_hooks
);
4880 Qget_file_buffer
= intern ("get-file-buffer");
4881 staticpro (&Qget_file_buffer
);
4882 Qpriority
= intern ("priority");
4883 staticpro (&Qpriority
);
4884 Qwindow
= intern ("window");
4885 staticpro (&Qwindow
);
4886 Qbefore_string
= intern ("before-string");
4887 staticpro (&Qbefore_string
);
4888 Qafter_string
= intern ("after-string");
4889 staticpro (&Qafter_string
);
4890 Qfirst_change_hook
= intern ("first-change-hook");
4891 staticpro (&Qfirst_change_hook
);
4892 Qbefore_change_functions
= intern ("before-change-functions");
4893 staticpro (&Qbefore_change_functions
);
4894 Qafter_change_functions
= intern ("after-change-functions");
4895 staticpro (&Qafter_change_functions
);
4897 Fput (Qprotected_field
, Qerror_conditions
,
4898 Fcons (Qprotected_field
, Fcons (Qerror
, Qnil
)));
4899 Fput (Qprotected_field
, Qerror_message
,
4900 build_string ("Attempt to modify a protected field"));
4902 /* All these use DEFVAR_LISP_NOPRO because the slots in
4903 buffer_defaults will all be marked via Vbuffer_defaults. */
4905 DEFVAR_LISP_NOPRO ("default-mode-line-format",
4906 &buffer_defaults
.mode_line_format
,
4907 "Default value of `mode-line-format' for buffers that don't override it.\n\
4908 This is the same as (default-value 'mode-line-format).");
4910 DEFVAR_LISP_NOPRO ("default-header-line-format",
4911 &buffer_defaults
.header_line_format
,
4912 "Default value of `header-line-format' for buffers that don't override it.\n\
4913 This is the same as (default-value 'header-line-format).");
4915 DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults
.cursor_type
,
4916 "Default value of `cursor-type' for buffers that don't override it.\n\
4917 This is the same as (default-value 'cursor-type).");
4919 DEFVAR_LISP_NOPRO ("default-line-spacing",
4920 &buffer_defaults
.extra_line_spacing
,
4921 "Default value of `line-spacing' for buffers that don't override it.\n\
4922 This is the same as (default-value 'line-spacing).");
4924 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
4925 &buffer_defaults
.abbrev_mode
,
4926 "Default value of `abbrev-mode' for buffers that do not override it.\n\
4927 This is the same as (default-value 'abbrev-mode).");
4929 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
4930 &buffer_defaults
.ctl_arrow
,
4931 "Default value of `ctl-arrow' for buffers that do not override it.\n\
4932 This is the same as (default-value 'ctl-arrow).");
4934 DEFVAR_LISP_NOPRO ("default-direction-reversed",
4935 &buffer_defaults
.direction_reversed
,
4936 "Default value of `direction_reversed' for buffers that do not override it.\n\
4937 This is the same as (default-value 'direction-reversed).");
4939 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
4940 &buffer_defaults
.enable_multibyte_characters
,
4941 "*Default value of `enable-multibyte-characters' for buffers not overriding it.\n\
4942 This is the same as (default-value 'enable-multibyte-characters).");
4944 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
4945 &buffer_defaults
.buffer_file_coding_system
,
4946 "Default value of `buffer-file-coding-system' for buffers not overriding it.\n\
4947 This is the same as (default-value 'buffer-file-coding-system).");
4949 DEFVAR_LISP_NOPRO ("default-truncate-lines",
4950 &buffer_defaults
.truncate_lines
,
4951 "Default value of `truncate-lines' for buffers that do not override it.\n\
4952 This is the same as (default-value 'truncate-lines).");
4954 DEFVAR_LISP_NOPRO ("default-fill-column",
4955 &buffer_defaults
.fill_column
,
4956 "Default value of `fill-column' for buffers that do not override it.\n\
4957 This is the same as (default-value 'fill-column).");
4959 DEFVAR_LISP_NOPRO ("default-left-margin",
4960 &buffer_defaults
.left_margin
,
4961 "Default value of `left-margin' for buffers that do not override it.\n\
4962 This is the same as (default-value 'left-margin).");
4964 DEFVAR_LISP_NOPRO ("default-tab-width",
4965 &buffer_defaults
.tab_width
,
4966 "Default value of `tab-width' for buffers that do not override it.\n\
4967 This is the same as (default-value 'tab-width).");
4969 DEFVAR_LISP_NOPRO ("default-case-fold-search",
4970 &buffer_defaults
.case_fold_search
,
4971 "Default value of `case-fold-search' for buffers that don't override it.\n\
4972 This is the same as (default-value 'case-fold-search).");
4975 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
4976 &buffer_defaults
.buffer_file_type
,
4977 "Default file type for buffers that do not override it.\n\
4978 This is the same as (default-value 'buffer-file-type).\n\
4979 The file type is nil for text, t for binary.");
4982 DEFVAR_LISP_NOPRO ("default-left-margin-width",
4983 &buffer_defaults
.left_margin_width
,
4984 "Default value of `left-margin-width' for buffers that don't override it.\n\
4985 This is the same as (default-value 'left-margin-width).");
4987 DEFVAR_LISP_NOPRO ("default-right-margin-width",
4988 &buffer_defaults
.right_margin_width
,
4989 "Default value of `right_margin_width' for buffers that don't override it.\n\
4990 This is the same as (default-value 'right-margin-width).");
4992 DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
4993 &buffer_defaults
.indicate_empty_lines
,
4994 "Default value of `indicate-empty-lines' for buffers that don't override it.\n\
4995 This is the same as (default-value 'indicate-empty-lines).");
4997 DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
4998 &buffer_defaults
.scroll_up_aggressively
,
4999 "Default value of `scroll-up-aggressively' for buffers that\n\
5000 don't override it. This is the same as (default-value\n\
5001 'scroll-up-aggressively).");
5003 DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
5004 &buffer_defaults
.scroll_down_aggressively
,
5005 "Default value of `scroll-down-aggressively' for buffers that\n\
5006 don't override it. This is the same as (default-value\n\
5007 'scroll-down-aggressively).");
5009 DEFVAR_PER_BUFFER ("header-line-format",
5010 ¤t_buffer
->header_line_format
,
5012 "Analogous to `mode-line-format', but for a mode line displayed\n\
5013 at the top of windows.");
5015 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer
->mode_line_format
,
5018 /* This doc string is too long for cpp; cpp dies if it isn't in a comment.
5019 But make-docfile finds it!
5020 DEFVAR_PER_BUFFER ("mode-line-format", ¤t_buffer->mode_line_format,
5022 "Template for displaying mode line for current buffer.\n\
5023 Each buffer has its own value of this variable.\n\
5024 Value may be nil, a string, a symbol or a list or cons cell.\n\
5025 A value of nil means don't display a mode line.\n\
5026 For a symbol, its value is used (but it is ignored if t or nil).\n\
5027 A string appearing directly as the value of a symbol is processed verbatim\n\
5028 in that the %-constructs below are not recognized.\n\
5029 For a list of the form `(:eval FORM)', FORM is evaluated and the result\n\
5030 is used as a mode line element.\n\
5031 For a list whose car is a symbol, the symbol's value is taken,\n\
5032 and if that is non-nil, the cadr of the list is processed recursively.\n\
5033 Otherwise, the caddr of the list (if there is one) is processed.\n\
5034 For a list whose car is a string or list, each element is processed\n\
5035 recursively and the results are effectively concatenated.\n\
5036 For a list whose car is an integer, the cdr of the list is processed\n\
5037 and padded (if the number is positive) or truncated (if negative)\n\
5038 to the width specified by that number.\n\
5039 A string is printed verbatim in the mode line except for %-constructs:\n\
5040 (%-constructs are allowed when the string is the entire mode-line-format\n\
5041 or when it is found in a cons-cell or a list)\n\
5042 %b -- print buffer name. %f -- print visited file name.\n\
5043 %F -- print frame name.\n\
5044 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.\n\
5045 %& is like %*, but ignore read-only-ness.\n\
5046 % means buffer is read-only and * means it is modified.\n\
5047 For a modified read-only buffer, %* gives % and %+ gives *.\n\
5048 %s -- print process status. %l -- print the current line number.\n\
5049 %c -- print the current column number (this makes editing slower).\n\
5050 To make the column number update correctly in all cases,\n\
5051 `column-number-mode' must be non-nil.\n\
5052 %p -- print percent of buffer above top of window, or Top, Bot or All.\n\
5053 %P -- print percent of buffer above bottom of window, perhaps plus Top,\n\
5054 or print Bottom or All.\n\
5055 %m -- print the mode name.\n\
5056 %n -- print Narrow if appropriate.\n\
5057 %z -- print mnemonics of buffer, terminal, and keyboard coding systems.\n\
5058 %Z -- like %z, but including the end-of-line format.\n\
5059 %[ -- print one [ for each recursive editing level. %] similar.\n\
5060 %% -- print %. %- -- print infinitely many dashes.\n\
5061 Decimal digits after the % specify field width to which to pad.");
5064 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults
.major_mode
,
5065 "*Major mode for new buffers. Defaults to `fundamental-mode'.\n\
5066 nil here means use current buffer's major mode.");
5068 DEFVAR_PER_BUFFER ("major-mode", ¤t_buffer
->major_mode
,
5069 make_number (Lisp_Symbol
),
5070 "Symbol for current buffer's major mode.");
5072 DEFVAR_PER_BUFFER ("mode-name", ¤t_buffer
->mode_name
,
5073 make_number (Lisp_String
),
5074 "Pretty name of current buffer's major mode (a string).");
5076 DEFVAR_PER_BUFFER ("abbrev-mode", ¤t_buffer
->abbrev_mode
, Qnil
,
5077 "Non-nil turns on automatic expansion of abbrevs as they are inserted.\n\
5078 Automatically becomes buffer-local when set in any fashion.");
5080 DEFVAR_PER_BUFFER ("case-fold-search", ¤t_buffer
->case_fold_search
,
5082 "*Non-nil if searches and matches should ignore case.\n\
5083 Automatically becomes buffer-local when set in any fashion.");
5085 DEFVAR_PER_BUFFER ("fill-column", ¤t_buffer
->fill_column
,
5086 make_number (Lisp_Int
),
5087 "*Column beyond which automatic line-wrapping should happen.\n\
5088 Automatically becomes buffer-local when set in any fashion.");
5090 DEFVAR_PER_BUFFER ("left-margin", ¤t_buffer
->left_margin
,
5091 make_number (Lisp_Int
),
5092 "*Column for the default indent-line-function to indent to.\n\
5093 Linefeed indents to this column in Fundamental mode.\n\
5094 Automatically becomes buffer-local when set in any fashion.");
5096 DEFVAR_PER_BUFFER ("tab-width", ¤t_buffer
->tab_width
,
5097 make_number (Lisp_Int
),
5098 "*Distance between tab stops (for display of tab characters), in columns.\n\
5099 Automatically becomes buffer-local when set in any fashion.");
5101 DEFVAR_PER_BUFFER ("ctl-arrow", ¤t_buffer
->ctl_arrow
, Qnil
,
5102 "*Non-nil means display control chars with uparrow.\n\
5103 A value of nil means use backslash and octal digits.\n\
5104 Automatically becomes buffer-local when set in any fashion.\n\
5105 This variable does not apply to characters whose display is specified\n\
5106 in the current display table (if there is one).");
5108 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5109 ¤t_buffer
->enable_multibyte_characters
,
5111 "Non-nil means the buffer contents are regarded as multi-byte characters.\n\
5112 Otherwise they are regarded as unibyte. This affects the display,\n\
5113 file I/O and the behavior of various editing commands.\n\
5115 This variable is buffer-local but you cannot set it directly;\n\
5116 use the function `set-buffer-multibyte' to change a buffer's representation.\n\
5117 Changing its default value with `setq-default' is supported.\n\
5118 See also variable `default-enable-multibyte-characters' and Info node\n\
5119 `(elisp)Text Representations'.");
5121 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5122 ¤t_buffer
->buffer_file_coding_system
, Qnil
,
5123 "Coding system to be used for encoding the buffer contents on saving.\n\
5124 This variable applies to saving the buffer, and also to `write-region'\n\
5125 and other functions that use `write-region'.\n\
5126 It does not apply to sending output to subprocesses, however.\n\
5128 If this is nil, the buffer is saved without any code conversion\n\
5129 unless some coding system is specified in `file-coding-system-alist'\n\
5130 for the buffer file.\n\
5132 The variable `coding-system-for-write', if non-nil, overrides this variable.\n\
5134 This variable is never applied to a way of decoding\n\
5135 a file while reading it.");
5137 DEFVAR_PER_BUFFER ("direction-reversed", ¤t_buffer
->direction_reversed
,
5139 "*Non-nil means lines in the buffer are displayed right to left.");
5141 DEFVAR_PER_BUFFER ("truncate-lines", ¤t_buffer
->truncate_lines
, Qnil
,
5142 "*Non-nil means do not display continuation lines;\n\
5143 give each line of text one screen line.\n\
5144 Automatically becomes buffer-local when set in any fashion.\n\
5146 Note that this is overridden by the variable\n\
5147 `truncate-partial-width-windows' if that variable is non-nil\n\
5148 and this buffer is not full-frame width.");
5151 DEFVAR_PER_BUFFER ("buffer-file-type", ¤t_buffer
->buffer_file_type
,
5153 "Non-nil if the visited file is a binary file.\n\
5154 This variable is meaningful on MS-DOG and Windows NT.\n\
5155 On those systems, it is automatically local in every buffer.\n\
5156 On other systems, this variable is normally always nil.");
5159 DEFVAR_PER_BUFFER ("default-directory", ¤t_buffer
->directory
,
5160 make_number (Lisp_String
),
5161 "Name of default directory of current buffer. Should end with slash.\n\
5162 Each buffer has its own value of this variable.");
5164 DEFVAR_PER_BUFFER ("auto-fill-function", ¤t_buffer
->auto_fill_function
,
5166 "Function called (if non-nil) to perform auto-fill.\n\
5167 It is called after self-inserting any character specified in\n\
5168 the `auto-fill-chars' table.\n\
5169 Each buffer has its own value of this variable.\n\
5170 NOTE: This variable is not a hook;\n\
5171 its value may not be a list of functions.");
5173 DEFVAR_PER_BUFFER ("buffer-file-name", ¤t_buffer
->filename
,
5174 make_number (Lisp_String
),
5175 "Name of file visited in current buffer, or nil if not visiting a file.\n\
5176 Each buffer has its own value of this variable.");
5178 DEFVAR_PER_BUFFER ("buffer-file-truename", ¤t_buffer
->file_truename
,
5179 make_number (Lisp_String
),
5180 "Abbreviated truename of file visited in current buffer, or nil if none.\n\
5181 The truename of a file is calculated by `file-truename'\n\
5182 and then abbreviated with `abbreviate-file-name'.\n\
5183 Each buffer has its own value of this variable.");
5185 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5186 ¤t_buffer
->auto_save_file_name
,
5187 make_number (Lisp_String
),
5188 "Name of file for auto-saving current buffer,\n\
5189 or nil if buffer should not be auto-saved.\n\
5190 Each buffer has its own value of this variable.");
5192 DEFVAR_PER_BUFFER ("buffer-read-only", ¤t_buffer
->read_only
, Qnil
,
5193 "Non-nil if this buffer is read-only.\n\
5194 Each buffer has its own value of this variable.");
5196 DEFVAR_PER_BUFFER ("buffer-backed-up", ¤t_buffer
->backed_up
, Qnil
,
5197 "Non-nil if this buffer's file has been backed up.\n\
5198 Backing up is done before the first time the file is saved.\n\
5199 Each buffer has its own value of this variable.");
5201 DEFVAR_PER_BUFFER ("buffer-saved-size", ¤t_buffer
->save_length
,
5202 make_number (Lisp_Int
),
5203 "Length of current buffer when last read in, saved or auto-saved.\n\
5205 Each buffer has its own value of this variable.");
5207 DEFVAR_PER_BUFFER ("selective-display", ¤t_buffer
->selective_display
,
5209 "Non-nil enables selective display:\n\
5210 Integer N as value means display only lines\n\
5211 that start with less than n columns of space.\n\
5212 A value of t means, after a ^M, all the rest of the line is invisible.\n\
5213 Then ^M's in the file are written into files as newlines.\n\n\
5214 Automatically becomes buffer-local when set in any fashion.");
5217 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5218 ¤t_buffer
->selective_display_ellipses
,
5220 "t means display ... on previous line when a line is invisible.\n\
5221 Automatically becomes buffer-local when set in any fashion.");
5224 DEFVAR_PER_BUFFER ("overwrite-mode", ¤t_buffer
->overwrite_mode
, Qnil
,
5225 "Non-nil if self-insertion should replace existing text.\n\
5226 The value should be one of `overwrite-mode-textual',\n\
5227 `overwrite-mode-binary', or nil.\n\
5228 If it is `overwrite-mode-textual', self-insertion still\n\
5229 inserts at the end of a line, and inserts when point is before a tab,\n\
5230 until the tab is filled in.\n\
5231 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.\n\
5232 Automatically becomes buffer-local when set in any fashion.");
5234 #if 0 /* The doc string is too long for some compilers,
5235 but make-docfile can find it in this comment. */
5236 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
5238 "Display table that controls display of the contents of current buffer.\n\
5239 Automatically becomes buffer-local when set in any fashion.\n\
5240 The display table is a char-table created with `make-display-table'.\n\
5241 The ordinary char-table elements control how to display each possible text\n\
5242 character. Each value should be a vector of characters or nil;\n\
5243 nil means display the character in the default fashion.\n\
5244 There are six extra slots to control the display of\n\
5245 the end of a truncated screen line (extra-slot 0, a single character);\n\
5246 the end of a continued line (extra-slot 1, a single character);\n\
5247 the escape character used to display character codes in octal\n\
5248 (extra-slot 2, a single character);\n\
5249 the character used as an arrow for control characters (extra-slot 3,\n\
5250 a single character);\n\
5251 the decoration indicating the presence of invisible lines (extra-slot 4,\n\
5252 a vector of characters);\n\
5253 the character used to draw the border between side-by-side windows\n\
5254 (extra-slot 5, a single character).\n\
5255 See also the functions `display-table-slot' and `set-display-table-slot'.\n\
5256 If this variable is nil, the value of `standard-display-table' is used.\n\
5257 Each window can have its own, overriding display table.");
5259 DEFVAR_PER_BUFFER ("buffer-display-table", ¤t_buffer
->display_table
,
5262 DEFVAR_PER_BUFFER ("left-margin-width", ¤t_buffer
->left_margin_width
,
5264 "*Width of left marginal area for display of a buffer.\n\
5265 Automatically becomes buffer-local when set in any fashion.\n\
5266 A value of nil means no marginal area.");
5268 DEFVAR_PER_BUFFER ("right-margin-width", ¤t_buffer
->right_margin_width
,
5270 "*Width of right marginal area for display of a buffer.\n\
5271 Automatically becomes buffer-local when set in any fashion.\n\
5272 A value of nil means no marginal area.");
5274 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5275 ¤t_buffer
->indicate_empty_lines
, Qnil
,
5276 "*Visually indicate empty lines after the buffer end.\n\
5277 If non-nil, a bitmap is displayed in the left fringe of a window on\n\
5279 Automatically becomes buffer-local when set in any fashion.\n");
5281 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5282 ¤t_buffer
->scroll_up_aggressively
, Qnil
,
5283 "*If a number, scroll display up aggressively.\n\
5284 If scrolling a window because point is above the window start, choose\n\
5285 a new window start so that point ends up that fraction of the window's\n\
5286 height from the top of the window.\n\
5287 Automatically becomes buffer-local when set in any fashion.");
5289 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
5290 ¤t_buffer
->scroll_down_aggressively
, Qnil
,
5291 "*If a number, scroll display down aggressively.\n\
5292 If scrolling a window because point is below the window end, choose\n\
5293 a new window start so that point ends up that fraction of the window's\n\
5294 height from the bottom of the window.\n\
5295 Automatically becomes buffer-local when set in any fashion.");
5297 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
5301 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions
,
5302 "List of functions to call before each text change.\n\
5303 Two arguments are passed to each function: the positions of\n\
5304 the beginning and end of the range of old text to be changed.\n\
5305 \(For an insertion, the beginning and end are at the same place.)\n\
5306 No information is given about the length of the text after the change.\n\
5308 Buffer changes made while executing the `before-change-functions'\n\
5309 don't call any before-change or after-change functions.\n\
5310 That's because these variables are temporarily set to nil.\n\
5311 As a result, a hook function cannot straightforwardly alter the value of\n\
5312 these variables. See the Emacs Lisp manual for a way of\n\
5313 accomplishing an equivalent result by using other variables.\n\
5315 If an unhandled error happens in running these functions,\n\
5316 the variable's value remains nil. That prevents the error\n\
5317 from happening repeatedly and making Emacs nonfunctional.");
5318 Vbefore_change_functions
= Qnil
;
5320 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions
,
5321 "List of function to call after each text change.\n\
5322 Three arguments are passed to each function: the positions of\n\
5323 the beginning and end of the range of changed text,\n\
5324 and the length in bytes of the pre-change text replaced by that range.\n\
5325 \(For an insertion, the pre-change length is zero;\n\
5326 for a deletion, that length is the number of bytes deleted,\n\
5327 and the post-change beginning and end are at the same place.)\n\
5329 Buffer changes made while executing the `after-change-functions'\n\
5330 don't call any before-change or after-change functions.\n\
5331 That's because these variables are temporarily set to nil.\n\
5332 As a result, a hook function cannot straightforwardly alter the value of\n\
5333 these variables. See the Emacs Lisp manual for a way of\n\
5334 accomplishing an equivalent result by using other variables.\n\
5336 If an unhandled error happens in running these functions,\n\
5337 the variable's value remains nil. That prevents the error\n\
5338 from happening repeatedly and making Emacs nonfunctional.");
5339 Vafter_change_functions
= Qnil
;
5341 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook
,
5342 "A list of functions to call before changing a buffer which is unmodified.\n\
5343 The functions are run using the `run-hooks' function.");
5344 Vfirst_change_hook
= Qnil
;
5346 #if 0 /* The doc string is too long for some compilers,
5347 but make-docfile can find it in this comment. */
5348 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
5349 "List of undo entries in current buffer.\n\
5350 This variable is always local in all buffers.\n\
5351 Recent changes come first; older changes follow newer.\n\
5353 An entry (BEG . END) represents an insertion which begins at\n\
5354 position BEG and ends at position END.\n\
5356 An entry (TEXT . POSITION) represents the deletion of the string TEXT\n\
5357 from (abs POSITION). If POSITION is positive, point was at the front\n\
5358 of the text being deleted; if negative, point was at the end.\n\
5360 An entry (t HIGH . LOW) indicates that the buffer previously had\n\
5361 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions\n\
5362 of the visited file's modification time, as of that time. If the\n\
5363 modification time of the most recent save is different, this entry is\n\
5366 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property\n\
5367 was modified between BEG and END. PROPERTY is the property name,\n\
5368 and VALUE is the old value.\n\
5370 An entry (MARKER . DISTANCE) indicates that the marker MARKER\n\
5371 was adjusted in position by the offset DISTANCE (an integer).\n\
5373 An entry of the form POSITION indicates that point was at the buffer\n\
5374 location given by the integer. Undoing an entry of this form places\n\
5375 point at POSITION.\n\
5377 nil marks undo boundaries. The undo command treats the changes\n\
5378 between two undo boundaries as a single step to be undone.\n\
5380 If the value of the variable is t, undo information is not recorded.");
5382 DEFVAR_PER_BUFFER ("buffer-undo-list", ¤t_buffer
->undo_list
, Qnil
,
5385 DEFVAR_PER_BUFFER ("mark-active", ¤t_buffer
->mark_active
, Qnil
,
5386 "Non-nil means the mark and region are currently active in this buffer.\n\
5387 Automatically local in all buffers.");
5389 DEFVAR_PER_BUFFER ("cache-long-line-scans", ¤t_buffer
->cache_long_line_scans
, Qnil
,
5390 "Non-nil means that Emacs should use caches to handle long lines more quickly.\n\
5391 This variable is buffer-local, in all buffers.\n\
5393 Normally, the line-motion functions work by scanning the buffer for\n\
5394 newlines. Columnar operations (like move-to-column and\n\
5395 compute-motion) also work by scanning the buffer, summing character\n\
5396 widths as they go. This works well for ordinary text, but if the\n\
5397 buffer's lines are very long (say, more than 500 characters), these\n\
5398 motion functions will take longer to execute. Emacs may also take\n\
5399 longer to update the display.\n\
5401 If cache-long-line-scans is non-nil, these motion functions cache the\n\
5402 results of their scans, and consult the cache to avoid rescanning\n\
5403 regions of the buffer until the text is modified. The caches are most\n\
5404 beneficial when they prevent the most searching---that is, when the\n\
5405 buffer contains long lines and large regions of characters with the\n\
5406 same, fixed screen width.\n\
5408 When cache-long-line-scans is non-nil, processing short lines will\n\
5409 become slightly slower (because of the overhead of consulting the\n\
5410 cache), and the caches will use memory roughly proportional to the\n\
5411 number of newlines and characters whose screen width varies.\n\
5413 The caches require no explicit maintenance; their accuracy is\n\
5414 maintained internally by the Emacs primitives. Enabling or disabling\n\
5415 the cache should not affect the behavior of any of the motion\n\
5416 functions; it should only affect their performance.");
5418 DEFVAR_PER_BUFFER ("point-before-scroll", ¤t_buffer
->point_before_scroll
, Qnil
,
5419 "Value of point before the last series of scroll operations, or nil.\n\
5420 This variable is always local in all buffers.");
5422 DEFVAR_PER_BUFFER ("buffer-file-format", ¤t_buffer
->file_format
, Qnil
,
5423 "List of formats to use when saving this buffer.\n\
5424 This variable is always local in all buffers.\n\
5425 Formats are defined by `format-alist'. This variable is\n\
5426 set when a file is visited. Automatically local in all buffers.");
5428 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
5429 ¤t_buffer
->invisibility_spec
, Qnil
,
5430 "Invisibility spec of this buffer.\n\
5431 This variable is always local in all buffers.\n\
5432 The default is t, which means that text is invisible\n\
5433 if it has a non-nil `invisible' property.\n\
5434 If the value is a list, a text character is invisible if its `invisible'\n\
5435 property is an element in that list.\n\
5436 If an element is a cons cell of the form (PROP . ELLIPSIS),\n\
5437 then characters with property value PROP are invisible,\n\
5438 and they have an ellipsis as well if ELLIPSIS is non-nil.");
5440 DEFVAR_PER_BUFFER ("buffer-display-count",
5441 ¤t_buffer
->display_count
, Qnil
,
5442 "A number incremented each time this buffer is displayed in a window.\n\
5443 This variable is always local in all buffers.\n\
5444 The function `set-window-buffer increments it.");
5446 DEFVAR_PER_BUFFER ("buffer-display-time",
5447 ¤t_buffer
->display_time
, Qnil
,
5448 "Time stamp updated each time this buffer is displayed in a window.\n\
5449 This variable is always local in all buffers.\n\
5450 The function `set-window-buffer' updates this variable\n\
5451 to the value obtained by calling `current-time'.\n\
5452 If the buffer has never been shown in a window, the value is nil.");
5454 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode
,
5455 "*Non-nil means deactivate the mark when the buffer contents change.\n\
5456 Non-nil also enables highlighting of the region whenever the mark is active.\n\
5457 The variable `highlight-nonselected-windows' controls whether to highlight\n\
5458 all windows or just the selected window.");
5459 Vtransient_mark_mode
= Qnil
;
5461 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only
,
5462 "*Non-nil means disregard read-only status of buffers or characters.\n\
5463 If the value is t, disregard `buffer-read-only' and all `read-only'\n\
5464 text properties. If the value is a list, disregard `buffer-read-only'\n\
5465 and disregard a `read-only' text property if the property value\n\
5466 is a member of the list.");
5467 Vinhibit_read_only
= Qnil
;
5469 DEFVAR_PER_BUFFER ("cursor-type", ¤t_buffer
->cursor_type
, Qnil
,
5470 "Cursor to use in window displaying this buffer.\n\
5471 Values are interpreted as follows:\n\
5473 t use the cursor specified for the frame\n\
5474 nil don't display a cursor\n\
5475 `bar' display a bar cursor with default width\n\
5476 (bar . WIDTH) display a bar cursor with width WIDTH\n\
5477 others display a box cursor.");
5479 DEFVAR_PER_BUFFER ("line-spacing",
5480 ¤t_buffer
->extra_line_spacing
, Qnil
,
5481 "Additional space to put between lines when displaying a buffer.\n\
5482 The space is measured in pixels, and put below lines on window systems.");
5484 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions
,
5485 "List of functions called with no args to query before killing a buffer.");
5486 Vkill_buffer_query_functions
= Qnil
;
5488 defsubr (&Sbuffer_live_p
);
5489 defsubr (&Sbuffer_list
);
5490 defsubr (&Sget_buffer
);
5491 defsubr (&Sget_file_buffer
);
5492 defsubr (&Sget_buffer_create
);
5493 defsubr (&Smake_indirect_buffer
);
5494 defsubr (&Sgenerate_new_buffer_name
);
5495 defsubr (&Sbuffer_name
);
5496 /*defsubr (&Sbuffer_number);*/
5497 defsubr (&Sbuffer_file_name
);
5498 defsubr (&Sbuffer_base_buffer
);
5499 defsubr (&Sbuffer_local_variables
);
5500 defsubr (&Sbuffer_modified_p
);
5501 defsubr (&Sset_buffer_modified_p
);
5502 defsubr (&Sbuffer_modified_tick
);
5503 defsubr (&Srename_buffer
);
5504 defsubr (&Sother_buffer
);
5505 defsubr (&Sbuffer_disable_undo
);
5506 defsubr (&Sbuffer_enable_undo
);
5507 defsubr (&Skill_buffer
);
5508 defsubr (&Sset_buffer_major_mode
);
5509 defsubr (&Sswitch_to_buffer
);
5510 defsubr (&Spop_to_buffer
);
5511 defsubr (&Scurrent_buffer
);
5512 defsubr (&Sset_buffer
);
5513 defsubr (&Sbarf_if_buffer_read_only
);
5514 defsubr (&Sbury_buffer
);
5515 defsubr (&Serase_buffer
);
5516 defsubr (&Sset_buffer_multibyte
);
5517 defsubr (&Skill_all_local_variables
);
5519 defsubr (&Soverlayp
);
5520 defsubr (&Smake_overlay
);
5521 defsubr (&Sdelete_overlay
);
5522 defsubr (&Smove_overlay
);
5523 defsubr (&Soverlay_start
);
5524 defsubr (&Soverlay_end
);
5525 defsubr (&Soverlay_buffer
);
5526 defsubr (&Soverlay_properties
);
5527 defsubr (&Soverlays_at
);
5528 defsubr (&Soverlays_in
);
5529 defsubr (&Snext_overlay_change
);
5530 defsubr (&Sprevious_overlay_change
);
5531 defsubr (&Soverlay_recenter
);
5532 defsubr (&Soverlay_lists
);
5533 defsubr (&Soverlay_get
);
5534 defsubr (&Soverlay_put
);
5535 defsubr (&Srestore_buffer_modified_p
);
5541 initial_define_key (control_x_map
, 'b', "switch-to-buffer");
5542 initial_define_key (control_x_map
, 'k', "kill-buffer");
5544 /* This must not be in syms_of_buffer, because Qdisabled is not
5545 initialized when that function gets called. */
5546 Fput (intern ("erase-buffer"), Qdisabled
, Qt
);