(Fmove_overlay): Set overlay's next pointer
[bpt/emacs.git] / src / buffer.c
1 /* Buffer manipulation primitives for GNU Emacs.
2 Copyright (C) 1985,86,87,88,89,93,94,95,97,98, 1999, 2000, 2001, 02, 2003
3 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 #include <config.h>
23
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #include <sys/param.h>
27 #include <errno.h>
28 #include <stdio.h>
29
30 #ifndef USE_CRT_DLL
31 extern int errno;
32 #endif
33
34 #ifndef MAXPATHLEN
35 /* in 4.1 [probably SunOS? -stef] , param.h fails to define this. */
36 #define MAXPATHLEN 1024
37 #endif /* not MAXPATHLEN */
38
39 #ifdef HAVE_UNISTD_H
40 #include <unistd.h>
41 #endif
42
43 #include "lisp.h"
44 #include "intervals.h"
45 #include "window.h"
46 #include "commands.h"
47 #include "buffer.h"
48 #include "charset.h"
49 #include "region-cache.h"
50 #include "indent.h"
51 #include "blockinput.h"
52 #include "keyboard.h"
53 #include "keymap.h"
54 #include "frame.h"
55
56 struct buffer *current_buffer; /* the current buffer */
57
58 /* First buffer in chain of all buffers (in reverse order of creation).
59 Threaded through ->next. */
60
61 struct buffer *all_buffers;
62
63 /* This structure holds the default values of the buffer-local variables
64 defined with DEFVAR_PER_BUFFER, that have special slots in each buffer.
65 The default value occupies the same slot in this structure
66 as an individual buffer's value occupies in that buffer.
67 Setting the default value also goes through the alist of buffers
68 and stores into each buffer that does not say it has a local value. */
69
70 struct buffer buffer_defaults;
71
72 /* A Lisp_Object pointer to the above, used for staticpro */
73
74 static Lisp_Object Vbuffer_defaults;
75
76 /* This structure marks which slots in a buffer have corresponding
77 default values in buffer_defaults.
78 Each such slot has a nonzero value in this structure.
79 The value has only one nonzero bit.
80
81 When a buffer has its own local value for a slot,
82 the entry for that slot (found in the same slot in this structure)
83 is turned on in the buffer's local_flags array.
84
85 If a slot in this structure is -1, then even though there may
86 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
87 and the corresponding slot in buffer_defaults is not used.
88
89 If a slot is -2, then there is no DEFVAR_PER_BUFFER for it,
90 but there is a default value which is copied into each buffer.
91
92 If a slot in this structure is negative, then even though there may
93 be a DEFVAR_PER_BUFFER for the slot, there is no default value for it;
94 and the corresponding slot in buffer_defaults is not used.
95
96 If a slot in this structure corresponding to a DEFVAR_PER_BUFFER is
97 zero, that is a bug */
98
99 struct buffer buffer_local_flags;
100
101 /* This structure holds the names of symbols whose values may be
102 buffer-local. It is indexed and accessed in the same way as the above. */
103
104 struct buffer buffer_local_symbols;
105 /* A Lisp_Object pointer to the above, used for staticpro */
106 static Lisp_Object Vbuffer_local_symbols;
107
108 /* This structure holds the required types for the values in the
109 buffer-local slots. If a slot contains Qnil, then the
110 corresponding buffer slot may contain a value of any type. If a
111 slot contains an integer, then prospective values' tags must be
112 equal to that integer (except nil is always allowed).
113 When a tag does not match, the function
114 buffer_slot_type_mismatch will signal an error.
115
116 If a slot here contains -1, the corresponding variable is read-only. */
117 struct buffer buffer_local_types;
118
119 /* Flags indicating which built-in buffer-local variables
120 are permanent locals. */
121 static char buffer_permanent_local_flags[MAX_PER_BUFFER_VARS];
122
123 /* Number of per-buffer variables used. */
124
125 int last_per_buffer_idx;
126
127 Lisp_Object Fset_buffer ();
128 void set_buffer_internal ();
129 void set_buffer_internal_1 ();
130 static void call_overlay_mod_hooks ();
131 static void swap_out_buffer_local_variables ();
132 static void reset_buffer_local_variables ();
133
134 /* Alist of all buffer names vs the buffers. */
135 /* This used to be a variable, but is no longer,
136 to prevent lossage due to user rplac'ing this alist or its elements. */
137 Lisp_Object Vbuffer_alist;
138
139 /* Functions to call before and after each text change. */
140 Lisp_Object Vbefore_change_functions;
141 Lisp_Object Vafter_change_functions;
142
143 Lisp_Object Vtransient_mark_mode;
144
145 /* t means ignore all read-only text properties.
146 A list means ignore such a property if its value is a member of the list.
147 Any non-nil value means ignore buffer-read-only. */
148 Lisp_Object Vinhibit_read_only;
149
150 /* List of functions to call that can query about killing a buffer.
151 If any of these functions returns nil, we don't kill it. */
152 Lisp_Object Vkill_buffer_query_functions;
153 Lisp_Object Qkill_buffer_query_functions;
154
155 /* List of functions to call before changing an unmodified buffer. */
156 Lisp_Object Vfirst_change_hook;
157
158 Lisp_Object Qfirst_change_hook;
159 Lisp_Object Qbefore_change_functions;
160 Lisp_Object Qafter_change_functions;
161 Lisp_Object Qucs_set_table_for_input;
162
163 /* If nonzero, all modification hooks are suppressed. */
164 int inhibit_modification_hooks;
165
166 Lisp_Object Qfundamental_mode, Qmode_class, Qpermanent_local;
167
168 Lisp_Object Qprotected_field;
169
170 Lisp_Object QSFundamental; /* A string "Fundamental" */
171
172 Lisp_Object Qkill_buffer_hook;
173
174 Lisp_Object Qget_file_buffer;
175
176 Lisp_Object Qoverlayp;
177
178 Lisp_Object Qpriority, Qwindow, Qevaporate, Qbefore_string, Qafter_string;
179
180 Lisp_Object Qmodification_hooks;
181 Lisp_Object Qinsert_in_front_hooks;
182 Lisp_Object Qinsert_behind_hooks;
183
184 static void alloc_buffer_text P_ ((struct buffer *, size_t));
185 static void free_buffer_text P_ ((struct buffer *b));
186 static struct Lisp_Overlay * copy_overlays P_ ((struct buffer *, struct Lisp_Overlay *));
187 static void modify_overlay P_ ((struct buffer *, EMACS_INT, EMACS_INT));
188
189
190 /* For debugging; temporary. See set_buffer_internal. */
191 /* Lisp_Object Qlisp_mode, Vcheck_symbol; */
192
193 void
194 nsberror (spec)
195 Lisp_Object spec;
196 {
197 if (STRINGP (spec))
198 error ("No buffer named %s", SDATA (spec));
199 error ("Invalid buffer argument");
200 }
201 \f
202 DEFUN ("buffer-live-p", Fbuffer_live_p, Sbuffer_live_p, 1, 1, 0,
203 doc: /* Return non-nil if OBJECT is a buffer which has not been killed.
204 Value is nil if OBJECT is not a buffer or if it has been killed. */)
205 (object)
206 Lisp_Object object;
207 {
208 return ((BUFFERP (object) && ! NILP (XBUFFER (object)->name))
209 ? Qt : Qnil);
210 }
211
212 DEFUN ("buffer-list", Fbuffer_list, Sbuffer_list, 0, 1, 0,
213 doc: /* Return a list of all existing live buffers.
214 If the optional arg FRAME is a frame, we return the buffer list
215 in the proper order for that frame: the buffers in FRAME's `buffer-list'
216 frame parameter come first, followed by the rest of the buffers. */)
217 (frame)
218 Lisp_Object frame;
219 {
220 Lisp_Object framelist, general;
221 general = Fmapcar (Qcdr, Vbuffer_alist);
222
223 if (FRAMEP (frame))
224 {
225 Lisp_Object tail;
226
227 CHECK_FRAME (frame);
228
229 framelist = Fcopy_sequence (XFRAME (frame)->buffer_list);
230
231 /* Remove from GENERAL any buffer that duplicates one in FRAMELIST. */
232 tail = framelist;
233 while (! NILP (tail))
234 {
235 general = Fdelq (XCAR (tail), general);
236 tail = XCDR (tail);
237 }
238 return nconc2 (framelist, general);
239 }
240
241 return general;
242 }
243
244 /* Like Fassoc, but use Fstring_equal to compare
245 (which ignores text properties),
246 and don't ever QUIT. */
247
248 static Lisp_Object
249 assoc_ignore_text_properties (key, list)
250 register Lisp_Object key;
251 Lisp_Object list;
252 {
253 register Lisp_Object tail;
254 for (tail = list; CONSP (tail); tail = XCDR (tail))
255 {
256 register Lisp_Object elt, tem;
257 elt = XCAR (tail);
258 tem = Fstring_equal (Fcar (elt), key);
259 if (!NILP (tem))
260 return elt;
261 }
262 return Qnil;
263 }
264
265 DEFUN ("get-buffer", Fget_buffer, Sget_buffer, 1, 1, 0,
266 doc: /* Return the buffer named NAME (a string).
267 If there is no live buffer named NAME, return nil.
268 NAME may also be a buffer; if so, the value is that buffer. */)
269 (name)
270 register Lisp_Object name;
271 {
272 if (BUFFERP (name))
273 return name;
274 CHECK_STRING (name);
275
276 return Fcdr (assoc_ignore_text_properties (name, Vbuffer_alist));
277 }
278
279 DEFUN ("get-file-buffer", Fget_file_buffer, Sget_file_buffer, 1, 1, 0,
280 doc: /* Return the buffer visiting file FILENAME (a string).
281 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
282 If there is no such live buffer, return nil.
283 See also `find-buffer-visiting'. */)
284 (filename)
285 register Lisp_Object filename;
286 {
287 register Lisp_Object tail, buf, tem;
288 Lisp_Object handler;
289
290 CHECK_STRING (filename);
291 filename = Fexpand_file_name (filename, Qnil);
292
293 /* If the file name has special constructs in it,
294 call the corresponding file handler. */
295 handler = Ffind_file_name_handler (filename, Qget_file_buffer);
296 if (!NILP (handler))
297 return call2 (handler, Qget_file_buffer, filename);
298
299 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
300 {
301 buf = Fcdr (XCAR (tail));
302 if (!BUFFERP (buf)) continue;
303 if (!STRINGP (XBUFFER (buf)->filename)) continue;
304 tem = Fstring_equal (XBUFFER (buf)->filename, filename);
305 if (!NILP (tem))
306 return buf;
307 }
308 return Qnil;
309 }
310
311 Lisp_Object
312 get_truename_buffer (filename)
313 register Lisp_Object filename;
314 {
315 register Lisp_Object tail, buf, tem;
316
317 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
318 {
319 buf = Fcdr (XCAR (tail));
320 if (!BUFFERP (buf)) continue;
321 if (!STRINGP (XBUFFER (buf)->file_truename)) continue;
322 tem = Fstring_equal (XBUFFER (buf)->file_truename, filename);
323 if (!NILP (tem))
324 return buf;
325 }
326 return Qnil;
327 }
328
329 /* Incremented for each buffer created, to assign the buffer number. */
330 int buffer_count;
331
332 DEFUN ("get-buffer-create", Fget_buffer_create, Sget_buffer_create, 1, 1, 0,
333 doc: /* Return the buffer named NAME, or create such a buffer and return it.
334 A new buffer is created if there is no live buffer named NAME.
335 If NAME starts with a space, the new buffer does not keep undo information.
336 If NAME is a buffer instead of a string, then it is the value returned.
337 The value is never nil. */)
338 (name)
339 register Lisp_Object name;
340 {
341 register Lisp_Object buf;
342 register struct buffer *b;
343
344 buf = Fget_buffer (name);
345 if (!NILP (buf))
346 return buf;
347
348 if (SCHARS (name) == 0)
349 error ("Empty string for buffer name is not allowed");
350
351 b = (struct buffer *) allocate_buffer ();
352
353 b->size = sizeof (struct buffer) / sizeof (EMACS_INT);
354
355 /* An ordinary buffer uses its own struct buffer_text. */
356 b->text = &b->own_text;
357 b->base_buffer = 0;
358
359 BUF_GAP_SIZE (b) = 20;
360 BLOCK_INPUT;
361 /* We allocate extra 1-byte at the tail and keep it always '\0' for
362 anchoring a search. */
363 alloc_buffer_text (b, BUF_GAP_SIZE (b) + 1);
364 UNBLOCK_INPUT;
365 if (! BUF_BEG_ADDR (b))
366 buffer_memory_full ();
367
368 BUF_PT (b) = BEG;
369 BUF_GPT (b) = BEG;
370 BUF_BEGV (b) = BEG;
371 BUF_ZV (b) = BEG;
372 BUF_Z (b) = BEG;
373 BUF_PT_BYTE (b) = BEG_BYTE;
374 BUF_GPT_BYTE (b) = BEG_BYTE;
375 BUF_BEGV_BYTE (b) = BEG_BYTE;
376 BUF_ZV_BYTE (b) = BEG_BYTE;
377 BUF_Z_BYTE (b) = BEG_BYTE;
378 BUF_MODIFF (b) = 1;
379 BUF_OVERLAY_MODIFF (b) = 1;
380 BUF_SAVE_MODIFF (b) = 1;
381 BUF_INTERVALS (b) = 0;
382 BUF_UNCHANGED_MODIFIED (b) = 1;
383 BUF_OVERLAY_UNCHANGED_MODIFIED (b) = 1;
384 BUF_END_UNCHANGED (b) = 0;
385 BUF_BEG_UNCHANGED (b) = 0;
386 *(BUF_GPT_ADDR (b)) = *(BUF_Z_ADDR (b)) = 0; /* Put an anchor '\0'. */
387
388 b->newline_cache = 0;
389 b->width_run_cache = 0;
390 b->width_table = Qnil;
391 b->prevent_redisplay_optimizations_p = 1;
392
393 /* Put this on the chain of all buffers including killed ones. */
394 b->next = all_buffers;
395 all_buffers = b;
396
397 /* An ordinary buffer normally doesn't need markers
398 to handle BEGV and ZV. */
399 b->pt_marker = Qnil;
400 b->begv_marker = Qnil;
401 b->zv_marker = Qnil;
402
403 name = Fcopy_sequence (name);
404 STRING_SET_INTERVALS (name, NULL_INTERVAL);
405 b->name = name;
406
407 if (SREF (name, 0) != ' ')
408 b->undo_list = Qnil;
409 else
410 b->undo_list = Qt;
411
412 reset_buffer (b);
413 reset_buffer_local_variables (b, 1);
414
415 b->mark = Fmake_marker ();
416 BUF_MARKERS (b) = NULL;
417 b->name = name;
418
419 /* Put this in the alist of all live buffers. */
420 XSETBUFFER (buf, b);
421 Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (Fcons (name, buf), Qnil));
422
423 /* An error in calling the function here (should someone redfine it)
424 can lead to infinite regress until you run out of stack. rms
425 says that's not worth protecting against. */
426 if (!NILP (Ffboundp (Qucs_set_table_for_input)))
427 /* buf is on buffer-alist, so no gcpro. */
428 call1 (Qucs_set_table_for_input, buf);
429
430 return buf;
431 }
432
433
434 /* Return a list of overlays which is a copy of the overlay list
435 LIST, but for buffer B. */
436
437 static struct Lisp_Overlay *
438 copy_overlays (b, list)
439 struct buffer *b;
440 struct Lisp_Overlay *list;
441 {
442 Lisp_Object buffer;
443 struct Lisp_Overlay *result = NULL, *tail = NULL;
444
445 XSETBUFFER (buffer, b);
446
447 for (; list; list = list->next)
448 {
449 Lisp_Object overlay, start, end, old_overlay;
450 EMACS_INT charpos;
451
452 XSETMISC (old_overlay, list);
453 charpos = marker_position (OVERLAY_START (old_overlay));
454 start = Fmake_marker ();
455 Fset_marker (start, make_number (charpos), buffer);
456 XMARKER (start)->insertion_type
457 = XMARKER (OVERLAY_START (old_overlay))->insertion_type;
458
459 charpos = marker_position (OVERLAY_END (old_overlay));
460 end = Fmake_marker ();
461 Fset_marker (end, make_number (charpos), buffer);
462 XMARKER (end)->insertion_type
463 = XMARKER (OVERLAY_END (old_overlay))->insertion_type;
464
465 overlay = allocate_misc ();
466 XMISCTYPE (overlay) = Lisp_Misc_Overlay;
467 OVERLAY_START (overlay) = start;
468 OVERLAY_END (overlay) = end;
469 OVERLAY_PLIST (overlay) = Fcopy_sequence (OVERLAY_PLIST (old_overlay));
470 XOVERLAY (overlay)->next = NULL;
471
472 if (tail)
473 tail = tail->next = XOVERLAY (overlay);
474 else
475 result = tail = XOVERLAY (overlay);
476 }
477
478 return result;
479 }
480
481
482 /* Clone per-buffer values of buffer FROM.
483
484 Buffer TO gets the same per-buffer values as FROM, with the
485 following exceptions: (1) TO's name is left untouched, (2) markers
486 are copied and made to refer to TO, and (3) overlay lists are
487 copied. */
488
489 static void
490 clone_per_buffer_values (from, to)
491 struct buffer *from, *to;
492 {
493 Lisp_Object to_buffer;
494 int offset;
495
496 XSETBUFFER (to_buffer, to);
497
498 for (offset = PER_BUFFER_VAR_OFFSET (name) + sizeof (Lisp_Object);
499 offset < sizeof *to;
500 offset += sizeof (Lisp_Object))
501 {
502 Lisp_Object obj;
503
504 obj = PER_BUFFER_VALUE (from, offset);
505 if (MARKERP (obj))
506 {
507 struct Lisp_Marker *m = XMARKER (obj);
508 obj = Fmake_marker ();
509 XMARKER (obj)->insertion_type = m->insertion_type;
510 set_marker_both (obj, to_buffer, m->charpos, m->bytepos);
511 }
512
513 PER_BUFFER_VALUE (to, offset) = obj;
514 }
515
516 bcopy (from->local_flags, to->local_flags, sizeof to->local_flags);
517
518 to->overlays_before = copy_overlays (to, from->overlays_before);
519 to->overlays_after = copy_overlays (to, from->overlays_after);
520 }
521
522
523 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer, Smake_indirect_buffer,
524 2, 3,
525 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ",
526 doc: /* Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
527 BASE-BUFFER should be an existing buffer (or buffer name).
528 NAME should be a string which is not the name of an existing buffer.
529 Optional argument CLONE non-nil means preserve BASE-BUFFER's state,
530 such as major and minor modes, in the indirect buffer.
531 CLONE nil means the indirect buffer's state is reset to default values. */)
532 (base_buffer, name, clone)
533 Lisp_Object base_buffer, name, clone;
534 {
535 Lisp_Object buf;
536 struct buffer *b;
537
538 buf = Fget_buffer (name);
539 if (!NILP (buf))
540 error ("Buffer name `%s' is in use", SDATA (name));
541
542 base_buffer = Fget_buffer (base_buffer);
543 if (NILP (base_buffer))
544 error ("No such buffer: `%s'", SDATA (name));
545
546 if (SCHARS (name) == 0)
547 error ("Empty string for buffer name is not allowed");
548
549 b = (struct buffer *) allocate_buffer ();
550 b->size = sizeof (struct buffer) / sizeof (EMACS_INT);
551
552 if (XBUFFER (base_buffer)->base_buffer)
553 b->base_buffer = XBUFFER (base_buffer)->base_buffer;
554 else
555 b->base_buffer = XBUFFER (base_buffer);
556
557 /* Use the base buffer's text object. */
558 b->text = b->base_buffer->text;
559
560 BUF_BEGV (b) = BUF_BEGV (b->base_buffer);
561 BUF_ZV (b) = BUF_ZV (b->base_buffer);
562 BUF_PT (b) = BUF_PT (b->base_buffer);
563 BUF_BEGV_BYTE (b) = BUF_BEGV_BYTE (b->base_buffer);
564 BUF_ZV_BYTE (b) = BUF_ZV_BYTE (b->base_buffer);
565 BUF_PT_BYTE (b) = BUF_PT_BYTE (b->base_buffer);
566
567 b->newline_cache = 0;
568 b->width_run_cache = 0;
569 b->width_table = Qnil;
570
571 /* Put this on the chain of all buffers including killed ones. */
572 b->next = all_buffers;
573 all_buffers = b;
574
575 name = Fcopy_sequence (name);
576 STRING_SET_INTERVALS (name, NULL_INTERVAL);
577 b->name = name;
578
579 reset_buffer (b);
580 reset_buffer_local_variables (b, 1);
581
582 /* Put this in the alist of all live buffers. */
583 XSETBUFFER (buf, b);
584 Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (Fcons (name, buf), Qnil));
585
586 b->mark = Fmake_marker ();
587 b->name = name;
588
589 /* The multibyte status belongs to the base buffer. */
590 b->enable_multibyte_characters = b->base_buffer->enable_multibyte_characters;
591
592 /* Make sure the base buffer has markers for its narrowing. */
593 if (NILP (b->base_buffer->pt_marker))
594 {
595 b->base_buffer->pt_marker = Fmake_marker ();
596 set_marker_both (b->base_buffer->pt_marker, base_buffer,
597 BUF_PT (b->base_buffer),
598 BUF_PT_BYTE (b->base_buffer));
599 }
600 if (NILP (b->base_buffer->begv_marker))
601 {
602 b->base_buffer->begv_marker = Fmake_marker ();
603 set_marker_both (b->base_buffer->begv_marker, base_buffer,
604 BUF_BEGV (b->base_buffer),
605 BUF_BEGV_BYTE (b->base_buffer));
606 }
607 if (NILP (b->base_buffer->zv_marker))
608 {
609 b->base_buffer->zv_marker = Fmake_marker ();
610 set_marker_both (b->base_buffer->zv_marker, base_buffer,
611 BUF_ZV (b->base_buffer),
612 BUF_ZV_BYTE (b->base_buffer));
613 XMARKER (b->base_buffer->zv_marker)->insertion_type = 1;
614 }
615
616 if (NILP (clone))
617 {
618 /* Give the indirect buffer markers for its narrowing. */
619 b->pt_marker = Fmake_marker ();
620 set_marker_both (b->pt_marker, buf, BUF_PT (b), BUF_PT_BYTE (b));
621 b->begv_marker = Fmake_marker ();
622 set_marker_both (b->begv_marker, buf, BUF_BEGV (b), BUF_BEGV_BYTE (b));
623 b->zv_marker = Fmake_marker ();
624 set_marker_both (b->zv_marker, buf, BUF_ZV (b), BUF_ZV_BYTE (b));
625 XMARKER (b->zv_marker)->insertion_type = 1;
626 }
627 else
628 clone_per_buffer_values (b->base_buffer, b);
629
630 return buf;
631 }
632
633 void
634 delete_all_overlays (b)
635 struct buffer *b;
636 {
637 Lisp_Object overlay;
638
639 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
640 have to empty the list, otherwise we end up with overlays that
641 think they belong to this buffer while the buffer doesn't know about
642 them any more. */
643 while (b->overlays_before)
644 {
645 XSETMISC (overlay, b->overlays_before);
646 Fdelete_overlay (overlay);
647 }
648 while (b->overlays_after)
649 {
650 XSETMISC (overlay, b->overlays_after);
651 Fdelete_overlay (overlay);
652 }
653 eassert (b->overlays_before == NULL);
654 eassert (b->overlays_after == NULL);
655 }
656
657 /* Reinitialize everything about a buffer except its name and contents
658 and local variables.
659 If called on an already-initialized buffer, the list of overlays
660 should be deleted before calling this function, otherwise we end up
661 with overlays that claim to belong to the buffer but the buffer
662 claims it doesn't belong to it. */
663
664 void
665 reset_buffer (b)
666 register struct buffer *b;
667 {
668 b->filename = Qnil;
669 b->file_truename = Qnil;
670 b->directory = (current_buffer) ? current_buffer->directory : Qnil;
671 b->modtime = 0;
672 XSETFASTINT (b->save_length, 0);
673 b->last_window_start = 1;
674 /* It is more conservative to start out "changed" than "unchanged". */
675 b->clip_changed = 0;
676 b->prevent_redisplay_optimizations_p = 1;
677 b->backed_up = Qnil;
678 b->auto_save_modified = 0;
679 b->auto_save_failure_time = -1;
680 b->auto_save_file_name = Qnil;
681 b->read_only = Qnil;
682 b->overlays_before = NULL;
683 b->overlays_after = NULL;
684 b->overlay_center = BEG;
685 b->mark_active = Qnil;
686 b->point_before_scroll = Qnil;
687 b->file_format = Qnil;
688 b->last_selected_window = Qnil;
689 XSETINT (b->display_count, 0);
690 b->display_time = Qnil;
691 b->enable_multibyte_characters = buffer_defaults.enable_multibyte_characters;
692 b->cursor_type = buffer_defaults.cursor_type;
693 b->extra_line_spacing = buffer_defaults.extra_line_spacing;
694
695 b->display_error_modiff = 0;
696 }
697
698 /* Reset buffer B's local variables info.
699 Don't use this on a buffer that has already been in use;
700 it does not treat permanent locals consistently.
701 Instead, use Fkill_all_local_variables.
702
703 If PERMANENT_TOO is 1, then we reset permanent built-in
704 buffer-local variables. If PERMANENT_TOO is 0,
705 we preserve those. */
706
707 static void
708 reset_buffer_local_variables (b, permanent_too)
709 register struct buffer *b;
710 int permanent_too;
711 {
712 register int offset;
713 int i;
714
715 /* Reset the major mode to Fundamental, together with all the
716 things that depend on the major mode.
717 default-major-mode is handled at a higher level.
718 We ignore it here. */
719 b->major_mode = Qfundamental_mode;
720 b->keymap = Qnil;
721 b->mode_name = QSFundamental;
722 b->minor_modes = Qnil;
723
724 /* If the standard case table has been altered and invalidated,
725 fix up its insides first. */
726 if (! (CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table)->extras[0])
727 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table)->extras[1])
728 && CHAR_TABLE_P (XCHAR_TABLE (Vascii_downcase_table)->extras[2])))
729 Fset_standard_case_table (Vascii_downcase_table);
730
731 b->downcase_table = Vascii_downcase_table;
732 b->upcase_table = XCHAR_TABLE (Vascii_downcase_table)->extras[0];
733 b->case_canon_table = XCHAR_TABLE (Vascii_downcase_table)->extras[1];
734 b->case_eqv_table = XCHAR_TABLE (Vascii_downcase_table)->extras[2];
735 b->invisibility_spec = Qt;
736 #ifndef DOS_NT
737 b->buffer_file_type = Qnil;
738 #endif
739
740 /* Reset all (or most) per-buffer variables to their defaults. */
741 b->local_var_alist = Qnil;
742 for (i = 0; i < last_per_buffer_idx; ++i)
743 if (permanent_too || buffer_permanent_local_flags[i] == 0)
744 SET_PER_BUFFER_VALUE_P (b, i, 0);
745
746 /* For each slot that has a default value,
747 copy that into the slot. */
748
749 for (offset = PER_BUFFER_VAR_OFFSET (name);
750 offset < sizeof *b;
751 offset += sizeof (Lisp_Object))
752 {
753 int idx = PER_BUFFER_IDX (offset);
754 if ((idx > 0
755 && (permanent_too
756 || buffer_permanent_local_flags[idx] == 0))
757 /* Is -2 used anywhere? */
758 || idx == -2)
759 PER_BUFFER_VALUE (b, offset) = PER_BUFFER_DEFAULT (offset);
760 }
761 }
762
763 /* We split this away from generate-new-buffer, because rename-buffer
764 and set-visited-file-name ought to be able to use this to really
765 rename the buffer properly. */
766
767 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name, Sgenerate_new_buffer_name,
768 1, 2, 0,
769 doc: /* Return a string that is the name of no existing buffer based on NAME.
770 If there is no live buffer named NAME, then return NAME.
771 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
772 until an unused name is found, and then return that name.
773 Optional second argument IGNORE specifies a name that is okay to use
774 \(if it is in the sequence to be tried)
775 even if a buffer with that name exists. */)
776 (name, ignore)
777 register Lisp_Object name, ignore;
778 {
779 register Lisp_Object gentemp, tem;
780 int count;
781 char number[10];
782
783 CHECK_STRING (name);
784
785 tem = Fget_buffer (name);
786 if (NILP (tem))
787 return name;
788
789 count = 1;
790 while (1)
791 {
792 sprintf (number, "<%d>", ++count);
793 gentemp = concat2 (name, build_string (number));
794 tem = Fstring_equal (gentemp, ignore);
795 if (!NILP (tem))
796 return gentemp;
797 tem = Fget_buffer (gentemp);
798 if (NILP (tem))
799 return gentemp;
800 }
801 }
802
803 \f
804 DEFUN ("buffer-name", Fbuffer_name, Sbuffer_name, 0, 1, 0,
805 doc: /* Return the name of BUFFER, as a string.
806 With no argument or nil as argument, return the name of the current buffer. */)
807 (buffer)
808 register Lisp_Object buffer;
809 {
810 if (NILP (buffer))
811 return current_buffer->name;
812 CHECK_BUFFER (buffer);
813 return XBUFFER (buffer)->name;
814 }
815
816 DEFUN ("buffer-file-name", Fbuffer_file_name, Sbuffer_file_name, 0, 1, 0,
817 doc: /* Return name of file BUFFER is visiting, or nil if none.
818 No argument or nil as argument means use the current buffer. */)
819 (buffer)
820 register Lisp_Object buffer;
821 {
822 if (NILP (buffer))
823 return current_buffer->filename;
824 CHECK_BUFFER (buffer);
825 return XBUFFER (buffer)->filename;
826 }
827
828 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer, Sbuffer_base_buffer,
829 0, 1, 0,
830 doc: /* Return the base buffer of indirect buffer BUFFER.
831 If BUFFER is not indirect, return nil. */)
832 (buffer)
833 register Lisp_Object buffer;
834 {
835 struct buffer *base;
836 Lisp_Object base_buffer;
837
838 if (NILP (buffer))
839 base = current_buffer->base_buffer;
840 else
841 {
842 CHECK_BUFFER (buffer);
843 base = XBUFFER (buffer)->base_buffer;
844 }
845
846 if (! base)
847 return Qnil;
848 XSETBUFFER (base_buffer, base);
849 return base_buffer;
850 }
851
852 DEFUN ("buffer-local-value", Fbuffer_local_value,
853 Sbuffer_local_value, 2, 2, 0,
854 doc: /* Return the value of VARIABLE in BUFFER.
855 If VARIABLE does not have a buffer-local binding in BUFFER, the value
856 is the default binding of variable. */)
857 (symbol, buffer)
858 register Lisp_Object symbol;
859 register Lisp_Object buffer;
860 {
861 register struct buffer *buf;
862 register Lisp_Object result;
863
864 CHECK_SYMBOL (symbol);
865 CHECK_BUFFER (buffer);
866 buf = XBUFFER (buffer);
867
868 /* Look in local_var_list */
869 result = Fassoc (symbol, buf->local_var_alist);
870 if (NILP (result))
871 {
872 int offset, idx;
873 int found = 0;
874
875 /* Look in special slots */
876 for (offset = PER_BUFFER_VAR_OFFSET (name);
877 offset < sizeof (struct buffer);
878 /* sizeof EMACS_INT == sizeof Lisp_Object */
879 offset += (sizeof (EMACS_INT)))
880 {
881 idx = PER_BUFFER_IDX (offset);
882 if ((idx == -1 || PER_BUFFER_VALUE_P (buf, idx))
883 && SYMBOLP (PER_BUFFER_SYMBOL (offset))
884 && EQ (PER_BUFFER_SYMBOL (offset), symbol))
885 {
886 result = PER_BUFFER_VALUE (buf, offset);
887 found = 1;
888 break;
889 }
890 }
891
892 if (!found)
893 result = Fdefault_value (symbol);
894 }
895 else
896 {
897 Lisp_Object valcontents;
898 Lisp_Object current_alist_element;
899
900 /* What binding is loaded right now? */
901 valcontents = SYMBOL_VALUE (symbol);
902 current_alist_element
903 = XCAR (XBUFFER_LOCAL_VALUE (valcontents)->cdr);
904
905 /* The value of the currently loaded binding is not
906 stored in it, but rather in the realvalue slot.
907 Store that value into the binding it belongs to
908 in case that is the one we are about to use. */
909
910 Fsetcdr (current_alist_element,
911 do_symval_forwarding (XBUFFER_LOCAL_VALUE (valcontents)->realvalue));
912
913 /* Now get the (perhaps updated) value out of the binding. */
914 result = XCDR (result);
915 }
916
917 if (EQ (result, Qunbound))
918 return Fsignal (Qvoid_variable, Fcons (symbol, Qnil));
919
920 return result;
921 }
922
923 DEFUN ("buffer-local-variables", Fbuffer_local_variables,
924 Sbuffer_local_variables, 0, 1, 0,
925 doc: /* Return an alist of variables that are buffer-local in BUFFER.
926 Most elements look like (SYMBOL . VALUE), describing one variable.
927 For a symbol that is locally unbound, just the symbol appears in the value.
928 Note that storing new VALUEs in these elements doesn't change the variables.
929 No argument or nil as argument means use current buffer as BUFFER. */)
930 (buffer)
931 register Lisp_Object buffer;
932 {
933 register struct buffer *buf;
934 register Lisp_Object result;
935
936 if (NILP (buffer))
937 buf = current_buffer;
938 else
939 {
940 CHECK_BUFFER (buffer);
941 buf = XBUFFER (buffer);
942 }
943
944 result = Qnil;
945
946 {
947 register Lisp_Object tail;
948 for (tail = buf->local_var_alist; CONSP (tail); tail = XCDR (tail))
949 {
950 Lisp_Object val, elt;
951
952 elt = XCAR (tail);
953
954 /* Reference each variable in the alist in buf.
955 If inquiring about the current buffer, this gets the current values,
956 so store them into the alist so the alist is up to date.
957 If inquiring about some other buffer, this swaps out any values
958 for that buffer, making the alist up to date automatically. */
959 val = find_symbol_value (XCAR (elt));
960 /* Use the current buffer value only if buf is the current buffer. */
961 if (buf != current_buffer)
962 val = XCDR (elt);
963
964 /* If symbol is unbound, put just the symbol in the list. */
965 if (EQ (val, Qunbound))
966 result = Fcons (XCAR (elt), result);
967 /* Otherwise, put (symbol . value) in the list. */
968 else
969 result = Fcons (Fcons (XCAR (elt), val), result);
970 }
971 }
972
973 /* Add on all the variables stored in special slots. */
974 {
975 int offset, idx;
976
977 for (offset = PER_BUFFER_VAR_OFFSET (name);
978 offset < sizeof (struct buffer);
979 /* sizeof EMACS_INT == sizeof Lisp_Object */
980 offset += (sizeof (EMACS_INT)))
981 {
982 idx = PER_BUFFER_IDX (offset);
983 if ((idx == -1 || PER_BUFFER_VALUE_P (buf, idx))
984 && SYMBOLP (PER_BUFFER_SYMBOL (offset)))
985 result = Fcons (Fcons (PER_BUFFER_SYMBOL (offset),
986 PER_BUFFER_VALUE (buf, offset)),
987 result);
988 }
989 }
990
991 return result;
992 }
993
994 \f
995 DEFUN ("buffer-modified-p", Fbuffer_modified_p, Sbuffer_modified_p,
996 0, 1, 0,
997 doc: /* Return t if BUFFER was modified since its file was last read or saved.
998 No argument or nil as argument means use current buffer as BUFFER. */)
999 (buffer)
1000 register Lisp_Object buffer;
1001 {
1002 register struct buffer *buf;
1003 if (NILP (buffer))
1004 buf = current_buffer;
1005 else
1006 {
1007 CHECK_BUFFER (buffer);
1008 buf = XBUFFER (buffer);
1009 }
1010
1011 return BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf) ? Qt : Qnil;
1012 }
1013
1014 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p, Sset_buffer_modified_p,
1015 1, 1, 0,
1016 doc: /* Mark current buffer as modified or unmodified according to FLAG.
1017 A non-nil FLAG means mark the buffer modified. */)
1018 (flag)
1019 register Lisp_Object flag;
1020 {
1021 register int already;
1022 register Lisp_Object fn;
1023 Lisp_Object buffer, window;
1024
1025 #ifdef CLASH_DETECTION
1026 /* If buffer becoming modified, lock the file.
1027 If buffer becoming unmodified, unlock the file. */
1028
1029 fn = current_buffer->file_truename;
1030 /* Test buffer-file-name so that binding it to nil is effective. */
1031 if (!NILP (fn) && ! NILP (current_buffer->filename))
1032 {
1033 already = SAVE_MODIFF < MODIFF;
1034 if (!already && !NILP (flag))
1035 lock_file (fn);
1036 else if (already && NILP (flag))
1037 unlock_file (fn);
1038 }
1039 #endif /* CLASH_DETECTION */
1040
1041 SAVE_MODIFF = NILP (flag) ? MODIFF : 0;
1042
1043 /* Set update_mode_lines only if buffer is displayed in some window.
1044 Packages like jit-lock or lazy-lock preserve a buffer's modified
1045 state by recording/restoring the state around blocks of code.
1046 Setting update_mode_lines makes redisplay consider all windows
1047 (on all frames). Stealth fontification of buffers not displayed
1048 would incur additional redisplay costs if we'd set
1049 update_modes_lines unconditionally.
1050
1051 Ideally, I think there should be another mechanism for fontifying
1052 buffers without "modifying" buffers, or redisplay should be
1053 smarter about updating the `*' in mode lines. --gerd */
1054 XSETBUFFER (buffer, current_buffer);
1055 window = Fget_buffer_window (buffer, Qt);
1056 if (WINDOWP (window))
1057 {
1058 ++update_mode_lines;
1059 current_buffer->prevent_redisplay_optimizations_p = 1;
1060 }
1061
1062 return flag;
1063 }
1064
1065 DEFUN ("restore-buffer-modified-p", Frestore_buffer_modified_p,
1066 Srestore_buffer_modified_p, 1, 1, 0,
1067 doc: /* Like `set-buffer-modified-p', with a differences concerning redisplay.
1068 It is not ensured that mode lines will be updated to show the modified
1069 state of the current buffer. Use with care. */)
1070 (flag)
1071 Lisp_Object flag;
1072 {
1073 #ifdef CLASH_DETECTION
1074 Lisp_Object fn;
1075
1076 /* If buffer becoming modified, lock the file.
1077 If buffer becoming unmodified, unlock the file. */
1078
1079 fn = current_buffer->file_truename;
1080 /* Test buffer-file-name so that binding it to nil is effective. */
1081 if (!NILP (fn) && ! NILP (current_buffer->filename))
1082 {
1083 int already = SAVE_MODIFF < MODIFF;
1084 if (!already && !NILP (flag))
1085 lock_file (fn);
1086 else if (already && NILP (flag))
1087 unlock_file (fn);
1088 }
1089 #endif /* CLASH_DETECTION */
1090
1091 SAVE_MODIFF = NILP (flag) ? MODIFF : 0;
1092 return flag;
1093 }
1094
1095 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick, Sbuffer_modified_tick,
1096 0, 1, 0,
1097 doc: /* Return BUFFER's tick counter, incremented for each change in text.
1098 Each buffer has a tick counter which is incremented each time the text in
1099 that buffer is changed. It wraps around occasionally.
1100 No argument or nil as argument means use current buffer as BUFFER. */)
1101 (buffer)
1102 register Lisp_Object buffer;
1103 {
1104 register struct buffer *buf;
1105 if (NILP (buffer))
1106 buf = current_buffer;
1107 else
1108 {
1109 CHECK_BUFFER (buffer);
1110 buf = XBUFFER (buffer);
1111 }
1112
1113 return make_number (BUF_MODIFF (buf));
1114 }
1115 \f
1116 DEFUN ("rename-buffer", Frename_buffer, Srename_buffer, 1, 2,
1117 "sRename buffer (to new name): \nP",
1118 doc: /* Change current buffer's name to NEWNAME (a string).
1119 If second arg UNIQUE is nil or omitted, it is an error if a
1120 buffer named NEWNAME already exists.
1121 If UNIQUE is non-nil, come up with a new name using
1122 `generate-new-buffer-name'.
1123 Interactively, you can set UNIQUE with a prefix argument.
1124 We return the name we actually gave the buffer.
1125 This does not change the name of the visited file (if any). */)
1126 (newname, unique)
1127 register Lisp_Object newname, unique;
1128 {
1129 register Lisp_Object tem, buf;
1130
1131 CHECK_STRING (newname);
1132
1133 if (SCHARS (newname) == 0)
1134 error ("Empty string is invalid as a buffer name");
1135
1136 tem = Fget_buffer (newname);
1137 if (!NILP (tem))
1138 {
1139 /* Don't short-circuit if UNIQUE is t. That is a useful way to
1140 rename the buffer automatically so you can create another
1141 with the original name. It makes UNIQUE equivalent to
1142 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1143 if (NILP (unique) && XBUFFER (tem) == current_buffer)
1144 return current_buffer->name;
1145 if (!NILP (unique))
1146 newname = Fgenerate_new_buffer_name (newname, current_buffer->name);
1147 else
1148 error ("Buffer name `%s' is in use", SDATA (newname));
1149 }
1150
1151 current_buffer->name = newname;
1152
1153 /* Catch redisplay's attention. Unless we do this, the mode lines for
1154 any windows displaying current_buffer will stay unchanged. */
1155 update_mode_lines++;
1156
1157 XSETBUFFER (buf, current_buffer);
1158 Fsetcar (Frassq (buf, Vbuffer_alist), newname);
1159 if (NILP (current_buffer->filename)
1160 && !NILP (current_buffer->auto_save_file_name))
1161 call0 (intern ("rename-auto-save-file"));
1162 /* Refetch since that last call may have done GC. */
1163 return current_buffer->name;
1164 }
1165
1166 DEFUN ("other-buffer", Fother_buffer, Sother_buffer, 0, 3, 0,
1167 doc: /* Return most recently selected buffer other than BUFFER.
1168 Buffers not visible in windows are preferred to visible buffers,
1169 unless optional second argument VISIBLE-OK is non-nil.
1170 If the optional third argument FRAME is non-nil, use that frame's
1171 buffer list instead of the selected frame's buffer list.
1172 If no other buffer exists, the buffer `*scratch*' is returned.
1173 If BUFFER is omitted or nil, some interesting buffer is returned. */)
1174 (buffer, visible_ok, frame)
1175 register Lisp_Object buffer, visible_ok, frame;
1176 {
1177 Lisp_Object Fset_buffer_major_mode ();
1178 register Lisp_Object tail, buf, notsogood, tem, pred, add_ons;
1179 notsogood = Qnil;
1180
1181 if (NILP (frame))
1182 frame = selected_frame;
1183
1184 tail = Vbuffer_alist;
1185 pred = frame_buffer_predicate (frame);
1186
1187 /* Consider buffers that have been seen in the selected frame
1188 before other buffers. */
1189
1190 tem = frame_buffer_list (frame);
1191 add_ons = Qnil;
1192 while (CONSP (tem))
1193 {
1194 if (BUFFERP (XCAR (tem)))
1195 add_ons = Fcons (Fcons (Qnil, XCAR (tem)), add_ons);
1196 tem = XCDR (tem);
1197 }
1198 tail = nconc2 (Fnreverse (add_ons), tail);
1199
1200 for (; CONSP (tail); tail = XCDR (tail))
1201 {
1202 buf = Fcdr (XCAR (tail));
1203 if (EQ (buf, buffer))
1204 continue;
1205 if (SREF (XBUFFER (buf)->name, 0) == ' ')
1206 continue;
1207 /* If the selected frame has a buffer_predicate,
1208 disregard buffers that don't fit the predicate. */
1209 if (!NILP (pred))
1210 {
1211 tem = call1 (pred, buf);
1212 if (NILP (tem))
1213 continue;
1214 }
1215
1216 if (NILP (visible_ok))
1217 tem = Fget_buffer_window (buf, Qvisible);
1218 else
1219 tem = Qnil;
1220 if (NILP (tem))
1221 return buf;
1222 if (NILP (notsogood))
1223 notsogood = buf;
1224 }
1225 if (!NILP (notsogood))
1226 return notsogood;
1227 buf = Fget_buffer (build_string ("*scratch*"));
1228 if (NILP (buf))
1229 {
1230 buf = Fget_buffer_create (build_string ("*scratch*"));
1231 Fset_buffer_major_mode (buf);
1232 }
1233 return buf;
1234 }
1235 \f
1236 DEFUN ("buffer-disable-undo", Fbuffer_disable_undo, Sbuffer_disable_undo,
1237 0, 1, "",
1238 doc: /* Make BUFFER stop keeping undo information.
1239 No argument or nil as argument means do this for the current buffer. */)
1240 (buffer)
1241 register Lisp_Object buffer;
1242 {
1243 Lisp_Object real_buffer;
1244
1245 if (NILP (buffer))
1246 XSETBUFFER (real_buffer, current_buffer);
1247 else
1248 {
1249 real_buffer = Fget_buffer (buffer);
1250 if (NILP (real_buffer))
1251 nsberror (buffer);
1252 }
1253
1254 XBUFFER (real_buffer)->undo_list = Qt;
1255
1256 return Qnil;
1257 }
1258
1259 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo, Sbuffer_enable_undo,
1260 0, 1, "",
1261 doc: /* Start keeping undo information for buffer BUFFER.
1262 No argument or nil as argument means do this for the current buffer. */)
1263 (buffer)
1264 register Lisp_Object buffer;
1265 {
1266 Lisp_Object real_buffer;
1267
1268 if (NILP (buffer))
1269 XSETBUFFER (real_buffer, current_buffer);
1270 else
1271 {
1272 real_buffer = Fget_buffer (buffer);
1273 if (NILP (real_buffer))
1274 nsberror (buffer);
1275 }
1276
1277 if (EQ (XBUFFER (real_buffer)->undo_list, Qt))
1278 XBUFFER (real_buffer)->undo_list = Qnil;
1279
1280 return Qnil;
1281 }
1282
1283 /*
1284 DEFVAR_LISP ("kill-buffer-hook", no_cell, "\
1285 Hook to be run (by `run-hooks', which see) when a buffer is killed.\n\
1286 The buffer being killed will be current while the hook is running.\n\
1287 See `kill-buffer'."
1288 */
1289 DEFUN ("kill-buffer", Fkill_buffer, Skill_buffer, 1, 1, "bKill buffer: ",
1290 doc: /* Kill the buffer BUFFER.
1291 The argument may be a buffer or may be the name of a buffer.
1292 An argument of nil means kill the current buffer.
1293
1294 Value is t if the buffer is actually killed, nil if user says no.
1295
1296 The value of `kill-buffer-hook' (which may be local to that buffer),
1297 if not void, is a list of functions to be called, with no arguments,
1298 before the buffer is actually killed. The buffer to be killed is current
1299 when the hook functions are called.
1300
1301 Any processes that have this buffer as the `process-buffer' are killed
1302 with SIGHUP. */)
1303 (buffer)
1304 Lisp_Object buffer;
1305 {
1306 Lisp_Object buf;
1307 register struct buffer *b;
1308 register Lisp_Object tem;
1309 register struct Lisp_Marker *m;
1310 struct gcpro gcpro1;
1311
1312 if (NILP (buffer))
1313 buf = Fcurrent_buffer ();
1314 else
1315 buf = Fget_buffer (buffer);
1316 if (NILP (buf))
1317 nsberror (buffer);
1318
1319 b = XBUFFER (buf);
1320
1321 /* Avoid trouble for buffer already dead. */
1322 if (NILP (b->name))
1323 return Qnil;
1324
1325 /* Query if the buffer is still modified. */
1326 if (INTERACTIVE && !NILP (b->filename)
1327 && BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
1328 {
1329 GCPRO1 (buf);
1330 tem = do_yes_or_no_p (format2 ("Buffer %s modified; kill anyway? ",
1331 b->name, make_number (0)));
1332 UNGCPRO;
1333 if (NILP (tem))
1334 return Qnil;
1335 }
1336
1337 /* Run hooks with the buffer to be killed the current buffer. */
1338 {
1339 int count = SPECPDL_INDEX ();
1340 Lisp_Object arglist[1];
1341
1342 record_unwind_protect (save_excursion_restore, save_excursion_save ());
1343 set_buffer_internal (b);
1344
1345 /* First run the query functions; if any query is answered no,
1346 don't kill the buffer. */
1347 arglist[0] = Qkill_buffer_query_functions;
1348 if (NILP (Frun_hook_with_args_until_failure (1, arglist)))
1349 return unbind_to (count, Qnil);
1350
1351 /* Then run the hooks. */
1352 Frun_hooks (1, &Qkill_buffer_hook);
1353 unbind_to (count, Qnil);
1354 }
1355
1356 /* We have no more questions to ask. Verify that it is valid
1357 to kill the buffer. This must be done after the questions
1358 since anything can happen within do_yes_or_no_p. */
1359
1360 /* Don't kill the minibuffer now current. */
1361 if (EQ (buf, XWINDOW (minibuf_window)->buffer))
1362 return Qnil;
1363
1364 if (NILP (b->name))
1365 return Qnil;
1366
1367 /* When we kill a base buffer, kill all its indirect buffers.
1368 We do it at this stage so nothing terrible happens if they
1369 ask questions or their hooks get errors. */
1370 if (! b->base_buffer)
1371 {
1372 struct buffer *other;
1373
1374 GCPRO1 (buf);
1375
1376 for (other = all_buffers; other; other = other->next)
1377 /* all_buffers contains dead buffers too;
1378 don't re-kill them. */
1379 if (other->base_buffer == b && !NILP (other->name))
1380 {
1381 Lisp_Object buf;
1382 XSETBUFFER (buf, other);
1383 Fkill_buffer (buf);
1384 }
1385
1386 UNGCPRO;
1387 }
1388
1389 /* Make this buffer not be current.
1390 In the process, notice if this is the sole visible buffer
1391 and give up if so. */
1392 if (b == current_buffer)
1393 {
1394 tem = Fother_buffer (buf, Qnil, Qnil);
1395 Fset_buffer (tem);
1396 if (b == current_buffer)
1397 return Qnil;
1398 }
1399
1400 /* Notice if the buffer to kill is the sole visible buffer
1401 when we're currently in the mini-buffer, and give up if so. */
1402 XSETBUFFER (tem, current_buffer);
1403 if (EQ (tem, XWINDOW (minibuf_window)->buffer))
1404 {
1405 tem = Fother_buffer (buf, Qnil, Qnil);
1406 if (EQ (buf, tem))
1407 return Qnil;
1408 }
1409
1410 /* Now there is no question: we can kill the buffer. */
1411
1412 #ifdef CLASH_DETECTION
1413 /* Unlock this buffer's file, if it is locked. */
1414 unlock_buffer (b);
1415 #endif /* CLASH_DETECTION */
1416
1417 kill_buffer_processes (buf);
1418 clear_charpos_cache (b);
1419
1420 tem = Vinhibit_quit;
1421 Vinhibit_quit = Qt;
1422 replace_buffer_in_all_windows (buf);
1423 Vbuffer_alist = Fdelq (Frassq (buf, Vbuffer_alist), Vbuffer_alist);
1424 frames_discard_buffer (buf);
1425 Vinhibit_quit = tem;
1426
1427 /* Delete any auto-save file, if we saved it in this session.
1428 But not if the buffer is modified. */
1429 if (STRINGP (b->auto_save_file_name)
1430 && b->auto_save_modified != 0
1431 && BUF_SAVE_MODIFF (b) < b->auto_save_modified
1432 && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
1433 {
1434 Lisp_Object tem;
1435 tem = Fsymbol_value (intern ("delete-auto-save-files"));
1436 if (! NILP (tem))
1437 internal_delete_file (b->auto_save_file_name);
1438 }
1439
1440 if (b->base_buffer)
1441 {
1442 /* Unchain all markers that belong to this indirect buffer.
1443 Don't unchain the markers that belong to the base buffer
1444 or its other indirect buffers. */
1445 for (m = BUF_MARKERS (b); m; )
1446 {
1447 struct Lisp_Marker *next = m->next;
1448 if (m->buffer == b)
1449 unchain_marker (m);
1450 m = next;
1451 }
1452 }
1453 else
1454 {
1455 /* Unchain all markers of this buffer and its indirect buffers.
1456 and leave them pointing nowhere. */
1457 for (m = BUF_MARKERS (b); m; )
1458 {
1459 struct Lisp_Marker *next = m->next;
1460 m->buffer = 0;
1461 m->next = NULL;
1462 m = next;
1463 }
1464 BUF_MARKERS (b) = NULL;
1465 BUF_INTERVALS (b) = NULL_INTERVAL;
1466
1467 /* Perhaps we should explicitly free the interval tree here... */
1468 }
1469
1470 /* Reset the local variables, so that this buffer's local values
1471 won't be protected from GC. They would be protected
1472 if they happened to remain encached in their symbols.
1473 This gets rid of them for certain. */
1474 swap_out_buffer_local_variables (b);
1475 reset_buffer_local_variables (b, 1);
1476
1477 b->name = Qnil;
1478
1479 BLOCK_INPUT;
1480 if (! b->base_buffer)
1481 free_buffer_text (b);
1482
1483 if (b->newline_cache)
1484 {
1485 free_region_cache (b->newline_cache);
1486 b->newline_cache = 0;
1487 }
1488 if (b->width_run_cache)
1489 {
1490 free_region_cache (b->width_run_cache);
1491 b->width_run_cache = 0;
1492 }
1493 b->width_table = Qnil;
1494 UNBLOCK_INPUT;
1495 b->undo_list = Qnil;
1496
1497 return Qt;
1498 }
1499 \f
1500 /* Move the assoc for buffer BUF to the front of buffer-alist. Since
1501 we do this each time BUF is selected visibly, the more recently
1502 selected buffers are always closer to the front of the list. This
1503 means that other_buffer is more likely to choose a relevant buffer. */
1504
1505 void
1506 record_buffer (buf)
1507 Lisp_Object buf;
1508 {
1509 register Lisp_Object link, prev;
1510 Lisp_Object frame;
1511 frame = selected_frame;
1512
1513 prev = Qnil;
1514 for (link = Vbuffer_alist; CONSP (link); link = XCDR (link))
1515 {
1516 if (EQ (XCDR (XCAR (link)), buf))
1517 break;
1518 prev = link;
1519 }
1520
1521 /* Effectively do Vbuffer_alist = Fdelq (link, Vbuffer_alist);
1522 we cannot use Fdelq itself here because it allows quitting. */
1523
1524 if (NILP (prev))
1525 Vbuffer_alist = XCDR (Vbuffer_alist);
1526 else
1527 XSETCDR (prev, XCDR (XCDR (prev)));
1528
1529 XSETCDR (link, Vbuffer_alist);
1530 Vbuffer_alist = link;
1531
1532 /* Now move this buffer to the front of frame_buffer_list also. */
1533
1534 prev = Qnil;
1535 for (link = frame_buffer_list (frame); CONSP (link);
1536 link = XCDR (link))
1537 {
1538 if (EQ (XCAR (link), buf))
1539 break;
1540 prev = link;
1541 }
1542
1543 /* Effectively do delq. */
1544
1545 if (CONSP (link))
1546 {
1547 if (NILP (prev))
1548 set_frame_buffer_list (frame,
1549 XCDR (frame_buffer_list (frame)));
1550 else
1551 XSETCDR (prev, XCDR (XCDR (prev)));
1552
1553 XSETCDR (link, frame_buffer_list (frame));
1554 set_frame_buffer_list (frame, link);
1555 }
1556 else
1557 set_frame_buffer_list (frame, Fcons (buf, frame_buffer_list (frame)));
1558 }
1559
1560 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode, Sset_buffer_major_mode, 1, 1, 0,
1561 doc: /* Set an appropriate major mode for BUFFER.
1562 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
1563 according to `default-major-mode'.
1564 Use this function before selecting the buffer, since it may need to inspect
1565 the current buffer's major mode. */)
1566 (buffer)
1567 Lisp_Object buffer;
1568 {
1569 int count;
1570 Lisp_Object function;
1571
1572 if (STRINGP (XBUFFER (buffer)->name)
1573 && strcmp (SDATA (XBUFFER (buffer)->name), "*scratch*") == 0)
1574 function = find_symbol_value (intern ("initial-major-mode"));
1575 else
1576 {
1577 function = buffer_defaults.major_mode;
1578 if (NILP (function)
1579 && NILP (Fget (current_buffer->major_mode, Qmode_class)))
1580 function = current_buffer->major_mode;
1581 }
1582
1583 if (NILP (function) || EQ (function, Qfundamental_mode))
1584 return Qnil;
1585
1586 count = SPECPDL_INDEX ();
1587
1588 /* To select a nonfundamental mode,
1589 select the buffer temporarily and then call the mode function. */
1590
1591 record_unwind_protect (save_excursion_restore, save_excursion_save ());
1592
1593 Fset_buffer (buffer);
1594 call0 (function);
1595
1596 return unbind_to (count, Qnil);
1597 }
1598
1599 /* If switching buffers in WINDOW would be an error, return
1600 a C string saying what the error would be. */
1601
1602 char *
1603 no_switch_window (window)
1604 Lisp_Object window;
1605 {
1606 Lisp_Object tem;
1607 if (EQ (minibuf_window, window))
1608 return "Cannot switch buffers in minibuffer window";
1609 tem = Fwindow_dedicated_p (window);
1610 if (EQ (tem, Qt))
1611 return "Cannot switch buffers in a dedicated window";
1612 return NULL;
1613 }
1614
1615 /* Switch to buffer BUFFER in the selected window.
1616 If NORECORD is non-nil, don't call record_buffer. */
1617
1618 Lisp_Object
1619 switch_to_buffer_1 (buffer, norecord)
1620 Lisp_Object buffer, norecord;
1621 {
1622 register Lisp_Object buf;
1623
1624 if (NILP (buffer))
1625 buf = Fother_buffer (Fcurrent_buffer (), Qnil, Qnil);
1626 else
1627 {
1628 buf = Fget_buffer (buffer);
1629 if (NILP (buf))
1630 {
1631 buf = Fget_buffer_create (buffer);
1632 Fset_buffer_major_mode (buf);
1633 }
1634 }
1635 Fset_buffer (buf);
1636 if (NILP (norecord))
1637 record_buffer (buf);
1638
1639 Fset_window_buffer (EQ (selected_window, minibuf_window)
1640 ? Fnext_window (minibuf_window, Qnil, Qnil)
1641 : selected_window,
1642 buf, Qnil);
1643
1644 return buf;
1645 }
1646
1647 DEFUN ("switch-to-buffer", Fswitch_to_buffer, Sswitch_to_buffer, 1, 2, "BSwitch to buffer: ",
1648 doc: /* Select buffer BUFFER in the current window.
1649 BUFFER may be a buffer or a buffer name.
1650 Optional second arg NORECORD non-nil means
1651 do not put this buffer at the front of the list of recently selected ones.
1652
1653 WARNING: This is NOT the way to work on another buffer temporarily
1654 within a Lisp program! Use `set-buffer' instead. That avoids messing with
1655 the window-buffer correspondences. */)
1656 (buffer, norecord)
1657 Lisp_Object buffer, norecord;
1658 {
1659 char *err;
1660
1661 if (EQ (buffer, Fwindow_buffer (selected_window)))
1662 /* Basically a NOP. Avoid signalling an error if the selected window
1663 is dedicated, or a minibuffer, ... */
1664 return Fset_buffer (buffer);
1665
1666 err = no_switch_window (selected_window);
1667 if (err) error (err);
1668
1669 return switch_to_buffer_1 (buffer, norecord);
1670 }
1671
1672 DEFUN ("pop-to-buffer", Fpop_to_buffer, Spop_to_buffer, 1, 3, 0,
1673 doc: /* Select buffer BUFFER in some window, preferably a different one.
1674 If BUFFER is nil, then some other buffer is chosen.
1675 If `pop-up-windows' is non-nil, windows can be split to do this.
1676 If optional second arg OTHER-WINDOW is non-nil, insist on finding another
1677 window even if BUFFER is already visible in the selected window.
1678 This uses the function `display-buffer' as a subroutine; see the documentation
1679 of `display-buffer' for additional customization information.
1680
1681 Optional third arg NORECORD non-nil means
1682 do not put this buffer at the front of the list of recently selected ones. */)
1683 (buffer, other_window, norecord)
1684 Lisp_Object buffer, other_window, norecord;
1685 {
1686 register Lisp_Object buf;
1687 if (NILP (buffer))
1688 buf = Fother_buffer (Fcurrent_buffer (), Qnil, Qnil);
1689 else
1690 {
1691 buf = Fget_buffer (buffer);
1692 if (NILP (buf))
1693 {
1694 buf = Fget_buffer_create (buffer);
1695 Fset_buffer_major_mode (buf);
1696 }
1697 }
1698 Fset_buffer (buf);
1699 if (NILP (norecord))
1700 /* Why bother ? Fselect_window will do it for us anyway. -stef */
1701 record_buffer (buf);
1702 Fselect_window (Fdisplay_buffer (buf, other_window, Qnil), norecord);
1703 return buf;
1704 }
1705
1706 DEFUN ("current-buffer", Fcurrent_buffer, Scurrent_buffer, 0, 0, 0,
1707 doc: /* Return the current buffer as a Lisp object. */)
1708 ()
1709 {
1710 register Lisp_Object buf;
1711 XSETBUFFER (buf, current_buffer);
1712 return buf;
1713 }
1714 \f
1715 /* Set the current buffer to B.
1716
1717 We previously set windows_or_buffers_changed here to invalidate
1718 global unchanged information in beg_unchanged and end_unchanged.
1719 This is no longer necessary because we now compute unchanged
1720 information on a buffer-basis. Every action affecting other
1721 windows than the selected one requires a select_window at some
1722 time, and that increments windows_or_buffers_changed. */
1723
1724 void
1725 set_buffer_internal (b)
1726 register struct buffer *b;
1727 {
1728 if (current_buffer != b)
1729 set_buffer_internal_1 (b);
1730 }
1731
1732 /* Set the current buffer to B, and do not set windows_or_buffers_changed.
1733 This is used by redisplay. */
1734
1735 void
1736 set_buffer_internal_1 (b)
1737 register struct buffer *b;
1738 {
1739 register struct buffer *old_buf;
1740 register Lisp_Object tail, valcontents;
1741 Lisp_Object tem;
1742
1743 #ifdef USE_MMAP_FOR_BUFFERS
1744 if (b->text->beg == NULL)
1745 enlarge_buffer_text (b, 0);
1746 #endif /* USE_MMAP_FOR_BUFFERS */
1747
1748 if (current_buffer == b)
1749 return;
1750
1751 old_buf = current_buffer;
1752 current_buffer = b;
1753 last_known_column_point = -1; /* invalidate indentation cache */
1754
1755 if (old_buf)
1756 {
1757 /* Put the undo list back in the base buffer, so that it appears
1758 that an indirect buffer shares the undo list of its base. */
1759 if (old_buf->base_buffer)
1760 old_buf->base_buffer->undo_list = old_buf->undo_list;
1761
1762 /* If the old current buffer has markers to record PT, BEGV and ZV
1763 when it is not current, update them now. */
1764 if (! NILP (old_buf->pt_marker))
1765 {
1766 Lisp_Object obuf;
1767 XSETBUFFER (obuf, old_buf);
1768 set_marker_both (old_buf->pt_marker, obuf,
1769 BUF_PT (old_buf), BUF_PT_BYTE (old_buf));
1770 }
1771 if (! NILP (old_buf->begv_marker))
1772 {
1773 Lisp_Object obuf;
1774 XSETBUFFER (obuf, old_buf);
1775 set_marker_both (old_buf->begv_marker, obuf,
1776 BUF_BEGV (old_buf), BUF_BEGV_BYTE (old_buf));
1777 }
1778 if (! NILP (old_buf->zv_marker))
1779 {
1780 Lisp_Object obuf;
1781 XSETBUFFER (obuf, old_buf);
1782 set_marker_both (old_buf->zv_marker, obuf,
1783 BUF_ZV (old_buf), BUF_ZV_BYTE (old_buf));
1784 }
1785 }
1786
1787 /* Get the undo list from the base buffer, so that it appears
1788 that an indirect buffer shares the undo list of its base. */
1789 if (b->base_buffer)
1790 b->undo_list = b->base_buffer->undo_list;
1791
1792 /* If the new current buffer has markers to record PT, BEGV and ZV
1793 when it is not current, fetch them now. */
1794 if (! NILP (b->pt_marker))
1795 {
1796 BUF_PT (b) = marker_position (b->pt_marker);
1797 BUF_PT_BYTE (b) = marker_byte_position (b->pt_marker);
1798 }
1799 if (! NILP (b->begv_marker))
1800 {
1801 BUF_BEGV (b) = marker_position (b->begv_marker);
1802 BUF_BEGV_BYTE (b) = marker_byte_position (b->begv_marker);
1803 }
1804 if (! NILP (b->zv_marker))
1805 {
1806 BUF_ZV (b) = marker_position (b->zv_marker);
1807 BUF_ZV_BYTE (b) = marker_byte_position (b->zv_marker);
1808 }
1809
1810 /* Look down buffer's list of local Lisp variables
1811 to find and update any that forward into C variables. */
1812
1813 for (tail = b->local_var_alist; CONSP (tail); tail = XCDR (tail))
1814 {
1815 valcontents = SYMBOL_VALUE (XCAR (XCAR (tail)));
1816 if ((BUFFER_LOCAL_VALUEP (valcontents)
1817 || SOME_BUFFER_LOCAL_VALUEP (valcontents))
1818 && (tem = XBUFFER_LOCAL_VALUE (valcontents)->realvalue,
1819 (BOOLFWDP (tem) || INTFWDP (tem) || OBJFWDP (tem))))
1820 /* Just reference the variable
1821 to cause it to become set for this buffer. */
1822 Fsymbol_value (XCAR (XCAR (tail)));
1823 }
1824
1825 /* Do the same with any others that were local to the previous buffer */
1826
1827 if (old_buf)
1828 for (tail = old_buf->local_var_alist; CONSP (tail); tail = XCDR (tail))
1829 {
1830 valcontents = SYMBOL_VALUE (XCAR (XCAR (tail)));
1831 if ((BUFFER_LOCAL_VALUEP (valcontents)
1832 || SOME_BUFFER_LOCAL_VALUEP (valcontents))
1833 && (tem = XBUFFER_LOCAL_VALUE (valcontents)->realvalue,
1834 (BOOLFWDP (tem) || INTFWDP (tem) || OBJFWDP (tem))))
1835 /* Just reference the variable
1836 to cause it to become set for this buffer. */
1837 Fsymbol_value (XCAR (XCAR (tail)));
1838 }
1839 }
1840
1841 /* Switch to buffer B temporarily for redisplay purposes.
1842 This avoids certain things that don't need to be done within redisplay. */
1843
1844 void
1845 set_buffer_temp (b)
1846 struct buffer *b;
1847 {
1848 register struct buffer *old_buf;
1849
1850 if (current_buffer == b)
1851 return;
1852
1853 old_buf = current_buffer;
1854 current_buffer = b;
1855
1856 if (old_buf)
1857 {
1858 /* If the old current buffer has markers to record PT, BEGV and ZV
1859 when it is not current, update them now. */
1860 if (! NILP (old_buf->pt_marker))
1861 {
1862 Lisp_Object obuf;
1863 XSETBUFFER (obuf, old_buf);
1864 set_marker_both (old_buf->pt_marker, obuf,
1865 BUF_PT (old_buf), BUF_PT_BYTE (old_buf));
1866 }
1867 if (! NILP (old_buf->begv_marker))
1868 {
1869 Lisp_Object obuf;
1870 XSETBUFFER (obuf, old_buf);
1871 set_marker_both (old_buf->begv_marker, obuf,
1872 BUF_BEGV (old_buf), BUF_BEGV_BYTE (old_buf));
1873 }
1874 if (! NILP (old_buf->zv_marker))
1875 {
1876 Lisp_Object obuf;
1877 XSETBUFFER (obuf, old_buf);
1878 set_marker_both (old_buf->zv_marker, obuf,
1879 BUF_ZV (old_buf), BUF_ZV_BYTE (old_buf));
1880 }
1881 }
1882
1883 /* If the new current buffer has markers to record PT, BEGV and ZV
1884 when it is not current, fetch them now. */
1885 if (! NILP (b->pt_marker))
1886 {
1887 BUF_PT (b) = marker_position (b->pt_marker);
1888 BUF_PT_BYTE (b) = marker_byte_position (b->pt_marker);
1889 }
1890 if (! NILP (b->begv_marker))
1891 {
1892 BUF_BEGV (b) = marker_position (b->begv_marker);
1893 BUF_BEGV_BYTE (b) = marker_byte_position (b->begv_marker);
1894 }
1895 if (! NILP (b->zv_marker))
1896 {
1897 BUF_ZV (b) = marker_position (b->zv_marker);
1898 BUF_ZV_BYTE (b) = marker_byte_position (b->zv_marker);
1899 }
1900 }
1901
1902 DEFUN ("set-buffer", Fset_buffer, Sset_buffer, 1, 1, 0,
1903 doc: /* Make the buffer BUFFER current for editing operations.
1904 BUFFER may be a buffer or the name of an existing buffer.
1905 See also `save-excursion' when you want to make a buffer current temporarily.
1906 This function does not display the buffer, so its effect ends
1907 when the current command terminates.
1908 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently. */)
1909 (buffer)
1910 register Lisp_Object buffer;
1911 {
1912 register Lisp_Object buf;
1913 buf = Fget_buffer (buffer);
1914 if (NILP (buf))
1915 nsberror (buffer);
1916 if (NILP (XBUFFER (buf)->name))
1917 error ("Selecting deleted buffer");
1918 set_buffer_internal (XBUFFER (buf));
1919 return buf;
1920 }
1921
1922 /* Set the current buffer to BUFFER provided it is alive. */
1923
1924 Lisp_Object
1925 set_buffer_if_live (buffer)
1926 Lisp_Object buffer;
1927 {
1928 if (! NILP (XBUFFER (buffer)->name))
1929 Fset_buffer (buffer);
1930 return Qnil;
1931 }
1932 \f
1933 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only,
1934 Sbarf_if_buffer_read_only, 0, 0, 0,
1935 doc: /* Signal a `buffer-read-only' error if the current buffer is read-only. */)
1936 ()
1937 {
1938 if (!NILP (current_buffer->read_only)
1939 && NILP (Vinhibit_read_only))
1940 Fsignal (Qbuffer_read_only, (Fcons (Fcurrent_buffer (), Qnil)));
1941 return Qnil;
1942 }
1943
1944 DEFUN ("bury-buffer", Fbury_buffer, Sbury_buffer, 0, 1, "",
1945 doc: /* Put BUFFER at the end of the list of all buffers.
1946 There it is the least likely candidate for `other-buffer' to return;
1947 thus, the least likely buffer for \\[switch-to-buffer] to select by default.
1948 If BUFFER is nil or omitted, bury the current buffer.
1949 Also, if BUFFER is nil or omitted, remove the current buffer from the
1950 selected window if it is displayed there. */)
1951 (buffer)
1952 register Lisp_Object buffer;
1953 {
1954 /* Figure out what buffer we're going to bury. */
1955 if (NILP (buffer))
1956 {
1957 Lisp_Object tem;
1958 XSETBUFFER (buffer, current_buffer);
1959
1960 tem = Fwindow_buffer (selected_window);
1961 /* If we're burying the current buffer, unshow it. */
1962 if (EQ (buffer, tem))
1963 {
1964 if (NILP (Fwindow_dedicated_p (selected_window)))
1965 Fswitch_to_buffer (Fother_buffer (buffer, Qnil, Qnil), Qnil);
1966 else if (NILP (XWINDOW (selected_window)->parent))
1967 Ficonify_frame (Fwindow_frame (selected_window));
1968 else
1969 Fdelete_window (selected_window);
1970 }
1971 }
1972 else
1973 {
1974 Lisp_Object buf1;
1975
1976 buf1 = Fget_buffer (buffer);
1977 if (NILP (buf1))
1978 nsberror (buffer);
1979 buffer = buf1;
1980 }
1981
1982 /* Move buffer to the end of the buffer list. Do nothing if the
1983 buffer is killed. */
1984 if (!NILP (XBUFFER (buffer)->name))
1985 {
1986 Lisp_Object aelt, link;
1987
1988 aelt = Frassq (buffer, Vbuffer_alist);
1989 link = Fmemq (aelt, Vbuffer_alist);
1990 Vbuffer_alist = Fdelq (aelt, Vbuffer_alist);
1991 XSETCDR (link, Qnil);
1992 Vbuffer_alist = nconc2 (Vbuffer_alist, link);
1993
1994 /* Removing BUFFER from frame-specific lists
1995 has the effect of putting BUFFER at the end
1996 of the combined list in each frame. */
1997 frames_discard_buffer (buffer);
1998 }
1999
2000 return Qnil;
2001 }
2002 \f
2003 DEFUN ("erase-buffer", Ferase_buffer, Serase_buffer, 0, 0, "*",
2004 doc: /* Delete the entire contents of the current buffer.
2005 Any narrowing restriction in effect (see `narrow-to-region') is removed,
2006 so the buffer is truly empty after this. */)
2007 ()
2008 {
2009 Fwiden ();
2010
2011 del_range (BEG, Z);
2012
2013 current_buffer->last_window_start = 1;
2014 /* Prevent warnings, or suspension of auto saving, that would happen
2015 if future size is less than past size. Use of erase-buffer
2016 implies that the future text is not really related to the past text. */
2017 XSETFASTINT (current_buffer->save_length, 0);
2018 return Qnil;
2019 }
2020
2021 void
2022 validate_region (b, e)
2023 register Lisp_Object *b, *e;
2024 {
2025 CHECK_NUMBER_COERCE_MARKER (*b);
2026 CHECK_NUMBER_COERCE_MARKER (*e);
2027
2028 if (XINT (*b) > XINT (*e))
2029 {
2030 Lisp_Object tem;
2031 tem = *b; *b = *e; *e = tem;
2032 }
2033
2034 if (!(BEGV <= XINT (*b) && XINT (*b) <= XINT (*e)
2035 && XINT (*e) <= ZV))
2036 args_out_of_range (*b, *e);
2037 }
2038 \f
2039 /* Advance BYTE_POS up to a character boundary
2040 and return the adjusted position. */
2041
2042 static int
2043 advance_to_char_boundary (byte_pos)
2044 int byte_pos;
2045 {
2046 int c;
2047
2048 if (byte_pos == BEG)
2049 /* Beginning of buffer is always a character boundary. */
2050 return BEG;
2051
2052 c = FETCH_BYTE (byte_pos);
2053 if (! CHAR_HEAD_P (c))
2054 {
2055 /* We should advance BYTE_POS only when C is a constituent of a
2056 multibyte sequence. */
2057 int orig_byte_pos = byte_pos;
2058
2059 do
2060 {
2061 byte_pos--;
2062 c = FETCH_BYTE (byte_pos);
2063 }
2064 while (! CHAR_HEAD_P (c) && byte_pos > BEG);
2065 INC_POS (byte_pos);
2066 if (byte_pos < orig_byte_pos)
2067 byte_pos = orig_byte_pos;
2068 /* If C is a constituent of a multibyte sequence, BYTE_POS was
2069 surely advance to the correct character boundary. If C is
2070 not, BYTE_POS was unchanged. */
2071 }
2072
2073 return byte_pos;
2074 }
2075
2076 DEFUN ("set-buffer-multibyte", Fset_buffer_multibyte, Sset_buffer_multibyte,
2077 1, 1, 0,
2078 doc: /* Set the multibyte flag of the current buffer to FLAG.
2079 If FLAG is t, this makes the buffer a multibyte buffer.
2080 If FLAG is nil, this makes the buffer a single-byte buffer.
2081 The buffer contents remain unchanged as a sequence of bytes
2082 but the contents viewed as characters do change. */)
2083 (flag)
2084 Lisp_Object flag;
2085 {
2086 struct Lisp_Marker *tail, *markers;
2087 struct buffer *other;
2088 int undo_enabled_p = !EQ (current_buffer->undo_list, Qt);
2089 int begv, zv;
2090 int narrowed = (BEG != BEGV || Z != ZV);
2091 int modified_p = !NILP (Fbuffer_modified_p (Qnil));
2092
2093 if (current_buffer->base_buffer)
2094 error ("Cannot do `set-buffer-multibyte' on an indirect buffer");
2095
2096 /* Do nothing if nothing actually changes. */
2097 if (NILP (flag) == NILP (current_buffer->enable_multibyte_characters))
2098 return flag;
2099
2100 /* It would be better to update the list,
2101 but this is good enough for now. */
2102 if (undo_enabled_p)
2103 current_buffer->undo_list = Qt;
2104
2105 /* If the cached position is for this buffer, clear it out. */
2106 clear_charpos_cache (current_buffer);
2107
2108 if (NILP (flag))
2109 begv = BEGV_BYTE, zv = ZV_BYTE;
2110 else
2111 begv = BEGV, zv = ZV;
2112
2113 if (narrowed)
2114 Fwiden ();
2115
2116 if (NILP (flag))
2117 {
2118 int pos, stop;
2119 unsigned char *p;
2120
2121 /* Do this first, so it can use CHAR_TO_BYTE
2122 to calculate the old correspondences. */
2123 set_intervals_multibyte (0);
2124
2125 current_buffer->enable_multibyte_characters = Qnil;
2126
2127 Z = Z_BYTE;
2128 BEGV = BEGV_BYTE;
2129 ZV = ZV_BYTE;
2130 GPT = GPT_BYTE;
2131 TEMP_SET_PT_BOTH (PT_BYTE, PT_BYTE);
2132
2133
2134 for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
2135 tail->charpos = tail->bytepos;
2136
2137 /* Convert multibyte form of 8-bit characters to unibyte. */
2138 pos = BEG;
2139 stop = GPT;
2140 p = BEG_ADDR;
2141 while (1)
2142 {
2143 int c, bytes;
2144
2145 if (pos == stop)
2146 {
2147 if (pos == Z)
2148 break;
2149 p = GAP_END_ADDR;
2150 stop = Z;
2151 }
2152 if (MULTIBYTE_STR_AS_UNIBYTE_P (p, bytes))
2153 p += bytes, pos += bytes;
2154 else
2155 {
2156 c = STRING_CHAR (p, stop - pos);
2157 /* Delete all bytes for this 8-bit character but the
2158 last one, and change the last one to the charcter
2159 code. */
2160 bytes--;
2161 del_range_2 (pos, pos, pos + bytes, pos + bytes, 0);
2162 p = GAP_END_ADDR;
2163 *p++ = c;
2164 pos++;
2165 if (begv > pos)
2166 begv -= bytes;
2167 if (zv > pos)
2168 zv -= bytes;
2169 stop = Z;
2170 }
2171 }
2172 if (narrowed)
2173 Fnarrow_to_region (make_number (begv), make_number (zv));
2174 }
2175 else
2176 {
2177 int pt = PT;
2178 int pos, stop;
2179 unsigned char *p;
2180
2181 /* Be sure not to have a multibyte sequence striding over the GAP.
2182 Ex: We change this: "...abc\201 _GAP_ \241def..."
2183 to: "...abc _GAP_ \201\241def..." */
2184
2185 if (GPT_BYTE > 1 && GPT_BYTE < Z_BYTE
2186 && ! CHAR_HEAD_P (*(GAP_END_ADDR)))
2187 {
2188 unsigned char *p = GPT_ADDR - 1;
2189
2190 while (! CHAR_HEAD_P (*p) && p > BEG_ADDR) p--;
2191 if (BASE_LEADING_CODE_P (*p))
2192 {
2193 int new_gpt = GPT_BYTE - (GPT_ADDR - p);
2194
2195 move_gap_both (new_gpt, new_gpt);
2196 }
2197 }
2198
2199 /* Make the buffer contents valid as multibyte by converting
2200 8-bit characters to multibyte form. */
2201 pos = BEG;
2202 stop = GPT;
2203 p = BEG_ADDR;
2204 while (1)
2205 {
2206 int bytes;
2207
2208 if (pos == stop)
2209 {
2210 if (pos == Z)
2211 break;
2212 p = GAP_END_ADDR;
2213 stop = Z;
2214 }
2215
2216 if (UNIBYTE_STR_AS_MULTIBYTE_P (p, stop - pos, bytes))
2217 p += bytes, pos += bytes;
2218 else
2219 {
2220 unsigned char tmp[MAX_MULTIBYTE_LENGTH];
2221
2222 bytes = CHAR_STRING (*p, tmp);
2223 *p = tmp[0];
2224 TEMP_SET_PT_BOTH (pos + 1, pos + 1);
2225 bytes--;
2226 insert_1_both (tmp + 1, bytes, bytes, 1, 0, 0);
2227 /* Now the gap is after the just inserted data. */
2228 pos = GPT;
2229 p = GAP_END_ADDR;
2230 if (pos <= begv)
2231 begv += bytes;
2232 if (pos <= zv)
2233 zv += bytes;
2234 if (pos <= pt)
2235 pt += bytes;
2236 stop = Z;
2237 }
2238 }
2239
2240 if (pt != PT)
2241 TEMP_SET_PT (pt);
2242
2243 if (narrowed)
2244 Fnarrow_to_region (make_number (begv), make_number (zv));
2245
2246 /* Do this first, so that chars_in_text asks the right question.
2247 set_intervals_multibyte needs it too. */
2248 current_buffer->enable_multibyte_characters = Qt;
2249
2250 GPT_BYTE = advance_to_char_boundary (GPT_BYTE);
2251 GPT = chars_in_text (BEG_ADDR, GPT_BYTE - BEG_BYTE) + BEG;
2252
2253 Z = chars_in_text (GAP_END_ADDR, Z_BYTE - GPT_BYTE) + GPT;
2254
2255 BEGV_BYTE = advance_to_char_boundary (BEGV_BYTE);
2256 if (BEGV_BYTE > GPT_BYTE)
2257 BEGV = chars_in_text (GAP_END_ADDR, BEGV_BYTE - GPT_BYTE) + GPT;
2258 else
2259 BEGV = chars_in_text (BEG_ADDR, BEGV_BYTE - BEG_BYTE) + BEG;
2260
2261 ZV_BYTE = advance_to_char_boundary (ZV_BYTE);
2262 if (ZV_BYTE > GPT_BYTE)
2263 ZV = chars_in_text (GAP_END_ADDR, ZV_BYTE - GPT_BYTE) + GPT;
2264 else
2265 ZV = chars_in_text (BEG_ADDR, ZV_BYTE - BEG_BYTE) + BEG;
2266
2267 {
2268 int pt_byte = advance_to_char_boundary (PT_BYTE);
2269 int pt;
2270
2271 if (pt_byte > GPT_BYTE)
2272 pt = chars_in_text (GAP_END_ADDR, pt_byte - GPT_BYTE) + GPT;
2273 else
2274 pt = chars_in_text (BEG_ADDR, pt_byte - BEG_BYTE) + BEG;
2275 TEMP_SET_PT_BOTH (pt, pt_byte);
2276 }
2277
2278 tail = markers = BUF_MARKERS (current_buffer);
2279
2280 /* This prevents BYTE_TO_CHAR (that is, buf_bytepos_to_charpos) from
2281 getting confused by the markers that have not yet been updated.
2282 It is also a signal that it should never create a marker. */
2283 BUF_MARKERS (current_buffer) = NULL;
2284
2285 for (; tail; tail = tail->next)
2286 {
2287 tail->bytepos = advance_to_char_boundary (tail->bytepos);
2288 tail->charpos = BYTE_TO_CHAR (tail->bytepos);
2289 }
2290
2291 /* Make sure no markers were put on the chain
2292 while the chain value was incorrect. */
2293 if (BUF_MARKERS (current_buffer))
2294 abort ();
2295
2296 BUF_MARKERS (current_buffer) = markers;
2297
2298 /* Do this last, so it can calculate the new correspondences
2299 between chars and bytes. */
2300 set_intervals_multibyte (1);
2301 }
2302
2303 if (undo_enabled_p)
2304 current_buffer->undo_list = Qnil;
2305
2306 /* Changing the multibyteness of a buffer means that all windows
2307 showing that buffer must be updated thoroughly. */
2308 current_buffer->prevent_redisplay_optimizations_p = 1;
2309 ++windows_or_buffers_changed;
2310
2311 /* Copy this buffer's new multibyte status
2312 into all of its indirect buffers. */
2313 for (other = all_buffers; other; other = other->next)
2314 if (other->base_buffer == current_buffer && !NILP (other->name))
2315 {
2316 other->enable_multibyte_characters
2317 = current_buffer->enable_multibyte_characters;
2318 other->prevent_redisplay_optimizations_p = 1;
2319 }
2320
2321 /* Restore the modifiedness of the buffer. */
2322 if (!modified_p && !NILP (Fbuffer_modified_p (Qnil)))
2323 Fset_buffer_modified_p (Qnil);
2324
2325 #ifdef subprocesses
2326 /* Update coding systems of this buffer's process (if any). */
2327 {
2328 Lisp_Object process;
2329
2330 process = Fget_buffer_process (Fcurrent_buffer ());
2331 if (PROCESSP (process))
2332 setup_process_coding_systems (process);
2333 }
2334 #endif /* subprocesses */
2335
2336 return flag;
2337 }
2338 \f
2339 DEFUN ("kill-all-local-variables", Fkill_all_local_variables, Skill_all_local_variables,
2340 0, 0, 0,
2341 doc: /* Switch to Fundamental mode by killing current buffer's local variables.
2342 Most local variable bindings are eliminated so that the default values
2343 become effective once more. Also, the syntax table is set from
2344 `standard-syntax-table', the local keymap is set to nil,
2345 and the abbrev table from `fundamental-mode-abbrev-table'.
2346 This function also forces redisplay of the mode line.
2347
2348 Every function to select a new major mode starts by
2349 calling this function.
2350
2351 As a special exception, local variables whose names have
2352 a non-nil `permanent-local' property are not eliminated by this function.
2353
2354 The first thing this function does is run
2355 the normal hook `change-major-mode-hook'. */)
2356 ()
2357 {
2358 register Lisp_Object alist, sym, tem;
2359 Lisp_Object oalist;
2360
2361 if (!NILP (Vrun_hooks))
2362 call1 (Vrun_hooks, intern ("change-major-mode-hook"));
2363 oalist = current_buffer->local_var_alist;
2364
2365 /* Make sure none of the bindings in oalist
2366 remain swapped in, in their symbols. */
2367
2368 swap_out_buffer_local_variables (current_buffer);
2369
2370 /* Actually eliminate all local bindings of this buffer. */
2371
2372 reset_buffer_local_variables (current_buffer, 0);
2373
2374 /* Any which are supposed to be permanent,
2375 make local again, with the same values they had. */
2376
2377 for (alist = oalist; !NILP (alist); alist = XCDR (alist))
2378 {
2379 sym = XCAR (XCAR (alist));
2380 tem = Fget (sym, Qpermanent_local);
2381 if (! NILP (tem))
2382 {
2383 Fmake_local_variable (sym);
2384 Fset (sym, XCDR (XCAR (alist)));
2385 }
2386 }
2387
2388 /* Force mode-line redisplay. Useful here because all major mode
2389 commands call this function. */
2390 update_mode_lines++;
2391
2392 return Qnil;
2393 }
2394
2395 /* Make sure no local variables remain set up with buffer B
2396 for their current values. */
2397
2398 static void
2399 swap_out_buffer_local_variables (b)
2400 struct buffer *b;
2401 {
2402 Lisp_Object oalist, alist, sym, tem, buffer;
2403
2404 XSETBUFFER (buffer, b);
2405 oalist = b->local_var_alist;
2406
2407 for (alist = oalist; !NILP (alist); alist = XCDR (alist))
2408 {
2409 sym = XCAR (XCAR (alist));
2410
2411 /* Need not do anything if some other buffer's binding is now encached. */
2412 tem = XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym))->buffer;
2413 if (BUFFERP (tem) && XBUFFER (tem) == current_buffer)
2414 {
2415 /* Symbol is set up for this buffer's old local value.
2416 Set it up for the current buffer with the default value. */
2417
2418 tem = XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym))->cdr;
2419 /* Store the symbol's current value into the alist entry
2420 it is currently set up for. This is so that, if the
2421 local is marked permanent, and we make it local again
2422 later in Fkill_all_local_variables, we don't lose the value. */
2423 XSETCDR (XCAR (tem),
2424 do_symval_forwarding (XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym))->realvalue));
2425 /* Switch to the symbol's default-value alist entry. */
2426 XSETCAR (tem, tem);
2427 /* Mark it as current for buffer B. */
2428 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym))->buffer = buffer;
2429 /* Store the current value into any forwarding in the symbol. */
2430 store_symval_forwarding (sym,
2431 XBUFFER_LOCAL_VALUE (SYMBOL_VALUE (sym))->realvalue,
2432 XCDR (tem), NULL);
2433 }
2434 }
2435 }
2436 \f
2437 /* Find all the overlays in the current buffer that contain position POS.
2438 Return the number found, and store them in a vector in *VEC_PTR.
2439 Store in *LEN_PTR the size allocated for the vector.
2440 Store in *NEXT_PTR the next position after POS where an overlay starts,
2441 or ZV if there are no more overlays.
2442 Store in *PREV_PTR the previous position before POS where an overlay ends,
2443 or where an overlay starts which ends at or after POS;
2444 or BEGV if there are no such overlays.
2445 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2446
2447 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2448 when this function is called.
2449
2450 If EXTEND is non-zero, we make the vector bigger if necessary.
2451 If EXTEND is zero, we never extend the vector,
2452 and we store only as many overlays as will fit.
2453 But we still return the total number of overlays.
2454
2455 If CHANGE_REQ is true, then any position written into *PREV_PTR or
2456 *NEXT_PTR is guaranteed to be not equal to POS, unless it is the
2457 default (BEGV or ZV). */
2458
2459 int
2460 overlays_at (pos, extend, vec_ptr, len_ptr, next_ptr, prev_ptr, change_req)
2461 EMACS_INT pos;
2462 int extend;
2463 Lisp_Object **vec_ptr;
2464 int *len_ptr;
2465 int *next_ptr;
2466 int *prev_ptr;
2467 int change_req;
2468 {
2469 Lisp_Object overlay, start, end;
2470 struct Lisp_Overlay *tail;
2471 int idx = 0;
2472 int len = *len_ptr;
2473 Lisp_Object *vec = *vec_ptr;
2474 int next = ZV;
2475 int prev = BEGV;
2476 int inhibit_storing = 0;
2477
2478 for (tail = current_buffer->overlays_before; tail; tail = tail->next)
2479 {
2480 int startpos, endpos;
2481
2482 XSETMISC (overlay, tail);
2483
2484 start = OVERLAY_START (overlay);
2485 end = OVERLAY_END (overlay);
2486 endpos = OVERLAY_POSITION (end);
2487 if (endpos < pos)
2488 {
2489 if (prev < endpos)
2490 prev = endpos;
2491 break;
2492 }
2493 startpos = OVERLAY_POSITION (start);
2494 /* This one ends at or after POS
2495 so its start counts for PREV_PTR if it's before POS. */
2496 if (prev < startpos && startpos < pos)
2497 prev = startpos;
2498 if (endpos == pos)
2499 continue;
2500 if (startpos <= pos)
2501 {
2502 if (idx == len)
2503 {
2504 /* The supplied vector is full.
2505 Either make it bigger, or don't store any more in it. */
2506 if (extend)
2507 {
2508 /* Make it work with an initial len == 0. */
2509 len *= 2;
2510 if (len == 0)
2511 len = 4;
2512 *len_ptr = len;
2513 vec = (Lisp_Object *) xrealloc (vec, len * sizeof (Lisp_Object));
2514 *vec_ptr = vec;
2515 }
2516 else
2517 inhibit_storing = 1;
2518 }
2519
2520 if (!inhibit_storing)
2521 vec[idx] = overlay;
2522 /* Keep counting overlays even if we can't return them all. */
2523 idx++;
2524 }
2525 else if (startpos < next)
2526 next = startpos;
2527 }
2528
2529 for (tail = current_buffer->overlays_after; tail; tail = tail->next)
2530 {
2531 int startpos, endpos;
2532
2533 XSETMISC (overlay, tail);
2534
2535 start = OVERLAY_START (overlay);
2536 end = OVERLAY_END (overlay);
2537 startpos = OVERLAY_POSITION (start);
2538 if (pos < startpos)
2539 {
2540 if (startpos < next)
2541 next = startpos;
2542 break;
2543 }
2544 endpos = OVERLAY_POSITION (end);
2545 if (pos < endpos)
2546 {
2547 if (idx == len)
2548 {
2549 if (extend)
2550 {
2551 /* Make it work with an initial len == 0. */
2552 len *= 2;
2553 if (len == 0)
2554 len = 4;
2555 *len_ptr = len;
2556 vec = (Lisp_Object *) xrealloc (vec, len * sizeof (Lisp_Object));
2557 *vec_ptr = vec;
2558 }
2559 else
2560 inhibit_storing = 1;
2561 }
2562
2563 if (!inhibit_storing)
2564 vec[idx] = overlay;
2565 idx++;
2566
2567 if (startpos < pos && startpos > prev)
2568 prev = startpos;
2569 }
2570 else if (endpos < pos && endpos > prev)
2571 prev = endpos;
2572 else if (endpos == pos && startpos > prev
2573 && (!change_req || startpos < pos))
2574 prev = startpos;
2575 }
2576
2577 if (next_ptr)
2578 *next_ptr = next;
2579 if (prev_ptr)
2580 *prev_ptr = prev;
2581 return idx;
2582 }
2583 \f
2584 /* Find all the overlays in the current buffer that overlap the range BEG-END
2585 or are empty at BEG.
2586
2587 Return the number found, and store them in a vector in *VEC_PTR.
2588 Store in *LEN_PTR the size allocated for the vector.
2589 Store in *NEXT_PTR the next position after POS where an overlay starts,
2590 or ZV if there are no more overlays.
2591 Store in *PREV_PTR the previous position before POS where an overlay ends,
2592 or BEGV if there are no previous overlays.
2593 NEXT_PTR and/or PREV_PTR may be 0, meaning don't store that info.
2594
2595 *VEC_PTR and *LEN_PTR should contain a valid vector and size
2596 when this function is called.
2597
2598 If EXTEND is non-zero, we make the vector bigger if necessary.
2599 If EXTEND is zero, we never extend the vector,
2600 and we store only as many overlays as will fit.
2601 But we still return the total number of overlays. */
2602
2603 static int
2604 overlays_in (beg, end, extend, vec_ptr, len_ptr, next_ptr, prev_ptr)
2605 int beg, end;
2606 int extend;
2607 Lisp_Object **vec_ptr;
2608 int *len_ptr;
2609 int *next_ptr;
2610 int *prev_ptr;
2611 {
2612 Lisp_Object overlay, ostart, oend;
2613 struct Lisp_Overlay *tail;
2614 int idx = 0;
2615 int len = *len_ptr;
2616 Lisp_Object *vec = *vec_ptr;
2617 int next = ZV;
2618 int prev = BEGV;
2619 int inhibit_storing = 0;
2620
2621 for (tail = current_buffer->overlays_before; tail; tail = tail->next)
2622 {
2623 int startpos, endpos;
2624
2625 XSETMISC (overlay, tail);
2626
2627 ostart = OVERLAY_START (overlay);
2628 oend = OVERLAY_END (overlay);
2629 endpos = OVERLAY_POSITION (oend);
2630 if (endpos < beg)
2631 {
2632 if (prev < endpos)
2633 prev = endpos;
2634 break;
2635 }
2636 startpos = OVERLAY_POSITION (ostart);
2637 /* Count an interval if it either overlaps the range
2638 or is empty at the start of the range. */
2639 if ((beg < endpos && startpos < end)
2640 || (startpos == endpos && beg == endpos))
2641 {
2642 if (idx == len)
2643 {
2644 /* The supplied vector is full.
2645 Either make it bigger, or don't store any more in it. */
2646 if (extend)
2647 {
2648 /* Make it work with an initial len == 0. */
2649 len *= 2;
2650 if (len == 0)
2651 len = 4;
2652 *len_ptr = len;
2653 vec = (Lisp_Object *) xrealloc (vec, len * sizeof (Lisp_Object));
2654 *vec_ptr = vec;
2655 }
2656 else
2657 inhibit_storing = 1;
2658 }
2659
2660 if (!inhibit_storing)
2661 vec[idx] = overlay;
2662 /* Keep counting overlays even if we can't return them all. */
2663 idx++;
2664 }
2665 else if (startpos < next)
2666 next = startpos;
2667 }
2668
2669 for (tail = current_buffer->overlays_after; tail; tail = tail->next)
2670 {
2671 int startpos, endpos;
2672
2673 XSETMISC (overlay, tail);
2674
2675 ostart = OVERLAY_START (overlay);
2676 oend = OVERLAY_END (overlay);
2677 startpos = OVERLAY_POSITION (ostart);
2678 if (end < startpos)
2679 {
2680 if (startpos < next)
2681 next = startpos;
2682 break;
2683 }
2684 endpos = OVERLAY_POSITION (oend);
2685 /* Count an interval if it either overlaps the range
2686 or is empty at the start of the range. */
2687 if ((beg < endpos && startpos < end)
2688 || (startpos == endpos && beg == endpos))
2689 {
2690 if (idx == len)
2691 {
2692 if (extend)
2693 {
2694 /* Make it work with an initial len == 0. */
2695 len *= 2;
2696 if (len == 0)
2697 len = 4;
2698 *len_ptr = len;
2699 vec = (Lisp_Object *) xrealloc (vec, len * sizeof (Lisp_Object));
2700 *vec_ptr = vec;
2701 }
2702 else
2703 inhibit_storing = 1;
2704 }
2705
2706 if (!inhibit_storing)
2707 vec[idx] = overlay;
2708 idx++;
2709 }
2710 else if (endpos < beg && endpos > prev)
2711 prev = endpos;
2712 }
2713
2714 if (next_ptr)
2715 *next_ptr = next;
2716 if (prev_ptr)
2717 *prev_ptr = prev;
2718 return idx;
2719 }
2720
2721
2722 /* Return non-zero if there exists an overlay with a non-nil
2723 `mouse-face' property overlapping OVERLAY. */
2724
2725 int
2726 mouse_face_overlay_overlaps (overlay)
2727 Lisp_Object overlay;
2728 {
2729 int start = OVERLAY_POSITION (OVERLAY_START (overlay));
2730 int end = OVERLAY_POSITION (OVERLAY_END (overlay));
2731 int n, i, size;
2732 Lisp_Object *v, tem;
2733
2734 size = 10;
2735 v = (Lisp_Object *) alloca (size * sizeof *v);
2736 n = overlays_in (start, end, 0, &v, &size, NULL, NULL);
2737 if (n > size)
2738 {
2739 v = (Lisp_Object *) alloca (n * sizeof *v);
2740 overlays_in (start, end, 0, &v, &n, NULL, NULL);
2741 }
2742
2743 for (i = 0; i < n; ++i)
2744 if (!EQ (v[i], overlay)
2745 && (tem = Foverlay_get (overlay, Qmouse_face),
2746 !NILP (tem)))
2747 break;
2748
2749 return i < n;
2750 }
2751
2752
2753 \f
2754 /* Fast function to just test if we're at an overlay boundary. */
2755 int
2756 overlay_touches_p (pos)
2757 int pos;
2758 {
2759 Lisp_Object overlay;
2760 struct Lisp_Overlay *tail;
2761
2762 for (tail = current_buffer->overlays_before; tail; tail = tail->next)
2763 {
2764 int endpos;
2765
2766 XSETMISC (overlay ,tail);
2767 if (!GC_OVERLAYP (overlay))
2768 abort ();
2769
2770 endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
2771 if (endpos < pos)
2772 break;
2773 if (endpos == pos || OVERLAY_POSITION (OVERLAY_START (overlay)) == pos)
2774 return 1;
2775 }
2776
2777 for (tail = current_buffer->overlays_after; tail; tail = tail->next)
2778 {
2779 int startpos;
2780
2781 XSETMISC (overlay, tail);
2782 if (!GC_OVERLAYP (overlay))
2783 abort ();
2784
2785 startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
2786 if (pos < startpos)
2787 break;
2788 if (startpos == pos || OVERLAY_POSITION (OVERLAY_END (overlay)) == pos)
2789 return 1;
2790 }
2791 return 0;
2792 }
2793 \f
2794 struct sortvec
2795 {
2796 Lisp_Object overlay;
2797 int beg, end;
2798 int priority;
2799 };
2800
2801 static int
2802 compare_overlays (v1, v2)
2803 const void *v1, *v2;
2804 {
2805 const struct sortvec *s1 = (const struct sortvec *) v1;
2806 const struct sortvec *s2 = (const struct sortvec *) v2;
2807 if (s1->priority != s2->priority)
2808 return s1->priority - s2->priority;
2809 if (s1->beg != s2->beg)
2810 return s1->beg - s2->beg;
2811 if (s1->end != s2->end)
2812 return s2->end - s1->end;
2813 return 0;
2814 }
2815
2816 /* Sort an array of overlays by priority. The array is modified in place.
2817 The return value is the new size; this may be smaller than the original
2818 size if some of the overlays were invalid or were window-specific. */
2819 int
2820 sort_overlays (overlay_vec, noverlays, w)
2821 Lisp_Object *overlay_vec;
2822 int noverlays;
2823 struct window *w;
2824 {
2825 int i, j;
2826 struct sortvec *sortvec;
2827 sortvec = (struct sortvec *) alloca (noverlays * sizeof (struct sortvec));
2828
2829 /* Put the valid and relevant overlays into sortvec. */
2830
2831 for (i = 0, j = 0; i < noverlays; i++)
2832 {
2833 Lisp_Object tem;
2834 Lisp_Object overlay;
2835
2836 overlay = overlay_vec[i];
2837 if (OVERLAY_VALID (overlay)
2838 && OVERLAY_POSITION (OVERLAY_START (overlay)) > 0
2839 && OVERLAY_POSITION (OVERLAY_END (overlay)) > 0)
2840 {
2841 /* If we're interested in a specific window, then ignore
2842 overlays that are limited to some other window. */
2843 if (w)
2844 {
2845 Lisp_Object window;
2846
2847 window = Foverlay_get (overlay, Qwindow);
2848 if (WINDOWP (window) && XWINDOW (window) != w)
2849 continue;
2850 }
2851
2852 /* This overlay is good and counts: put it into sortvec. */
2853 sortvec[j].overlay = overlay;
2854 sortvec[j].beg = OVERLAY_POSITION (OVERLAY_START (overlay));
2855 sortvec[j].end = OVERLAY_POSITION (OVERLAY_END (overlay));
2856 tem = Foverlay_get (overlay, Qpriority);
2857 if (INTEGERP (tem))
2858 sortvec[j].priority = XINT (tem);
2859 else
2860 sortvec[j].priority = 0;
2861 j++;
2862 }
2863 }
2864 noverlays = j;
2865
2866 /* Sort the overlays into the proper order: increasing priority. */
2867
2868 if (noverlays > 1)
2869 qsort (sortvec, noverlays, sizeof (struct sortvec), compare_overlays);
2870
2871 for (i = 0; i < noverlays; i++)
2872 overlay_vec[i] = sortvec[i].overlay;
2873 return (noverlays);
2874 }
2875 \f
2876 struct sortstr
2877 {
2878 Lisp_Object string, string2;
2879 int size;
2880 int priority;
2881 };
2882
2883 struct sortstrlist
2884 {
2885 struct sortstr *buf; /* An array that expands as needed; never freed. */
2886 int size; /* Allocated length of that array. */
2887 int used; /* How much of the array is currently in use. */
2888 int bytes; /* Total length of the strings in buf. */
2889 };
2890
2891 /* Buffers for storing information about the overlays touching a given
2892 position. These could be automatic variables in overlay_strings, but
2893 it's more efficient to hold onto the memory instead of repeatedly
2894 allocating and freeing it. */
2895 static struct sortstrlist overlay_heads, overlay_tails;
2896 static unsigned char *overlay_str_buf;
2897
2898 /* Allocated length of overlay_str_buf. */
2899 static int overlay_str_len;
2900
2901 /* A comparison function suitable for passing to qsort. */
2902 static int
2903 cmp_for_strings (as1, as2)
2904 char *as1, *as2;
2905 {
2906 struct sortstr *s1 = (struct sortstr *)as1;
2907 struct sortstr *s2 = (struct sortstr *)as2;
2908 if (s1->size != s2->size)
2909 return s2->size - s1->size;
2910 if (s1->priority != s2->priority)
2911 return s1->priority - s2->priority;
2912 return 0;
2913 }
2914
2915 static void
2916 record_overlay_string (ssl, str, str2, pri, size)
2917 struct sortstrlist *ssl;
2918 Lisp_Object str, str2, pri;
2919 int size;
2920 {
2921 int nbytes;
2922
2923 if (ssl->used == ssl->size)
2924 {
2925 if (ssl->buf)
2926 ssl->size *= 2;
2927 else
2928 ssl->size = 5;
2929 ssl->buf = ((struct sortstr *)
2930 xrealloc (ssl->buf, ssl->size * sizeof (struct sortstr)));
2931 }
2932 ssl->buf[ssl->used].string = str;
2933 ssl->buf[ssl->used].string2 = str2;
2934 ssl->buf[ssl->used].size = size;
2935 ssl->buf[ssl->used].priority = (INTEGERP (pri) ? XINT (pri) : 0);
2936 ssl->used++;
2937
2938 if (NILP (current_buffer->enable_multibyte_characters))
2939 nbytes = SCHARS (str);
2940 else if (! STRING_MULTIBYTE (str))
2941 nbytes = count_size_as_multibyte (SDATA (str),
2942 SBYTES (str));
2943 else
2944 nbytes = SBYTES (str);
2945
2946 ssl->bytes += nbytes;
2947
2948 if (STRINGP (str2))
2949 {
2950 if (NILP (current_buffer->enable_multibyte_characters))
2951 nbytes = SCHARS (str2);
2952 else if (! STRING_MULTIBYTE (str2))
2953 nbytes = count_size_as_multibyte (SDATA (str2),
2954 SBYTES (str2));
2955 else
2956 nbytes = SBYTES (str2);
2957
2958 ssl->bytes += nbytes;
2959 }
2960 }
2961
2962 /* Return the concatenation of the strings associated with overlays that
2963 begin or end at POS, ignoring overlays that are specific to a window
2964 other than W. The strings are concatenated in the appropriate order:
2965 shorter overlays nest inside longer ones, and higher priority inside
2966 lower. Normally all of the after-strings come first, but zero-sized
2967 overlays have their after-strings ride along with the before-strings
2968 because it would look strange to print them inside-out.
2969
2970 Returns the string length, and stores the contents indirectly through
2971 PSTR, if that variable is non-null. The string may be overwritten by
2972 subsequent calls. */
2973
2974 int
2975 overlay_strings (pos, w, pstr)
2976 EMACS_INT pos;
2977 struct window *w;
2978 unsigned char **pstr;
2979 {
2980 Lisp_Object overlay, window, str;
2981 struct Lisp_Overlay *ov;
2982 int startpos, endpos;
2983 int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
2984
2985 overlay_heads.used = overlay_heads.bytes = 0;
2986 overlay_tails.used = overlay_tails.bytes = 0;
2987 for (ov = current_buffer->overlays_before; ov; ov = ov->next)
2988 {
2989 XSETMISC (overlay, ov);
2990 eassert (OVERLAYP (overlay));
2991
2992 startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
2993 endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
2994 if (endpos < pos)
2995 break;
2996 if (endpos != pos && startpos != pos)
2997 continue;
2998 window = Foverlay_get (overlay, Qwindow);
2999 if (WINDOWP (window) && XWINDOW (window) != w)
3000 continue;
3001 if (startpos == pos
3002 && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str)))
3003 record_overlay_string (&overlay_heads, str,
3004 (startpos == endpos
3005 ? Foverlay_get (overlay, Qafter_string)
3006 : Qnil),
3007 Foverlay_get (overlay, Qpriority),
3008 endpos - startpos);
3009 else if (endpos == pos
3010 && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str)))
3011 record_overlay_string (&overlay_tails, str, Qnil,
3012 Foverlay_get (overlay, Qpriority),
3013 endpos - startpos);
3014 }
3015 for (ov = current_buffer->overlays_after; ov; ov = ov->next)
3016 {
3017 XSETMISC (overlay, ov);
3018 eassert (OVERLAYP (overlay));
3019
3020 startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
3021 endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
3022 if (startpos > pos)
3023 break;
3024 if (endpos != pos && startpos != pos)
3025 continue;
3026 window = Foverlay_get (overlay, Qwindow);
3027 if (WINDOWP (window) && XWINDOW (window) != w)
3028 continue;
3029 if (startpos == pos
3030 && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str)))
3031 record_overlay_string (&overlay_heads, str,
3032 (startpos == endpos
3033 ? Foverlay_get (overlay, Qafter_string)
3034 : Qnil),
3035 Foverlay_get (overlay, Qpriority),
3036 endpos - startpos);
3037 else if (endpos == pos
3038 && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str)))
3039 record_overlay_string (&overlay_tails, str, Qnil,
3040 Foverlay_get (overlay, Qpriority),
3041 endpos - startpos);
3042 }
3043 if (overlay_tails.used > 1)
3044 qsort (overlay_tails.buf, overlay_tails.used, sizeof (struct sortstr),
3045 cmp_for_strings);
3046 if (overlay_heads.used > 1)
3047 qsort (overlay_heads.buf, overlay_heads.used, sizeof (struct sortstr),
3048 cmp_for_strings);
3049 if (overlay_heads.bytes || overlay_tails.bytes)
3050 {
3051 Lisp_Object tem;
3052 int i;
3053 unsigned char *p;
3054 int total = overlay_heads.bytes + overlay_tails.bytes;
3055
3056 if (total > overlay_str_len)
3057 {
3058 overlay_str_len = total;
3059 overlay_str_buf = (unsigned char *)xrealloc (overlay_str_buf,
3060 total);
3061 }
3062 p = overlay_str_buf;
3063 for (i = overlay_tails.used; --i >= 0;)
3064 {
3065 int nbytes;
3066 tem = overlay_tails.buf[i].string;
3067 nbytes = copy_text (SDATA (tem), p,
3068 SBYTES (tem),
3069 STRING_MULTIBYTE (tem), multibyte);
3070 p += nbytes;
3071 }
3072 for (i = 0; i < overlay_heads.used; ++i)
3073 {
3074 int nbytes;
3075 tem = overlay_heads.buf[i].string;
3076 nbytes = copy_text (SDATA (tem), p,
3077 SBYTES (tem),
3078 STRING_MULTIBYTE (tem), multibyte);
3079 p += nbytes;
3080 tem = overlay_heads.buf[i].string2;
3081 if (STRINGP (tem))
3082 {
3083 nbytes = copy_text (SDATA (tem), p,
3084 SBYTES (tem),
3085 STRING_MULTIBYTE (tem), multibyte);
3086 p += nbytes;
3087 }
3088 }
3089 if (p != overlay_str_buf + total)
3090 abort ();
3091 if (pstr)
3092 *pstr = overlay_str_buf;
3093 return total;
3094 }
3095 return 0;
3096 }
3097 \f
3098 /* Shift overlays in BUF's overlay lists, to center the lists at POS. */
3099
3100 void
3101 recenter_overlay_lists (buf, pos)
3102 struct buffer *buf;
3103 EMACS_INT pos;
3104 {
3105 Lisp_Object overlay, beg, end;
3106 struct Lisp_Overlay *prev, *tail, *next;
3107
3108 /* See if anything in overlays_before should move to overlays_after. */
3109
3110 /* We don't strictly need prev in this loop; it should always be nil.
3111 But we use it for symmetry and in case that should cease to be true
3112 with some future change. */
3113 prev = NULL;
3114 for (tail = buf->overlays_before; tail; prev = tail, tail = next)
3115 {
3116 next = tail->next;
3117 XSETMISC (overlay, tail);
3118
3119 /* If the overlay is not valid, get rid of it. */
3120 if (!OVERLAY_VALID (overlay))
3121 #if 1
3122 abort ();
3123 #else
3124 {
3125 /* Splice the cons cell TAIL out of overlays_before. */
3126 if (!NILP (prev))
3127 XCDR (prev) = next;
3128 else
3129 buf->overlays_before = next;
3130 tail = prev;
3131 continue;
3132 }
3133 #endif
3134
3135 beg = OVERLAY_START (overlay);
3136 end = OVERLAY_END (overlay);
3137
3138 if (OVERLAY_POSITION (end) > pos)
3139 {
3140 /* OVERLAY needs to be moved. */
3141 int where = OVERLAY_POSITION (beg);
3142 struct Lisp_Overlay *other, *other_prev;
3143
3144 /* Splice the cons cell TAIL out of overlays_before. */
3145 if (prev)
3146 prev->next = next;
3147 else
3148 buf->overlays_before = next;
3149
3150 /* Search thru overlays_after for where to put it. */
3151 other_prev = NULL;
3152 for (other = buf->overlays_after; other;
3153 other_prev = other, other = other->next)
3154 {
3155 Lisp_Object otherbeg, otheroverlay;
3156
3157 XSETMISC (otheroverlay, other);
3158 eassert (OVERLAY_VALID (otheroverlay));
3159
3160 otherbeg = OVERLAY_START (otheroverlay);
3161 if (OVERLAY_POSITION (otherbeg) >= where)
3162 break;
3163 }
3164
3165 /* Add TAIL to overlays_after before OTHER. */
3166 tail->next = other;
3167 if (other_prev)
3168 other_prev->next = tail;
3169 else
3170 buf->overlays_after = tail;
3171 tail = prev;
3172 }
3173 else
3174 /* We've reached the things that should stay in overlays_before.
3175 All the rest of overlays_before must end even earlier,
3176 so stop now. */
3177 break;
3178 }
3179
3180 /* See if anything in overlays_after should be in overlays_before. */
3181 prev = NULL;
3182 for (tail = buf->overlays_after; tail; prev = tail, tail = next)
3183 {
3184 next = tail->next;
3185 XSETMISC (overlay, tail);
3186
3187 /* If the overlay is not valid, get rid of it. */
3188 if (!OVERLAY_VALID (overlay))
3189 #if 1
3190 abort ();
3191 #else
3192 {
3193 /* Splice the cons cell TAIL out of overlays_after. */
3194 if (!NILP (prev))
3195 XCDR (prev) = next;
3196 else
3197 buf->overlays_after = next;
3198 tail = prev;
3199 continue;
3200 }
3201 #endif
3202
3203 beg = OVERLAY_START (overlay);
3204 end = OVERLAY_END (overlay);
3205
3206 /* Stop looking, when we know that nothing further
3207 can possibly end before POS. */
3208 if (OVERLAY_POSITION (beg) > pos)
3209 break;
3210
3211 if (OVERLAY_POSITION (end) <= pos)
3212 {
3213 /* OVERLAY needs to be moved. */
3214 int where = OVERLAY_POSITION (end);
3215 struct Lisp_Overlay *other, *other_prev;
3216
3217 /* Splice the cons cell TAIL out of overlays_after. */
3218 if (prev)
3219 prev->next = next;
3220 else
3221 buf->overlays_after = next;
3222
3223 /* Search thru overlays_before for where to put it. */
3224 other_prev = NULL;
3225 for (other = buf->overlays_before; other;
3226 other_prev = other, other = other->next)
3227 {
3228 Lisp_Object otherend, otheroverlay;
3229
3230 XSETMISC (otheroverlay, other);
3231 eassert (OVERLAY_VALID (otheroverlay));
3232
3233 otherend = OVERLAY_END (otheroverlay);
3234 if (OVERLAY_POSITION (otherend) <= where)
3235 break;
3236 }
3237
3238 /* Add TAIL to overlays_before before OTHER. */
3239 tail->next = other;
3240 if (other_prev)
3241 other_prev->next = tail;
3242 else
3243 buf->overlays_before = tail;
3244 tail = prev;
3245 }
3246 }
3247
3248 buf->overlay_center = pos;
3249 }
3250
3251 void
3252 adjust_overlays_for_insert (pos, length)
3253 EMACS_INT pos;
3254 EMACS_INT length;
3255 {
3256 /* After an insertion, the lists are still sorted properly,
3257 but we may need to update the value of the overlay center. */
3258 if (current_buffer->overlay_center >= pos)
3259 current_buffer->overlay_center += length;
3260 }
3261
3262 void
3263 adjust_overlays_for_delete (pos, length)
3264 EMACS_INT pos;
3265 EMACS_INT length;
3266 {
3267 if (current_buffer->overlay_center < pos)
3268 /* The deletion was to our right. No change needed; the before- and
3269 after-lists are still consistent. */
3270 ;
3271 else if (current_buffer->overlay_center > pos + length)
3272 /* The deletion was to our left. We need to adjust the center value
3273 to account for the change in position, but the lists are consistent
3274 given the new value. */
3275 current_buffer->overlay_center -= length;
3276 else
3277 /* We're right in the middle. There might be things on the after-list
3278 that now belong on the before-list. Recentering will move them,
3279 and also update the center point. */
3280 recenter_overlay_lists (current_buffer, pos);
3281 }
3282
3283 /* Fix up overlays that were garbled as a result of permuting markers
3284 in the range START through END. Any overlay with at least one
3285 endpoint in this range will need to be unlinked from the overlay
3286 list and reinserted in its proper place.
3287 Such an overlay might even have negative size at this point.
3288 If so, we'll reverse the endpoints. Can you think of anything
3289 better to do in this situation? */
3290 void
3291 fix_overlays_in_range (start, end)
3292 register int start, end;
3293 {
3294 Lisp_Object overlay;
3295 struct Lisp_Overlay *before_list, *after_list;
3296 /* These are either nil, indicating that before_list or after_list
3297 should be assigned, or the cons cell the cdr of which should be
3298 assigned. */
3299 struct Lisp_Overlay *beforep = NULL, *afterp = NULL;
3300 /* 'Parent', likewise, indicates a cons cell or
3301 current_buffer->overlays_before or overlays_after, depending
3302 which loop we're in. */
3303 struct Lisp_Overlay *tail, *parent;
3304 int startpos, endpos;
3305
3306 /* This algorithm shifts links around instead of consing and GCing.
3307 The loop invariant is that before_list (resp. after_list) is a
3308 well-formed list except that its last element, the CDR of beforep
3309 (resp. afterp) if beforep (afterp) isn't nil or before_list
3310 (after_list) if it is, is still uninitialized. So it's not a bug
3311 that before_list isn't initialized, although it may look
3312 strange. */
3313 for (parent = NULL, tail = current_buffer->overlays_before; tail;)
3314 {
3315 XSETMISC (overlay, tail);
3316 endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
3317 if (endpos < start)
3318 break;
3319 startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
3320 if (endpos < end
3321 || (startpos >= start && startpos < end))
3322 {
3323 /* If the overlay is backwards, fix that now. */
3324 if (startpos > endpos)
3325 {
3326 int tem;
3327 Fset_marker (OVERLAY_START (overlay), make_number (endpos),
3328 Qnil);
3329 Fset_marker (OVERLAY_END (overlay), make_number (startpos),
3330 Qnil);
3331 tem = startpos; startpos = endpos; endpos = tem;
3332 }
3333 /* Add it to the end of the wrong list. Later on,
3334 recenter_overlay_lists will move it to the right place. */
3335 if (endpos < current_buffer->overlay_center)
3336 {
3337 if (!afterp)
3338 after_list = tail;
3339 else
3340 afterp->next = tail;
3341 afterp = tail;
3342 }
3343 else
3344 {
3345 if (!beforep)
3346 before_list = tail;
3347 else
3348 beforep->next = tail;
3349 beforep = tail;
3350 }
3351 if (!parent)
3352 current_buffer->overlays_before = tail->next;
3353 else
3354 parent->next = tail->next;
3355 tail = tail->next;
3356 }
3357 else
3358 parent = tail, tail = parent->next;
3359 }
3360 for (parent = NULL, tail = current_buffer->overlays_after; tail;)
3361 {
3362 XSETMISC (overlay, tail);
3363 startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
3364 if (startpos >= end)
3365 break;
3366 endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
3367 if (startpos >= start
3368 || (endpos >= start && endpos < end))
3369 {
3370 if (startpos > endpos)
3371 {
3372 int tem;
3373 Fset_marker (OVERLAY_START (overlay), make_number (endpos),
3374 Qnil);
3375 Fset_marker (OVERLAY_END (overlay), make_number (startpos),
3376 Qnil);
3377 tem = startpos; startpos = endpos; endpos = tem;
3378 }
3379 if (endpos < current_buffer->overlay_center)
3380 {
3381 if (!afterp)
3382 after_list = tail;
3383 else
3384 afterp->next = tail;
3385 afterp = tail;
3386 }
3387 else
3388 {
3389 if (!beforep)
3390 before_list = tail;
3391 else
3392 beforep->next = tail;
3393 beforep = tail;
3394 }
3395 if (!parent)
3396 current_buffer->overlays_after = tail->next;
3397 else
3398 parent->next = tail->next;
3399 tail = tail->next;
3400 }
3401 else
3402 parent = tail, tail = parent->next;
3403 }
3404
3405 /* Splice the constructed (wrong) lists into the buffer's lists,
3406 and let the recenter function make it sane again. */
3407 if (beforep)
3408 {
3409 beforep->next = current_buffer->overlays_before;
3410 current_buffer->overlays_before = before_list;
3411 }
3412 recenter_overlay_lists (current_buffer, current_buffer->overlay_center);
3413
3414 if (afterp)
3415 {
3416 afterp->next = current_buffer->overlays_after;
3417 current_buffer->overlays_after = after_list;
3418 }
3419 recenter_overlay_lists (current_buffer, current_buffer->overlay_center);
3420 }
3421
3422 /* We have two types of overlay: the one whose ending marker is
3423 after-insertion-marker (this is the usual case) and the one whose
3424 ending marker is before-insertion-marker. When `overlays_before'
3425 contains overlays of the latter type and the former type in this
3426 order and both overlays end at inserting position, inserting a text
3427 increases only the ending marker of the latter type, which results
3428 in incorrect ordering of `overlays_before'.
3429
3430 This function fixes ordering of overlays in the slot
3431 `overlays_before' of the buffer *BP. Before the insertion, `point'
3432 was at PREV, and now is at POS. */
3433
3434 void
3435 fix_overlays_before (bp, prev, pos)
3436 struct buffer *bp;
3437 EMACS_INT prev, pos;
3438 {
3439 /* If parent is nil, replace overlays_before; otherwise, parent->next. */
3440 struct Lisp_Overlay *tail = bp->overlays_before, *parent = NULL, *right_pair;
3441 Lisp_Object tem;
3442 EMACS_INT end;
3443
3444 /* After the insertion, the several overlays may be in incorrect
3445 order. The possibility is that, in the list `overlays_before',
3446 an overlay which ends at POS appears after an overlay which ends
3447 at PREV. Since POS is greater than PREV, we must fix the
3448 ordering of these overlays, by moving overlays ends at POS before
3449 the overlays ends at PREV. */
3450
3451 /* At first, find a place where disordered overlays should be linked
3452 in. It is where an overlay which end before POS exists. (i.e. an
3453 overlay whose ending marker is after-insertion-marker if disorder
3454 exists). */
3455 while (tail
3456 && (XSETMISC (tem, tail),
3457 (end = OVERLAY_POSITION (OVERLAY_END (tem))) >= pos))
3458 {
3459 parent = tail;
3460 tail = tail->next;
3461 }
3462
3463 /* If we don't find such an overlay,
3464 or the found one ends before PREV,
3465 or the found one is the last one in the list,
3466 we don't have to fix anything. */
3467 if (!tail || end < prev || !tail->next)
3468 return;
3469
3470 right_pair = parent;
3471 parent = tail;
3472 tail = tail->next;
3473
3474 /* Now, end position of overlays in the list TAIL should be before
3475 or equal to PREV. In the loop, an overlay which ends at POS is
3476 moved ahead to the place indicated by the CDR of RIGHT_PAIR. If
3477 we found an overlay which ends before PREV, the remaining
3478 overlays are in correct order. */
3479 while (tail)
3480 {
3481 XSETMISC (tem, tail);
3482 end = OVERLAY_POSITION (OVERLAY_END (tem));
3483
3484 if (end == pos)
3485 { /* This overlay is disordered. */
3486 struct Lisp_Overlay *found = tail;
3487
3488 /* Unlink the found overlay. */
3489 tail = found->next;
3490 parent->next = tail;
3491 /* Move an overlay at RIGHT_PLACE to the next of the found one,
3492 and link it into the right place. */
3493 if (!right_pair)
3494 {
3495 found->next = bp->overlays_before;
3496 bp->overlays_before = found;
3497 }
3498 else
3499 {
3500 found->next = right_pair->next;
3501 right_pair->next = found;
3502 }
3503 }
3504 else if (end == prev)
3505 {
3506 parent = tail;
3507 tail = tail->next;
3508 }
3509 else /* No more disordered overlay. */
3510 break;
3511 }
3512 }
3513 \f
3514 DEFUN ("overlayp", Foverlayp, Soverlayp, 1, 1, 0,
3515 doc: /* Return t if OBJECT is an overlay. */)
3516 (object)
3517 Lisp_Object object;
3518 {
3519 return (OVERLAYP (object) ? Qt : Qnil);
3520 }
3521
3522 DEFUN ("make-overlay", Fmake_overlay, Smake_overlay, 2, 5, 0,
3523 doc: /* Create a new overlay with range BEG to END in BUFFER.
3524 If omitted, BUFFER defaults to the current buffer.
3525 BEG and END may be integers or markers.
3526 The fourth arg FRONT-ADVANCE, if non-nil, makes the
3527 front delimiter advance when text is inserted there.
3528 The fifth arg REAR-ADVANCE, if non-nil, makes the
3529 rear delimiter advance when text is inserted there. */)
3530 (beg, end, buffer, front_advance, rear_advance)
3531 Lisp_Object beg, end, buffer;
3532 Lisp_Object front_advance, rear_advance;
3533 {
3534 Lisp_Object overlay;
3535 struct buffer *b;
3536
3537 if (NILP (buffer))
3538 XSETBUFFER (buffer, current_buffer);
3539 else
3540 CHECK_BUFFER (buffer);
3541 if (MARKERP (beg)
3542 && ! EQ (Fmarker_buffer (beg), buffer))
3543 error ("Marker points into wrong buffer");
3544 if (MARKERP (end)
3545 && ! EQ (Fmarker_buffer (end), buffer))
3546 error ("Marker points into wrong buffer");
3547
3548 CHECK_NUMBER_COERCE_MARKER (beg);
3549 CHECK_NUMBER_COERCE_MARKER (end);
3550
3551 if (XINT (beg) > XINT (end))
3552 {
3553 Lisp_Object temp;
3554 temp = beg; beg = end; end = temp;
3555 }
3556
3557 b = XBUFFER (buffer);
3558
3559 beg = Fset_marker (Fmake_marker (), beg, buffer);
3560 end = Fset_marker (Fmake_marker (), end, buffer);
3561
3562 if (!NILP (front_advance))
3563 XMARKER (beg)->insertion_type = 1;
3564 if (!NILP (rear_advance))
3565 XMARKER (end)->insertion_type = 1;
3566
3567 overlay = allocate_misc ();
3568 XMISCTYPE (overlay) = Lisp_Misc_Overlay;
3569 XOVERLAY (overlay)->start = beg;
3570 XOVERLAY (overlay)->end = end;
3571 XOVERLAY (overlay)->plist = Qnil;
3572 XOVERLAY (overlay)->next = NULL;
3573
3574 /* Put the new overlay on the wrong list. */
3575 end = OVERLAY_END (overlay);
3576 if (OVERLAY_POSITION (end) < b->overlay_center)
3577 {
3578 if (b->overlays_after)
3579 XOVERLAY (overlay)->next = b->overlays_after;
3580 b->overlays_after = XOVERLAY (overlay);
3581 }
3582 else
3583 {
3584 if (b->overlays_before)
3585 XOVERLAY (overlay)->next = b->overlays_before;
3586 b->overlays_before = XOVERLAY (overlay);
3587 }
3588
3589 /* This puts it in the right list, and in the right order. */
3590 recenter_overlay_lists (b, b->overlay_center);
3591
3592 /* We don't need to redisplay the region covered by the overlay, because
3593 the overlay has no properties at the moment. */
3594
3595 return overlay;
3596 }
3597 \f
3598 /* Mark a section of BUF as needing redisplay because of overlays changes. */
3599
3600 static void
3601 modify_overlay (buf, start, end)
3602 struct buffer *buf;
3603 EMACS_INT start, end;
3604 {
3605 if (start > end)
3606 {
3607 int temp = start;
3608 start = end;
3609 end = temp;
3610 }
3611
3612 BUF_COMPUTE_UNCHANGED (buf, start, end);
3613
3614 /* If this is a buffer not in the selected window,
3615 we must do other windows. */
3616 if (buf != XBUFFER (XWINDOW (selected_window)->buffer))
3617 windows_or_buffers_changed = 1;
3618 /* If multiple windows show this buffer, we must do other windows. */
3619 else if (buffer_shared > 1)
3620 windows_or_buffers_changed = 1;
3621
3622 ++BUF_OVERLAY_MODIFF (buf);
3623 }
3624
3625 \f
3626 Lisp_Object Fdelete_overlay ();
3627
3628 static struct Lisp_Overlay *
3629 unchain_overlay (list, overlay)
3630 struct Lisp_Overlay *list, *overlay;
3631 {
3632 struct Lisp_Overlay *tmp, *prev;
3633 for (tmp = list, prev = NULL; tmp; prev = tmp, tmp = tmp->next)
3634 if (tmp == overlay)
3635 {
3636 if (prev)
3637 prev->next = tmp->next;
3638 else
3639 list = tmp->next;
3640 overlay->next = NULL;
3641 break;
3642 }
3643 return list;
3644 }
3645
3646 DEFUN ("move-overlay", Fmove_overlay, Smove_overlay, 3, 4, 0,
3647 doc: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
3648 If BUFFER is omitted, leave OVERLAY in the same buffer it inhabits now.
3649 If BUFFER is omitted, and OVERLAY is in no buffer, put it in the current
3650 buffer. */)
3651 (overlay, beg, end, buffer)
3652 Lisp_Object overlay, beg, end, buffer;
3653 {
3654 struct buffer *b, *ob;
3655 Lisp_Object obuffer;
3656 int count = SPECPDL_INDEX ();
3657
3658 CHECK_OVERLAY (overlay);
3659 if (NILP (buffer))
3660 buffer = Fmarker_buffer (OVERLAY_START (overlay));
3661 if (NILP (buffer))
3662 XSETBUFFER (buffer, current_buffer);
3663 CHECK_BUFFER (buffer);
3664
3665 if (MARKERP (beg)
3666 && ! EQ (Fmarker_buffer (beg), buffer))
3667 error ("Marker points into wrong buffer");
3668 if (MARKERP (end)
3669 && ! EQ (Fmarker_buffer (end), buffer))
3670 error ("Marker points into wrong buffer");
3671
3672 CHECK_NUMBER_COERCE_MARKER (beg);
3673 CHECK_NUMBER_COERCE_MARKER (end);
3674
3675 if (XINT (beg) == XINT (end) && ! NILP (Foverlay_get (overlay, Qevaporate)))
3676 return Fdelete_overlay (overlay);
3677
3678 if (XINT (beg) > XINT (end))
3679 {
3680 Lisp_Object temp;
3681 temp = beg; beg = end; end = temp;
3682 }
3683
3684 specbind (Qinhibit_quit, Qt);
3685
3686 obuffer = Fmarker_buffer (OVERLAY_START (overlay));
3687 b = XBUFFER (buffer);
3688 ob = BUFFERP (obuffer) ? XBUFFER (obuffer) : (struct buffer *) 0;
3689
3690 /* If the overlay has changed buffers, do a thorough redisplay. */
3691 if (!EQ (buffer, obuffer))
3692 {
3693 /* Redisplay where the overlay was. */
3694 if (!NILP (obuffer))
3695 {
3696 int o_beg;
3697 int o_end;
3698
3699 o_beg = OVERLAY_POSITION (OVERLAY_START (overlay));
3700 o_end = OVERLAY_POSITION (OVERLAY_END (overlay));
3701
3702 modify_overlay (ob, o_beg, o_end);
3703 }
3704
3705 /* Redisplay where the overlay is going to be. */
3706 modify_overlay (b, XINT (beg), XINT (end));
3707 }
3708 else
3709 /* Redisplay the area the overlay has just left, or just enclosed. */
3710 {
3711 int o_beg, o_end;
3712
3713 o_beg = OVERLAY_POSITION (OVERLAY_START (overlay));
3714 o_end = OVERLAY_POSITION (OVERLAY_END (overlay));
3715
3716 if (o_beg == XINT (beg))
3717 modify_overlay (b, o_end, XINT (end));
3718 else if (o_end == XINT (end))
3719 modify_overlay (b, o_beg, XINT (beg));
3720 else
3721 {
3722 if (XINT (beg) < o_beg) o_beg = XINT (beg);
3723 if (XINT (end) > o_end) o_end = XINT (end);
3724 modify_overlay (b, o_beg, o_end);
3725 }
3726 }
3727
3728 if (!NILP (obuffer))
3729 {
3730 ob->overlays_before
3731 = unchain_overlay (ob->overlays_before, XOVERLAY (overlay));
3732 ob->overlays_after
3733 = unchain_overlay (ob->overlays_after, XOVERLAY (overlay));
3734 eassert (XOVERLAY (overlay)->next == NULL);
3735 }
3736
3737 Fset_marker (OVERLAY_START (overlay), beg, buffer);
3738 Fset_marker (OVERLAY_END (overlay), end, buffer);
3739
3740 /* Put the overlay on the wrong list. */
3741 end = OVERLAY_END (overlay);
3742 if (OVERLAY_POSITION (end) < b->overlay_center)
3743 {
3744 XOVERLAY (overlay)->next = b->overlays_after;
3745 b->overlays_after = XOVERLAY (overlay);
3746 }
3747 else
3748 {
3749 XOVERLAY (overlay)->next = b->overlays_before;
3750 b->overlays_before = XOVERLAY (overlay);
3751 }
3752
3753 /* This puts it in the right list, and in the right order. */
3754 recenter_overlay_lists (b, b->overlay_center);
3755
3756 return unbind_to (count, overlay);
3757 }
3758
3759 DEFUN ("delete-overlay", Fdelete_overlay, Sdelete_overlay, 1, 1, 0,
3760 doc: /* Delete the overlay OVERLAY from its buffer. */)
3761 (overlay)
3762 Lisp_Object overlay;
3763 {
3764 Lisp_Object buffer;
3765 struct buffer *b;
3766 int count = SPECPDL_INDEX ();
3767
3768 CHECK_OVERLAY (overlay);
3769
3770 buffer = Fmarker_buffer (OVERLAY_START (overlay));
3771 if (NILP (buffer))
3772 return Qnil;
3773
3774 b = XBUFFER (buffer);
3775 specbind (Qinhibit_quit, Qt);
3776
3777 b->overlays_before = unchain_overlay (b->overlays_before,XOVERLAY (overlay));
3778 b->overlays_after = unchain_overlay (b->overlays_after, XOVERLAY (overlay));
3779 eassert (XOVERLAY (overlay)->next == NULL);
3780 modify_overlay (b,
3781 marker_position (OVERLAY_START (overlay)),
3782 marker_position (OVERLAY_END (overlay)));
3783 Fset_marker (OVERLAY_START (overlay), Qnil, Qnil);
3784 Fset_marker (OVERLAY_END (overlay), Qnil, Qnil);
3785
3786 /* When deleting an overlay with before or after strings, turn off
3787 display optimizations for the affected buffer, on the basis that
3788 these strings may contain newlines. This is easier to do than to
3789 check for that situation during redisplay. */
3790 if (!windows_or_buffers_changed
3791 && (!NILP (Foverlay_get (overlay, Qbefore_string))
3792 || !NILP (Foverlay_get (overlay, Qafter_string))))
3793 b->prevent_redisplay_optimizations_p = 1;
3794
3795 return unbind_to (count, Qnil);
3796 }
3797 \f
3798 /* Overlay dissection functions. */
3799
3800 DEFUN ("overlay-start", Foverlay_start, Soverlay_start, 1, 1, 0,
3801 doc: /* Return the position at which OVERLAY starts. */)
3802 (overlay)
3803 Lisp_Object overlay;
3804 {
3805 CHECK_OVERLAY (overlay);
3806
3807 return (Fmarker_position (OVERLAY_START (overlay)));
3808 }
3809
3810 DEFUN ("overlay-end", Foverlay_end, Soverlay_end, 1, 1, 0,
3811 doc: /* Return the position at which OVERLAY ends. */)
3812 (overlay)
3813 Lisp_Object overlay;
3814 {
3815 CHECK_OVERLAY (overlay);
3816
3817 return (Fmarker_position (OVERLAY_END (overlay)));
3818 }
3819
3820 DEFUN ("overlay-buffer", Foverlay_buffer, Soverlay_buffer, 1, 1, 0,
3821 doc: /* Return the buffer OVERLAY belongs to. */)
3822 (overlay)
3823 Lisp_Object overlay;
3824 {
3825 CHECK_OVERLAY (overlay);
3826
3827 return Fmarker_buffer (OVERLAY_START (overlay));
3828 }
3829
3830 DEFUN ("overlay-properties", Foverlay_properties, Soverlay_properties, 1, 1, 0,
3831 doc: /* Return a list of the properties on OVERLAY.
3832 This is a copy of OVERLAY's plist; modifying its conses has no effect on
3833 OVERLAY. */)
3834 (overlay)
3835 Lisp_Object overlay;
3836 {
3837 CHECK_OVERLAY (overlay);
3838
3839 return Fcopy_sequence (XOVERLAY (overlay)->plist);
3840 }
3841
3842 \f
3843 DEFUN ("overlays-at", Foverlays_at, Soverlays_at, 1, 1, 0,
3844 doc: /* Return a list of the overlays that contain position POS. */)
3845 (pos)
3846 Lisp_Object pos;
3847 {
3848 int noverlays;
3849 Lisp_Object *overlay_vec;
3850 int len;
3851 Lisp_Object result;
3852
3853 CHECK_NUMBER_COERCE_MARKER (pos);
3854
3855 len = 10;
3856 /* We can't use alloca here because overlays_at can call xrealloc. */
3857 overlay_vec = (Lisp_Object *) xmalloc (len * sizeof (Lisp_Object));
3858
3859 /* Put all the overlays we want in a vector in overlay_vec.
3860 Store the length in len. */
3861 noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
3862 (int *) 0, (int *) 0, 0);
3863
3864 /* Make a list of them all. */
3865 result = Flist (noverlays, overlay_vec);
3866
3867 xfree (overlay_vec);
3868 return result;
3869 }
3870
3871 DEFUN ("overlays-in", Foverlays_in, Soverlays_in, 2, 2, 0,
3872 doc: /* Return a list of the overlays that overlap the region BEG ... END.
3873 Overlap means that at least one character is contained within the overlay
3874 and also contained within the specified region.
3875 Empty overlays are included in the result if they are located at BEG
3876 or between BEG and END. */)
3877 (beg, end)
3878 Lisp_Object beg, end;
3879 {
3880 int noverlays;
3881 Lisp_Object *overlay_vec;
3882 int len;
3883 Lisp_Object result;
3884
3885 CHECK_NUMBER_COERCE_MARKER (beg);
3886 CHECK_NUMBER_COERCE_MARKER (end);
3887
3888 len = 10;
3889 overlay_vec = (Lisp_Object *) xmalloc (len * sizeof (Lisp_Object));
3890
3891 /* Put all the overlays we want in a vector in overlay_vec.
3892 Store the length in len. */
3893 noverlays = overlays_in (XINT (beg), XINT (end), 1, &overlay_vec, &len,
3894 (int *) 0, (int *) 0);
3895
3896 /* Make a list of them all. */
3897 result = Flist (noverlays, overlay_vec);
3898
3899 xfree (overlay_vec);
3900 return result;
3901 }
3902
3903 DEFUN ("next-overlay-change", Fnext_overlay_change, Snext_overlay_change,
3904 1, 1, 0,
3905 doc: /* Return the next position after POS where an overlay starts or ends.
3906 If there are no more overlay boundaries after POS, return (point-max). */)
3907 (pos)
3908 Lisp_Object pos;
3909 {
3910 int noverlays;
3911 int endpos;
3912 Lisp_Object *overlay_vec;
3913 int len;
3914 int i;
3915
3916 CHECK_NUMBER_COERCE_MARKER (pos);
3917
3918 len = 10;
3919 overlay_vec = (Lisp_Object *) xmalloc (len * sizeof (Lisp_Object));
3920
3921 /* Put all the overlays we want in a vector in overlay_vec.
3922 Store the length in len.
3923 endpos gets the position where the next overlay starts. */
3924 noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
3925 &endpos, (int *) 0, 1);
3926
3927 /* If any of these overlays ends before endpos,
3928 use its ending point instead. */
3929 for (i = 0; i < noverlays; i++)
3930 {
3931 Lisp_Object oend;
3932 int oendpos;
3933
3934 oend = OVERLAY_END (overlay_vec[i]);
3935 oendpos = OVERLAY_POSITION (oend);
3936 if (oendpos < endpos)
3937 endpos = oendpos;
3938 }
3939
3940 xfree (overlay_vec);
3941 return make_number (endpos);
3942 }
3943
3944 DEFUN ("previous-overlay-change", Fprevious_overlay_change,
3945 Sprevious_overlay_change, 1, 1, 0,
3946 doc: /* Return the previous position before POS where an overlay starts or ends.
3947 If there are no more overlay boundaries before POS, return (point-min). */)
3948 (pos)
3949 Lisp_Object pos;
3950 {
3951 int noverlays;
3952 int prevpos;
3953 Lisp_Object *overlay_vec;
3954 int len;
3955
3956 CHECK_NUMBER_COERCE_MARKER (pos);
3957
3958 /* At beginning of buffer, we know the answer;
3959 avoid bug subtracting 1 below. */
3960 if (XINT (pos) == BEGV)
3961 return pos;
3962
3963 len = 10;
3964 overlay_vec = (Lisp_Object *) xmalloc (len * sizeof (Lisp_Object));
3965
3966 /* Put all the overlays we want in a vector in overlay_vec.
3967 Store the length in len.
3968 prevpos gets the position of the previous change. */
3969 noverlays = overlays_at (XINT (pos), 1, &overlay_vec, &len,
3970 (int *) 0, &prevpos, 1);
3971
3972 xfree (overlay_vec);
3973 return make_number (prevpos);
3974 }
3975 \f
3976 /* These functions are for debugging overlays. */
3977
3978 DEFUN ("overlay-lists", Foverlay_lists, Soverlay_lists, 0, 0, 0,
3979 doc: /* Return a pair of lists giving all the overlays of the current buffer.
3980 The car has all the overlays before the overlay center;
3981 the cdr has all the overlays after the overlay center.
3982 Recentering overlays moves overlays between these lists.
3983 The lists you get are copies, so that changing them has no effect.
3984 However, the overlays you get are the real objects that the buffer uses. */)
3985 ()
3986 {
3987 struct Lisp_Overlay *ol;
3988 Lisp_Object before = Qnil, after = Qnil, tmp;
3989 for (ol = current_buffer->overlays_before; ol; ol = ol->next)
3990 {
3991 XSETMISC (tmp, ol);
3992 before = Fcons (tmp, before);
3993 }
3994 for (ol = current_buffer->overlays_after; ol; ol = ol->next)
3995 {
3996 XSETMISC (tmp, ol);
3997 after = Fcons (tmp, after);
3998 }
3999 return Fcons (Fnreverse (before), Fnreverse (after));
4000 }
4001
4002 DEFUN ("overlay-recenter", Foverlay_recenter, Soverlay_recenter, 1, 1, 0,
4003 doc: /* Recenter the overlays of the current buffer around position POS.
4004 That makes overlay lookup faster for positions near POS (but perhaps slower
4005 for positions far away from POS). */)
4006 (pos)
4007 Lisp_Object pos;
4008 {
4009 CHECK_NUMBER_COERCE_MARKER (pos);
4010
4011 recenter_overlay_lists (current_buffer, XINT (pos));
4012 return Qnil;
4013 }
4014 \f
4015 DEFUN ("overlay-get", Foverlay_get, Soverlay_get, 2, 2, 0,
4016 doc: /* Get the property of overlay OVERLAY with property name PROP. */)
4017 (overlay, prop)
4018 Lisp_Object overlay, prop;
4019 {
4020 CHECK_OVERLAY (overlay);
4021 return lookup_char_property (XOVERLAY (overlay)->plist, prop, 0);
4022 }
4023
4024 DEFUN ("overlay-put", Foverlay_put, Soverlay_put, 3, 3, 0,
4025 doc: /* Set one property of overlay OVERLAY: give property PROP value VALUE. */)
4026 (overlay, prop, value)
4027 Lisp_Object overlay, prop, value;
4028 {
4029 Lisp_Object tail, buffer;
4030 int changed;
4031
4032 CHECK_OVERLAY (overlay);
4033
4034 buffer = Fmarker_buffer (OVERLAY_START (overlay));
4035
4036 for (tail = XOVERLAY (overlay)->plist;
4037 CONSP (tail) && CONSP (XCDR (tail));
4038 tail = XCDR (XCDR (tail)))
4039 if (EQ (XCAR (tail), prop))
4040 {
4041 changed = !EQ (XCAR (XCDR (tail)), value);
4042 XSETCAR (XCDR (tail), value);
4043 goto found;
4044 }
4045 /* It wasn't in the list, so add it to the front. */
4046 changed = !NILP (value);
4047 XOVERLAY (overlay)->plist
4048 = Fcons (prop, Fcons (value, XOVERLAY (overlay)->plist));
4049 found:
4050 if (! NILP (buffer))
4051 {
4052 if (changed)
4053 modify_overlay (XBUFFER (buffer),
4054 marker_position (OVERLAY_START (overlay)),
4055 marker_position (OVERLAY_END (overlay)));
4056 if (EQ (prop, Qevaporate) && ! NILP (value)
4057 && (OVERLAY_POSITION (OVERLAY_START (overlay))
4058 == OVERLAY_POSITION (OVERLAY_END (overlay))))
4059 Fdelete_overlay (overlay);
4060 }
4061 return value;
4062 }
4063 \f
4064 /* Subroutine of report_overlay_modification. */
4065
4066 /* Lisp vector holding overlay hook functions to call.
4067 Vector elements come in pairs.
4068 Each even-index element is a list of hook functions.
4069 The following odd-index element is the overlay they came from.
4070
4071 Before the buffer change, we fill in this vector
4072 as we call overlay hook functions.
4073 After the buffer change, we get the functions to call from this vector.
4074 This way we always call the same functions before and after the change. */
4075 static Lisp_Object last_overlay_modification_hooks;
4076
4077 /* Number of elements actually used in last_overlay_modification_hooks. */
4078 static int last_overlay_modification_hooks_used;
4079
4080 /* Add one functionlist/overlay pair
4081 to the end of last_overlay_modification_hooks. */
4082
4083 static void
4084 add_overlay_mod_hooklist (functionlist, overlay)
4085 Lisp_Object functionlist, overlay;
4086 {
4087 int oldsize = XVECTOR (last_overlay_modification_hooks)->size;
4088
4089 if (last_overlay_modification_hooks_used == oldsize)
4090 {
4091 Lisp_Object old;
4092 old = last_overlay_modification_hooks;
4093 last_overlay_modification_hooks
4094 = Fmake_vector (make_number (oldsize * 2), Qnil);
4095 bcopy (XVECTOR (old)->contents,
4096 XVECTOR (last_overlay_modification_hooks)->contents,
4097 sizeof (Lisp_Object) * oldsize);
4098 }
4099 AREF (last_overlay_modification_hooks, last_overlay_modification_hooks_used++) = functionlist;
4100 AREF (last_overlay_modification_hooks, last_overlay_modification_hooks_used++) = overlay;
4101 }
4102 \f
4103 /* Run the modification-hooks of overlays that include
4104 any part of the text in START to END.
4105 If this change is an insertion, also
4106 run the insert-before-hooks of overlay starting at END,
4107 and the insert-after-hooks of overlay ending at START.
4108
4109 This is called both before and after the modification.
4110 AFTER is nonzero when we call after the modification.
4111
4112 ARG1, ARG2, ARG3 are arguments to pass to the hook functions.
4113 When AFTER is nonzero, they are the start position,
4114 the position after the inserted new text,
4115 and the length of deleted or replaced old text. */
4116
4117 void
4118 report_overlay_modification (start, end, after, arg1, arg2, arg3)
4119 Lisp_Object start, end;
4120 int after;
4121 Lisp_Object arg1, arg2, arg3;
4122 {
4123 Lisp_Object prop, overlay;
4124 struct Lisp_Overlay *tail;
4125 /* 1 if this change is an insertion. */
4126 int insertion = (after ? XFASTINT (arg3) == 0 : EQ (start, end));
4127 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
4128
4129 overlay = Qnil;
4130 tail = NULL;
4131
4132 /* We used to run the functions as soon as we found them and only register
4133 them in last_overlay_modification_hooks for the purpose of the `after'
4134 case. But running elisp code as we traverse the list of overlays is
4135 painful because the list can be modified by the elisp code so we had to
4136 copy at several places. We now simply do a read-only traversal that
4137 only collects the functions to run and we run them afterwards. It's
4138 simpler, especially since all the code was already there. -stef */
4139
4140 if (!after)
4141 {
4142 /* We are being called before a change.
4143 Scan the overlays to find the functions to call. */
4144 last_overlay_modification_hooks_used = 0;
4145 for (tail = current_buffer->overlays_before; tail; tail = tail->next)
4146 {
4147 int startpos, endpos;
4148 Lisp_Object ostart, oend;
4149
4150 XSETMISC (overlay, tail);
4151
4152 ostart = OVERLAY_START (overlay);
4153 oend = OVERLAY_END (overlay);
4154 endpos = OVERLAY_POSITION (oend);
4155 if (XFASTINT (start) > endpos)
4156 break;
4157 startpos = OVERLAY_POSITION (ostart);
4158 if (insertion && (XFASTINT (start) == startpos
4159 || XFASTINT (end) == startpos))
4160 {
4161 prop = Foverlay_get (overlay, Qinsert_in_front_hooks);
4162 if (!NILP (prop))
4163 add_overlay_mod_hooklist (prop, overlay);
4164 }
4165 if (insertion && (XFASTINT (start) == endpos
4166 || XFASTINT (end) == endpos))
4167 {
4168 prop = Foverlay_get (overlay, Qinsert_behind_hooks);
4169 if (!NILP (prop))
4170 add_overlay_mod_hooklist (prop, overlay);
4171 }
4172 /* Test for intersecting intervals. This does the right thing
4173 for both insertion and deletion. */
4174 if (XFASTINT (end) > startpos && XFASTINT (start) < endpos)
4175 {
4176 prop = Foverlay_get (overlay, Qmodification_hooks);
4177 if (!NILP (prop))
4178 add_overlay_mod_hooklist (prop, overlay);
4179 }
4180 }
4181
4182 for (tail = current_buffer->overlays_after; tail; tail = tail->next)
4183 {
4184 int startpos, endpos;
4185 Lisp_Object ostart, oend;
4186
4187 XSETMISC (overlay, tail);
4188
4189 ostart = OVERLAY_START (overlay);
4190 oend = OVERLAY_END (overlay);
4191 startpos = OVERLAY_POSITION (ostart);
4192 endpos = OVERLAY_POSITION (oend);
4193 if (XFASTINT (end) < startpos)
4194 break;
4195 if (insertion && (XFASTINT (start) == startpos
4196 || XFASTINT (end) == startpos))
4197 {
4198 prop = Foverlay_get (overlay, Qinsert_in_front_hooks);
4199 if (!NILP (prop))
4200 add_overlay_mod_hooklist (prop, overlay);
4201 }
4202 if (insertion && (XFASTINT (start) == endpos
4203 || XFASTINT (end) == endpos))
4204 {
4205 prop = Foverlay_get (overlay, Qinsert_behind_hooks);
4206 if (!NILP (prop))
4207 add_overlay_mod_hooklist (prop, overlay);
4208 }
4209 /* Test for intersecting intervals. This does the right thing
4210 for both insertion and deletion. */
4211 if (XFASTINT (end) > startpos && XFASTINT (start) < endpos)
4212 {
4213 prop = Foverlay_get (overlay, Qmodification_hooks);
4214 if (!NILP (prop))
4215 add_overlay_mod_hooklist (prop, overlay);
4216 }
4217 }
4218 }
4219
4220 GCPRO4 (overlay, arg1, arg2, arg3);
4221 {
4222 /* Call the functions recorded in last_overlay_modification_hooks.
4223 First copy the vector contents, in case some of these hooks
4224 do subsequent modification of the buffer. */
4225 int size = last_overlay_modification_hooks_used;
4226 Lisp_Object *copy = (Lisp_Object *) alloca (size * sizeof (Lisp_Object));
4227 int i;
4228
4229 bcopy (XVECTOR (last_overlay_modification_hooks)->contents,
4230 copy, size * sizeof (Lisp_Object));
4231 gcpro1.var = copy;
4232 gcpro1.nvars = size;
4233
4234 for (i = 0; i < size;)
4235 {
4236 Lisp_Object prop, overlay;
4237 prop = copy[i++];
4238 overlay = copy[i++];
4239 call_overlay_mod_hooks (prop, overlay, after, arg1, arg2, arg3);
4240 }
4241 }
4242 UNGCPRO;
4243 }
4244
4245 static void
4246 call_overlay_mod_hooks (list, overlay, after, arg1, arg2, arg3)
4247 Lisp_Object list, overlay;
4248 int after;
4249 Lisp_Object arg1, arg2, arg3;
4250 {
4251 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
4252
4253 GCPRO4 (list, arg1, arg2, arg3);
4254
4255 while (CONSP (list))
4256 {
4257 if (NILP (arg3))
4258 call4 (XCAR (list), overlay, after ? Qt : Qnil, arg1, arg2);
4259 else
4260 call5 (XCAR (list), overlay, after ? Qt : Qnil, arg1, arg2, arg3);
4261 list = XCDR (list);
4262 }
4263 UNGCPRO;
4264 }
4265
4266 /* Delete any zero-sized overlays at position POS, if the `evaporate'
4267 property is set. */
4268 void
4269 evaporate_overlays (pos)
4270 EMACS_INT pos;
4271 {
4272 Lisp_Object overlay, hit_list;
4273 struct Lisp_Overlay *tail;
4274
4275 hit_list = Qnil;
4276 if (pos <= current_buffer->overlay_center)
4277 for (tail = current_buffer->overlays_before; tail; tail = tail->next)
4278 {
4279 int endpos;
4280 XSETMISC (overlay, tail);
4281 endpos = OVERLAY_POSITION (OVERLAY_END (overlay));
4282 if (endpos < pos)
4283 break;
4284 if (endpos == pos && OVERLAY_POSITION (OVERLAY_START (overlay)) == pos
4285 && ! NILP (Foverlay_get (overlay, Qevaporate)))
4286 hit_list = Fcons (overlay, hit_list);
4287 }
4288 else
4289 for (tail = current_buffer->overlays_after; tail; tail = tail->next)
4290 {
4291 int startpos;
4292 XSETMISC (overlay, tail);
4293 startpos = OVERLAY_POSITION (OVERLAY_START (overlay));
4294 if (startpos > pos)
4295 break;
4296 if (startpos == pos && OVERLAY_POSITION (OVERLAY_END (overlay)) == pos
4297 && ! NILP (Foverlay_get (overlay, Qevaporate)))
4298 hit_list = Fcons (overlay, hit_list);
4299 }
4300 for (; CONSP (hit_list); hit_list = XCDR (hit_list))
4301 Fdelete_overlay (XCAR (hit_list));
4302 }
4303 \f
4304 /* Somebody has tried to store a value with an unacceptable type
4305 in the slot with offset OFFSET. */
4306
4307 void
4308 buffer_slot_type_mismatch (offset)
4309 int offset;
4310 {
4311 Lisp_Object sym;
4312 char *type_name;
4313
4314 switch (XINT (PER_BUFFER_TYPE (offset)))
4315 {
4316 case Lisp_Int:
4317 type_name = "integers";
4318 break;
4319
4320 case Lisp_String:
4321 type_name = "strings";
4322 break;
4323
4324 case Lisp_Symbol:
4325 type_name = "symbols";
4326 break;
4327
4328 default:
4329 abort ();
4330 }
4331
4332 sym = PER_BUFFER_SYMBOL (offset);
4333 error ("Only %s should be stored in the buffer-local variable %s",
4334 type_name, SDATA (SYMBOL_NAME (sym)));
4335 }
4336
4337 \f
4338 /***********************************************************************
4339 Allocation with mmap
4340 ***********************************************************************/
4341
4342 #ifdef USE_MMAP_FOR_BUFFERS
4343
4344 #include <sys/types.h>
4345 #include <sys/mman.h>
4346
4347 #ifndef MAP_ANON
4348 #ifdef MAP_ANONYMOUS
4349 #define MAP_ANON MAP_ANONYMOUS
4350 #else
4351 #define MAP_ANON 0
4352 #endif
4353 #endif
4354
4355 #ifndef MAP_FAILED
4356 #define MAP_FAILED ((void *) -1)
4357 #endif
4358
4359 #include <stdio.h>
4360 #include <errno.h>
4361
4362 #if MAP_ANON == 0
4363 #include <fcntl.h>
4364 #endif
4365
4366 #include "coding.h"
4367
4368
4369 /* Memory is allocated in regions which are mapped using mmap(2).
4370 The current implementation lets the system select mapped
4371 addresses; we're not using MAP_FIXED in general, except when
4372 trying to enlarge regions.
4373
4374 Each mapped region starts with a mmap_region structure, the user
4375 area starts after that structure, aligned to MEM_ALIGN.
4376
4377 +-----------------------+
4378 | struct mmap_info + |
4379 | padding |
4380 +-----------------------+
4381 | user data |
4382 | |
4383 | |
4384 +-----------------------+ */
4385
4386 struct mmap_region
4387 {
4388 /* User-specified size. */
4389 size_t nbytes_specified;
4390
4391 /* Number of bytes mapped */
4392 size_t nbytes_mapped;
4393
4394 /* Pointer to the location holding the address of the memory
4395 allocated with the mmap'd block. The variable actually points
4396 after this structure. */
4397 POINTER_TYPE **var;
4398
4399 /* Next and previous in list of all mmap'd regions. */
4400 struct mmap_region *next, *prev;
4401 };
4402
4403 /* Doubly-linked list of mmap'd regions. */
4404
4405 static struct mmap_region *mmap_regions;
4406
4407 /* File descriptor for mmap. If we don't have anonymous mapping,
4408 /dev/zero will be opened on it. */
4409
4410 static int mmap_fd;
4411
4412 /* Temporary storage for mmap_set_vars, see there. */
4413
4414 static struct mmap_region *mmap_regions_1;
4415 static int mmap_fd_1;
4416
4417 /* Page size on this system. */
4418
4419 static int mmap_page_size;
4420
4421 /* 1 means mmap has been intialized. */
4422
4423 static int mmap_initialized_p;
4424
4425 /* Value is X rounded up to the next multiple of N. */
4426
4427 #define ROUND(X, N) (((X) + (N) - 1) / (N) * (N))
4428
4429 /* Size of mmap_region structure plus padding. */
4430
4431 #define MMAP_REGION_STRUCT_SIZE \
4432 ROUND (sizeof (struct mmap_region), MEM_ALIGN)
4433
4434 /* Given a pointer P to the start of the user-visible part of a mapped
4435 region, return a pointer to the start of the region. */
4436
4437 #define MMAP_REGION(P) \
4438 ((struct mmap_region *) ((char *) (P) - MMAP_REGION_STRUCT_SIZE))
4439
4440 /* Given a pointer P to the start of a mapped region, return a pointer
4441 to the start of the user-visible part of the region. */
4442
4443 #define MMAP_USER_AREA(P) \
4444 ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
4445
4446 #define MEM_ALIGN sizeof (double)
4447
4448 /* Predicate returning true if part of the address range [START .. END]
4449 is currently mapped. Used to prevent overwriting an existing
4450 memory mapping.
4451
4452 Default is to conservativly assume the address range is occupied by
4453 something else. This can be overridden by system configuration
4454 files if system-specific means to determine this exists. */
4455
4456 #ifndef MMAP_ALLOCATED_P
4457 #define MMAP_ALLOCATED_P(start, end) 1
4458 #endif
4459
4460 /* Function prototypes. */
4461
4462 static int mmap_free_1 P_ ((struct mmap_region *));
4463 static int mmap_enlarge P_ ((struct mmap_region *, int));
4464 static struct mmap_region *mmap_find P_ ((POINTER_TYPE *, POINTER_TYPE *));
4465 static POINTER_TYPE *mmap_alloc P_ ((POINTER_TYPE **, size_t));
4466 static POINTER_TYPE *mmap_realloc P_ ((POINTER_TYPE **, size_t));
4467 static void mmap_free P_ ((POINTER_TYPE **ptr));
4468 static void mmap_init P_ ((void));
4469
4470
4471 /* Return a region overlapping address range START...END, or null if
4472 none. END is not including, i.e. the last byte in the range
4473 is at END - 1. */
4474
4475 static struct mmap_region *
4476 mmap_find (start, end)
4477 POINTER_TYPE *start, *end;
4478 {
4479 struct mmap_region *r;
4480 char *s = (char *) start, *e = (char *) end;
4481
4482 for (r = mmap_regions; r; r = r->next)
4483 {
4484 char *rstart = (char *) r;
4485 char *rend = rstart + r->nbytes_mapped;
4486
4487 if (/* First byte of range, i.e. START, in this region? */
4488 (s >= rstart && s < rend)
4489 /* Last byte of range, i.e. END - 1, in this region? */
4490 || (e > rstart && e <= rend)
4491 /* First byte of this region in the range? */
4492 || (rstart >= s && rstart < e)
4493 /* Last byte of this region in the range? */
4494 || (rend > s && rend <= e))
4495 break;
4496 }
4497
4498 return r;
4499 }
4500
4501
4502 /* Unmap a region. P is a pointer to the start of the user-araa of
4503 the region. Value is non-zero if successful. */
4504
4505 static int
4506 mmap_free_1 (r)
4507 struct mmap_region *r;
4508 {
4509 if (r->next)
4510 r->next->prev = r->prev;
4511 if (r->prev)
4512 r->prev->next = r->next;
4513 else
4514 mmap_regions = r->next;
4515
4516 if (munmap ((POINTER_TYPE *) r, r->nbytes_mapped) == -1)
4517 {
4518 fprintf (stderr, "munmap: %s\n", emacs_strerror (errno));
4519 return 0;
4520 }
4521
4522 return 1;
4523 }
4524
4525
4526 /* Enlarge region R by NPAGES pages. NPAGES < 0 means shrink R.
4527 Value is non-zero if successful. */
4528
4529 static int
4530 mmap_enlarge (r, npages)
4531 struct mmap_region *r;
4532 int npages;
4533 {
4534 char *region_end = (char *) r + r->nbytes_mapped;
4535 size_t nbytes;
4536 int success = 0;
4537
4538 if (npages < 0)
4539 {
4540 /* Unmap pages at the end of the region. */
4541 nbytes = - npages * mmap_page_size;
4542 if (munmap (region_end - nbytes, nbytes) == -1)
4543 fprintf (stderr, "munmap: %s\n", emacs_strerror (errno));
4544 else
4545 {
4546 r->nbytes_mapped -= nbytes;
4547 success = 1;
4548 }
4549 }
4550 else if (npages > 0)
4551 {
4552 nbytes = npages * mmap_page_size;
4553
4554 /* Try to map additional pages at the end of the region. We
4555 cannot do this if the address range is already occupied by
4556 something else because mmap deletes any previous mapping.
4557 I'm not sure this is worth doing, let's see. */
4558 if (!MMAP_ALLOCATED_P (region_end, region_end + nbytes))
4559 {
4560 POINTER_TYPE *p;
4561
4562 p = mmap (region_end, nbytes, PROT_READ | PROT_WRITE,
4563 MAP_ANON | MAP_PRIVATE | MAP_FIXED, mmap_fd, 0);
4564 if (p == MAP_FAILED)
4565 ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
4566 else if (p != (POINTER_TYPE *) region_end)
4567 {
4568 /* Kernels are free to choose a different address. In
4569 that case, unmap what we've mapped above; we have
4570 no use for it. */
4571 if (munmap (p, nbytes) == -1)
4572 fprintf (stderr, "munmap: %s\n", emacs_strerror (errno));
4573 }
4574 else
4575 {
4576 r->nbytes_mapped += nbytes;
4577 success = 1;
4578 }
4579 }
4580 }
4581
4582 return success;
4583 }
4584
4585
4586 /* Set or reset variables holding references to mapped regions. If
4587 RESTORE_P is zero, set all variables to null. If RESTORE_P is
4588 non-zero, set all variables to the start of the user-areas
4589 of mapped regions.
4590
4591 This function is called from Fdump_emacs to ensure that the dumped
4592 Emacs doesn't contain references to memory that won't be mapped
4593 when Emacs starts. */
4594
4595 void
4596 mmap_set_vars (restore_p)
4597 int restore_p;
4598 {
4599 struct mmap_region *r;
4600
4601 if (restore_p)
4602 {
4603 mmap_regions = mmap_regions_1;
4604 mmap_fd = mmap_fd_1;
4605 for (r = mmap_regions; r; r = r->next)
4606 *r->var = MMAP_USER_AREA (r);
4607 }
4608 else
4609 {
4610 for (r = mmap_regions; r; r = r->next)
4611 *r->var = NULL;
4612 mmap_regions_1 = mmap_regions;
4613 mmap_regions = NULL;
4614 mmap_fd_1 = mmap_fd;
4615 mmap_fd = -1;
4616 }
4617 }
4618
4619
4620 /* Allocate a block of storage large enough to hold NBYTES bytes of
4621 data. A pointer to the data is returned in *VAR. VAR is thus the
4622 address of some variable which will use the data area.
4623
4624 The allocation of 0 bytes is valid.
4625
4626 If we can't allocate the necessary memory, set *VAR to null, and
4627 return null. */
4628
4629 static POINTER_TYPE *
4630 mmap_alloc (var, nbytes)
4631 POINTER_TYPE **var;
4632 size_t nbytes;
4633 {
4634 void *p;
4635 size_t map;
4636
4637 mmap_init ();
4638
4639 map = ROUND (nbytes + MMAP_REGION_STRUCT_SIZE, mmap_page_size);
4640 p = mmap (NULL, map, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE,
4641 mmap_fd, 0);
4642
4643 if (p == MAP_FAILED)
4644 {
4645 if (errno != ENOMEM)
4646 fprintf (stderr, "mmap: %s\n", emacs_strerror (errno));
4647 p = NULL;
4648 }
4649 else
4650 {
4651 struct mmap_region *r = (struct mmap_region *) p;
4652
4653 r->nbytes_specified = nbytes;
4654 r->nbytes_mapped = map;
4655 r->var = var;
4656 r->prev = NULL;
4657 r->next = mmap_regions;
4658 if (r->next)
4659 r->next->prev = r;
4660 mmap_regions = r;
4661
4662 p = MMAP_USER_AREA (p);
4663 }
4664
4665 return *var = p;
4666 }
4667
4668
4669 /* Given a pointer at address VAR to data allocated with mmap_alloc,
4670 resize it to size NBYTES. Change *VAR to reflect the new block,
4671 and return this value. If more memory cannot be allocated, then
4672 leave *VAR unchanged, and return null. */
4673
4674 static POINTER_TYPE *
4675 mmap_realloc (var, nbytes)
4676 POINTER_TYPE **var;
4677 size_t nbytes;
4678 {
4679 POINTER_TYPE *result;
4680
4681 mmap_init ();
4682
4683 if (*var == NULL)
4684 result = mmap_alloc (var, nbytes);
4685 else if (nbytes == 0)
4686 {
4687 mmap_free (var);
4688 result = mmap_alloc (var, nbytes);
4689 }
4690 else
4691 {
4692 struct mmap_region *r = MMAP_REGION (*var);
4693 size_t room = r->nbytes_mapped - MMAP_REGION_STRUCT_SIZE;
4694
4695 if (room < nbytes)
4696 {
4697 /* Must enlarge. */
4698 POINTER_TYPE *old_ptr = *var;
4699
4700 /* Try to map additional pages at the end of the region.
4701 If that fails, allocate a new region, copy data
4702 from the old region, then free it. */
4703 if (mmap_enlarge (r, (ROUND (nbytes - room, mmap_page_size)
4704 / mmap_page_size)))
4705 {
4706 r->nbytes_specified = nbytes;
4707 *var = result = old_ptr;
4708 }
4709 else if (mmap_alloc (var, nbytes))
4710 {
4711 bcopy (old_ptr, *var, r->nbytes_specified);
4712 mmap_free_1 (MMAP_REGION (old_ptr));
4713 result = *var;
4714 r = MMAP_REGION (result);
4715 r->nbytes_specified = nbytes;
4716 }
4717 else
4718 {
4719 *var = old_ptr;
4720 result = NULL;
4721 }
4722 }
4723 else if (room - nbytes >= mmap_page_size)
4724 {
4725 /* Shrinking by at least a page. Let's give some
4726 memory back to the system.
4727
4728 The extra parens are to make the division happens first,
4729 on positive values, so we know it will round towards
4730 zero. */
4731 mmap_enlarge (r, - ((room - nbytes) / mmap_page_size));
4732 result = *var;
4733 r->nbytes_specified = nbytes;
4734 }
4735 else
4736 {
4737 /* Leave it alone. */
4738 result = *var;
4739 r->nbytes_specified = nbytes;
4740 }
4741 }
4742
4743 return result;
4744 }
4745
4746
4747 /* Free a block of relocatable storage whose data is pointed to by
4748 PTR. Store 0 in *PTR to show there's no block allocated. */
4749
4750 static void
4751 mmap_free (var)
4752 POINTER_TYPE **var;
4753 {
4754 mmap_init ();
4755
4756 if (*var)
4757 {
4758 mmap_free_1 (MMAP_REGION (*var));
4759 *var = NULL;
4760 }
4761 }
4762
4763
4764 /* Perform necessary intializations for the use of mmap. */
4765
4766 static void
4767 mmap_init ()
4768 {
4769 #if MAP_ANON == 0
4770 /* The value of mmap_fd is initially 0 in temacs, and -1
4771 in a dumped Emacs. */
4772 if (mmap_fd <= 0)
4773 {
4774 /* No anonymous mmap -- we need the file descriptor. */
4775 mmap_fd = open ("/dev/zero", O_RDONLY);
4776 if (mmap_fd == -1)
4777 fatal ("Cannot open /dev/zero: %s", emacs_strerror (errno));
4778 }
4779 #endif /* MAP_ANON == 0 */
4780
4781 if (mmap_initialized_p)
4782 return;
4783 mmap_initialized_p = 1;
4784
4785 #if MAP_ANON != 0
4786 mmap_fd = -1;
4787 #endif
4788
4789 mmap_page_size = getpagesize ();
4790 }
4791
4792 #endif /* USE_MMAP_FOR_BUFFERS */
4793
4794
4795 \f
4796 /***********************************************************************
4797 Buffer-text Allocation
4798 ***********************************************************************/
4799
4800 #ifdef REL_ALLOC
4801 extern POINTER_TYPE *r_alloc P_ ((POINTER_TYPE **, size_t));
4802 extern POINTER_TYPE *r_re_alloc P_ ((POINTER_TYPE **, size_t));
4803 extern void r_alloc_free P_ ((POINTER_TYPE **ptr));
4804 #endif /* REL_ALLOC */
4805
4806
4807 /* Allocate NBYTES bytes for buffer B's text buffer. */
4808
4809 static void
4810 alloc_buffer_text (b, nbytes)
4811 struct buffer *b;
4812 size_t nbytes;
4813 {
4814 POINTER_TYPE *p;
4815
4816 BLOCK_INPUT;
4817 #if defined USE_MMAP_FOR_BUFFERS
4818 p = mmap_alloc ((POINTER_TYPE **) &b->text->beg, nbytes);
4819 #elif defined REL_ALLOC
4820 p = r_alloc ((POINTER_TYPE **) &b->text->beg, nbytes);
4821 #else
4822 p = xmalloc (nbytes);
4823 #endif
4824
4825 if (p == NULL)
4826 {
4827 UNBLOCK_INPUT;
4828 memory_full ();
4829 }
4830
4831 b->text->beg = (unsigned char *) p;
4832 UNBLOCK_INPUT;
4833 }
4834
4835 /* Enlarge buffer B's text buffer by DELTA bytes. DELTA < 0 means
4836 shrink it. */
4837
4838 void
4839 enlarge_buffer_text (b, delta)
4840 struct buffer *b;
4841 int delta;
4842 {
4843 POINTER_TYPE *p;
4844 size_t nbytes = (BUF_Z_BYTE (b) - BUF_BEG_BYTE (b) + BUF_GAP_SIZE (b) + 1
4845 + delta);
4846 BLOCK_INPUT;
4847 #if defined USE_MMAP_FOR_BUFFERS
4848 p = mmap_realloc ((POINTER_TYPE **) &b->text->beg, nbytes);
4849 #elif defined REL_ALLOC
4850 p = r_re_alloc ((POINTER_TYPE **) &b->text->beg, nbytes);
4851 #else
4852 p = xrealloc (b->text->beg, nbytes);
4853 #endif
4854
4855 if (p == NULL)
4856 {
4857 UNBLOCK_INPUT;
4858 memory_full ();
4859 }
4860
4861 BUF_BEG_ADDR (b) = (unsigned char *) p;
4862 UNBLOCK_INPUT;
4863 }
4864
4865
4866 /* Free buffer B's text buffer. */
4867
4868 static void
4869 free_buffer_text (b)
4870 struct buffer *b;
4871 {
4872 BLOCK_INPUT;
4873
4874 #if defined USE_MMAP_FOR_BUFFERS
4875 mmap_free ((POINTER_TYPE **) &b->text->beg);
4876 #elif defined REL_ALLOC
4877 r_alloc_free ((POINTER_TYPE **) &b->text->beg);
4878 #else
4879 xfree (b->text->beg);
4880 #endif
4881
4882 BUF_BEG_ADDR (b) = NULL;
4883 UNBLOCK_INPUT;
4884 }
4885
4886
4887 \f
4888 /***********************************************************************
4889 Initialization
4890 ***********************************************************************/
4891
4892 void
4893 init_buffer_once ()
4894 {
4895 int idx;
4896
4897 bzero (buffer_permanent_local_flags, sizeof buffer_permanent_local_flags);
4898
4899 /* Make sure all markable slots in buffer_defaults
4900 are initialized reasonably, so mark_buffer won't choke. */
4901 reset_buffer (&buffer_defaults);
4902 reset_buffer_local_variables (&buffer_defaults, 1);
4903 reset_buffer (&buffer_local_symbols);
4904 reset_buffer_local_variables (&buffer_local_symbols, 1);
4905 /* Prevent GC from getting confused. */
4906 buffer_defaults.text = &buffer_defaults.own_text;
4907 buffer_local_symbols.text = &buffer_local_symbols.own_text;
4908 BUF_INTERVALS (&buffer_defaults) = 0;
4909 BUF_INTERVALS (&buffer_local_symbols) = 0;
4910 XSETBUFFER (Vbuffer_defaults, &buffer_defaults);
4911 XSETBUFFER (Vbuffer_local_symbols, &buffer_local_symbols);
4912
4913 /* Set up the default values of various buffer slots. */
4914 /* Must do these before making the first buffer! */
4915
4916 /* real setup is done in bindings.el */
4917 buffer_defaults.mode_line_format = build_string ("%-");
4918 buffer_defaults.header_line_format = Qnil;
4919 buffer_defaults.abbrev_mode = Qnil;
4920 buffer_defaults.overwrite_mode = Qnil;
4921 buffer_defaults.case_fold_search = Qt;
4922 buffer_defaults.auto_fill_function = Qnil;
4923 buffer_defaults.selective_display = Qnil;
4924 #ifndef old
4925 buffer_defaults.selective_display_ellipses = Qt;
4926 #endif
4927 buffer_defaults.abbrev_table = Qnil;
4928 buffer_defaults.display_table = Qnil;
4929 buffer_defaults.undo_list = Qnil;
4930 buffer_defaults.mark_active = Qnil;
4931 buffer_defaults.file_format = Qnil;
4932 buffer_defaults.overlays_before = NULL;
4933 buffer_defaults.overlays_after = NULL;
4934 buffer_defaults.overlay_center = BEG;
4935
4936 XSETFASTINT (buffer_defaults.tab_width, 8);
4937 buffer_defaults.truncate_lines = Qnil;
4938 buffer_defaults.ctl_arrow = Qt;
4939 buffer_defaults.direction_reversed = Qnil;
4940 buffer_defaults.cursor_type = Qt;
4941 buffer_defaults.extra_line_spacing = Qnil;
4942
4943 #ifdef DOS_NT
4944 buffer_defaults.buffer_file_type = Qnil; /* TEXT */
4945 #endif
4946 buffer_defaults.enable_multibyte_characters = Qt;
4947 buffer_defaults.buffer_file_coding_system = Qnil;
4948 XSETFASTINT (buffer_defaults.fill_column, 70);
4949 XSETFASTINT (buffer_defaults.left_margin, 0);
4950 buffer_defaults.cache_long_line_scans = Qnil;
4951 buffer_defaults.file_truename = Qnil;
4952 XSETFASTINT (buffer_defaults.display_count, 0);
4953 XSETFASTINT (buffer_defaults.left_margin_cols, 0);
4954 XSETFASTINT (buffer_defaults.right_margin_cols, 0);
4955 buffer_defaults.left_fringe_width = Qnil;
4956 buffer_defaults.right_fringe_width = Qnil;
4957 buffer_defaults.fringes_outside_margins = Qnil;
4958 buffer_defaults.scroll_bar_width = Qnil;
4959 buffer_defaults.vertical_scroll_bar_type = Qt;
4960 buffer_defaults.indicate_empty_lines = Qnil;
4961 buffer_defaults.scroll_up_aggressively = Qnil;
4962 buffer_defaults.scroll_down_aggressively = Qnil;
4963 buffer_defaults.display_time = Qnil;
4964
4965 /* Assign the local-flags to the slots that have default values.
4966 The local flag is a bit that is used in the buffer
4967 to say that it has its own local value for the slot.
4968 The local flag bits are in the local_var_flags slot of the buffer. */
4969
4970 /* Nothing can work if this isn't true */
4971 if (sizeof (EMACS_INT) != sizeof (Lisp_Object)) abort ();
4972
4973 /* 0 means not a lisp var, -1 means always local, else mask */
4974 bzero (&buffer_local_flags, sizeof buffer_local_flags);
4975 XSETINT (buffer_local_flags.filename, -1);
4976 XSETINT (buffer_local_flags.directory, -1);
4977 XSETINT (buffer_local_flags.backed_up, -1);
4978 XSETINT (buffer_local_flags.save_length, -1);
4979 XSETINT (buffer_local_flags.auto_save_file_name, -1);
4980 XSETINT (buffer_local_flags.read_only, -1);
4981 XSETINT (buffer_local_flags.major_mode, -1);
4982 XSETINT (buffer_local_flags.mode_name, -1);
4983 XSETINT (buffer_local_flags.undo_list, -1);
4984 XSETINT (buffer_local_flags.mark_active, -1);
4985 XSETINT (buffer_local_flags.point_before_scroll, -1);
4986 XSETINT (buffer_local_flags.file_truename, -1);
4987 XSETINT (buffer_local_flags.invisibility_spec, -1);
4988 XSETINT (buffer_local_flags.file_format, -1);
4989 XSETINT (buffer_local_flags.display_count, -1);
4990 XSETINT (buffer_local_flags.display_time, -1);
4991 XSETINT (buffer_local_flags.enable_multibyte_characters, -1);
4992
4993 idx = 1;
4994 XSETFASTINT (buffer_local_flags.mode_line_format, idx); ++idx;
4995 XSETFASTINT (buffer_local_flags.abbrev_mode, idx); ++idx;
4996 XSETFASTINT (buffer_local_flags.overwrite_mode, idx); ++idx;
4997 XSETFASTINT (buffer_local_flags.case_fold_search, idx); ++idx;
4998 XSETFASTINT (buffer_local_flags.auto_fill_function, idx); ++idx;
4999 XSETFASTINT (buffer_local_flags.selective_display, idx); ++idx;
5000 #ifndef old
5001 XSETFASTINT (buffer_local_flags.selective_display_ellipses, idx); ++idx;
5002 #endif
5003 XSETFASTINT (buffer_local_flags.tab_width, idx); ++idx;
5004 XSETFASTINT (buffer_local_flags.truncate_lines, idx); ++idx;
5005 XSETFASTINT (buffer_local_flags.ctl_arrow, idx); ++idx;
5006 XSETFASTINT (buffer_local_flags.fill_column, idx); ++idx;
5007 XSETFASTINT (buffer_local_flags.left_margin, idx); ++idx;
5008 XSETFASTINT (buffer_local_flags.abbrev_table, idx); ++idx;
5009 XSETFASTINT (buffer_local_flags.display_table, idx); ++idx;
5010 #ifdef DOS_NT
5011 XSETFASTINT (buffer_local_flags.buffer_file_type, idx);
5012 /* Make this one a permanent local. */
5013 buffer_permanent_local_flags[idx++] = 1;
5014 #endif
5015 XSETFASTINT (buffer_local_flags.syntax_table, idx); ++idx;
5016 XSETFASTINT (buffer_local_flags.cache_long_line_scans, idx); ++idx;
5017 XSETFASTINT (buffer_local_flags.category_table, idx); ++idx;
5018 XSETFASTINT (buffer_local_flags.direction_reversed, idx); ++idx;
5019 XSETFASTINT (buffer_local_flags.buffer_file_coding_system, idx);
5020 /* Make this one a permanent local. */
5021 buffer_permanent_local_flags[idx++] = 1;
5022 XSETFASTINT (buffer_local_flags.left_margin_cols, idx); ++idx;
5023 XSETFASTINT (buffer_local_flags.right_margin_cols, idx); ++idx;
5024 XSETFASTINT (buffer_local_flags.left_fringe_width, idx); ++idx;
5025 XSETFASTINT (buffer_local_flags.right_fringe_width, idx); ++idx;
5026 XSETFASTINT (buffer_local_flags.fringes_outside_margins, idx); ++idx;
5027 XSETFASTINT (buffer_local_flags.scroll_bar_width, idx); ++idx;
5028 XSETFASTINT (buffer_local_flags.vertical_scroll_bar_type, idx); ++idx;
5029 XSETFASTINT (buffer_local_flags.indicate_empty_lines, idx); ++idx;
5030 XSETFASTINT (buffer_local_flags.scroll_up_aggressively, idx); ++idx;
5031 XSETFASTINT (buffer_local_flags.scroll_down_aggressively, idx); ++idx;
5032 XSETFASTINT (buffer_local_flags.header_line_format, idx); ++idx;
5033 XSETFASTINT (buffer_local_flags.cursor_type, idx); ++idx;
5034 XSETFASTINT (buffer_local_flags.extra_line_spacing, idx); ++idx;
5035
5036 /* Need more room? */
5037 if (idx >= MAX_PER_BUFFER_VARS)
5038 abort ();
5039 last_per_buffer_idx = idx;
5040
5041 Vbuffer_alist = Qnil;
5042 current_buffer = 0;
5043 all_buffers = 0;
5044
5045 QSFundamental = build_string ("Fundamental");
5046
5047 Qfundamental_mode = intern ("fundamental-mode");
5048 buffer_defaults.major_mode = Qfundamental_mode;
5049
5050 Qmode_class = intern ("mode-class");
5051
5052 Qprotected_field = intern ("protected-field");
5053
5054 Qpermanent_local = intern ("permanent-local");
5055
5056 Qkill_buffer_hook = intern ("kill-buffer-hook");
5057 Fput (Qkill_buffer_hook, Qpermanent_local, Qt);
5058
5059 Qucs_set_table_for_input = intern ("ucs-set-table-for-input");
5060
5061 Vprin1_to_string_buffer = Fget_buffer_create (build_string (" prin1"));
5062
5063 /* super-magic invisible buffer */
5064 Vbuffer_alist = Qnil;
5065
5066 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5067
5068 inhibit_modification_hooks = 0;
5069 }
5070
5071 void
5072 init_buffer ()
5073 {
5074 char buf[MAXPATHLEN + 1];
5075 char *pwd;
5076 struct stat dotstat, pwdstat;
5077 Lisp_Object temp;
5078 int rc;
5079
5080 #ifdef USE_MMAP_FOR_BUFFERS
5081 {
5082 /* When using the ralloc implementation based on mmap(2), buffer
5083 text pointers will have been set to null in the dumped Emacs.
5084 Map new memory. */
5085 struct buffer *b;
5086
5087 for (b = all_buffers; b; b = b->next)
5088 if (b->text->beg == NULL)
5089 enlarge_buffer_text (b, 0);
5090 }
5091 #endif /* USE_MMAP_FOR_BUFFERS */
5092
5093 Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
5094 if (NILP (buffer_defaults.enable_multibyte_characters))
5095 Fset_buffer_multibyte (Qnil);
5096
5097 /* If PWD is accurate, use it instead of calling getwd. PWD is
5098 sometimes a nicer name, and using it may avoid a fatal error if a
5099 parent directory is searchable but not readable. */
5100 if ((pwd = getenv ("PWD")) != 0
5101 && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
5102 && stat (pwd, &pwdstat) == 0
5103 && stat (".", &dotstat) == 0
5104 && dotstat.st_ino == pwdstat.st_ino
5105 && dotstat.st_dev == pwdstat.st_dev
5106 && strlen (pwd) < MAXPATHLEN)
5107 strcpy (buf, pwd);
5108 #ifdef HAVE_GETCWD
5109 else if (getcwd (buf, MAXPATHLEN+1) == 0)
5110 fatal ("`getcwd' failed: %s\n", strerror (errno));
5111 #else
5112 else if (getwd (buf) == 0)
5113 fatal ("`getwd' failed: %s\n", buf);
5114 #endif
5115
5116 #ifndef VMS
5117 /* Maybe this should really use some standard subroutine
5118 whose definition is filename syntax dependent. */
5119 rc = strlen (buf);
5120 if (!(IS_DIRECTORY_SEP (buf[rc - 1])))
5121 {
5122 buf[rc] = DIRECTORY_SEP;
5123 buf[rc + 1] = '\0';
5124 }
5125 #endif /* not VMS */
5126
5127 current_buffer->directory = build_string (buf);
5128
5129 /* Add /: to the front of the name
5130 if it would otherwise be treated as magic. */
5131 temp = Ffind_file_name_handler (current_buffer->directory, Qt);
5132 if (! NILP (temp)
5133 /* If the default dir is just /, TEMP is non-nil
5134 because of the ange-ftp completion handler.
5135 However, it is not necessary to turn / into /:/.
5136 So avoid doing that. */
5137 && strcmp ("/", SDATA (current_buffer->directory)))
5138 current_buffer->directory
5139 = concat2 (build_string ("/:"), current_buffer->directory);
5140
5141 temp = get_minibuffer (0);
5142 XBUFFER (temp)->directory = current_buffer->directory;
5143 }
5144
5145 /* initialize the buffer routines */
5146 void
5147 syms_of_buffer ()
5148 {
5149 staticpro (&last_overlay_modification_hooks);
5150 last_overlay_modification_hooks
5151 = Fmake_vector (make_number (10), Qnil);
5152
5153 staticpro (&Vbuffer_defaults);
5154 staticpro (&Vbuffer_local_symbols);
5155 staticpro (&Qfundamental_mode);
5156 staticpro (&Qmode_class);
5157 staticpro (&QSFundamental);
5158 staticpro (&Vbuffer_alist);
5159 staticpro (&Qprotected_field);
5160 staticpro (&Qpermanent_local);
5161 staticpro (&Qkill_buffer_hook);
5162 Qoverlayp = intern ("overlayp");
5163 staticpro (&Qoverlayp);
5164 Qevaporate = intern ("evaporate");
5165 staticpro (&Qevaporate);
5166 Qmodification_hooks = intern ("modification-hooks");
5167 staticpro (&Qmodification_hooks);
5168 Qinsert_in_front_hooks = intern ("insert-in-front-hooks");
5169 staticpro (&Qinsert_in_front_hooks);
5170 Qinsert_behind_hooks = intern ("insert-behind-hooks");
5171 staticpro (&Qinsert_behind_hooks);
5172 Qget_file_buffer = intern ("get-file-buffer");
5173 staticpro (&Qget_file_buffer);
5174 Qpriority = intern ("priority");
5175 staticpro (&Qpriority);
5176 Qwindow = intern ("window");
5177 staticpro (&Qwindow);
5178 Qbefore_string = intern ("before-string");
5179 staticpro (&Qbefore_string);
5180 Qafter_string = intern ("after-string");
5181 staticpro (&Qafter_string);
5182 Qfirst_change_hook = intern ("first-change-hook");
5183 staticpro (&Qfirst_change_hook);
5184 Qbefore_change_functions = intern ("before-change-functions");
5185 staticpro (&Qbefore_change_functions);
5186 Qafter_change_functions = intern ("after-change-functions");
5187 staticpro (&Qafter_change_functions);
5188 staticpro (&Qucs_set_table_for_input);
5189
5190 Qkill_buffer_query_functions = intern ("kill-buffer-query-functions");
5191 staticpro (&Qkill_buffer_query_functions);
5192
5193 Fput (Qprotected_field, Qerror_conditions,
5194 Fcons (Qprotected_field, Fcons (Qerror, Qnil)));
5195 Fput (Qprotected_field, Qerror_message,
5196 build_string ("Attempt to modify a protected field"));
5197
5198 /* All these use DEFVAR_LISP_NOPRO because the slots in
5199 buffer_defaults will all be marked via Vbuffer_defaults. */
5200
5201 DEFVAR_LISP_NOPRO ("default-mode-line-format",
5202 &buffer_defaults.mode_line_format,
5203 doc: /* Default value of `mode-line-format' for buffers that don't override it.
5204 This is the same as (default-value 'mode-line-format). */);
5205
5206 DEFVAR_LISP_NOPRO ("default-header-line-format",
5207 &buffer_defaults.header_line_format,
5208 doc: /* Default value of `header-line-format' for buffers that don't override it.
5209 This is the same as (default-value 'header-line-format). */);
5210
5211 DEFVAR_LISP_NOPRO ("default-cursor-type", &buffer_defaults.cursor_type,
5212 doc: /* Default value of `cursor-type' for buffers that don't override it.
5213 This is the same as (default-value 'cursor-type). */);
5214
5215 DEFVAR_LISP_NOPRO ("default-line-spacing",
5216 &buffer_defaults.extra_line_spacing,
5217 doc: /* Default value of `line-spacing' for buffers that don't override it.
5218 This is the same as (default-value 'line-spacing). */);
5219
5220 DEFVAR_LISP_NOPRO ("default-abbrev-mode",
5221 &buffer_defaults.abbrev_mode,
5222 doc: /* Default value of `abbrev-mode' for buffers that do not override it.
5223 This is the same as (default-value 'abbrev-mode). */);
5224
5225 DEFVAR_LISP_NOPRO ("default-ctl-arrow",
5226 &buffer_defaults.ctl_arrow,
5227 doc: /* Default value of `ctl-arrow' for buffers that do not override it.
5228 This is the same as (default-value 'ctl-arrow). */);
5229
5230 DEFVAR_LISP_NOPRO ("default-direction-reversed",
5231 &buffer_defaults.direction_reversed,
5232 doc: /* Default value of `direction-reversed' for buffers that do not override it.
5233 This is the same as (default-value 'direction-reversed). */);
5234
5235 DEFVAR_LISP_NOPRO ("default-enable-multibyte-characters",
5236 &buffer_defaults.enable_multibyte_characters,
5237 doc: /* *Default value of `enable-multibyte-characters' for buffers not overriding it.
5238 This is the same as (default-value 'enable-multibyte-characters). */);
5239
5240 DEFVAR_LISP_NOPRO ("default-buffer-file-coding-system",
5241 &buffer_defaults.buffer_file_coding_system,
5242 doc: /* Default value of `buffer-file-coding-system' for buffers not overriding it.
5243 This is the same as (default-value 'buffer-file-coding-system). */);
5244
5245 DEFVAR_LISP_NOPRO ("default-truncate-lines",
5246 &buffer_defaults.truncate_lines,
5247 doc: /* Default value of `truncate-lines' for buffers that do not override it.
5248 This is the same as (default-value 'truncate-lines). */);
5249
5250 DEFVAR_LISP_NOPRO ("default-fill-column",
5251 &buffer_defaults.fill_column,
5252 doc: /* Default value of `fill-column' for buffers that do not override it.
5253 This is the same as (default-value 'fill-column). */);
5254
5255 DEFVAR_LISP_NOPRO ("default-left-margin",
5256 &buffer_defaults.left_margin,
5257 doc: /* Default value of `left-margin' for buffers that do not override it.
5258 This is the same as (default-value 'left-margin). */);
5259
5260 DEFVAR_LISP_NOPRO ("default-tab-width",
5261 &buffer_defaults.tab_width,
5262 doc: /* Default value of `tab-width' for buffers that do not override it.
5263 This is the same as (default-value 'tab-width). */);
5264
5265 DEFVAR_LISP_NOPRO ("default-case-fold-search",
5266 &buffer_defaults.case_fold_search,
5267 doc: /* Default value of `case-fold-search' for buffers that don't override it.
5268 This is the same as (default-value 'case-fold-search). */);
5269
5270 #ifdef DOS_NT
5271 DEFVAR_LISP_NOPRO ("default-buffer-file-type",
5272 &buffer_defaults.buffer_file_type,
5273 doc: /* Default file type for buffers that do not override it.
5274 This is the same as (default-value 'buffer-file-type).
5275 The file type is nil for text, t for binary. */);
5276 #endif
5277
5278 DEFVAR_LISP_NOPRO ("default-left-margin-width",
5279 &buffer_defaults.left_margin_cols,
5280 doc: /* Default value of `left-margin-width' for buffers that don't override it.
5281 This is the same as (default-value 'left-margin-width). */);
5282
5283 DEFVAR_LISP_NOPRO ("default-right-margin-width",
5284 &buffer_defaults.right_margin_cols,
5285 doc: /* Default value of `right-margin-width' for buffers that don't override it.
5286 This is the same as (default-value 'right-margin-width). */);
5287
5288 DEFVAR_LISP_NOPRO ("default-left-fringe-width",
5289 &buffer_defaults.left_fringe_width,
5290 doc: /* Default value of `left-fringe-width' for buffers that don't override it.
5291 This is the same as (default-value 'left-fringe-width). */);
5292
5293 DEFVAR_LISP_NOPRO ("default-right-fringe-width",
5294 &buffer_defaults.right_fringe_width,
5295 doc: /* Default value of `right-fringe-width' for buffers that don't override it.
5296 This is the same as (default-value 'right-fringe-width). */);
5297
5298 DEFVAR_LISP_NOPRO ("default-fringes-outside-margins",
5299 &buffer_defaults.fringes_outside_margins,
5300 doc: /* Default value of `fringes-outside-margins' for buffers that don't override it.
5301 This is the same as (default-value 'fringes-outside-margins). */);
5302
5303 DEFVAR_LISP_NOPRO ("default-scroll-bar-width",
5304 &buffer_defaults.scroll_bar_width,
5305 doc: /* Default value of `scroll-bar-width' for buffers that don't override it.
5306 This is the same as (default-value 'scroll-bar-width). */);
5307
5308 DEFVAR_LISP_NOPRO ("default-vertical-scroll-bar",
5309 &buffer_defaults.vertical_scroll_bar_type,
5310 doc: /* Default value of `vertical-scroll-bar' for buffers that don't override it.
5311 This is the same as (default-value 'vertical-scroll-bar). */);
5312
5313 DEFVAR_LISP_NOPRO ("default-indicate-empty-lines",
5314 &buffer_defaults.indicate_empty_lines,
5315 doc: /* Default value of `indicate-empty-lines' for buffers that don't override it.
5316 This is the same as (default-value 'indicate-empty-lines). */);
5317
5318 DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
5319 &buffer_defaults.scroll_up_aggressively,
5320 doc: /* Default value of `scroll-up-aggressively'.
5321 This value applies in buffers that don't have their own local values.
5322 This variable is an alias for (default-value 'scroll-up-aggressively). */);
5323
5324 DEFVAR_LISP_NOPRO ("default-scroll-down-aggressively",
5325 &buffer_defaults.scroll_down_aggressively,
5326 doc: /* Default value of `scroll-down-aggressively'.
5327 This value applies in buffers that don't have their own local values.
5328 This variable is an alias for (default-value 'scroll-down-aggressively). */);
5329
5330 DEFVAR_PER_BUFFER ("header-line-format",
5331 &current_buffer->header_line_format,
5332 Qnil,
5333 doc: /* Analogous to `mode-line-format', but controls the header line.
5334 The header line appears, optionally, at the top of a window;
5335 the mode line appears at the bottom. */);
5336
5337 DEFVAR_PER_BUFFER ("mode-line-format", &current_buffer->mode_line_format,
5338 Qnil,
5339 doc: /* Template for displaying mode line for current buffer.
5340 Each buffer has its own value of this variable.
5341 Value may be nil, a string, a symbol or a list or cons cell.
5342 A value of nil means don't display a mode line.
5343 For a symbol, its value is used (but it is ignored if t or nil).
5344 A string appearing directly as the value of a symbol is processed verbatim
5345 in that the %-constructs below are not recognized.
5346 Note that unless the symbol is marked as a `risky-local-variable', all
5347 properties in any strings, as well as all :eval and :propertize forms
5348 in the value of that symbol will be ignored.
5349 For a list of the form `(:eval FORM)', FORM is evaluated and the result
5350 is used as a mode line element. Be careful--FORM should not load any files,
5351 because that can cause an infinite recursion.
5352 For a list of the form `(:propertize ELT PROPS...)', ELT is displayed
5353 with the specified properties PROPS applied.
5354 For a list whose car is a symbol, the symbol's value is taken,
5355 and if that is non-nil, the cadr of the list is processed recursively.
5356 Otherwise, the caddr of the list (if there is one) is processed.
5357 For a list whose car is a string or list, each element is processed
5358 recursively and the results are effectively concatenated.
5359 For a list whose car is an integer, the cdr of the list is processed
5360 and padded (if the number is positive) or truncated (if negative)
5361 to the width specified by that number.
5362 A string is printed verbatim in the mode line except for %-constructs:
5363 (%-constructs are allowed when the string is the entire mode-line-format
5364 or when it is found in a cons-cell or a list)
5365 %b -- print buffer name. %f -- print visited file name.
5366 %F -- print frame name.
5367 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
5368 %& is like %*, but ignore read-only-ness.
5369 % means buffer is read-only and * means it is modified.
5370 For a modified read-only buffer, %* gives % and %+ gives *.
5371 %s -- print process status. %l -- print the current line number.
5372 %c -- print the current column number (this makes editing slower).
5373 To make the column number update correctly in all cases,
5374 `column-number-mode' must be non-nil.
5375 %p -- print percent of buffer above top of window, or Top, Bot or All.
5376 %P -- print percent of buffer above bottom of window, perhaps plus Top,
5377 or print Bottom or All.
5378 %m -- print the mode name.
5379 %n -- print Narrow if appropriate.
5380 %z -- print mnemonics of buffer, terminal, and keyboard coding systems.
5381 %Z -- like %z, but including the end-of-line format.
5382 %[ -- print one [ for each recursive editing level. %] similar.
5383 %% -- print %. %- -- print infinitely many dashes.
5384 Decimal digits after the % specify field width to which to pad. */);
5385
5386 DEFVAR_LISP_NOPRO ("default-major-mode", &buffer_defaults.major_mode,
5387 doc: /* *Major mode for new buffers. Defaults to `fundamental-mode'.
5388 nil here means use current buffer's major mode. */);
5389
5390 DEFVAR_PER_BUFFER ("major-mode", &current_buffer->major_mode,
5391 make_number (Lisp_Symbol),
5392 doc: /* Symbol for current buffer's major mode. */);
5393
5394 DEFVAR_PER_BUFFER ("mode-name", &current_buffer->mode_name,
5395 Qnil,
5396 doc: /* Pretty name of current buffer's major mode (a string). */);
5397
5398 DEFVAR_PER_BUFFER ("abbrev-mode", &current_buffer->abbrev_mode, Qnil,
5399 doc: /* Non-nil turns on automatic expansion of abbrevs as they are inserted. */);
5400
5401 DEFVAR_PER_BUFFER ("case-fold-search", &current_buffer->case_fold_search,
5402 Qnil,
5403 doc: /* *Non-nil if searches and matches should ignore case. */);
5404
5405 DEFVAR_PER_BUFFER ("fill-column", &current_buffer->fill_column,
5406 make_number (Lisp_Int),
5407 doc: /* *Column beyond which automatic line-wrapping should happen.
5408 Interactively, you can set this using \\[set-fill-column]. */);
5409
5410 DEFVAR_PER_BUFFER ("left-margin", &current_buffer->left_margin,
5411 make_number (Lisp_Int),
5412 doc: /* *Column for the default indent-line-function to indent to.
5413 Linefeed indents to this column in Fundamental mode. */);
5414
5415 DEFVAR_PER_BUFFER ("tab-width", &current_buffer->tab_width,
5416 make_number (Lisp_Int),
5417 doc: /* *Distance between tab stops (for display of tab characters), in columns. */);
5418
5419 DEFVAR_PER_BUFFER ("ctl-arrow", &current_buffer->ctl_arrow, Qnil,
5420 doc: /* *Non-nil means display control chars with uparrow.
5421 A value of nil means use backslash and octal digits.
5422 This variable does not apply to characters whose display is specified
5423 in the current display table (if there is one). */);
5424
5425 DEFVAR_PER_BUFFER ("enable-multibyte-characters",
5426 &current_buffer->enable_multibyte_characters,
5427 Qnil,
5428 doc: /* Non-nil means the buffer contents are regarded as multi-byte characters.
5429 Otherwise they are regarded as unibyte. This affects the display,
5430 file I/O and the behavior of various editing commands.
5431
5432 This variable is buffer-local but you cannot set it directly;
5433 use the function `set-buffer-multibyte' to change a buffer's representation.
5434 Changing its default value with `setq-default' is supported.
5435 See also variable `default-enable-multibyte-characters' and Info node
5436 `(elisp)Text Representations'. */);
5437 XSYMBOL (intern ("enable-multibyte-characters"))->constant = 1;
5438
5439 DEFVAR_PER_BUFFER ("buffer-file-coding-system",
5440 &current_buffer->buffer_file_coding_system, Qnil,
5441 doc: /* Coding system to be used for encoding the buffer contents on saving.
5442 This variable applies to saving the buffer, and also to `write-region'
5443 and other functions that use `write-region'.
5444 It does not apply to sending output to subprocesses, however.
5445
5446 If this is nil, the buffer is saved without any code conversion
5447 unless some coding system is specified in `file-coding-system-alist'
5448 for the buffer file.
5449
5450 If the text to be saved cannot be encoded as specified by this variable,
5451 an alternative encoding is selected by `select-safe-coding-system', which see.
5452
5453 The variable `coding-system-for-write', if non-nil, overrides this variable.
5454
5455 This variable is never applied to a way of decoding a file while reading it. */);
5456
5457 DEFVAR_PER_BUFFER ("direction-reversed", &current_buffer->direction_reversed,
5458 Qnil,
5459 doc: /* *Non-nil means lines in the buffer are displayed right to left. */);
5460
5461 DEFVAR_PER_BUFFER ("truncate-lines", &current_buffer->truncate_lines, Qnil,
5462 doc: /* *Non-nil means do not display continuation lines.
5463 Instead, give each line of text just one screen line.
5464
5465 Note that this is overridden by the variable
5466 `truncate-partial-width-windows' if that variable is non-nil
5467 and this buffer is not full-frame width. */);
5468
5469 #ifdef DOS_NT
5470 DEFVAR_PER_BUFFER ("buffer-file-type", &current_buffer->buffer_file_type,
5471 Qnil,
5472 doc: /* Non-nil if the visited file is a binary file.
5473 This variable is meaningful on MS-DOG and Windows NT.
5474 On those systems, it is automatically local in every buffer.
5475 On other systems, this variable is normally always nil. */);
5476 #endif
5477
5478 DEFVAR_PER_BUFFER ("default-directory", &current_buffer->directory,
5479 make_number (Lisp_String),
5480 doc: /* Name of default directory of current buffer. Should end with slash.
5481 To interactively change the default directory, use command `cd'. */);
5482
5483 DEFVAR_PER_BUFFER ("auto-fill-function", &current_buffer->auto_fill_function,
5484 Qnil,
5485 doc: /* Function called (if non-nil) to perform auto-fill.
5486 It is called after self-inserting any character specified in
5487 the `auto-fill-chars' table.
5488 NOTE: This variable is not a hook;
5489 its value may not be a list of functions. */);
5490
5491 DEFVAR_PER_BUFFER ("buffer-file-name", &current_buffer->filename,
5492 make_number (Lisp_String),
5493 doc: /* Name of file visited in current buffer, or nil if not visiting a file. */);
5494
5495 DEFVAR_PER_BUFFER ("buffer-file-truename", &current_buffer->file_truename,
5496 make_number (Lisp_String),
5497 doc: /* Abbreviated truename of file visited in current buffer, or nil if none.
5498 The truename of a file is calculated by `file-truename'
5499 and then abbreviated with `abbreviate-file-name'. */);
5500
5501 DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
5502 &current_buffer->auto_save_file_name,
5503 make_number (Lisp_String),
5504 doc: /* Name of file for auto-saving current buffer.
5505 If it is nil, that means don't auto-save this buffer. */);
5506
5507 DEFVAR_PER_BUFFER ("buffer-read-only", &current_buffer->read_only, Qnil,
5508 doc: /* Non-nil if this buffer is read-only. */);
5509
5510 DEFVAR_PER_BUFFER ("buffer-backed-up", &current_buffer->backed_up, Qnil,
5511 doc: /* Non-nil if this buffer's file has been backed up.
5512 Backing up is done before the first time the file is saved. */);
5513
5514 DEFVAR_PER_BUFFER ("buffer-saved-size", &current_buffer->save_length,
5515 make_number (Lisp_Int),
5516 doc: /* Length of current buffer when last read in, saved or auto-saved.
5517 0 initially. */);
5518
5519 DEFVAR_PER_BUFFER ("selective-display", &current_buffer->selective_display,
5520 Qnil,
5521 doc: /* Non-nil enables selective display.
5522 An Integer N as value means display only lines
5523 that start with less than n columns of space.
5524 A value of t means that the character ^M makes itself and
5525 all the rest of the line invisible; also, when saving the buffer
5526 in a file, save the ^M as a newline. */);
5527
5528 #ifndef old
5529 DEFVAR_PER_BUFFER ("selective-display-ellipses",
5530 &current_buffer->selective_display_ellipses,
5531 Qnil,
5532 doc: /* Non-nil means display ... on previous line when a line is invisible. */);
5533 #endif
5534
5535 DEFVAR_PER_BUFFER ("overwrite-mode", &current_buffer->overwrite_mode, Qnil,
5536 doc: /* Non-nil if self-insertion should replace existing text.
5537 The value should be one of `overwrite-mode-textual',
5538 `overwrite-mode-binary', or nil.
5539 If it is `overwrite-mode-textual', self-insertion still
5540 inserts at the end of a line, and inserts when point is before a tab,
5541 until the tab is filled in.
5542 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too. */);
5543
5544 DEFVAR_PER_BUFFER ("buffer-display-table", &current_buffer->display_table,
5545 Qnil,
5546 doc: /* Display table that controls display of the contents of current buffer.
5547
5548 If this variable is nil, the value of `standard-display-table' is used.
5549 Each window can have its own, overriding display table, see
5550 `set-window-display-table' and `window-display-table'.
5551
5552 The display table is a char-table created with `make-display-table'.
5553 A char-table is an array indexed by character codes. Normal array
5554 primitives `aref' and `aset' can be used to access elements of a char-table.
5555
5556 Each of the char-table elements control how to display the corresponding
5557 text character: the element at index C in the table says how to display
5558 the character whose code is C. Each element should be a vector of
5559 characters or nil. nil means display the character in the default fashion;
5560 otherwise, the characters from the vector are delivered to the screen
5561 instead of the original character.
5562
5563 For example, (aset buffer-display-table ?X ?Y) will cause Emacs to display
5564 a capital Y instead of each X character.
5565
5566 In addition, a char-table has six extra slots to control the display of:
5567
5568 the end of a truncated screen line (extra-slot 0, a single character);
5569 the end of a continued line (extra-slot 1, a single character);
5570 the escape character used to display character codes in octal
5571 (extra-slot 2, a single character);
5572 the character used as an arrow for control characters (extra-slot 3,
5573 a single character);
5574 the decoration indicating the presence of invisible lines (extra-slot 4,
5575 a vector of characters);
5576 the character used to draw the border between side-by-side windows
5577 (extra-slot 5, a single character).
5578
5579 See also the functions `display-table-slot' and `set-display-table-slot'. */);
5580
5581 DEFVAR_PER_BUFFER ("left-margin-width", &current_buffer->left_margin_cols,
5582 Qnil,
5583 doc: /* *Width of left marginal area for display of a buffer.
5584 A value of nil means no marginal area. */);
5585
5586 DEFVAR_PER_BUFFER ("right-margin-width", &current_buffer->right_margin_cols,
5587 Qnil,
5588 doc: /* *Width of right marginal area for display of a buffer.
5589 A value of nil means no marginal area. */);
5590
5591 DEFVAR_PER_BUFFER ("left-fringe-width", &current_buffer->left_fringe_width,
5592 Qnil,
5593 doc: /* *Width of this buffer's left fringe (in pixels).
5594 A value of 0 means no left fringe is shown in this buffer's window.
5595 A value of nil means to use the left fringe width from the window's frame. */);
5596
5597 DEFVAR_PER_BUFFER ("right-fringe-width", &current_buffer->right_fringe_width,
5598 Qnil,
5599 doc: /* *Width of this buffer's right fringe (in pixels).
5600 A value of 0 means no right fringe is shown in this buffer's window.
5601 A value of nil means to use the right fringe width from the window's frame. */);
5602
5603 DEFVAR_PER_BUFFER ("fringes-outside-margins", &current_buffer->fringes_outside_margins,
5604 Qnil,
5605 doc: /* *Non-nil means to display fringes outside display margins.
5606 A value of nil means to display fringes between margins and buffer text. */);
5607
5608 DEFVAR_PER_BUFFER ("scroll-bar-width", &current_buffer->scroll_bar_width,
5609 Qnil,
5610 doc: /* *Width of this buffer's scroll bars in pixels.
5611 A value of nil means to use the scroll bar width from the window's frame. */);
5612
5613 DEFVAR_PER_BUFFER ("vertical-scroll-bar", &current_buffer->vertical_scroll_bar_type,
5614 Qnil,
5615 doc: /* *Position of this buffer's vertical scroll bar.
5616 A value of left or right means to place the vertical scroll bar at that side
5617 of the window; a value of nil means that this window has no vertical scroll bar.
5618 A value of t means to use the vertical scroll bar type from the window's frame. */);
5619
5620 DEFVAR_PER_BUFFER ("indicate-empty-lines",
5621 &current_buffer->indicate_empty_lines, Qnil,
5622 doc: /* *Visually indicate empty lines after the buffer end.
5623 If non-nil, a bitmap is displayed in the left fringe of a window on
5624 window-systems. */);
5625
5626 DEFVAR_PER_BUFFER ("scroll-up-aggressively",
5627 &current_buffer->scroll_up_aggressively, Qnil,
5628 doc: /* How far to scroll windows upward.
5629 If you move point off the bottom, the window scrolls automatically.
5630 This variable controls how far it scrolls. nil, the default,
5631 means scroll to center point. A fraction means scroll to put point
5632 that fraction of the window's height from the bottom of the window.
5633 When the value is 0.0, point goes at the bottom line, which in the simple
5634 case that you moved off with C-f means scrolling just one line. 1.0 means
5635 point goes at the top, so that in that simple case, the window
5636 window scrolls by a full window height. Meaningful values are
5637 between 0.0 and 1.0, inclusive. */);
5638
5639 DEFVAR_PER_BUFFER ("scroll-down-aggressively",
5640 &current_buffer->scroll_down_aggressively, Qnil,
5641 doc: /* How far to scroll windows downward.
5642 If you move point off the top, the window scrolls automatically.
5643 This variable controls how far it scrolls. nil, the default,
5644 means scroll to center point. A fraction means scroll to put point
5645 that fraction of the window's height from the top of the window.
5646 When the value is 0.0, point goes at the top line, which in the simple
5647 case that you moved off with C-b means scrolling just one line. 1.0 means
5648 point goes at the bottom, so that in that simple case, the window
5649 window scrolls by a full window height. Meaningful values are
5650 between 0.0 and 1.0, inclusive. */);
5651
5652 /*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
5653 "Don't ask.");
5654 */
5655
5656 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions,
5657 doc: /* List of functions to call before each text change.
5658 Two arguments are passed to each function: the positions of
5659 the beginning and end of the range of old text to be changed.
5660 \(For an insertion, the beginning and end are at the same place.)
5661 No information is given about the length of the text after the change.
5662
5663 Buffer changes made while executing the `before-change-functions'
5664 don't call any before-change or after-change functions.
5665 That's because these variables are temporarily set to nil.
5666 As a result, a hook function cannot straightforwardly alter the value of
5667 these variables. See the Emacs Lisp manual for a way of
5668 accomplishing an equivalent result by using other variables.
5669
5670 If an unhandled error happens in running these functions,
5671 the variable's value remains nil. That prevents the error
5672 from happening repeatedly and making Emacs nonfunctional. */);
5673 Vbefore_change_functions = Qnil;
5674
5675 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions,
5676 doc: /* List of functions to call after each text change.
5677 Three arguments are passed to each function: the positions of
5678 the beginning and end of the range of changed text,
5679 and the length in bytes of the pre-change text replaced by that range.
5680 \(For an insertion, the pre-change length is zero;
5681 for a deletion, that length is the number of bytes deleted,
5682 and the post-change beginning and end are at the same place.)
5683
5684 Buffer changes made while executing the `after-change-functions'
5685 don't call any before-change or after-change functions.
5686 That's because these variables are temporarily set to nil.
5687 As a result, a hook function cannot straightforwardly alter the value of
5688 these variables. See the Emacs Lisp manual for a way of
5689 accomplishing an equivalent result by using other variables.
5690
5691 If an unhandled error happens in running these functions,
5692 the variable's value remains nil. That prevents the error
5693 from happening repeatedly and making Emacs nonfunctional. */);
5694 Vafter_change_functions = Qnil;
5695
5696 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook,
5697 doc: /* A list of functions to call before changing a buffer which is unmodified.
5698 The functions are run using the `run-hooks' function. */);
5699 Vfirst_change_hook = Qnil;
5700
5701 DEFVAR_PER_BUFFER ("buffer-undo-list", &current_buffer->undo_list, Qnil,
5702 doc: /* List of undo entries in current buffer.
5703 Recent changes come first; older changes follow newer.
5704
5705 An entry (BEG . END) represents an insertion which begins at
5706 position BEG and ends at position END.
5707
5708 An entry (TEXT . POSITION) represents the deletion of the string TEXT
5709 from (abs POSITION). If POSITION is positive, point was at the front
5710 of the text being deleted; if negative, point was at the end.
5711
5712 An entry (t HIGH . LOW) indicates that the buffer previously had
5713 \"unmodified\" status. HIGH and LOW are the high and low 16-bit portions
5714 of the visited file's modification time, as of that time. If the
5715 modification time of the most recent save is different, this entry is
5716 obsolete.
5717
5718 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
5719 was modified between BEG and END. PROPERTY is the property name,
5720 and VALUE is the old value.
5721
5722 An entry (MARKER . DISTANCE) indicates that the marker MARKER
5723 was adjusted in position by the offset DISTANCE (an integer).
5724
5725 An entry of the form POSITION indicates that point was at the buffer
5726 location given by the integer. Undoing an entry of this form places
5727 point at POSITION.
5728
5729 nil marks undo boundaries. The undo command treats the changes
5730 between two undo boundaries as a single step to be undone.
5731
5732 If the value of the variable is t, undo information is not recorded. */);
5733
5734 DEFVAR_PER_BUFFER ("mark-active", &current_buffer->mark_active, Qnil,
5735 doc: /* Non-nil means the mark and region are currently active in this buffer. */);
5736
5737 DEFVAR_PER_BUFFER ("cache-long-line-scans", &current_buffer->cache_long_line_scans, Qnil,
5738 doc: /* Non-nil means that Emacs should use caches to handle long lines more quickly.
5739
5740 Normally, the line-motion functions work by scanning the buffer for
5741 newlines. Columnar operations (like move-to-column and
5742 compute-motion) also work by scanning the buffer, summing character
5743 widths as they go. This works well for ordinary text, but if the
5744 buffer's lines are very long (say, more than 500 characters), these
5745 motion functions will take longer to execute. Emacs may also take
5746 longer to update the display.
5747
5748 If cache-long-line-scans is non-nil, these motion functions cache the
5749 results of their scans, and consult the cache to avoid rescanning
5750 regions of the buffer until the text is modified. The caches are most
5751 beneficial when they prevent the most searching---that is, when the
5752 buffer contains long lines and large regions of characters with the
5753 same, fixed screen width.
5754
5755 When cache-long-line-scans is non-nil, processing short lines will
5756 become slightly slower (because of the overhead of consulting the
5757 cache), and the caches will use memory roughly proportional to the
5758 number of newlines and characters whose screen width varies.
5759
5760 The caches require no explicit maintenance; their accuracy is
5761 maintained internally by the Emacs primitives. Enabling or disabling
5762 the cache should not affect the behavior of any of the motion
5763 functions; it should only affect their performance. */);
5764
5765 DEFVAR_PER_BUFFER ("point-before-scroll", &current_buffer->point_before_scroll, Qnil,
5766 doc: /* Value of point before the last series of scroll operations, or nil. */);
5767
5768 DEFVAR_PER_BUFFER ("buffer-file-format", &current_buffer->file_format, Qnil,
5769 doc: /* List of formats to use when saving this buffer.
5770 Formats are defined by `format-alist'. This variable is
5771 set when a file is visited. */);
5772
5773 DEFVAR_PER_BUFFER ("buffer-invisibility-spec",
5774 &current_buffer->invisibility_spec, Qnil,
5775 doc: /* Invisibility spec of this buffer.
5776 The default is t, which means that text is invisible
5777 if it has a non-nil `invisible' property.
5778 If the value is a list, a text character is invisible if its `invisible'
5779 property is an element in that list.
5780 If an element is a cons cell of the form (PROP . ELLIPSIS),
5781 then characters with property value PROP are invisible,
5782 and they have an ellipsis as well if ELLIPSIS is non-nil. */);
5783
5784 DEFVAR_PER_BUFFER ("buffer-display-count",
5785 &current_buffer->display_count, Qnil,
5786 doc: /* A number incremented each time this buffer is displayed in a window.
5787 The function `set-window-buffer' increments it. */);
5788
5789 DEFVAR_PER_BUFFER ("buffer-display-time",
5790 &current_buffer->display_time, Qnil,
5791 doc: /* Time stamp updated each time this buffer is displayed in a window.
5792 The function `set-window-buffer' updates this variable
5793 to the value obtained by calling `current-time'.
5794 If the buffer has never been shown in a window, the value is nil. */);
5795
5796 DEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode,
5797 doc: /* *Non-nil means deactivate the mark when the buffer contents change.
5798 Non-nil also enables highlighting of the region whenever the mark is active.
5799 The variable `highlight-nonselected-windows' controls whether to highlight
5800 all windows or just the selected window. */);
5801 Vtransient_mark_mode = Qnil;
5802
5803 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only,
5804 doc: /* *Non-nil means disregard read-only status of buffers or characters.
5805 If the value is t, disregard `buffer-read-only' and all `read-only'
5806 text properties. If the value is a list, disregard `buffer-read-only'
5807 and disregard a `read-only' text property if the property value
5808 is a member of the list. */);
5809 Vinhibit_read_only = Qnil;
5810
5811 DEFVAR_PER_BUFFER ("cursor-type", &current_buffer->cursor_type, Qnil,
5812 doc: /* Cursor to use when this buffer is in the selected window.
5813 Values are interpreted as follows:
5814
5815 t use the cursor specified for the frame
5816 nil don't display a cursor
5817 bar display a bar cursor with default width
5818 (bar . WIDTH) display a bar cursor with width WIDTH
5819 ANYTHING ELSE display a box cursor.
5820
5821 When the buffer is displayed in a nonselected window,
5822 this variable has no effect; the cursor appears as a hollow box. */);
5823
5824 DEFVAR_PER_BUFFER ("line-spacing",
5825 &current_buffer->extra_line_spacing, Qnil,
5826 doc: /* Additional space to put between lines when displaying a buffer.
5827 The space is measured in pixels, and put below lines on window systems. */);
5828
5829 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions,
5830 doc: /* List of functions called with no args to query before killing a buffer. */);
5831 Vkill_buffer_query_functions = Qnil;
5832
5833 defsubr (&Sbuffer_live_p);
5834 defsubr (&Sbuffer_list);
5835 defsubr (&Sget_buffer);
5836 defsubr (&Sget_file_buffer);
5837 defsubr (&Sget_buffer_create);
5838 defsubr (&Smake_indirect_buffer);
5839 defsubr (&Sgenerate_new_buffer_name);
5840 defsubr (&Sbuffer_name);
5841 /*defsubr (&Sbuffer_number);*/
5842 defsubr (&Sbuffer_file_name);
5843 defsubr (&Sbuffer_base_buffer);
5844 defsubr (&Sbuffer_local_value);
5845 defsubr (&Sbuffer_local_variables);
5846 defsubr (&Sbuffer_modified_p);
5847 defsubr (&Sset_buffer_modified_p);
5848 defsubr (&Sbuffer_modified_tick);
5849 defsubr (&Srename_buffer);
5850 defsubr (&Sother_buffer);
5851 defsubr (&Sbuffer_disable_undo);
5852 defsubr (&Sbuffer_enable_undo);
5853 defsubr (&Skill_buffer);
5854 defsubr (&Sset_buffer_major_mode);
5855 defsubr (&Sswitch_to_buffer);
5856 defsubr (&Spop_to_buffer);
5857 defsubr (&Scurrent_buffer);
5858 defsubr (&Sset_buffer);
5859 defsubr (&Sbarf_if_buffer_read_only);
5860 defsubr (&Sbury_buffer);
5861 defsubr (&Serase_buffer);
5862 defsubr (&Sset_buffer_multibyte);
5863 defsubr (&Skill_all_local_variables);
5864
5865 defsubr (&Soverlayp);
5866 defsubr (&Smake_overlay);
5867 defsubr (&Sdelete_overlay);
5868 defsubr (&Smove_overlay);
5869 defsubr (&Soverlay_start);
5870 defsubr (&Soverlay_end);
5871 defsubr (&Soverlay_buffer);
5872 defsubr (&Soverlay_properties);
5873 defsubr (&Soverlays_at);
5874 defsubr (&Soverlays_in);
5875 defsubr (&Snext_overlay_change);
5876 defsubr (&Sprevious_overlay_change);
5877 defsubr (&Soverlay_recenter);
5878 defsubr (&Soverlay_lists);
5879 defsubr (&Soverlay_get);
5880 defsubr (&Soverlay_put);
5881 defsubr (&Srestore_buffer_modified_p);
5882 }
5883
5884 void
5885 keys_of_buffer ()
5886 {
5887 initial_define_key (control_x_map, 'b', "switch-to-buffer");
5888 initial_define_key (control_x_map, 'k', "kill-buffer");
5889
5890 /* This must not be in syms_of_buffer, because Qdisabled is not
5891 initialized when that function gets called. */
5892 Fput (intern ("erase-buffer"), Qdisabled, Qt);
5893 }