1 /* Buffer manipulation primitives for XEmacs.
2 Copyright (C) 1985-1989, 1992-1995 Free Software Foundation, Inc.
3 Copyright (C) 1995 Sun Microsystems, Inc.
4 Copyright (C) 1995, 1996 Ben Wing.
5 Copyright (C) 1999,2000,2001 MORIOKA Tomohiko
7 This file is part of XEmacs.
9 XEmacs is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 XEmacs is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with XEmacs; see the file COPYING. If not, write to
21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* Synched up with: Mule 2.0, FSF 19.30. */
29 JWZ: some changes for Lemacs, long ago. (e.g. separate buffer
31 Mly: a few changes for buffer-local vars, 19.8 or 19.9.
32 Ben Wing: some changes and cleanups for Mule, 19.12.
33 MORIOKA Tomohiko: some changes for XEmacs UTF-2000.
36 /* This file contains functions that work with buffer objects.
37 Functions that manipulate a buffer's text, however, are not
40 1) The low-level functions that actually know about the
41 implementation of a buffer's text are located in insdel.c.
42 2) The higher-level (mostly Lisp) functions that manipulate a
43 buffer's text are in editfns.c.
44 3) The highest-level Lisp commands are in cmds.c.
48 -- Functions that know about syntax tables (forward-word,
49 scan-sexps, etc.) are in syntax.c, as are functions
50 that manipulate syntax tables.
51 -- Functions that know about case tables (upcase, downcase,
52 etc.) are in casefiddle.c. Functions that manipulate
53 case tables (case-table-p, set-case-table, etc.) are
55 -- Functions that do searching and replacing are in
56 search.c. The low-level functions that implement
57 regular expressions are in regex.c.
61 -- Some file and process functions (in fileio.c and process.c)
62 copy text from or insert text into a buffer; they call
63 low-level functions in insdel.c to do this.
64 -- insdel.c calls low-level functions in undo.c and extents.c
65 to record buffer modifications for undoing and to handle
66 extent adjustment and extent-data creation and insertion.
81 #include "file-coding.h"
86 #include "process.h" /* for kill_buffer_processes */
87 #ifdef REGION_CACHE_NEEDS_WORK
88 #include "region-cache.h"
90 #include "select.h" /* for select_notify_buffer_kill */
91 #include "specifier.h"
93 #include "sysdep.h" /* for getwd */
98 struct buffer *current_buffer; /* the current buffer */
100 /* This structure holds the default values of the buffer-local variables
101 defined with DEFVAR_BUFFER_LOCAL, that have special slots in each buffer.
102 The default value occupies the same slot in this structure
103 as an individual buffer's value occupies in that buffer.
104 Setting the default value also goes through the alist of buffers
105 and stores into each buffer that does not say it has a local value. */
106 Lisp_Object Vbuffer_defaults;
107 static void *buffer_defaults_saved_slots;
109 /* This structure marks which slots in a buffer have corresponding
110 default values in Vbuffer_defaults.
111 Each such slot has a nonzero value in this structure.
112 The value has only one nonzero bit.
114 When a buffer has its own local value for a slot,
115 the bit for that slot (found in the same slot in this structure)
116 is turned on in the buffer's local_var_flags slot.
118 If a slot in this structure is 0, then there is a DEFVAR_BUFFER_LOCAL
119 for the slot, but there is no default value for it; the corresponding
120 slot in Vbuffer_defaults is not used except to initialize newly-created
123 If a slot is -1, then there is a DEFVAR_BUFFER_LOCAL for it
124 as well as a default value which is used to initialize newly-created
125 buffers and as a reset-value when local-vars are killed.
127 If a slot is -2, there is no DEFVAR_BUFFER_LOCAL for it.
128 (The slot is always local, but there's no lisp variable for it.)
129 The default value is only used to initialize newly-creation buffers.
131 If a slot is -3, then there is no DEFVAR_BUFFER_LOCAL for it but
132 there is a default which is used to initialize newly-creation
133 buffers and as a reset-value when local-vars are killed. */
134 struct buffer buffer_local_flags;
136 /* This is the initial (startup) directory, as used for the *scratch* buffer.
137 We're making this a global to make others aware of the startup directory.
138 `initial_directory' is stored in external format.
140 char initial_directory[MAXPATHLEN+1];
142 /* This structure holds the names of symbols whose values may be
143 buffer-local. It is indexed and accessed in the same way as the above. */
144 static Lisp_Object Vbuffer_local_symbols;
145 static void *buffer_local_symbols_saved_slots;
147 /* Alist of all buffer names vs the buffers. */
148 /* This used to be a variable, but is no longer,
149 to prevent lossage due to user rplac'ing this alist or its elements.
150 Note that there is a per-frame copy of this as well; the frame slot
151 and the global variable contain the same data, but possibly in different
152 orders, so that the buffer ordering can be per-frame.
154 Lisp_Object Vbuffer_alist;
156 /* Functions to call before and after each text change. */
157 Lisp_Object Qbefore_change_functions;
158 Lisp_Object Qafter_change_functions;
159 Lisp_Object Vbefore_change_functions;
160 Lisp_Object Vafter_change_functions;
162 /* #### Obsolete, for compatibility */
163 Lisp_Object Qbefore_change_function;
164 Lisp_Object Qafter_change_function;
165 Lisp_Object Vbefore_change_function;
166 Lisp_Object Vafter_change_function;
169 Lisp_Object Vtransient_mark_mode;
172 /* t means ignore all read-only text properties.
173 A list means ignore such a property if its value is a member of the list.
174 Any non-nil value means ignore buffer-read-only. */
175 Lisp_Object Vinhibit_read_only;
177 /* List of functions to call that can query about killing a buffer.
178 If any of these functions returns nil, we don't kill it. */
179 Lisp_Object Vkill_buffer_query_functions;
181 /* Non-nil means delete a buffer's auto-save file when the buffer is saved. */
182 int delete_auto_save_files;
184 Lisp_Object Qbuffer_live_p;
185 Lisp_Object Qbuffer_or_string_p;
187 /* List of functions to call before changing an unmodified buffer. */
188 Lisp_Object Vfirst_change_hook;
189 Lisp_Object Qfirst_change_hook;
191 Lisp_Object Qfundamental_mode;
192 Lisp_Object Qmode_class;
193 Lisp_Object Qpermanent_local;
195 Lisp_Object Qprotected_field;
197 Lisp_Object QSFundamental; /* A string "Fundamental" */
198 Lisp_Object QSscratch; /* "*scratch*" */
199 Lisp_Object Qdefault_directory;
201 Lisp_Object Qkill_buffer_hook;
203 Lisp_Object Qrename_auto_save_file;
205 Lisp_Object Qget_file_buffer;
206 Lisp_Object Qchange_major_mode_hook, Vchange_major_mode_hook;
208 Lisp_Object Qfind_file_compare_truenames;
210 Lisp_Object Qswitch_to_buffer;
212 /* Two thresholds controlling how much undo information to keep. */
213 Fixnum undo_threshold;
214 Fixnum undo_high_threshold;
216 int find_file_compare_truenames;
217 int find_file_use_truenames;
220 static void reset_buffer_local_variables (struct buffer *, int first_time);
221 static void nuke_all_buffer_slots (struct buffer *b, Lisp_Object zap);
224 make_buffer (struct buffer *buf)
227 XSETBUFFER (obj, buf);
232 mark_buffer (Lisp_Object obj)
234 struct buffer *buf = XBUFFER (obj);
236 /* Truncate undo information. */
237 buf->undo_list = truncate_undo_list (buf->undo_list,
239 undo_high_threshold);
241 #define MARKED_SLOT(x) mark_object (buf->x)
242 #include "bufslots.h"
245 mark_object (buf->extent_info);
247 mark_object (buf->text->line_number_cache);
249 /* Don't mark normally through the children slot.
250 (Actually, in this case, it doesn't matter.) */
251 if (! EQ (buf->indirect_children, Qnull_pointer))
252 mark_conses_in_list (buf->indirect_children);
254 return buf->base_buffer ? make_buffer (buf->base_buffer) : Qnil;
258 print_buffer (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
260 struct buffer *b = XBUFFER (obj);
264 if (!BUFFER_LIVE_P (b))
265 error ("printing unreadable object #<killed buffer>");
267 error ("printing unreadable object #<buffer %s>",
268 XSTRING_DATA (b->name));
270 else if (!BUFFER_LIVE_P (b))
271 write_c_string ("#<killed buffer>", printcharfun);
274 write_c_string ("#<buffer ", printcharfun);
275 print_internal (b->name, printcharfun, 1);
276 write_c_string (">", printcharfun);
280 print_internal (b->name, printcharfun, 0);
284 /* We do not need a finalize method to handle a buffer's children list
285 because all buffers have `kill-buffer' applied to them before
286 they disappear, and the children removal happens then. */
287 DEFINE_LRECORD_IMPLEMENTATION ("buffer", buffer,
288 mark_buffer, print_buffer, 0, 0, 0, 0,
291 DEFUN ("bufferp", Fbufferp, 1, 1, 0, /*
292 Return t if OBJECT is an editor buffer.
296 return BUFFERP (object) ? Qt : Qnil;
299 DEFUN ("buffer-live-p", Fbuffer_live_p, 1, 1, 0, /*
300 Return t if OBJECT is an editor buffer that has not been deleted.
304 return BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object)) ? Qt : Qnil;
308 nsberror (Lisp_Object spec)
311 error ("No buffer named %s", XSTRING_DATA (spec));
312 signal_simple_error ("Invalid buffer argument", spec);
315 DEFUN ("buffer-list", Fbuffer_list, 0, 1, 0, /*
316 Return a list of all existing live buffers.
317 The order is specific to the selected frame; if the optional FRAME
318 argument is provided, the ordering for that frame is returned instead.
319 If the FRAME argument is t, then the global (non-frame) ordering is
324 return Fmapcar (Qcdr,
325 EQ (frame, Qt) ? Vbuffer_alist :
326 decode_frame (frame)->buffer_alist);
330 get_buffer (Lisp_Object name, int error_if_deleted_or_does_not_exist)
334 if (!BUFFER_LIVE_P (XBUFFER (name)))
336 if (error_if_deleted_or_does_not_exist)
348 name = LISP_GETTEXT (name); /* I18N3 */
350 buf = Fcdr (Fassoc (name, Vbuffer_alist));
352 if (NILP (buf) && error_if_deleted_or_does_not_exist)
359 decode_buffer (Lisp_Object buffer, int allow_string)
362 return current_buffer;
364 if (allow_string && STRINGP (buffer))
365 return XBUFFER (get_buffer (buffer, 1));
367 CHECK_LIVE_BUFFER (buffer);
368 return XBUFFER (buffer);
371 DEFUN ("decode-buffer", Fdecode_buffer, 1, 1, 0, /*
372 Validate BUFFER or if BUFFER is nil, return the current buffer.
373 If BUFFER is a valid buffer or a string representing a valid buffer,
374 the corresponding buffer object will be returned. Otherwise an error
379 struct buffer *b = decode_buffer (buffer, 1);
380 XSETBUFFER (buffer, b);
386 /* Like Fassoc, but use Fstring_equal to compare
387 (which ignores text properties),
388 and don't ever QUIT. */
391 assoc_ignore_text_properties (REGISTER Lisp_Object key, Lisp_Object list)
393 REGISTER Lisp_Object tail;
394 for (tail = list; !NILP (tail); tail = Fcdr (tail))
396 REGISTER Lisp_Object elt, tem;
398 tem = Fstring_equal (Fcar (elt), key);
407 DEFUN ("get-buffer", Fget_buffer, 1, 1, 0, /*
408 Return the buffer named BUFFER-NAME (a string), or nil if there is none.
409 BUFFER-NAME may also be a buffer; if so, the value is that buffer.
414 /* #### Doc string should indicate that the buffer name will get
418 /* #### This might return a dead buffer. This is gross. This is
419 called FSF compatibility. */
420 if (BUFFERP (buffer_name))
422 return get_buffer (buffer_name, 0);
423 /* FSFmacs 19.29 calls assoc_ignore_text_properties() here.
428 DEFUN ("get-file-buffer", Fget_file_buffer, 1, 1, 0, /*
429 Return the buffer visiting file FILENAME (a string).
430 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
431 If there is no such live buffer, return nil.
433 Normally, the comparison is done by canonicalizing FILENAME (using
434 `expand-file-name') and comparing that to the value of `buffer-file-name'
435 for each existing buffer. However, If `find-file-compare-truenames' is
436 non-nil, FILENAME will be converted to its truename and the search will be
437 done on each buffer's value of `buffer-file-truename' instead of
438 `buffer-file-name'. Otherwise, if `find-file-use-truenames' is non-nil,
439 FILENAME will be converted to its truename and used for searching, but
440 the search will still be done on `buffer-file-name'.
444 /* This function can GC. GC checked and fixed 7-11-2000 ben. */
445 REGISTER Lisp_Object buf;
449 /* DO NOT translate the filename. */
452 CHECK_STRING (filename);
453 filename = Fexpand_file_name (filename, Qnil);
455 /* If the file name has special constructs in it,
456 call the corresponding file handler. */
457 Lisp_Object handler = Ffind_file_name_handler (filename, Qget_file_buffer);
461 return call2 (handler, Qget_file_buffer, filename);
466 if (find_file_compare_truenames || find_file_use_truenames)
468 struct gcpro ngcpro1, ngcpro2, ngcpro3;
469 Lisp_Object fn = Qnil;
470 Lisp_Object dn = Qnil;
472 NGCPRO3 (fn, dn, filename);
473 fn = Ffile_truename (filename, Qnil);
476 dn = Ffile_name_directory (filename);
477 fn = Ffile_truename (dn, Qnil);
478 if (! NILP (fn)) dn = fn;
479 /* Formerly the two calls below were combined, but that is
480 not GC-safe because the first call returns unprotected
481 data and the second call can GC. --ben */
482 fn = Ffile_name_nondirectory (filename);
483 fn = Fexpand_file_name (fn, dn);
490 LIST_LOOP_2 (elt, Vbuffer_alist)
493 if (!BUFFERP (buf)) continue;
494 if (!STRINGP (XBUFFER (buf)->filename)) continue;
495 if (!NILP (Fstring_equal (filename,
496 (find_file_compare_truenames
497 ? XBUFFER (buf)->file_truename
498 : XBUFFER (buf)->filename))))
507 push_buffer_alist (Lisp_Object name, Lisp_Object buf)
509 Lisp_Object cons = Fcons (name, buf);
510 Lisp_Object frmcons, devcons, concons;
512 Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (cons, Qnil));
513 FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
516 f = XFRAME (XCAR (frmcons));
517 f->buffer_alist = nconc2 (f->buffer_alist, Fcons (cons, Qnil));
522 delete_from_buffer_alist (Lisp_Object buf)
524 Lisp_Object cons = Frassq (buf, Vbuffer_alist);
525 Lisp_Object frmcons, devcons, concons;
527 return; /* abort() ? */
528 Vbuffer_alist = delq_no_quit (cons, Vbuffer_alist);
530 FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
533 f = XFRAME (XCAR (frmcons));
534 f->buffer_alist = delq_no_quit (cons, f->buffer_alist);
539 get_truename_buffer (REGISTER Lisp_Object filename)
541 /* This function can GC. GC correct 7-11-00 ben */
542 /* FSFmacs has its own code here and doesn't call get-file-buffer.
543 That's because their equivalent of find-file-compare-truenames
544 (find-file-existing-other-name) isn't looked at in get-file-buffer.
545 This way is more correct. */
546 int count = specpdl_depth ();
548 specbind (Qfind_file_compare_truenames, Qt);
549 return unbind_to (count, Fget_file_buffer (filename));
552 static struct buffer *
553 allocate_buffer (void)
555 struct buffer *b = alloc_lcrecord_type (struct buffer, &lrecord_buffer);
557 copy_lcrecord (b, XBUFFER (Vbuffer_defaults));
563 finish_init_buffer (struct buffer *b, Lisp_Object name)
569 name = Fcopy_sequence (name);
570 /* #### This really does not need to be called. We already
571 initialized the buffer-local variables in allocate_buffer().
572 local_var_alist is set to Qnil at the same point, in
573 nuke_all_buffer_slots(). */
574 reset_buffer_local_variables (b, 1);
575 b->directory = current_buffer ? current_buffer->directory : Qnil;
577 b->last_window_start = 1;
580 if (string_byte (XSTRING (name), 0) != ' ')
585 /* initialize the extent list */
586 init_buffer_extents (b);
588 /* Put this in the alist of all live buffers. */
589 push_buffer_alist (name, buf);
591 init_buffer_markers (b);
593 b->generated_modeline_string = Fmake_string (make_int (84), make_int (' '));
594 b->modeline_extent_table = make_lisp_hash_table (20, HASH_TABLE_KEY_WEAK,
600 DEFUN ("get-buffer-create", Fget_buffer_create, 1, 1, 0, /*
601 Return the buffer named NAME, or create such a buffer and return it.
602 A new buffer is created if there is no live buffer named NAME.
603 If NAME starts with a space, the new buffer does not keep undo information.
604 If NAME is a buffer instead of a string, then it is the value returned.
605 The value is never nil.
609 /* This function can GC */
611 REGISTER struct buffer *b;
614 /* #### Doc string should indicate that the buffer name will get
618 name = LISP_GETTEXT (name);
619 buf = Fget_buffer (name);
623 if (XSTRING_LENGTH (name) == 0)
624 error ("Empty string for buffer name is not allowed");
626 b = allocate_buffer ();
628 b->text = &b->own_text;
630 b->indirect_children = Qnil;
631 init_buffer_text (b);
633 return finish_init_buffer (b, name);
636 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer, 2, 2,
637 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ", /*
638 Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
639 BASE-BUFFER should be an existing buffer (or buffer name).
640 NAME should be a string which is not the name of an existing buffer.
642 If BASE-BUFFER is itself an indirect buffer, the base buffer for that buffer
643 is made the base buffer for the newly created buffer. (Thus, there will
644 never be indirect buffers whose base buffers are themselves indirect.)
648 /* This function can GC */
650 /* #### The above interactive specification is totally bogus,
651 because it offers an existing buffer as default answer to the
652 second question. However, the second argument may not BE an
656 base_buffer = get_buffer (base_buffer, 1);
659 /* #### Doc string should indicate that the buffer name will get
663 name = LISP_GETTEXT (name);
664 if (!NILP (Fget_buffer (name)))
665 signal_simple_error ("Buffer name already in use", name);
666 if (XSTRING_LENGTH (name) == 0)
667 error ("Empty string for buffer name is not allowed");
669 b = allocate_buffer ();
671 b->base_buffer = BUFFER_BASE_BUFFER (XBUFFER (base_buffer));
673 /* Use the base buffer's text object. */
674 b->text = b->base_buffer->text;
675 b->indirect_children = Qnil;
676 b->base_buffer->indirect_children =
677 Fcons (make_buffer (b), b->base_buffer->indirect_children);
678 init_buffer_text (b);
680 return finish_init_buffer (b, name);
686 reset_buffer_local_variables (struct buffer *b, int first_time)
688 struct buffer *def = XBUFFER (Vbuffer_defaults);
690 b->local_var_flags = 0;
691 /* For each slot that has a default value,
692 copy that into the slot. */
693 #define MARKED_SLOT(slot) \
694 { int mask = XINT (buffer_local_flags.slot); \
695 if ((mask > 0 || mask == -1 || mask == -3) \
697 || NILP (Fget (XBUFFER (Vbuffer_local_symbols)->slot, \
698 Qpermanent_local, Qnil)))) \
699 b->slot = def->slot; \
701 #include "bufslots.h"
706 /* We split this away from generate-new-buffer, because rename-buffer
707 and set-visited-file-name ought to be able to use this to really
708 rename the buffer properly. */
710 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name, 1, 2, 0, /*
711 Return a string that is the name of no existing buffer based on NAME.
712 If there is no live buffer named NAME, then return NAME.
713 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
714 until an unused name is found, and then return that name.
715 Optional second argument IGNORE specifies a name that is okay to use
716 \(if it is in the sequence to be tried)
717 even if a buffer with that name exists.
721 REGISTER Lisp_Object gentemp, tem;
727 name = LISP_GETTEXT (name);
729 /* #### Doc string should indicate that the buffer name will get
733 tem = Fget_buffer (name);
740 sprintf (number, "<%d>", ++count);
741 gentemp = concat2 (name, build_string (number));
744 tem = Fstring_equal (gentemp, ignore);
748 tem = Fget_buffer (gentemp);
755 DEFUN ("buffer-name", Fbuffer_name, 0, 1, 0, /*
756 Return the name of BUFFER, as a string.
757 With no argument or nil as argument, return the name of the current buffer.
761 /* For compatibility, we allow a dead buffer here.
762 Earlier versions of Emacs didn't provide buffer-live-p. */
764 return current_buffer->name;
765 CHECK_BUFFER (buffer);
766 return XBUFFER (buffer)->name;
769 DEFUN ("buffer-file-name", Fbuffer_file_name, 0, 1, 0, /*
770 Return name of file BUFFER is visiting, or nil if none.
771 No argument or nil as argument means use the current buffer.
775 /* For compatibility, we allow a dead buffer here. Yuck! */
777 return current_buffer->filename;
778 CHECK_BUFFER (buffer);
779 return XBUFFER (buffer)->filename;
782 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer, 0, 1, 0, /*
783 Return the base buffer of indirect buffer BUFFER.
784 If BUFFER is not indirect, return nil.
788 struct buffer *buf = decode_buffer (buffer, 0);
790 return buf->base_buffer ? make_buffer (buf->base_buffer) : Qnil;
793 DEFUN ("buffer-indirect-children", Fbuffer_indirect_children, 0, 1, 0, /*
794 Return a list of all indirect buffers whose base buffer is BUFFER.
795 If BUFFER is indirect, the return value will always be nil; see
796 `make-indirect-buffer'.
800 struct buffer *buf = decode_buffer (buffer, 0);
802 return Fcopy_sequence (buf->indirect_children);
805 DEFUN ("buffer-local-variables", Fbuffer_local_variables, 0, 1, 0, /*
806 Return an alist of variables that are buffer-local in BUFFER.
807 Most elements look like (SYMBOL . VALUE), describing one variable.
808 For a symbol that is locally unbound, just the symbol appears in the value.
809 Note that storing new VALUEs in these elements doesn't change the variables.
810 No argument or nil as argument means use current buffer as BUFFER.
814 struct buffer *buf = decode_buffer (buffer, 0);
815 Lisp_Object result = Qnil;
819 for (tail = buf->local_var_alist; CONSP (tail); tail = XCDR (tail))
821 Lisp_Object elt = XCAR (tail);
822 /* Reference each variable in the alist in buf.
823 If inquiring about the current buffer, this gets the current values,
824 so store them into the alist so the alist is up to date.
825 If inquiring about some other buffer, this swaps out any values
826 for that buffer, making the alist up to date automatically. */
827 Lisp_Object val = find_symbol_value (XCAR (elt));
828 /* Use the current buffer value only if buf is the current buffer. */
829 if (buf != current_buffer)
832 /* If symbol is unbound, put just the symbol in the list. */
834 result = Fcons (XCAR (elt), result);
835 /* Otherwise, put (symbol . value) in the list. */
837 result = Fcons (Fcons (XCAR (elt), val), result);
841 /* Add on all the variables stored in special slots. */
843 struct buffer *syms = XBUFFER (Vbuffer_local_symbols);
844 #define MARKED_SLOT(slot) \
845 { int mask = XINT (buffer_local_flags.slot); \
846 if (mask == 0 || mask == -1 \
847 || ((mask > 0) && (buf->local_var_flags & mask))) \
848 result = Fcons (Fcons (syms->slot, buf->slot), result); \
850 #include "bufslots.h"
857 DEFUN ("buffer-modified-p", Fbuffer_modified_p, 0, 1, 0, /*
858 Return t if BUFFER was modified since its file was last read or saved.
859 No argument or nil as argument means use current buffer as BUFFER.
863 struct buffer *buf = decode_buffer (buffer, 0);
865 return BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf) ? Qt : Qnil;
868 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p, 1, 2, 0, /*
869 Mark BUFFER as modified or unmodified according to FLAG.
870 A non-nil FLAG means mark the buffer modified. No argument or nil
871 as BUFFER means use current buffer.
875 /* This function can GC */
876 struct buffer *buf = decode_buffer (buffer, 0);
878 #ifdef CLASH_DETECTION
879 /* If buffer becoming modified, lock the file.
880 If buffer becoming unmodified, unlock the file. */
882 Lisp_Object fn = buf->file_truename;
885 int already = BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf);
886 if (already == NILP (flag))
888 int count = specpdl_depth ();
889 /* lock_file() and unlock_file() currently use current_buffer */
890 /* #### - dmoore, what if lock_file or unlock_file kill
891 the current buffer? */
892 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
893 set_buffer_internal (buf);
894 if (!already && !NILP (flag))
896 else if (already && NILP (flag))
898 unbind_to (count, Qnil);
901 #endif /* CLASH_DETECTION */
903 /* This is often called when the buffer contents are altered but we
904 don't want to treat the changes that way (e.g. selective
905 display). We still need to make sure redisplay realizes that the
906 contents have potentially altered and it needs to do some
908 buf = decode_buffer (buffer, 0);
910 BUF_SAVE_MODIFF (buf) = NILP (flag) ? BUF_MODIFF (buf) : 0;
911 MARK_MODELINE_CHANGED;
916 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick, 0, 1, 0, /*
917 Return BUFFER's tick counter, incremented for each change in text.
918 Each buffer has a tick counter which is incremented each time the text in
919 that buffer is changed. It wraps around occasionally.
920 No argument or nil as argument means use current buffer as BUFFER.
924 struct buffer *buf = decode_buffer (buffer, 0);
926 return make_int (BUF_MODIFF (buf));
929 DEFUN ("rename-buffer", Frename_buffer, 1, 2,
930 "sRename buffer (to new name): \nP", /*
931 Change current buffer's name to NEWNAME (a string).
932 If second arg UNIQUE is nil or omitted, it is an error if a
933 buffer named NEWNAME already exists.
934 If UNIQUE is non-nil, come up with a new name using
935 `generate-new-buffer-name'.
936 Interactively, one can set UNIQUE with a prefix argument.
937 Returns the name we actually gave the buffer.
938 This does not change the name of the visited file (if any).
942 /* This function can GC */
943 Lisp_Object tem, buf;
946 /* #### Doc string should indicate that the buffer name will get
949 CHECK_STRING (newname);
950 newname = LISP_GETTEXT (newname);
952 if (XSTRING_LENGTH (newname) == 0)
953 error ("Empty string is invalid as a buffer name");
955 tem = Fget_buffer (newname);
956 /* Don't short-circuit if UNIQUE is t. That is a useful way to rename
957 the buffer automatically so you can create another with the original name.
958 It makes UNIQUE equivalent to
959 (rename-buffer (generate-new-buffer-name NEWNAME)). */
960 /* XEmacs change: added check for nil */
961 if (NILP (unique) && !NILP (tem) && XBUFFER (tem) == current_buffer)
962 return current_buffer->name;
966 newname = Fgenerate_new_buffer_name (newname, current_buffer->name);
968 error ("Buffer name \"%s\" is in use",
969 XSTRING_DATA (newname));
972 current_buffer->name = newname;
974 /* Catch redisplay's attention. Unless we do this, the modelines for
975 any windows displaying current_buffer will stay unchanged. */
976 MARK_MODELINE_CHANGED;
978 buf = Fcurrent_buffer ();
980 /* The aconses in the Vbuffer_alist are shared with frame->buffer_alist,
981 so this will change it in the per-frame ordering as well. */
982 Fsetcar (Frassq (buf, Vbuffer_alist), newname);
984 if (NILP (current_buffer->filename)
985 && !NILP (current_buffer->auto_save_file_name))
986 call0 (Qrename_auto_save_file);
987 /* refetch since that last call may have done GC */
988 /* (hypothetical relocating GC) */
989 return current_buffer->name;
992 DEFUN ("other-buffer", Fother_buffer, 0, 3, 0, /*
993 Return most recently selected buffer other than BUFFER.
994 Buffers not visible in windows are preferred to visible buffers,
995 unless optional third argument VISIBLE-OK is non-nil.
996 If no other buffer exists, the buffer `*scratch*' is returned.
997 If BUFFER is omitted or nil, some interesting buffer is returned.
999 The ordering is for this frame; If second optional argument FRAME
1000 is provided, then the ordering is for that frame. If the second arg
1001 is t, then the global ordering is returned.
1003 Note: In FSF Emacs, this function takes two arguments: BUFFER and
1006 (buffer, frame, visible_ok))
1008 /* This function can GC */
1009 Lisp_Object tail, buf, notsogood, tem;
1015 alist = Vbuffer_alist;
1018 struct frame *f = decode_frame (frame);
1020 XSETFRAME (frame, f);
1021 alist = f->buffer_alist;
1024 for (tail = alist; !NILP (tail); tail = Fcdr (tail))
1026 buf = Fcdr (Fcar (tail));
1027 if (EQ (buf, buffer))
1029 if (string_byte (XSTRING (XBUFFER (buf)->name), 0) == ' ')
1031 /* If FRAME has a buffer_predicate,
1032 disregard buffers that don't fit the predicate. */
1035 tem = XFRAME (frame)->buffer_predicate;
1038 tem = call1 (tem, buf);
1044 if (NILP (visible_ok))
1046 /* get-buffer-window will handle nil or t frame */
1047 tem = Fget_buffer_window (buf, frame, Qnil);
1053 if (NILP (notsogood))
1056 if (!NILP (notsogood))
1058 return Fget_buffer_create (QSscratch);
1061 DEFUN ("buffer-disable-undo", Fbuffer_disable_undo, 0, 1, "", /*
1062 Stop keeping undo information for BUFFER.
1063 Any undo records it already has are discarded.
1064 No argument or nil as argument means do this for the current buffer.
1068 /* Allowing nil is an RMSism */
1069 struct buffer *real_buf = decode_buffer (buffer, 1);
1070 real_buf->undo_list = Qt;
1074 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo, 0, 1, "", /*
1075 Start keeping undo information for BUFFER.
1076 No argument or nil as argument means do this for the current buffer.
1080 /* Allowing nil is an RMSism */
1081 struct buffer *real_buf = decode_buffer (buffer, 1);
1082 if (EQ (real_buf->undo_list, Qt))
1083 real_buf->undo_list = Qnil;
1088 DEFUN ("kill-buffer", Fkill_buffer, 1, 1, "bKill buffer: ", /*
1089 Kill the buffer BUFFER.
1090 The argument may be a buffer or may be the name of a buffer.
1091 An argument of nil means kill the current buffer.
1093 Value is t if the buffer is actually killed, nil if user says no.
1095 The value of `kill-buffer-hook' (which may be local to that buffer),
1096 if not void, is a list of functions to be called, with no arguments,
1097 before the buffer is actually killed. The buffer to be killed is current
1098 when the hook functions are called.
1100 Any processes that have this buffer as the `process-buffer' are killed
1101 with `delete-process'.
1105 /* This function can call lisp */
1107 REGISTER struct buffer *b;
1108 struct gcpro gcpro1, gcpro2;
1111 buf = Fcurrent_buffer ();
1112 else if (BUFFERP (buffer))
1116 buf = get_buffer (buffer, 0);
1117 if (NILP (buf)) nsberror (buffer);
1122 /* OK to delete an already-deleted buffer. */
1123 if (!BUFFER_LIVE_P (b))
1126 /* Don't kill the minibuffer now current. */
1127 if (EQ (buf, Vminibuffer_zero))
1130 /* Or the echo area. */
1131 if (EQ (buf, Vecho_area_buffer))
1134 /* Query if the buffer is still modified. */
1135 if (INTERACTIVE && !NILP (b->filename)
1136 && BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
1142 (emacs_doprnt_string_c
1143 ((const Bufbyte *) GETTEXT ("Buffer %s modified; kill anyway? "),
1144 Qnil, -1, XSTRING_DATA (b->name))));
1148 b = XBUFFER (buf); /* Hypothetical relocating GC. */
1151 /* Run hooks with the buffer to be killed temporarily selected,
1152 unless the buffer is already dead (could have been deleted
1153 in the question above).
1155 if (BUFFER_LIVE_P (b))
1157 int speccount = specpdl_depth ();
1158 Lisp_Object tail = Qnil;
1161 record_unwind_protect (save_excursion_restore, save_excursion_save ());
1164 /* First run the query functions; if any query is answered no,
1165 don't kill the buffer. */
1166 EXTERNAL_LIST_LOOP (tail, Vkill_buffer_query_functions)
1168 if (NILP (call0 (Fcar (tail))))
1171 return unbind_to (speccount, Qnil);
1175 /* Then run the hooks. */
1176 run_hook (Qkill_buffer_hook);
1178 /* Inform the selection code that a buffer just got killed.
1179 We do this in C because (a) it's faster, and (b) it needs
1180 to access data internal to select.c that can't be seen from
1181 Lisp (so the Lisp code would just call into C anyway. */
1182 select_notify_buffer_kill (buf);
1184 unbind_to (speccount, Qnil);
1186 b = XBUFFER (buf); /* Hypothetical relocating GC. */
1189 /* We have no more questions to ask. Verify that it is valid
1190 to kill the buffer. This must be done after the questions
1191 since anything can happen within yes-or-no-p. */
1193 /* Might have been deleted during the last question above */
1194 if (!BUFFER_LIVE_P (b))
1197 /* Don't kill the minibuffer now current. */
1198 if (EQ (buf, XWINDOW (minibuf_window)->buffer))
1201 /* When we kill a base buffer, kill all its indirect buffers.
1202 We do it at this stage so nothing terrible happens if they
1203 ask questions or their hooks get errors. */
1204 if (! b->base_buffer)
1210 LIST_LOOP (rest, b->indirect_children)
1212 Fkill_buffer (XCAR (rest));
1213 /* Keep indirect_children updated in case a
1214 query-function/hook throws. */
1215 b->indirect_children = XCDR (rest);
1221 /* Make this buffer not be current.
1222 In the process, notice if this is the sole visible buffer
1223 and give up if so. */
1224 if (b == current_buffer)
1226 Fset_buffer (Fother_buffer (buf, Qnil, Qnil));
1227 if (b == current_buffer)
1231 /* Now there is no question: we can kill the buffer. */
1233 #ifdef CLASH_DETECTION
1234 /* Unlock this buffer's file, if it is locked. unlock_buffer
1235 can both GC and kill the current buffer, and wreak general
1236 havok by running lisp code. */
1242 if (!BUFFER_LIVE_P (b))
1245 if (b == current_buffer)
1247 Fset_buffer (Fother_buffer (buf, Qnil, Qnil));
1248 if (b == current_buffer)
1251 #endif /* CLASH_DETECTION */
1254 int speccount = specpdl_depth ();
1255 specbind (Qinhibit_quit, Qt);
1257 kill_buffer_processes (buf);
1259 delete_from_buffer_alist (buf);
1261 /* #### This is a problem if this buffer is in a dedicated window.
1262 Need to undedicate any windows of this buffer first (and delete them?)
1265 Freplace_buffer_in_windows (buf, Qnil, Qall);
1268 font_lock_buffer_was_killed (b);
1270 /* Delete any auto-save file, if we saved it in this session. */
1271 if (STRINGP (b->auto_save_file_name)
1272 && b->auto_save_modified != 0
1273 && BUF_SAVE_MODIFF (b) < b->auto_save_modified)
1275 if (delete_auto_save_files != 0)
1277 /* deleting the auto save file might kill b! */
1278 /* #### dmoore - fix this crap, we do this same gcpro and
1279 buffer liveness check multiple times. Let's get a
1280 macro or something for it. */
1282 internal_delete_file (b->auto_save_file_name);
1286 if (!BUFFER_LIVE_P (b))
1289 if (b == current_buffer)
1291 Fset_buffer (Fother_buffer (buf, Qnil, Qnil));
1292 if (b == current_buffer)
1298 uninit_buffer_markers (b);
1300 kill_buffer_local_variables (b);
1303 uninit_buffer_text (b);
1304 b->undo_list = Qnil;
1305 uninit_buffer_extents (b);
1308 #ifdef ERROR_CHECK_BUFPOS
1309 assert (!NILP (memq_no_quit (buf, b->base_buffer->indirect_children)));
1311 b->base_buffer->indirect_children =
1312 delq_no_quit (buf, b->base_buffer->indirect_children);
1315 /* Clear away all Lisp objects, so that they
1316 won't be protected from GC. */
1317 nuke_all_buffer_slots (b, Qnil);
1319 unbind_to (speccount, Qnil);
1324 DEFUN ("record-buffer", Frecord_buffer, 1, 1, 0, /*
1325 Place buffer BUFFER first in the buffer order.
1326 Call this function when a buffer is selected "visibly".
1328 This function changes the global buffer order and the per-frame buffer
1329 order for the selected frame. The buffer order keeps track of recency
1330 of selection so that `other-buffer' will return a recently selected
1331 buffer. See `other-buffer' for more information.
1335 REGISTER Lisp_Object lynk, prev;
1336 struct frame *f = selected_frame ();
1339 for (lynk = Vbuffer_alist; CONSP (lynk); lynk = XCDR (lynk))
1341 if (EQ (XCDR (XCAR (lynk)), buffer))
1345 /* Effectively do Vbuffer_alist = delq_no_quit (lynk, Vbuffer_alist) */
1347 Vbuffer_alist = XCDR (Vbuffer_alist);
1349 XCDR (prev) = XCDR (XCDR (prev));
1350 XCDR (lynk) = Vbuffer_alist;
1351 Vbuffer_alist = lynk;
1353 /* That was the global one. Now do the same thing for the
1354 per-frame buffer-alist. */
1356 for (lynk = f->buffer_alist; CONSP (lynk); lynk = XCDR (lynk))
1358 if (EQ (XCDR (XCAR (lynk)), buffer))
1362 /* Effectively do f->buffer_alist = delq_no_quit (lynk, f->buffer_alist) */
1364 f->buffer_alist = XCDR (f->buffer_alist);
1366 XCDR (prev) = XCDR (XCDR (prev));
1367 XCDR (lynk) = f->buffer_alist;
1368 f->buffer_alist = lynk;
1373 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode, 1, 1, 0, /*
1374 Set an appropriate major mode for BUFFER, according to `default-major-mode'.
1375 Use this function before selecting the buffer, since it may need to inspect
1376 the current buffer's major mode.
1380 int speccount = specpdl_depth ();
1381 Lisp_Object function = XBUFFER (Vbuffer_defaults)->major_mode;
1383 if (NILP (function))
1385 Lisp_Object tem = Fget (current_buffer->major_mode, Qmode_class, Qnil);
1387 function = current_buffer->major_mode;
1390 if (NILP (function) || EQ (function, Qfundamental_mode))
1393 /* To select a nonfundamental mode,
1394 select the buffer temporarily and then call the mode function. */
1396 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
1398 Fset_buffer (buffer);
1401 return unbind_to (speccount, Qnil);
1405 switch_to_buffer (Lisp_Object bufname, Lisp_Object norecord)
1407 call2 (Qswitch_to_buffer, bufname, norecord);
1411 DEFUN ("current-buffer", Fcurrent_buffer, 0, 0, 0, /*
1412 Return the current buffer as a Lisp object.
1417 XSETBUFFER (buffer, current_buffer);
1421 /* Set the current buffer to B. */
1424 set_buffer_internal (struct buffer *b)
1426 REGISTER struct buffer *old_buf;
1427 REGISTER Lisp_Object tail;
1429 if (current_buffer == b)
1432 INVALIDATE_PIXEL_TO_GLYPH_CACHE;
1434 old_buf = current_buffer;
1436 invalidate_current_column (); /* invalidate indentation cache */
1440 /* Put the undo list back in the base buffer, so that it appears
1441 that an indirect buffer shares the undo list of its base. */
1442 if (old_buf->base_buffer)
1443 old_buf->base_buffer->undo_list = old_buf->undo_list;
1446 /* Get the undo list from the base buffer, so that it appears
1447 that an indirect buffer shares the undo list of its base. */
1449 b->undo_list = b->base_buffer->undo_list;
1451 /* Look down buffer's list of local Lisp variables
1452 to find and update any that forward into C variables. */
1454 LIST_LOOP (tail, b->local_var_alist)
1456 Lisp_Object sym = XCAR (XCAR (tail));
1457 Lisp_Object valcontents = XSYMBOL (sym)->value;
1458 if (SYMBOL_VALUE_MAGIC_P (valcontents))
1460 /* Just reference the variable
1461 to cause it to become set for this buffer. */
1462 /* Use find_symbol_value_quickly to avoid an unnecessary O(n)
1464 (void) find_symbol_value_quickly (XCAR (tail), 1);
1468 /* Do the same with any others that were local to the previous buffer */
1472 LIST_LOOP (tail, old_buf->local_var_alist)
1474 Lisp_Object sym = XCAR (XCAR (tail));
1475 Lisp_Object valcontents = XSYMBOL (sym)->value;
1477 if (SYMBOL_VALUE_MAGIC_P (valcontents))
1479 /* Just reference the variable
1480 to cause it to become set for this buffer. */
1481 /* Use find_symbol_value_quickly with find_it_p as 0 to avoid an
1482 unnecessary O(n) lookup which is guaranteed to be worst case.
1483 Any symbols which are local are guaranteed to have been
1484 handled in the previous loop, above. */
1485 (void) find_symbol_value_quickly (sym, 0);
1491 DEFUN ("set-buffer", Fset_buffer, 1, 1, 0, /*
1492 Make the buffer BUFFER current for editing operations.
1493 BUFFER may be a buffer or the name of an existing buffer.
1494 See also `save-excursion' when you want to make a buffer current temporarily.
1495 This function does not display the buffer, so its effect ends
1496 when the current command terminates.
1497 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.
1501 buffer = get_buffer (buffer, 0);
1503 error ("Selecting deleted or non-existent buffer");
1504 set_buffer_internal (XBUFFER (buffer));
1509 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only, 0, 3, 0, /*
1510 Signal a `buffer-read-only' error if BUFFER is read-only.
1511 Optional argument BUFFER defaults to the current buffer.
1513 If optional argument START is non-nil, all extents in the buffer
1514 which overlap that part of the buffer are checked to ensure none has a
1515 `read-only' property. (Extents that lie completely within the range,
1516 however, are not checked.) END defaults to the value of START.
1518 If START and END are equal, the range checked is [START, END] (i.e.
1519 closed on both ends); otherwise, the range checked is (START, END)
1520 \(open on both ends), except that extents that lie completely within
1521 [START, END] are not checked. See `extent-in-region-p' for a fuller
1524 (buffer, start, end))
1526 struct buffer *b = decode_buffer (buffer, 0);
1535 get_buffer_range_char (b, start, end, &s, &e, 0);
1537 barf_if_buffer_read_only (b, s, e);
1543 bury_buffer_1 (Lisp_Object buffer, Lisp_Object before,
1544 Lisp_Object *buffer_alist)
1546 Lisp_Object aelt = rassq_no_quit (buffer, *buffer_alist);
1547 Lisp_Object lynk = memq_no_quit (aelt, *buffer_alist);
1548 Lisp_Object iter, before_before;
1550 *buffer_alist = delq_no_quit (aelt, *buffer_alist);
1551 for (before_before = Qnil, iter = *buffer_alist;
1552 !NILP (iter) && !EQ (XCDR (XCAR (iter)), before);
1553 before_before = iter, iter = XCDR (iter))
1556 if (!NILP (before_before))
1557 XCDR (before_before) = lynk;
1559 *buffer_alist = lynk;
1562 DEFUN ("bury-buffer", Fbury_buffer, 0, 2, "", /*
1563 Put BUFFER at the end of the list of all buffers.
1564 There it is the least likely candidate for `other-buffer' to return;
1565 thus, the least likely buffer for \\[switch-to-buffer] to select by default.
1566 If BUFFER is nil or omitted, bury the current buffer.
1567 Also, if BUFFER is nil or omitted, remove the current buffer from the
1568 selected window if it is displayed there.
1569 Because of this, you may need to specify (current-buffer) as
1570 BUFFER when calling from minibuffer.
1571 If BEFORE is non-nil, it specifies a buffer before which BUFFER
1572 will be placed, instead of being placed at the end.
1576 /* This function can GC */
1577 struct buffer *buf = decode_buffer (buffer, 1);
1578 /* If we're burying the current buffer, unshow it. */
1579 /* Note that the behavior of (bury-buffer nil) and
1580 (bury-buffer (current-buffer)) is not the same.
1581 This is illogical but is historical. Changing it
1582 breaks mh-e and TeX and such packages. */
1584 switch_to_buffer (Fother_buffer (Fcurrent_buffer (), Qnil, Qnil), Qnil);
1585 XSETBUFFER (buffer, buf);
1588 before = get_buffer (before, 1);
1590 if (EQ (before, buffer))
1591 error ("Cannot place a buffer before itself");
1593 bury_buffer_1 (buffer, before, &Vbuffer_alist);
1594 bury_buffer_1 (buffer, before, &selected_frame ()->buffer_alist);
1600 DEFUN ("erase-buffer", Ferase_buffer, 0, 1, "*", /*
1601 Delete the entire contents of the BUFFER.
1602 Any clipping restriction in effect (see `narrow-to-region') is removed,
1603 so the buffer is truly empty after this.
1604 BUFFER defaults to the current buffer if omitted.
1608 /* This function can GC */
1609 struct buffer *b = decode_buffer (buffer, 1);
1610 /* #### yuck yuck yuck. This is gross. The old echo-area code,
1611 however, was the only place that called erase_buffer() with a
1612 non-zero NO_CLIP argument.
1614 Someone needs to fix up the redisplay code so it is smarter
1615 about this, so that the NO_CLIP junk isn't necessary. */
1616 int no_clip = (b == XBUFFER (Vecho_area_buffer));
1618 INVALIDATE_PIXEL_TO_GLYPH_CACHE;
1620 widen_buffer (b, no_clip);
1621 buffer_delete_range (b, BUF_BEG (b), BUF_Z (b), 0);
1622 b->last_window_start = 1;
1624 /* Prevent warnings, or suspension of auto saving, that would happen
1625 if future size is less than past size. Use of erase-buffer
1626 implies that the future text is not really related to the past text. */
1627 b->saved_size = Qzero;
1629 zmacs_region_stays = 0;
1635 DEFUN ("kill-all-local-variables", Fkill_all_local_variables, 0, 0, 0, /*
1636 Switch to Fundamental mode by killing current buffer's local variables.
1637 Most local variable bindings are eliminated so that the default values
1638 become effective once more. Also, the syntax table is set from
1639 `standard-syntax-table', the category table is set from
1640 `standard-category-table' (if support for Mule exists), local keymap is set
1641 to nil, the abbrev table is set from `fundamental-mode-abbrev-table',
1642 and all specifier specifications whose locale is the current buffer
1643 are removed. This function also forces redisplay of the modeline.
1645 Every function to select a new major mode starts by
1646 calling this function.
1648 As a special exception, local variables whose names have
1649 a non-nil `permanent-local' property are not eliminated by this function.
1651 The first thing this function does is run
1652 the normal hook `change-major-mode-hook'.
1656 /* This function can GC */
1657 run_hook (Qchange_major_mode_hook);
1659 reset_buffer_local_variables (current_buffer, 0);
1661 kill_buffer_local_variables (current_buffer);
1663 kill_specifier_buffer_locals (Fcurrent_buffer ());
1665 /* Force modeline redisplay. Useful here because all major mode
1666 commands call this function. */
1667 MARK_MODELINE_CHANGED;
1672 #ifdef MEMORY_USAGE_STATS
1683 compute_buffer_text_usage (struct buffer *b, struct overhead_stats *ovstats)
1685 int was_requested = b->text->z - 1;
1686 size_t gap = b->text->gap_size + b->text->end_gap_size;
1687 size_t malloc_use = malloced_storage_size (b->text->beg, was_requested + gap, 0);
1689 ovstats->gap_overhead += gap;
1690 ovstats->was_requested += was_requested;
1691 ovstats->malloc_overhead += malloc_use - (was_requested + gap);
1696 compute_buffer_usage (struct buffer *b, struct buffer_stats *stats,
1697 struct overhead_stats *ovstats)
1700 stats->other += malloced_storage_size (b, sizeof (*b), ovstats);
1701 stats->text += compute_buffer_text_usage (b, ovstats);
1702 stats->markers += compute_buffer_marker_usage (b, ovstats);
1703 stats->extents += compute_buffer_extent_usage (b, ovstats);
1706 DEFUN ("buffer-memory-usage", Fbuffer_memory_usage, 1, 1, 0, /*
1707 Return stats about the memory usage of buffer BUFFER.
1708 The values returned are in the form of an alist of usage types and byte
1709 counts. The byte counts attempt to encompass all the memory used
1710 by the buffer (separate from the memory logically associated with a
1711 buffer or frame), including internal structures and any malloc()
1712 overhead associated with them. In practice, the byte counts are
1713 underestimated because certain memory usage is very hard to determine
1714 \(e.g. the amount of memory used inside the Xt library or inside the
1715 X server) and because there is other stuff that might logically
1716 be associated with a window, buffer, or frame (e.g. window configurations,
1717 glyphs) but should not obviously be included in the usage counts.
1719 Multiple slices of the total memory usage may be returned, separated
1720 by a nil. Each slice represents a particular view of the memory, a
1721 particular way of partitioning it into groups. Within a slice, there
1722 is no overlap between the groups of memory, and each slice collectively
1723 represents all the memory concerned.
1727 struct buffer_stats stats;
1728 struct overhead_stats ovstats;
1729 Lisp_Object val = Qnil;
1731 CHECK_BUFFER (buffer); /* dead buffers should be allowed, no? */
1733 compute_buffer_usage (XBUFFER (buffer), &stats, &ovstats);
1735 val = acons (Qtext, make_int (stats.text), val);
1736 val = acons (Qmarkers, make_int (stats.markers), val);
1737 val = acons (Qextents, make_int (stats.extents), val);
1738 val = acons (Qother, make_int (stats.other), val);
1739 val = Fcons (Qnil, val);
1740 val = acons (Qactually_requested, make_int (ovstats.was_requested), val);
1741 val = acons (Qmalloc_overhead, make_int (ovstats.malloc_overhead), val);
1742 val = acons (Qgap_overhead, make_int (ovstats.gap_overhead), val);
1743 val = acons (Qdynarr_overhead, make_int (ovstats.dynarr_overhead), val);
1745 return Fnreverse (val);
1748 #endif /* MEMORY_USAGE_STATS */
1751 /************************************************************************/
1752 /* Implement TO_EXTERNAL_FORMAT, TO_INTERNAL_FORMAT */
1753 /************************************************************************/
1755 /* This implementation should probably be elsewhere, but it can't be
1756 in file-coding.c since that file is only available if FILE_CODING
1760 coding_system_is_binary (Lisp_Object coding_system)
1762 Lisp_Coding_System *cs = XCODING_SYSTEM (coding_system);
1764 (CODING_SYSTEM_TYPE (cs) == CODESYS_NO_CONVERSION &&
1765 CODING_SYSTEM_EOL_TYPE (cs) == EOL_LF &&
1766 EQ (CODING_SYSTEM_POST_READ_CONVERSION (cs), Qnil) &&
1767 EQ (CODING_SYSTEM_PRE_WRITE_CONVERSION (cs), Qnil));
1770 #define coding_system_is_binary(coding_system) 1
1775 Dynarr_declare (Bufbyte_dynarr *);
1776 } Bufbyte_dynarr_dynarr;
1780 Dynarr_declare (Extbyte_dynarr *);
1781 } Extbyte_dynarr_dynarr;
1783 static Extbyte_dynarr_dynarr *conversion_out_dynarr_list;
1784 static Bufbyte_dynarr_dynarr *conversion_in_dynarr_list;
1786 static int dfc_convert_to_external_format_in_use;
1787 static int dfc_convert_to_internal_format_in_use;
1790 dfc_convert_to_external_format_reset_in_use (Lisp_Object value)
1792 dfc_convert_to_external_format_in_use = XINT (value);
1797 dfc_convert_to_internal_format_reset_in_use (Lisp_Object value)
1799 dfc_convert_to_internal_format_in_use = XINT (value);
1804 dfc_convert_to_external_format (dfc_conversion_type source_type,
1805 dfc_conversion_data *source,
1807 Lisp_Object coding_system,
1809 dfc_conversion_type sink_type,
1810 dfc_conversion_data *sink)
1812 int count = specpdl_depth ();
1813 Extbyte_dynarr *conversion_out_dynarr;
1815 type_checking_assert
1816 (((source_type == DFC_TYPE_DATA) ||
1817 (source_type == DFC_TYPE_LISP_LSTREAM && LSTREAMP (source->lisp_object)) ||
1818 (source_type == DFC_TYPE_LISP_STRING && STRINGP (source->lisp_object)))
1820 ((sink_type == DFC_TYPE_DATA) ||
1821 (sink_type == DFC_TYPE_LISP_LSTREAM && LSTREAMP (source->lisp_object))));
1823 record_unwind_protect (dfc_convert_to_external_format_reset_in_use,
1824 make_int (dfc_convert_to_external_format_in_use));
1825 if (Dynarr_length (conversion_out_dynarr_list) <=
1826 dfc_convert_to_external_format_in_use)
1827 Dynarr_add (conversion_out_dynarr_list, Dynarr_new (Extbyte));
1828 conversion_out_dynarr = Dynarr_at (conversion_out_dynarr_list,
1829 dfc_convert_to_external_format_in_use);
1830 dfc_convert_to_external_format_in_use++;
1831 Dynarr_reset (conversion_out_dynarr);
1834 coding_system = Fget_coding_system (coding_system);
1837 /* Here we optimize in the case where the coding system does no
1838 conversion. However, we don't want to optimize in case the source
1839 or sink is an lstream, since writing to an lstream can cause a
1840 garbage collection, and this could be problematic if the source
1841 is a lisp string. */
1842 if (source_type != DFC_TYPE_LISP_LSTREAM &&
1843 sink_type != DFC_TYPE_LISP_LSTREAM &&
1844 coding_system_is_binary (coding_system))
1849 if (source_type == DFC_TYPE_LISP_STRING)
1851 ptr = XSTRING_DATA (source->lisp_object);
1852 len = XSTRING_LENGTH (source->lisp_object);
1856 ptr = (Bufbyte *) source->data.ptr;
1857 len = source->data.len;
1863 for (end = ptr + len; ptr < end;)
1867 (*ptr < 0xc0) ? *ptr :
1868 ((*ptr & 0x1f) << 6) | (*(ptr+1) & 0x3f);
1871 (BYTE_ASCII_P (*ptr)) ? *ptr :
1872 (*ptr == LEADING_BYTE_CONTROL_1) ? (*(ptr+1) - 0x20) :
1873 (*ptr == LEADING_BYTE_LATIN_ISO8859_1) ? (*(ptr+1)) :
1877 Dynarr_add (conversion_out_dynarr, (Extbyte) c);
1880 bufpos_checking_assert (ptr == end);
1883 Dynarr_add_many (conversion_out_dynarr, ptr, len);
1889 Lisp_Object streams_to_delete[3];
1890 int delete_count = 0;
1891 Lisp_Object instream, outstream;
1892 Lstream *reader, *writer;
1893 struct gcpro gcpro1, gcpro2;
1895 if (source_type == DFC_TYPE_LISP_LSTREAM)
1896 instream = source->lisp_object;
1897 else if (source_type == DFC_TYPE_DATA)
1898 streams_to_delete[delete_count++] = instream =
1899 make_fixed_buffer_input_stream (source->data.ptr, source->data.len);
1902 type_checking_assert (source_type == DFC_TYPE_LISP_STRING);
1903 streams_to_delete[delete_count++] = instream =
1904 make_lisp_string_input_stream (source->lisp_object, 0, -1);
1907 if (sink_type == DFC_TYPE_LISP_LSTREAM)
1908 outstream = sink->lisp_object;
1911 type_checking_assert (sink_type == DFC_TYPE_DATA);
1912 streams_to_delete[delete_count++] = outstream =
1913 make_dynarr_output_stream
1914 ((unsigned_char_dynarr *) conversion_out_dynarr);
1918 streams_to_delete[delete_count++] = outstream =
1919 make_encoding_output_stream (XLSTREAM (outstream), coding_system);
1922 reader = XLSTREAM (instream);
1923 writer = XLSTREAM (outstream);
1924 /* decoding_stream will gc-protect outstream */
1925 GCPRO2 (instream, outstream);
1929 ssize_t size_in_bytes;
1930 char tempbuf[1024]; /* some random amount */
1932 size_in_bytes = Lstream_read (reader, tempbuf, sizeof (tempbuf));
1934 if (size_in_bytes == 0)
1936 else if (size_in_bytes < 0)
1937 error ("Error converting to external format");
1939 size_in_bytes = Lstream_write (writer, tempbuf, size_in_bytes);
1941 if (size_in_bytes <= 0)
1942 error ("Error converting to external format");
1945 /* Closing writer will close any stream at the other end of writer. */
1946 Lstream_close (writer);
1947 Lstream_close (reader);
1950 /* The idea is that this function will create no garbage. */
1951 while (delete_count)
1952 Lstream_delete (XLSTREAM (streams_to_delete [--delete_count]));
1955 unbind_to (count, Qnil);
1957 if (sink_type != DFC_TYPE_LISP_LSTREAM)
1959 sink->data.len = Dynarr_length (conversion_out_dynarr);
1960 Dynarr_add (conversion_out_dynarr, '\0'); /* NUL-terminate! */
1961 sink->data.ptr = Dynarr_atp (conversion_out_dynarr, 0);
1966 dfc_convert_to_internal_format (dfc_conversion_type source_type,
1967 dfc_conversion_data *source,
1969 Lisp_Object coding_system,
1971 dfc_conversion_type sink_type,
1972 dfc_conversion_data *sink)
1974 int count = specpdl_depth ();
1975 Bufbyte_dynarr *conversion_in_dynarr;
1977 type_checking_assert
1978 ((source_type == DFC_TYPE_DATA ||
1979 source_type == DFC_TYPE_LISP_LSTREAM)
1981 (sink_type == DFC_TYPE_DATA ||
1982 sink_type == DFC_TYPE_LISP_LSTREAM));
1984 record_unwind_protect (dfc_convert_to_internal_format_reset_in_use,
1985 make_int (dfc_convert_to_internal_format_in_use));
1986 if (Dynarr_length (conversion_in_dynarr_list) <=
1987 dfc_convert_to_internal_format_in_use)
1988 Dynarr_add (conversion_in_dynarr_list, Dynarr_new (Bufbyte));
1989 conversion_in_dynarr = Dynarr_at (conversion_in_dynarr_list,
1990 dfc_convert_to_internal_format_in_use);
1991 dfc_convert_to_internal_format_in_use++;
1992 Dynarr_reset (conversion_in_dynarr);
1995 coding_system = Fget_coding_system (coding_system);
1998 if (source_type != DFC_TYPE_LISP_LSTREAM &&
1999 sink_type != DFC_TYPE_LISP_LSTREAM &&
2000 coding_system_is_binary (coding_system))
2003 const Bufbyte *ptr = (const Bufbyte *) source->data.ptr;
2004 Bytecount len = source->data.len;
2005 const Bufbyte *end = ptr + len;
2007 for (; ptr < end; ptr++)
2012 if (BYTE_ASCII_P (c))
2013 Dynarr_add (conversion_in_dynarr, c);
2016 Dynarr_add (conversion_in_dynarr, (c >> 6) | 0xC0);
2017 Dynarr_add (conversion_in_dynarr, (c & 0x3F) | 0x80);
2020 if (BYTE_ASCII_P (c))
2021 Dynarr_add (conversion_in_dynarr, c);
2022 else if (BYTE_C1_P (c))
2024 Dynarr_add (conversion_in_dynarr, LEADING_BYTE_CONTROL_1);
2025 Dynarr_add (conversion_in_dynarr, c + 0x20);
2029 Dynarr_add (conversion_in_dynarr, LEADING_BYTE_LATIN_ISO8859_1);
2030 Dynarr_add (conversion_in_dynarr, c);
2035 Dynarr_add_many (conversion_in_dynarr, source->data.ptr, source->data.len);
2040 Lisp_Object streams_to_delete[3];
2041 int delete_count = 0;
2042 Lisp_Object instream, outstream;
2043 Lstream *reader, *writer;
2044 struct gcpro gcpro1, gcpro2;
2046 if (source_type == DFC_TYPE_LISP_LSTREAM)
2047 instream = source->lisp_object;
2050 type_checking_assert (source_type == DFC_TYPE_DATA);
2051 streams_to_delete[delete_count++] = instream =
2052 make_fixed_buffer_input_stream (source->data.ptr, source->data.len);
2055 if (sink_type == DFC_TYPE_LISP_LSTREAM)
2056 outstream = sink->lisp_object;
2059 type_checking_assert (sink_type == DFC_TYPE_DATA);
2060 streams_to_delete[delete_count++] = outstream =
2061 make_dynarr_output_stream
2062 ((unsigned_char_dynarr *) conversion_in_dynarr);
2066 streams_to_delete[delete_count++] = outstream =
2067 make_decoding_output_stream (XLSTREAM (outstream), coding_system);
2070 reader = XLSTREAM (instream);
2071 writer = XLSTREAM (outstream);
2072 /* outstream will gc-protect its sink stream, if necessary */
2073 GCPRO2 (instream, outstream);
2077 ssize_t size_in_bytes;
2078 char tempbuf[1024]; /* some random amount */
2080 size_in_bytes = Lstream_read (reader, tempbuf, sizeof (tempbuf));
2082 if (size_in_bytes == 0)
2084 else if (size_in_bytes < 0)
2085 error ("Error converting to internal format");
2087 size_in_bytes = Lstream_write (writer, tempbuf, size_in_bytes);
2089 if (size_in_bytes <= 0)
2090 error ("Error converting to internal format");
2093 /* Closing writer will close any stream at the other end of writer. */
2094 Lstream_close (writer);
2095 Lstream_close (reader);
2098 /* The idea is that this function will create no garbage. */
2099 while (delete_count)
2100 Lstream_delete (XLSTREAM (streams_to_delete [--delete_count]));
2103 unbind_to (count, Qnil);
2105 if (sink_type != DFC_TYPE_LISP_LSTREAM)
2107 sink->data.len = Dynarr_length (conversion_in_dynarr);
2108 Dynarr_add (conversion_in_dynarr, '\0'); /* NUL-terminate! */
2109 sink->data.ptr = Dynarr_atp (conversion_in_dynarr, 0);
2115 syms_of_buffer (void)
2117 INIT_LRECORD_IMPLEMENTATION (buffer);
2119 defsymbol (&Qbuffer_live_p, "buffer-live-p");
2120 defsymbol (&Qbuffer_or_string_p, "buffer-or-string-p");
2121 defsymbol (&Qmode_class, "mode-class");
2122 defsymbol (&Qrename_auto_save_file, "rename-auto-save-file");
2123 defsymbol (&Qkill_buffer_hook, "kill-buffer-hook");
2124 defsymbol (&Qpermanent_local, "permanent-local");
2126 defsymbol (&Qfirst_change_hook, "first-change-hook");
2127 defsymbol (&Qbefore_change_functions, "before-change-functions");
2128 defsymbol (&Qafter_change_functions, "after-change-functions");
2130 /* #### Obsolete, for compatibility */
2131 defsymbol (&Qbefore_change_function, "before-change-function");
2132 defsymbol (&Qafter_change_function, "after-change-function");
2134 defsymbol (&Qdefault_directory, "default-directory");
2136 defsymbol (&Qget_file_buffer, "get-file-buffer");
2137 defsymbol (&Qchange_major_mode_hook, "change-major-mode-hook");
2139 defsymbol (&Qfundamental_mode, "fundamental-mode");
2141 defsymbol (&Qfind_file_compare_truenames, "find-file-compare-truenames");
2143 defsymbol (&Qswitch_to_buffer, "switch-to-buffer");
2146 DEFSUBR (Fbuffer_live_p);
2147 DEFSUBR (Fbuffer_list);
2148 DEFSUBR (Fdecode_buffer);
2149 DEFSUBR (Fget_buffer);
2150 DEFSUBR (Fget_file_buffer);
2151 DEFSUBR (Fget_buffer_create);
2152 DEFSUBR (Fmake_indirect_buffer);
2154 DEFSUBR (Fgenerate_new_buffer_name);
2155 DEFSUBR (Fbuffer_name);
2156 DEFSUBR (Fbuffer_file_name);
2157 DEFSUBR (Fbuffer_base_buffer);
2158 DEFSUBR (Fbuffer_indirect_children);
2159 DEFSUBR (Fbuffer_local_variables);
2160 DEFSUBR (Fbuffer_modified_p);
2161 DEFSUBR (Fset_buffer_modified_p);
2162 DEFSUBR (Fbuffer_modified_tick);
2163 DEFSUBR (Frename_buffer);
2164 DEFSUBR (Fother_buffer);
2165 DEFSUBR (Fbuffer_disable_undo);
2166 DEFSUBR (Fbuffer_enable_undo);
2167 DEFSUBR (Fkill_buffer);
2168 DEFSUBR (Ferase_buffer);
2169 DEFSUBR (Frecord_buffer);
2170 DEFSUBR (Fset_buffer_major_mode);
2171 DEFSUBR (Fcurrent_buffer);
2172 DEFSUBR (Fset_buffer);
2173 DEFSUBR (Fbarf_if_buffer_read_only);
2174 DEFSUBR (Fbury_buffer);
2175 DEFSUBR (Fkill_all_local_variables);
2176 #ifdef MEMORY_USAGE_STATS
2177 DEFSUBR (Fbuffer_memory_usage);
2180 DEFERROR (Qprotected_field, "Attempt to modify a protected field",
2185 reinit_vars_of_buffer (void)
2187 conversion_in_dynarr_list = Dynarr_new2 (Bufbyte_dynarr_dynarr,
2189 conversion_out_dynarr_list = Dynarr_new2 (Extbyte_dynarr_dynarr,
2192 staticpro_nodump (&Vbuffer_alist);
2193 Vbuffer_alist = Qnil;
2197 /* initialize the buffer routines */
2199 vars_of_buffer (void)
2201 /* This function can GC */
2202 reinit_vars_of_buffer ();
2204 staticpro (&QSFundamental);
2205 staticpro (&QSscratch);
2207 QSFundamental = build_string ("Fundamental");
2208 QSscratch = build_string (DEFER_GETTEXT ("*scratch*"));
2210 DEFVAR_LISP ("change-major-mode-hook", &Vchange_major_mode_hook /*
2211 List of hooks to be run before killing local variables in a buffer.
2212 This should be used by any mode that temporarily alters the contents or
2213 the read-only state of the buffer. See also `kill-all-local-variables'.
2215 Vchange_major_mode_hook = Qnil;
2217 DEFVAR_BOOL ("find-file-compare-truenames", &find_file_compare_truenames /*
2218 If this is true, then the `find-file' command will check the truenames
2219 of all visited files when deciding whether a given file is already in
2220 a buffer, instead of just `buffer-file-name'. This means that if you
2221 attempt to visit another file which is a symbolic link to a file which
2222 is already in a buffer, the existing buffer will be found instead of a
2223 newly-created one. This works if any component of the pathname
2224 (including a non-terminal component) is a symbolic link as well, but
2225 doesn't work with hard links (nothing does).
2227 See also the variable `find-file-use-truenames'.
2229 #if defined(CYGWIN) || defined(WIN32_NATIVE)
2230 find_file_compare_truenames = 1;
2232 find_file_compare_truenames = 0;
2235 DEFVAR_BOOL ("find-file-use-truenames", &find_file_use_truenames /*
2236 If this is true, then a buffer's visited file-name will always be
2237 chased back to the real file; it will never be a symbolic link, and there
2238 will never be a symbolic link anywhere in its directory path.
2239 That is, the buffer-file-name and buffer-file-truename will be equal.
2240 This doesn't work with hard links.
2242 See also the variable `find-file-compare-truenames'.
2244 find_file_use_truenames = 0;
2246 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions /*
2247 List of functions to call before each text change.
2248 Two arguments are passed to each function: the positions of
2249 the beginning and end of the range of old text to be changed.
2250 \(For an insertion, the beginning and end are at the same place.)
2251 No information is given about the length of the text after the change.
2253 Buffer changes made while executing the `before-change-functions'
2254 don't call any before-change or after-change functions.
2256 Vbefore_change_functions = Qnil;
2258 /* FSF Emacs has the following additional doc at the end of
2259 before-change-functions and after-change-functions:
2261 That's because these variables are temporarily set to nil.
2262 As a result, a hook function cannot straightforwardly alter the value of
2263 these variables. See the Emacs Lisp manual for a way of
2264 accomplishing an equivalent result by using other variables.
2266 But this doesn't apply under XEmacs because things are
2269 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions /*
2270 List of functions to call after each text change.
2271 Three arguments are passed to each function: the positions of
2272 the beginning and end of the range of changed text,
2273 and the length of the pre-change text replaced by that range.
2274 \(For an insertion, the pre-change length is zero;
2275 for a deletion, that length is the number of characters deleted,
2276 and the post-change beginning and end are at the same place.)
2278 Buffer changes made while executing `after-change-functions'
2279 don't call any before-change or after-change functions.
2281 Vafter_change_functions = Qnil;
2283 DEFVAR_LISP ("before-change-function", &Vbefore_change_function /*
2285 */ ); /* obsoleteness will be documented */
2286 Vbefore_change_function = Qnil;
2288 DEFVAR_LISP ("after-change-function", &Vafter_change_function /*
2290 */ ); /* obsoleteness will be documented */
2291 Vafter_change_function = Qnil;
2293 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook /*
2294 A list of functions to call before changing a buffer which is unmodified.
2295 The functions are run using the `run-hooks' function.
2297 Vfirst_change_hook = Qnil;
2300 xxDEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode /*
2301 *Non-nil means deactivate the mark when the buffer contents change.
2303 Vtransient_mark_mode = Qnil;
2304 #endif /* FSFmacs */
2306 DEFVAR_INT ("undo-threshold", &undo_threshold /*
2307 Keep no more undo information once it exceeds this size.
2308 This threshold is applied when garbage collection happens.
2309 The size is counted as the number of bytes occupied,
2310 which includes both saved text and other data.
2312 undo_threshold = 20000;
2314 DEFVAR_INT ("undo-high-threshold", &undo_high_threshold /*
2315 Don't keep more than this much size of undo information.
2316 A command which pushes past this size is itself forgotten.
2317 This threshold is applied when garbage collection happens.
2318 The size is counted as the number of bytes occupied,
2319 which includes both saved text and other data.
2321 undo_high_threshold = 30000;
2323 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only /*
2324 *Non-nil means disregard read-only status of buffers or characters.
2325 If the value is t, disregard `buffer-read-only' and all `read-only'
2326 text properties. If the value is a list, disregard `buffer-read-only'
2327 and disregard a `read-only' extent property or text property if the
2328 property value is a member of the list.
2330 Vinhibit_read_only = Qnil;
2332 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions /*
2333 List of functions called with no args to query before killing a buffer.
2335 Vkill_buffer_query_functions = Qnil;
2337 DEFVAR_BOOL ("delete-auto-save-files", &delete_auto_save_files /*
2338 *Non-nil means delete auto-save file when a buffer is saved or killed.
2340 delete_auto_save_files = 1;
2343 /* The docstrings for DEFVAR_* are recorded externally by make-docfile. */
2345 /* Renamed from DEFVAR_PER_BUFFER because FSFmacs D_P_B takes
2346 a bogus extra arg, which confuses an otherwise identical make-docfile.c */
2347 #define DEFVAR_BUFFER_LOCAL_1(lname, field_name, forward_type, magicfun) do { \
2348 static const struct symbol_value_forward I_hate_C = \
2349 { /* struct symbol_value_forward */ \
2350 { /* struct symbol_value_magic */ \
2351 { /* struct lcrecord_header */ \
2352 { /* struct lrecord_header */ \
2353 lrecord_type_symbol_value_forward, /* lrecord_type_index */ \
2355 1, /* c_readonly bit */ \
2356 1 /* lisp_readonly bit */ \
2362 &(buffer_local_flags.field_name), \
2369 int offset = ((char *)symbol_value_forward_forward (&I_hate_C) - \
2370 (char *)&buffer_local_flags); \
2371 defvar_magic (lname, &I_hate_C); \
2373 *((Lisp_Object *)(offset + (char *)XBUFFER (Vbuffer_local_symbols))) \
2378 #define DEFVAR_BUFFER_LOCAL_MAGIC(lname, field_name, magicfun) \
2379 DEFVAR_BUFFER_LOCAL_1 (lname, field_name, \
2380 SYMVAL_CURRENT_BUFFER_FORWARD, magicfun)
2381 #define DEFVAR_BUFFER_LOCAL(lname, field_name) \
2382 DEFVAR_BUFFER_LOCAL_MAGIC (lname, field_name, 0)
2383 #define DEFVAR_CONST_BUFFER_LOCAL_MAGIC(lname, field_name, magicfun) \
2384 DEFVAR_BUFFER_LOCAL_1 (lname, field_name, \
2385 SYMVAL_CONST_CURRENT_BUFFER_FORWARD, magicfun)
2386 #define DEFVAR_CONST_BUFFER_LOCAL(lname, field_name) \
2387 DEFVAR_CONST_BUFFER_LOCAL_MAGIC (lname, field_name, 0)
2389 #define DEFVAR_BUFFER_DEFAULTS_MAGIC(lname, field_name, magicfun) \
2390 DEFVAR_SYMVAL_FWD (lname, &(buffer_local_flags.field_name), \
2391 SYMVAL_DEFAULT_BUFFER_FORWARD, magicfun)
2392 #define DEFVAR_BUFFER_DEFAULTS(lname, field_name) \
2393 DEFVAR_BUFFER_DEFAULTS_MAGIC (lname, field_name, 0)
2396 nuke_all_buffer_slots (struct buffer *b, Lisp_Object zap)
2400 b->extent_info = Qnil;
2401 b->indirect_children = Qnil;
2402 b->own_text.line_number_cache = Qnil;
2404 #define MARKED_SLOT(x) b->x = zap
2405 #include "bufslots.h"
2410 common_init_complex_vars_of_buffer (void)
2412 /* Make sure all markable slots in buffer_defaults
2413 are initialized reasonably, so mark_buffer won't choke. */
2414 struct buffer *defs = alloc_lcrecord_type (struct buffer, &lrecord_buffer);
2415 struct buffer *syms = alloc_lcrecord_type (struct buffer, &lrecord_buffer);
2417 staticpro_nodump (&Vbuffer_defaults);
2418 staticpro_nodump (&Vbuffer_local_symbols);
2419 XSETBUFFER (Vbuffer_defaults, defs);
2420 XSETBUFFER (Vbuffer_local_symbols, syms);
2422 nuke_all_buffer_slots (syms, Qnil);
2423 nuke_all_buffer_slots (defs, Qnil);
2424 defs->text = &defs->own_text;
2425 syms->text = &syms->own_text;
2427 /* Set up the non-nil default values of various buffer slots.
2428 Must do these before making the first buffer. */
2429 defs->major_mode = Qfundamental_mode;
2430 defs->mode_name = QSFundamental;
2431 defs->abbrev_table = Qnil; /* real default setup by Lisp code */
2433 defs->case_table = Vstandard_case_table;
2435 defs->category_table = Vstandard_category_table;
2437 defs->syntax_table = Vstandard_syntax_table;
2439 defs->mirror_syntax_table =
2440 XCHAR_TABLE (Vstandard_syntax_table)->mirror_table;
2442 defs->modeline_format = build_string ("%-"); /* reset in loaddefs.el */
2443 defs->case_fold_search = Qt;
2444 defs->selective_display_ellipses = Qt;
2445 defs->tab_width = make_int (8);
2446 defs->ctl_arrow = Qt;
2447 defs->fill_column = make_int (70);
2448 defs->left_margin = Qzero;
2449 defs->saved_size = Qzero; /* lisp code wants int-or-nil */
2451 defs->auto_save_modified = 0;
2452 defs->auto_save_failure_time = -1;
2453 defs->invisibility_spec = Qt;
2454 defs->buffer_local_face_property = 0;
2456 defs->indirect_children = Qnil;
2457 syms->indirect_children = Qnil;
2460 /* 0 means var is always local. Default used only at creation.
2461 * -1 means var is always local. Default used only at reset and
2463 * -2 means there's no lisp variable corresponding to this slot
2464 * and the default is only used at creation.
2465 * -3 means no Lisp variable. Default used only at reset and creation.
2466 * >0 is mask. Var is local if ((buffer->local_var_flags & mask) != 0)
2467 * Otherwise default is used.
2469 Lisp_Object always_local_no_default = make_int (0);
2470 Lisp_Object always_local_resettable = make_int (-1);
2471 Lisp_Object resettable = make_int (-3);
2473 /* Assign the local-flags to the slots that have default values.
2474 The local flag is a bit that is used in the buffer
2475 to say that it has its own local value for the slot.
2476 The local flag bits are in the local_var_flags slot of the
2479 nuke_all_buffer_slots (&buffer_local_flags, make_int (-2));
2480 buffer_local_flags.filename = always_local_no_default;
2481 buffer_local_flags.directory = always_local_no_default;
2482 buffer_local_flags.backed_up = always_local_no_default;
2483 buffer_local_flags.saved_size = always_local_no_default;
2484 buffer_local_flags.auto_save_file_name = always_local_no_default;
2485 buffer_local_flags.read_only = always_local_no_default;
2487 buffer_local_flags.major_mode = always_local_resettable;
2488 buffer_local_flags.mode_name = always_local_resettable;
2489 buffer_local_flags.undo_list = always_local_no_default;
2491 buffer_local_flags.mark_active = always_local_resettable;
2493 buffer_local_flags.point_before_scroll = always_local_resettable;
2494 buffer_local_flags.file_truename = always_local_no_default;
2495 buffer_local_flags.invisibility_spec = always_local_resettable;
2496 buffer_local_flags.file_format = always_local_resettable;
2497 buffer_local_flags.generated_modeline_string = always_local_no_default;
2499 buffer_local_flags.keymap = resettable;
2500 buffer_local_flags.case_table = resettable;
2501 buffer_local_flags.syntax_table = resettable;
2503 buffer_local_flags.category_table = resettable;
2506 buffer_local_flags.modeline_format = make_int (1<<0);
2507 buffer_local_flags.abbrev_mode = make_int (1<<1);
2508 buffer_local_flags.overwrite_mode = make_int (1<<2);
2509 buffer_local_flags.case_fold_search = make_int (1<<3);
2510 buffer_local_flags.auto_fill_function = make_int (1<<4);
2511 buffer_local_flags.selective_display = make_int (1<<5);
2512 buffer_local_flags.selective_display_ellipses = make_int (1<<6);
2513 buffer_local_flags.tab_width = make_int (1<<7);
2514 buffer_local_flags.truncate_lines = make_int (1<<8);
2515 buffer_local_flags.ctl_arrow = make_int (1<<9);
2516 buffer_local_flags.fill_column = make_int (1<<10);
2517 buffer_local_flags.left_margin = make_int (1<<11);
2518 buffer_local_flags.abbrev_table = make_int (1<<12);
2519 #ifdef REGION_CACHE_NEEDS_WORK
2520 buffer_local_flags.cache_long_line_scans = make_int (1<<13);
2523 buffer_local_flags.buffer_file_coding_system = make_int (1<<14);
2526 /* #### Warning: 1<<31 is the largest number currently allowable
2527 due to the XINT() handling of this value. With some
2528 rearrangement you can get 3 more bits. */
2532 #define BUFFER_SLOTS_SIZE (offsetof (struct buffer, BUFFER_SLOTS_LAST_NAME) - offsetof (struct buffer, BUFFER_SLOTS_FIRST_NAME) + sizeof (Lisp_Object))
2533 #define BUFFER_SLOTS_COUNT (BUFFER_SLOTS_SIZE / sizeof (Lisp_Object))
2536 reinit_complex_vars_of_buffer (void)
2538 struct buffer *defs, *syms;
2540 common_init_complex_vars_of_buffer ();
2542 defs = XBUFFER (Vbuffer_defaults);
2543 syms = XBUFFER (Vbuffer_local_symbols);
2544 memcpy (&defs->BUFFER_SLOTS_FIRST_NAME,
2545 buffer_defaults_saved_slots,
2547 memcpy (&syms->BUFFER_SLOTS_FIRST_NAME,
2548 buffer_local_symbols_saved_slots,
2553 static const struct lrecord_description buffer_slots_description_1[] = {
2554 { XD_LISP_OBJECT_ARRAY, 0, BUFFER_SLOTS_COUNT },
2558 static const struct struct_description buffer_slots_description = {
2560 buffer_slots_description_1
2564 complex_vars_of_buffer (void)
2566 struct buffer *defs, *syms;
2568 common_init_complex_vars_of_buffer ();
2570 defs = XBUFFER (Vbuffer_defaults);
2571 syms = XBUFFER (Vbuffer_local_symbols);
2572 buffer_defaults_saved_slots = &defs->BUFFER_SLOTS_FIRST_NAME;
2573 buffer_local_symbols_saved_slots = &syms->BUFFER_SLOTS_FIRST_NAME;
2574 dump_add_root_struct_ptr (&buffer_defaults_saved_slots, &buffer_slots_description);
2575 dump_add_root_struct_ptr (&buffer_local_symbols_saved_slots, &buffer_slots_description);
2577 DEFVAR_BUFFER_DEFAULTS ("default-modeline-format", modeline_format /*
2578 Default value of `modeline-format' for buffers that don't override it.
2579 This is the same as (default-value 'modeline-format).
2582 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode", abbrev_mode /*
2583 Default value of `abbrev-mode' for buffers that do not override it.
2584 This is the same as (default-value 'abbrev-mode).
2587 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow", ctl_arrow /*
2588 Default value of `ctl-arrow' for buffers that do not override it.
2589 This is the same as (default-value 'ctl-arrow).
2592 #if 0 /* #### make this a specifier! */
2593 DEFVAR_BUFFER_DEFAULTS ("default-display-direction", display_direction /*
2594 Default display-direction for buffers that do not override it.
2595 This is the same as (default-value 'display-direction).
2596 Note: This is not yet implemented.
2600 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines", truncate_lines /*
2601 Default value of `truncate-lines' for buffers that do not override it.
2602 This is the same as (default-value 'truncate-lines).
2605 DEFVAR_BUFFER_DEFAULTS ("default-fill-column", fill_column /*
2606 Default value of `fill-column' for buffers that do not override it.
2607 This is the same as (default-value 'fill-column).
2610 DEFVAR_BUFFER_DEFAULTS ("default-left-margin", left_margin /*
2611 Default value of `left-margin' for buffers that do not override it.
2612 This is the same as (default-value 'left-margin).
2615 DEFVAR_BUFFER_DEFAULTS ("default-tab-width", tab_width /*
2616 Default value of `tab-width' for buffers that do not override it.
2617 This is the same as (default-value 'tab-width).
2620 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search", case_fold_search /*
2621 Default value of `case-fold-search' for buffers that don't override it.
2622 This is the same as (default-value 'case-fold-search).
2625 DEFVAR_BUFFER_LOCAL ("modeline-format", modeline_format /*
2626 Template for displaying modeline for current buffer.
2627 Each buffer has its own value of this variable.
2628 Value may be a string, symbol, glyph, generic specifier, list or cons cell.
2629 For a symbol, its value is processed (but it is ignored if t or nil).
2630 A string appearing directly as the value of a symbol is processed verbatim
2631 in that the %-constructs below are not recognized.
2632 For a glyph, it is inserted as is.
2633 For a generic specifier (i.e. a specifier of type `generic'), its instance
2634 is computed in the current window using the equivalent of `specifier-instance'
2635 and the value is processed.
2636 For a list whose car is a symbol, the symbol's value is taken,
2637 and if that is non-nil, the cadr of the list is processed recursively.
2638 Otherwise, the caddr of the list (if there is one) is processed.
2639 For a list whose car is a string or list, each element is processed
2640 recursively and the results are effectively concatenated.
2641 For a list whose car is an integer, the cdr of the list is processed
2642 and padded (if the number is positive) or truncated (if negative)
2643 to the width specified by that number.
2644 For a list whose car is an extent, the cdr of the list is processed
2645 normally but the results are displayed using the face of the
2646 extent, and mouse clicks over this section are processed using the
2647 keymap of the extent. (In addition, if the extent has a help-echo
2648 property, that string will be echoed when the mouse moves over this
2649 section.) If extents are nested, all keymaps are properly consulted
2650 when processing mouse clicks, but multiple faces are not correctly
2651 merged (only the first face is used), and lists of faces are not
2652 correctly handled. See `generated-modeline-string' for more information.
2653 A string is printed verbatim in the modeline except for %-constructs:
2654 (%-constructs are processed when the string is the entire modeline-format
2655 or when it is found in a cons-cell or a list)
2656 %b -- print buffer name. %c -- print the current column number.
2657 %f -- print visited file name.
2658 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
2659 % means buffer is read-only and * means it is modified.
2660 For a modified read-only buffer, %* gives % and %+ gives *.
2661 %s -- print process status. %l -- print the current line number.
2662 %S -- print name of selected frame (only meaningful under X Windows).
2663 %p -- print percent of buffer above top of window, or Top, Bot or All.
2664 %P -- print percent of buffer above bottom of window, perhaps plus Top,
2665 or print Bottom or All.
2666 %n -- print Narrow if appropriate.
2667 %C -- under XEmacs/mule, print the mnemonic for `buffer-file-coding-system'.
2668 %[ -- print one [ for each recursive editing level. %] similar.
2669 %% -- print %. %- -- print infinitely many dashes.
2670 Decimal digits after the % specify field width to which to pad.
2673 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode /*
2674 *Major mode for new buffers. Defaults to `fundamental-mode'.
2675 nil here means use current buffer's major mode.
2678 DEFVAR_BUFFER_DEFAULTS ("fundamental-mode-abbrev-table", abbrev_table /*
2679 The abbrev table of mode-specific abbrevs for Fundamental Mode.
2682 DEFVAR_BUFFER_LOCAL ("major-mode", major_mode /*
2683 Symbol for current buffer's major mode.
2686 DEFVAR_BUFFER_LOCAL ("mode-name", mode_name /*
2687 Pretty name of current buffer's major mode (a string).
2690 DEFVAR_BUFFER_LOCAL ("abbrev-mode", abbrev_mode /*
2691 Non-nil turns on automatic expansion of abbrevs as they are inserted.
2692 Automatically becomes buffer-local when set in any fashion.
2695 DEFVAR_BUFFER_LOCAL ("case-fold-search", case_fold_search /*
2696 *Non-nil if searches should ignore case.
2697 Automatically becomes buffer-local when set in any fashion.
2699 BUG: Under XEmacs/Mule, translations to or from non-ASCII characters
2700 (this includes chars in the range 128 - 255) are ignored by
2701 the string/buffer-searching routines. Thus, `case-fold-search'
2702 will not correctly conflate a-umlaut and A-umlaut even if the
2703 case tables call for this.
2706 DEFVAR_BUFFER_LOCAL ("fill-column", fill_column /*
2707 *Column beyond which automatic line-wrapping should happen.
2708 Automatically becomes buffer-local when set in any fashion.
2711 DEFVAR_BUFFER_LOCAL ("left-margin", left_margin /*
2712 *Column for the default indent-line-function to indent to.
2713 Linefeed indents to this column in Fundamental mode.
2714 Automatically becomes buffer-local when set in any fashion.
2715 Do not confuse this with the specifier `left-margin-width';
2716 that controls the size of a margin that is displayed outside
2720 DEFVAR_BUFFER_LOCAL_MAGIC ("tab-width", tab_width /*
2721 *Distance between tab stops (for display of tab characters), in columns.
2722 Automatically becomes buffer-local when set in any fashion.
2723 */ , redisplay_variable_changed);
2725 DEFVAR_BUFFER_LOCAL_MAGIC ("ctl-arrow", ctl_arrow /*
2726 *Non-nil means display control chars with uparrow.
2727 Nil means use backslash and octal digits.
2728 An integer means characters >= ctl-arrow are assumed to be printable, and
2729 will be displayed as a single glyph.
2730 Any other value is the same as 160 - the code SPC with the high bit on.
2732 The interpretation of this variable is likely to change in the future.
2734 Automatically becomes buffer-local when set in any fashion.
2735 This variable does not apply to characters whose display is specified
2736 in the current display table (if there is one).
2737 */ , redisplay_variable_changed);
2739 #if 0 /* #### Make this a specifier! */
2740 xxDEFVAR_BUFFER_LOCAL ("display-direction", display_direction /*
2741 *Non-nil means lines in the buffer are displayed right to left.
2742 Nil means left to right. (Not yet implemented.)
2744 #endif /* Not yet implemented */
2746 DEFVAR_BUFFER_LOCAL_MAGIC ("truncate-lines", truncate_lines /*
2747 *Non-nil means do not display continuation lines;
2748 give each line of text one frame line.
2749 Automatically becomes buffer-local when set in any fashion.
2751 Note that this is overridden by the variable
2752 `truncate-partial-width-windows' if that variable is non-nil
2753 and this buffer is not full-frame width.
2754 */ , redisplay_variable_changed);
2756 DEFVAR_BUFFER_LOCAL ("default-directory", directory /*
2757 Name of default directory of current buffer. Should end with slash.
2758 Each buffer has its own value of this variable.
2762 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system", buffer_file_coding_system /*
2763 Default value of `buffer-file-coding-system' for buffers that do not override it.
2764 This is the same as (default-value 'buffer-file-coding-system).
2765 This value is used both for buffers without associated files and
2766 for buffers whose files do not have any apparent coding system.
2767 See `buffer-file-coding-system'.
2770 DEFVAR_BUFFER_LOCAL ("buffer-file-coding-system", buffer_file_coding_system /*
2771 *Current coding system for the current buffer.
2772 When the buffer is written out into a file, this coding system will be
2773 used for the encoding. Automatically buffer-local when set in any
2774 fashion. This is normally set automatically when a file is loaded in
2775 based on the determined coding system of the file (assuming that
2776 `buffer-file-coding-system-for-read' is set to `undecided', which
2777 calls for automatic determination of the file's coding system).
2778 Normally the modeline indicates the current file coding system using
2779 its mnemonic abbreviation.
2781 The default value for this variable (which is normally used for
2782 buffers without associated files) is also used when automatic
2783 detection of a file's encoding is called for and there was no
2784 discernible encoding in the file (i.e. it was entirely or almost
2785 entirely ASCII). The default value should generally *not* be set to
2786 nil (equivalent to `no-conversion'), because if extended characters
2787 are ever inserted into the buffer, they will be lost when the file is
2788 written out. A good choice is `iso-2022-8' (the simple ISO 2022 8-bit
2789 encoding), which will write out ASCII and Latin-1 characters in the
2790 standard (and highly portable) fashion and use standard escape
2791 sequences for other charsets. Another reasonable choice is
2792 `escape-quoted', which is equivalent to `iso-2022-8' but prefixes
2793 certain control characters with ESC to make sure they are not
2794 interpreted as escape sequences when read in. This latter coding
2795 system results in more "correct" output in the presence of control
2796 characters in the buffer, in the sense that when read in again using
2797 the same coding system, the result will virtually always match the
2798 original contents of the buffer, which is not the case with
2799 `iso-2022-8'; but the output is less portable when dealing with binary
2800 data -- there may be stray ESC characters when the file is read by
2803 `buffer-file-coding-system' does *not* control the coding system used when
2804 a file is read in. Use the variables `buffer-file-coding-system-for-read'
2805 and `buffer-file-coding-system-alist' for that. From a Lisp program, if
2806 you wish to unilaterally specify the coding system used for one
2807 particular operation, you should bind the variable
2808 `coding-system-for-read' rather than changing the other two
2809 variables just mentioned, which are intended to be used for
2810 global environment specification.
2812 #endif /* FILE_CODING */
2814 DEFVAR_BUFFER_LOCAL ("auto-fill-function", auto_fill_function /*
2815 Function called (if non-nil) to perform auto-fill.
2816 It is called after self-inserting a space at a column beyond `fill-column'.
2817 Each buffer has its own value of this variable.
2818 NOTE: This variable is not an ordinary hook;
2819 It may not be a list of functions.
2822 DEFVAR_BUFFER_LOCAL ("buffer-file-name", filename /*
2823 Name of file visited in current buffer, or nil if not visiting a file.
2824 Each buffer has its own value of this variable.
2829 Abbreviated truename of file visited in current buffer, or nil if none.
2830 The truename of a file is calculated by `file-truename'
2831 and then abbreviated with `abbreviate-file-name'.
2832 Each buffer has its own value of this variable.
2834 #endif /* FSFmacs */
2836 DEFVAR_BUFFER_LOCAL ("buffer-file-truename", file_truename /*
2837 The real name of the file visited in the current buffer,
2838 or nil if not visiting a file. This is the result of passing
2839 buffer-file-name to the `file-truename' function. Every buffer has
2840 its own value of this variable. This variable is automatically
2841 maintained by the functions that change the file name associated
2845 DEFVAR_BUFFER_LOCAL ("buffer-auto-save-file-name", auto_save_file_name /*
2846 Name of file for auto-saving current buffer,
2847 or nil if buffer should not be auto-saved.
2848 Each buffer has its own value of this variable.
2851 DEFVAR_BUFFER_LOCAL ("buffer-read-only", read_only /*
2852 Non-nil if this buffer is read-only.
2853 Each buffer has its own value of this variable.
2856 DEFVAR_BUFFER_LOCAL ("buffer-backed-up", backed_up /*
2857 Non-nil if this buffer's file has been backed up.
2858 Backing up is done before the first time the file is saved.
2859 Each buffer has its own value of this variable.
2862 DEFVAR_BUFFER_LOCAL ("buffer-saved-size", saved_size /*
2863 Length of current buffer when last read in, saved or auto-saved.
2865 Each buffer has its own value of this variable.
2868 DEFVAR_BUFFER_LOCAL_MAGIC ("selective-display", selective_display /*
2869 Non-nil enables selective display:
2870 Integer N as value means display only lines
2871 that start with less than n columns of space.
2872 A value of t means, after a ^M, all the rest of the line is invisible.
2873 Then ^M's in the file are written into files as newlines.
2875 Automatically becomes buffer-local when set in any fashion.
2876 */, redisplay_variable_changed);
2879 DEFVAR_BUFFER_LOCAL_MAGIC ("selective-display-ellipses",
2880 selective_display_ellipses /*
2881 t means display ... on previous line when a line is invisible.
2882 Automatically becomes buffer-local when set in any fashion.
2883 */, redisplay_variable_changed);
2886 DEFVAR_BUFFER_LOCAL ("local-abbrev-table", abbrev_table /*
2887 Local (mode-specific) abbrev table of current buffer.
2890 DEFVAR_BUFFER_LOCAL ("overwrite-mode", overwrite_mode /*
2891 Non-nil if self-insertion should replace existing text.
2892 The value should be one of `overwrite-mode-textual',
2893 `overwrite-mode-binary', or nil.
2894 If it is `overwrite-mode-textual', self-insertion still
2895 inserts at the end of a line, and inserts when point is before a tab,
2896 until the tab is filled in.
2897 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.
2898 Automatically becomes buffer-local when set in any fashion.
2900 Normally, you shouldn't modify this variable by hand, but use the functions
2901 `overwrite-mode' and `binary-overwrite-mode' instead. However, you can
2902 customize the default value from the options menu.
2906 /* Adds the following to the doc string for buffer-undo-list:
2908 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
2909 was modified between BEG and END. PROPERTY is the property name,
2910 and VALUE is the old value.
2912 #endif /* FSFmacs */
2914 DEFVAR_BUFFER_LOCAL ("buffer-undo-list", undo_list /*
2915 List of undo entries in current buffer.
2916 Recent changes come first; older changes follow newer.
2918 An entry (START . END) represents an insertion which begins at
2919 position START and ends at position END.
2921 An entry (TEXT . POSITION) represents the deletion of the string TEXT
2922 from (abs POSITION). If POSITION is positive, point was at the front
2923 of the text being deleted; if negative, point was at the end.
2925 An entry (t HIGH . LOW) indicates that the buffer previously had
2926 "unmodified" status. HIGH and LOW are the high and low 16-bit portions
2927 of the visited file's modification time, as of that time. If the
2928 modification time of the most recent save is different, this entry is
2931 An entry of the form EXTENT indicates that EXTENT was attached in
2932 the buffer. Undoing an entry of this form detaches EXTENT.
2934 An entry of the form (EXTENT START END) indicates that EXTENT was
2935 detached from the buffer. Undoing an entry of this form attaches
2936 EXTENT from START to END.
2938 An entry of the form POSITION indicates that point was at the buffer
2939 location given by the integer. Undoing an entry of this form places
2942 nil marks undo boundaries. The undo command treats the changes
2943 between two undo boundaries as a single step to be undone.
2945 If the value of the variable is t, undo information is not recorded.
2949 xxDEFVAR_BUFFER_LOCAL ("mark-active", mark_active /*
2950 Non-nil means the mark and region are currently active in this buffer.
2951 Automatically local in all buffers.
2953 #endif /* FSFmacs */
2955 #ifdef REGION_CACHE_NEEDS_WORK
2956 xxDEFVAR_BUFFER_LOCAL ("cache-long-line-scans", cache_long_line_scans /*
2957 Non-nil means that Emacs should use caches to handle long lines more quickly.
2958 This variable is buffer-local, in all buffers.
2960 Normally, the line-motion functions work by scanning the buffer for
2961 newlines. Columnar operations (like move-to-column and
2962 compute-motion) also work by scanning the buffer, summing character
2963 widths as they go. This works well for ordinary text, but if the
2964 buffer's lines are very long (say, more than 500 characters), these
2965 motion functions will take longer to execute. Emacs may also take
2966 longer to update the display.
2968 If cache-long-line-scans is non-nil, these motion functions cache the
2969 results of their scans, and consult the cache to avoid rescanning
2970 regions of the buffer until the text is modified. The caches are most
2971 beneficial when they prevent the most searching---that is, when the
2972 buffer contains long lines and large regions of characters with the
2973 same, fixed screen width.
2975 When cache-long-line-scans is non-nil, processing short lines will
2976 become slightly slower (because of the overhead of consulting the
2977 cache), and the caches will use memory roughly proportional to the
2978 number of newlines and characters whose screen width varies.
2980 The caches require no explicit maintenance; their accuracy is
2981 maintained internally by the Emacs primitives. Enabling or disabling
2982 the cache should not affect the behavior of any of the motion
2983 functions; it should only affect their performance.
2985 #endif /* REGION_CACHE_NEEDS_WORK */
2987 DEFVAR_BUFFER_LOCAL ("point-before-scroll", point_before_scroll /*
2988 Value of point before the last series of scroll operations, or nil.
2991 DEFVAR_BUFFER_LOCAL ("buffer-file-format", file_format /*
2992 List of formats to use when saving this buffer.
2993 Formats are defined by `format-alist'. This variable is
2994 set when a file is visited. Automatically local in all buffers.
2997 DEFVAR_BUFFER_LOCAL_MAGIC ("buffer-invisibility-spec", invisibility_spec /*
2998 Invisibility spec of this buffer.
2999 The default is t, which means that text is invisible
3000 if it has (or is covered by an extent with) a non-nil `invisible' property.
3001 If the value is a list, a text character is invisible if its `invisible'
3002 property is an element in that list.
3003 If an element is a cons cell of the form (PROPERTY . ELLIPSIS),
3004 then characters with property value PROPERTY are invisible,
3005 and they have an ellipsis as well if ELLIPSIS is non-nil.
3006 Note that the actual characters used for the ellipsis are controllable
3007 using `invisible-text-glyph', and default to "...".
3008 */, redisplay_variable_changed);
3010 DEFVAR_CONST_BUFFER_LOCAL ("generated-modeline-string",
3011 generated_modeline_string /*
3012 String of characters in this buffer's modeline as of the last redisplay.
3013 Each time the modeline is recomputed, the resulting characters are
3014 stored in this string, which is resized as necessary. You may not
3015 set this variable, and modifying this string will not change the
3016 modeline; you have to change `modeline-format' if you want that.
3018 For each extent in `modeline-format' that is encountered when
3019 processing the modeline, a corresponding extent is placed in
3020 `generated-modeline-string' and covers the text over which the
3021 extent in `modeline-format' applies. The extent in
3022 `generated-modeline-string' is made a child of the extent in
3023 `modeline-format', which means that it inherits all properties from
3024 that extent. Note that the extents in `generated-modeline-string'
3025 are managed automatically. You should not explicitly put any extents
3026 in `generated-modeline-string'; if you do, they will disappear the
3027 next time the modeline is processed.
3029 For extents in `modeline-format', the following properties are currently
3033 Affects the face of the modeline text. Currently, faces do
3034 not merge properly; only the most recently encountered face
3035 is used. This is a bug.
3038 Affects the disposition of button events over the modeline
3039 text. Multiple applicable keymaps *are* handled properly,
3040 and `modeline-map' still applies to any events that don't
3041 have bindings in extent-specific keymaps.
3044 If a string, causes the string to be displayed when the mouse
3045 moves over the text.
3048 /* Check for DEFVAR_BUFFER_LOCAL without initializing the corresponding
3049 slot of buffer_local_flags and vice-versa. Must be done after all
3050 DEFVAR_BUFFER_LOCAL() calls. */
3051 #define MARKED_SLOT(slot) \
3052 if ((XINT (buffer_local_flags.slot) != -2 && \
3053 XINT (buffer_local_flags.slot) != -3) \
3054 != !(NILP (XBUFFER (Vbuffer_local_symbols)->slot))) \
3056 #include "bufslots.h"
3060 Lisp_Object scratch = Fget_buffer_create (QSscratch);
3061 Fset_buffer (scratch);
3062 /* Want no undo records for *scratch* until after Emacs is dumped */
3063 Fbuffer_disable_undo (scratch);
3067 #ifndef WIN32_NATIVE
3068 /* Is PWD another name for `.' ? */
3070 directory_is_current_directory (Extbyte *pwd)
3072 Bufbyte *pwd_internal;
3073 Bytecount pwd_internal_len;
3074 struct stat dotstat, pwdstat;
3076 TO_INTERNAL_FORMAT (DATA, (pwd, strlen ((char *)pwd) + 1),
3077 ALLOCA, (pwd_internal, pwd_internal_len),
3080 return (IS_DIRECTORY_SEP (*pwd_internal)
3081 && xemacs_stat ((char *) pwd_internal, &pwdstat) == 0
3082 && xemacs_stat (".", &dotstat) == 0
3083 && dotstat.st_ino == pwdstat.st_ino
3084 && dotstat.st_dev == pwdstat.st_dev
3085 && pwd_internal_len < MAXPATHLEN);
3090 init_initial_directory (void)
3092 /* This function can GC */
3094 #ifndef WIN32_NATIVE
3098 initial_directory[0] = 0;
3100 /* If PWD is accurate, use it instead of calling getcwd. This is faster
3101 when PWD is right, and may avoid a fatal error. */
3102 #ifndef WIN32_NATIVE
3103 if ((pwd = (Extbyte *) getenv ("PWD")) != NULL
3104 && directory_is_current_directory (pwd))
3105 strcpy (initial_directory, (char *) pwd);
3108 if (getcwd (initial_directory, MAXPATHLEN) == NULL)
3109 fatal ("`getcwd' failed: %s\n", strerror (errno));
3111 /* Make sure pwd is DIRECTORY_SEP-terminated.
3112 Maybe this should really use some standard subroutine
3113 whose definition is filename syntax dependent. */
3115 int len = strlen (initial_directory);
3117 if (! IS_DIRECTORY_SEP (initial_directory[len - 1]))
3119 initial_directory[len] = DIRECTORY_SEP;
3120 initial_directory[len + 1] = '\0';
3124 #ifdef CORRECT_DIR_SEPS
3125 CORRECT_DIR_SEPS (initial_directory);
3132 /* This function can GC */
3134 Fset_buffer (Fget_buffer_create (QSscratch));
3136 current_buffer->directory =
3137 build_ext_string (initial_directory, Qfile_name);
3140 /* #### is this correct? */
3141 temp = get_minibuffer (0);
3142 XBUFFER (temp)->directory = current_buffer->directory;
3143 #endif /* FSFmacs */