Minor EBADF fixes.
[emacs.git] / src / buffer.c
blob81768849a4b4d8fb17ff184175e7ecce8dcb0985
1 /* Buffer manipulation primitives for GNU Emacs.
3 Copyright (C) 1985-1989, 1993-1995, 1997-2013 Free Software Foundation,
4 Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 #include <config.h>
23 #define BUFFER_INLINE EXTERN_INLINE
25 #include <sys/types.h>
26 #include <sys/stat.h>
27 #include <sys/param.h>
28 #include <errno.h>
29 #include <stdio.h>
30 #include <unistd.h>
32 #include <verify.h>
34 #include "lisp.h"
35 #include "intervals.h"
36 #include "window.h"
37 #include "commands.h"
38 #include "character.h"
39 #include "buffer.h"
40 #include "region-cache.h"
41 #include "indent.h"
42 #include "blockinput.h"
43 #include "keyboard.h"
44 #include "keymap.h"
45 #include "frame.h"
47 struct buffer *current_buffer; /* The current buffer. */
49 /* First buffer in chain of all buffers (in reverse order of creation).
50 Threaded through ->header.next.buffer. */
52 struct buffer *all_buffers;
54 /* This structure holds the default values of the buffer-local variables
55 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
56 The default value occupies the same slot in this structure
57 as an individual buffer's value occupies in that buffer.
58 Setting the default value also goes through the alist of buffers
59 and stores into each buffer that does not say it has a local value. */
61 struct buffer alignas (GCALIGNMENT) buffer_defaults;
63 /* This structure marks which slots in a buffer have corresponding
64 default values in buffer_defaults.
65 Each such slot has a nonzero value in this structure.
66 The value has only one nonzero bit.
68 When a buffer has its own local value for a slot,
69 the entry for that slot (found in the same slot in this structure)
70 is turned on in the buffer's local_flags array.
72 If a slot in this structure is -1, then even though there may
73 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
74 and the corresponding slot in buffer_defaults is not used.
76 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
77 zero, that is a bug. */
79 struct buffer buffer_local_flags;
81 /* This structure holds the names of symbols whose values may be
82 buffer-local. It is indexed and accessed in the same way as the above. */
84 struct buffer alignas (GCALIGNMENT) buffer_local_symbols;
86 /* Return the symbol of the per-buffer variable at offset OFFSET in
87 the buffer structure. */
89 #define PER_BUFFER_SYMBOL(OFFSET) \
90 (*(Lisp_Object *)((OFFSET) + (char *) &buffer_local_symbols))
92 /* Maximum length of an overlay vector. */
93 #define OVERLAY_COUNT_MAX \
94 ((ptrdiff_t) min (MOST_POSITIVE_FIXNUM, \
95 min (PTRDIFF_MAX, SIZE_MAX) / word_size))
97 /* Flags indicating which built-in buffer-local variables
98 are permanent locals. */
99 static char buffer_permanent_local_flags[MAX_PER_BUFFER_VARS];
101 /* Number of per-buffer variables used. */
103 int last_per_buffer_idx;
105 static void call_overlay_mod_hooks (Lisp_Object list, Lisp_Object overlay,
106 bool after, Lisp_Object arg1,
107 Lisp_Object arg2, Lisp_Object arg3);
108 static void swap_out_buffer_local_variables (struct buffer *b);
109 static void reset_buffer_local_variables (struct buffer *, bool);
111 /* Alist of all buffer names vs the buffers. */
112 /* This used to be a variable, but is no longer,
113 to prevent lossage due to user rplac'ing this alist or its elements. */
114 Lisp_Object Vbuffer_alist;
116 static Lisp_Object Qkill_buffer_query_functions;
118 /* Hook run before changing a major mode. */
119 static Lisp_Object Qchange_major_mode_hook;
121 Lisp_Object Qfirst_change_hook;
122 Lisp_Object Qbefore_change_functions;
123 Lisp_Object Qafter_change_functions;
125 static Lisp_Object Qfundamental_mode, Qmode_class, Qpermanent_local;
126 static Lisp_Object Qpermanent_local_hook;
128 static Lisp_Object Qprotected_field;
130 static Lisp_Object QSFundamental; /* A string "Fundamental". */
132 static Lisp_Object Qkill_buffer_hook;
133 static Lisp_Object Qbuffer_list_update_hook;
135 static Lisp_Object Qget_file_buffer;
137 static Lisp_Object Qoverlayp;
139 Lisp_Object Qpriority, Qbefore_string, Qafter_string;
141 static Lisp_Object Qevaporate;
143 Lisp_Object Qmodification_hooks;
144 Lisp_Object Qinsert_in_front_hooks;
145 Lisp_Object Qinsert_behind_hooks;
147 static void alloc_buffer_text (struct buffer *, ptrdiff_t);
148 static void free_buffer_text (struct buffer *b);
149 static struct Lisp_Overlay * copy_overlays (struct buffer *, struct Lisp_Overlay *);
150 static void modify_overlay (struct buffer *, ptrdiff_t, ptrdiff_t);
151 static Lisp_Object buffer_lisp_local_variables (struct buffer *, bool);
153 static void
154 CHECK_OVERLAY (Lisp_Object x)
156 CHECK_TYPE (OVERLAYP (x), Qoverlayp, x);
159 /* These setters are used only in this file, so they can be private. */
160 static void
161 bset_abbrev_mode (struct buffer *b, Lisp_Object val)
163 b->INTERNAL_FIELD (abbrev_mode) = val;
165 static void
166 bset_abbrev_table (struct buffer *b, Lisp_Object val)
168 b->INTERNAL_FIELD (abbrev_table) = val;
170 static void
171 bset_auto_fill_function (struct buffer *b, Lisp_Object val)
173 b->INTERNAL_FIELD (auto_fill_function) = val;
175 static void
176 bset_auto_save_file_format (struct buffer *b, Lisp_Object val)
178 b->INTERNAL_FIELD (auto_save_file_format) = val;
180 static void
181 bset_auto_save_file_name (struct buffer *b, Lisp_Object val)
183 b->INTERNAL_FIELD (auto_save_file_name) = val;
185 static void
186 bset_backed_up (struct buffer *b, Lisp_Object val)
188 b->INTERNAL_FIELD (backed_up) = val;
190 static void
191 bset_begv_marker (struct buffer *b, Lisp_Object val)
193 b->INTERNAL_FIELD (begv_marker) = val;
195 static void
196 bset_bidi_display_reordering (struct buffer *b, Lisp_Object val)
198 b->INTERNAL_FIELD (bidi_display_reordering) = val;
200 static void
201 bset_buffer_file_coding_system (struct buffer *b, Lisp_Object val)
203 b->INTERNAL_FIELD (buffer_file_coding_system) = val;
205 static void
206 bset_cache_long_line_scans (struct buffer *b, Lisp_Object val)
208 b->INTERNAL_FIELD (cache_long_line_scans) = val;
210 static void
211 bset_case_fold_search (struct buffer *b, Lisp_Object val)
213 b->INTERNAL_FIELD (case_fold_search) = val;
215 static void
216 bset_ctl_arrow (struct buffer *b, Lisp_Object val)
218 b->INTERNAL_FIELD (ctl_arrow) = val;
220 static void
221 bset_cursor_in_non_selected_windows (struct buffer *b, Lisp_Object val)
223 b->INTERNAL_FIELD (cursor_in_non_selected_windows) = val;
225 static void
226 bset_cursor_type (struct buffer *b, Lisp_Object val)
228 b->INTERNAL_FIELD (cursor_type) = val;
230 static void
231 bset_display_table (struct buffer *b, Lisp_Object val)
233 b->INTERNAL_FIELD (display_table) = val;
235 static void
236 bset_extra_line_spacing (struct buffer *b, Lisp_Object val)
238 b->INTERNAL_FIELD (extra_line_spacing) = val;
240 static void
241 bset_file_format (struct buffer *b, Lisp_Object val)
243 b->INTERNAL_FIELD (file_format) = val;
245 static void
246 bset_file_truename (struct buffer *b, Lisp_Object val)
248 b->INTERNAL_FIELD (file_truename) = val;
250 static void
251 bset_fringe_cursor_alist (struct buffer *b, Lisp_Object val)
253 b->INTERNAL_FIELD (fringe_cursor_alist) = val;
255 static void
256 bset_fringe_indicator_alist (struct buffer *b, Lisp_Object val)
258 b->INTERNAL_FIELD (fringe_indicator_alist) = val;
260 static void
261 bset_fringes_outside_margins (struct buffer *b, Lisp_Object val)
263 b->INTERNAL_FIELD (fringes_outside_margins) = val;
265 static void
266 bset_header_line_format (struct buffer *b, Lisp_Object val)
268 b->INTERNAL_FIELD (header_line_format) = val;
270 static void
271 bset_indicate_buffer_boundaries (struct buffer *b, Lisp_Object val)
273 b->INTERNAL_FIELD (indicate_buffer_boundaries) = val;
275 static void
276 bset_indicate_empty_lines (struct buffer *b, Lisp_Object val)
278 b->INTERNAL_FIELD (indicate_empty_lines) = val;
280 static void
281 bset_invisibility_spec (struct buffer *b, Lisp_Object val)
283 b->INTERNAL_FIELD (invisibility_spec) = val;
285 static void
286 bset_left_fringe_width (struct buffer *b, Lisp_Object val)
288 b->INTERNAL_FIELD (left_fringe_width) = val;
290 static void
291 bset_major_mode (struct buffer *b, Lisp_Object val)
293 b->INTERNAL_FIELD (major_mode) = val;
295 static void
296 bset_mark (struct buffer *b, Lisp_Object val)
298 b->INTERNAL_FIELD (mark) = val;
300 static void
301 bset_minor_modes (struct buffer *b, Lisp_Object val)
303 b->INTERNAL_FIELD (minor_modes) = val;
305 static void
306 bset_mode_line_format (struct buffer *b, Lisp_Object val)
308 b->INTERNAL_FIELD (mode_line_format) = val;
310 static void
311 bset_mode_name (struct buffer *b, Lisp_Object val)
313 b->INTERNAL_FIELD (mode_name) = val;
315 static void
316 bset_name (struct buffer *b, Lisp_Object val)
318 b->INTERNAL_FIELD (name) = val;
320 static void
321 bset_overwrite_mode (struct buffer *b, Lisp_Object val)
323 b->INTERNAL_FIELD (overwrite_mode) = val;
325 static void
326 bset_pt_marker (struct buffer *b, Lisp_Object val)
328 b->INTERNAL_FIELD (pt_marker) = val;
330 static void
331 bset_right_fringe_width (struct buffer *b, Lisp_Object val)
333 b->INTERNAL_FIELD (right_fringe_width) = val;
335 static void
336 bset_save_length (struct buffer *b, Lisp_Object val)
338 b->INTERNAL_FIELD (save_length) = val;
340 static void
341 bset_scroll_bar_width (struct buffer *b, Lisp_Object val)
343 b->INTERNAL_FIELD (scroll_bar_width) = val;
345 static void
346 bset_scroll_down_aggressively (struct buffer *b, Lisp_Object val)
348 b->INTERNAL_FIELD (scroll_down_aggressively) = val;
350 static void
351 bset_scroll_up_aggressively (struct buffer *b, Lisp_Object val)
353 b->INTERNAL_FIELD (scroll_up_aggressively) = val;
355 static void
356 bset_selective_display (struct buffer *b, Lisp_Object val)
358 b->INTERNAL_FIELD (selective_display) = val;
360 static void
361 bset_selective_display_ellipses (struct buffer *b, Lisp_Object val)
363 b->INTERNAL_FIELD (selective_display_ellipses) = val;
365 static void
366 bset_vertical_scroll_bar_type (struct buffer *b, Lisp_Object val)
368 b->INTERNAL_FIELD (vertical_scroll_bar_type) = val;
370 static void
371 bset_word_wrap (struct buffer *b, Lisp_Object val)
373 b->INTERNAL_FIELD (word_wrap) = val;
375 static void
376 bset_zv_marker (struct buffer *b, Lisp_Object val)
378 b->INTERNAL_FIELD (zv_marker) = val;
381 void
382 nsberror (Lisp_Object spec)
384 if (STRINGP (spec))
385 error ("No buffer named %s", SDATA (spec));
386 error ("Invalid buffer argument");
389 DEFUN ("buffer-live-p", Fbuffer_live_p, Sbuffer_live_p, 1, 1, 0,
390 doc: /* Return non-nil if OBJECT is a buffer which has not been killed.
391 Value is nil if OBJECT is not a buffer or if it has been killed. */)
392 (Lisp_Object object)
394 return ((BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object)))
395 ? Qt : Qnil);
398 DEFUN ("buffer-list", Fbuffer_list, Sbuffer_list, 0, 1, 0,
399 doc: /* Return a list of all existing live buffers.
400 If the optional arg FRAME is a frame, we return the buffer list in the
401 proper order for that frame: the buffers show in FRAME come first,
402 followed by the rest of the buffers. */)
403 (Lisp_Object frame)
405 Lisp_Object general;
406 general = Fmapcar (Qcdr, Vbuffer_alist);
408 if (FRAMEP (frame))
410 Lisp_Object framelist, prevlist, tail;
411 Lisp_Object args[3];
413 framelist = Fcopy_sequence (XFRAME (frame)->buffer_list);
414 prevlist = Fnreverse (Fcopy_sequence
415 (XFRAME (frame)->buried_buffer_list));
417 /* Remove from GENERAL any buffer that duplicates one in
418 FRAMELIST or PREVLIST. */
419 tail = framelist;
420 while (CONSP (tail))
422 general = Fdelq (XCAR (tail), general);
423 tail = XCDR (tail);
425 tail = prevlist;
426 while (CONSP (tail))
428 general = Fdelq (XCAR (tail), general);
429 tail = XCDR (tail);
432 args[0] = framelist;
433 args[1] = general;
434 args[2] = prevlist;
435 return Fnconc (3, args);
437 else
438 return general;
441 /* Like Fassoc, but use Fstring_equal to compare
442 (which ignores text properties),
443 and don't ever QUIT. */
445 static Lisp_Object
446 assoc_ignore_text_properties (register Lisp_Object key, Lisp_Object list)
448 register Lisp_Object tail;
449 for (tail = list; CONSP (tail); tail = XCDR (tail))
451 register Lisp_Object elt, tem;
452 elt = XCAR (tail);
453 tem = Fstring_equal (Fcar (elt), key);
454 if (!NILP (tem))
455 return elt;
457 return Qnil;
460 DEFUN ("get-buffer", Fget_buffer, Sget_buffer, 1, 1, 0,
461 doc: /* Return the buffer named BUFFER-OR-NAME.
462 BUFFER-OR-NAME must be either a string or a buffer. If BUFFER-OR-NAME
463 is a string and there is no buffer with that name, return nil. If
464 BUFFER-OR-NAME is a buffer, return it as given. */)
465 (register Lisp_Object buffer_or_name)
467 if (BUFFERP (buffer_or_name))
468 return buffer_or_name;
469 CHECK_STRING (buffer_or_name);
471 return Fcdr (assoc_ignore_text_properties (buffer_or_name, Vbuffer_alist));
474 DEFUN ("get-file-buffer", Fget_file_buffer, Sget_file_buffer, 1, 1, 0,
475 doc: /* Return the buffer visiting file FILENAME (a string).
476 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
477 If there is no such live buffer, return nil.
478 See also `find-buffer-visiting'. */)
479 (register Lisp_Object filename)
481 register Lisp_Object tail, buf, tem;
482 Lisp_Object handler;
484 CHECK_STRING (filename);
485 filename = Fexpand_file_name (filename, Qnil);
487 /* If the file name has special constructs in it,
488 call the corresponding file handler. */
489 handler = Ffind_file_name_handler (filename, Qget_file_buffer);
490 if (!NILP (handler))
492 Lisp_Object handled_buf = call2 (handler, Qget_file_buffer,
493 filename);
494 return BUFFERP (handled_buf) ? handled_buf : Qnil;
497 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
499 buf = Fcdr (XCAR (tail));
500 if (!BUFFERP (buf)) continue;
501 if (!STRINGP (BVAR (XBUFFER (buf), filename))) continue;
502 tem = Fstring_equal (BVAR (XBUFFER (buf), filename), filename);
503 if (!NILP (tem))
504 return buf;
506 return Qnil;
509 Lisp_Object
510 get_truename_buffer (register Lisp_Object filename)
512 register Lisp_Object tail, buf, tem;
514 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
516 buf = Fcdr (XCAR (tail));
517 if (!BUFFERP (buf)) continue;
518 if (!STRINGP (BVAR (XBUFFER (buf), file_truename))) continue;
519 tem = Fstring_equal (BVAR (XBUFFER (buf), file_truename), filename);
520 if (!NILP (tem))
521 return buf;
523 return Qnil;
526 DEFUN ("get-buffer-create", Fget_buffer_create, Sget_buffer_create, 1, 1, 0,
527 doc: /* Return the buffer specified by BUFFER-OR-NAME, creating a new one if needed.
528 If BUFFER-OR-NAME is a string and a live buffer with that name exists,
529 return that buffer. If no such buffer exists, create a new buffer with
530 that name and return it. If BUFFER-OR-NAME starts with a space, the new
531 buffer does not keep undo information.
533 If BUFFER-OR-NAME is a buffer instead of a string, return it as given,
534 even if it is dead. The return value is never nil. */)
535 (register Lisp_Object buffer_or_name)
537 register Lisp_Object buffer, name;
538 register struct buffer *b;
540 buffer = Fget_buffer (buffer_or_name);
541 if (!NILP (buffer))
542 return buffer;
544 if (SCHARS (buffer_or_name) == 0)
545 error ("Empty string for buffer name is not allowed");
547 b = allocate_buffer ();
549 /* An ordinary buffer uses its own struct buffer_text. */
550 b->text = &b->own_text;
551 b->base_buffer = NULL;
552 /* No one shares the text with us now. */
553 b->indirections = 0;
554 /* No one shows us now. */
555 b->window_count = 0;
557 BUF_GAP_SIZE (b) = 20;
558 block_input ();
559 /* We allocate extra 1-byte at the tail and keep it always '\0' for
560 anchoring a search. */
561 alloc_buffer_text (b, BUF_GAP_SIZE (b) + 1);
562 unblock_input ();
563 if (! BUF_BEG_ADDR (b))
564 buffer_memory_full (BUF_GAP_SIZE (b) + 1);
566 b->pt = BEG;
567 b->begv = BEG;
568 b->zv = BEG;
569 b->pt_byte = BEG_BYTE;
570 b->begv_byte = BEG_BYTE;
571 b->zv_byte = BEG_BYTE;
573 BUF_GPT (b) = BEG;
574 BUF_GPT_BYTE (b) = BEG_BYTE;
576 BUF_Z (b) = BEG;
577 BUF_Z_BYTE (b) = BEG_BYTE;
578 BUF_MODIFF (b) = 1;
579 BUF_CHARS_MODIFF (b) = 1;
580 BUF_OVERLAY_MODIFF (b) = 1;
581 BUF_SAVE_MODIFF (b) = 1;
582 BUF_COMPACT (b) = 1;
583 set_buffer_intervals (b, NULL);
584 BUF_UNCHANGED_MODIFIED (b) = 1;
585 BUF_OVERLAY_UNCHANGED_MODIFIED (b) = 1;
586 BUF_END_UNCHANGED (b) = 0;
587 BUF_BEG_UNCHANGED (b) = 0;
588 *(BUF_GPT_ADDR (b)) = *(BUF_Z_ADDR (b)) = 0; /* Put an anchor '\0'. */
589 b->text->inhibit_shrinking = 0;
591 b->newline_cache = 0;
592 b->width_run_cache = 0;
593 bset_width_table (b, Qnil);
594 b->prevent_redisplay_optimizations_p = 1;
596 /* An ordinary buffer normally doesn't need markers
597 to handle BEGV and ZV. */
598 bset_pt_marker (b, Qnil);
599 bset_begv_marker (b, Qnil);
600 bset_zv_marker (b, Qnil);
602 name = Fcopy_sequence (buffer_or_name);
603 set_string_intervals (name, NULL);
604 bset_name (b, name);
606 bset_undo_list (b, SREF (name, 0) != ' ' ? Qnil : Qt);
608 reset_buffer (b);
609 reset_buffer_local_variables (b, 1);
611 bset_mark (b, Fmake_marker ());
612 BUF_MARKERS (b) = NULL;
614 /* Put this in the alist of all live buffers. */
615 XSETBUFFER (buffer, b);
616 Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (Fcons (name, buffer), Qnil));
617 /* And run buffer-list-update-hook. */
618 if (!NILP (Vrun_hooks))
619 call1 (Vrun_hooks, Qbuffer_list_update_hook);
621 return buffer;
625 /* Return a list of overlays which is a copy of the overlay list
626 LIST, but for buffer B. */
628 static struct Lisp_Overlay *
629 copy_overlays (struct buffer *b, struct Lisp_Overlay *list)
631 struct Lisp_Overlay *result = NULL, *tail = NULL;
633 for (; list; list = list->next)
635 Lisp_Object overlay, start, end;
636 struct Lisp_Marker *m;
638 eassert (MARKERP (list->start));
639 m = XMARKER (list->start);
640 start = build_marker (b, m->charpos, m->bytepos);
641 XMARKER (start)->insertion_type = m->insertion_type;
643 eassert (MARKERP (list->end));
644 m = XMARKER (list->end);
645 end = build_marker (b, m->charpos, m->bytepos);
646 XMARKER (end)->insertion_type = m->insertion_type;
648 overlay = build_overlay (start, end, Fcopy_sequence (list->plist));
649 if (tail)
650 tail = tail->next = XOVERLAY (overlay);
651 else
652 result = tail = XOVERLAY (overlay);
655 return result;
658 /* Set an appropriate overlay of B. */
660 static void
661 set_buffer_overlays_before (struct buffer *b, struct Lisp_Overlay *o)
663 b->overlays_before = o;
666 static void
667 set_buffer_overlays_after (struct buffer *b, struct Lisp_Overlay *o)
669 b->overlays_after = o;
672 /* Clone per-buffer values of buffer FROM.
674 Buffer TO gets the same per-buffer values as FROM, with the
675 following exceptions: (1) TO's name is left untouched, (2) markers
676 are copied and made to refer to TO, and (3) overlay lists are
677 copied. */
679 static void
680 clone_per_buffer_values (struct buffer *from, struct buffer *to)
682 int offset;
684 FOR_EACH_PER_BUFFER_OBJECT_AT (offset)
686 Lisp_Object obj;
688 /* Don't touch the `name' which should be unique for every buffer. */
689 if (offset == PER_BUFFER_VAR_OFFSET (name))
690 continue;
692 obj = per_buffer_value (from, offset);
693 if (MARKERP (obj) && XMARKER (obj)->buffer == from)
695 struct Lisp_Marker *m = XMARKER (obj);
697 obj = build_marker (to, m->charpos, m->bytepos);
698 XMARKER (obj)->insertion_type = m->insertion_type;
701 set_per_buffer_value (to, offset, obj);
704 memcpy (to->local_flags, from->local_flags, sizeof to->local_flags);
706 set_buffer_overlays_before (to, copy_overlays (to, from->overlays_before));
707 set_buffer_overlays_after (to, copy_overlays (to, from->overlays_after));
709 /* Get (a copy of) the alist of Lisp-level local variables of FROM
710 and install that in TO. */
711 bset_local_var_alist (to, buffer_lisp_local_variables (from, 1));
715 /* If buffer B has markers to record PT, BEGV and ZV when it is not
716 current, update these markers. */
718 static void
719 record_buffer_markers (struct buffer *b)
721 if (! NILP (BVAR (b, pt_marker)))
723 Lisp_Object buffer;
725 eassert (!NILP (BVAR (b, begv_marker)));
726 eassert (!NILP (BVAR (b, zv_marker)));
728 XSETBUFFER (buffer, b);
729 set_marker_both (BVAR (b, pt_marker), buffer, b->pt, b->pt_byte);
730 set_marker_both (BVAR (b, begv_marker), buffer, b->begv, b->begv_byte);
731 set_marker_both (BVAR (b, zv_marker), buffer, b->zv, b->zv_byte);
736 /* If buffer B has markers to record PT, BEGV and ZV when it is not
737 current, fetch these values into B->begv etc. */
739 static void
740 fetch_buffer_markers (struct buffer *b)
742 if (! NILP (BVAR (b, pt_marker)))
744 Lisp_Object m;
746 eassert (!NILP (BVAR (b, begv_marker)));
747 eassert (!NILP (BVAR (b, zv_marker)));
749 m = BVAR (b, pt_marker);
750 SET_BUF_PT_BOTH (b, marker_position (m), marker_byte_position (m));
752 m = BVAR (b, begv_marker);
753 SET_BUF_BEGV_BOTH (b, marker_position (m), marker_byte_position (m));
755 m = BVAR (b, zv_marker);
756 SET_BUF_ZV_BOTH (b, marker_position (m), marker_byte_position (m));
761 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer, Smake_indirect_buffer,
762 2, 3,
763 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
764 doc: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
765 BASE-BUFFER should be a live buffer, or the name of an existing buffer.
766 NAME should be a string which is not the name of an existing buffer.
767 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
768 such as major and minor modes, in the indirect buffer.
769 CLONE nil means the indirect buffer's state is reset to default values. */)
770 (Lisp_Object base_buffer, Lisp_Object name, Lisp_Object clone)
772 Lisp_Object buf, tem;
773 struct buffer *b;
775 CHECK_STRING (name);
776 buf = Fget_buffer (name);
777 if (!NILP (buf))
778 error ("Buffer name `%s' is in use", SDATA (name));
780 tem = base_buffer;
781 base_buffer = Fget_buffer (base_buffer);
782 if (NILP (base_buffer))
783 error ("No such buffer: `%s'", SDATA (tem));
784 if (!BUFFER_LIVE_P (XBUFFER (base_buffer)))
785 error ("Base buffer has been killed");
787 if (SCHARS (name) == 0)
788 error ("Empty string for buffer name is not allowed");
790 b = allocate_buffer ();
792 /* No double indirection - if base buffer is indirect,
793 new buffer becomes an indirect to base's base. */
794 b->base_buffer = (XBUFFER (base_buffer)->base_buffer
795 ? XBUFFER (base_buffer)->base_buffer
796 : XBUFFER (base_buffer));
798 /* Use the base buffer's text object. */
799 b->text = b->base_buffer->text;
800 /* We have no own text. */
801 b->indirections = -1;
802 /* Notify base buffer that we share the text now. */
803 b->base_buffer->indirections++;
804 /* Always -1 for an indirect buffer. */
805 b->window_count = -1;
807 b->pt = b->base_buffer->pt;
808 b->begv = b->base_buffer->begv;
809 b->zv = b->base_buffer->zv;
810 b->pt_byte = b->base_buffer->pt_byte;
811 b->begv_byte = b->base_buffer->begv_byte;
812 b->zv_byte = b->base_buffer->zv_byte;
814 b->newline_cache = 0;
815 b->width_run_cache = 0;
816 bset_width_table (b, Qnil);
818 name = Fcopy_sequence (name);
819 set_string_intervals (name, NULL);
820 bset_name (b, name);
822 reset_buffer (b);
823 reset_buffer_local_variables (b, 1);
825 /* Put this in the alist of all live buffers. */
826 XSETBUFFER (buf, b);
827 Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (Fcons (name, buf), Qnil));
829 bset_mark (b, Fmake_marker ());
831 /* The multibyte status belongs to the base buffer. */
832 bset_enable_multibyte_characters
833 (b, BVAR (b->base_buffer, enable_multibyte_characters));
835 /* Make sure the base buffer has markers for its narrowing. */
836 if (NILP (BVAR (b->base_buffer, pt_marker)))
838 eassert (NILP (BVAR (b->base_buffer, begv_marker)));
839 eassert (NILP (BVAR (b->base_buffer, zv_marker)));
841 bset_pt_marker (b->base_buffer,
842 build_marker (b->base_buffer, b->base_buffer->pt,
843 b->base_buffer->pt_byte));
845 bset_begv_marker (b->base_buffer,
846 build_marker (b->base_buffer, b->base_buffer->begv,
847 b->base_buffer->begv_byte));
849 bset_zv_marker (b->base_buffer,
850 build_marker (b->base_buffer, b->base_buffer->zv,
851 b->base_buffer->zv_byte));
853 XMARKER (BVAR (b->base_buffer, zv_marker))->insertion_type = 1;
856 if (NILP (clone))
858 /* Give the indirect buffer markers for its narrowing. */
859 bset_pt_marker (b, build_marker (b, b->pt, b->pt_byte));
860 bset_begv_marker (b, build_marker (b, b->begv, b->begv_byte));
861 bset_zv_marker (b, build_marker (b, b->zv, b->zv_byte));
862 XMARKER (BVAR (b, zv_marker))->insertion_type = 1;
864 else
866 struct buffer *old_b = current_buffer;
868 clone_per_buffer_values (b->base_buffer, b);
869 bset_filename (b, Qnil);
870 bset_file_truename (b, Qnil);
871 bset_display_count (b, make_number (0));
872 bset_backed_up (b, Qnil);
873 bset_auto_save_file_name (b, Qnil);
874 set_buffer_internal_1 (b);
875 Fset (intern ("buffer-save-without-query"), Qnil);
876 Fset (intern ("buffer-file-number"), Qnil);
877 Fset (intern ("buffer-stale-function"), Qnil);
878 set_buffer_internal_1 (old_b);
881 /* Run buffer-list-update-hook. */
882 if (!NILP (Vrun_hooks))
883 call1 (Vrun_hooks, Qbuffer_list_update_hook);
885 return buf;
888 /* Mark OV as no longer associated with B. */
890 static void
891 drop_overlay (struct buffer *b, struct Lisp_Overlay *ov)
893 eassert (b == XBUFFER (Fmarker_buffer (ov->start)));
894 modify_overlay (b, marker_position (ov->start),
895 marker_position (ov->end));
896 Fset_marker (ov->start, Qnil, Qnil);
897 Fset_marker (ov->end, Qnil, Qnil);
901 /* Delete all overlays of B and reset it's overlay lists. */
903 void
904 delete_all_overlays (struct buffer *b)
906 struct Lisp_Overlay *ov, *next;
908 /* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
909 markers, we have an unneeded O(N^2) behavior here. */
910 for (ov = b->overlays_before; ov; ov = next)
912 drop_overlay (b, ov);
913 next = ov->next;
914 ov->next = NULL;
917 for (ov = b->overlays_after; ov; ov = next)
919 drop_overlay (b, ov);
920 next = ov->next;
921 ov->next = NULL;
924 set_buffer_overlays_before (b, NULL);
925 set_buffer_overlays_after (b, NULL);
928 /* Reinitialize everything about a buffer except its name and contents
929 and local variables.
930 If called on an already-initialized buffer, the list of overlays
931 should be deleted before calling this function, otherwise we end up
932 with overlays that claim to belong to the buffer but the buffer
933 claims it doesn't belong to it. */
935 void
936 reset_buffer (register struct buffer *b)
938 bset_filename (b, Qnil);
939 bset_file_truename (b, Qnil);
940 bset_directory (b, current_buffer ? BVAR (current_buffer, directory) : Qnil);
941 b->modtime = make_emacs_time (0, UNKNOWN_MODTIME_NSECS);
942 b->modtime_size = -1;
943 XSETFASTINT (BVAR (b, save_length), 0);
944 b->last_window_start = 1;
945 /* It is more conservative to start out "changed" than "unchanged". */
946 b->clip_changed = 0;
947 b->prevent_redisplay_optimizations_p = 1;
948 bset_backed_up (b, Qnil);
949 BUF_AUTOSAVE_MODIFF (b) = 0;
950 b->auto_save_failure_time = 0;
951 bset_auto_save_file_name (b, Qnil);
952 bset_read_only (b, Qnil);
953 set_buffer_overlays_before (b, NULL);
954 set_buffer_overlays_after (b, NULL);
955 b->overlay_center = BEG;
956 bset_mark_active (b, Qnil);
957 bset_point_before_scroll (b, Qnil);
958 bset_file_format (b, Qnil);
959 bset_auto_save_file_format (b, Qt);
960 bset_last_selected_window (b, Qnil);
961 bset_display_count (b, make_number (0));
962 bset_display_time (b, Qnil);
963 bset_enable_multibyte_characters
964 (b, BVAR (&buffer_defaults, enable_multibyte_characters));
965 bset_cursor_type (b, BVAR (&buffer_defaults, cursor_type));
966 bset_extra_line_spacing (b, BVAR (&buffer_defaults, extra_line_spacing));
968 b->display_error_modiff = 0;
971 /* Reset buffer B's local variables info.
972 Don't use this on a buffer that has already been in use;
973 it does not treat permanent locals consistently.
974 Instead, use Fkill_all_local_variables.
976 If PERMANENT_TOO, reset permanent buffer-local variables.
977 If not, preserve those. */
979 static void
980 reset_buffer_local_variables (struct buffer *b, bool permanent_too)
982 int offset, i;
984 /* Reset the major mode to Fundamental, together with all the
985 things that depend on the major mode.
986 default-major-mode is handled at a higher level.
987 We ignore it here. */
988 bset_major_mode (b, Qfundamental_mode);
989 bset_keymap (b, Qnil);
990 bset_mode_name (b, QSFundamental);
991 bset_minor_modes (b, Qnil);
993 /* If the standard case table has been altered and invalidated,
994 fix up its insides first. */
995 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table)->extras[0])
996 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table)->extras[1])
997 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table)->extras[2])))
998 Fset_standard_case_table (Vascii_downcase_table);
1000 bset_downcase_table (b, Vascii_downcase_table);
1001 bset_upcase_table (b, XCHAR_TABLE (Vascii_downcase_table)->extras[0]);
1002 bset_case_canon_table (b, XCHAR_TABLE (Vascii_downcase_table)->extras[1]);
1003 bset_case_eqv_table (b, XCHAR_TABLE (Vascii_downcase_table)->extras[2]);
1004 bset_invisibility_spec (b, Qt);
1006 /* Reset all (or most) per-buffer variables to their defaults. */
1007 if (permanent_too)
1008 bset_local_var_alist (b, Qnil);
1009 else
1011 Lisp_Object tmp, prop, last = Qnil;
1012 for (tmp = BVAR (b, local_var_alist); CONSP (tmp); tmp = XCDR (tmp))
1013 if (!NILP (prop = Fget (XCAR (XCAR (tmp)), Qpermanent_local)))
1015 /* If permanent-local, keep it. */
1016 last = tmp;
1017 if (EQ (prop, Qpermanent_local_hook))
1019 /* This is a partially permanent hook variable.
1020 Preserve only the elements that want to be preserved. */
1021 Lisp_Object list, newlist;
1022 list = XCDR (XCAR (tmp));
1023 if (!CONSP (list))
1024 newlist = list;
1025 else
1026 for (newlist = Qnil; CONSP (list); list = XCDR (list))
1028 Lisp_Object elt = XCAR (list);
1029 /* Preserve element ELT if it's t,
1030 if it is a function with a `permanent-local-hook' property,
1031 or if it's not a symbol. */
1032 if (! SYMBOLP (elt)
1033 || EQ (elt, Qt)
1034 || !NILP (Fget (elt, Qpermanent_local_hook)))
1035 newlist = Fcons (elt, newlist);
1037 XSETCDR (XCAR (tmp), Fnreverse (newlist));
1040 /* Delete this local variable. */
1041 else if (NILP (last))
1042 bset_local_var_alist (b, XCDR (tmp));
1043 else
1044 XSETCDR (last, XCDR (tmp));
1047 for (i = 0; i < last_per_buffer_idx; ++i)
1048 if (permanent_too || buffer_permanent_local_flags[i] == 0)
1049 SET_PER_BUFFER_VALUE_P (b, i, 0);
1051 /* For each slot that has a default value, copy that into the slot. */
1052 FOR_EACH_PER_BUFFER_OBJECT_AT (offset)
1054 int idx = PER_BUFFER_IDX (offset);
1055 if ((idx > 0
1056 && (permanent_too
1057 || buffer_permanent_local_flags[idx] == 0)))
1058 set_per_buffer_value (b, offset, per_buffer_default (offset));
1062 /* We split this away from generate-new-buffer, because rename-buffer
1063 and set-visited-file-name ought to be able to use this to really
1064 rename the buffer properly. */
1066 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name,
1067 Sgenerate_new_buffer_name, 1, 2, 0,
1068 doc: /* Return a string that is the name of no existing buffer based on NAME.
1069 If there is no live buffer named NAME, then return NAME.
1070 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
1071 \(starting at 2) until an unused name is found, and then return that name.
1072 Optional second argument IGNORE specifies a name that is okay to use (if
1073 it is in the sequence to be tried) even if a buffer with that name exists.
1075 If NAME begins with a space (i.e., a buffer that is not normally
1076 visible to users), then if buffer NAME already exists a random number
1077 is first appended to NAME, to speed up finding a non-existent buffer. */)
1078 (register Lisp_Object name, Lisp_Object ignore)
1080 register Lisp_Object gentemp, tem, tem2;
1081 ptrdiff_t count;
1082 char number[INT_BUFSIZE_BOUND (ptrdiff_t) + sizeof "<>"];
1084 CHECK_STRING (name);
1086 tem = Fstring_equal (name, ignore);
1087 if (!NILP (tem))
1088 return name;
1089 tem = Fget_buffer (name);
1090 if (NILP (tem))
1091 return name;
1093 if (!strncmp (SSDATA (name), " ", 1)) /* see bug#1229 */
1095 /* Note fileio.c:make_temp_name does random differently. */
1096 tem2 = concat2 (name, make_formatted_string
1097 (number, "-%"pI"d",
1098 XFASTINT (Frandom (make_number (999999)))));
1099 tem = Fget_buffer (tem2);
1100 if (NILP (tem))
1101 return tem2;
1103 else
1104 tem2 = name;
1106 count = 1;
1107 while (1)
1109 gentemp = concat2 (tem2, make_formatted_string
1110 (number, "<%"pD"d>", ++count));
1111 tem = Fstring_equal (gentemp, ignore);
1112 if (!NILP (tem))
1113 return gentemp;
1114 tem = Fget_buffer (gentemp);
1115 if (NILP (tem))
1116 return gentemp;
1121 DEFUN ("buffer-name", Fbuffer_name, Sbuffer_name, 0, 1, 0,
1122 doc: /* Return the name of BUFFER, as a string.
1123 BUFFER defaults to the current buffer.
1124 Return nil if BUFFER has been killed. */)
1125 (register Lisp_Object buffer)
1127 if (NILP (buffer))
1128 return BVAR (current_buffer, name);
1129 CHECK_BUFFER (buffer);
1130 return BVAR (XBUFFER (buffer), name);
1133 DEFUN ("buffer-file-name", Fbuffer_file_name, Sbuffer_file_name, 0, 1, 0,
1134 doc: /* Return name of file BUFFER is visiting, or nil if none.
1135 No argument or nil as argument means use the current buffer. */)
1136 (register Lisp_Object buffer)
1138 if (NILP (buffer))
1139 return BVAR (current_buffer, filename);
1140 CHECK_BUFFER (buffer);
1141 return BVAR (XBUFFER (buffer), filename);
1144 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer, Sbuffer_base_buffer,
1145 0, 1, 0,
1146 doc: /* Return the base buffer of indirect buffer BUFFER.
1147 If BUFFER is not indirect, return nil.
1148 BUFFER defaults to the current buffer. */)
1149 (register Lisp_Object buffer)
1151 struct buffer *base;
1152 Lisp_Object base_buffer;
1154 if (NILP (buffer))
1155 base = current_buffer->base_buffer;
1156 else
1158 CHECK_BUFFER (buffer);
1159 base = XBUFFER (buffer)->base_buffer;
1162 if (! base)
1163 return Qnil;
1164 XSETBUFFER (base_buffer, base);
1165 return base_buffer;
1168 DEFUN ("buffer-local-value", Fbuffer_local_value,
1169 Sbuffer_local_value, 2, 2, 0,
1170 doc: /* Return the value of VARIABLE in BUFFER.
1171 If VARIABLE does not have a buffer-local binding in BUFFER, the value
1172 is the default binding of the variable. */)
1173 (register Lisp_Object variable, register Lisp_Object buffer)
1175 register Lisp_Object result = buffer_local_value_1 (variable, buffer);
1177 if (EQ (result, Qunbound))
1178 xsignal1 (Qvoid_variable, variable);
1180 return result;
1184 /* Like Fbuffer_local_value, but return Qunbound if the variable is
1185 locally unbound. */
1187 Lisp_Object
1188 buffer_local_value_1 (Lisp_Object variable, Lisp_Object buffer)
1190 register struct buffer *buf;
1191 register Lisp_Object result;
1192 struct Lisp_Symbol *sym;
1194 CHECK_SYMBOL (variable);
1195 CHECK_BUFFER (buffer);
1196 buf = XBUFFER (buffer);
1197 sym = XSYMBOL (variable);
1199 start:
1200 switch (sym->redirect)
1202 case SYMBOL_VARALIAS: sym = indirect_variable (sym); goto start;
1203 case SYMBOL_PLAINVAL: result = SYMBOL_VAL (sym); break;
1204 case SYMBOL_LOCALIZED:
1205 { /* Look in local_var_alist. */
1206 struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (sym);
1207 XSETSYMBOL (variable, sym); /* Update In case of aliasing. */
1208 result = Fassoc (variable, BVAR (buf, local_var_alist));
1209 if (!NILP (result))
1211 if (blv->fwd)
1212 { /* What binding is loaded right now? */
1213 Lisp_Object current_alist_element = blv->valcell;
1215 /* The value of the currently loaded binding is not
1216 stored in it, but rather in the realvalue slot.
1217 Store that value into the binding it belongs to
1218 in case that is the one we are about to use. */
1220 XSETCDR (current_alist_element,
1221 do_symval_forwarding (blv->fwd));
1223 /* Now get the (perhaps updated) value out of the binding. */
1224 result = XCDR (result);
1226 else
1227 result = Fdefault_value (variable);
1228 break;
1230 case SYMBOL_FORWARDED:
1232 union Lisp_Fwd *fwd = SYMBOL_FWD (sym);
1233 if (BUFFER_OBJFWDP (fwd))
1234 result = per_buffer_value (buf, XBUFFER_OBJFWD (fwd)->offset);
1235 else
1236 result = Fdefault_value (variable);
1237 break;
1239 default: emacs_abort ();
1242 return result;
1245 /* Return an alist of the Lisp-level buffer-local bindings of
1246 buffer BUF. That is, don't include the variables maintained
1247 in special slots in the buffer object.
1248 If not CLONE, replace elements of the form (VAR . unbound)
1249 by VAR. */
1251 static Lisp_Object
1252 buffer_lisp_local_variables (struct buffer *buf, bool clone)
1254 Lisp_Object result = Qnil;
1255 Lisp_Object tail;
1256 for (tail = BVAR (buf, local_var_alist); CONSP (tail); tail = XCDR (tail))
1258 Lisp_Object val, elt;
1260 elt = XCAR (tail);
1262 /* Reference each variable in the alist in buf.
1263 If inquiring about the current buffer, this gets the current values,
1264 so store them into the alist so the alist is up to date.
1265 If inquiring about some other buffer, this swaps out any values
1266 for that buffer, making the alist up to date automatically. */
1267 val = find_symbol_value (XCAR (elt));
1268 /* Use the current buffer value only if buf is the current buffer. */
1269 if (buf != current_buffer)
1270 val = XCDR (elt);
1272 result = Fcons (!clone && EQ (val, Qunbound)
1273 ? XCAR (elt)
1274 : Fcons (XCAR (elt), val),
1275 result);
1278 return result;
1281 DEFUN ("buffer-local-variables", Fbuffer_local_variables,
1282 Sbuffer_local_variables, 0, 1, 0,
1283 doc: /* Return an alist of variables that are buffer-local in BUFFER.
1284 Most elements look like (SYMBOL . VALUE), describing one variable.
1285 For a symbol that is locally unbound, just the symbol appears in the value.
1286 Note that storing new VALUEs in these elements doesn't change the variables.
1287 No argument or nil as argument means use current buffer as BUFFER. */)
1288 (register Lisp_Object buffer)
1290 register struct buffer *buf;
1291 register Lisp_Object result;
1293 if (NILP (buffer))
1294 buf = current_buffer;
1295 else
1297 CHECK_BUFFER (buffer);
1298 buf = XBUFFER (buffer);
1301 result = buffer_lisp_local_variables (buf, 0);
1303 /* Add on all the variables stored in special slots. */
1305 int offset, idx;
1307 FOR_EACH_PER_BUFFER_OBJECT_AT (offset)
1309 idx = PER_BUFFER_IDX (offset);
1310 if ((idx == -1 || PER_BUFFER_VALUE_P (buf, idx))
1311 && SYMBOLP (PER_BUFFER_SYMBOL (offset)))
1313 Lisp_Object sym = PER_BUFFER_SYMBOL (offset);
1314 Lisp_Object val = per_buffer_value (buf, offset);
1315 result = Fcons (EQ (val, Qunbound) ? sym : Fcons (sym, val),
1316 result);
1321 return result;
1324 DEFUN ("buffer-modified-p", Fbuffer_modified_p, Sbuffer_modified_p,
1325 0, 1, 0,
1326 doc: /* Return t if BUFFER was modified since its file was last read or saved.
1327 No argument or nil as argument means use current buffer as BUFFER. */)
1328 (register Lisp_Object buffer)
1330 register struct buffer *buf;
1331 if (NILP (buffer))
1332 buf = current_buffer;
1333 else
1335 CHECK_BUFFER (buffer);
1336 buf = XBUFFER (buffer);
1339 return BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf) ? Qt : Qnil;
1342 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p, Sset_buffer_modified_p,
1343 1, 1, 0,
1344 doc: /* Mark current buffer as modified or unmodified according to FLAG.
1345 A non-nil FLAG means mark the buffer modified. */)
1346 (Lisp_Object flag)
1348 Lisp_Object fn;
1350 #ifdef CLASH_DETECTION
1351 /* If buffer becoming modified, lock the file.
1352 If buffer becoming unmodified, unlock the file. */
1354 struct buffer *b = current_buffer->base_buffer
1355 ? current_buffer->base_buffer
1356 : current_buffer;
1358 fn = BVAR (b, file_truename);
1359 /* Test buffer-file-name so that binding it to nil is effective. */
1360 if (!NILP (fn) && ! NILP (BVAR (b, filename)))
1362 bool already = SAVE_MODIFF < MODIFF;
1363 if (!already && !NILP (flag))
1364 lock_file (fn);
1365 else if (already && NILP (flag))
1366 unlock_file (fn);
1368 #endif /* CLASH_DETECTION */
1370 /* Here we have a problem. SAVE_MODIFF is used here to encode
1371 buffer-modified-p (as SAVE_MODIFF<MODIFF) as well as
1372 recent-auto-save-p (as SAVE_MODIFF<auto_save_modified). So if we
1373 modify SAVE_MODIFF to affect one, we may affect the other
1374 as well.
1375 E.g. if FLAG is nil we need to set SAVE_MODIFF to MODIFF, but
1376 if SAVE_MODIFF<auto_save_modified that means we risk changing
1377 recent-auto-save-p from t to nil.
1378 Vice versa, if FLAG is non-nil and SAVE_MODIFF>=auto_save_modified
1379 we risk changing recent-auto-save-p from nil to t. */
1380 SAVE_MODIFF = (NILP (flag)
1381 /* FIXME: This unavoidably sets recent-auto-save-p to nil. */
1382 ? MODIFF
1383 /* Let's try to preserve recent-auto-save-p. */
1384 : SAVE_MODIFF < MODIFF ? SAVE_MODIFF
1385 /* If SAVE_MODIFF == auto_save_modified == MODIFF,
1386 we can either decrease SAVE_MODIFF and auto_save_modified
1387 or increase MODIFF. */
1388 : MODIFF++);
1390 /* Set update_mode_lines only if buffer is displayed in some window.
1391 Packages like jit-lock or lazy-lock preserve a buffer's modified
1392 state by recording/restoring the state around blocks of code.
1393 Setting update_mode_lines makes redisplay consider all windows
1394 (on all frames). Stealth fontification of buffers not displayed
1395 would incur additional redisplay costs if we'd set
1396 update_modes_lines unconditionally.
1398 Ideally, I think there should be another mechanism for fontifying
1399 buffers without "modifying" buffers, or redisplay should be
1400 smarter about updating the `*' in mode lines. --gerd */
1401 if (buffer_window_count (current_buffer))
1403 ++update_mode_lines;
1404 current_buffer->prevent_redisplay_optimizations_p = 1;
1407 return flag;
1410 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p,
1411 Srestore_buffer_modified_p, 1, 1, 0,
1412 doc: /* Like `set-buffer-modified-p', with a difference concerning redisplay.
1413 It is not ensured that mode lines will be updated to show the modified
1414 state of the current buffer. Use with care. */)
1415 (Lisp_Object flag)
1417 #ifdef CLASH_DETECTION
1418 Lisp_Object fn;
1420 /* If buffer becoming modified, lock the file.
1421 If buffer becoming unmodified, unlock the file. */
1423 fn = BVAR (current_buffer, file_truename);
1424 /* Test buffer-file-name so that binding it to nil is effective. */
1425 if (!NILP (fn) && ! NILP (BVAR (current_buffer, filename)))
1427 bool already = SAVE_MODIFF < MODIFF;
1428 if (!already && !NILP (flag))
1429 lock_file (fn);
1430 else if (already && NILP (flag))
1431 unlock_file (fn);
1433 #endif /* CLASH_DETECTION */
1435 SAVE_MODIFF = NILP (flag) ? MODIFF : 0;
1436 return flag;
1439 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick, Sbuffer_modified_tick,
1440 0, 1, 0,
1441 doc: /* Return BUFFER's tick counter, incremented for each change in text.
1442 Each buffer has a tick counter which is incremented each time the
1443 text in that buffer is changed. It wraps around occasionally.
1444 No argument or nil as argument means use current buffer as BUFFER. */)
1445 (register Lisp_Object buffer)
1447 register struct buffer *buf;
1448 if (NILP (buffer))
1449 buf = current_buffer;
1450 else
1452 CHECK_BUFFER (buffer);
1453 buf = XBUFFER (buffer);
1456 return make_number (BUF_MODIFF (buf));
1459 DEFUN ("buffer-chars-modified-tick", Fbuffer_chars_modified_tick,
1460 Sbuffer_chars_modified_tick, 0, 1, 0,
1461 doc: /* Return BUFFER's character-change tick counter.
1462 Each buffer has a character-change tick counter, which is set to the
1463 value of the buffer's tick counter \(see `buffer-modified-tick'), each
1464 time text in that buffer is inserted or deleted. By comparing the
1465 values returned by two individual calls of `buffer-chars-modified-tick',
1466 you can tell whether a character change occurred in that buffer in
1467 between these calls. No argument or nil as argument means use current
1468 buffer as BUFFER. */)
1469 (register Lisp_Object buffer)
1471 register struct buffer *buf;
1472 if (NILP (buffer))
1473 buf = current_buffer;
1474 else
1476 CHECK_BUFFER (buffer);
1477 buf = XBUFFER (buffer);
1480 return make_number (BUF_CHARS_MODIFF (buf));
1483 DEFUN ("rename-buffer", Frename_buffer, Srename_buffer, 1, 2,
1484 "(list (read-string \"Rename buffer (to new name): \" \
1485 nil 'buffer-name-history (buffer-name (current-buffer))) \
1486 current-prefix-arg)",
1487 doc: /* Change current buffer's name to NEWNAME (a string).
1488 If second arg UNIQUE is nil or omitted, it is an error if a
1489 buffer named NEWNAME already exists.
1490 If UNIQUE is non-nil, come up with a new name using
1491 `generate-new-buffer-name'.
1492 Interactively, you can set UNIQUE with a prefix argument.
1493 We return the name we actually gave the buffer.
1494 This does not change the name of the visited file (if any). */)
1495 (register Lisp_Object newname, Lisp_Object unique)
1497 register Lisp_Object tem, buf;
1499 CHECK_STRING (newname);
1501 if (SCHARS (newname) == 0)
1502 error ("Empty string is invalid as a buffer name");
1504 tem = Fget_buffer (newname);
1505 if (!NILP (tem))
1507 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1508 rename the buffer automatically so you can create another
1509 with the original name. It makes UNIQUE equivalent to
1510 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1511 if (NILP (unique) && XBUFFER (tem) == current_buffer)
1512 return BVAR (current_buffer, name);
1513 if (!NILP (unique))
1514 newname = Fgenerate_new_buffer_name (newname, BVAR (current_buffer, name));
1515 else
1516 error ("Buffer name `%s' is in use", SDATA (newname));
1519 bset_name (current_buffer, newname);
1521 /* Catch redisplay's attention. Unless we do this, the mode lines for
1522 any windows displaying current_buffer will stay unchanged. */
1523 update_mode_lines++;
1525 XSETBUFFER (buf, current_buffer);
1526 Fsetcar (Frassq (buf, Vbuffer_alist), newname);
1527 if (NILP (BVAR (current_buffer, filename))
1528 && !NILP (BVAR (current_buffer, auto_save_file_name)))
1529 call0 (intern ("rename-auto-save-file"));
1531 /* Run buffer-list-update-hook. */
1532 if (!NILP (Vrun_hooks))
1533 call1 (Vrun_hooks, Qbuffer_list_update_hook);
1535 /* Refetch since that last call may have done GC. */
1536 return BVAR (current_buffer, name);
1539 /* True if B can be used as 'other-than-BUFFER' buffer. */
1541 static bool
1542 candidate_buffer (Lisp_Object b, Lisp_Object buffer)
1544 return (BUFFERP (b) && !EQ (b, buffer)
1545 && BUFFER_LIVE_P (XBUFFER (b))
1546 && !BUFFER_HIDDEN_P (XBUFFER (b)));
1549 DEFUN ("other-buffer", Fother_buffer, Sother_buffer, 0, 3, 0,
1550 doc: /* Return most recently selected buffer other than BUFFER.
1551 Buffers not visible in windows are preferred to visible buffers, unless
1552 optional second argument VISIBLE-OK is non-nil. Ignore the argument
1553 BUFFER unless it denotes a live buffer. If the optional third argument
1554 FRAME is non-nil, use that frame's buffer list instead of the selected
1555 frame's buffer list.
1557 The buffer is found by scanning the selected or specified frame's buffer
1558 list first, followed by the list of all buffers. If no other buffer
1559 exists, return the buffer `*scratch*' (creating it if necessary). */)
1560 (register Lisp_Object buffer, Lisp_Object visible_ok, Lisp_Object frame)
1562 struct frame *f = decode_any_frame (frame);
1563 Lisp_Object tail = f->buffer_list, pred = f->buffer_predicate;
1564 Lisp_Object buf, notsogood = Qnil;
1566 /* Consider buffers that have been seen in the frame first. */
1567 for (; CONSP (tail); tail = XCDR (tail))
1569 buf = XCAR (tail);
1570 if (candidate_buffer (buf, buffer)
1571 /* If the frame has a buffer_predicate, disregard buffers that
1572 don't fit the predicate. */
1573 && (NILP (pred) || !NILP (call1 (pred, buf))))
1575 if (!NILP (visible_ok)
1576 || NILP (Fget_buffer_window (buf, Qvisible)))
1577 return buf;
1578 else if (NILP (notsogood))
1579 notsogood = buf;
1583 /* Consider alist of all buffers next. */
1584 tail = Vbuffer_alist;
1585 for (; CONSP (tail); tail = XCDR (tail))
1587 buf = Fcdr (XCAR (tail));
1588 if (candidate_buffer (buf, buffer)
1589 /* If the frame has a buffer_predicate, disregard buffers that
1590 don't fit the predicate. */
1591 && (NILP (pred) || !NILP (call1 (pred, buf))))
1593 if (!NILP (visible_ok)
1594 || NILP (Fget_buffer_window (buf, Qvisible)))
1595 return buf;
1596 else if (NILP (notsogood))
1597 notsogood = buf;
1601 if (!NILP (notsogood))
1602 return notsogood;
1603 else
1605 buf = Fget_buffer (build_string ("*scratch*"));
1606 if (NILP (buf))
1608 buf = Fget_buffer_create (build_string ("*scratch*"));
1609 Fset_buffer_major_mode (buf);
1611 return buf;
1615 /* The following function is a safe variant of Fother_buffer: It doesn't
1616 pay attention to any frame-local buffer lists, doesn't care about
1617 visibility of buffers, and doesn't evaluate any frame predicates. */
1619 Lisp_Object
1620 other_buffer_safely (Lisp_Object buffer)
1622 Lisp_Object tail, buf;
1624 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
1626 buf = Fcdr (XCAR (tail));
1627 if (candidate_buffer (buf, buffer))
1628 return buf;
1631 buf = Fget_buffer (build_string ("*scratch*"));
1632 if (NILP (buf))
1634 buf = Fget_buffer_create (build_string ("*scratch*"));
1635 Fset_buffer_major_mode (buf);
1638 return buf;
1641 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo, Sbuffer_enable_undo,
1642 0, 1, "",
1643 doc: /* Start keeping undo information for buffer BUFFER.
1644 No argument or nil as argument means do this for the current buffer. */)
1645 (register Lisp_Object buffer)
1647 Lisp_Object real_buffer;
1649 if (NILP (buffer))
1650 XSETBUFFER (real_buffer, current_buffer);
1651 else
1653 real_buffer = Fget_buffer (buffer);
1654 if (NILP (real_buffer))
1655 nsberror (buffer);
1658 if (EQ (BVAR (XBUFFER (real_buffer), undo_list), Qt))
1659 bset_undo_list (XBUFFER (real_buffer), Qnil);
1661 return Qnil;
1664 /* Truncate undo list and shrink the gap of BUFFER. */
1666 void
1667 compact_buffer (struct buffer *buffer)
1669 BUFFER_CHECK_INDIRECTION (buffer);
1671 /* Skip dead buffers, indirect buffers and buffers
1672 which aren't changed since last compaction. */
1673 if (BUFFER_LIVE_P (buffer)
1674 && (buffer->base_buffer == NULL)
1675 && (BUF_COMPACT (buffer) != BUF_MODIFF (buffer)))
1677 /* If a buffer's undo list is Qt, that means that undo is
1678 turned off in that buffer. Calling truncate_undo_list on
1679 Qt tends to return NULL, which effectively turns undo back on.
1680 So don't call truncate_undo_list if undo_list is Qt. */
1681 if (!EQ (buffer->INTERNAL_FIELD (undo_list), Qt))
1682 truncate_undo_list (buffer);
1684 /* Shrink buffer gaps. */
1685 if (!buffer->text->inhibit_shrinking)
1687 /* If a buffer's gap size is more than 10% of the buffer
1688 size, or larger than GAP_BYTES_DFL bytes, then shrink it
1689 accordingly. Keep a minimum size of GAP_BYTES_MIN bytes. */
1690 ptrdiff_t size = clip_to_bounds (GAP_BYTES_MIN,
1691 BUF_Z_BYTE (buffer) / 10,
1692 GAP_BYTES_DFL);
1693 if (BUF_GAP_SIZE (buffer) > size)
1694 make_gap_1 (buffer, -(BUF_GAP_SIZE (buffer) - size));
1696 BUF_COMPACT (buffer) = BUF_MODIFF (buffer);
1700 DEFUN ("kill-buffer", Fkill_buffer, Skill_buffer, 0, 1, "bKill buffer: ",
1701 doc: /* Kill the buffer specified by BUFFER-OR-NAME.
1702 The argument may be a buffer or the name of an existing buffer.
1703 Argument nil or omitted means kill the current buffer. Return t if the
1704 buffer is actually killed, nil otherwise.
1706 The functions in `kill-buffer-query-functions' are called with the
1707 buffer to be killed as the current buffer. If any of them returns nil,
1708 the buffer is not killed. The hook `kill-buffer-hook' is run before the
1709 buffer is actually killed. The buffer being killed will be current
1710 while the hook is running. Functions called by any of these hooks are
1711 supposed to not change the current buffer.
1713 Any processes that have this buffer as the `process-buffer' are killed
1714 with SIGHUP. This function calls `replace-buffer-in-windows' for
1715 cleaning up all windows currently displaying the buffer to be killed. */)
1716 (Lisp_Object buffer_or_name)
1718 Lisp_Object buffer;
1719 register struct buffer *b;
1720 register Lisp_Object tem;
1721 register struct Lisp_Marker *m;
1722 struct gcpro gcpro1;
1724 if (NILP (buffer_or_name))
1725 buffer = Fcurrent_buffer ();
1726 else
1727 buffer = Fget_buffer (buffer_or_name);
1728 if (NILP (buffer))
1729 nsberror (buffer_or_name);
1731 b = XBUFFER (buffer);
1733 /* Avoid trouble for buffer already dead. */
1734 if (!BUFFER_LIVE_P (b))
1735 return Qnil;
1737 /* Run hooks with the buffer to be killed the current buffer. */
1739 ptrdiff_t count = SPECPDL_INDEX ();
1740 Lisp_Object arglist[1];
1742 record_unwind_protect (save_excursion_restore, save_excursion_save ());
1743 set_buffer_internal (b);
1745 /* First run the query functions; if any query is answered no,
1746 don't kill the buffer. */
1747 arglist[0] = Qkill_buffer_query_functions;
1748 tem = Frun_hook_with_args_until_failure (1, arglist);
1749 if (NILP (tem))
1750 return unbind_to (count, Qnil);
1752 /* Query if the buffer is still modified. */
1753 if (INTERACTIVE && !NILP (BVAR (b, filename))
1754 && BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
1756 GCPRO1 (buffer);
1757 tem = do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1758 BVAR (b, name), make_number (0)));
1759 UNGCPRO;
1760 if (NILP (tem))
1761 return unbind_to (count, Qnil);
1764 /* If the hooks have killed the buffer, exit now. */
1765 if (!BUFFER_LIVE_P (b))
1766 return unbind_to (count, Qt);
1768 /* Then run the hooks. */
1769 Frun_hooks (1, &Qkill_buffer_hook);
1770 unbind_to (count, Qnil);
1773 /* If the hooks have killed the buffer, exit now. */
1774 if (!BUFFER_LIVE_P (b))
1775 return Qt;
1777 /* We have no more questions to ask. Verify that it is valid
1778 to kill the buffer. This must be done after the questions
1779 since anything can happen within do_yes_or_no_p. */
1781 /* Don't kill the minibuffer now current. */
1782 if (EQ (buffer, XWINDOW (minibuf_window)->contents))
1783 return Qnil;
1785 /* When we kill an ordinary buffer which shares it's buffer text
1786 with indirect buffer(s), we must kill indirect buffer(s) too.
1787 We do it at this stage so nothing terrible happens if they
1788 ask questions or their hooks get errors. */
1789 if (!b->base_buffer && b->indirections > 0)
1791 struct buffer *other;
1793 GCPRO1 (buffer);
1795 FOR_EACH_BUFFER (other)
1796 if (other->base_buffer == b)
1798 Lisp_Object buf;
1799 XSETBUFFER (buf, other);
1800 Fkill_buffer (buf);
1803 UNGCPRO;
1805 /* Exit if we now have killed the base buffer (Bug#11665). */
1806 if (!BUFFER_LIVE_P (b))
1807 return Qt;
1810 /* Run replace_buffer_in_windows before making another buffer current
1811 since set-window-buffer-start-and-point will refuse to make another
1812 buffer current if the selected window does not show the current
1813 buffer. (Bug#10114) */
1814 replace_buffer_in_windows (buffer);
1816 /* Exit if replacing the buffer in windows has killed our buffer. */
1817 if (!BUFFER_LIVE_P (b))
1818 return Qt;
1820 /* Make this buffer not be current. Exit if it is the sole visible
1821 buffer. */
1822 if (b == current_buffer)
1824 tem = Fother_buffer (buffer, Qnil, Qnil);
1825 Fset_buffer (tem);
1826 if (b == current_buffer)
1827 return Qnil;
1830 /* If the buffer now current is shown in the minibuffer and our buffer
1831 is the sole other buffer give up. */
1832 XSETBUFFER (tem, current_buffer);
1833 if (EQ (tem, XWINDOW (minibuf_window)->contents)
1834 && EQ (buffer, Fother_buffer (buffer, Qnil, Qnil)))
1835 return Qnil;
1837 /* Now there is no question: we can kill the buffer. */
1839 #ifdef CLASH_DETECTION
1840 /* Unlock this buffer's file, if it is locked. */
1841 unlock_buffer (b);
1842 #endif /* CLASH_DETECTION */
1844 GCPRO1 (buffer);
1845 kill_buffer_processes (buffer);
1846 UNGCPRO;
1848 /* Killing buffer processes may run sentinels which may have killed
1849 our buffer. */
1850 if (!BUFFER_LIVE_P (b))
1851 return Qt;
1853 /* These may run Lisp code and into infinite loops (if someone
1854 insisted on circular lists) so allow quitting here. */
1855 frames_discard_buffer (buffer);
1857 clear_charpos_cache (b);
1859 tem = Vinhibit_quit;
1860 Vinhibit_quit = Qt;
1861 /* Remove the buffer from the list of all buffers. */
1862 Vbuffer_alist = Fdelq (Frassq (buffer, Vbuffer_alist), Vbuffer_alist);
1863 /* If replace_buffer_in_windows didn't do its job fix that now. */
1864 replace_buffer_in_windows_safely (buffer);
1865 Vinhibit_quit = tem;
1867 /* Delete any auto-save file, if we saved it in this session.
1868 But not if the buffer is modified. */
1869 if (STRINGP (BVAR (b, auto_save_file_name))
1870 && BUF_AUTOSAVE_MODIFF (b) != 0
1871 && BUF_SAVE_MODIFF (b) < BUF_AUTOSAVE_MODIFF (b)
1872 && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)
1873 && NILP (Fsymbol_value (intern ("auto-save-visited-file-name"))))
1875 Lisp_Object delete;
1876 delete = Fsymbol_value (intern ("delete-auto-save-files"));
1877 if (! NILP (delete))
1878 internal_delete_file (BVAR (b, auto_save_file_name));
1881 /* Deleting an auto-save file could have killed our buffer. */
1882 if (!BUFFER_LIVE_P (b))
1883 return Qt;
1885 if (b->base_buffer)
1887 /* Unchain all markers that belong to this indirect buffer.
1888 Don't unchain the markers that belong to the base buffer
1889 or its other indirect buffers. */
1890 struct Lisp_Marker **mp = &BUF_MARKERS (b);
1891 while ((m = *mp))
1893 if (m->buffer == b)
1895 m->buffer = NULL;
1896 *mp = m->next;
1898 else
1899 mp = &m->next;
1902 else
1904 /* Unchain all markers of this buffer and its indirect buffers.
1905 and leave them pointing nowhere. */
1906 for (m = BUF_MARKERS (b); m; )
1908 struct Lisp_Marker *next = m->next;
1909 m->buffer = 0;
1910 m->next = NULL;
1911 m = next;
1913 BUF_MARKERS (b) = NULL;
1914 set_buffer_intervals (b, NULL);
1916 /* Perhaps we should explicitly free the interval tree here... */
1918 /* Since we've unlinked the markers, the overlays can't be here any more
1919 either. */
1920 b->overlays_before = NULL;
1921 b->overlays_after = NULL;
1923 /* Reset the local variables, so that this buffer's local values
1924 won't be protected from GC. They would be protected
1925 if they happened to remain cached in their symbols.
1926 This gets rid of them for certain. */
1927 swap_out_buffer_local_variables (b);
1928 reset_buffer_local_variables (b, 1);
1930 bset_name (b, Qnil);
1932 block_input ();
1933 if (b->base_buffer)
1935 /* Notify our base buffer that we don't share the text anymore. */
1936 eassert (b->indirections == -1);
1937 b->base_buffer->indirections--;
1938 eassert (b->base_buffer->indirections >= 0);
1939 /* Make sure that we wasn't confused. */
1940 eassert (b->window_count == -1);
1942 else
1944 /* Make sure that no one shows us. */
1945 eassert (b->window_count == 0);
1946 /* No one shares our buffer text, can free it. */
1947 free_buffer_text (b);
1950 if (b->newline_cache)
1952 free_region_cache (b->newline_cache);
1953 b->newline_cache = 0;
1955 if (b->width_run_cache)
1957 free_region_cache (b->width_run_cache);
1958 b->width_run_cache = 0;
1960 bset_width_table (b, Qnil);
1961 unblock_input ();
1962 bset_undo_list (b, Qnil);
1964 /* Run buffer-list-update-hook. */
1965 if (!NILP (Vrun_hooks))
1966 call1 (Vrun_hooks, Qbuffer_list_update_hook);
1968 return Qt;
1971 /* Move association for BUFFER to the front of buffer (a)lists. Since
1972 we do this each time BUFFER is selected visibly, the more recently
1973 selected buffers are always closer to the front of those lists. This
1974 means that other_buffer is more likely to choose a relevant buffer.
1976 Note that this moves BUFFER to the front of the buffer lists of the
1977 selected frame even if BUFFER is not shown there. If BUFFER is not
1978 shown in the selected frame, consider the present behavior a feature.
1979 `select-window' gets this right since it shows BUFFER in the selected
1980 window when calling us. */
1982 void
1983 record_buffer (Lisp_Object buffer)
1985 Lisp_Object aelt, aelt_cons, tem;
1986 register struct frame *f = XFRAME (selected_frame);
1988 CHECK_BUFFER (buffer);
1990 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
1991 Don't allow quitting since this might leave the buffer list in an
1992 inconsistent state. */
1993 tem = Vinhibit_quit;
1994 Vinhibit_quit = Qt;
1995 aelt = Frassq (buffer, Vbuffer_alist);
1996 aelt_cons = Fmemq (aelt, Vbuffer_alist);
1997 Vbuffer_alist = Fdelq (aelt, Vbuffer_alist);
1998 XSETCDR (aelt_cons, Vbuffer_alist);
1999 Vbuffer_alist = aelt_cons;
2000 Vinhibit_quit = tem;
2002 /* Update buffer list of selected frame. */
2003 fset_buffer_list (f, Fcons (buffer, Fdelq (buffer, f->buffer_list)));
2004 fset_buried_buffer_list (f, Fdelq (buffer, f->buried_buffer_list));
2006 /* Run buffer-list-update-hook. */
2007 if (!NILP (Vrun_hooks))
2008 call1 (Vrun_hooks, Qbuffer_list_update_hook);
2012 /* Move BUFFER to the end of the buffer (a)lists. Do nothing if the
2013 buffer is killed. For the selected frame's buffer list this moves
2014 BUFFER to its end even if it was never shown in that frame. If
2015 this happens we have a feature, hence `bury-buffer-internal' should be
2016 called only when BUFFER was shown in the selected frame. */
2018 DEFUN ("bury-buffer-internal", Fbury_buffer_internal, Sbury_buffer_internal,
2019 1, 1, 0,
2020 doc: /* Move BUFFER to the end of the buffer list. */)
2021 (Lisp_Object buffer)
2023 Lisp_Object aelt, aelt_cons, tem;
2024 register struct frame *f = XFRAME (selected_frame);
2026 CHECK_BUFFER (buffer);
2028 /* Update Vbuffer_alist (we know that it has an entry for BUFFER).
2029 Don't allow quitting since this might leave the buffer list in an
2030 inconsistent state. */
2031 tem = Vinhibit_quit;
2032 Vinhibit_quit = Qt;
2033 aelt = Frassq (buffer, Vbuffer_alist);
2034 aelt_cons = Fmemq (aelt, Vbuffer_alist);
2035 Vbuffer_alist = Fdelq (aelt, Vbuffer_alist);
2036 XSETCDR (aelt_cons, Qnil);
2037 Vbuffer_alist = nconc2 (Vbuffer_alist, aelt_cons);
2038 Vinhibit_quit = tem;
2040 /* Update buffer lists of selected frame. */
2041 fset_buffer_list (f, Fdelq (buffer, f->buffer_list));
2042 fset_buried_buffer_list
2043 (f, Fcons (buffer, Fdelq (buffer, f->buried_buffer_list)));
2045 /* Run buffer-list-update-hook. */
2046 if (!NILP (Vrun_hooks))
2047 call1 (Vrun_hooks, Qbuffer_list_update_hook);
2049 return Qnil;
2052 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode, Sset_buffer_major_mode, 1, 1, 0,
2053 doc: /* Set an appropriate major mode for BUFFER.
2054 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
2055 according to the default value of `major-mode'.
2056 Use this function before selecting the buffer, since it may need to inspect
2057 the current buffer's major mode. */)
2058 (Lisp_Object buffer)
2060 ptrdiff_t count;
2061 Lisp_Object function;
2063 CHECK_BUFFER (buffer);
2065 if (!BUFFER_LIVE_P (XBUFFER (buffer)))
2066 error ("Attempt to set major mode for a dead buffer");
2068 if (strcmp (SSDATA (BVAR (XBUFFER (buffer), name)), "*scratch*") == 0)
2069 function = find_symbol_value (intern ("initial-major-mode"));
2070 else
2072 function = BVAR (&buffer_defaults, major_mode);
2073 if (NILP (function)
2074 && NILP (Fget (BVAR (current_buffer, major_mode), Qmode_class)))
2075 function = BVAR (current_buffer, major_mode);
2078 if (NILP (function) || EQ (function, Qfundamental_mode))
2079 return Qnil;
2081 count = SPECPDL_INDEX ();
2083 /* To select a nonfundamental mode,
2084 select the buffer temporarily and then call the mode function. */
2086 record_unwind_protect (save_excursion_restore, save_excursion_save ());
2088 Fset_buffer (buffer);
2089 call0 (function);
2091 return unbind_to (count, Qnil);
2094 DEFUN ("current-buffer", Fcurrent_buffer, Scurrent_buffer, 0, 0, 0,
2095 doc: /* Return the current buffer as a Lisp object. */)
2096 (void)
2098 register Lisp_Object buf;
2099 XSETBUFFER (buf, current_buffer);
2100 return buf;
2103 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
2104 This is used by redisplay. */
2106 void
2107 set_buffer_internal_1 (register struct buffer *b)
2109 register struct buffer *old_buf;
2110 register Lisp_Object tail;
2112 #ifdef USE_MMAP_FOR_BUFFERS
2113 if (b->text->beg == NULL)
2114 enlarge_buffer_text (b, 0);
2115 #endif /* USE_MMAP_FOR_BUFFERS */
2117 if (current_buffer == b)
2118 return;
2120 BUFFER_CHECK_INDIRECTION (b);
2122 old_buf = current_buffer;
2123 current_buffer = b;
2124 last_known_column_point = -1; /* invalidate indentation cache */
2126 if (old_buf)
2128 /* Put the undo list back in the base buffer, so that it appears
2129 that an indirect buffer shares the undo list of its base. */
2130 if (old_buf->base_buffer)
2131 bset_undo_list (old_buf->base_buffer, BVAR (old_buf, undo_list));
2133 /* If the old current buffer has markers to record PT, BEGV and ZV
2134 when it is not current, update them now. */
2135 record_buffer_markers (old_buf);
2138 /* Get the undo list from the base buffer, so that it appears
2139 that an indirect buffer shares the undo list of its base. */
2140 if (b->base_buffer)
2141 bset_undo_list (b, BVAR (b->base_buffer, undo_list));
2143 /* If the new current buffer has markers to record PT, BEGV and ZV
2144 when it is not current, fetch them now. */
2145 fetch_buffer_markers (b);
2147 /* Look down buffer's list of local Lisp variables
2148 to find and update any that forward into C variables. */
2152 for (tail = BVAR (b, local_var_alist); CONSP (tail); tail = XCDR (tail))
2154 Lisp_Object var = XCAR (XCAR (tail));
2155 struct Lisp_Symbol *sym = XSYMBOL (var);
2156 if (sym->redirect == SYMBOL_LOCALIZED /* Just to be sure. */
2157 && SYMBOL_BLV (sym)->fwd)
2158 /* Just reference the variable
2159 to cause it to become set for this buffer. */
2160 Fsymbol_value (var);
2163 /* Do the same with any others that were local to the previous buffer */
2164 while (b != old_buf && (b = old_buf, b));
2167 /* Switch to buffer B temporarily for redisplay purposes.
2168 This avoids certain things that don't need to be done within redisplay. */
2170 void
2171 set_buffer_temp (struct buffer *b)
2173 register struct buffer *old_buf;
2175 if (current_buffer == b)
2176 return;
2178 old_buf = current_buffer;
2179 current_buffer = b;
2181 /* If the old current buffer has markers to record PT, BEGV and ZV
2182 when it is not current, update them now. */
2183 record_buffer_markers (old_buf);
2185 /* If the new current buffer has markers to record PT, BEGV and ZV
2186 when it is not current, fetch them now. */
2187 fetch_buffer_markers (b);
2190 DEFUN ("set-buffer", Fset_buffer, Sset_buffer, 1, 1, 0,
2191 doc: /* Make buffer BUFFER-OR-NAME current for editing operations.
2192 BUFFER-OR-NAME may be a buffer or the name of an existing buffer. See
2193 also `with-current-buffer' when you want to make a buffer current
2194 temporarily. This function does not display the buffer, so its effect
2195 ends when the current command terminates. Use `switch-to-buffer' or
2196 `pop-to-buffer' to switch buffers permanently. */)
2197 (register Lisp_Object buffer_or_name)
2199 register Lisp_Object buffer;
2200 buffer = Fget_buffer (buffer_or_name);
2201 if (NILP (buffer))
2202 nsberror (buffer_or_name);
2203 if (!BUFFER_LIVE_P (XBUFFER (buffer)))
2204 error ("Selecting deleted buffer");
2205 set_buffer_internal (XBUFFER (buffer));
2206 return buffer;
2209 /* Set the current buffer to BUFFER provided if it is alive. */
2211 Lisp_Object
2212 set_buffer_if_live (Lisp_Object buffer)
2214 if (BUFFER_LIVE_P (XBUFFER (buffer)))
2215 set_buffer_internal (XBUFFER (buffer));
2216 return Qnil;
2219 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only,
2220 Sbarf_if_buffer_read_only, 0, 0, 0,
2221 doc: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
2222 (void)
2224 if (!NILP (BVAR (current_buffer, read_only))
2225 && NILP (Vinhibit_read_only))
2226 xsignal1 (Qbuffer_read_only, Fcurrent_buffer ());
2227 return Qnil;
2230 DEFUN ("erase-buffer", Ferase_buffer, Serase_buffer, 0, 0, "*",
2231 doc: /* Delete the entire contents of the current buffer.
2232 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2233 so the buffer is truly empty after this. */)
2234 (void)
2236 Fwiden ();
2238 del_range (BEG, Z);
2240 current_buffer->last_window_start = 1;
2241 /* Prevent warnings, or suspension of auto saving, that would happen
2242 if future size is less than past size. Use of erase-buffer
2243 implies that the future text is not really related to the past text. */
2244 XSETFASTINT (BVAR (current_buffer, save_length), 0);
2245 return Qnil;
2248 void
2249 validate_region (register Lisp_Object *b, register Lisp_Object *e)
2251 CHECK_NUMBER_COERCE_MARKER (*b);
2252 CHECK_NUMBER_COERCE_MARKER (*e);
2254 if (XINT (*b) > XINT (*e))
2256 Lisp_Object tem;
2257 tem = *b; *b = *e; *e = tem;
2260 if (! (BEGV <= XINT (*b) && XINT (*e) <= ZV))
2261 args_out_of_range (*b, *e);
2264 /* Advance BYTE_POS up to a character boundary
2265 and return the adjusted position. */
2267 static ptrdiff_t
2268 advance_to_char_boundary (ptrdiff_t byte_pos)
2270 int c;
2272 if (byte_pos == BEG)
2273 /* Beginning of buffer is always a character boundary. */
2274 return BEG;
2276 c = FETCH_BYTE (byte_pos);
2277 if (! CHAR_HEAD_P (c))
2279 /* We should advance BYTE_POS only when C is a constituent of a
2280 multibyte sequence. */
2281 ptrdiff_t orig_byte_pos = byte_pos;
2285 byte_pos--;
2286 c = FETCH_BYTE (byte_pos);
2288 while (! CHAR_HEAD_P (c) && byte_pos > BEG);
2289 INC_POS (byte_pos);
2290 if (byte_pos < orig_byte_pos)
2291 byte_pos = orig_byte_pos;
2292 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2293 surely advance to the correct character boundary. If C is
2294 not, BYTE_POS was unchanged. */
2297 return byte_pos;
2300 DEFUN ("buffer-swap-text", Fbuffer_swap_text, Sbuffer_swap_text,
2301 1, 1, 0,
2302 doc: /* Swap the text between current buffer and BUFFER. */)
2303 (Lisp_Object buffer)
2305 struct buffer *other_buffer;
2306 CHECK_BUFFER (buffer);
2307 other_buffer = XBUFFER (buffer);
2309 if (!BUFFER_LIVE_P (other_buffer))
2310 error ("Cannot swap a dead buffer's text");
2312 /* Actually, it probably works just fine.
2313 * if (other_buffer == current_buffer)
2314 * error ("Cannot swap a buffer's text with itself"); */
2316 /* Actually, this may be workable as well, tho probably only if they're
2317 *both* indirect. */
2318 if (other_buffer->base_buffer
2319 || current_buffer->base_buffer)
2320 error ("Cannot swap indirect buffers's text");
2322 { /* This is probably harder to make work. */
2323 struct buffer *other;
2324 FOR_EACH_BUFFER (other)
2325 if (other->base_buffer == other_buffer
2326 || other->base_buffer == current_buffer)
2327 error ("One of the buffers to swap has indirect buffers");
2330 #define swapfield(field, type) \
2331 do { \
2332 type tmp##field = other_buffer->field; \
2333 other_buffer->field = current_buffer->field; \
2334 current_buffer->field = tmp##field; \
2335 } while (0)
2336 #define swapfield_(field, type) \
2337 do { \
2338 type tmp##field = BVAR (other_buffer, field); \
2339 bset_##field (other_buffer, BVAR (current_buffer, field)); \
2340 bset_##field (current_buffer, tmp##field); \
2341 } while (0)
2343 swapfield (own_text, struct buffer_text);
2344 eassert (current_buffer->text == &current_buffer->own_text);
2345 eassert (other_buffer->text == &other_buffer->own_text);
2346 #ifdef REL_ALLOC
2347 r_alloc_reset_variable ((void **) &current_buffer->own_text.beg,
2348 (void **) &other_buffer->own_text.beg);
2349 r_alloc_reset_variable ((void **) &other_buffer->own_text.beg,
2350 (void **) &current_buffer->own_text.beg);
2351 #endif /* REL_ALLOC */
2353 swapfield (pt, ptrdiff_t);
2354 swapfield (pt_byte, ptrdiff_t);
2355 swapfield (begv, ptrdiff_t);
2356 swapfield (begv_byte, ptrdiff_t);
2357 swapfield (zv, ptrdiff_t);
2358 swapfield (zv_byte, ptrdiff_t);
2359 eassert (!current_buffer->base_buffer);
2360 eassert (!other_buffer->base_buffer);
2361 swapfield (indirections, ptrdiff_t);
2362 current_buffer->clip_changed = 1; other_buffer->clip_changed = 1;
2363 swapfield (newline_cache, struct region_cache *);
2364 swapfield (width_run_cache, struct region_cache *);
2365 current_buffer->prevent_redisplay_optimizations_p = 1;
2366 other_buffer->prevent_redisplay_optimizations_p = 1;
2367 swapfield (overlays_before, struct Lisp_Overlay *);
2368 swapfield (overlays_after, struct Lisp_Overlay *);
2369 swapfield (overlay_center, ptrdiff_t);
2370 swapfield_ (undo_list, Lisp_Object);
2371 swapfield_ (mark, Lisp_Object);
2372 swapfield_ (enable_multibyte_characters, Lisp_Object);
2373 swapfield_ (bidi_display_reordering, Lisp_Object);
2374 swapfield_ (bidi_paragraph_direction, Lisp_Object);
2375 /* FIXME: Not sure what we should do with these *_marker fields.
2376 Hopefully they're just nil anyway. */
2377 swapfield_ (pt_marker, Lisp_Object);
2378 swapfield_ (begv_marker, Lisp_Object);
2379 swapfield_ (zv_marker, Lisp_Object);
2380 bset_point_before_scroll (current_buffer, Qnil);
2381 bset_point_before_scroll (other_buffer, Qnil);
2383 current_buffer->text->modiff++; other_buffer->text->modiff++;
2384 current_buffer->text->chars_modiff++; other_buffer->text->chars_modiff++;
2385 current_buffer->text->overlay_modiff++; other_buffer->text->overlay_modiff++;
2386 current_buffer->text->beg_unchanged = current_buffer->text->gpt;
2387 current_buffer->text->end_unchanged = current_buffer->text->gpt;
2388 other_buffer->text->beg_unchanged = other_buffer->text->gpt;
2389 other_buffer->text->end_unchanged = other_buffer->text->gpt;
2391 struct Lisp_Marker *m;
2392 for (m = BUF_MARKERS (current_buffer); m; m = m->next)
2393 if (m->buffer == other_buffer)
2394 m->buffer = current_buffer;
2395 else
2396 /* Since there's no indirect buffer in sight, markers on
2397 BUF_MARKERS(buf) should either be for `buf' or dead. */
2398 eassert (!m->buffer);
2399 for (m = BUF_MARKERS (other_buffer); m; m = m->next)
2400 if (m->buffer == current_buffer)
2401 m->buffer = other_buffer;
2402 else
2403 /* Since there's no indirect buffer in sight, markers on
2404 BUF_MARKERS(buf) should either be for `buf' or dead. */
2405 eassert (!m->buffer);
2407 { /* Some of the C code expects that both window markers of a
2408 live window points to that window's buffer. So since we
2409 just swapped the markers between the two buffers, we need
2410 to undo the effect of this swap for window markers. */
2411 Lisp_Object w = Fselected_window (), ws = Qnil;
2412 Lisp_Object buf1, buf2;
2413 XSETBUFFER (buf1, current_buffer); XSETBUFFER (buf2, other_buffer);
2415 while (NILP (Fmemq (w, ws)))
2417 ws = Fcons (w, ws);
2418 if (MARKERP (XWINDOW (w)->pointm)
2419 && (EQ (XWINDOW (w)->contents, buf1)
2420 || EQ (XWINDOW (w)->contents, buf2)))
2421 Fset_marker (XWINDOW (w)->pointm,
2422 make_number
2423 (BUF_BEGV (XBUFFER (XWINDOW (w)->contents))),
2424 XWINDOW (w)->contents);
2425 if (MARKERP (XWINDOW (w)->start)
2426 && (EQ (XWINDOW (w)->contents, buf1)
2427 || EQ (XWINDOW (w)->contents, buf2)))
2428 Fset_marker (XWINDOW (w)->start,
2429 make_number
2430 (XBUFFER (XWINDOW (w)->contents)->last_window_start),
2431 XWINDOW (w)->contents);
2432 w = Fnext_window (w, Qt, Qt);
2436 if (current_buffer->text->intervals)
2437 (eassert (EQ (current_buffer->text->intervals->up.obj, buffer)),
2438 XSETBUFFER (current_buffer->text->intervals->up.obj, current_buffer));
2439 if (other_buffer->text->intervals)
2440 (eassert (EQ (other_buffer->text->intervals->up.obj, Fcurrent_buffer ())),
2441 XSETBUFFER (other_buffer->text->intervals->up.obj, other_buffer));
2443 return Qnil;
2446 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte, Sset_buffer_multibyte,
2447 1, 1, 0,
2448 doc: /* Set the multibyte flag of the current buffer to FLAG.
2449 If FLAG is t, this makes the buffer a multibyte buffer.
2450 If FLAG is nil, this makes the buffer a single-byte buffer.
2451 In these cases, the buffer contents remain unchanged as a sequence of
2452 bytes but the contents viewed as characters do change.
2453 If FLAG is `to', this makes the buffer a multibyte buffer by changing
2454 all eight-bit bytes to eight-bit characters.
2455 If the multibyte flag was really changed, undo information of the
2456 current buffer is cleared. */)
2457 (Lisp_Object flag)
2459 struct Lisp_Marker *tail, *markers;
2460 struct buffer *other;
2461 ptrdiff_t begv, zv;
2462 bool narrowed = (BEG != BEGV || Z != ZV);
2463 bool modified_p = !NILP (Fbuffer_modified_p (Qnil));
2464 Lisp_Object old_undo = BVAR (current_buffer, undo_list);
2465 struct gcpro gcpro1;
2467 if (current_buffer->base_buffer)
2468 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2470 /* Do nothing if nothing actually changes. */
2471 if (NILP (flag) == NILP (BVAR (current_buffer, enable_multibyte_characters)))
2472 return flag;
2474 GCPRO1 (old_undo);
2476 /* Don't record these buffer changes. We will put a special undo entry
2477 instead. */
2478 bset_undo_list (current_buffer, Qt);
2480 /* If the cached position is for this buffer, clear it out. */
2481 clear_charpos_cache (current_buffer);
2483 if (NILP (flag))
2484 begv = BEGV_BYTE, zv = ZV_BYTE;
2485 else
2486 begv = BEGV, zv = ZV;
2488 if (narrowed)
2489 error ("Changing multibyteness in a narrowed buffer");
2491 if (NILP (flag))
2493 ptrdiff_t pos, stop;
2494 unsigned char *p;
2496 /* Do this first, so it can use CHAR_TO_BYTE
2497 to calculate the old correspondences. */
2498 set_intervals_multibyte (0);
2500 bset_enable_multibyte_characters (current_buffer, Qnil);
2502 Z = Z_BYTE;
2503 BEGV = BEGV_BYTE;
2504 ZV = ZV_BYTE;
2505 GPT = GPT_BYTE;
2506 TEMP_SET_PT_BOTH (PT_BYTE, PT_BYTE);
2509 for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
2510 tail->charpos = tail->bytepos;
2512 /* Convert multibyte form of 8-bit characters to unibyte. */
2513 pos = BEG;
2514 stop = GPT;
2515 p = BEG_ADDR;
2516 while (1)
2518 int c, bytes;
2520 if (pos == stop)
2522 if (pos == Z)
2523 break;
2524 p = GAP_END_ADDR;
2525 stop = Z;
2527 if (ASCII_BYTE_P (*p))
2528 p++, pos++;
2529 else if (CHAR_BYTE8_HEAD_P (*p))
2531 c = STRING_CHAR_AND_LENGTH (p, bytes);
2532 /* Delete all bytes for this 8-bit character but the
2533 last one, and change the last one to the character
2534 code. */
2535 bytes--;
2536 del_range_2 (pos, pos, pos + bytes, pos + bytes, 0);
2537 p = GAP_END_ADDR;
2538 *p++ = c;
2539 pos++;
2540 if (begv > pos)
2541 begv -= bytes;
2542 if (zv > pos)
2543 zv -= bytes;
2544 stop = Z;
2546 else
2548 bytes = BYTES_BY_CHAR_HEAD (*p);
2549 p += bytes, pos += bytes;
2552 if (narrowed)
2553 Fnarrow_to_region (make_number (begv), make_number (zv));
2555 else
2557 ptrdiff_t pt = PT;
2558 ptrdiff_t pos, stop;
2559 unsigned char *p, *pend;
2561 /* Be sure not to have a multibyte sequence striding over the GAP.
2562 Ex: We change this: "...abc\302 _GAP_ \241def..."
2563 to: "...abc _GAP_ \302\241def..." */
2565 if (EQ (flag, Qt)
2566 && GPT_BYTE > 1 && GPT_BYTE < Z_BYTE
2567 && ! CHAR_HEAD_P (*(GAP_END_ADDR)))
2569 unsigned char *q = GPT_ADDR - 1;
2571 while (! CHAR_HEAD_P (*q) && q > BEG_ADDR) q--;
2572 if (LEADING_CODE_P (*q))
2574 ptrdiff_t new_gpt = GPT_BYTE - (GPT_ADDR - q);
2576 move_gap_both (new_gpt, new_gpt);
2580 /* Make the buffer contents valid as multibyte by converting
2581 8-bit characters to multibyte form. */
2582 pos = BEG;
2583 stop = GPT;
2584 p = BEG_ADDR;
2585 pend = GPT_ADDR;
2586 while (1)
2588 int bytes;
2590 if (pos == stop)
2592 if (pos == Z)
2593 break;
2594 p = GAP_END_ADDR;
2595 pend = Z_ADDR;
2596 stop = Z;
2599 if (ASCII_BYTE_P (*p))
2600 p++, pos++;
2601 else if (EQ (flag, Qt)
2602 && ! CHAR_BYTE8_HEAD_P (*p)
2603 && (bytes = MULTIBYTE_LENGTH (p, pend)) > 0)
2604 p += bytes, pos += bytes;
2605 else
2607 unsigned char tmp[MAX_MULTIBYTE_LENGTH];
2608 int c;
2610 c = BYTE8_TO_CHAR (*p);
2611 bytes = CHAR_STRING (c, tmp);
2612 *p = tmp[0];
2613 TEMP_SET_PT_BOTH (pos + 1, pos + 1);
2614 bytes--;
2615 insert_1_both ((char *) tmp + 1, bytes, bytes, 1, 0, 0);
2616 /* Now the gap is after the just inserted data. */
2617 pos = GPT;
2618 p = GAP_END_ADDR;
2619 if (pos <= begv)
2620 begv += bytes;
2621 if (pos <= zv)
2622 zv += bytes;
2623 if (pos <= pt)
2624 pt += bytes;
2625 pend = Z_ADDR;
2626 stop = Z;
2630 if (pt != PT)
2631 TEMP_SET_PT (pt);
2633 if (narrowed)
2634 Fnarrow_to_region (make_number (begv), make_number (zv));
2636 /* Do this first, so that chars_in_text asks the right question.
2637 set_intervals_multibyte needs it too. */
2638 bset_enable_multibyte_characters (current_buffer, Qt);
2640 GPT_BYTE = advance_to_char_boundary (GPT_BYTE);
2641 GPT = chars_in_text (BEG_ADDR, GPT_BYTE - BEG_BYTE) + BEG;
2643 Z = chars_in_text (GAP_END_ADDR, Z_BYTE - GPT_BYTE) + GPT;
2645 BEGV_BYTE = advance_to_char_boundary (BEGV_BYTE);
2646 if (BEGV_BYTE > GPT_BYTE)
2647 BEGV = chars_in_text (GAP_END_ADDR, BEGV_BYTE - GPT_BYTE) + GPT;
2648 else
2649 BEGV = chars_in_text (BEG_ADDR, BEGV_BYTE - BEG_BYTE) + BEG;
2651 ZV_BYTE = advance_to_char_boundary (ZV_BYTE);
2652 if (ZV_BYTE > GPT_BYTE)
2653 ZV = chars_in_text (GAP_END_ADDR, ZV_BYTE - GPT_BYTE) + GPT;
2654 else
2655 ZV = chars_in_text (BEG_ADDR, ZV_BYTE - BEG_BYTE) + BEG;
2658 ptrdiff_t byte = advance_to_char_boundary (PT_BYTE);
2659 ptrdiff_t position;
2661 if (byte > GPT_BYTE)
2662 position = chars_in_text (GAP_END_ADDR, byte - GPT_BYTE) + GPT;
2663 else
2664 position = chars_in_text (BEG_ADDR, byte - BEG_BYTE) + BEG;
2665 TEMP_SET_PT_BOTH (position, byte);
2668 tail = markers = BUF_MARKERS (current_buffer);
2670 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2671 getting confused by the markers that have not yet been updated.
2672 It is also a signal that it should never create a marker. */
2673 BUF_MARKERS (current_buffer) = NULL;
2675 for (; tail; tail = tail->next)
2677 tail->bytepos = advance_to_char_boundary (tail->bytepos);
2678 tail->charpos = BYTE_TO_CHAR (tail->bytepos);
2681 /* Make sure no markers were put on the chain
2682 while the chain value was incorrect. */
2683 if (BUF_MARKERS (current_buffer))
2684 emacs_abort ();
2686 BUF_MARKERS (current_buffer) = markers;
2688 /* Do this last, so it can calculate the new correspondences
2689 between chars and bytes. */
2690 set_intervals_multibyte (1);
2693 if (!EQ (old_undo, Qt))
2695 /* Represent all the above changes by a special undo entry. */
2696 bset_undo_list (current_buffer,
2697 Fcons (list3 (Qapply,
2698 intern ("set-buffer-multibyte"),
2699 NILP (flag) ? Qt : Qnil),
2700 old_undo));
2703 UNGCPRO;
2705 current_buffer->prevent_redisplay_optimizations_p = 1;
2707 /* If buffer is shown in a window, let redisplay consider other windows. */
2708 if (buffer_window_count (current_buffer))
2709 ++windows_or_buffers_changed;
2711 /* Copy this buffer's new multibyte status
2712 into all of its indirect buffers. */
2713 FOR_EACH_BUFFER (other)
2714 if (other->base_buffer == current_buffer && BUFFER_LIVE_P (other))
2716 BVAR (other, enable_multibyte_characters)
2717 = BVAR (current_buffer, enable_multibyte_characters);
2718 other->prevent_redisplay_optimizations_p = 1;
2721 /* Restore the modifiedness of the buffer. */
2722 if (!modified_p && !NILP (Fbuffer_modified_p (Qnil)))
2723 Fset_buffer_modified_p (Qnil);
2725 /* Update coding systems of this buffer's process (if any). */
2727 Lisp_Object process;
2729 process = Fget_buffer_process (Fcurrent_buffer ());
2730 if (PROCESSP (process))
2731 setup_process_coding_systems (process);
2734 return flag;
2737 DEFUN ("kill-all-local-variables", Fkill_all_local_variables,
2738 Skill_all_local_variables, 0, 0, 0,
2739 doc: /* Switch to Fundamental mode by killing current buffer's local variables.
2740 Most local variable bindings are eliminated so that the default values
2741 become effective once more. Also, the syntax table is set from
2742 `standard-syntax-table', the local keymap is set to nil,
2743 and the abbrev table from `fundamental-mode-abbrev-table'.
2744 This function also forces redisplay of the mode line.
2746 Every function to select a new major mode starts by
2747 calling this function.
2749 As a special exception, local variables whose names have
2750 a non-nil `permanent-local' property are not eliminated by this function.
2752 The first thing this function does is run
2753 the normal hook `change-major-mode-hook'. */)
2754 (void)
2756 Frun_hooks (1, &Qchange_major_mode_hook);
2758 /* Make sure none of the bindings in local_var_alist
2759 remain swapped in, in their symbols. */
2761 swap_out_buffer_local_variables (current_buffer);
2763 /* Actually eliminate all local bindings of this buffer. */
2765 reset_buffer_local_variables (current_buffer, 0);
2767 /* Force mode-line redisplay. Useful here because all major mode
2768 commands call this function. */
2769 update_mode_lines++;
2771 return Qnil;
2774 /* Make sure no local variables remain set up with buffer B
2775 for their current values. */
2777 static void
2778 swap_out_buffer_local_variables (struct buffer *b)
2780 Lisp_Object oalist, alist, buffer;
2782 XSETBUFFER (buffer, b);
2783 oalist = BVAR (b, local_var_alist);
2785 for (alist = oalist; CONSP (alist); alist = XCDR (alist))
2787 Lisp_Object sym = XCAR (XCAR (alist));
2788 eassert (XSYMBOL (sym)->redirect == SYMBOL_LOCALIZED);
2789 /* Need not do anything if some other buffer's binding is
2790 now cached. */
2791 if (EQ (SYMBOL_BLV (XSYMBOL (sym))->where, buffer))
2793 /* Symbol is set up for this buffer's old local value:
2794 swap it out! */
2795 swap_in_global_binding (XSYMBOL (sym));
2800 /* Find all the overlays in the current buffer that contain position POS.
2801 Return the number found, and store them in a vector in *VEC_PTR.
2802 Store in *LEN_PTR the size allocated for the vector.
2803 Store in *NEXT_PTR the next position after POS where an overlay starts,
2804 or ZV if there are no more overlays between POS and ZV.
2805 Store in *PREV_PTR the previous position before POS where an overlay ends,
2806 or where an overlay starts which ends at or after POS;
2807 or BEGV if there are no such overlays from BEGV to POS.
2808 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2810 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2811 when this function is called.
2813 If EXTEND, make the vector bigger if necessary.
2814 If not, never extend the vector,
2815 and store only as many overlays as will fit.
2816 But still return the total number of overlays.
2818 If CHANGE_REQ, any position written into *PREV_PTR or
2819 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2820 default (BEGV or ZV). */
2822 ptrdiff_t
2823 overlays_at (EMACS_INT pos, bool extend, Lisp_Object **vec_ptr,
2824 ptrdiff_t *len_ptr,
2825 ptrdiff_t *next_ptr, ptrdiff_t *prev_ptr, bool change_req)
2827 Lisp_Object overlay, start, end;
2828 struct Lisp_Overlay *tail;
2829 ptrdiff_t idx = 0;
2830 ptrdiff_t len = *len_ptr;
2831 Lisp_Object *vec = *vec_ptr;
2832 ptrdiff_t next = ZV;
2833 ptrdiff_t prev = BEGV;
2834 bool inhibit_storing = 0;
2836 for (tail = current_buffer->overlays_before; tail; tail = tail->next)
2838 ptrdiff_t startpos, endpos;
2840 XSETMISC (overlay, tail);
2842 start = OVERLAY_START (overlay);
2843 end = OVERLAY_END (overlay);
2844 endpos = OVERLAY_POSITION (end);
2845 if (endpos < pos)
2847 if (prev < endpos)
2848 prev = endpos;
2849 break;
2851 startpos = OVERLAY_POSITION (start);
2852 /* This one ends at or after POS
2853 so its start counts for PREV_PTR if it's before POS. */
2854 if (prev < startpos && startpos < pos)
2855 prev = startpos;
2856 if (endpos == pos)
2857 continue;
2858 if (startpos <= pos)
2860 if (idx == len)
2862 /* The supplied vector is full.
2863 Either make it bigger, or don't store any more in it. */
2864 if (extend)
2866 vec = xpalloc (vec, len_ptr, 1, OVERLAY_COUNT_MAX,
2867 sizeof *vec);
2868 *vec_ptr = vec;
2869 len = *len_ptr;
2871 else
2872 inhibit_storing = 1;
2875 if (!inhibit_storing)
2876 vec[idx] = overlay;
2877 /* Keep counting overlays even if we can't return them all. */
2878 idx++;
2880 else if (startpos < next)
2881 next = startpos;
2884 for (tail = current_buffer->overlays_after; tail; tail = tail->next)
2886 ptrdiff_t startpos, endpos;
2888 XSETMISC (overlay, tail);
2890 start = OVERLAY_START (overlay);
2891 end = OVERLAY_END (overlay);
2892 startpos = OVERLAY_POSITION (start);
2893 if (pos < startpos)
2895 if (startpos < next)
2896 next = startpos;
2897 break;
2899 endpos = OVERLAY_POSITION (end);
2900 if (pos < endpos)
2902 if (idx == len)
2904 if (extend)
2906 vec = xpalloc (vec, len_ptr, 1, OVERLAY_COUNT_MAX,
2907 sizeof *vec);
2908 *vec_ptr = vec;
2909 len = *len_ptr;
2911 else
2912 inhibit_storing = 1;
2915 if (!inhibit_storing)
2916 vec[idx] = overlay;
2917 idx++;
2919 if (startpos < pos && startpos > prev)
2920 prev = startpos;
2922 else if (endpos < pos && endpos > prev)
2923 prev = endpos;
2924 else if (endpos == pos && startpos > prev
2925 && (!change_req || startpos < pos))
2926 prev = startpos;
2929 if (next_ptr)
2930 *next_ptr = next;
2931 if (prev_ptr)
2932 *prev_ptr = prev;
2933 return idx;
2936 /* Find all the overlays in the current buffer that overlap the range
2937 BEG-END, or are empty at BEG, or are empty at END provided END
2938 denotes the position at the end of the current buffer.
2940 Return the number found, and store them in a vector in *VEC_PTR.
2941 Store in *LEN_PTR the size allocated for the vector.
2942 Store in *NEXT_PTR the next position after POS where an overlay starts,
2943 or ZV if there are no more overlays.
2944 Store in *PREV_PTR the previous position before POS where an overlay ends,
2945 or BEGV if there are no previous overlays.
2946 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2948 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2949 when this function is called.
2951 If EXTEND, make the vector bigger if necessary.
2952 If not, never extend the vector,
2953 and store only as many overlays as will fit.
2954 But still return the total number of overlays. */
2956 static ptrdiff_t
2957 overlays_in (EMACS_INT beg, EMACS_INT end, bool extend,
2958 Lisp_Object **vec_ptr, ptrdiff_t *len_ptr,
2959 ptrdiff_t *next_ptr, ptrdiff_t *prev_ptr)
2961 Lisp_Object overlay, ostart, oend;
2962 struct Lisp_Overlay *tail;
2963 ptrdiff_t idx = 0;
2964 ptrdiff_t len = *len_ptr;
2965 Lisp_Object *vec = *vec_ptr;
2966 ptrdiff_t next = ZV;
2967 ptrdiff_t prev = BEGV;
2968 bool inhibit_storing = 0;
2969 bool end_is_Z = end == Z;
2971 for (tail = current_buffer->overlays_before; tail; tail = tail->next)
2973 ptrdiff_t startpos, endpos;
2975 XSETMISC (overlay, tail);
2977 ostart = OVERLAY_START (overlay);
2978 oend = OVERLAY_END (overlay);
2979 endpos = OVERLAY_POSITION (oend);
2980 if (endpos < beg)
2982 if (prev < endpos)
2983 prev = endpos;
2984 break;
2986 startpos = OVERLAY_POSITION (ostart);
2987 /* Count an interval if it overlaps the range, is empty at the
2988 start of the range, or is empty at END provided END denotes the
2989 end of the buffer. */
2990 if ((beg < endpos && startpos < end)
2991 || (startpos == endpos
2992 && (beg == endpos || (end_is_Z && endpos == end))))
2994 if (idx == len)
2996 /* The supplied vector is full.
2997 Either make it bigger, or don't store any more in it. */
2998 if (extend)
3000 vec = xpalloc (vec, len_ptr, 1, OVERLAY_COUNT_MAX,
3001 sizeof *vec);
3002 *vec_ptr = vec;
3003 len = *len_ptr;
3005 else
3006 inhibit_storing = 1;
3009 if (!inhibit_storing)
3010 vec[idx] = overlay;
3011 /* Keep counting overlays even if we can't return them all. */
3012 idx++;
3014 else if (startpos < next)
3015 next = startpos;
3018 for (tail = current_buffer->overlays_after; tail; tail = tail->next)
3020 ptrdiff_t startpos, endpos;
3022 XSETMISC (overlay, tail);
3024 ostart = OVERLAY_START (overlay);
3025 oend = OVERLAY_END (overlay);
3026 startpos = OVERLAY_POSITION (ostart);
3027 if (end < startpos)
3029 if (startpos < next)
3030 next = startpos;
3031 break;
3033 endpos = OVERLAY_POSITION (oend);
3034 /* Count an interval if it overlaps the range, is empty at the
3035 start of the range, or is empty at END provided END denotes the
3036 end of the buffer. */
3037 if ((beg < endpos && startpos < end)
3038 || (startpos == endpos
3039 && (beg == endpos || (end_is_Z && endpos == end))))
3041 if (idx == len)
3043 if (extend)
3045 vec = xpalloc (vec, len_ptr, 1, OVERLAY_COUNT_MAX,
3046 sizeof *vec);
3047 *vec_ptr = vec;
3048 len = *len_ptr;
3050 else
3051 inhibit_storing = 1;
3054 if (!inhibit_storing)
3055 vec[idx] = overlay;
3056 idx++;
3058 else if (endpos < beg && endpos > prev)
3059 prev = endpos;
3062 if (next_ptr)
3063 *next_ptr = next;
3064 if (prev_ptr)
3065 *prev_ptr = prev;
3066 return idx;
3070 /* Return true if there exists an overlay with a non-nil
3071 `mouse-face' property overlapping OVERLAY. */
3073 bool
3074 mouse_face_overlay_overlaps (Lisp_Object overlay)
3076 ptrdiff_t start = OVERLAY_POSITION (OVERLAY_START (overlay));
3077 ptrdiff_t end = OVERLAY_POSITION (OVERLAY_END (overlay));
3078 ptrdiff_t n, i, size;
3079 Lisp_Object *v, tem;
3081 size = 10;
3082 v = alloca (size * sizeof *v);
3083 n = overlays_in (start, end, 0, &v, &size, NULL, NULL);
3084 if (n > size)
3086 v = alloca (n * sizeof *v);
3087 overlays_in (start, end, 0, &v, &n, NULL, NULL);
3090 for (i = 0; i < n; ++i)
3091 if (!EQ (v[i], overlay)
3092 && (tem = Foverlay_get (overlay, Qmouse_face),
3093 !NILP (tem)))
3094 break;
3096 return i < n;
3101 /* Fast function to just test if we're at an overlay boundary. */
3102 bool
3103 overlay_touches_p (ptrdiff_t pos)
3105 Lisp_Object overlay;
3106 struct Lisp_Overlay *tail;
3108 for (tail = current_buffer->overlays_before; tail; tail = tail->next)
3110 ptrdiff_t endpos;
3112 XSETMISC (overlay ,tail);
3113 eassert (OVERLAYP (overlay));
3115 endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
3116 if (endpos < pos)
3117 break;
3118 if (endpos == pos || OVERLAY_POSITION (OVERLAY_START (overlay)) == pos)
3119 return 1;
3122 for (tail = current_buffer->overlays_after; tail; tail = tail->next)
3124 ptrdiff_t startpos;
3126 XSETMISC (overlay, tail);
3127 eassert (OVERLAYP (overlay));
3129 startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
3130 if (pos < startpos)
3131 break;
3132 if (startpos == pos || OVERLAY_POSITION (OVERLAY_END (overlay)) == pos)
3133 return 1;
3135 return 0;
3138 struct sortvec
3140 Lisp_Object overlay;
3141 ptrdiff_t beg, end;
3142 EMACS_INT priority;
3145 static int
3146 compare_overlays (const void *v1, const void *v2)
3148 const struct sortvec *s1 = (const struct sortvec *) v1;
3149 const struct sortvec *s2 = (const struct sortvec *) v2;
3150 if (s1->priority != s2->priority)
3151 return s1->priority < s2->priority ? -1 : 1;
3152 if (s1->beg != s2->beg)
3153 return s1->beg < s2->beg ? -1 : 1;
3154 if (s1->end != s2->end)
3155 return s2->end < s1->end ? -1 : 1;
3156 /* Avoid the non-determinism of qsort by choosing an arbitrary ordering
3157 between "equal" overlays. The result can still change between
3158 invocations of Emacs, but it won't change in the middle of
3159 `find_field' (bug#6830). */
3160 if (!EQ (s1->overlay, s2->overlay))
3161 return XLI (s1->overlay) < XLI (s2->overlay) ? -1 : 1;
3162 return 0;
3165 /* Sort an array of overlays by priority. The array is modified in place.
3166 The return value is the new size; this may be smaller than the original
3167 size if some of the overlays were invalid or were window-specific. */
3168 ptrdiff_t
3169 sort_overlays (Lisp_Object *overlay_vec, ptrdiff_t noverlays, struct window *w)
3171 ptrdiff_t i, j;
3172 USE_SAFE_ALLOCA;
3173 struct sortvec *sortvec;
3175 SAFE_NALLOCA (sortvec, 1, noverlays);
3177 /* Put the valid and relevant overlays into sortvec. */
3179 for (i = 0, j = 0; i < noverlays; i++)
3181 Lisp_Object tem;
3182 Lisp_Object overlay;
3184 overlay = overlay_vec[i];
3185 if (OVERLAYP (overlay)
3186 && OVERLAY_POSITION (OVERLAY_START (overlay)) > 0
3187 && OVERLAY_POSITION (OVERLAY_END (overlay)) > 0)
3189 /* If we're interested in a specific window, then ignore
3190 overlays that are limited to some other window. */
3191 if (w)
3193 Lisp_Object window;
3195 window = Foverlay_get (overlay, Qwindow);
3196 if (WINDOWP (window) && XWINDOW (window) != w)
3197 continue;
3200 /* This overlay is good and counts: put it into sortvec. */
3201 sortvec[j].overlay = overlay;
3202 sortvec[j].beg = OVERLAY_POSITION (OVERLAY_START (overlay));
3203 sortvec[j].end = OVERLAY_POSITION (OVERLAY_END (overlay));
3204 tem = Foverlay_get (overlay, Qpriority);
3205 if (INTEGERP (tem))
3206 sortvec[j].priority = XINT (tem);
3207 else
3208 sortvec[j].priority = 0;
3209 j++;
3212 noverlays = j;
3214 /* Sort the overlays into the proper order: increasing priority. */
3216 if (noverlays > 1)
3217 qsort (sortvec, noverlays, sizeof (struct sortvec), compare_overlays);
3219 for (i = 0; i < noverlays; i++)
3220 overlay_vec[i] = sortvec[i].overlay;
3222 SAFE_FREE ();
3223 return (noverlays);
3226 struct sortstr
3228 Lisp_Object string, string2;
3229 ptrdiff_t size;
3230 EMACS_INT priority;
3233 struct sortstrlist
3235 struct sortstr *buf; /* An array that expands as needed; never freed. */
3236 ptrdiff_t size; /* Allocated length of that array. */
3237 ptrdiff_t used; /* How much of the array is currently in use. */
3238 ptrdiff_t bytes; /* Total length of the strings in buf. */
3241 /* Buffers for storing information about the overlays touching a given
3242 position. These could be automatic variables in overlay_strings, but
3243 it's more efficient to hold onto the memory instead of repeatedly
3244 allocating and freeing it. */
3245 static struct sortstrlist overlay_heads, overlay_tails;
3246 static unsigned char *overlay_str_buf;
3248 /* Allocated length of overlay_str_buf. */
3249 static ptrdiff_t overlay_str_len;
3251 /* A comparison function suitable for passing to qsort. */
3252 static int
3253 cmp_for_strings (const void *as1, const void *as2)
3255 struct sortstr *s1 = (struct sortstr *)as1;
3256 struct sortstr *s2 = (struct sortstr *)as2;
3257 if (s1->size != s2->size)
3258 return s2->size < s1->size ? -1 : 1;
3259 if (s1->priority != s2->priority)
3260 return s1->priority < s2->priority ? -1 : 1;
3261 return 0;
3264 static void
3265 record_overlay_string (struct sortstrlist *ssl, Lisp_Object str,
3266 Lisp_Object str2, Lisp_Object pri, ptrdiff_t size)
3268 ptrdiff_t nbytes;
3270 if (ssl->used == ssl->size)
3271 ssl->buf = xpalloc (ssl->buf, &ssl->size, 5, -1, sizeof *ssl->buf);
3272 ssl->buf[ssl->used].string = str;
3273 ssl->buf[ssl->used].string2 = str2;
3274 ssl->buf[ssl->used].size = size;
3275 ssl->buf[ssl->used].priority = (INTEGERP (pri) ? XINT (pri) : 0);
3276 ssl->used++;
3278 if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
3279 nbytes = SCHARS (str);
3280 else if (! STRING_MULTIBYTE (str))
3281 nbytes = count_size_as_multibyte (SDATA (str),
3282 SBYTES (str));
3283 else
3284 nbytes = SBYTES (str);
3286 if (INT_ADD_OVERFLOW (ssl->bytes, nbytes))
3287 memory_full (SIZE_MAX);
3288 ssl->bytes += nbytes;
3290 if (STRINGP (str2))
3292 if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
3293 nbytes = SCHARS (str2);
3294 else if (! STRING_MULTIBYTE (str2))
3295 nbytes = count_size_as_multibyte (SDATA (str2),
3296 SBYTES (str2));
3297 else
3298 nbytes = SBYTES (str2);
3300 if (INT_ADD_OVERFLOW (ssl->bytes, nbytes))
3301 memory_full (SIZE_MAX);
3302 ssl->bytes += nbytes;
3306 /* Return the concatenation of the strings associated with overlays that
3307 begin or end at POS, ignoring overlays that are specific to a window
3308 other than W. The strings are concatenated in the appropriate order:
3309 shorter overlays nest inside longer ones, and higher priority inside
3310 lower. Normally all of the after-strings come first, but zero-sized
3311 overlays have their after-strings ride along with the before-strings
3312 because it would look strange to print them inside-out.
3314 Returns the string length, and stores the contents indirectly through
3315 PSTR, if that variable is non-null. The string may be overwritten by
3316 subsequent calls. */
3318 ptrdiff_t
3319 overlay_strings (ptrdiff_t pos, struct window *w, unsigned char **pstr)
3321 Lisp_Object overlay, window, str;
3322 struct Lisp_Overlay *ov;
3323 ptrdiff_t startpos, endpos;
3324 bool multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
3326 overlay_heads.used = overlay_heads.bytes = 0;
3327 overlay_tails.used = overlay_tails.bytes = 0;
3328 for (ov = current_buffer->overlays_before; ov; ov = ov->next)
3330 XSETMISC (overlay, ov);
3331 eassert (OVERLAYP (overlay));
3333 startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
3334 endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
3335 if (endpos < pos)
3336 break;
3337 if (endpos != pos && startpos != pos)
3338 continue;
3339 window = Foverlay_get (overlay, Qwindow);
3340 if (WINDOWP (window) && XWINDOW (window) != w)
3341 continue;
3342 if (startpos == pos
3343 && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str)))
3344 record_overlay_string (&overlay_heads, str,
3345 (startpos == endpos
3346 ? Foverlay_get (overlay, Qafter_string)
3347 : Qnil),
3348 Foverlay_get (overlay, Qpriority),
3349 endpos - startpos);
3350 else if (endpos == pos
3351 && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str)))
3352 record_overlay_string (&overlay_tails, str, Qnil,
3353 Foverlay_get (overlay, Qpriority),
3354 endpos - startpos);
3356 for (ov = current_buffer->overlays_after; ov; ov = ov->next)
3358 XSETMISC (overlay, ov);
3359 eassert (OVERLAYP (overlay));
3361 startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
3362 endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
3363 if (startpos > pos)
3364 break;
3365 if (endpos != pos && startpos != pos)
3366 continue;
3367 window = Foverlay_get (overlay, Qwindow);
3368 if (WINDOWP (window) && XWINDOW (window) != w)
3369 continue;
3370 if (startpos == pos
3371 && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str)))
3372 record_overlay_string (&overlay_heads, str,
3373 (startpos == endpos
3374 ? Foverlay_get (overlay, Qafter_string)
3375 : Qnil),
3376 Foverlay_get (overlay, Qpriority),
3377 endpos - startpos);
3378 else if (endpos == pos
3379 && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str)))
3380 record_overlay_string (&overlay_tails, str, Qnil,
3381 Foverlay_get (overlay, Qpriority),
3382 endpos - startpos);
3384 if (overlay_tails.used > 1)
3385 qsort (overlay_tails.buf, overlay_tails.used, sizeof (struct sortstr),
3386 cmp_for_strings);
3387 if (overlay_heads.used > 1)
3388 qsort (overlay_heads.buf, overlay_heads.used, sizeof (struct sortstr),
3389 cmp_for_strings);
3390 if (overlay_heads.bytes || overlay_tails.bytes)
3392 Lisp_Object tem;
3393 ptrdiff_t i;
3394 unsigned char *p;
3395 ptrdiff_t total;
3397 if (INT_ADD_OVERFLOW (overlay_heads.bytes, overlay_tails.bytes))
3398 memory_full (SIZE_MAX);
3399 total = overlay_heads.bytes + overlay_tails.bytes;
3400 if (total > overlay_str_len)
3401 overlay_str_buf = xpalloc (overlay_str_buf, &overlay_str_len,
3402 total - overlay_str_len, -1, 1);
3404 p = overlay_str_buf;
3405 for (i = overlay_tails.used; --i >= 0;)
3407 ptrdiff_t nbytes;
3408 tem = overlay_tails.buf[i].string;
3409 nbytes = copy_text (SDATA (tem), p,
3410 SBYTES (tem),
3411 STRING_MULTIBYTE (tem), multibyte);
3412 p += nbytes;
3414 for (i = 0; i < overlay_heads.used; ++i)
3416 ptrdiff_t nbytes;
3417 tem = overlay_heads.buf[i].string;
3418 nbytes = copy_text (SDATA (tem), p,
3419 SBYTES (tem),
3420 STRING_MULTIBYTE (tem), multibyte);
3421 p += nbytes;
3422 tem = overlay_heads.buf[i].string2;
3423 if (STRINGP (tem))
3425 nbytes = copy_text (SDATA (tem), p,
3426 SBYTES (tem),
3427 STRING_MULTIBYTE (tem), multibyte);
3428 p += nbytes;
3431 if (p != overlay_str_buf + total)
3432 emacs_abort ();
3433 if (pstr)
3434 *pstr = overlay_str_buf;
3435 return total;
3437 return 0;
3440 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3442 void
3443 recenter_overlay_lists (struct buffer *buf, ptrdiff_t pos)
3445 Lisp_Object overlay, beg, end;
3446 struct Lisp_Overlay *prev, *tail, *next;
3448 /* See if anything in overlays_before should move to overlays_after. */
3450 /* We don't strictly need prev in this loop; it should always be nil.
3451 But we use it for symmetry and in case that should cease to be true
3452 with some future change. */
3453 prev = NULL;
3454 for (tail = buf->overlays_before; tail; prev = tail, tail = next)
3456 next = tail->next;
3457 XSETMISC (overlay, tail);
3458 eassert (OVERLAYP (overlay));
3460 beg = OVERLAY_START (overlay);
3461 end = OVERLAY_END (overlay);
3463 if (OVERLAY_POSITION (end) > pos)
3465 /* OVERLAY needs to be moved. */
3466 ptrdiff_t where = OVERLAY_POSITION (beg);
3467 struct Lisp_Overlay *other, *other_prev;
3469 /* Splice the cons cell TAIL out of overlays_before. */
3470 if (prev)
3471 prev->next = next;
3472 else
3473 set_buffer_overlays_before (buf, next);
3475 /* Search thru overlays_after for where to put it. */
3476 other_prev = NULL;
3477 for (other = buf->overlays_after; other;
3478 other_prev = other, other = other->next)
3480 Lisp_Object otherbeg, otheroverlay;
3482 XSETMISC (otheroverlay, other);
3483 eassert (OVERLAYP (otheroverlay));
3485 otherbeg = OVERLAY_START (otheroverlay);
3486 if (OVERLAY_POSITION (otherbeg) >= where)
3487 break;
3490 /* Add TAIL to overlays_after before OTHER. */
3491 tail->next = other;
3492 if (other_prev)
3493 other_prev->next = tail;
3494 else
3495 set_buffer_overlays_after (buf, tail);
3496 tail = prev;
3498 else
3499 /* We've reached the things that should stay in overlays_before.
3500 All the rest of overlays_before must end even earlier,
3501 so stop now. */
3502 break;
3505 /* See if anything in overlays_after should be in overlays_before. */
3506 prev = NULL;
3507 for (tail = buf->overlays_after; tail; prev = tail, tail = next)
3509 next = tail->next;
3510 XSETMISC (overlay, tail);
3511 eassert (OVERLAYP (overlay));
3513 beg = OVERLAY_START (overlay);
3514 end = OVERLAY_END (overlay);
3516 /* Stop looking, when we know that nothing further
3517 can possibly end before POS. */
3518 if (OVERLAY_POSITION (beg) > pos)
3519 break;
3521 if (OVERLAY_POSITION (end) <= pos)
3523 /* OVERLAY needs to be moved. */
3524 ptrdiff_t where = OVERLAY_POSITION (end);
3525 struct Lisp_Overlay *other, *other_prev;
3527 /* Splice the cons cell TAIL out of overlays_after. */
3528 if (prev)
3529 prev->next = next;
3530 else
3531 set_buffer_overlays_after (buf, next);
3533 /* Search thru overlays_before for where to put it. */
3534 other_prev = NULL;
3535 for (other = buf->overlays_before; other;
3536 other_prev = other, other = other->next)
3538 Lisp_Object otherend, otheroverlay;
3540 XSETMISC (otheroverlay, other);
3541 eassert (OVERLAYP (otheroverlay));
3543 otherend = OVERLAY_END (otheroverlay);
3544 if (OVERLAY_POSITION (otherend) <= where)
3545 break;
3548 /* Add TAIL to overlays_before before OTHER. */
3549 tail->next = other;
3550 if (other_prev)
3551 other_prev->next = tail;
3552 else
3553 set_buffer_overlays_before (buf, tail);
3554 tail = prev;
3558 buf->overlay_center = pos;
3561 void
3562 adjust_overlays_for_insert (ptrdiff_t pos, ptrdiff_t length)
3564 /* After an insertion, the lists are still sorted properly,
3565 but we may need to update the value of the overlay center. */
3566 if (current_buffer->overlay_center >= pos)
3567 current_buffer->overlay_center += length;
3570 void
3571 adjust_overlays_for_delete (ptrdiff_t pos, ptrdiff_t length)
3573 if (current_buffer->overlay_center < pos)
3574 /* The deletion was to our right. No change needed; the before- and
3575 after-lists are still consistent. */
3577 else if (current_buffer->overlay_center - pos > length)
3578 /* The deletion was to our left. We need to adjust the center value
3579 to account for the change in position, but the lists are consistent
3580 given the new value. */
3581 current_buffer->overlay_center -= length;
3582 else
3583 /* We're right in the middle. There might be things on the after-list
3584 that now belong on the before-list. Recentering will move them,
3585 and also update the center point. */
3586 recenter_overlay_lists (current_buffer, pos);
3589 /* Fix up overlays that were garbled as a result of permuting markers
3590 in the range START through END. Any overlay with at least one
3591 endpoint in this range will need to be unlinked from the overlay
3592 list and reinserted in its proper place.
3593 Such an overlay might even have negative size at this point.
3594 If so, we'll make the overlay empty. */
3595 void
3596 fix_start_end_in_overlays (register ptrdiff_t start, register ptrdiff_t end)
3598 Lisp_Object overlay;
3599 struct Lisp_Overlay *before_list IF_LINT (= NULL);
3600 struct Lisp_Overlay *after_list IF_LINT (= NULL);
3601 /* These are either nil, indicating that before_list or after_list
3602 should be assigned, or the cons cell the cdr of which should be
3603 assigned. */
3604 struct Lisp_Overlay *beforep = NULL, *afterp = NULL;
3605 /* 'Parent', likewise, indicates a cons cell or
3606 current_buffer->overlays_before or overlays_after, depending
3607 which loop we're in. */
3608 struct Lisp_Overlay *tail, *parent;
3609 ptrdiff_t startpos, endpos;
3611 /* This algorithm shifts links around instead of consing and GCing.
3612 The loop invariant is that before_list (resp. after_list) is a
3613 well-formed list except that its last element, the CDR of beforep
3614 (resp. afterp) if beforep (afterp) isn't nil or before_list
3615 (after_list) if it is, is still uninitialized. So it's not a bug
3616 that before_list isn't initialized, although it may look
3617 strange. */
3618 for (parent = NULL, tail = current_buffer->overlays_before; tail;)
3620 XSETMISC (overlay, tail);
3622 endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
3623 startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
3625 /* If the overlay is backwards, make it empty. */
3626 if (endpos < startpos)
3628 startpos = endpos;
3629 Fset_marker (OVERLAY_START (overlay), make_number (startpos),
3630 Qnil);
3633 if (endpos < start)
3634 break;
3636 if (endpos < end
3637 || (startpos >= start && startpos < end))
3639 /* Add it to the end of the wrong list. Later on,
3640 recenter_overlay_lists will move it to the right place. */
3641 if (endpos < current_buffer->overlay_center)
3643 if (!afterp)
3644 after_list = tail;
3645 else
3646 afterp->next = tail;
3647 afterp = tail;
3649 else
3651 if (!beforep)
3652 before_list = tail;
3653 else
3654 beforep->next = tail;
3655 beforep = tail;
3657 if (!parent)
3658 set_buffer_overlays_before (current_buffer, tail->next);
3659 else
3660 parent->next = tail->next;
3661 tail = tail->next;
3663 else
3664 parent = tail, tail = parent->next;
3666 for (parent = NULL, tail = current_buffer->overlays_after; tail;)
3668 XSETMISC (overlay, tail);
3670 startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
3671 endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
3673 /* If the overlay is backwards, make it empty. */
3674 if (endpos < startpos)
3676 startpos = endpos;
3677 Fset_marker (OVERLAY_START (overlay), make_number (startpos),
3678 Qnil);
3681 if (startpos >= end)
3682 break;
3684 if (startpos >= start
3685 || (endpos >= start && endpos < end))
3687 if (endpos < current_buffer->overlay_center)
3689 if (!afterp)
3690 after_list = tail;
3691 else
3692 afterp->next = tail;
3693 afterp = tail;
3695 else
3697 if (!beforep)
3698 before_list = tail;
3699 else
3700 beforep->next = tail;
3701 beforep = tail;
3703 if (!parent)
3704 set_buffer_overlays_after (current_buffer, tail->next);
3705 else
3706 parent->next = tail->next;
3707 tail = tail->next;
3709 else
3710 parent = tail, tail = parent->next;
3713 /* Splice the constructed (wrong) lists into the buffer's lists,
3714 and let the recenter function make it sane again. */
3715 if (beforep)
3717 beforep->next = current_buffer->overlays_before;
3718 set_buffer_overlays_before (current_buffer, before_list);
3721 if (afterp)
3723 afterp->next = current_buffer->overlays_after;
3724 set_buffer_overlays_after (current_buffer, after_list);
3726 recenter_overlay_lists (current_buffer, current_buffer->overlay_center);
3729 /* We have two types of overlay: the one whose ending marker is
3730 after-insertion-marker (this is the usual case) and the one whose
3731 ending marker is before-insertion-marker. When `overlays_before'
3732 contains overlays of the latter type and the former type in this
3733 order and both overlays end at inserting position, inserting a text
3734 increases only the ending marker of the latter type, which results
3735 in incorrect ordering of `overlays_before'.
3737 This function fixes ordering of overlays in the slot
3738 `overlays_before' of the buffer *BP. Before the insertion, `point'
3739 was at PREV, and now is at POS. */
3741 void
3742 fix_overlays_before (struct buffer *bp, ptrdiff_t prev, ptrdiff_t pos)
3744 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3745 struct Lisp_Overlay *tail = bp->overlays_before, *parent = NULL, *right_pair;
3746 Lisp_Object tem;
3747 ptrdiff_t end IF_LINT (= 0);
3749 /* After the insertion, the several overlays may be in incorrect
3750 order. The possibility is that, in the list `overlays_before',
3751 an overlay which ends at POS appears after an overlay which ends
3752 at PREV. Since POS is greater than PREV, we must fix the
3753 ordering of these overlays, by moving overlays ends at POS before
3754 the overlays ends at PREV. */
3756 /* At first, find a place where disordered overlays should be linked
3757 in. It is where an overlay which end before POS exists. (i.e. an
3758 overlay whose ending marker is after-insertion-marker if disorder
3759 exists). */
3760 while (tail
3761 && (XSETMISC (tem, tail),
3762 (end = OVERLAY_POSITION (OVERLAY_END (tem))) >= pos))
3764 parent = tail;
3765 tail = tail->next;
3768 /* If we don't find such an overlay,
3769 or the found one ends before PREV,
3770 or the found one is the last one in the list,
3771 we don't have to fix anything. */
3772 if (!tail || end < prev || !tail->next)
3773 return;
3775 right_pair = parent;
3776 parent = tail;
3777 tail = tail->next;
3779 /* Now, end position of overlays in the list TAIL should be before
3780 or equal to PREV. In the loop, an overlay which ends at POS is
3781 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3782 we found an overlay which ends before PREV, the remaining
3783 overlays are in correct order. */
3784 while (tail)
3786 XSETMISC (tem, tail);
3787 end = OVERLAY_POSITION (OVERLAY_END (tem));
3789 if (end == pos)
3790 { /* This overlay is disordered. */
3791 struct Lisp_Overlay *found = tail;
3793 /* Unlink the found overlay. */
3794 tail = found->next;
3795 parent->next = tail;
3796 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3797 and link it into the right place. */
3798 if (!right_pair)
3800 found->next = bp->overlays_before;
3801 set_buffer_overlays_before (bp, found);
3803 else
3805 found->next = right_pair->next;
3806 right_pair->next = found;
3809 else if (end == prev)
3811 parent = tail;
3812 tail = tail->next;
3814 else /* No more disordered overlay. */
3815 break;
3819 DEFUN ("overlayp", Foverlayp, Soverlayp, 1, 1, 0,
3820 doc: /* Return t if OBJECT is an overlay. */)
3821 (Lisp_Object object)
3823 return (OVERLAYP (object) ? Qt : Qnil);
3826 DEFUN ("make-overlay", Fmake_overlay, Smake_overlay, 2, 5, 0,
3827 doc: /* Create a new overlay with range BEG to END in BUFFER.
3828 If omitted, BUFFER defaults to the current buffer.
3829 BEG and END may be integers or markers.
3830 The fourth arg FRONT-ADVANCE, if non-nil, makes the marker
3831 for the front of the overlay advance when text is inserted there
3832 \(which means the text *is not* included in the overlay).
3833 The fifth arg REAR-ADVANCE, if non-nil, makes the marker
3834 for the rear of the overlay advance when text is inserted there
3835 \(which means the text *is* included in the overlay). */)
3836 (Lisp_Object beg, Lisp_Object end, Lisp_Object buffer, Lisp_Object front_advance, Lisp_Object rear_advance)
3838 Lisp_Object overlay;
3839 struct buffer *b;
3841 if (NILP (buffer))
3842 XSETBUFFER (buffer, current_buffer);
3843 else
3844 CHECK_BUFFER (buffer);
3845 if (MARKERP (beg)
3846 && ! EQ (Fmarker_buffer (beg), buffer))
3847 error ("Marker points into wrong buffer");
3848 if (MARKERP (end)
3849 && ! EQ (Fmarker_buffer (end), buffer))
3850 error ("Marker points into wrong buffer");
3852 CHECK_NUMBER_COERCE_MARKER (beg);
3853 CHECK_NUMBER_COERCE_MARKER (end);
3855 if (XINT (beg) > XINT (end))
3857 Lisp_Object temp;
3858 temp = beg; beg = end; end = temp;
3861 b = XBUFFER (buffer);
3863 beg = Fset_marker (Fmake_marker (), beg, buffer);
3864 end = Fset_marker (Fmake_marker (), end, buffer);
3866 if (!NILP (front_advance))
3867 XMARKER (beg)->insertion_type = 1;
3868 if (!NILP (rear_advance))
3869 XMARKER (end)->insertion_type = 1;
3871 overlay = build_overlay (beg, end, Qnil);
3873 /* Put the new overlay on the wrong list. */
3874 end = OVERLAY_END (overlay);
3875 if (OVERLAY_POSITION (end) < b->overlay_center)
3877 eassert (b->overlays_after || (XOVERLAY (overlay)->next == NULL));
3878 XOVERLAY (overlay)->next = b->overlays_after;
3879 set_buffer_overlays_after (b, XOVERLAY (overlay));
3881 else
3883 eassert (b->overlays_before || (XOVERLAY (overlay)->next == NULL));
3884 XOVERLAY (overlay)->next = b->overlays_before;
3885 set_buffer_overlays_before (b, XOVERLAY (overlay));
3887 /* This puts it in the right list, and in the right order. */
3888 recenter_overlay_lists (b, b->overlay_center);
3890 /* We don't need to redisplay the region covered by the overlay, because
3891 the overlay has no properties at the moment. */
3893 return overlay;
3896 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3898 static void
3899 modify_overlay (struct buffer *buf, ptrdiff_t start, ptrdiff_t end)
3901 if (start > end)
3903 ptrdiff_t temp = start;
3904 start = end;
3905 end = temp;
3908 BUF_COMPUTE_UNCHANGED (buf, start, end);
3910 /* If BUF is visible, consider updating the display if ... */
3911 if (buffer_window_count (buf) > 0)
3913 /* ... it's visible in other window than selected, */
3914 if (buf != XBUFFER (XWINDOW (selected_window)->contents))
3915 windows_or_buffers_changed = 1;
3916 /* ... or if we modify an overlay at the end of the buffer
3917 and so we cannot be sure that window end is still valid. */
3918 else if (end >= ZV && start <= ZV)
3919 windows_or_buffers_changed = 1;
3922 ++BUF_OVERLAY_MODIFF (buf);
3925 /* Remove OVERLAY from LIST. */
3927 static struct Lisp_Overlay *
3928 unchain_overlay (struct Lisp_Overlay *list, struct Lisp_Overlay *overlay)
3930 register struct Lisp_Overlay *tail, **prev = &list;
3932 for (tail = list; tail; prev = &tail->next, tail = *prev)
3933 if (tail == overlay)
3935 *prev = overlay->next;
3936 overlay->next = NULL;
3937 break;
3939 return list;
3942 /* Remove OVERLAY from both overlay lists of B. */
3944 static void
3945 unchain_both (struct buffer *b, Lisp_Object overlay)
3947 struct Lisp_Overlay *ov = XOVERLAY (overlay);
3949 set_buffer_overlays_before (b, unchain_overlay (b->overlays_before, ov));
3950 set_buffer_overlays_after (b, unchain_overlay (b->overlays_after, ov));
3951 eassert (XOVERLAY (overlay)->next == NULL);
3954 DEFUN ("move-overlay", Fmove_overlay, Smove_overlay, 3, 4, 0,
3955 doc: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3956 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3957 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3958 buffer. */)
3959 (Lisp_Object overlay, Lisp_Object beg, Lisp_Object end, Lisp_Object buffer)
3961 struct buffer *b, *ob = 0;
3962 Lisp_Object obuffer;
3963 ptrdiff_t count = SPECPDL_INDEX ();
3964 ptrdiff_t n_beg, n_end, o_beg IF_LINT (= 0), o_end IF_LINT (= 0);
3966 CHECK_OVERLAY (overlay);
3967 if (NILP (buffer))
3968 buffer = Fmarker_buffer (OVERLAY_START (overlay));
3969 if (NILP (buffer))
3970 XSETBUFFER (buffer, current_buffer);
3971 CHECK_BUFFER (buffer);
3973 if (NILP (Fbuffer_live_p (buffer)))
3974 error ("Attempt to move overlay to a dead buffer");
3976 if (MARKERP (beg)
3977 && ! EQ (Fmarker_buffer (beg), buffer))
3978 error ("Marker points into wrong buffer");
3979 if (MARKERP (end)
3980 && ! EQ (Fmarker_buffer (end), buffer))
3981 error ("Marker points into wrong buffer");
3983 CHECK_NUMBER_COERCE_MARKER (beg);
3984 CHECK_NUMBER_COERCE_MARKER (end);
3986 if (XINT (beg) > XINT (end))
3988 Lisp_Object temp;
3989 temp = beg; beg = end; end = temp;
3992 specbind (Qinhibit_quit, Qt);
3994 obuffer = Fmarker_buffer (OVERLAY_START (overlay));
3995 b = XBUFFER (buffer);
3997 if (!NILP (obuffer))
3999 ob = XBUFFER (obuffer);
4001 o_beg = OVERLAY_POSITION (OVERLAY_START (overlay));
4002 o_end = OVERLAY_POSITION (OVERLAY_END (overlay));
4004 unchain_both (ob, overlay);
4007 /* Set the overlay boundaries, which may clip them. */
4008 Fset_marker (OVERLAY_START (overlay), beg, buffer);
4009 Fset_marker (OVERLAY_END (overlay), end, buffer);
4011 n_beg = marker_position (OVERLAY_START (overlay));
4012 n_end = marker_position (OVERLAY_END (overlay));
4014 /* If the overlay has changed buffers, do a thorough redisplay. */
4015 if (!EQ (buffer, obuffer))
4017 /* Redisplay where the overlay was. */
4018 if (ob)
4019 modify_overlay (ob, o_beg, o_end);
4021 /* Redisplay where the overlay is going to be. */
4022 modify_overlay (b, n_beg, n_end);
4024 else
4025 /* Redisplay the area the overlay has just left, or just enclosed. */
4027 if (o_beg == n_beg)
4028 modify_overlay (b, o_end, n_end);
4029 else if (o_end == n_end)
4030 modify_overlay (b, o_beg, n_beg);
4031 else
4032 modify_overlay (b, min (o_beg, n_beg), max (o_end, n_end));
4035 /* Delete the overlay if it is empty after clipping and has the
4036 evaporate property. */
4037 if (n_beg == n_end && !NILP (Foverlay_get (overlay, Qevaporate)))
4038 return unbind_to (count, Fdelete_overlay (overlay));
4040 /* Put the overlay into the new buffer's overlay lists, first on the
4041 wrong list. */
4042 if (n_end < b->overlay_center)
4044 XOVERLAY (overlay)->next = b->overlays_after;
4045 set_buffer_overlays_after (b, XOVERLAY (overlay));
4047 else
4049 XOVERLAY (overlay)->next = b->overlays_before;
4050 set_buffer_overlays_before (b, XOVERLAY (overlay));
4053 /* This puts it in the right list, and in the right order. */
4054 recenter_overlay_lists (b, b->overlay_center);
4056 return unbind_to (count, overlay);
4059 DEFUN ("delete-overlay", Fdelete_overlay, Sdelete_overlay, 1, 1, 0,
4060 doc: /* Delete the overlay OVERLAY from its buffer. */)
4061 (Lisp_Object overlay)
4063 Lisp_Object buffer;
4064 struct buffer *b;
4065 ptrdiff_t count = SPECPDL_INDEX ();
4067 CHECK_OVERLAY (overlay);
4069 buffer = Fmarker_buffer (OVERLAY_START (overlay));
4070 if (NILP (buffer))
4071 return Qnil;
4073 b = XBUFFER (buffer);
4074 specbind (Qinhibit_quit, Qt);
4076 unchain_both (b, overlay);
4077 drop_overlay (b, XOVERLAY (overlay));
4079 /* When deleting an overlay with before or after strings, turn off
4080 display optimizations for the affected buffer, on the basis that
4081 these strings may contain newlines. This is easier to do than to
4082 check for that situation during redisplay. */
4083 if (!windows_or_buffers_changed
4084 && (!NILP (Foverlay_get (overlay, Qbefore_string))
4085 || !NILP (Foverlay_get (overlay, Qafter_string))))
4086 b->prevent_redisplay_optimizations_p = 1;
4088 return unbind_to (count, Qnil);
4091 DEFUN ("delete-all-overlays", Fdelete_all_overlays, Sdelete_all_overlays, 0, 1, 0,
4092 doc: /* Delete all overlays of BUFFER.
4093 BUFFER omitted or nil means delete all overlays of the current
4094 buffer. */)
4095 (Lisp_Object buffer)
4097 register struct buffer *buf;
4099 if (NILP (buffer))
4100 buf = current_buffer;
4101 else
4103 CHECK_BUFFER (buffer);
4104 buf = XBUFFER (buffer);
4107 delete_all_overlays (buf);
4108 return Qnil;
4111 /* Overlay dissection functions. */
4113 DEFUN ("overlay-start", Foverlay_start, Soverlay_start, 1, 1, 0,
4114 doc: /* Return the position at which OVERLAY starts. */)
4115 (Lisp_Object overlay)
4117 CHECK_OVERLAY (overlay);
4119 return (Fmarker_position (OVERLAY_START (overlay)));
4122 DEFUN ("overlay-end", Foverlay_end, Soverlay_end, 1, 1, 0,
4123 doc: /* Return the position at which OVERLAY ends. */)
4124 (Lisp_Object overlay)
4126 CHECK_OVERLAY (overlay);
4128 return (Fmarker_position (OVERLAY_END (overlay)));
4131 DEFUN ("overlay-buffer", Foverlay_buffer, Soverlay_buffer, 1, 1, 0,
4132 doc: /* Return the buffer OVERLAY belongs to.
4133 Return nil if OVERLAY has been deleted. */)
4134 (Lisp_Object overlay)
4136 CHECK_OVERLAY (overlay);
4138 return Fmarker_buffer (OVERLAY_START (overlay));
4141 DEFUN ("overlay-properties", Foverlay_properties, Soverlay_properties, 1, 1, 0,
4142 doc: /* Return a list of the properties on OVERLAY.
4143 This is a copy of OVERLAY's plist; modifying its conses has no effect on
4144 OVERLAY. */)
4145 (Lisp_Object overlay)
4147 CHECK_OVERLAY (overlay);
4149 return Fcopy_sequence (XOVERLAY (overlay)->plist);
4153 DEFUN ("overlays-at", Foverlays_at, Soverlays_at, 1, 1, 0,
4154 doc: /* Return a list of the overlays that contain the character at POS. */)
4155 (Lisp_Object pos)
4157 ptrdiff_t len, noverlays;
4158 Lisp_Object *overlay_vec;
4159 Lisp_Object result;
4161 CHECK_NUMBER_COERCE_MARKER (pos);
4163 len = 10;
4164 /* We can't use alloca here because overlays_at can call xrealloc. */
4165 overlay_vec = xmalloc (len * sizeof *overlay_vec);
4167 /* Put all the overlays we want in a vector in overlay_vec.
4168 Store the length in len. */
4169 noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
4170 NULL, NULL, 0);
4172 /* Make a list of them all. */
4173 result = Flist (noverlays, overlay_vec);
4175 xfree (overlay_vec);
4176 return result;
4179 DEFUN ("overlays-in", Foverlays_in, Soverlays_in, 2, 2, 0,
4180 doc: /* Return a list of the overlays that overlap the region BEG ... END.
4181 Overlap means that at least one character is contained within the overlay
4182 and also contained within the specified region.
4183 Empty overlays are included in the result if they are located at BEG,
4184 between BEG and END, or at END provided END denotes the position at the
4185 end of the buffer. */)
4186 (Lisp_Object beg, Lisp_Object end)
4188 ptrdiff_t len, noverlays;
4189 Lisp_Object *overlay_vec;
4190 Lisp_Object result;
4192 CHECK_NUMBER_COERCE_MARKER (beg);
4193 CHECK_NUMBER_COERCE_MARKER (end);
4195 len = 10;
4196 overlay_vec = xmalloc (len * sizeof *overlay_vec);
4198 /* Put all the overlays we want in a vector in overlay_vec.
4199 Store the length in len. */
4200 noverlays = overlays_in (XINT (beg), XINT (end), 1, &overlay_vec, &len,
4201 NULL, NULL);
4203 /* Make a list of them all. */
4204 result = Flist (noverlays, overlay_vec);
4206 xfree (overlay_vec);
4207 return result;
4210 DEFUN ("next-overlay-change", Fnext_overlay_change, Snext_overlay_change,
4211 1, 1, 0,
4212 doc: /* Return the next position after POS where an overlay starts or ends.
4213 If there are no overlay boundaries from POS to (point-max),
4214 the value is (point-max). */)
4215 (Lisp_Object pos)
4217 ptrdiff_t i, len, noverlays;
4218 ptrdiff_t endpos;
4219 Lisp_Object *overlay_vec;
4221 CHECK_NUMBER_COERCE_MARKER (pos);
4223 len = 10;
4224 overlay_vec = xmalloc (len * sizeof *overlay_vec);
4226 /* Put all the overlays we want in a vector in overlay_vec.
4227 Store the length in len.
4228 endpos gets the position where the next overlay starts. */
4229 noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
4230 &endpos, 0, 1);
4232 /* If any of these overlays ends before endpos,
4233 use its ending point instead. */
4234 for (i = 0; i < noverlays; i++)
4236 Lisp_Object oend;
4237 ptrdiff_t oendpos;
4239 oend = OVERLAY_END (overlay_vec[i]);
4240 oendpos = OVERLAY_POSITION (oend);
4241 if (oendpos < endpos)
4242 endpos = oendpos;
4245 xfree (overlay_vec);
4246 return make_number (endpos);
4249 DEFUN ("previous-overlay-change", Fprevious_overlay_change,
4250 Sprevious_overlay_change, 1, 1, 0,
4251 doc: /* Return the previous position before POS where an overlay starts or ends.
4252 If there are no overlay boundaries from (point-min) to POS,
4253 the value is (point-min). */)
4254 (Lisp_Object pos)
4256 ptrdiff_t prevpos;
4257 Lisp_Object *overlay_vec;
4258 ptrdiff_t len;
4260 CHECK_NUMBER_COERCE_MARKER (pos);
4262 /* At beginning of buffer, we know the answer;
4263 avoid bug subtracting 1 below. */
4264 if (XINT (pos) == BEGV)
4265 return pos;
4267 len = 10;
4268 overlay_vec = xmalloc (len * sizeof *overlay_vec);
4270 /* Put all the overlays we want in a vector in overlay_vec.
4271 Store the length in len.
4272 prevpos gets the position of the previous change. */
4273 overlays_at (XINT (pos), 1, &overlay_vec, &len,
4274 0, &prevpos, 1);
4276 xfree (overlay_vec);
4277 return make_number (prevpos);
4280 /* These functions are for debugging overlays. */
4282 DEFUN ("overlay-lists", Foverlay_lists, Soverlay_lists, 0, 0, 0,
4283 doc: /* Return a pair of lists giving all the overlays of the current buffer.
4284 The car has all the overlays before the overlay center;
4285 the cdr has all the overlays after the overlay center.
4286 Recentering overlays moves overlays between these lists.
4287 The lists you get are copies, so that changing them has no effect.
4288 However, the overlays you get are the real objects that the buffer uses. */)
4289 (void)
4291 struct Lisp_Overlay *ol;
4292 Lisp_Object before = Qnil, after = Qnil, tmp;
4294 for (ol = current_buffer->overlays_before; ol; ol = ol->next)
4296 XSETMISC (tmp, ol);
4297 before = Fcons (tmp, before);
4299 for (ol = current_buffer->overlays_after; ol; ol = ol->next)
4301 XSETMISC (tmp, ol);
4302 after = Fcons (tmp, after);
4305 return Fcons (Fnreverse (before), Fnreverse (after));
4308 DEFUN ("overlay-recenter", Foverlay_recenter, Soverlay_recenter, 1, 1, 0,
4309 doc: /* Recenter the overlays of the current buffer around position POS.
4310 That makes overlay lookup faster for positions near POS (but perhaps slower
4311 for positions far away from POS). */)
4312 (Lisp_Object pos)
4314 ptrdiff_t p;
4315 CHECK_NUMBER_COERCE_MARKER (pos);
4317 p = clip_to_bounds (PTRDIFF_MIN, XINT (pos), PTRDIFF_MAX);
4318 recenter_overlay_lists (current_buffer, p);
4319 return Qnil;
4322 DEFUN ("overlay-get", Foverlay_get, Soverlay_get, 2, 2, 0,
4323 doc: /* Get the property of overlay OVERLAY with property name PROP. */)
4324 (Lisp_Object overlay, Lisp_Object prop)
4326 CHECK_OVERLAY (overlay);
4327 return lookup_char_property (XOVERLAY (overlay)->plist, prop, 0);
4330 DEFUN ("overlay-put", Foverlay_put, Soverlay_put, 3, 3, 0,
4331 doc: /* Set one property of overlay OVERLAY: give property PROP value VALUE.
4332 VALUE will be returned.*/)
4333 (Lisp_Object overlay, Lisp_Object prop, Lisp_Object value)
4335 Lisp_Object tail, buffer;
4336 bool changed;
4338 CHECK_OVERLAY (overlay);
4340 buffer = Fmarker_buffer (OVERLAY_START (overlay));
4342 for (tail = XOVERLAY (overlay)->plist;
4343 CONSP (tail) && CONSP (XCDR (tail));
4344 tail = XCDR (XCDR (tail)))
4345 if (EQ (XCAR (tail), prop))
4347 changed = !EQ (XCAR (XCDR (tail)), value);
4348 XSETCAR (XCDR (tail), value);
4349 goto found;
4351 /* It wasn't in the list, so add it to the front. */
4352 changed = !NILP (value);
4353 set_overlay_plist
4354 (overlay, Fcons (prop, Fcons (value, XOVERLAY (overlay)->plist)));
4355 found:
4356 if (! NILP (buffer))
4358 if (changed)
4359 modify_overlay (XBUFFER (buffer),
4360 marker_position (OVERLAY_START (overlay)),
4361 marker_position (OVERLAY_END (overlay)));
4362 if (EQ (prop, Qevaporate) && ! NILP (value)
4363 && (OVERLAY_POSITION (OVERLAY_START (overlay))
4364 == OVERLAY_POSITION (OVERLAY_END (overlay))))
4365 Fdelete_overlay (overlay);
4368 return value;
4371 /* Subroutine of report_overlay_modification. */
4373 /* Lisp vector holding overlay hook functions to call.
4374 Vector elements come in pairs.
4375 Each even-index element is a list of hook functions.
4376 The following odd-index element is the overlay they came from.
4378 Before the buffer change, we fill in this vector
4379 as we call overlay hook functions.
4380 After the buffer change, we get the functions to call from this vector.
4381 This way we always call the same functions before and after the change. */
4382 static Lisp_Object last_overlay_modification_hooks;
4384 /* Number of elements actually used in last_overlay_modification_hooks. */
4385 static ptrdiff_t last_overlay_modification_hooks_used;
4387 /* Add one functionlist/overlay pair
4388 to the end of last_overlay_modification_hooks. */
4390 static void
4391 add_overlay_mod_hooklist (Lisp_Object functionlist, Lisp_Object overlay)
4393 ptrdiff_t oldsize = ASIZE (last_overlay_modification_hooks);
4395 if (oldsize - 1 <= last_overlay_modification_hooks_used)
4396 last_overlay_modification_hooks =
4397 larger_vector (last_overlay_modification_hooks, 2, -1);
4398 ASET (last_overlay_modification_hooks, last_overlay_modification_hooks_used,
4399 functionlist); last_overlay_modification_hooks_used++;
4400 ASET (last_overlay_modification_hooks, last_overlay_modification_hooks_used,
4401 overlay); last_overlay_modification_hooks_used++;
4404 /* Run the modification-hooks of overlays that include
4405 any part of the text in START to END.
4406 If this change is an insertion, also
4407 run the insert-before-hooks of overlay starting at END,
4408 and the insert-after-hooks of overlay ending at START.
4410 This is called both before and after the modification.
4411 AFTER is true when we call after the modification.
4413 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4414 When AFTER is nonzero, they are the start position,
4415 the position after the inserted new text,
4416 and the length of deleted or replaced old text. */
4418 void
4419 report_overlay_modification (Lisp_Object start, Lisp_Object end, bool after,
4420 Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3)
4422 Lisp_Object prop, overlay;
4423 struct Lisp_Overlay *tail;
4424 /* True if this change is an insertion. */
4425 bool insertion = (after ? XFASTINT (arg3) == 0 : EQ (start, end));
4426 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
4428 overlay = Qnil;
4429 tail = NULL;
4431 /* We used to run the functions as soon as we found them and only register
4432 them in last_overlay_modification_hooks for the purpose of the `after'
4433 case. But running elisp code as we traverse the list of overlays is
4434 painful because the list can be modified by the elisp code so we had to
4435 copy at several places. We now simply do a read-only traversal that
4436 only collects the functions to run and we run them afterwards. It's
4437 simpler, especially since all the code was already there. -stef */
4439 if (!after)
4441 /* We are being called before a change.
4442 Scan the overlays to find the functions to call. */
4443 last_overlay_modification_hooks_used = 0;
4444 for (tail = current_buffer->overlays_before; tail; tail = tail->next)
4446 ptrdiff_t startpos, endpos;
4447 Lisp_Object ostart, oend;
4449 XSETMISC (overlay, tail);
4451 ostart = OVERLAY_START (overlay);
4452 oend = OVERLAY_END (overlay);
4453 endpos = OVERLAY_POSITION (oend);
4454 if (XFASTINT (start) > endpos)
4455 break;
4456 startpos = OVERLAY_POSITION (ostart);
4457 if (insertion && (XFASTINT (start) == startpos
4458 || XFASTINT (end) == startpos))
4460 prop = Foverlay_get (overlay, Qinsert_in_front_hooks);
4461 if (!NILP (prop))
4462 add_overlay_mod_hooklist (prop, overlay);
4464 if (insertion && (XFASTINT (start) == endpos
4465 || XFASTINT (end) == endpos))
4467 prop = Foverlay_get (overlay, Qinsert_behind_hooks);
4468 if (!NILP (prop))
4469 add_overlay_mod_hooklist (prop, overlay);
4471 /* Test for intersecting intervals. This does the right thing
4472 for both insertion and deletion. */
4473 if (XFASTINT (end) > startpos && XFASTINT (start) < endpos)
4475 prop = Foverlay_get (overlay, Qmodification_hooks);
4476 if (!NILP (prop))
4477 add_overlay_mod_hooklist (prop, overlay);
4481 for (tail = current_buffer->overlays_after; tail; tail = tail->next)
4483 ptrdiff_t startpos, endpos;
4484 Lisp_Object ostart, oend;
4486 XSETMISC (overlay, tail);
4488 ostart = OVERLAY_START (overlay);
4489 oend = OVERLAY_END (overlay);
4490 startpos = OVERLAY_POSITION (ostart);
4491 endpos = OVERLAY_POSITION (oend);
4492 if (XFASTINT (end) < startpos)
4493 break;
4494 if (insertion && (XFASTINT (start) == startpos
4495 || XFASTINT (end) == startpos))
4497 prop = Foverlay_get (overlay, Qinsert_in_front_hooks);
4498 if (!NILP (prop))
4499 add_overlay_mod_hooklist (prop, overlay);
4501 if (insertion && (XFASTINT (start) == endpos
4502 || XFASTINT (end) == endpos))
4504 prop = Foverlay_get (overlay, Qinsert_behind_hooks);
4505 if (!NILP (prop))
4506 add_overlay_mod_hooklist (prop, overlay);
4508 /* Test for intersecting intervals. This does the right thing
4509 for both insertion and deletion. */
4510 if (XFASTINT (end) > startpos && XFASTINT (start) < endpos)
4512 prop = Foverlay_get (overlay, Qmodification_hooks);
4513 if (!NILP (prop))
4514 add_overlay_mod_hooklist (prop, overlay);
4519 GCPRO4 (overlay, arg1, arg2, arg3);
4521 /* Call the functions recorded in last_overlay_modification_hooks.
4522 First copy the vector contents, in case some of these hooks
4523 do subsequent modification of the buffer. */
4524 ptrdiff_t size = last_overlay_modification_hooks_used;
4525 Lisp_Object *copy = alloca (size * sizeof *copy);
4526 ptrdiff_t i;
4528 memcpy (copy, XVECTOR (last_overlay_modification_hooks)->contents,
4529 size * word_size);
4530 gcpro1.var = copy;
4531 gcpro1.nvars = size;
4533 for (i = 0; i < size;)
4535 Lisp_Object prop_i, overlay_i;
4536 prop_i = copy[i++];
4537 overlay_i = copy[i++];
4538 call_overlay_mod_hooks (prop_i, overlay_i, after, arg1, arg2, arg3);
4541 UNGCPRO;
4544 static void
4545 call_overlay_mod_hooks (Lisp_Object list, Lisp_Object overlay, bool after,
4546 Lisp_Object arg1, Lisp_Object arg2, Lisp_Object arg3)
4548 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
4550 GCPRO4 (list, arg1, arg2, arg3);
4552 while (CONSP (list))
4554 if (NILP (arg3))
4555 call4 (XCAR (list), overlay, after ? Qt : Qnil, arg1, arg2);
4556 else
4557 call5 (XCAR (list), overlay, after ? Qt : Qnil, arg1, arg2, arg3);
4558 list = XCDR (list);
4560 UNGCPRO;
4563 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4564 property is set. */
4565 void
4566 evaporate_overlays (ptrdiff_t pos)
4568 Lisp_Object overlay, hit_list;
4569 struct Lisp_Overlay *tail;
4571 hit_list = Qnil;
4572 if (pos <= current_buffer->overlay_center)
4573 for (tail = current_buffer->overlays_before; tail; tail = tail->next)
4575 ptrdiff_t endpos;
4576 XSETMISC (overlay, tail);
4577 endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
4578 if (endpos < pos)
4579 break;
4580 if (endpos == pos && OVERLAY_POSITION (OVERLAY_START (overlay)) == pos
4581 && ! NILP (Foverlay_get (overlay, Qevaporate)))
4582 hit_list = Fcons (overlay, hit_list);
4584 else
4585 for (tail = current_buffer->overlays_after; tail; tail = tail->next)
4587 ptrdiff_t startpos;
4588 XSETMISC (overlay, tail);
4589 startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
4590 if (startpos > pos)
4591 break;
4592 if (startpos == pos && OVERLAY_POSITION (OVERLAY_END (overlay)) == pos
4593 && ! NILP (Foverlay_get (overlay, Qevaporate)))
4594 hit_list = Fcons (overlay, hit_list);
4596 for (; CONSP (hit_list); hit_list = XCDR (hit_list))
4597 Fdelete_overlay (XCAR (hit_list));
4600 /***********************************************************************
4601 Allocation with mmap
4602 ***********************************************************************/
4604 #ifdef USE_MMAP_FOR_BUFFERS
4606 #include <sys/mman.h>
4608 #ifndef MAP_ANON
4609 #ifdef MAP_ANONYMOUS
4610 #define MAP_ANON MAP_ANONYMOUS
4611 #else
4612 #define MAP_ANON 0
4613 #endif
4614 #endif
4616 #ifndef MAP_FAILED
4617 #define MAP_FAILED ((void *) -1)
4618 #endif
4620 #if MAP_ANON == 0
4621 #include <fcntl.h>
4622 #endif
4624 #include "coding.h"
4627 /* Memory is allocated in regions which are mapped using mmap(2).
4628 The current implementation lets the system select mapped
4629 addresses; we're not using MAP_FIXED in general, except when
4630 trying to enlarge regions.
4632 Each mapped region starts with a mmap_region structure, the user
4633 area starts after that structure, aligned to MEM_ALIGN.
4635 +-----------------------+
4636 | struct mmap_info + |
4637 | padding |
4638 +-----------------------+
4639 | user data |
4642 +-----------------------+ */
4644 struct mmap_region
4646 /* User-specified size. */
4647 size_t nbytes_specified;
4649 /* Number of bytes mapped */
4650 size_t nbytes_mapped;
4652 /* Pointer to the location holding the address of the memory
4653 allocated with the mmap'd block. The variable actually points
4654 after this structure. */
4655 void **var;
4657 /* Next and previous in list of all mmap'd regions. */
4658 struct mmap_region *next, *prev;
4661 /* Doubly-linked list of mmap'd regions. */
4663 static struct mmap_region *mmap_regions;
4665 /* File descriptor for mmap. If we don't have anonymous mapping,
4666 /dev/zero will be opened on it. */
4668 static int mmap_fd;
4670 /* Temporary storage for mmap_set_vars, see there. */
4672 static struct mmap_region *mmap_regions_1;
4673 static int mmap_fd_1;
4675 /* Page size on this system. */
4677 static int mmap_page_size;
4679 /* 1 means mmap has been initialized. */
4681 static bool mmap_initialized_p;
4683 /* Value is X rounded up to the next multiple of N. */
4685 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4687 /* Size of mmap_region structure plus padding. */
4689 #define MMAP_REGION_STRUCT_SIZE \
4690 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4692 /* Given a pointer P to the start of the user-visible part of a mapped
4693 region, return a pointer to the start of the region. */
4695 #define MMAP_REGION(P) \
4696 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4698 /* Given a pointer P to the start of a mapped region, return a pointer
4699 to the start of the user-visible part of the region. */
4701 #define MMAP_USER_AREA(P) \
4702 ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4704 #define MEM_ALIGN sizeof (double)
4706 /* Predicate returning true if part of the address range [START .. END]
4707 is currently mapped. Used to prevent overwriting an existing
4708 memory mapping.
4710 Default is to conservatively assume the address range is occupied by
4711 something else. This can be overridden by system configuration
4712 files if system-specific means to determine this exists. */
4714 #ifndef MMAP_ALLOCATED_P
4715 #define MMAP_ALLOCATED_P(start, end) 1
4716 #endif
4718 /* Perform necessary initializations for the use of mmap. */
4720 static void
4721 mmap_init (void)
4723 #if MAP_ANON == 0
4724 /* The value of mmap_fd is initially 0 in temacs, and -1
4725 in a dumped Emacs. */
4726 if (mmap_fd <= 0)
4728 /* No anonymous mmap -- we need the file descriptor. */
4729 mmap_fd = emacs_open ("/dev/zero", O_RDONLY, 0);
4730 if (mmap_fd == -1)
4731 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno));
4733 #endif /* MAP_ANON == 0 */
4735 if (mmap_initialized_p)
4736 return;
4737 mmap_initialized_p = 1;
4739 #if MAP_ANON != 0
4740 mmap_fd = -1;
4741 #endif
4743 mmap_page_size = getpagesize ();
4746 /* Return a region overlapping address range START...END, or null if
4747 none. END is not including, i.e. the last byte in the range
4748 is at END - 1. */
4750 static struct mmap_region *
4751 mmap_find (void *start, void *end)
4753 struct mmap_region *r;
4754 char *s = (char *) start, *e = (char *) end;
4756 for (r = mmap_regions; r; r = r->next)
4758 char *rstart = (char *) r;
4759 char *rend = rstart + r->nbytes_mapped;
4761 if (/* First byte of range, i.e. START, in this region? */
4762 (s >= rstart && s < rend)
4763 /* Last byte of range, i.e. END - 1, in this region? */
4764 || (e > rstart && e <= rend)
4765 /* First byte of this region in the range? */
4766 || (rstart >= s && rstart < e)
4767 /* Last byte of this region in the range? */
4768 || (rend > s && rend <= e))
4769 break;
4772 return r;
4776 /* Unmap a region. P is a pointer to the start of the user-araa of
4777 the region. */
4779 static void
4780 mmap_free_1 (struct mmap_region *r)
4782 if (r->next)
4783 r->next->prev = r->prev;
4784 if (r->prev)
4785 r->prev->next = r->next;
4786 else
4787 mmap_regions = r->next;
4789 if (munmap (r, r->nbytes_mapped) == -1)
4790 fprintf (stderr, "munmap: %s\n", emacs_strerror (errno));
4794 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4795 Value is true if successful. */
4797 static bool
4798 mmap_enlarge (struct mmap_region *r, int npages)
4800 char *region_end = (char *) r + r->nbytes_mapped;
4801 size_t nbytes;
4802 bool success = 0;
4804 if (npages < 0)
4806 /* Unmap pages at the end of the region. */
4807 nbytes = - npages * mmap_page_size;
4808 if (munmap (region_end - nbytes, nbytes) == -1)
4809 fprintf (stderr, "munmap: %s\n", emacs_strerror (errno));
4810 else
4812 r->nbytes_mapped -= nbytes;
4813 success = 1;
4816 else if (npages > 0)
4818 nbytes = npages * mmap_page_size;
4820 /* Try to map additional pages at the end of the region. We
4821 cannot do this if the address range is already occupied by
4822 something else because mmap deletes any previous mapping.
4823 I'm not sure this is worth doing, let's see. */
4824 if (!MMAP_ALLOCATED_P (region_end, region_end + nbytes))
4826 void *p;
4828 p = mmap (region_end, nbytes, PROT_READ | PROT_WRITE,
4829 MAP_ANON | MAP_PRIVATE | MAP_FIXED, mmap_fd, 0);
4830 if (p == MAP_FAILED)
4831 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4832 else if (p != region_end)
4834 /* Kernels are free to choose a different address. In
4835 that case, unmap what we've mapped above; we have
4836 no use for it. */
4837 if (munmap (p, nbytes) == -1)
4838 fprintf (stderr, "munmap: %s\n", emacs_strerror (errno));
4840 else
4842 r->nbytes_mapped += nbytes;
4843 success = 1;
4848 return success;
4852 /* Set or reset variables holding references to mapped regions.
4853 If not RESTORE_P, set all variables to null. If RESTORE_P, set all
4854 variables to the start of the user-areas of mapped regions.
4856 This function is called from Fdump_emacs to ensure that the dumped
4857 Emacs doesn't contain references to memory that won't be mapped
4858 when Emacs starts. */
4860 void
4861 mmap_set_vars (bool restore_p)
4863 struct mmap_region *r;
4865 if (restore_p)
4867 mmap_regions = mmap_regions_1;
4868 mmap_fd = mmap_fd_1;
4869 for (r = mmap_regions; r; r = r->next)
4870 *r->var = MMAP_USER_AREA (r);
4872 else
4874 for (r = mmap_regions; r; r = r->next)
4875 *r->var = NULL;
4876 mmap_regions_1 = mmap_regions;
4877 mmap_regions = NULL;
4878 mmap_fd_1 = mmap_fd;
4879 mmap_fd = -1;
4884 /* Allocate a block of storage large enough to hold NBYTES bytes of
4885 data. A pointer to the data is returned in *VAR. VAR is thus the
4886 address of some variable which will use the data area.
4888 The allocation of 0 bytes is valid.
4890 If we can't allocate the necessary memory, set *VAR to null, and
4891 return null. */
4893 static void *
4894 mmap_alloc (void **var, size_t nbytes)
4896 void *p;
4897 size_t map;
4899 mmap_init ();
4901 map = ROUND (nbytes + MMAP_REGION_STRUCT_SIZE, mmap_page_size);
4902 p = mmap (NULL, map, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE,
4903 mmap_fd, 0);
4905 if (p == MAP_FAILED)
4907 if (errno != ENOMEM)
4908 fprintf (stderr, "mmap: %s\n", emacs_strerror (errno));
4909 p = NULL;
4911 else
4913 struct mmap_region *r = (struct mmap_region *) p;
4915 r->nbytes_specified = nbytes;
4916 r->nbytes_mapped = map;
4917 r->var = var;
4918 r->prev = NULL;
4919 r->next = mmap_regions;
4920 if (r->next)
4921 r->next->prev = r;
4922 mmap_regions = r;
4924 p = MMAP_USER_AREA (p);
4927 return *var = p;
4931 /* Free a block of relocatable storage whose data is pointed to by
4932 PTR. Store 0 in *PTR to show there's no block allocated. */
4934 static void
4935 mmap_free (void **var)
4937 mmap_init ();
4939 if (*var)
4941 mmap_free_1 (MMAP_REGION (*var));
4942 *var = NULL;
4947 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4948 resize it to size NBYTES. Change *VAR to reflect the new block,
4949 and return this value. If more memory cannot be allocated, then
4950 leave *VAR unchanged, and return null. */
4952 static void *
4953 mmap_realloc (void **var, size_t nbytes)
4955 void *result;
4957 mmap_init ();
4959 if (*var == NULL)
4960 result = mmap_alloc (var, nbytes);
4961 else if (nbytes == 0)
4963 mmap_free (var);
4964 result = mmap_alloc (var, nbytes);
4966 else
4968 struct mmap_region *r = MMAP_REGION (*var);
4969 size_t room = r->nbytes_mapped - MMAP_REGION_STRUCT_SIZE;
4971 if (room < nbytes)
4973 /* Must enlarge. */
4974 void *old_ptr = *var;
4976 /* Try to map additional pages at the end of the region.
4977 If that fails, allocate a new region, copy data
4978 from the old region, then free it. */
4979 if (mmap_enlarge (r, (ROUND (nbytes - room, mmap_page_size)
4980 / mmap_page_size)))
4982 r->nbytes_specified = nbytes;
4983 *var = result = old_ptr;
4985 else if (mmap_alloc (var, nbytes))
4987 memcpy (*var, old_ptr, r->nbytes_specified);
4988 mmap_free_1 (MMAP_REGION (old_ptr));
4989 result = *var;
4990 r = MMAP_REGION (result);
4991 r->nbytes_specified = nbytes;
4993 else
4995 *var = old_ptr;
4996 result = NULL;
4999 else if (room - nbytes >= mmap_page_size)
5001 /* Shrinking by at least a page. Let's give some
5002 memory back to the system.
5004 The extra parens are to make the division happens first,
5005 on positive values, so we know it will round towards
5006 zero. */
5007 mmap_enlarge (r, - ((room - nbytes) / mmap_page_size));
5008 result = *var;
5009 r->nbytes_specified = nbytes;
5011 else
5013 /* Leave it alone. */
5014 result = *var;
5015 r->nbytes_specified = nbytes;
5019 return result;
5023 #endif /* USE_MMAP_FOR_BUFFERS */
5027 /***********************************************************************
5028 Buffer-text Allocation
5029 ***********************************************************************/
5031 /* Allocate NBYTES bytes for buffer B's text buffer. */
5033 static void
5034 alloc_buffer_text (struct buffer *b, ptrdiff_t nbytes)
5036 void *p;
5038 block_input ();
5039 #if defined USE_MMAP_FOR_BUFFERS
5040 p = mmap_alloc ((void **) &b->text->beg, nbytes);
5041 #elif defined REL_ALLOC
5042 p = r_alloc ((void **) &b->text->beg, nbytes);
5043 #else
5044 p = xmalloc (nbytes);
5045 #endif
5047 if (p == NULL)
5049 unblock_input ();
5050 memory_full (nbytes);
5053 b->text->beg = (unsigned char *) p;
5054 unblock_input ();
5057 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
5058 shrink it. */
5060 void
5061 enlarge_buffer_text (struct buffer *b, ptrdiff_t delta)
5063 void *p;
5064 ptrdiff_t nbytes = (BUF_Z_BYTE (b) - BUF_BEG_BYTE (b) + BUF_GAP_SIZE (b) + 1
5065 + delta);
5066 block_input ();
5067 #if defined USE_MMAP_FOR_BUFFERS
5068 p = mmap_realloc ((void **) &b->text->beg, nbytes);
5069 #elif defined REL_ALLOC
5070 p = r_re_alloc ((void **) &b->text->beg, nbytes);
5071 #else
5072 p = xrealloc (b->text->beg, nbytes);
5073 #endif
5075 if (p == NULL)
5077 unblock_input ();
5078 memory_full (nbytes);
5081 BUF_BEG_ADDR (b) = (unsigned char *) p;
5082 unblock_input ();
5086 /* Free buffer B's text buffer. */
5088 static void
5089 free_buffer_text (struct buffer *b)
5091 block_input ();
5093 #if defined USE_MMAP_FOR_BUFFERS
5094 mmap_free ((void **) &b->text->beg);
5095 #elif defined REL_ALLOC
5096 r_alloc_free ((void **) &b->text->beg);
5097 #else
5098 xfree (b->text->beg);
5099 #endif
5101 BUF_BEG_ADDR (b) = NULL;
5102 unblock_input ();
5107 /***********************************************************************
5108 Initialization
5109 ***********************************************************************/
5111 void
5112 init_buffer_once (void)
5114 int idx;
5116 memset (buffer_permanent_local_flags, 0, sizeof buffer_permanent_local_flags);
5118 /* Make sure all markable slots in buffer_defaults
5119 are initialized reasonably, so mark_buffer won't choke. */
5120 reset_buffer (&buffer_defaults);
5121 eassert (EQ (BVAR (&buffer_defaults, name), make_number (0)));
5122 reset_buffer_local_variables (&buffer_defaults, 1);
5123 eassert (EQ (BVAR (&buffer_local_symbols, name), make_number (0)));
5124 reset_buffer (&buffer_local_symbols);
5125 reset_buffer_local_variables (&buffer_local_symbols, 1);
5126 /* Prevent GC from getting confused. */
5127 buffer_defaults.text = &buffer_defaults.own_text;
5128 buffer_local_symbols.text = &buffer_local_symbols.own_text;
5129 /* No one will share the text with these buffers, but let's play it safe. */
5130 buffer_defaults.indirections = 0;
5131 buffer_local_symbols.indirections = 0;
5132 /* Likewise no one will display them. */
5133 buffer_defaults.window_count = 0;
5134 buffer_local_symbols.window_count = 0;
5135 set_buffer_intervals (&buffer_defaults, NULL);
5136 set_buffer_intervals (&buffer_local_symbols, NULL);
5137 /* This is not strictly necessary, but let's make them initialized. */
5138 bset_name (&buffer_defaults, build_pure_c_string (" *buffer-defaults*"));
5139 bset_name (&buffer_local_symbols, build_pure_c_string (" *buffer-local-symbols*"));
5140 BUFFER_PVEC_INIT (&buffer_defaults);
5141 BUFFER_PVEC_INIT (&buffer_local_symbols);
5143 /* Set up the default values of various buffer slots. */
5144 /* Must do these before making the first buffer! */
5146 /* real setup is done in bindings.el */
5147 bset_mode_line_format (&buffer_defaults, build_pure_c_string ("%-"));
5148 bset_header_line_format (&buffer_defaults, Qnil);
5149 bset_abbrev_mode (&buffer_defaults, Qnil);
5150 bset_overwrite_mode (&buffer_defaults, Qnil);
5151 bset_case_fold_search (&buffer_defaults, Qt);
5152 bset_auto_fill_function (&buffer_defaults, Qnil);
5153 bset_selective_display (&buffer_defaults, Qnil);
5154 bset_selective_display_ellipses (&buffer_defaults, Qt);
5155 bset_abbrev_table (&buffer_defaults, Qnil);
5156 bset_display_table (&buffer_defaults, Qnil);
5157 bset_undo_list (&buffer_defaults, Qnil);
5158 bset_mark_active (&buffer_defaults, Qnil);
5159 bset_file_format (&buffer_defaults, Qnil);
5160 bset_auto_save_file_format (&buffer_defaults, Qt);
5161 set_buffer_overlays_before (&buffer_defaults, NULL);
5162 set_buffer_overlays_after (&buffer_defaults, NULL);
5163 buffer_defaults.overlay_center = BEG;
5165 XSETFASTINT (BVAR (&buffer_defaults, tab_width), 8);
5166 bset_truncate_lines (&buffer_defaults, Qnil);
5167 bset_word_wrap (&buffer_defaults, Qnil);
5168 bset_ctl_arrow (&buffer_defaults, Qt);
5169 bset_bidi_display_reordering (&buffer_defaults, Qt);
5170 bset_bidi_paragraph_direction (&buffer_defaults, Qnil);
5171 bset_cursor_type (&buffer_defaults, Qt);
5172 bset_extra_line_spacing (&buffer_defaults, Qnil);
5173 bset_cursor_in_non_selected_windows (&buffer_defaults, Qt);
5175 bset_enable_multibyte_characters (&buffer_defaults, Qt);
5176 bset_buffer_file_coding_system (&buffer_defaults, Qnil);
5177 XSETFASTINT (BVAR (&buffer_defaults, fill_column), 70);
5178 XSETFASTINT (BVAR (&buffer_defaults, left_margin), 0);
5179 bset_cache_long_line_scans (&buffer_defaults, Qnil);
5180 bset_file_truename (&buffer_defaults, Qnil);
5181 XSETFASTINT (BVAR (&buffer_defaults, display_count), 0);
5182 XSETFASTINT (BVAR (&buffer_defaults, left_margin_cols), 0);
5183 XSETFASTINT (BVAR (&buffer_defaults, right_margin_cols), 0);
5184 bset_left_fringe_width (&buffer_defaults, Qnil);
5185 bset_right_fringe_width (&buffer_defaults, Qnil);
5186 bset_fringes_outside_margins (&buffer_defaults, Qnil);
5187 bset_scroll_bar_width (&buffer_defaults, Qnil);
5188 bset_vertical_scroll_bar_type (&buffer_defaults, Qt);
5189 bset_indicate_empty_lines (&buffer_defaults, Qnil);
5190 bset_indicate_buffer_boundaries (&buffer_defaults, Qnil);
5191 bset_fringe_indicator_alist (&buffer_defaults, Qnil);
5192 bset_fringe_cursor_alist (&buffer_defaults, Qnil);
5193 bset_scroll_up_aggressively (&buffer_defaults, Qnil);
5194 bset_scroll_down_aggressively (&buffer_defaults, Qnil);
5195 bset_display_time (&buffer_defaults, Qnil);
5197 /* Assign the local-flags to the slots that have default values.
5198 The local flag is a bit that is used in the buffer
5199 to say that it has its own local value for the slot.
5200 The local flag bits are in the local_var_flags slot of the buffer. */
5202 /* Nothing can work if this isn't true */
5203 { verify (sizeof (EMACS_INT) == word_size); }
5205 /* 0 means not a lisp var, -1 means always local, else mask */
5206 memset (&buffer_local_flags, 0, sizeof buffer_local_flags);
5207 bset_filename (&buffer_local_flags, make_number (-1));
5208 bset_directory (&buffer_local_flags, make_number (-1));
5209 bset_backed_up (&buffer_local_flags, make_number (-1));
5210 bset_save_length (&buffer_local_flags, make_number (-1));
5211 bset_auto_save_file_name (&buffer_local_flags, make_number (-1));
5212 bset_read_only (&buffer_local_flags, make_number (-1));
5213 bset_major_mode (&buffer_local_flags, make_number (-1));
5214 bset_mode_name (&buffer_local_flags, make_number (-1));
5215 bset_undo_list (&buffer_local_flags, make_number (-1));
5216 bset_mark_active (&buffer_local_flags, make_number (-1));
5217 bset_point_before_scroll (&buffer_local_flags, make_number (-1));
5218 bset_file_truename (&buffer_local_flags, make_number (-1));
5219 bset_invisibility_spec (&buffer_local_flags, make_number (-1));
5220 bset_file_format (&buffer_local_flags, make_number (-1));
5221 bset_auto_save_file_format (&buffer_local_flags, make_number (-1));
5222 bset_display_count (&buffer_local_flags, make_number (-1));
5223 bset_display_time (&buffer_local_flags, make_number (-1));
5224 bset_enable_multibyte_characters (&buffer_local_flags, make_number (-1));
5226 idx = 1;
5227 XSETFASTINT (BVAR (&buffer_local_flags, mode_line_format), idx); ++idx;
5228 XSETFASTINT (BVAR (&buffer_local_flags, abbrev_mode), idx); ++idx;
5229 XSETFASTINT (BVAR (&buffer_local_flags, overwrite_mode), idx); ++idx;
5230 XSETFASTINT (BVAR (&buffer_local_flags, case_fold_search), idx); ++idx;
5231 XSETFASTINT (BVAR (&buffer_local_flags, auto_fill_function), idx); ++idx;
5232 XSETFASTINT (BVAR (&buffer_local_flags, selective_display), idx); ++idx;
5233 XSETFASTINT (BVAR (&buffer_local_flags, selective_display_ellipses), idx); ++idx;
5234 XSETFASTINT (BVAR (&buffer_local_flags, tab_width), idx); ++idx;
5235 XSETFASTINT (BVAR (&buffer_local_flags, truncate_lines), idx); ++idx;
5236 XSETFASTINT (BVAR (&buffer_local_flags, word_wrap), idx); ++idx;
5237 XSETFASTINT (BVAR (&buffer_local_flags, ctl_arrow), idx); ++idx;
5238 XSETFASTINT (BVAR (&buffer_local_flags, fill_column), idx); ++idx;
5239 XSETFASTINT (BVAR (&buffer_local_flags, left_margin), idx); ++idx;
5240 XSETFASTINT (BVAR (&buffer_local_flags, abbrev_table), idx); ++idx;
5241 XSETFASTINT (BVAR (&buffer_local_flags, display_table), idx); ++idx;
5242 XSETFASTINT (BVAR (&buffer_local_flags, syntax_table), idx); ++idx;
5243 XSETFASTINT (BVAR (&buffer_local_flags, cache_long_line_scans), idx); ++idx;
5244 XSETFASTINT (BVAR (&buffer_local_flags, category_table), idx); ++idx;
5245 XSETFASTINT (BVAR (&buffer_local_flags, bidi_display_reordering), idx); ++idx;
5246 XSETFASTINT (BVAR (&buffer_local_flags, bidi_paragraph_direction), idx); ++idx;
5247 XSETFASTINT (BVAR (&buffer_local_flags, buffer_file_coding_system), idx);
5248 /* Make this one a permanent local. */
5249 buffer_permanent_local_flags[idx++] = 1;
5250 XSETFASTINT (BVAR (&buffer_local_flags, left_margin_cols), idx); ++idx;
5251 XSETFASTINT (BVAR (&buffer_local_flags, right_margin_cols), idx); ++idx;
5252 XSETFASTINT (BVAR (&buffer_local_flags, left_fringe_width), idx); ++idx;
5253 XSETFASTINT (BVAR (&buffer_local_flags, right_fringe_width), idx); ++idx;
5254 XSETFASTINT (BVAR (&buffer_local_flags, fringes_outside_margins), idx); ++idx;
5255 XSETFASTINT (BVAR (&buffer_local_flags, scroll_bar_width), idx); ++idx;
5256 XSETFASTINT (BVAR (&buffer_local_flags, vertical_scroll_bar_type), idx); ++idx;
5257 XSETFASTINT (BVAR (&buffer_local_flags, indicate_empty_lines), idx); ++idx;
5258 XSETFASTINT (BVAR (&buffer_local_flags, indicate_buffer_boundaries), idx); ++idx;
5259 XSETFASTINT (BVAR (&buffer_local_flags, fringe_indicator_alist), idx); ++idx;
5260 XSETFASTINT (BVAR (&buffer_local_flags, fringe_cursor_alist), idx); ++idx;
5261 XSETFASTINT (BVAR (&buffer_local_flags, scroll_up_aggressively), idx); ++idx;
5262 XSETFASTINT (BVAR (&buffer_local_flags, scroll_down_aggressively), idx); ++idx;
5263 XSETFASTINT (BVAR (&buffer_local_flags, header_line_format), idx); ++idx;
5264 XSETFASTINT (BVAR (&buffer_local_flags, cursor_type), idx); ++idx;
5265 XSETFASTINT (BVAR (&buffer_local_flags, extra_line_spacing), idx); ++idx;
5266 XSETFASTINT (BVAR (&buffer_local_flags, cursor_in_non_selected_windows), idx); ++idx;
5268 /* Need more room? */
5269 if (idx >= MAX_PER_BUFFER_VARS)
5270 emacs_abort ();
5271 last_per_buffer_idx = idx;
5273 Vbuffer_alist = Qnil;
5274 current_buffer = 0;
5275 all_buffers = 0;
5277 QSFundamental = build_pure_c_string ("Fundamental");
5279 Qfundamental_mode = intern_c_string ("fundamental-mode");
5280 bset_major_mode (&buffer_defaults, Qfundamental_mode);
5282 Qmode_class = intern_c_string ("mode-class");
5284 Qprotected_field = intern_c_string ("protected-field");
5286 Qpermanent_local = intern_c_string ("permanent-local");
5288 Qkill_buffer_hook = intern_c_string ("kill-buffer-hook");
5289 Fput (Qkill_buffer_hook, Qpermanent_local, Qt);
5291 /* super-magic invisible buffer */
5292 Vprin1_to_string_buffer = Fget_buffer_create (build_pure_c_string (" prin1"));
5293 Vbuffer_alist = Qnil;
5295 Fset_buffer (Fget_buffer_create (build_pure_c_string ("*scratch*")));
5297 inhibit_modification_hooks = 0;
5300 void
5301 init_buffer (void)
5303 char *pwd;
5304 Lisp_Object temp;
5305 ptrdiff_t len;
5307 #ifdef USE_MMAP_FOR_BUFFERS
5309 /* When using the ralloc implementation based on mmap(2), buffer
5310 text pointers will have been set to null in the dumped Emacs.
5311 Map new memory. */
5312 struct buffer *b;
5314 FOR_EACH_BUFFER (b)
5315 if (b->text->beg == NULL)
5316 enlarge_buffer_text (b, 0);
5318 #endif /* USE_MMAP_FOR_BUFFERS */
5320 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5321 if (NILP (BVAR (&buffer_defaults, enable_multibyte_characters)))
5322 Fset_buffer_multibyte (Qnil);
5324 pwd = get_current_dir_name ();
5326 if (!pwd)
5327 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno));
5329 /* Maybe this should really use some standard subroutine
5330 whose definition is filename syntax dependent. */
5331 len = strlen (pwd);
5332 if (!(IS_DIRECTORY_SEP (pwd[len - 1])))
5334 /* Grow buffer to add directory separator and '\0'. */
5335 pwd = realloc (pwd, len + 2);
5336 if (!pwd)
5337 fatal ("`get_current_dir_name' failed: %s\n", strerror (errno));
5338 pwd[len] = DIRECTORY_SEP;
5339 pwd[len + 1] = '\0';
5340 len++;
5343 bset_directory (current_buffer, make_unibyte_string (pwd, len));
5344 if (! NILP (BVAR (&buffer_defaults, enable_multibyte_characters)))
5345 /* At this moment, we still don't know how to decode the
5346 directory name. So, we keep the bytes in multibyte form so
5347 that ENCODE_FILE correctly gets the original bytes. */
5348 bset_directory
5349 (current_buffer, string_to_multibyte (BVAR (current_buffer, directory)));
5351 /* Add /: to the front of the name
5352 if it would otherwise be treated as magic. */
5353 temp = Ffind_file_name_handler (BVAR (current_buffer, directory), Qt);
5354 if (! NILP (temp)
5355 /* If the default dir is just /, TEMP is non-nil
5356 because of the ange-ftp completion handler.
5357 However, it is not necessary to turn / into /:/.
5358 So avoid doing that. */
5359 && strcmp ("/", SSDATA (BVAR (current_buffer, directory))))
5360 bset_directory
5361 (current_buffer,
5362 concat2 (build_string ("/:"), BVAR (current_buffer, directory)));
5364 temp = get_minibuffer (0);
5365 bset_directory (XBUFFER (temp), BVAR (current_buffer, directory));
5367 free (pwd);
5370 /* Similar to defvar_lisp but define a variable whose value is the
5371 Lisp_Object stored in the current buffer. LNAME is the Lisp-level
5372 variable name. VNAME is the name of the buffer slot. PREDICATE
5373 is nil for a general Lisp variable. If PREDICATE is non-nil, then
5374 only Lisp values that satisfies the PREDICATE are allowed (except
5375 that nil is allowed too). DOC is a dummy where you write the doc
5376 string as a comment. */
5378 #define DEFVAR_PER_BUFFER(lname, vname, predicate, doc) \
5379 do { \
5380 static struct Lisp_Buffer_Objfwd bo_fwd; \
5381 defvar_per_buffer (&bo_fwd, lname, vname, predicate); \
5382 } while (0)
5384 static void
5385 defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring,
5386 Lisp_Object *address, Lisp_Object predicate)
5388 struct Lisp_Symbol *sym;
5389 int offset;
5391 sym = XSYMBOL (intern (namestring));
5392 offset = (char *)address - (char *)current_buffer;
5394 bo_fwd->type = Lisp_Fwd_Buffer_Obj;
5395 bo_fwd->offset = offset;
5396 bo_fwd->predicate = predicate;
5397 sym->declared_special = 1;
5398 sym->redirect = SYMBOL_FORWARDED;
5400 /* I tried to do the job without a cast, but it seems impossible.
5401 union Lisp_Fwd *fwd; &(fwd->u_buffer_objfwd) = bo_fwd; */
5402 SET_SYMBOL_FWD (sym, (union Lisp_Fwd *)bo_fwd);
5404 XSETSYMBOL (PER_BUFFER_SYMBOL (offset), sym);
5406 if (PER_BUFFER_IDX (offset) == 0)
5407 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
5408 slot of buffer_local_flags */
5409 emacs_abort ();
5413 /* initialize the buffer routines */
5414 void
5415 syms_of_buffer (void)
5417 staticpro (&last_overlay_modification_hooks);
5418 last_overlay_modification_hooks
5419 = Fmake_vector (make_number (10), Qnil);
5421 staticpro (&Qfundamental_mode);
5422 staticpro (&Qmode_class);
5423 staticpro (&QSFundamental);
5424 staticpro (&Vbuffer_alist);
5425 staticpro (&Qprotected_field);
5426 staticpro (&Qpermanent_local);
5427 staticpro (&Qkill_buffer_hook);
5429 DEFSYM (Qpermanent_local_hook, "permanent-local-hook");
5430 DEFSYM (Qoverlayp, "overlayp");
5431 DEFSYM (Qevaporate, "evaporate");
5432 DEFSYM (Qmodification_hooks, "modification-hooks");
5433 DEFSYM (Qinsert_in_front_hooks, "insert-in-front-hooks");
5434 DEFSYM (Qinsert_behind_hooks, "insert-behind-hooks");
5435 DEFSYM (Qget_file_buffer, "get-file-buffer");
5436 DEFSYM (Qpriority, "priority");
5437 DEFSYM (Qbefore_string, "before-string");
5438 DEFSYM (Qafter_string, "after-string");
5439 DEFSYM (Qfirst_change_hook, "first-change-hook");
5440 DEFSYM (Qbefore_change_functions, "before-change-functions");
5441 DEFSYM (Qafter_change_functions, "after-change-functions");
5442 DEFSYM (Qkill_buffer_query_functions, "kill-buffer-query-functions");
5444 Fput (Qprotected_field, Qerror_conditions,
5445 listn (CONSTYPE_PURE, 2, Qprotected_field, Qerror));
5446 Fput (Qprotected_field, Qerror_message,
5447 build_pure_c_string ("Attempt to modify a protected field"));
5449 DEFVAR_BUFFER_DEFAULTS ("default-mode-line-format",
5450 mode_line_format,
5451 doc: /* Default value of `mode-line-format' for buffers that don't override it.
5452 This is the same as (default-value 'mode-line-format). */);
5454 DEFVAR_BUFFER_DEFAULTS ("default-header-line-format",
5455 header_line_format,
5456 doc: /* Default value of `header-line-format' for buffers that don't override it.
5457 This is the same as (default-value 'header-line-format). */);
5459 DEFVAR_BUFFER_DEFAULTS ("default-cursor-type", cursor_type,
5460 doc: /* Default value of `cursor-type' for buffers that don't override it.
5461 This is the same as (default-value 'cursor-type). */);
5463 DEFVAR_BUFFER_DEFAULTS ("default-line-spacing",
5464 extra_line_spacing,
5465 doc: /* Default value of `line-spacing' for buffers that don't override it.
5466 This is the same as (default-value 'line-spacing). */);
5468 DEFVAR_BUFFER_DEFAULTS ("default-cursor-in-non-selected-windows",
5469 cursor_in_non_selected_windows,
5470 doc: /* Default value of `cursor-in-non-selected-windows'.
5471 This is the same as (default-value 'cursor-in-non-selected-windows). */);
5473 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode",
5474 abbrev_mode,
5475 doc: /* Default value of `abbrev-mode' for buffers that do not override it.
5476 This is the same as (default-value 'abbrev-mode). */);
5478 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow",
5479 ctl_arrow,
5480 doc: /* Default value of `ctl-arrow' for buffers that do not override it.
5481 This is the same as (default-value 'ctl-arrow). */);
5483 DEFVAR_BUFFER_DEFAULTS ("default-enable-multibyte-characters",
5484 enable_multibyte_characters,
5485 doc: /* Default value of `enable-multibyte-characters' for buffers not overriding it.
5486 This is the same as (default-value 'enable-multibyte-characters). */);
5488 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system",
5489 buffer_file_coding_system,
5490 doc: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5491 This is the same as (default-value 'buffer-file-coding-system). */);
5493 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines",
5494 truncate_lines,
5495 doc: /* Default value of `truncate-lines' for buffers that do not override it.
5496 This is the same as (default-value 'truncate-lines). */);
5498 DEFVAR_BUFFER_DEFAULTS ("default-fill-column",
5499 fill_column,
5500 doc: /* Default value of `fill-column' for buffers that do not override it.
5501 This is the same as (default-value 'fill-column). */);
5503 DEFVAR_BUFFER_DEFAULTS ("default-left-margin",
5504 left_margin,
5505 doc: /* Default value of `left-margin' for buffers that do not override it.
5506 This is the same as (default-value 'left-margin). */);
5508 DEFVAR_BUFFER_DEFAULTS ("default-tab-width",
5509 tab_width,
5510 doc: /* Default value of `tab-width' for buffers that do not override it.
5511 NOTE: This controls the display width of a TAB character, and not
5512 the size of an indentation step.
5513 This is the same as (default-value 'tab-width). */);
5515 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search",
5516 case_fold_search,
5517 doc: /* Default value of `case-fold-search' for buffers that don't override it.
5518 This is the same as (default-value 'case-fold-search). */);
5520 DEFVAR_BUFFER_DEFAULTS ("default-left-margin-width",
5521 left_margin_cols,
5522 doc: /* Default value of `left-margin-width' for buffers that don't override it.
5523 This is the same as (default-value 'left-margin-width). */);
5525 DEFVAR_BUFFER_DEFAULTS ("default-right-margin-width",
5526 right_margin_cols,
5527 doc: /* Default value of `right-margin-width' for buffers that don't override it.
5528 This is the same as (default-value 'right-margin-width). */);
5530 DEFVAR_BUFFER_DEFAULTS ("default-left-fringe-width",
5531 left_fringe_width,
5532 doc: /* Default value of `left-fringe-width' for buffers that don't override it.
5533 This is the same as (default-value 'left-fringe-width). */);
5535 DEFVAR_BUFFER_DEFAULTS ("default-right-fringe-width",
5536 right_fringe_width,
5537 doc: /* Default value of `right-fringe-width' for buffers that don't override it.
5538 This is the same as (default-value 'right-fringe-width). */);
5540 DEFVAR_BUFFER_DEFAULTS ("default-fringes-outside-margins",
5541 fringes_outside_margins,
5542 doc: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5543 This is the same as (default-value 'fringes-outside-margins). */);
5545 DEFVAR_BUFFER_DEFAULTS ("default-scroll-bar-width",
5546 scroll_bar_width,
5547 doc: /* Default value of `scroll-bar-width' for buffers that don't override it.
5548 This is the same as (default-value 'scroll-bar-width). */);
5550 DEFVAR_BUFFER_DEFAULTS ("default-vertical-scroll-bar",
5551 vertical_scroll_bar_type,
5552 doc: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5553 This is the same as (default-value 'vertical-scroll-bar). */);
5555 DEFVAR_BUFFER_DEFAULTS ("default-indicate-empty-lines",
5556 indicate_empty_lines,
5557 doc: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5558 This is the same as (default-value 'indicate-empty-lines). */);
5560 DEFVAR_BUFFER_DEFAULTS ("default-indicate-buffer-boundaries",
5561 indicate_buffer_boundaries,
5562 doc: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
5563 This is the same as (default-value 'indicate-buffer-boundaries). */);
5565 DEFVAR_BUFFER_DEFAULTS ("default-fringe-indicator-alist",
5566 fringe_indicator_alist,
5567 doc: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
5568 This is the same as (default-value 'fringe-indicator-alist'). */);
5570 DEFVAR_BUFFER_DEFAULTS ("default-fringe-cursor-alist",
5571 fringe_cursor_alist,
5572 doc: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
5573 This is the same as (default-value 'fringe-cursor-alist'). */);
5575 DEFVAR_BUFFER_DEFAULTS ("default-scroll-up-aggressively",
5576 scroll_up_aggressively,
5577 doc: /* Default value of `scroll-up-aggressively'.
5578 This value applies in buffers that don't have their own local values.
5579 This is the same as (default-value 'scroll-up-aggressively). */);
5581 DEFVAR_BUFFER_DEFAULTS ("default-scroll-down-aggressively",
5582 scroll_down_aggressively,
5583 doc: /* Default value of `scroll-down-aggressively'.
5584 This value applies in buffers that don't have their own local values.
5585 This is the same as (default-value 'scroll-down-aggressively). */);
5587 DEFVAR_PER_BUFFER ("header-line-format",
5588 &BVAR (current_buffer, header_line_format),
5589 Qnil,
5590 doc: /* Analogous to `mode-line-format', but controls the header line.
5591 The header line appears, optionally, at the top of a window;
5592 the mode line appears at the bottom. */);
5594 DEFVAR_PER_BUFFER ("mode-line-format", &BVAR (current_buffer, mode_line_format),
5595 Qnil,
5596 doc: /* Template for displaying mode line for current buffer.
5598 The value may be nil, a string, a symbol or a list.
5600 A value of nil means don't display a mode line.
5602 For any symbol other than t or nil, the symbol's value is processed as
5603 a mode line construct. As a special exception, if that value is a
5604 string, the string is processed verbatim, without handling any
5605 %-constructs (see below). Also, unless the symbol has a non-nil
5606 `risky-local-variable' property, all properties in any strings, as
5607 well as all :eval and :propertize forms in the value, are ignored.
5609 A list whose car is a string or list is processed by processing each
5610 of the list elements recursively, as separate mode line constructs,
5611 and concatenating the results.
5613 A list of the form `(:eval FORM)' is processed by evaluating FORM and
5614 using the result as a mode line construct. Be careful--FORM should
5615 not load any files, because that can cause an infinite recursion.
5617 A list of the form `(:propertize ELT PROPS...)' is processed by
5618 processing ELT as the mode line construct, and adding the text
5619 properties PROPS to the result.
5621 A list whose car is a symbol is processed by examining the symbol's
5622 value, and, if that value is non-nil, processing the cadr of the list
5623 recursively; and if that value is nil, processing the caddr of the
5624 list recursively.
5626 A list whose car is an integer is processed by processing the cadr of
5627 the list, and padding (if the number is positive) or truncating (if
5628 negative) to the width specified by that number.
5630 A string is printed verbatim in the mode line except for %-constructs:
5631 %b -- print buffer name. %f -- print visited file name.
5632 %F -- print frame name.
5633 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5634 %& is like %*, but ignore read-only-ness.
5635 % means buffer is read-only and * means it is modified.
5636 For a modified read-only buffer, %* gives % and %+ gives *.
5637 %s -- print process status. %l -- print the current line number.
5638 %c -- print the current column number (this makes editing slower).
5639 To make the column number update correctly in all cases,
5640 `column-number-mode' must be non-nil.
5641 %i -- print the size of the buffer.
5642 %I -- like %i, but use k, M, G, etc., to abbreviate.
5643 %p -- print percent of buffer above top of window, or Top, Bot or All.
5644 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5645 or print Bottom or All.
5646 %n -- print Narrow if appropriate.
5647 %t -- visited file is text or binary (if OS supports this distinction).
5648 %z -- print mnemonics of keyboard, terminal, and buffer coding systems.
5649 %Z -- like %z, but including the end-of-line format.
5650 %e -- print error message about full memory.
5651 %@ -- print @ or hyphen. @ means that default-directory is on a
5652 remote machine.
5653 %[ -- print one [ for each recursive editing level. %] similar.
5654 %% -- print %. %- -- print infinitely many dashes.
5655 Decimal digits after the % specify field width to which to pad. */);
5657 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode,
5658 doc: /* Value of `major-mode' for new buffers. */);
5660 DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer, major_mode),
5661 Qsymbolp,
5662 doc: /* Symbol for current buffer's major mode.
5663 The default value (normally `fundamental-mode') affects new buffers.
5664 A value of nil means to use the current buffer's major mode, provided
5665 it is not marked as "special".
5667 When a mode is used by default, `find-file' switches to it before it
5668 reads the contents into the buffer and before it finishes setting up
5669 the buffer. Thus, the mode and its hooks should not expect certain
5670 variables such as `buffer-read-only' and `buffer-file-coding-system'
5671 to be set up. */);
5673 DEFVAR_PER_BUFFER ("mode-name", &BVAR (current_buffer, mode_name),
5674 Qnil,
5675 doc: /* Pretty name of current buffer's major mode.
5676 Usually a string, but can use any of the constructs for `mode-line-format',
5677 which see.
5678 Format with `format-mode-line' to produce a string value. */);
5680 DEFVAR_PER_BUFFER ("local-abbrev-table", &BVAR (current_buffer, abbrev_table), Qnil,
5681 doc: /* Local (mode-specific) abbrev table of current buffer. */);
5683 DEFVAR_PER_BUFFER ("abbrev-mode", &BVAR (current_buffer, abbrev_mode), Qnil,
5684 doc: /* Non-nil if Abbrev mode is enabled.
5685 Use the command `abbrev-mode' to change this variable. */);
5687 DEFVAR_PER_BUFFER ("case-fold-search", &BVAR (current_buffer, case_fold_search),
5688 Qnil,
5689 doc: /* Non-nil if searches and matches should ignore case. */);
5691 DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer, fill_column),
5692 Qintegerp,
5693 doc: /* Column beyond which automatic line-wrapping should happen.
5694 Interactively, you can set the buffer local value using \\[set-fill-column]. */);
5696 DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer, left_margin),
5697 Qintegerp,
5698 doc: /* Column for the default `indent-line-function' to indent to.
5699 Linefeed indents to this column in Fundamental mode. */);
5701 DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer, tab_width),
5702 Qintegerp,
5703 doc: /* Distance between tab stops (for display of tab characters), in columns.
5704 NOTE: This controls the display width of a TAB character, and not
5705 the size of an indentation step.
5706 This should be an integer greater than zero. */);
5708 DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer, ctl_arrow), Qnil,
5709 doc: /* Non-nil means display control chars with uparrow.
5710 A value of nil means use backslash and octal digits.
5711 This variable does not apply to characters whose display is specified
5712 in the current display table (if there is one). */);
5714 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5715 &BVAR (current_buffer, enable_multibyte_characters),
5716 Qnil,
5717 doc: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5718 Otherwise they are regarded as unibyte. This affects the display,
5719 file I/O and the behavior of various editing commands.
5721 This variable is buffer-local but you cannot set it directly;
5722 use the function `set-buffer-multibyte' to change a buffer's representation.
5723 See also Info node `(elisp)Text Representations'. */);
5724 XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant = 1;
5726 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5727 &BVAR (current_buffer, buffer_file_coding_system), Qnil,
5728 doc: /* Coding system to be used for encoding the buffer contents on saving.
5729 This variable applies to saving the buffer, and also to `write-region'
5730 and other functions that use `write-region'.
5731 It does not apply to sending output to subprocesses, however.
5733 If this is nil, the buffer is saved without any code conversion
5734 unless some coding system is specified in `file-coding-system-alist'
5735 for the buffer file.
5737 If the text to be saved cannot be encoded as specified by this variable,
5738 an alternative encoding is selected by `select-safe-coding-system', which see.
5740 The variable `coding-system-for-write', if non-nil, overrides this variable.
5742 This variable is never applied to a way of decoding a file while reading it. */);
5744 DEFVAR_PER_BUFFER ("bidi-display-reordering",
5745 &BVAR (current_buffer, bidi_display_reordering), Qnil,
5746 doc: /* Non-nil means reorder bidirectional text for display in the visual order. */);
5748 DEFVAR_PER_BUFFER ("bidi-paragraph-direction",
5749 &BVAR (current_buffer, bidi_paragraph_direction), Qnil,
5750 doc: /* If non-nil, forces directionality of text paragraphs in the buffer.
5752 If this is nil (the default), the direction of each paragraph is
5753 determined by the first strong directional character of its text.
5754 The values of `right-to-left' and `left-to-right' override that.
5755 Any other value is treated as nil.
5757 This variable has no effect unless the buffer's value of
5758 \`bidi-display-reordering' is non-nil. */);
5760 DEFVAR_PER_BUFFER ("truncate-lines", &BVAR (current_buffer, truncate_lines), Qnil,
5761 doc: /* Non-nil means do not display continuation lines.
5762 Instead, give each line of text just one screen line.
5764 Note that this is overridden by the variable
5765 `truncate-partial-width-windows' if that variable is non-nil
5766 and this buffer is not full-frame width.
5768 Minibuffers set this variable to nil. */);
5770 DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer, word_wrap), Qnil,
5771 doc: /* Non-nil means to use word-wrapping for continuation lines.
5772 When word-wrapping is on, continuation lines are wrapped at the space
5773 or tab character nearest to the right window edge.
5774 If nil, continuation lines are wrapped at the right screen edge.
5776 This variable has no effect if long lines are truncated (see
5777 `truncate-lines' and `truncate-partial-width-windows'). If you use
5778 word-wrapping, you might want to reduce the value of
5779 `truncate-partial-width-windows', since wrapping can make text readable
5780 in narrower windows.
5782 Instead of setting this variable directly, most users should use
5783 Visual Line mode . Visual Line mode, when enabled, sets `word-wrap'
5784 to t, and additionally redefines simple editing commands to act on
5785 visual lines rather than logical lines. See the documentation of
5786 `visual-line-mode'. */);
5788 DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer, directory),
5789 Qstringp,
5790 doc: /* Name of default directory of current buffer. Should end with slash.
5791 To interactively change the default directory, use command `cd'. */);
5793 DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer, auto_fill_function),
5794 Qnil,
5795 doc: /* Function called (if non-nil) to perform auto-fill.
5796 It is called after self-inserting any character specified in
5797 the `auto-fill-chars' table.
5798 NOTE: This variable is not a hook;
5799 its value may not be a list of functions. */);
5801 DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer, filename),
5802 Qstringp,
5803 doc: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5805 DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer, file_truename),
5806 Qstringp,
5807 doc: /* Abbreviated truename of file visited in current buffer, or nil if none.
5808 The truename of a file is calculated by `file-truename'
5809 and then abbreviated with `abbreviate-file-name'. */);
5811 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5812 &BVAR (current_buffer, auto_save_file_name),
5813 Qstringp,
5814 doc: /* Name of file for auto-saving current buffer.
5815 If it is nil, that means don't auto-save this buffer. */);
5817 DEFVAR_PER_BUFFER ("buffer-read-only", &BVAR (current_buffer, read_only), Qnil,
5818 doc: /* Non-nil if this buffer is read-only. */);
5820 DEFVAR_PER_BUFFER ("buffer-backed-up", &BVAR (current_buffer, backed_up), Qnil,
5821 doc: /* Non-nil if this buffer's file has been backed up.
5822 Backing up is done before the first time the file is saved. */);
5824 DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer, save_length),
5825 Qintegerp,
5826 doc: /* Length of current buffer when last read in, saved or auto-saved.
5827 0 initially.
5828 -1 means auto-saving turned off until next real save.
5830 If you set this to -2, that means don't turn off auto-saving in this buffer
5831 if its text size shrinks. If you use `buffer-swap-text' on a buffer,
5832 you probably should set this to -2 in that buffer. */);
5834 DEFVAR_PER_BUFFER ("selective-display", &BVAR (current_buffer, selective_display),
5835 Qnil,
5836 doc: /* Non-nil enables selective display.
5837 An integer N as value means display only lines
5838 that start with less than N columns of space.
5839 A value of t means that the character ^M makes itself and
5840 all the rest of the line invisible; also, when saving the buffer
5841 in a file, save the ^M as a newline. */);
5843 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5844 &BVAR (current_buffer, selective_display_ellipses),
5845 Qnil,
5846 doc: /* Non-nil means display ... on previous line when a line is invisible. */);
5848 DEFVAR_PER_BUFFER ("overwrite-mode", &BVAR (current_buffer, overwrite_mode), Qnil,
5849 doc: /* Non-nil if self-insertion should replace existing text.
5850 The value should be one of `overwrite-mode-textual',
5851 `overwrite-mode-binary', or nil.
5852 If it is `overwrite-mode-textual', self-insertion still
5853 inserts at the end of a line, and inserts when point is before a tab,
5854 until the tab is filled in.
5855 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5857 DEFVAR_PER_BUFFER ("buffer-display-table", &BVAR (current_buffer, display_table),
5858 Qnil,
5859 doc: /* Display table that controls display of the contents of current buffer.
5861 If this variable is nil, the value of `standard-display-table' is used.
5862 Each window can have its own, overriding display table, see
5863 `set-window-display-table' and `window-display-table'.
5865 The display table is a char-table created with `make-display-table'.
5866 A char-table is an array indexed by character codes. Normal array
5867 primitives `aref' and `aset' can be used to access elements of a char-table.
5869 Each of the char-table elements control how to display the corresponding
5870 text character: the element at index C in the table says how to display
5871 the character whose code is C. Each element should be a vector of
5872 characters or nil. The value nil means display the character in the
5873 default fashion; otherwise, the characters from the vector are delivered
5874 to the screen instead of the original character.
5876 For example, (aset buffer-display-table ?X [?Y]) tells Emacs
5877 to display a capital Y instead of each X character.
5879 In addition, a char-table has six extra slots to control the display of:
5881 the end of a truncated screen line (extra-slot 0, a single character);
5882 the end of a continued line (extra-slot 1, a single character);
5883 the escape character used to display character codes in octal
5884 (extra-slot 2, a single character);
5885 the character used as an arrow for control characters (extra-slot 3,
5886 a single character);
5887 the decoration indicating the presence of invisible lines (extra-slot 4,
5888 a vector of characters);
5889 the character used to draw the border between side-by-side windows
5890 (extra-slot 5, a single character).
5892 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5894 DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer, left_margin_cols),
5895 Qintegerp,
5896 doc: /* Width of left marginal area for display of a buffer.
5897 A value of nil means no marginal area.
5899 Setting this variable does not take effect until a new buffer is displayed
5900 in a window. To make the change take effect, call `set-window-buffer'. */);
5902 DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer, right_margin_cols),
5903 Qintegerp,
5904 doc: /* Width of right marginal area for display of a buffer.
5905 A value of nil means no marginal area.
5907 Setting this variable does not take effect until a new buffer is displayed
5908 in a window. To make the change take effect, call `set-window-buffer'. */);
5910 DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer, left_fringe_width),
5911 Qintegerp,
5912 doc: /* Width of this buffer's left fringe (in pixels).
5913 A value of 0 means no left fringe is shown in this buffer's window.
5914 A value of nil means to use the left fringe width from the window's frame.
5916 Setting this variable does not take effect until a new buffer is displayed
5917 in a window. To make the change take effect, call `set-window-buffer'. */);
5919 DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer, right_fringe_width),
5920 Qintegerp,
5921 doc: /* Width of this buffer's right fringe (in pixels).
5922 A value of 0 means no right fringe is shown in this buffer's window.
5923 A value of nil means to use the right fringe width from the window's frame.
5925 Setting this variable does not take effect until a new buffer is displayed
5926 in a window. To make the change take effect, call `set-window-buffer'. */);
5928 DEFVAR_PER_BUFFER ("fringes-outside-margins", &BVAR (current_buffer, fringes_outside_margins),
5929 Qnil,
5930 doc: /* Non-nil means to display fringes outside display margins.
5931 A value of nil means to display fringes between margins and buffer text.
5933 Setting this variable does not take effect until a new buffer is displayed
5934 in a window. To make the change take effect, call `set-window-buffer'. */);
5936 DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer, scroll_bar_width),
5937 Qintegerp,
5938 doc: /* Width of this buffer's scroll bars in pixels.
5939 A value of nil means to use the scroll bar width from the window's frame. */);
5941 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &BVAR (current_buffer, vertical_scroll_bar_type),
5942 Qnil,
5943 doc: /* Position of this buffer's vertical scroll bar.
5944 The value takes effect whenever you tell a window to display this buffer;
5945 for instance, with `set-window-buffer' or when `display-buffer' displays it.
5947 A value of `left' or `right' means put the vertical scroll bar at that side
5948 of the window; a value of nil means don't show any vertical scroll bars.
5949 A value of t (the default) means do whatever the window's frame specifies. */);
5951 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5952 &BVAR (current_buffer, indicate_empty_lines), Qnil,
5953 doc: /* Visually indicate empty lines after the buffer end.
5954 If non-nil, a bitmap is displayed in the left fringe of a window on
5955 window-systems. */);
5957 DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
5958 &BVAR (current_buffer, indicate_buffer_boundaries), Qnil,
5959 doc: /* Visually indicate buffer boundaries and scrolling.
5960 If non-nil, the first and last line of the buffer are marked in the fringe
5961 of a window on window-systems with angle bitmaps, or if the window can be
5962 scrolled, the top and bottom line of the window are marked with up and down
5963 arrow bitmaps.
5965 If value is a symbol `left' or `right', both angle and arrow bitmaps
5966 are displayed in the left or right fringe, resp. Any other value
5967 that doesn't look like an alist means display the angle bitmaps in
5968 the left fringe but no arrows.
5970 You can exercise more precise control by using an alist as the
5971 value. Each alist element (INDICATOR . POSITION) specifies
5972 where to show one of the indicators. INDICATOR is one of `top',
5973 `bottom', `up', `down', or t, which specifies the default position,
5974 and POSITION is one of `left', `right', or nil, meaning do not show
5975 this indicator.
5977 For example, ((top . left) (t . right)) places the top angle bitmap in
5978 left fringe, the bottom angle bitmap in right fringe, and both arrow
5979 bitmaps in right fringe. To show just the angle bitmaps in the left
5980 fringe, but no arrow bitmaps, use ((top . left) (bottom . left)). */);
5982 DEFVAR_PER_BUFFER ("fringe-indicator-alist",
5983 &BVAR (current_buffer, fringe_indicator_alist), Qnil,
5984 doc: /* Mapping from logical to physical fringe indicator bitmaps.
5985 The value is an alist where each element (INDICATOR . BITMAPS)
5986 specifies the fringe bitmaps used to display a specific logical
5987 fringe indicator.
5989 INDICATOR specifies the logical indicator type which is one of the
5990 following symbols: `truncation' , `continuation', `overlay-arrow',
5991 `top', `bottom', `top-bottom', `up', `down', empty-line', or `unknown'.
5993 BITMAPS is a list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
5994 the actual bitmap shown in the left or right fringe for the logical
5995 indicator. LEFT and RIGHT are the bitmaps shown in the left and/or
5996 right fringe for the specific indicator. The LEFT1 or RIGHT1 bitmaps
5997 are used only for the `bottom' and `top-bottom' indicators when the
5998 last (only) line has no final newline. BITMAPS may also be a single
5999 symbol which is used in both left and right fringes. */);
6001 DEFVAR_PER_BUFFER ("fringe-cursor-alist",
6002 &BVAR (current_buffer, fringe_cursor_alist), Qnil,
6003 doc: /* Mapping from logical to physical fringe cursor bitmaps.
6004 The value is an alist where each element (CURSOR . BITMAP)
6005 specifies the fringe bitmaps used to display a specific logical
6006 cursor type in the fringe.
6008 CURSOR specifies the logical cursor type which is one of the following
6009 symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'. The last
6010 one is used to show a hollow cursor on narrow lines display lines
6011 where the normal hollow cursor will not fit.
6013 BITMAP is the corresponding fringe bitmap shown for the logical
6014 cursor type. */);
6016 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
6017 &BVAR (current_buffer, scroll_up_aggressively), Qfloatp,
6018 doc: /* How far to scroll windows upward.
6019 If you move point off the bottom, the window scrolls automatically.
6020 This variable controls how far it scrolls. The value nil, the default,
6021 means scroll to center point. A fraction means scroll to put point
6022 that fraction of the window's height from the bottom of the window.
6023 When the value is 0.0, point goes at the bottom line, which in the
6024 simple case that you moved off with C-f means scrolling just one line.
6025 1.0 means point goes at the top, so that in that simple case, the
6026 window scrolls by a full window height. Meaningful values are
6027 between 0.0 and 1.0, inclusive. */);
6029 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
6030 &BVAR (current_buffer, scroll_down_aggressively), Qfloatp,
6031 doc: /* How far to scroll windows downward.
6032 If you move point off the top, the window scrolls automatically.
6033 This variable controls how far it scrolls. The value nil, the default,
6034 means scroll to center point. A fraction means scroll to put point
6035 that fraction of the window's height from the top of the window.
6036 When the value is 0.0, point goes at the top line, which in the
6037 simple case that you moved off with C-b means scrolling just one line.
6038 1.0 means point goes at the bottom, so that in that simple case, the
6039 window scrolls by a full window height. Meaningful values are
6040 between 0.0 and 1.0, inclusive. */);
6042 DEFVAR_LISP ("before-change-functions", Vbefore_change_functions,
6043 doc: /* List of functions to call before each text change.
6044 Two arguments are passed to each function: the positions of
6045 the beginning and end of the range of old text to be changed.
6046 \(For an insertion, the beginning and end are at the same place.)
6047 No information is given about the length of the text after the change.
6049 Buffer changes made while executing the `before-change-functions'
6050 don't call any before-change or after-change functions.
6051 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6053 If an unhandled error happens in running these functions,
6054 the variable's value remains nil. That prevents the error
6055 from happening repeatedly and making Emacs nonfunctional. */);
6056 Vbefore_change_functions = Qnil;
6058 DEFVAR_LISP ("after-change-functions", Vafter_change_functions,
6059 doc: /* List of functions to call after each text change.
6060 Three arguments are passed to each function: the positions of
6061 the beginning and end of the range of changed text,
6062 and the length in bytes of the pre-change text replaced by that range.
6063 \(For an insertion, the pre-change length is zero;
6064 for a deletion, that length is the number of bytes deleted,
6065 and the post-change beginning and end are at the same place.)
6067 Buffer changes made while executing the `after-change-functions'
6068 don't call any before-change or after-change functions.
6069 That's because `inhibit-modification-hooks' is temporarily set non-nil.
6071 If an unhandled error happens in running these functions,
6072 the variable's value remains nil. That prevents the error
6073 from happening repeatedly and making Emacs nonfunctional. */);
6074 Vafter_change_functions = Qnil;
6076 DEFVAR_LISP ("first-change-hook", Vfirst_change_hook,
6077 doc: /* A list of functions to call before changing a buffer which is unmodified.
6078 The functions are run using the `run-hooks' function. */);
6079 Vfirst_change_hook = Qnil;
6081 DEFVAR_PER_BUFFER ("buffer-undo-list", &BVAR (current_buffer, undo_list), Qnil,
6082 doc: /* List of undo entries in current buffer.
6083 Recent changes come first; older changes follow newer.
6085 An entry (BEG . END) represents an insertion which begins at
6086 position BEG and ends at position END.
6088 An entry (TEXT . POSITION) represents the deletion of the string TEXT
6089 from (abs POSITION). If POSITION is positive, point was at the front
6090 of the text being deleted; if negative, point was at the end.
6092 An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously
6093 unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time)
6094 and is the visited file's modification time, as of that time. If the
6095 modification time of the most recent save is different, this entry is
6096 obsolete.
6098 An entry (t . 0) means means the buffer was previously unmodified but
6099 its time stamp was unknown because it was not associated with a file.
6100 An entry (t . -1) is similar, except that it means the buffer's visited
6101 file did not exist.
6103 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
6104 was modified between BEG and END. PROPERTY is the property name,
6105 and VALUE is the old value.
6107 An entry (apply FUN-NAME . ARGS) means undo the change with
6108 \(apply FUN-NAME ARGS).
6110 An entry (apply DELTA BEG END FUN-NAME . ARGS) supports selective undo
6111 in the active region. BEG and END is the range affected by this entry
6112 and DELTA is the number of bytes added or deleted in that range by
6113 this change.
6115 An entry (MARKER . DISTANCE) indicates that the marker MARKER
6116 was adjusted in position by the offset DISTANCE (an integer).
6118 An entry of the form POSITION indicates that point was at the buffer
6119 location given by the integer. Undoing an entry of this form places
6120 point at POSITION.
6122 Entries with value `nil' mark undo boundaries. The undo command treats
6123 the changes between two undo boundaries as a single step to be undone.
6125 If the value of the variable is t, undo information is not recorded. */);
6127 DEFVAR_PER_BUFFER ("mark-active", &BVAR (current_buffer, mark_active), Qnil,
6128 doc: /* Non-nil means the mark and region are currently active in this buffer. */);
6130 DEFVAR_PER_BUFFER ("cache-long-line-scans", &BVAR (current_buffer, cache_long_line_scans), Qnil,
6131 doc: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
6133 Normally, the line-motion functions work by scanning the buffer for
6134 newlines. Columnar operations (like `move-to-column' and
6135 `compute-motion') also work by scanning the buffer, summing character
6136 widths as they go. This works well for ordinary text, but if the
6137 buffer's lines are very long (say, more than 500 characters), these
6138 motion functions will take longer to execute. Emacs may also take
6139 longer to update the display.
6141 If `cache-long-line-scans' is non-nil, these motion functions cache the
6142 results of their scans, and consult the cache to avoid rescanning
6143 regions of the buffer until the text is modified. The caches are most
6144 beneficial when they prevent the most searching---that is, when the
6145 buffer contains long lines and large regions of characters with the
6146 same, fixed screen width.
6148 When `cache-long-line-scans' is non-nil, processing short lines will
6149 become slightly slower (because of the overhead of consulting the
6150 cache), and the caches will use memory roughly proportional to the
6151 number of newlines and characters whose screen width varies.
6153 The caches require no explicit maintenance; their accuracy is
6154 maintained internally by the Emacs primitives. Enabling or disabling
6155 the cache should not affect the behavior of any of the motion
6156 functions; it should only affect their performance. */);
6158 DEFVAR_PER_BUFFER ("point-before-scroll", &BVAR (current_buffer, point_before_scroll), Qnil,
6159 doc: /* Value of point before the last series of scroll operations, or nil. */);
6161 DEFVAR_PER_BUFFER ("buffer-file-format", &BVAR (current_buffer, file_format), Qnil,
6162 doc: /* List of formats to use when saving this buffer.
6163 Formats are defined by `format-alist'. This variable is
6164 set when a file is visited. */);
6166 DEFVAR_PER_BUFFER ("buffer-auto-save-file-format",
6167 &BVAR (current_buffer, auto_save_file_format), Qnil,
6168 doc: /* Format in which to write auto-save files.
6169 Should be a list of symbols naming formats that are defined in `format-alist'.
6170 If it is t, which is the default, auto-save files are written in the
6171 same format as a regular save would use. */);
6173 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
6174 &BVAR (current_buffer, invisibility_spec), Qnil,
6175 doc: /* Invisibility spec of this buffer.
6176 The default is t, which means that text is invisible
6177 if it has a non-nil `invisible' property.
6178 If the value is a list, a text character is invisible if its `invisible'
6179 property is an element in that list (or is a list with members in common).
6180 If an element is a cons cell of the form (PROP . ELLIPSIS),
6181 then characters with property value PROP are invisible,
6182 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
6184 DEFVAR_PER_BUFFER ("buffer-display-count",
6185 &BVAR (current_buffer, display_count), Qintegerp,
6186 doc: /* A number incremented each time this buffer is displayed in a window.
6187 The function `set-window-buffer' increments it. */);
6189 DEFVAR_PER_BUFFER ("buffer-display-time",
6190 &BVAR (current_buffer, display_time), Qnil,
6191 doc: /* Time stamp updated each time this buffer is displayed in a window.
6192 The function `set-window-buffer' updates this variable
6193 to the value obtained by calling `current-time'.
6194 If the buffer has never been shown in a window, the value is nil. */);
6196 DEFVAR_LISP ("transient-mark-mode", Vtransient_mark_mode,
6197 doc: /* Non-nil if Transient Mark mode is enabled.
6198 See the command `transient-mark-mode' for a description of this minor mode.
6200 Non-nil also enables highlighting of the region whenever the mark is active.
6201 The variable `highlight-nonselected-windows' controls whether to highlight
6202 all windows or just the selected window.
6204 Lisp programs may give this variable certain special values:
6206 - A value of `lambda' enables Transient Mark mode temporarily.
6207 It is disabled again after any subsequent action that would
6208 normally deactivate the mark (e.g. buffer modification).
6210 - A value of (only . OLDVAL) enables Transient Mark mode
6211 temporarily. After any subsequent point motion command that is
6212 not shift-translated, or any other action that would normally
6213 deactivate the mark (e.g. buffer modification), the value of
6214 `transient-mark-mode' is set to OLDVAL. */);
6215 Vtransient_mark_mode = Qnil;
6217 DEFVAR_LISP ("inhibit-read-only", Vinhibit_read_only,
6218 doc: /* Non-nil means disregard read-only status of buffers or characters.
6219 If the value is t, disregard `buffer-read-only' and all `read-only'
6220 text properties. If the value is a list, disregard `buffer-read-only'
6221 and disregard a `read-only' text property if the property value
6222 is a member of the list. */);
6223 Vinhibit_read_only = Qnil;
6225 DEFVAR_PER_BUFFER ("cursor-type", &BVAR (current_buffer, cursor_type), Qnil,
6226 doc: /* Cursor to use when this buffer is in the selected window.
6227 Values are interpreted as follows:
6229 t use the cursor specified for the frame
6230 nil don't display a cursor
6231 box display a filled box cursor
6232 hollow display a hollow box cursor
6233 bar display a vertical bar cursor with default width
6234 (bar . WIDTH) display a vertical bar cursor with width WIDTH
6235 hbar display a horizontal bar cursor with default height
6236 (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
6237 ANYTHING ELSE display a hollow box cursor
6239 When the buffer is displayed in a non-selected window, the
6240 cursor's appearance is instead controlled by the variable
6241 `cursor-in-non-selected-windows'. */);
6243 DEFVAR_PER_BUFFER ("line-spacing",
6244 &BVAR (current_buffer, extra_line_spacing), Qnumberp,
6245 doc: /* Additional space to put between lines when displaying a buffer.
6246 The space is measured in pixels, and put below lines on graphic displays,
6247 see `display-graphic-p'.
6248 If value is a floating point number, it specifies the spacing relative
6249 to the default frame line height. A value of nil means add no extra space. */);
6251 DEFVAR_PER_BUFFER ("cursor-in-non-selected-windows",
6252 &BVAR (current_buffer, cursor_in_non_selected_windows), Qnil,
6253 doc: /* Non-nil means show a cursor in non-selected windows.
6254 If nil, only shows a cursor in the selected window.
6255 If t, displays a cursor related to the usual cursor type
6256 \(a solid box becomes hollow, a bar becomes a narrower bar).
6257 You can also specify the cursor type as in the `cursor-type' variable.
6258 Use Custom to set this variable and update the display." */);
6260 DEFVAR_LISP ("kill-buffer-query-functions", Vkill_buffer_query_functions,
6261 doc: /* List of functions called with no args to query before killing a buffer.
6262 The buffer being killed will be current while the functions are running.
6264 If any of them returns nil, the buffer is not killed. Functions run by
6265 this hook are supposed to not change the current buffer. */);
6266 Vkill_buffer_query_functions = Qnil;
6268 DEFVAR_LISP ("change-major-mode-hook", Vchange_major_mode_hook,
6269 doc: /* Normal hook run before changing the major mode of a buffer.
6270 The function `kill-all-local-variables' runs this before doing anything else. */);
6271 Vchange_major_mode_hook = Qnil;
6272 DEFSYM (Qchange_major_mode_hook, "change-major-mode-hook");
6274 DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook,
6275 doc: /* Hook run when the buffer list changes.
6276 Functions running this hook are `get-buffer-create',
6277 `make-indirect-buffer', `rename-buffer', `kill-buffer',
6278 and `bury-buffer-internal'. */);
6279 Vbuffer_list_update_hook = Qnil;
6280 DEFSYM (Qbuffer_list_update_hook, "buffer-list-update-hook");
6282 defsubr (&Sbuffer_live_p);
6283 defsubr (&Sbuffer_list);
6284 defsubr (&Sget_buffer);
6285 defsubr (&Sget_file_buffer);
6286 defsubr (&Sget_buffer_create);
6287 defsubr (&Smake_indirect_buffer);
6288 defsubr (&Sgenerate_new_buffer_name);
6289 defsubr (&Sbuffer_name);
6290 defsubr (&Sbuffer_file_name);
6291 defsubr (&Sbuffer_base_buffer);
6292 defsubr (&Sbuffer_local_value);
6293 defsubr (&Sbuffer_local_variables);
6294 defsubr (&Sbuffer_modified_p);
6295 defsubr (&Sset_buffer_modified_p);
6296 defsubr (&Sbuffer_modified_tick);
6297 defsubr (&Sbuffer_chars_modified_tick);
6298 defsubr (&Srename_buffer);
6299 defsubr (&Sother_buffer);
6300 defsubr (&Sbuffer_enable_undo);
6301 defsubr (&Skill_buffer);
6302 defsubr (&Sbury_buffer_internal);
6303 defsubr (&Sset_buffer_major_mode);
6304 defsubr (&Scurrent_buffer);
6305 defsubr (&Sset_buffer);
6306 defsubr (&Sbarf_if_buffer_read_only);
6307 defsubr (&Serase_buffer);
6308 defsubr (&Sbuffer_swap_text);
6309 defsubr (&Sset_buffer_multibyte);
6310 defsubr (&Skill_all_local_variables);
6312 defsubr (&Soverlayp);
6313 defsubr (&Smake_overlay);
6314 defsubr (&Sdelete_overlay);
6315 defsubr (&Sdelete_all_overlays);
6316 defsubr (&Smove_overlay);
6317 defsubr (&Soverlay_start);
6318 defsubr (&Soverlay_end);
6319 defsubr (&Soverlay_buffer);
6320 defsubr (&Soverlay_properties);
6321 defsubr (&Soverlays_at);
6322 defsubr (&Soverlays_in);
6323 defsubr (&Snext_overlay_change);
6324 defsubr (&Sprevious_overlay_change);
6325 defsubr (&Soverlay_recenter);
6326 defsubr (&Soverlay_lists);
6327 defsubr (&Soverlay_get);
6328 defsubr (&Soverlay_put);
6329 defsubr (&Srestore_buffer_modified_p);
6332 void
6333 keys_of_buffer (void)
6335 initial_define_key (control_x_map, 'b', "switch-to-buffer");
6336 initial_define_key (control_x_map, 'k', "kill-buffer");
6338 /* This must not be in syms_of_buffer, because Qdisabled is not
6339 initialized when that function gets called. */
6340 Fput (intern_c_string ("erase-buffer"), Qdisabled, Qt);