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.
6 This file is part of XEmacs.
8 XEmacs is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with XEmacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Synched up with: Mule 2.0, FSF 19.30. */
28 JWZ: some changes for Lemacs, long ago. (e.g. separate buffer
30 Mly: a few changes for buffer-local vars, 19.8 or 19.9.
31 Ben Wing: some changes and cleanups for Mule, 19.12.
34 /* This file contains functions that work with buffer objects.
35 Functions that manipulate a buffer's text, however, are not
38 1) The low-level functions that actually know about the
39 implementation of a buffer's text are located in insdel.c.
40 2) The higher-level (mostly Lisp) functions that manipulate a
41 buffer's text are in editfns.c.
42 3) The highest-level Lisp commands are in cmds.c.
46 -- Functions that know about syntax tables (forward-word,
47 scan-sexps, etc.) are in syntax.c, as are functions
48 that manipulate syntax tables.
49 -- Functions that know about case tables (upcase, downcase,
50 etc.) are in casefiddle.c. Functions that manipulate
51 case tables (case-table-p, set-case-table, etc.) are
53 -- Functions that do searching and replacing are in
54 search.c. The low-level functions that implement
55 regular expressions are in regex.c.
59 -- Some file and process functions (in fileio.c and process.c)
60 copy text from or insert text into a buffer; they call
61 low-level functions in insdel.c to do this.
62 -- insdel.c calls low-level functions in undo.c and extents.c
63 to record buffer modifications for undoing and to handle
64 extent adjustment and extent-data creation and insertion.
78 #include "file-coding.h"
83 #include "process.h" /* for kill_buffer_processes */
84 #ifdef REGION_CACHE_NEEDS_WORK
85 #include "region-cache.h"
87 #include "specifier.h"
89 #include "sysdep.h" /* for getwd */
94 struct buffer *current_buffer; /* the current buffer */
96 /* This structure holds the default values of the buffer-local variables
97 defined with DEFVAR_BUFFER_LOCAL, that have special slots in each buffer.
98 The default value occupies the same slot in this structure
99 as an individual buffer's value occupies in that buffer.
100 Setting the default value also goes through the alist of buffers
101 and stores into each buffer that does not say it has a local value. */
102 Lisp_Object Vbuffer_defaults;
103 static void *buffer_defaults_saved_slots;
105 /* This structure marks which slots in a buffer have corresponding
106 default values in Vbuffer_defaults.
107 Each such slot has a nonzero value in this structure.
108 The value has only one nonzero bit.
110 When a buffer has its own local value for a slot,
111 the bit for that slot (found in the same slot in this structure)
112 is turned on in the buffer's local_var_flags slot.
114 If a slot in this structure is 0, then there is a DEFVAR_BUFFER_LOCAL
115 for the slot, but there is no default value for it; the corresponding
116 slot in Vbuffer_defaults is not used except to initialize newly-created
119 If a slot is -1, then there is a DEFVAR_BUFFER_LOCAL for it
120 as well as a default value which is used to initialize newly-created
121 buffers and as a reset-value when local-vars are killed.
123 If a slot is -2, there is no DEFVAR_BUFFER_LOCAL for it.
124 (The slot is always local, but there's no lisp variable for it.)
125 The default value is only used to initialize newly-creation buffers.
127 If a slot is -3, then there is no DEFVAR_BUFFER_LOCAL for it but
128 there is a default which is used to initialize newly-creation
129 buffers and as a reset-value when local-vars are killed. */
130 struct buffer buffer_local_flags;
132 /* This is the initial (startup) directory, as used for the *scratch* buffer.
133 We're making this a global to make others aware of the startup directory.
134 `initial_directory' is stored in external format.
136 char initial_directory[MAXPATHLEN+1];
138 /* This structure holds the names of symbols whose values may be
139 buffer-local. It is indexed and accessed in the same way as the above. */
140 static Lisp_Object Vbuffer_local_symbols;
141 static void *buffer_local_symbols_saved_slots;
143 /* Alist of all buffer names vs the buffers. */
144 /* This used to be a variable, but is no longer,
145 to prevent lossage due to user rplac'ing this alist or its elements.
146 Note that there is a per-frame copy of this as well; the frame slot
147 and the global variable contain the same data, but possibly in different
148 orders, so that the buffer ordering can be per-frame.
150 Lisp_Object Vbuffer_alist;
152 /* Functions to call before and after each text change. */
153 Lisp_Object Qbefore_change_functions;
154 Lisp_Object Qafter_change_functions;
155 Lisp_Object Vbefore_change_functions;
156 Lisp_Object Vafter_change_functions;
158 /* #### Obsolete, for compatibility */
159 Lisp_Object Qbefore_change_function;
160 Lisp_Object Qafter_change_function;
161 Lisp_Object Vbefore_change_function;
162 Lisp_Object Vafter_change_function;
165 Lisp_Object Vtransient_mark_mode;
168 /* t means ignore all read-only text properties.
169 A list means ignore such a property if its value is a member of the list.
170 Any non-nil value means ignore buffer-read-only. */
171 Lisp_Object Vinhibit_read_only;
173 /* List of functions to call that can query about killing a buffer.
174 If any of these functions returns nil, we don't kill it. */
175 Lisp_Object Vkill_buffer_query_functions;
177 /* Non-nil means delete a buffer's auto-save file when the buffer is saved. */
178 int delete_auto_save_files;
180 Lisp_Object Qbuffer_live_p;
181 Lisp_Object Qbuffer_or_string_p;
183 /* List of functions to call before changing an unmodified buffer. */
184 Lisp_Object Vfirst_change_hook;
185 Lisp_Object Qfirst_change_hook;
187 Lisp_Object Qfundamental_mode;
188 Lisp_Object Qmode_class;
189 Lisp_Object Qpermanent_local;
191 Lisp_Object Qprotected_field;
193 Lisp_Object QSFundamental; /* A string "Fundamental" */
194 Lisp_Object QSscratch; /* "*scratch*" */
195 Lisp_Object Qdefault_directory;
197 Lisp_Object Qkill_buffer_hook;
199 Lisp_Object Qrename_auto_save_file;
201 Lisp_Object Qget_file_buffer;
202 Lisp_Object Qchange_major_mode_hook, Vchange_major_mode_hook;
204 Lisp_Object Qfind_file_compare_truenames;
206 Lisp_Object Qswitch_to_buffer;
208 /* Two thresholds controlling how much undo information to keep. */
210 int undo_high_threshold;
212 int find_file_compare_truenames;
213 int find_file_use_truenames;
216 static void reset_buffer_local_variables (struct buffer *, int first_time);
217 static void nuke_all_buffer_slots (struct buffer *b, Lisp_Object zap);
220 make_buffer (struct buffer *buf)
223 XSETBUFFER (obj, buf);
228 mark_buffer (Lisp_Object obj)
230 struct buffer *buf = XBUFFER (obj);
232 /* Truncate undo information. */
233 buf->undo_list = truncate_undo_list (buf->undo_list,
235 undo_high_threshold);
237 #define MARKED_SLOT(x) mark_object (buf->x)
238 #include "bufslots.h"
241 mark_object (buf->extent_info);
243 mark_object (buf->text->line_number_cache);
245 /* Don't mark normally through the children slot.
246 (Actually, in this case, it doesn't matter.) */
247 if (! EQ (buf->indirect_children, Qnull_pointer))
248 mark_conses_in_list (buf->indirect_children);
250 return buf->base_buffer ? make_buffer (buf->base_buffer) : Qnil;
254 print_buffer (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
256 struct buffer *b = XBUFFER (obj);
260 if (!BUFFER_LIVE_P (b))
261 error ("printing unreadable object #<killed buffer>");
263 error ("printing unreadable object #<buffer %s>",
264 XSTRING_DATA (b->name));
266 else if (!BUFFER_LIVE_P (b))
267 write_c_string ("#<killed buffer>", printcharfun);
270 write_c_string ("#<buffer ", printcharfun);
271 print_internal (b->name, printcharfun, 1);
272 write_c_string (">", printcharfun);
276 print_internal (b->name, printcharfun, 0);
280 /* We do not need a finalize method to handle a buffer's children list
281 because all buffers have `kill-buffer' applied to them before
282 they disappear, and the children removal happens then. */
283 DEFINE_LRECORD_IMPLEMENTATION ("buffer", buffer,
284 mark_buffer, print_buffer, 0, 0, 0, 0,
287 DEFUN ("bufferp", Fbufferp, 1, 1, 0, /*
288 Return t if OBJECT is an editor buffer.
292 return BUFFERP (object) ? Qt : Qnil;
295 DEFUN ("buffer-live-p", Fbuffer_live_p, 1, 1, 0, /*
296 Return t if OBJECT is an editor buffer that has not been deleted.
300 return BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object)) ? Qt : Qnil;
304 nsberror (Lisp_Object spec)
307 error ("No buffer named %s", XSTRING_DATA (spec));
308 signal_simple_error ("Invalid buffer argument", spec);
311 DEFUN ("buffer-list", Fbuffer_list, 0, 1, 0, /*
312 Return a list of all existing live buffers.
313 The order is specific to the selected frame; if the optional FRAME
314 argument is provided, the ordering for that frame is returned instead.
315 If the FRAME argument is t, then the global (non-frame) ordering is
320 return Fmapcar (Qcdr,
321 EQ (frame, Qt) ? Vbuffer_alist :
322 decode_frame (frame)->buffer_alist);
326 get_buffer (Lisp_Object name, int error_if_deleted_or_does_not_exist)
330 if (!BUFFER_LIVE_P (XBUFFER (name)))
332 if (error_if_deleted_or_does_not_exist)
344 name = LISP_GETTEXT (name); /* I18N3 */
346 buf = Fcdr (Fassoc (name, Vbuffer_alist));
348 if (NILP (buf) && error_if_deleted_or_does_not_exist)
355 decode_buffer (Lisp_Object buffer, int allow_string)
358 return current_buffer;
360 if (allow_string && STRINGP (buffer))
361 return XBUFFER (get_buffer (buffer, 1));
363 CHECK_LIVE_BUFFER (buffer);
364 return XBUFFER (buffer);
367 DEFUN ("decode-buffer", Fdecode_buffer, 1, 1, 0, /*
368 Validate BUFFER or if BUFFER is nil, return the current buffer.
369 If BUFFER is a valid buffer or a string representing a valid buffer,
370 the corresponding buffer object will be returned. Otherwise an error
375 struct buffer *b = decode_buffer (buffer, 1);
376 XSETBUFFER (buffer, b);
382 /* Like Fassoc, but use Fstring_equal to compare
383 (which ignores text properties),
384 and don't ever QUIT. */
387 assoc_ignore_text_properties (REGISTER Lisp_Object key, Lisp_Object list)
389 REGISTER Lisp_Object tail;
390 for (tail = list; !NILP (tail); tail = Fcdr (tail))
392 REGISTER Lisp_Object elt, tem;
394 tem = Fstring_equal (Fcar (elt), key);
403 DEFUN ("get-buffer", Fget_buffer, 1, 1, 0, /*
404 Return the buffer named NAME (a string).
405 If there is no live buffer named NAME, return nil.
406 NAME may also be a buffer; if so, the value is that buffer.
411 /* #### Doc string should indicate that the buffer name will get
415 /* #### This might return a dead buffer. This is gross. This is
416 called FSF compatibility. */
419 return get_buffer (name, 0);
420 /* FSFmacs 19.29 calls assoc_ignore_text_properties() here.
425 DEFUN ("get-file-buffer", Fget_file_buffer, 1, 1, 0, /*
426 Return the buffer visiting file FILENAME (a string).
427 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
428 If there is no such live buffer, return nil.
430 Normally, the comparison is done by canonicalizing FILENAME (using
431 `expand-file-name') and comparing that to the value of `buffer-file-name'
432 for each existing buffer. However, If `find-file-compare-truenames' is
433 non-nil, FILENAME will be converted to its truename and the search will be
434 done on each buffer's value of `buffer-file-truename' instead of
435 `buffer-file-name'. Otherwise, if `find-file-use-truenames' is non-nil,
436 FILENAME will be converted to its truename and used for searching, but
437 the search will still be done on `buffer-file-name'.
441 /* This function can GC. GC checked 1997.04.06. */
442 REGISTER Lisp_Object buf;
446 /* DO NOT translate the filename. */
449 CHECK_STRING (filename);
450 filename = Fexpand_file_name (filename, Qnil);
452 /* If the file name has special constructs in it,
453 call the corresponding file handler. */
454 Lisp_Object handler = Ffind_file_name_handler (filename, Qget_file_buffer);
458 return call2 (handler, Qget_file_buffer, filename);
463 if (find_file_compare_truenames || find_file_use_truenames)
465 struct gcpro ngcpro1, ngcpro2, ngcpro3;
466 Lisp_Object fn = Qnil;
467 Lisp_Object dn = Qnil;
469 NGCPRO3 (fn, dn, filename);
470 fn = Ffile_truename (filename, Qnil);
473 dn = Ffile_name_directory (filename);
474 fn = Ffile_truename (dn, Qnil);
475 if (! NILP (fn)) dn = fn;
476 fn = Fexpand_file_name (Ffile_name_nondirectory (filename),
485 LIST_LOOP_2 (elt, Vbuffer_alist)
488 if (!BUFFERP (buf)) continue;
489 if (!STRINGP (XBUFFER (buf)->filename)) continue;
490 if (!NILP (Fstring_equal (filename,
491 (find_file_compare_truenames
492 ? XBUFFER (buf)->file_truename
493 : XBUFFER (buf)->filename))))
502 push_buffer_alist (Lisp_Object name, Lisp_Object buf)
504 Lisp_Object cons = Fcons (name, buf);
505 Lisp_Object frmcons, devcons, concons;
507 Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (cons, Qnil));
508 FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
511 f = XFRAME (XCAR (frmcons));
512 f->buffer_alist = nconc2 (f->buffer_alist, Fcons (cons, Qnil));
517 delete_from_buffer_alist (Lisp_Object buf)
519 Lisp_Object cons = Frassq (buf, Vbuffer_alist);
520 Lisp_Object frmcons, devcons, concons;
522 return; /* abort() ? */
523 Vbuffer_alist = delq_no_quit (cons, Vbuffer_alist);
525 FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
528 f = XFRAME (XCAR (frmcons));
529 f->buffer_alist = delq_no_quit (cons, f->buffer_alist);
534 get_truename_buffer (REGISTER Lisp_Object filename)
536 /* FSFmacs has its own code here and doesn't call get-file-buffer.
537 That's because their equivalent of find-file-compare-truenames
538 (find-file-existing-other-name) isn't looked at in get-file-buffer.
539 This way is more correct. */
540 int count = specpdl_depth ();
542 specbind (Qfind_file_compare_truenames, Qt);
543 return unbind_to (count, Fget_file_buffer (filename));
546 static struct buffer *
547 allocate_buffer (void)
549 struct buffer *b = alloc_lcrecord_type (struct buffer, &lrecord_buffer);
551 copy_lcrecord (b, XBUFFER (Vbuffer_defaults));
557 finish_init_buffer (struct buffer *b, Lisp_Object name)
563 name = Fcopy_sequence (name);
564 /* #### This really does not need to be called. We already
565 initialized the buffer-local variables in allocate_buffer().
566 local_var_alist is set to Qnil at the same point, in
567 nuke_all_buffer_slots(). */
568 reset_buffer_local_variables (b, 1);
569 b->directory = current_buffer ? current_buffer->directory : Qnil;
571 b->last_window_start = 1;
574 if (string_byte (XSTRING (name), 0) != ' ')
579 /* initialize the extent list */
580 init_buffer_extents (b);
582 /* Put this in the alist of all live buffers. */
583 push_buffer_alist (name, buf);
585 init_buffer_markers (b);
587 b->generated_modeline_string = Fmake_string (make_int (84), make_int (' '));
588 b->modeline_extent_table = make_lisp_hash_table (20, HASH_TABLE_KEY_WEAK,
594 DEFUN ("get-buffer-create", Fget_buffer_create, 1, 1, 0, /*
595 Return the buffer named NAME, or create such a buffer and return it.
596 A new buffer is created if there is no live buffer named NAME.
597 If NAME starts with a space, the new buffer does not keep undo information.
598 If NAME is a buffer instead of a string, then it is the value returned.
599 The value is never nil.
603 /* This function can GC */
605 REGISTER struct buffer *b;
608 /* #### Doc string should indicate that the buffer name will get
612 name = LISP_GETTEXT (name);
613 buf = Fget_buffer (name);
617 if (XSTRING_LENGTH (name) == 0)
618 error ("Empty string for buffer name is not allowed");
620 b = allocate_buffer ();
622 b->text = &b->own_text;
624 b->indirect_children = Qnil;
625 init_buffer_text (b);
627 return finish_init_buffer (b, name);
630 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer, 2, 2,
631 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ", /*
632 Create and return an indirect buffer for buffer BASE, named NAME.
633 BASE should be an existing buffer (or buffer name).
634 NAME should be a string which is not the name of an existing buffer.
635 If BASE is an indirect buffer itself, the base buffer for that buffer
636 is made the base buffer for the newly created buffer. (Thus, there will
637 never be indirect buffers whose base buffers are themselves indirect.)
641 /* This function can GC */
643 /* #### The above interactive specification is totally bogus,
644 because it offers an existing buffer as default answer to the
645 second question. However, the second argument may not BE an
649 base_buffer = get_buffer (base_buffer, 1);
652 /* #### Doc string should indicate that the buffer name will get
656 name = LISP_GETTEXT (name);
657 if (!NILP (Fget_buffer (name)))
658 signal_simple_error ("Buffer name already in use", name);
659 if (XSTRING_LENGTH (name) == 0)
660 error ("Empty string for buffer name is not allowed");
662 b = allocate_buffer ();
664 b->base_buffer = BUFFER_BASE_BUFFER (XBUFFER (base_buffer));
666 /* Use the base buffer's text object. */
667 b->text = b->base_buffer->text;
668 b->indirect_children = Qnil;
669 b->base_buffer->indirect_children =
670 Fcons (make_buffer (b), b->base_buffer->indirect_children);
671 init_buffer_text (b);
673 return finish_init_buffer (b, name);
679 reset_buffer_local_variables (struct buffer *b, int first_time)
681 struct buffer *def = XBUFFER (Vbuffer_defaults);
683 b->local_var_flags = 0;
684 /* For each slot that has a default value,
685 copy that into the slot. */
686 #define MARKED_SLOT(slot) \
687 { int mask = XINT (buffer_local_flags.slot); \
688 if ((mask > 0 || mask == -1 || mask == -3) \
690 || NILP (Fget (XBUFFER (Vbuffer_local_symbols)->slot, \
691 Qpermanent_local, Qnil)))) \
692 b->slot = def->slot; \
694 #include "bufslots.h"
697 #define STRING256_P(obj) \
698 (STRINGP (obj) && XSTRING_CHAR_LENGTH (obj) == 256)
699 /* If the standard case table has been altered and invalidated,
700 fix up its insides first. */
701 if (!(STRING256_P(Vascii_upcase_table) &&
702 STRING256_P(Vascii_canon_table) &&
703 STRING256_P(Vascii_eqv_table)))
705 Fset_standard_case_table (Vascii_downcase_table);
707 b->downcase_table = Vascii_downcase_table;
708 b->upcase_table = Vascii_upcase_table;
709 b->case_canon_table = Vascii_canon_table;
710 b->case_eqv_table = Vascii_eqv_table;
712 b->mirror_downcase_table = Vmirror_ascii_downcase_table;
713 b->mirror_upcase_table = Vmirror_ascii_upcase_table;
714 b->mirror_case_canon_table = Vmirror_ascii_canon_table;
715 b->mirror_case_eqv_table = Vmirror_ascii_eqv_table;
721 /* We split this away from generate-new-buffer, because rename-buffer
722 and set-visited-file-name ought to be able to use this to really
723 rename the buffer properly. */
725 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name, 1, 2, 0, /*
726 Return a string that is the name of no existing buffer based on NAME.
727 If there is no live buffer named NAME, then return NAME.
728 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
729 until an unused name is found, and then return that name.
730 Optional second argument IGNORE specifies a name that is okay to use
731 \(if it is in the sequence to be tried)
732 even if a buffer with that name exists.
736 REGISTER Lisp_Object gentemp, tem;
742 name = LISP_GETTEXT (name);
744 /* #### Doc string should indicate that the buffer name will get
748 tem = Fget_buffer (name);
755 sprintf (number, "<%d>", ++count);
756 gentemp = concat2 (name, build_string (number));
759 tem = Fstring_equal (gentemp, ignore);
763 tem = Fget_buffer (gentemp);
770 DEFUN ("buffer-name", Fbuffer_name, 0, 1, 0, /*
771 Return the name of BUFFER, as a string.
772 With no argument or nil as argument, return the name of the current buffer.
776 /* For compatibility, we allow a dead buffer here.
777 Earlier versions of Emacs didn't provide buffer-live-p. */
779 return current_buffer->name;
780 CHECK_BUFFER (buffer);
781 return XBUFFER (buffer)->name;
784 DEFUN ("buffer-file-name", Fbuffer_file_name, 0, 1, 0, /*
785 Return name of file BUFFER is visiting, or nil if none.
786 No argument or nil as argument means use the current buffer.
790 /* For compatibility, we allow a dead buffer here. Yuck! */
792 return current_buffer->filename;
793 CHECK_BUFFER (buffer);
794 return XBUFFER (buffer)->filename;
797 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer, 0, 1, 0, /*
798 Return the base buffer of indirect buffer BUFFER.
799 If BUFFER is not indirect, return nil.
803 struct buffer *buf = decode_buffer (buffer, 0);
805 return buf->base_buffer ? make_buffer (buf->base_buffer) : Qnil;
808 DEFUN ("buffer-indirect-children", Fbuffer_indirect_children, 0, 1, 0, /*
809 Return a list of all indirect buffers whose base buffer is BUFFER.
810 If BUFFER is indirect, the return value will always be nil; see
811 `make-indirect-buffer'.
815 struct buffer *buf = decode_buffer (buffer, 0);
817 return Fcopy_sequence (buf->indirect_children);
820 DEFUN ("buffer-local-variables", Fbuffer_local_variables, 0, 1, 0, /*
821 Return an alist of variables that are buffer-local in BUFFER.
822 Most elements look like (SYMBOL . VALUE), describing one variable.
823 For a symbol that is locally unbound, just the symbol appears in the value.
824 Note that storing new VALUEs in these elements doesn't change the variables.
825 No argument or nil as argument means use current buffer as BUFFER.
829 struct buffer *buf = decode_buffer (buffer, 0);
830 Lisp_Object result = Qnil;
834 for (tail = buf->local_var_alist; CONSP (tail); tail = XCDR (tail))
836 Lisp_Object elt = XCAR (tail);
837 /* Reference each variable in the alist in buf.
838 If inquiring about the current buffer, this gets the current values,
839 so store them into the alist so the alist is up to date.
840 If inquiring about some other buffer, this swaps out any values
841 for that buffer, making the alist up to date automatically. */
842 Lisp_Object val = find_symbol_value (XCAR (elt));
843 /* Use the current buffer value only if buf is the current buffer. */
844 if (buf != current_buffer)
847 /* If symbol is unbound, put just the symbol in the list. */
849 result = Fcons (XCAR (elt), result);
850 /* Otherwise, put (symbol . value) in the list. */
852 result = Fcons (Fcons (XCAR (elt), val), result);
856 /* Add on all the variables stored in special slots. */
858 struct buffer *syms = XBUFFER (Vbuffer_local_symbols);
859 #define MARKED_SLOT(slot) \
860 { int mask = XINT (buffer_local_flags.slot); \
861 if (mask == 0 || mask == -1 \
862 || ((mask > 0) && (buf->local_var_flags & mask))) \
863 result = Fcons (Fcons (syms->slot, buf->slot), result); \
865 #include "bufslots.h"
871 DEFUN ("buffer-dedicated-frame", Fbuffer_dedicated_frame, 0, 1, 0, /*
872 Return the frame dedicated to this BUFFER, or nil if there is none.
873 No argument or nil as argument means use current buffer as BUFFER.
877 struct buffer *buf = decode_buffer (buffer, 0);
879 /* XEmacs addition: if the frame is dead, silently make it go away. */
880 if (!NILP (buf->dedicated_frame) &&
881 !FRAME_LIVE_P (XFRAME (buf->dedicated_frame)))
882 buf->dedicated_frame = Qnil;
884 return buf->dedicated_frame;
887 DEFUN ("set-buffer-dedicated-frame", Fset_buffer_dedicated_frame, 2, 2, 0, /*
888 For this BUFFER, set the FRAME dedicated to it.
889 FRAME must be a frame or nil.
893 struct buffer *buf = decode_buffer (buffer, 0);
896 CHECK_LIVE_FRAME (frame); /* XEmacs change */
898 return buf->dedicated_frame = frame;
903 DEFUN ("buffer-modified-p", Fbuffer_modified_p, 0, 1, 0, /*
904 Return t if BUFFER was modified since its file was last read or saved.
905 No argument or nil as argument means use current buffer as BUFFER.
909 struct buffer *buf = decode_buffer (buffer, 0);
911 return BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf) ? Qt : Qnil;
914 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p, 1, 2, 0, /*
915 Mark BUFFER as modified or unmodified according to FLAG.
916 A non-nil FLAG means mark the buffer modified. No argument or nil
917 as BUFFER means use current buffer.
921 /* This function can GC */
922 struct buffer *buf = decode_buffer (buffer, 0);
924 #ifdef CLASH_DETECTION
925 /* If buffer becoming modified, lock the file.
926 If buffer becoming unmodified, unlock the file. */
928 Lisp_Object fn = buf->file_truename;
931 int already = BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf);
932 if (already == NILP (flag))
934 int count = specpdl_depth ();
935 /* lock_file() and unlock_file() currently use current_buffer */
936 /* #### - dmoore, what if lock_file or unlock_file kill
937 the current buffer? */
938 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
939 set_buffer_internal (buf);
940 if (!already && !NILP (flag))
942 else if (already && NILP (flag))
944 unbind_to (count, Qnil);
947 #endif /* CLASH_DETECTION */
949 /* This is often called when the buffer contents are altered but we
950 don't want to treat the changes that way (e.g. selective
951 display). We still need to make sure redisplay realizes that the
952 contents have potentially altered and it needs to do some
954 buf = decode_buffer(buffer, 0);
956 BUF_SAVE_MODIFF (buf) = NILP (flag) ? BUF_MODIFF (buf) : 0;
957 MARK_MODELINE_CHANGED;
962 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick, 0, 1, 0, /*
963 Return BUFFER's tick counter, incremented for each change in text.
964 Each buffer has a tick counter which is incremented each time the text in
965 that buffer is changed. It wraps around occasionally.
966 No argument or nil as argument means use current buffer as BUFFER.
970 struct buffer *buf = decode_buffer (buffer, 0);
972 return make_int (BUF_MODIFF (buf));
975 DEFUN ("rename-buffer", Frename_buffer, 1, 2,
976 "sRename buffer (to new name): \nP", /*
977 Change current buffer's name to NEWNAME (a string).
978 If second arg UNIQUE is nil or omitted, it is an error if a
979 buffer named NEWNAME already exists.
980 If UNIQUE is non-nil, come up with a new name using
981 `generate-new-buffer-name'.
982 Interactively, one can set UNIQUE with a prefix argument.
983 Returns the name we actually gave the buffer.
984 This does not change the name of the visited file (if any).
988 /* This function can GC */
989 Lisp_Object tem, buf;
992 /* #### Doc string should indicate that the buffer name will get
995 CHECK_STRING (newname);
996 newname = LISP_GETTEXT (newname);
998 if (XSTRING_LENGTH (newname) == 0)
999 error ("Empty string is invalid as a buffer name");
1001 tem = Fget_buffer (newname);
1002 /* Don't short-circuit if UNIQUE is t. That is a useful way to rename
1003 the buffer automatically so you can create another with the original name.
1004 It makes UNIQUE equivalent to
1005 (rename-buffer (generate-new-buffer-name NEWNAME)). */
1006 /* XEmacs change: added check for nil */
1007 if (NILP (unique) && !NILP (tem) && XBUFFER (tem) == current_buffer)
1008 return current_buffer->name;
1012 newname = Fgenerate_new_buffer_name (newname, current_buffer->name);
1014 error ("Buffer name \"%s\" is in use",
1015 XSTRING_DATA (newname));
1018 current_buffer->name = newname;
1020 /* Catch redisplay's attention. Unless we do this, the modelines for
1021 any windows displaying current_buffer will stay unchanged. */
1022 MARK_MODELINE_CHANGED;
1024 buf = Fcurrent_buffer ();
1026 /* The aconses in the Vbuffer_alist are shared with frame->buffer_alist,
1027 so this will change it in the per-frame ordering as well. */
1028 Fsetcar (Frassq (buf, Vbuffer_alist), newname);
1030 if (NILP (current_buffer->filename)
1031 && !NILP (current_buffer->auto_save_file_name))
1032 call0 (Qrename_auto_save_file);
1033 /* refetch since that last call may have done GC */
1034 /* (hypothetical relocating GC) */
1035 return current_buffer->name;
1038 DEFUN ("other-buffer", Fother_buffer, 0, 3, 0, /*
1039 Return most recently selected buffer other than BUFFER.
1040 Buffers not visible in windows are preferred to visible buffers,
1041 unless optional third argument VISIBLE-OK is non-nil.
1042 If no other buffer exists, the buffer `*scratch*' is returned.
1043 If BUFFER is omitted or nil, some interesting buffer is returned.
1045 The ordering is for this frame; If second optional argument FRAME
1046 is provided, then the ordering is for that frame. If the second arg
1047 is t, then the global ordering is returned.
1049 Note: In FSF Emacs, this function takes two arguments: BUFFER and
1052 (buffer, frame, visible_ok))
1054 /* This function can GC */
1055 Lisp_Object tail, buf, notsogood, tem;
1061 alist = Vbuffer_alist;
1064 struct frame *f = decode_frame (frame);
1066 XSETFRAME (frame, f);
1067 alist = f->buffer_alist;
1070 for (tail = alist; !NILP (tail); tail = Fcdr (tail))
1072 buf = Fcdr (Fcar (tail));
1073 if (EQ (buf, buffer))
1075 if (string_byte (XSTRING (XBUFFER (buf)->name), 0) == ' ')
1077 /* If FRAME has a buffer_predicate,
1078 disregard buffers that don't fit the predicate. */
1081 tem = XFRAME (frame)->buffer_predicate;
1084 tem = call1 (tem, buf);
1090 if (NILP (visible_ok))
1092 /* get-buffer-window will handle nil or t frame */
1093 tem = Fget_buffer_window (buf, frame, Qnil);
1099 if (NILP (notsogood))
1102 if (!NILP (notsogood))
1104 return Fget_buffer_create (QSscratch);
1107 DEFUN ("buffer-disable-undo", Fbuffer_disable_undo, 0, 1, "", /*
1108 Make BUFFER stop keeping undo information.
1109 Any undo records it already has are discarded.
1110 No argument or nil as argument means do this for the current buffer.
1114 /* Allowing nil is an RMSism */
1115 struct buffer *real_buf = decode_buffer (buffer, 1);
1116 real_buf->undo_list = Qt;
1120 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo, 0, 1, "", /*
1121 Start keeping undo information for buffer BUFFER.
1122 No argument or nil as argument means do this for the current buffer.
1126 /* Allowing nil is an RMSism */
1127 struct buffer *real_buf = decode_buffer (buffer, 1);
1128 if (EQ (real_buf->undo_list, Qt))
1129 real_buf->undo_list = Qnil;
1134 DEFUN ("kill-buffer", Fkill_buffer, 1, 1, "bKill buffer: ", /*
1135 Kill the buffer BUFFER.
1136 The argument may be a buffer or may be the name of a buffer.
1137 An argument of nil means kill the current buffer.
1139 Value is t if the buffer is actually killed, nil if user says no.
1141 The value of `kill-buffer-hook' (which may be local to that buffer),
1142 if not void, is a list of functions to be called, with no arguments,
1143 before the buffer is actually killed. The buffer to be killed is current
1144 when the hook functions are called.
1146 Any processes that have this buffer as the `process-buffer' are killed
1147 with `delete-process'.
1151 /* This function can call lisp */
1153 REGISTER struct buffer *b;
1154 struct gcpro gcpro1, gcpro2;
1157 buf = Fcurrent_buffer ();
1158 else if (BUFFERP (buffer))
1162 buf = get_buffer (buffer, 0);
1163 if (NILP (buf)) nsberror (buffer);
1168 /* OK to delete an already-deleted buffer. */
1169 if (!BUFFER_LIVE_P (b))
1172 /* Don't kill the minibuffer now current. */
1173 if (EQ (buf, Vminibuffer_zero))
1176 /* Or the echo area. */
1177 if (EQ (buf, Vecho_area_buffer))
1180 /* Query if the buffer is still modified. */
1181 if (INTERACTIVE && !NILP (b->filename)
1182 && BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
1188 (emacs_doprnt_string_c
1189 ((const Bufbyte *) GETTEXT ("Buffer %s modified; kill anyway? "),
1190 Qnil, -1, XSTRING_DATA (b->name))));
1194 b = XBUFFER (buf); /* Hypothetical relocating GC. */
1197 /* Run hooks with the buffer to be killed temporarily selected,
1198 unless the buffer is already dead (could have been deleted
1199 in the question above).
1201 if (BUFFER_LIVE_P (b))
1203 int speccount = specpdl_depth ();
1204 Lisp_Object tail = Qnil;
1207 record_unwind_protect (save_excursion_restore, save_excursion_save ());
1210 /* First run the query functions; if any query is answered no,
1211 don't kill the buffer. */
1212 EXTERNAL_LIST_LOOP (tail, Vkill_buffer_query_functions)
1214 if (NILP (call0 (Fcar (tail))))
1217 return unbind_to (speccount, Qnil);
1221 /* Then run the hooks. */
1222 run_hook (Qkill_buffer_hook);
1223 #ifdef HAVE_X_WINDOWS
1224 /* If an X selection was in this buffer, disown it.
1225 We could have done this by simply adding this function to the
1226 kill-buffer-hook, but the user might mess that up.
1228 if (EQ (Vwindow_system, Qx))
1229 call0 (intern ("xselect-kill-buffer-hook"));
1230 /* #### generalize me! */
1231 #endif /* HAVE_X_WINDOWS */
1232 unbind_to (speccount, Qnil);
1234 b = XBUFFER (buf); /* Hypothetical relocating GC. */
1237 /* We have no more questions to ask. Verify that it is valid
1238 to kill the buffer. This must be done after the questions
1239 since anything can happen within yes-or-no-p. */
1241 /* Might have been deleted during the last question above */
1242 if (!BUFFER_LIVE_P (b))
1245 /* Don't kill the minibuffer now current. */
1246 if (EQ (buf, XWINDOW (minibuf_window)->buffer))
1249 /* When we kill a base buffer, kill all its indirect buffers.
1250 We do it at this stage so nothing terrible happens if they
1251 ask questions or their hooks get errors. */
1252 if (! b->base_buffer)
1258 LIST_LOOP (rest, b->indirect_children)
1260 Fkill_buffer (XCAR (rest));
1261 /* Keep indirect_children updated in case a
1262 query-function/hook throws. */
1263 b->indirect_children = XCDR (rest);
1269 /* Make this buffer not be current.
1270 In the process, notice if this is the sole visible buffer
1271 and give up if so. */
1272 if (b == current_buffer)
1274 Fset_buffer (Fother_buffer (buf, Qnil, Qnil));
1275 if (b == current_buffer)
1279 /* Now there is no question: we can kill the buffer. */
1281 #ifdef CLASH_DETECTION
1282 /* Unlock this buffer's file, if it is locked. unlock_buffer
1283 can both GC and kill the current buffer, and wreak general
1284 havok by running lisp code. */
1290 if (!BUFFER_LIVE_P (b))
1293 if (b == current_buffer)
1295 Fset_buffer (Fother_buffer (buf, Qnil, Qnil));
1296 if (b == current_buffer)
1299 #endif /* CLASH_DETECTION */
1302 int speccount = specpdl_depth ();
1303 specbind (Qinhibit_quit, Qt);
1305 kill_buffer_processes (buf);
1307 delete_from_buffer_alist (buf);
1309 /* #### This is a problem if this buffer is in a dedicated window.
1310 Need to undedicate any windows of this buffer first (and delete them?)
1312 Freplace_buffer_in_windows (buf);
1314 font_lock_buffer_was_killed (b);
1316 /* Delete any auto-save file, if we saved it in this session. */
1317 if (STRINGP (b->auto_save_file_name)
1318 && b->auto_save_modified != 0
1319 && BUF_SAVE_MODIFF (b) < b->auto_save_modified)
1321 if (delete_auto_save_files != 0)
1323 /* deleting the auto save file might kill b! */
1324 /* #### dmoore - fix this crap, we do this same gcpro and
1325 buffer liveness check multiple times. Let's get a
1326 macro or something for it. */
1328 internal_delete_file (b->auto_save_file_name);
1332 if (!BUFFER_LIVE_P (b))
1335 if (b == current_buffer)
1337 Fset_buffer (Fother_buffer (buf, Qnil, Qnil));
1338 if (b == current_buffer)
1344 uninit_buffer_markers (b);
1346 kill_buffer_local_variables (b);
1349 uninit_buffer_text (b);
1350 b->undo_list = Qnil;
1351 uninit_buffer_extents (b);
1354 #ifdef ERROR_CHECK_BUFPOS
1355 assert (!NILP (memq_no_quit (buf, b->base_buffer->indirect_children)));
1357 b->base_buffer->indirect_children =
1358 delq_no_quit (buf, b->base_buffer->indirect_children);
1361 /* Clear away all Lisp objects, so that they
1362 won't be protected from GC. */
1363 nuke_all_buffer_slots (b, Qnil);
1365 unbind_to (speccount, Qnil);
1370 DEFUN ("record-buffer", Frecord_buffer, 1, 1, 0, /*
1371 Place buffer BUFFER first in the buffer order.
1372 Call this function when a buffer is selected "visibly".
1374 This function changes the global buffer order and the per-frame buffer
1375 order for the selected frame. The buffer order keeps track of recency
1376 of selection so that `other-buffer' will return a recently selected
1377 buffer. See `other-buffer' for more information.
1381 REGISTER Lisp_Object lynk, prev;
1382 struct frame *f = selected_frame ();
1385 for (lynk = Vbuffer_alist; CONSP (lynk); lynk = XCDR (lynk))
1387 if (EQ (XCDR (XCAR (lynk)), buffer))
1391 /* Effectively do Vbuffer_alist = delq_no_quit (lynk, Vbuffer_alist) */
1393 Vbuffer_alist = XCDR (Vbuffer_alist);
1395 XCDR (prev) = XCDR (XCDR (prev));
1396 XCDR (lynk) = Vbuffer_alist;
1397 Vbuffer_alist = lynk;
1399 /* That was the global one. Now do the same thing for the
1400 per-frame buffer-alist. */
1402 for (lynk = f->buffer_alist; CONSP (lynk); lynk = XCDR (lynk))
1404 if (EQ (XCDR (XCAR (lynk)), buffer))
1408 /* Effectively do f->buffer_alist = delq_no_quit (lynk, f->buffer_alist) */
1410 f->buffer_alist = XCDR (f->buffer_alist);
1412 XCDR (prev) = XCDR (XCDR (prev));
1413 XCDR (lynk) = f->buffer_alist;
1414 f->buffer_alist = lynk;
1419 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode, 1, 1, 0, /*
1420 Set an appropriate major mode for BUFFER, according to `default-major-mode'.
1421 Use this function before selecting the buffer, since it may need to inspect
1422 the current buffer's major mode.
1426 int speccount = specpdl_depth ();
1427 Lisp_Object function = XBUFFER (Vbuffer_defaults)->major_mode;
1429 if (NILP (function))
1431 Lisp_Object tem = Fget (current_buffer->major_mode, Qmode_class, Qnil);
1433 function = current_buffer->major_mode;
1436 if (NILP (function) || EQ (function, Qfundamental_mode))
1439 /* To select a nonfundamental mode,
1440 select the buffer temporarily and then call the mode function. */
1442 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
1444 Fset_buffer (buffer);
1447 return unbind_to (speccount, Qnil);
1451 switch_to_buffer (Lisp_Object bufname, Lisp_Object norecord)
1453 call2 (Qswitch_to_buffer, bufname, norecord);
1457 DEFUN ("current-buffer", Fcurrent_buffer, 0, 0, 0, /*
1458 Return the current buffer as a Lisp object.
1463 XSETBUFFER (buffer, current_buffer);
1467 /* Set the current buffer to B. */
1470 set_buffer_internal (struct buffer *b)
1472 REGISTER struct buffer *old_buf;
1473 REGISTER Lisp_Object tail;
1475 if (current_buffer == b)
1478 INVALIDATE_PIXEL_TO_GLYPH_CACHE;
1480 old_buf = current_buffer;
1482 invalidate_current_column (); /* invalidate indentation cache */
1485 if (!noninteractive && initialized)
1487 extern Lisp_Object Ffep_force_on (), Ffep_force_off (), Ffep_get_mode ();
1489 old_buf->fep_mode = Ffep_get_mode ();
1491 if (!NILP (current_buffer->fep_mode))
1496 #endif /* HAVE_FEP */
1500 /* Put the undo list back in the base buffer, so that it appears
1501 that an indirect buffer shares the undo list of its base. */
1502 if (old_buf->base_buffer)
1503 old_buf->base_buffer->undo_list = old_buf->undo_list;
1506 /* Get the undo list from the base buffer, so that it appears
1507 that an indirect buffer shares the undo list of its base. */
1509 b->undo_list = b->base_buffer->undo_list;
1511 /* Look down buffer's list of local Lisp variables
1512 to find and update any that forward into C variables. */
1514 LIST_LOOP (tail, b->local_var_alist)
1516 Lisp_Object sym = XCAR (XCAR (tail));
1517 Lisp_Object valcontents = XSYMBOL (sym)->value;
1518 if (SYMBOL_VALUE_MAGIC_P (valcontents))
1520 /* Just reference the variable
1521 to cause it to become set for this buffer. */
1522 /* Use find_symbol_value_quickly to avoid an unnecessary O(n)
1524 (void) find_symbol_value_quickly (XCAR (tail), 1);
1528 /* Do the same with any others that were local to the previous buffer */
1532 LIST_LOOP (tail, old_buf->local_var_alist)
1534 Lisp_Object sym = XCAR (XCAR (tail));
1535 Lisp_Object valcontents = XSYMBOL (sym)->value;
1537 if (SYMBOL_VALUE_MAGIC_P (valcontents))
1539 /* Just reference the variable
1540 to cause it to become set for this buffer. */
1541 /* Use find_symbol_value_quickly with find_it_p as 0 to avoid an
1542 unnecessary O(n) lookup which is guaranteed to be worst case.
1543 Any symbols which are local are guaranteed to have been
1544 handled in the previous loop, above. */
1545 (void) find_symbol_value_quickly (sym, 0);
1551 DEFUN ("set-buffer", Fset_buffer, 1, 1, 0, /*
1552 Make the buffer BUFFER current for editing operations.
1553 BUFFER may be a buffer or the name of an existing buffer.
1554 See also `save-excursion' when you want to make a buffer current temporarily.
1555 This function does not display the buffer, so its effect ends
1556 when the current command terminates.
1557 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.
1561 buffer = get_buffer (buffer, 0);
1563 error ("Selecting deleted or non-existent buffer");
1564 set_buffer_internal (XBUFFER (buffer));
1569 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only, 0, 3, 0, /*
1570 Signal a `buffer-read-only' error if the buffer is read-only.
1571 Optional argument BUFFER defaults to the current buffer.
1573 If optional argument START is non-nil, all extents in the buffer
1574 which overlap that part of the buffer are checked to ensure none has a
1575 `read-only' property. (Extents that lie completely within the range,
1576 however, are not checked.) END defaults to the value of START.
1578 If START and END are equal, the range checked is [START, END] (i.e.
1579 closed on both ends); otherwise, the range checked is (START, END)
1580 \(open on both ends), except that extents that lie completely within
1581 [START, END] are not checked. See `extent-in-region-p' for a fuller
1584 (buffer, start, end))
1586 struct buffer *b = decode_buffer (buffer, 0);
1595 get_buffer_range_char (b, start, end, &s, &e, 0);
1597 barf_if_buffer_read_only (b, s, e);
1603 bury_buffer_1 (Lisp_Object buffer, Lisp_Object before,
1604 Lisp_Object *buffer_alist)
1606 Lisp_Object aelt = rassq_no_quit (buffer, *buffer_alist);
1607 Lisp_Object lynk = memq_no_quit (aelt, *buffer_alist);
1608 Lisp_Object iter, before_before;
1610 *buffer_alist = delq_no_quit (aelt, *buffer_alist);
1611 for (before_before = Qnil, iter = *buffer_alist;
1612 !NILP (iter) && !EQ (XCDR (XCAR (iter)), before);
1613 before_before = iter, iter = XCDR (iter))
1616 if (!NILP (before_before))
1617 XCDR (before_before) = lynk;
1619 *buffer_alist = lynk;
1622 DEFUN ("bury-buffer", Fbury_buffer, 0, 2, "", /*
1623 Put BUFFER at the end of the list of all buffers.
1624 There it is the least likely candidate for `other-buffer' to return;
1625 thus, the least likely buffer for \\[switch-to-buffer] to select by default.
1626 If BUFFER is nil or omitted, bury the current buffer.
1627 Also, if BUFFER is nil or omitted, remove the current buffer from the
1628 selected window if it is displayed there.
1629 Because of this, you may need to specify (current-buffer) as
1630 BUFFER when calling from minibuffer.
1631 If BEFORE is non-nil, it specifies a buffer before which BUFFER
1632 will be placed, instead of being placed at the end.
1636 /* This function can GC */
1637 struct buffer *buf = decode_buffer (buffer, 1);
1638 /* If we're burying the current buffer, unshow it. */
1639 /* Note that the behavior of (bury-buffer nil) and
1640 (bury-buffer (current-buffer)) is not the same.
1641 This is illogical but is historical. Changing it
1642 breaks mh-e and TeX and such packages. */
1644 switch_to_buffer (Fother_buffer (Fcurrent_buffer (), Qnil, Qnil), Qnil);
1645 XSETBUFFER (buffer, buf);
1648 before = get_buffer (before, 1);
1650 if (EQ (before, buffer))
1651 error ("Cannot place a buffer before itself");
1653 bury_buffer_1 (buffer, before, &Vbuffer_alist);
1654 bury_buffer_1 (buffer, before, &selected_frame ()->buffer_alist);
1660 DEFUN ("erase-buffer", Ferase_buffer, 0, 1, "*", /*
1661 Delete the entire contents of the BUFFER.
1662 Any clipping restriction in effect (see `narrow-to-region') is removed,
1663 so the buffer is truly empty after this.
1664 BUFFER defaults to the current buffer if omitted.
1668 /* This function can GC */
1669 struct buffer *b = decode_buffer (buffer, 1);
1670 /* #### yuck yuck yuck. This is gross. The old echo-area code,
1671 however, was the only place that called erase_buffer() with a
1672 non-zero NO_CLIP argument.
1674 Someone needs to fix up the redisplay code so it is smarter
1675 about this, so that the NO_CLIP junk isn't necessary. */
1676 int no_clip = (b == XBUFFER (Vecho_area_buffer));
1678 INVALIDATE_PIXEL_TO_GLYPH_CACHE;
1680 widen_buffer (b, no_clip);
1681 buffer_delete_range (b, BUF_BEG (b), BUF_Z (b), 0);
1682 b->last_window_start = 1;
1684 /* Prevent warnings, or suspension of auto saving, that would happen
1685 if future size is less than past size. Use of erase-buffer
1686 implies that the future text is not really related to the past text. */
1687 b->saved_size = Qzero;
1689 zmacs_region_stays = 0;
1695 DEFUN ("kill-all-local-variables", Fkill_all_local_variables, 0, 0, 0, /*
1696 Switch to Fundamental mode by killing current buffer's local variables.
1697 Most local variable bindings are eliminated so that the default values
1698 become effective once more. Also, the syntax table is set from
1699 `standard-syntax-table', the category table is set from
1700 `standard-category-table' (if support for Mule exists), local keymap is set
1701 to nil, the abbrev table is set from `fundamental-mode-abbrev-table',
1702 and all specifier specifications whose locale is the current buffer
1703 are removed. This function also forces redisplay of the modeline.
1705 Every function to select a new major mode starts by
1706 calling this function.
1708 As a special exception, local variables whose names have
1709 a non-nil `permanent-local' property are not eliminated by this function.
1711 The first thing this function does is run
1712 the normal hook `change-major-mode-hook'.
1716 /* This function can GC */
1717 run_hook (Qchange_major_mode_hook);
1719 reset_buffer_local_variables (current_buffer, 0);
1721 kill_buffer_local_variables (current_buffer);
1723 kill_specifier_buffer_locals (Fcurrent_buffer ());
1725 /* Force modeline redisplay. Useful here because all major mode
1726 commands call this function. */
1727 MARK_MODELINE_CHANGED;
1732 #ifdef MEMORY_USAGE_STATS
1743 compute_buffer_text_usage (struct buffer *b, struct overhead_stats *ovstats)
1745 int was_requested = b->text->z - 1;
1746 size_t gap = b->text->gap_size + b->text->end_gap_size;
1747 size_t malloc_use = malloced_storage_size (b->text->beg, was_requested + gap, 0);
1749 ovstats->gap_overhead += gap;
1750 ovstats->was_requested += was_requested;
1751 ovstats->malloc_overhead += malloc_use - (was_requested + gap);
1756 compute_buffer_usage (struct buffer *b, struct buffer_stats *stats,
1757 struct overhead_stats *ovstats)
1760 stats->other += malloced_storage_size (b, sizeof (*b), ovstats);
1761 stats->text += compute_buffer_text_usage (b, ovstats);
1762 stats->markers += compute_buffer_marker_usage (b, ovstats);
1763 stats->extents += compute_buffer_extent_usage (b, ovstats);
1766 DEFUN ("buffer-memory-usage", Fbuffer_memory_usage, 1, 1, 0, /*
1767 Return stats about the memory usage of buffer BUFFER.
1768 The values returned are in the form of an alist of usage types and byte
1769 counts. The byte counts attempt to encompass all the memory used
1770 by the buffer (separate from the memory logically associated with a
1771 buffer or frame), including internal structures and any malloc()
1772 overhead associated with them. In practice, the byte counts are
1773 underestimated because certain memory usage is very hard to determine
1774 \(e.g. the amount of memory used inside the Xt library or inside the
1775 X server) and because there is other stuff that might logically
1776 be associated with a window, buffer, or frame (e.g. window configurations,
1777 glyphs) but should not obviously be included in the usage counts.
1779 Multiple slices of the total memory usage may be returned, separated
1780 by a nil. Each slice represents a particular view of the memory, a
1781 particular way of partitioning it into groups. Within a slice, there
1782 is no overlap between the groups of memory, and each slice collectively
1783 represents all the memory concerned.
1787 struct buffer_stats stats;
1788 struct overhead_stats ovstats;
1789 Lisp_Object val = Qnil;
1791 CHECK_BUFFER (buffer); /* dead buffers should be allowed, no? */
1793 compute_buffer_usage (XBUFFER (buffer), &stats, &ovstats);
1795 val = acons (Qtext, make_int (stats.text), val);
1796 val = acons (Qmarkers, make_int (stats.markers), val);
1797 val = acons (Qextents, make_int (stats.extents), val);
1798 val = acons (Qother, make_int (stats.other), val);
1799 val = Fcons (Qnil, val);
1800 val = acons (Qactually_requested, make_int (ovstats.was_requested), val);
1801 val = acons (Qmalloc_overhead, make_int (ovstats.malloc_overhead), val);
1802 val = acons (Qgap_overhead, make_int (ovstats.gap_overhead), val);
1803 val = acons (Qdynarr_overhead, make_int (ovstats.dynarr_overhead), val);
1805 return Fnreverse (val);
1808 #endif /* MEMORY_USAGE_STATS */
1811 /************************************************************************/
1812 /* Implement TO_EXTERNAL_FORMAT, TO_INTERNAL_FORMAT */
1813 /************************************************************************/
1815 /* This implementation should probably be elsewhere, but it can't be
1816 in file-coding.c since that file is only available if FILE_CODING
1820 coding_system_is_binary (Lisp_Object coding_system)
1822 Lisp_Coding_System *cs = XCODING_SYSTEM (coding_system);
1824 (CODING_SYSTEM_TYPE (cs) == CODESYS_NO_CONVERSION &&
1825 CODING_SYSTEM_EOL_TYPE (cs) == EOL_LF &&
1826 EQ (CODING_SYSTEM_POST_READ_CONVERSION (cs), Qnil) &&
1827 EQ (CODING_SYSTEM_PRE_WRITE_CONVERSION (cs), Qnil));
1830 #define coding_system_is_binary(coding_system) 1
1835 Dynarr_declare (Bufbyte_dynarr *);
1836 } Bufbyte_dynarr_dynarr;
1840 Dynarr_declare (Extbyte_dynarr *);
1841 } Extbyte_dynarr_dynarr;
1843 static Extbyte_dynarr_dynarr *conversion_out_dynarr_list;
1844 static Bufbyte_dynarr_dynarr *conversion_in_dynarr_list;
1846 static int dfc_convert_to_external_format_in_use;
1847 static int dfc_convert_to_internal_format_in_use;
1850 dfc_convert_to_external_format_reset_in_use (Lisp_Object value)
1852 dfc_convert_to_external_format_in_use = XINT (value);
1857 dfc_convert_to_internal_format_reset_in_use (Lisp_Object value)
1859 dfc_convert_to_internal_format_in_use = XINT (value);
1864 dfc_convert_to_external_format (dfc_conversion_type source_type,
1865 dfc_conversion_data *source,
1867 Lisp_Object coding_system,
1869 dfc_conversion_type sink_type,
1870 dfc_conversion_data *sink)
1872 int count = specpdl_depth ();
1873 Extbyte_dynarr *conversion_out_dynarr;
1875 type_checking_assert
1876 (((source_type == DFC_TYPE_DATA) ||
1877 (source_type == DFC_TYPE_LISP_LSTREAM && LSTREAMP (source->lisp_object)) ||
1878 (source_type == DFC_TYPE_LISP_STRING && STRINGP (source->lisp_object)))
1880 ((sink_type == DFC_TYPE_DATA) ||
1881 (sink_type == DFC_TYPE_LISP_LSTREAM && LSTREAMP (source->lisp_object))));
1883 record_unwind_protect (dfc_convert_to_external_format_reset_in_use,
1884 make_int (dfc_convert_to_external_format_in_use));
1885 if (Dynarr_length (conversion_out_dynarr_list) <=
1886 dfc_convert_to_external_format_in_use)
1887 Dynarr_add (conversion_out_dynarr_list, Dynarr_new (Extbyte));
1888 conversion_out_dynarr = Dynarr_at (conversion_out_dynarr_list,
1889 dfc_convert_to_external_format_in_use);
1890 dfc_convert_to_external_format_in_use++;
1891 Dynarr_reset (conversion_out_dynarr);
1894 coding_system = Fget_coding_system (coding_system);
1897 /* Here we optimize in the case where the coding system does no
1898 conversion. However, we don't want to optimize in case the source
1899 or sink is an lstream, since writing to an lstream can cause a
1900 garbage collection, and this could be problematic if the source
1901 is a lisp string. */
1902 if (source_type != DFC_TYPE_LISP_LSTREAM &&
1903 sink_type != DFC_TYPE_LISP_LSTREAM &&
1904 coding_system_is_binary (coding_system))
1909 if (source_type == DFC_TYPE_LISP_STRING)
1911 ptr = XSTRING_DATA (source->lisp_object);
1912 len = XSTRING_LENGTH (source->lisp_object);
1916 ptr = (Bufbyte *) source->data.ptr;
1917 len = source->data.len;
1923 for (end = ptr + len; ptr < end;)
1927 (*ptr < 0xc0) ? *ptr :
1928 ((*ptr & 0x1f) << 6) | (*(ptr+1) & 0x3f);
1931 (BYTE_ASCII_P (*ptr)) ? *ptr :
1932 (*ptr == LEADING_BYTE_CONTROL_1) ? (*(ptr+1) - 0x20) :
1933 (*ptr == LEADING_BYTE_LATIN_ISO8859_1) ? (*(ptr+1)) :
1937 Dynarr_add (conversion_out_dynarr, (Extbyte) c);
1940 bufpos_checking_assert (ptr == end);
1943 Dynarr_add_many (conversion_out_dynarr, ptr, len);
1949 Lisp_Object streams_to_delete[3];
1950 int delete_count = 0;
1951 Lisp_Object instream, outstream;
1952 Lstream *reader, *writer;
1953 struct gcpro gcpro1, gcpro2;
1955 if (source_type == DFC_TYPE_LISP_LSTREAM)
1956 instream = source->lisp_object;
1957 else if (source_type == DFC_TYPE_DATA)
1958 streams_to_delete[delete_count++] = instream =
1959 make_fixed_buffer_input_stream (source->data.ptr, source->data.len);
1962 type_checking_assert (source_type == DFC_TYPE_LISP_STRING);
1963 streams_to_delete[delete_count++] = instream =
1964 make_lisp_string_input_stream (source->lisp_object, 0, -1);
1967 if (sink_type == DFC_TYPE_LISP_LSTREAM)
1968 outstream = sink->lisp_object;
1971 type_checking_assert (sink_type == DFC_TYPE_DATA);
1972 streams_to_delete[delete_count++] = outstream =
1973 make_dynarr_output_stream
1974 ((unsigned_char_dynarr *) conversion_out_dynarr);
1978 streams_to_delete[delete_count++] = outstream =
1979 make_encoding_output_stream (XLSTREAM (outstream), coding_system);
1982 reader = XLSTREAM (instream);
1983 writer = XLSTREAM (outstream);
1984 /* decoding_stream will gc-protect outstream */
1985 GCPRO2 (instream, outstream);
1989 ssize_t size_in_bytes;
1990 char tempbuf[1024]; /* some random amount */
1992 size_in_bytes = Lstream_read (reader, tempbuf, sizeof (tempbuf));
1994 if (size_in_bytes == 0)
1996 else if (size_in_bytes < 0)
1997 error ("Error converting to external format");
1999 size_in_bytes = Lstream_write (writer, tempbuf, size_in_bytes);
2001 if (size_in_bytes <= 0)
2002 error ("Error converting to external format");
2005 /* Closing writer will close any stream at the other end of writer. */
2006 Lstream_close (writer);
2007 Lstream_close (reader);
2010 /* The idea is that this function will create no garbage. */
2011 while (delete_count)
2012 Lstream_delete (XLSTREAM (streams_to_delete [--delete_count]));
2015 unbind_to (count, Qnil);
2017 if (sink_type != DFC_TYPE_LISP_LSTREAM)
2019 sink->data.len = Dynarr_length (conversion_out_dynarr);
2020 Dynarr_add (conversion_out_dynarr, 0);
2021 sink->data.ptr = Dynarr_atp (conversion_out_dynarr, 0);
2026 dfc_convert_to_internal_format (dfc_conversion_type source_type,
2027 dfc_conversion_data *source,
2029 Lisp_Object coding_system,
2031 dfc_conversion_type sink_type,
2032 dfc_conversion_data *sink)
2034 int count = specpdl_depth ();
2035 Bufbyte_dynarr *conversion_in_dynarr;
2037 type_checking_assert
2038 ((source_type == DFC_TYPE_DATA ||
2039 source_type == DFC_TYPE_LISP_LSTREAM)
2041 (sink_type == DFC_TYPE_DATA ||
2042 sink_type == DFC_TYPE_LISP_LSTREAM));
2044 record_unwind_protect (dfc_convert_to_internal_format_reset_in_use,
2045 make_int (dfc_convert_to_internal_format_in_use));
2046 if (Dynarr_length (conversion_in_dynarr_list) <=
2047 dfc_convert_to_internal_format_in_use)
2048 Dynarr_add (conversion_in_dynarr_list, Dynarr_new (Bufbyte));
2049 conversion_in_dynarr = Dynarr_at (conversion_in_dynarr_list,
2050 dfc_convert_to_internal_format_in_use);
2051 dfc_convert_to_internal_format_in_use++;
2052 Dynarr_reset (conversion_in_dynarr);
2055 coding_system = Fget_coding_system (coding_system);
2058 if (source_type != DFC_TYPE_LISP_LSTREAM &&
2059 sink_type != DFC_TYPE_LISP_LSTREAM &&
2060 coding_system_is_binary (coding_system))
2063 const Bufbyte *ptr = (const Bufbyte *) source->data.ptr;
2064 Bytecount len = source->data.len;
2065 const Bufbyte *end = ptr + len;
2067 for (; ptr < end; ptr++)
2072 if (BYTE_ASCII_P (c))
2073 Dynarr_add (conversion_in_dynarr, c);
2076 Dynarr_add (conversion_in_dynarr, (c >> 6) | 0xC0);
2077 Dynarr_add (conversion_in_dynarr, (c & 0x3F) | 0x80);
2080 if (BYTE_ASCII_P (c))
2081 Dynarr_add (conversion_in_dynarr, c);
2082 else if (BYTE_C1_P (c))
2084 Dynarr_add (conversion_in_dynarr, LEADING_BYTE_CONTROL_1);
2085 Dynarr_add (conversion_in_dynarr, c + 0x20);
2089 Dynarr_add (conversion_in_dynarr, LEADING_BYTE_LATIN_ISO8859_1);
2090 Dynarr_add (conversion_in_dynarr, c);
2095 Dynarr_add_many (conversion_in_dynarr, source->data.ptr, source->data.len);
2100 Lisp_Object streams_to_delete[3];
2101 int delete_count = 0;
2102 Lisp_Object instream, outstream;
2103 Lstream *reader, *writer;
2104 struct gcpro gcpro1, gcpro2;
2106 if (source_type == DFC_TYPE_LISP_LSTREAM)
2107 instream = source->lisp_object;
2110 type_checking_assert (source_type == DFC_TYPE_DATA);
2111 streams_to_delete[delete_count++] = instream =
2112 make_fixed_buffer_input_stream (source->data.ptr, source->data.len);
2115 if (sink_type == DFC_TYPE_LISP_LSTREAM)
2116 outstream = sink->lisp_object;
2119 type_checking_assert (sink_type == DFC_TYPE_DATA);
2120 streams_to_delete[delete_count++] = outstream =
2121 make_dynarr_output_stream
2122 ((unsigned_char_dynarr *) conversion_in_dynarr);
2126 streams_to_delete[delete_count++] = outstream =
2127 make_decoding_output_stream (XLSTREAM (outstream), coding_system);
2130 reader = XLSTREAM (instream);
2131 writer = XLSTREAM (outstream);
2132 /* outstream will gc-protect its sink stream, if necessary */
2133 GCPRO2 (instream, outstream);
2137 ssize_t size_in_bytes;
2138 char tempbuf[1024]; /* some random amount */
2140 size_in_bytes = Lstream_read (reader, tempbuf, sizeof (tempbuf));
2142 if (size_in_bytes == 0)
2144 else if (size_in_bytes < 0)
2145 error ("Error converting to internal format");
2147 size_in_bytes = Lstream_write (writer, tempbuf, size_in_bytes);
2149 if (size_in_bytes <= 0)
2150 error ("Error converting to internal format");
2153 /* Closing writer will close any stream at the other end of writer. */
2154 Lstream_close (writer);
2155 Lstream_close (reader);
2158 /* The idea is that this function will create no garbage. */
2159 while (delete_count)
2160 Lstream_delete (XLSTREAM (streams_to_delete [--delete_count]));
2163 unbind_to (count, Qnil);
2165 if (sink_type != DFC_TYPE_LISP_LSTREAM)
2167 sink->data.len = Dynarr_length (conversion_in_dynarr);
2168 Dynarr_add (conversion_in_dynarr, 0); /* remember to zero-terminate! */
2169 sink->data.ptr = Dynarr_atp (conversion_in_dynarr, 0);
2175 syms_of_buffer (void)
2177 INIT_LRECORD_IMPLEMENTATION (buffer);
2179 defsymbol (&Qbuffer_live_p, "buffer-live-p");
2180 defsymbol (&Qbuffer_or_string_p, "buffer-or-string-p");
2181 defsymbol (&Qmode_class, "mode-class");
2182 defsymbol (&Qrename_auto_save_file, "rename-auto-save-file");
2183 defsymbol (&Qkill_buffer_hook, "kill-buffer-hook");
2184 defsymbol (&Qpermanent_local, "permanent-local");
2186 defsymbol (&Qfirst_change_hook, "first-change-hook");
2187 defsymbol (&Qbefore_change_functions, "before-change-functions");
2188 defsymbol (&Qafter_change_functions, "after-change-functions");
2190 /* #### Obsolete, for compatibility */
2191 defsymbol (&Qbefore_change_function, "before-change-function");
2192 defsymbol (&Qafter_change_function, "after-change-function");
2194 defsymbol (&Qdefault_directory, "default-directory");
2196 defsymbol (&Qget_file_buffer, "get-file-buffer");
2197 defsymbol (&Qchange_major_mode_hook, "change-major-mode-hook");
2199 defsymbol (&Qfundamental_mode, "fundamental-mode");
2201 defsymbol (&Qfind_file_compare_truenames, "find-file-compare-truenames");
2203 defsymbol (&Qswitch_to_buffer, "switch-to-buffer");
2206 DEFSUBR (Fbuffer_live_p);
2207 DEFSUBR (Fbuffer_list);
2208 DEFSUBR (Fdecode_buffer);
2209 DEFSUBR (Fget_buffer);
2210 DEFSUBR (Fget_file_buffer);
2211 DEFSUBR (Fget_buffer_create);
2212 DEFSUBR (Fmake_indirect_buffer);
2214 DEFSUBR (Fgenerate_new_buffer_name);
2215 DEFSUBR (Fbuffer_name);
2216 DEFSUBR (Fbuffer_file_name);
2217 DEFSUBR (Fbuffer_base_buffer);
2218 DEFSUBR (Fbuffer_indirect_children);
2219 DEFSUBR (Fbuffer_local_variables);
2220 DEFSUBR (Fbuffer_dedicated_frame);
2221 DEFSUBR (Fset_buffer_dedicated_frame);
2222 DEFSUBR (Fbuffer_modified_p);
2223 DEFSUBR (Fset_buffer_modified_p);
2224 DEFSUBR (Fbuffer_modified_tick);
2225 DEFSUBR (Frename_buffer);
2226 DEFSUBR (Fother_buffer);
2227 DEFSUBR (Fbuffer_disable_undo);
2228 DEFSUBR (Fbuffer_enable_undo);
2229 DEFSUBR (Fkill_buffer);
2230 DEFSUBR (Ferase_buffer);
2231 DEFSUBR (Frecord_buffer);
2232 DEFSUBR (Fset_buffer_major_mode);
2233 DEFSUBR (Fcurrent_buffer);
2234 DEFSUBR (Fset_buffer);
2235 DEFSUBR (Fbarf_if_buffer_read_only);
2236 DEFSUBR (Fbury_buffer);
2237 DEFSUBR (Fkill_all_local_variables);
2238 #ifdef MEMORY_USAGE_STATS
2239 DEFSUBR (Fbuffer_memory_usage);
2242 deferror (&Qprotected_field, "protected-field",
2243 "Attempt to modify a protected field", Qerror);
2247 reinit_vars_of_buffer (void)
2249 conversion_in_dynarr_list = Dynarr_new2 (Bufbyte_dynarr_dynarr,
2251 conversion_out_dynarr_list = Dynarr_new2 (Extbyte_dynarr_dynarr,
2254 staticpro_nodump (&Vbuffer_alist);
2255 Vbuffer_alist = Qnil;
2259 /* initialize the buffer routines */
2261 vars_of_buffer (void)
2263 /* This function can GC */
2264 reinit_vars_of_buffer ();
2266 staticpro (&QSFundamental);
2267 staticpro (&QSscratch);
2269 QSFundamental = build_string ("Fundamental");
2270 QSscratch = build_string (DEFER_GETTEXT ("*scratch*"));
2272 DEFVAR_LISP ("change-major-mode-hook", &Vchange_major_mode_hook /*
2273 List of hooks to be run before killing local variables in a buffer.
2274 This should be used by any mode that temporarily alters the contents or
2275 the read-only state of the buffer. See also `kill-all-local-variables'.
2277 Vchange_major_mode_hook = Qnil;
2279 DEFVAR_BOOL ("find-file-compare-truenames", &find_file_compare_truenames /*
2280 If this is true, then the find-file command will check the truenames
2281 of all visited files when deciding whether a given file is already in
2282 a buffer, instead of just the buffer-file-name. This means that if you
2283 attempt to visit another file which is a symbolic-link to a file which is
2284 already in a buffer, the existing buffer will be found instead of a newly-
2285 created one. This works if any component of the pathname (including a non-
2286 terminal component) is a symbolic link as well, but doesn't work with hard
2287 links (nothing does).
2289 See also the variable find-file-use-truenames.
2291 find_file_compare_truenames = 0;
2293 DEFVAR_BOOL ("find-file-use-truenames", &find_file_use_truenames /*
2294 If this is true, then a buffer's visited file-name will always be
2295 chased back to the real file; it will never be a symbolic link, and there
2296 will never be a symbolic link anywhere in its directory path.
2297 That is, the buffer-file-name and buffer-file-truename will be equal.
2298 This doesn't work with hard links.
2300 See also the variable find-file-compare-truenames.
2302 find_file_use_truenames = 0;
2304 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions /*
2305 List of functions to call before each text change.
2306 Two arguments are passed to each function: the positions of
2307 the beginning and end of the range of old text to be changed.
2308 \(For an insertion, the beginning and end are at the same place.)
2309 No information is given about the length of the text after the change.
2311 Buffer changes made while executing the `before-change-functions'
2312 don't call any before-change or after-change functions.
2314 Vbefore_change_functions = Qnil;
2316 /* FSF Emacs has the following additional doc at the end of
2317 before-change-functions and after-change-functions:
2319 That's because these variables are temporarily set to nil.
2320 As a result, a hook function cannot straightforwardly alter the value of
2321 these variables. See the Emacs Lisp manual for a way of
2322 accomplishing an equivalent result by using other variables.
2324 But this doesn't apply under XEmacs because things are
2327 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions /*
2328 List of functions to call after each text change.
2329 Three arguments are passed to each function: the positions of
2330 the beginning and end of the range of changed text,
2331 and the length of the pre-change text replaced by that range.
2332 \(For an insertion, the pre-change length is zero;
2333 for a deletion, that length is the number of characters deleted,
2334 and the post-change beginning and end are at the same place.)
2336 Buffer changes made while executing `after-change-functions'
2337 don't call any before-change or after-change functions.
2339 Vafter_change_functions = Qnil;
2341 DEFVAR_LISP ("before-change-function", &Vbefore_change_function /*
2343 */ ); /* obsoleteness will be documented */
2344 Vbefore_change_function = Qnil;
2346 DEFVAR_LISP ("after-change-function", &Vafter_change_function /*
2348 */ ); /* obsoleteness will be documented */
2349 Vafter_change_function = Qnil;
2351 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook /*
2352 A list of functions to call before changing a buffer which is unmodified.
2353 The functions are run using the `run-hooks' function.
2355 Vfirst_change_hook = Qnil;
2358 xxDEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode /*
2359 *Non-nil means deactivate the mark when the buffer contents change.
2361 Vtransient_mark_mode = Qnil;
2362 #endif /* FSFmacs */
2364 DEFVAR_INT ("undo-threshold", &undo_threshold /*
2365 Keep no more undo information once it exceeds this size.
2366 This threshold is applied when garbage collection happens.
2367 The size is counted as the number of bytes occupied,
2368 which includes both saved text and other data.
2370 undo_threshold = 20000;
2372 DEFVAR_INT ("undo-high-threshold", &undo_high_threshold /*
2373 Don't keep more than this much size of undo information.
2374 A command which pushes past this size is itself forgotten.
2375 This threshold is applied when garbage collection happens.
2376 The size is counted as the number of bytes occupied,
2377 which includes both saved text and other data.
2379 undo_high_threshold = 30000;
2381 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only /*
2382 *Non-nil means disregard read-only status of buffers or characters.
2383 If the value is t, disregard `buffer-read-only' and all `read-only'
2384 text properties. If the value is a list, disregard `buffer-read-only'
2385 and disregard a `read-only' extent property or text property if the
2386 property value is a member of the list.
2388 Vinhibit_read_only = Qnil;
2390 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions /*
2391 List of functions called with no args to query before killing a buffer.
2393 Vkill_buffer_query_functions = Qnil;
2395 DEFVAR_BOOL ("delete-auto-save-files", &delete_auto_save_files /*
2396 *Non-nil means delete auto-save file when a buffer is saved or killed.
2398 delete_auto_save_files = 1;
2401 /* The docstrings for DEFVAR_* are recorded externally by make-docfile. */
2403 /* Renamed from DEFVAR_PER_BUFFER because FSFmacs D_P_B takes
2404 a bogus extra arg, which confuses an otherwise identical make-docfile.c */
2405 #define DEFVAR_BUFFER_LOCAL_1(lname, field_name, forward_type, magicfun) do { \
2406 static const struct symbol_value_forward I_hate_C = \
2407 { /* struct symbol_value_forward */ \
2408 { /* struct symbol_value_magic */ \
2409 { /* struct lcrecord_header */ \
2410 { /* struct lrecord_header */ \
2411 lrecord_type_symbol_value_forward, /* lrecord_type_index */ \
2413 1, /* c_readonly bit */ \
2414 1 /* lisp_readonly bit */ \
2420 &(buffer_local_flags.field_name), \
2427 int offset = ((char *)symbol_value_forward_forward (&I_hate_C) - \
2428 (char *)&buffer_local_flags); \
2429 defvar_magic (lname, &I_hate_C); \
2431 *((Lisp_Object *)(offset + (char *)XBUFFER (Vbuffer_local_symbols))) \
2436 #define DEFVAR_BUFFER_LOCAL_MAGIC(lname, field_name, magicfun) \
2437 DEFVAR_BUFFER_LOCAL_1 (lname, field_name, \
2438 SYMVAL_CURRENT_BUFFER_FORWARD, magicfun)
2439 #define DEFVAR_BUFFER_LOCAL(lname, field_name) \
2440 DEFVAR_BUFFER_LOCAL_MAGIC (lname, field_name, 0)
2441 #define DEFVAR_CONST_BUFFER_LOCAL_MAGIC(lname, field_name, magicfun) \
2442 DEFVAR_BUFFER_LOCAL_1 (lname, field_name, \
2443 SYMVAL_CONST_CURRENT_BUFFER_FORWARD, magicfun)
2444 #define DEFVAR_CONST_BUFFER_LOCAL(lname, field_name) \
2445 DEFVAR_CONST_BUFFER_LOCAL_MAGIC (lname, field_name, 0)
2447 #define DEFVAR_BUFFER_DEFAULTS_MAGIC(lname, field_name, magicfun) \
2448 DEFVAR_SYMVAL_FWD (lname, &(buffer_local_flags.field_name), \
2449 SYMVAL_DEFAULT_BUFFER_FORWARD, magicfun)
2450 #define DEFVAR_BUFFER_DEFAULTS(lname, field_name) \
2451 DEFVAR_BUFFER_DEFAULTS_MAGIC (lname, field_name, 0)
2454 nuke_all_buffer_slots (struct buffer *b, Lisp_Object zap)
2458 b->extent_info = Qnil;
2459 b->indirect_children = Qnil;
2460 b->own_text.line_number_cache = Qnil;
2462 #define MARKED_SLOT(x) b->x = zap
2463 #include "bufslots.h"
2468 common_init_complex_vars_of_buffer (void)
2470 /* Make sure all markable slots in buffer_defaults
2471 are initialized reasonably, so mark_buffer won't choke. */
2472 struct buffer *defs = alloc_lcrecord_type (struct buffer, &lrecord_buffer);
2473 struct buffer *syms = alloc_lcrecord_type (struct buffer, &lrecord_buffer);
2475 staticpro_nodump (&Vbuffer_defaults);
2476 staticpro_nodump (&Vbuffer_local_symbols);
2477 XSETBUFFER (Vbuffer_defaults, defs);
2478 XSETBUFFER (Vbuffer_local_symbols, syms);
2480 nuke_all_buffer_slots (syms, Qnil);
2481 nuke_all_buffer_slots (defs, Qnil);
2482 defs->text = &defs->own_text;
2483 syms->text = &syms->own_text;
2485 /* Set up the non-nil default values of various buffer slots.
2486 Must do these before making the first buffer. */
2487 defs->major_mode = Qfundamental_mode;
2488 defs->mode_name = QSFundamental;
2489 defs->abbrev_table = Qnil; /* real default setup by Lisp code */
2491 defs->downcase_table = Vascii_downcase_table;
2492 defs->upcase_table = Vascii_upcase_table;
2493 defs->case_canon_table = Vascii_canon_table;
2494 defs->case_eqv_table = Vascii_eqv_table;
2496 defs->mirror_downcase_table = Vmirror_ascii_downcase_table;
2497 defs->mirror_upcase_table = Vmirror_ascii_upcase_table;
2498 defs->mirror_case_canon_table = Vmirror_ascii_canon_table;
2499 defs->mirror_case_eqv_table = Vmirror_ascii_eqv_table;
2501 defs->category_table = Vstandard_category_table;
2503 defs->syntax_table = Vstandard_syntax_table;
2504 defs->mirror_syntax_table =
2505 XCHAR_TABLE (Vstandard_syntax_table)->mirror_table;
2506 defs->modeline_format = build_string ("%-"); /* reset in loaddefs.el */
2507 defs->case_fold_search = Qt;
2508 defs->selective_display_ellipses = Qt;
2509 defs->tab_width = make_int (8);
2510 defs->ctl_arrow = Qt;
2511 defs->fill_column = make_int (70);
2512 defs->left_margin = Qzero;
2513 defs->saved_size = Qzero; /* lisp code wants int-or-nil */
2515 defs->auto_save_modified = 0;
2516 defs->auto_save_failure_time = -1;
2517 defs->invisibility_spec = Qt;
2519 defs->indirect_children = Qnil;
2520 syms->indirect_children = Qnil;
2523 /* 0 means var is always local. Default used only at creation.
2524 * -1 means var is always local. Default used only at reset and
2526 * -2 means there's no lisp variable corresponding to this slot
2527 * and the default is only used at creation.
2528 * -3 means no Lisp variable. Default used only at reset and creation.
2529 * >0 is mask. Var is local if ((buffer->local_var_flags & mask) != 0)
2530 * Otherwise default is used.
2532 Lisp_Object always_local_no_default = make_int (0);
2533 Lisp_Object always_local_resettable = make_int (-1);
2534 Lisp_Object resettable = make_int (-3);
2536 /* Assign the local-flags to the slots that have default values.
2537 The local flag is a bit that is used in the buffer
2538 to say that it has its own local value for the slot.
2539 The local flag bits are in the local_var_flags slot of the
2542 nuke_all_buffer_slots (&buffer_local_flags, make_int (-2));
2543 buffer_local_flags.filename = always_local_no_default;
2544 buffer_local_flags.directory = always_local_no_default;
2545 buffer_local_flags.backed_up = always_local_no_default;
2546 buffer_local_flags.saved_size = always_local_no_default;
2547 buffer_local_flags.auto_save_file_name = always_local_no_default;
2548 buffer_local_flags.read_only = always_local_no_default;
2550 buffer_local_flags.major_mode = always_local_resettable;
2551 buffer_local_flags.mode_name = always_local_resettable;
2552 buffer_local_flags.undo_list = always_local_no_default;
2554 buffer_local_flags.mark_active = always_local_resettable;
2556 buffer_local_flags.point_before_scroll = always_local_resettable;
2557 buffer_local_flags.file_truename = always_local_no_default;
2558 buffer_local_flags.invisibility_spec = always_local_resettable;
2559 buffer_local_flags.file_format = always_local_resettable;
2560 buffer_local_flags.generated_modeline_string = always_local_no_default;
2562 buffer_local_flags.keymap = resettable;
2563 buffer_local_flags.downcase_table = resettable;
2564 buffer_local_flags.upcase_table = resettable;
2565 buffer_local_flags.case_canon_table = resettable;
2566 buffer_local_flags.case_eqv_table = resettable;
2567 buffer_local_flags.syntax_table = resettable;
2569 buffer_local_flags.category_table = resettable;
2572 buffer_local_flags.modeline_format = make_int (1<<0);
2573 buffer_local_flags.abbrev_mode = make_int (1<<1);
2574 buffer_local_flags.overwrite_mode = make_int (1<<2);
2575 buffer_local_flags.case_fold_search = make_int (1<<3);
2576 buffer_local_flags.auto_fill_function = make_int (1<<4);
2577 buffer_local_flags.selective_display = make_int (1<<5);
2578 buffer_local_flags.selective_display_ellipses = make_int (1<<6);
2579 buffer_local_flags.tab_width = make_int (1<<7);
2580 buffer_local_flags.truncate_lines = make_int (1<<8);
2581 buffer_local_flags.ctl_arrow = make_int (1<<9);
2582 buffer_local_flags.fill_column = make_int (1<<10);
2583 buffer_local_flags.left_margin = make_int (1<<11);
2584 buffer_local_flags.abbrev_table = make_int (1<<12);
2585 #ifdef REGION_CACHE_NEEDS_WORK
2586 buffer_local_flags.cache_long_line_scans = make_int (1<<13);
2589 buffer_local_flags.buffer_file_coding_system = make_int (1<<14);
2592 /* #### Warning: 1<<31 is the largest number currently allowable
2593 due to the XINT() handling of this value. With some
2594 rearrangement you can get 3 more bits. */
2598 #define BUFFER_SLOTS_SIZE (offsetof (struct buffer, BUFFER_SLOTS_LAST_NAME) - offsetof (struct buffer, BUFFER_SLOTS_FIRST_NAME) + sizeof (Lisp_Object))
2599 #define BUFFER_SLOTS_COUNT (BUFFER_SLOTS_SIZE / sizeof (Lisp_Object))
2602 reinit_complex_vars_of_buffer (void)
2604 struct buffer *defs, *syms;
2606 common_init_complex_vars_of_buffer ();
2608 defs = XBUFFER (Vbuffer_defaults);
2609 syms = XBUFFER (Vbuffer_local_symbols);
2610 memcpy (&defs->BUFFER_SLOTS_FIRST_NAME,
2611 buffer_defaults_saved_slots,
2613 memcpy (&syms->BUFFER_SLOTS_FIRST_NAME,
2614 buffer_local_symbols_saved_slots,
2619 static const struct lrecord_description buffer_slots_description_1[] = {
2620 { XD_LISP_OBJECT_ARRAY, 0, BUFFER_SLOTS_COUNT },
2624 static const struct struct_description buffer_slots_description = {
2626 buffer_slots_description_1
2630 complex_vars_of_buffer (void)
2632 struct buffer *defs, *syms;
2634 common_init_complex_vars_of_buffer ();
2636 defs = XBUFFER (Vbuffer_defaults);
2637 syms = XBUFFER (Vbuffer_local_symbols);
2638 buffer_defaults_saved_slots = &defs->BUFFER_SLOTS_FIRST_NAME;
2639 buffer_local_symbols_saved_slots = &syms->BUFFER_SLOTS_FIRST_NAME;
2640 dumpstruct (&buffer_defaults_saved_slots, &buffer_slots_description);
2641 dumpstruct (&buffer_local_symbols_saved_slots, &buffer_slots_description);
2643 DEFVAR_BUFFER_DEFAULTS ("default-modeline-format", modeline_format /*
2644 Default value of `modeline-format' for buffers that don't override it.
2645 This is the same as (default-value 'modeline-format).
2648 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode", abbrev_mode /*
2649 Default value of `abbrev-mode' for buffers that do not override it.
2650 This is the same as (default-value 'abbrev-mode).
2653 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow", ctl_arrow /*
2654 Default value of `ctl-arrow' for buffers that do not override it.
2655 This is the same as (default-value 'ctl-arrow).
2658 #if 0 /* #### make this a specifier! */
2659 DEFVAR_BUFFER_DEFAULTS ("default-display-direction", display_direction /*
2660 Default display-direction for buffers that do not override it.
2661 This is the same as (default-value 'display-direction).
2662 Note: This is not yet implemented.
2666 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines", truncate_lines /*
2667 Default value of `truncate-lines' for buffers that do not override it.
2668 This is the same as (default-value 'truncate-lines).
2671 DEFVAR_BUFFER_DEFAULTS ("default-fill-column", fill_column /*
2672 Default value of `fill-column' for buffers that do not override it.
2673 This is the same as (default-value 'fill-column).
2676 DEFVAR_BUFFER_DEFAULTS ("default-left-margin", left_margin /*
2677 Default value of `left-margin' for buffers that do not override it.
2678 This is the same as (default-value 'left-margin).
2681 DEFVAR_BUFFER_DEFAULTS ("default-tab-width", tab_width /*
2682 Default value of `tab-width' for buffers that do not override it.
2683 This is the same as (default-value 'tab-width).
2686 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search", case_fold_search /*
2687 Default value of `case-fold-search' for buffers that don't override it.
2688 This is the same as (default-value 'case-fold-search).
2691 DEFVAR_BUFFER_LOCAL ("modeline-format", modeline_format /*
2692 Template for displaying modeline for current buffer.
2693 Each buffer has its own value of this variable.
2694 Value may be a string, symbol, glyph, generic specifier, list or cons cell.
2695 For a symbol, its value is processed (but it is ignored if t or nil).
2696 A string appearing directly as the value of a symbol is processed verbatim
2697 in that the %-constructs below are not recognized.
2698 For a glyph, it is inserted as is.
2699 For a generic specifier (i.e. a specifier of type `generic'), its instance
2700 is computed in the current window using the equivalent of `specifier-instance'
2701 and the value is processed.
2702 For a list whose car is a symbol, the symbol's value is taken,
2703 and if that is non-nil, the cadr of the list is processed recursively.
2704 Otherwise, the caddr of the list (if there is one) is processed.
2705 For a list whose car is a string or list, each element is processed
2706 recursively and the results are effectively concatenated.
2707 For a list whose car is an integer, the cdr of the list is processed
2708 and padded (if the number is positive) or truncated (if negative)
2709 to the width specified by that number.
2710 For a list whose car is an extent, the cdr of the list is processed
2711 normally but the results are displayed using the face of the
2712 extent, and mouse clicks over this section are processed using the
2713 keymap of the extent. (In addition, if the extent has a help-echo
2714 property, that string will be echoed when the mouse moves over this
2715 section.) If extents are nested, all keymaps are properly consulted
2716 when processing mouse clicks, but multiple faces are not correctly
2717 merged (only the first face is used), and lists of faces are not
2718 correctly handled. See `generated-modeline-string' for more information.
2719 A string is printed verbatim in the modeline except for %-constructs:
2720 (%-constructs are processed when the string is the entire modeline-format
2721 or when it is found in a cons-cell or a list)
2722 %b -- print buffer name. %c -- print the current column number.
2723 %f -- print visited file name.
2724 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
2725 % means buffer is read-only and * means it is modified.
2726 For a modified read-only buffer, %* gives % and %+ gives *.
2727 %s -- print process status. %l -- print the current line number.
2728 %S -- print name of selected frame (only meaningful under X Windows).
2729 %p -- print percent of buffer above top of window, or Top, Bot or All.
2730 %P -- print percent of buffer above bottom of window, perhaps plus Top,
2731 or print Bottom or All.
2732 %n -- print Narrow if appropriate.
2733 %C -- under XEmacs/mule, print the mnemonic for `buffer-file-coding-system'.
2734 %[ -- print one [ for each recursive editing level. %] similar.
2735 %% -- print %. %- -- print infinitely many dashes.
2736 Decimal digits after the % specify field width to which to pad.
2739 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode /*
2740 *Major mode for new buffers. Defaults to `fundamental-mode'.
2741 nil here means use current buffer's major mode.
2744 DEFVAR_BUFFER_DEFAULTS ("fundamental-mode-abbrev-table", abbrev_table /*
2745 The abbrev table of mode-specific abbrevs for Fundamental Mode.
2748 DEFVAR_BUFFER_LOCAL ("major-mode", major_mode /*
2749 Symbol for current buffer's major mode.
2752 DEFVAR_BUFFER_LOCAL ("mode-name", mode_name /*
2753 Pretty name of current buffer's major mode (a string).
2756 DEFVAR_BUFFER_LOCAL ("abbrev-mode", abbrev_mode /*
2757 Non-nil turns on automatic expansion of abbrevs as they are inserted.
2758 Automatically becomes buffer-local when set in any fashion.
2761 DEFVAR_BUFFER_LOCAL ("case-fold-search", case_fold_search /*
2762 *Non-nil if searches should ignore case.
2763 Automatically becomes buffer-local when set in any fashion.
2765 BUG: Under XEmacs/Mule, translations to or from non-ASCII characters
2766 (this includes chars in the range 128 - 255) are ignored by
2767 the string/buffer-searching routines. Thus, `case-fold-search'
2768 will not correctly conflate a-umlaut and A-umlaut even if the
2769 case tables call for this.
2772 DEFVAR_BUFFER_LOCAL ("fill-column", fill_column /*
2773 *Column beyond which automatic line-wrapping should happen.
2774 Automatically becomes buffer-local when set in any fashion.
2777 DEFVAR_BUFFER_LOCAL ("left-margin", left_margin /*
2778 *Column for the default indent-line-function to indent to.
2779 Linefeed indents to this column in Fundamental mode.
2780 Automatically becomes buffer-local when set in any fashion.
2781 Do not confuse this with the specifier `left-margin-width';
2782 that controls the size of a margin that is displayed outside
2786 DEFVAR_BUFFER_LOCAL_MAGIC ("tab-width", tab_width /*
2787 *Distance between tab stops (for display of tab characters), in columns.
2788 Automatically becomes buffer-local when set in any fashion.
2789 */ , redisplay_variable_changed);
2791 DEFVAR_BUFFER_LOCAL_MAGIC ("ctl-arrow", ctl_arrow /*
2792 *Non-nil means display control chars with uparrow.
2793 Nil means use backslash and octal digits.
2794 An integer means characters >= ctl-arrow are assumed to be printable, and
2795 will be displayed as a single glyph.
2796 Any other value is the same as 160 - the code SPC with the high bit on.
2798 The interpretation of this variable is likely to change in the future.
2800 Automatically becomes buffer-local when set in any fashion.
2801 This variable does not apply to characters whose display is specified
2802 in the current display table (if there is one).
2803 */ , redisplay_variable_changed);
2805 #if 0 /* #### Make this a specifier! */
2806 xxDEFVAR_BUFFER_LOCAL ("display-direction", display_direction /*
2807 *Non-nil means lines in the buffer are displayed right to left.
2808 Nil means left to right. (Not yet implemented.)
2810 #endif /* Not yet implemented */
2812 DEFVAR_BUFFER_LOCAL_MAGIC ("truncate-lines", truncate_lines /*
2813 *Non-nil means do not display continuation lines;
2814 give each line of text one frame line.
2815 Automatically becomes buffer-local when set in any fashion.
2817 Note that this is overridden by the variable
2818 `truncate-partial-width-windows' if that variable is non-nil
2819 and this buffer is not full-frame width.
2820 */ , redisplay_variable_changed);
2822 DEFVAR_BUFFER_LOCAL ("default-directory", directory /*
2823 Name of default directory of current buffer. Should end with slash.
2824 Each buffer has its own value of this variable.
2828 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system", buffer_file_coding_system /*
2829 Default value of `buffer-file-coding-system' for buffers that do not override it.
2830 This is the same as (default-value 'buffer-file-coding-system).
2831 This value is used both for buffers without associated files and
2832 for buffers whose files do not have any apparent coding system.
2833 See `buffer-file-coding-system'.
2836 DEFVAR_BUFFER_LOCAL ("buffer-file-coding-system", buffer_file_coding_system /*
2837 *Current coding system for the current buffer.
2838 When the buffer is written out into a file, this coding system will be
2839 used for the encoding. Automatically buffer-local when set in any
2840 fashion. This is normally set automatically when a file is loaded in
2841 based on the determined coding system of the file (assuming that
2842 `buffer-file-coding-system-for-read' is set to `undecided', which
2843 calls for automatic determination of the file's coding system).
2844 Normally the modeline indicates the current file coding system using
2845 its mnemonic abbreviation.
2847 The default value for this variable (which is normally used for
2848 buffers without associated files) is also used when automatic
2849 detection of a file's encoding is called for and there was no
2850 discernible encoding in the file (i.e. it was entirely or almost
2851 entirely ASCII). The default value should generally *not* be set to
2852 nil (equivalent to `no-conversion'), because if extended characters
2853 are ever inserted into the buffer, they will be lost when the file is
2854 written out. A good choice is `iso-2022-8' (the simple ISO 2022 8-bit
2855 encoding), which will write out ASCII and Latin-1 characters in the
2856 standard (and highly portable) fashion and use standard escape
2857 sequences for other charsets. Another reasonable choice is
2858 `escape-quoted', which is equivalent to `iso-2022-8' but prefixes
2859 certain control characters with ESC to make sure they are not
2860 interpreted as escape sequences when read in. This latter coding
2861 system results in more "correct" output in the presence of control
2862 characters in the buffer, in the sense that when read in again using
2863 the same coding system, the result will virtually always match the
2864 original contents of the buffer, which is not the case with
2865 `iso-2022-8'; but the output is less portable when dealing with binary
2866 data -- there may be stray ESC characters when the file is read by
2869 `buffer-file-coding-system' does *not* control the coding system used when
2870 a file is read in. Use the variables `buffer-file-coding-system-for-read'
2871 and `buffer-file-coding-system-alist' for that. From a Lisp program, if
2872 you wish to unilaterally specify the coding system used for one
2873 particular operation, you should bind the variable
2874 `coding-system-for-read' rather than changing the other two
2875 variables just mentioned, which are intended to be used for
2876 global environment specification.
2878 #endif /* FILE_CODING */
2880 DEFVAR_BUFFER_LOCAL ("auto-fill-function", auto_fill_function /*
2881 Function called (if non-nil) to perform auto-fill.
2882 It is called after self-inserting a space at a column beyond `fill-column'.
2883 Each buffer has its own value of this variable.
2884 NOTE: This variable is not an ordinary hook;
2885 It may not be a list of functions.
2888 DEFVAR_BUFFER_LOCAL ("buffer-file-name", filename /*
2889 Name of file visited in current buffer, or nil if not visiting a file.
2890 Each buffer has its own value of this variable.
2895 Abbreviated truename of file visited in current buffer, or nil if none.
2896 The truename of a file is calculated by `file-truename'
2897 and then abbreviated with `abbreviate-file-name'.
2898 Each buffer has its own value of this variable.
2900 #endif /* FSFmacs */
2902 DEFVAR_BUFFER_LOCAL ("buffer-file-truename", file_truename /*
2903 The real name of the file visited in the current buffer,
2904 or nil if not visiting a file. This is the result of passing
2905 buffer-file-name to the `file-truename' function. Every buffer has
2906 its own value of this variable. This variable is automatically
2907 maintained by the functions that change the file name associated
2911 DEFVAR_BUFFER_LOCAL ("buffer-auto-save-file-name", auto_save_file_name /*
2912 Name of file for auto-saving current buffer,
2913 or nil if buffer should not be auto-saved.
2914 Each buffer has its own value of this variable.
2917 DEFVAR_BUFFER_LOCAL ("buffer-read-only", read_only /*
2918 Non-nil if this buffer is read-only.
2919 Each buffer has its own value of this variable.
2922 DEFVAR_BUFFER_LOCAL ("buffer-backed-up", backed_up /*
2923 Non-nil if this buffer's file has been backed up.
2924 Backing up is done before the first time the file is saved.
2925 Each buffer has its own value of this variable.
2928 DEFVAR_BUFFER_LOCAL ("buffer-saved-size", saved_size /*
2929 Length of current buffer when last read in, saved or auto-saved.
2931 Each buffer has its own value of this variable.
2934 DEFVAR_BUFFER_LOCAL_MAGIC ("selective-display", selective_display /*
2935 Non-nil enables selective display:
2936 Integer N as value means display only lines
2937 that start with less than n columns of space.
2938 A value of t means, after a ^M, all the rest of the line is invisible.
2939 Then ^M's in the file are written into files as newlines.
2941 Automatically becomes buffer-local when set in any fashion.
2942 */, redisplay_variable_changed);
2945 DEFVAR_BUFFER_LOCAL_MAGIC ("selective-display-ellipses",
2946 selective_display_ellipses /*
2947 t means display ... on previous line when a line is invisible.
2948 Automatically becomes buffer-local when set in any fashion.
2949 */, redisplay_variable_changed);
2952 DEFVAR_BUFFER_LOCAL ("local-abbrev-table", abbrev_table /*
2953 Local (mode-specific) abbrev table of current buffer.
2956 DEFVAR_BUFFER_LOCAL ("overwrite-mode", overwrite_mode /*
2957 Non-nil if self-insertion should replace existing text.
2958 The value should be one of `overwrite-mode-textual',
2959 `overwrite-mode-binary', or nil.
2960 If it is `overwrite-mode-textual', self-insertion still
2961 inserts at the end of a line, and inserts when point is before a tab,
2962 until the tab is filled in.
2963 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.
2964 Automatically becomes buffer-local when set in any fashion.
2966 Normally, you shouldn't modify this variable by hand, but use the functions
2967 `overwrite-mode' and `binary-overwrite-mode' instead. However, you can
2968 customize the default value from the options menu.
2972 /* Adds the following to the doc string for buffer-undo-list:
2974 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
2975 was modified between BEG and END. PROPERTY is the property name,
2976 and VALUE is the old value.
2978 #endif /* FSFmacs */
2980 DEFVAR_BUFFER_LOCAL ("buffer-undo-list", undo_list /*
2981 List of undo entries in current buffer.
2982 Recent changes come first; older changes follow newer.
2984 An entry (BEG . END) represents an insertion which begins at
2985 position BEG and ends at position END.
2987 An entry (TEXT . POSITION) represents the deletion of the string TEXT
2988 from (abs POSITION). If POSITION is positive, point was at the front
2989 of the text being deleted; if negative, point was at the end.
2991 An entry (t HIGH . LOW) indicates that the buffer previously had
2992 "unmodified" status. HIGH and LOW are the high and low 16-bit portions
2993 of the visited file's modification time, as of that time. If the
2994 modification time of the most recent save is different, this entry is
2997 An entry of the form EXTENT indicates that EXTENT was attached in
2998 the buffer. Undoing an entry of this form detaches EXTENT.
3000 An entry of the form (EXTENT START END) indicates that EXTENT was
3001 detached from the buffer. Undoing an entry of this form attaches
3002 EXTENT from START to END.
3004 An entry of the form POSITION indicates that point was at the buffer
3005 location given by the integer. Undoing an entry of this form places
3008 nil marks undo boundaries. The undo command treats the changes
3009 between two undo boundaries as a single step to be undone.
3011 If the value of the variable is t, undo information is not recorded.
3015 xxDEFVAR_BUFFER_LOCAL ("mark-active", mark_active /*
3016 Non-nil means the mark and region are currently active in this buffer.
3017 Automatically local in all buffers.
3019 #endif /* FSFmacs */
3021 #ifdef REGION_CACHE_NEEDS_WORK
3022 xxDEFVAR_BUFFER_LOCAL ("cache-long-line-scans", cache_long_line_scans /*
3023 Non-nil means that Emacs should use caches to handle long lines more quickly.
3024 This variable is buffer-local, in all buffers.
3026 Normally, the line-motion functions work by scanning the buffer for
3027 newlines. Columnar operations (like move-to-column and
3028 compute-motion) also work by scanning the buffer, summing character
3029 widths as they go. This works well for ordinary text, but if the
3030 buffer's lines are very long (say, more than 500 characters), these
3031 motion functions will take longer to execute. Emacs may also take
3032 longer to update the display.
3034 If cache-long-line-scans is non-nil, these motion functions cache the
3035 results of their scans, and consult the cache to avoid rescanning
3036 regions of the buffer until the text is modified. The caches are most
3037 beneficial when they prevent the most searching---that is, when the
3038 buffer contains long lines and large regions of characters with the
3039 same, fixed screen width.
3041 When cache-long-line-scans is non-nil, processing short lines will
3042 become slightly slower (because of the overhead of consulting the
3043 cache), and the caches will use memory roughly proportional to the
3044 number of newlines and characters whose screen width varies.
3046 The caches require no explicit maintenance; their accuracy is
3047 maintained internally by the Emacs primitives. Enabling or disabling
3048 the cache should not affect the behavior of any of the motion
3049 functions; it should only affect their performance.
3051 #endif /* REGION_CACHE_NEEDS_WORK */
3053 DEFVAR_BUFFER_LOCAL ("point-before-scroll", point_before_scroll /*
3054 Value of point before the last series of scroll operations, or nil.
3057 DEFVAR_BUFFER_LOCAL ("buffer-file-format", file_format /*
3058 List of formats to use when saving this buffer.
3059 Formats are defined by `format-alist'. This variable is
3060 set when a file is visited. Automatically local in all buffers.
3063 DEFVAR_BUFFER_LOCAL_MAGIC ("buffer-invisibility-spec", invisibility_spec /*
3064 Invisibility spec of this buffer.
3065 The default is t, which means that text is invisible
3066 if it has (or is covered by an extent with) a non-nil `invisible' property.
3067 If the value is a list, a text character is invisible if its `invisible'
3068 property is an element in that list.
3069 If an element is a cons cell of the form (PROP . ELLIPSIS),
3070 then characters with property value PROP are invisible,
3071 and they have an ellipsis as well if ELLIPSIS is non-nil.
3072 Note that the actual characters used for the ellipsis are controllable
3073 using `invisible-text-glyph', and default to "...".
3074 */, redisplay_variable_changed);
3076 DEFVAR_CONST_BUFFER_LOCAL ("generated-modeline-string",
3077 generated_modeline_string /*
3078 String of characters in this buffer's modeline as of the last redisplay.
3079 Each time the modeline is recomputed, the resulting characters are
3080 stored in this string, which is resized as necessary. You may not
3081 set this variable, and modifying this string will not change the
3082 modeline; you have to change `modeline-format' if you want that.
3084 For each extent in `modeline-format' that is encountered when
3085 processing the modeline, a corresponding extent is placed in
3086 `generated-modeline-string' and covers the text over which the
3087 extent in `modeline-format' applies. The extent in
3088 `generated-modeline-string' is made a child of the extent in
3089 `modeline-format', which means that it inherits all properties from
3090 that extent. Note that the extents in `generated-modeline-string'
3091 are managed automatically. You should not explicitly put any extents
3092 in `generated-modeline-string'; if you do, they will disappear the
3093 next time the modeline is processed.
3095 For extents in `modeline-format', the following properties are currently
3099 Affects the face of the modeline text. Currently, faces do
3100 not merge properly; only the most recently encountered face
3101 is used. This is a bug.
3104 Affects the disposition of button events over the modeline
3105 text. Multiple applicable keymaps *are* handled properly,
3106 and `modeline-map' still applies to any events that don't
3107 have bindings in extent-specific keymaps.
3110 If a string, causes the string to be displayed when the mouse
3111 moves over the text.
3114 /* Check for DEFVAR_BUFFER_LOCAL without initializing the corresponding
3115 slot of buffer_local_flags and vice-versa. Must be done after all
3116 DEFVAR_BUFFER_LOCAL() calls. */
3117 #define MARKED_SLOT(slot) \
3118 if ((XINT (buffer_local_flags.slot) != -2 && \
3119 XINT (buffer_local_flags.slot) != -3) \
3120 != !(NILP (XBUFFER (Vbuffer_local_symbols)->slot))) \
3122 #include "bufslots.h"
3126 Lisp_Object scratch = Fget_buffer_create (QSscratch);
3127 Fset_buffer (scratch);
3128 /* Want no undo records for *scratch* until after Emacs is dumped */
3129 Fbuffer_disable_undo (scratch);
3133 /* Is PWD another name for `.' ? */
3135 directory_is_current_directory (Extbyte *pwd)
3137 Bufbyte *pwd_internal;
3138 Bytecount pwd_internal_len;
3139 struct stat dotstat, pwdstat;
3141 TO_INTERNAL_FORMAT (DATA, (pwd, strlen ((char *)pwd) + 1),
3142 ALLOCA, (pwd_internal, pwd_internal_len),
3145 return (IS_DIRECTORY_SEP (*pwd_internal)
3146 && stat ((char *) pwd_internal, &pwdstat) == 0
3147 && stat (".", &dotstat) == 0
3148 && dotstat.st_ino == pwdstat.st_ino
3149 && dotstat.st_dev == pwdstat.st_dev
3150 && pwd_internal_len < MAXPATHLEN);
3154 init_initial_directory (void)
3156 /* This function can GC */
3160 initial_directory[0] = 0;
3162 /* If PWD is accurate, use it instead of calling getcwd. This is faster
3163 when PWD is right, and may avoid a fatal error. */
3164 if ((pwd = (Extbyte *) getenv ("PWD")) != NULL
3165 && directory_is_current_directory (pwd))
3166 strcpy (initial_directory, (char *) pwd);
3167 else if (getcwd (initial_directory, MAXPATHLEN) == NULL)
3168 fatal ("`getcwd' failed: %s\n", strerror (errno));
3170 /* Make sure pwd is DIRECTORY_SEP-terminated.
3171 Maybe this should really use some standard subroutine
3172 whose definition is filename syntax dependent. */
3174 int len = strlen (initial_directory);
3176 if (! IS_DIRECTORY_SEP (initial_directory[len - 1]))
3178 initial_directory[len] = DIRECTORY_SEP;
3179 initial_directory[len + 1] = '\0';
3183 /* XEmacs change: store buffer's default directory
3184 using preferred (i.e. as defined at compile-time)
3185 directory separator. --marcpa */
3187 #define CORRECT_DIR_SEPS(s) \
3188 do { if ('/' == DIRECTORY_SEP) dostounix_filename (s); \
3189 else unixtodos_filename (s); \
3192 CORRECT_DIR_SEPS(initial_directory);
3199 /* This function can GC */
3201 Fset_buffer (Fget_buffer_create (QSscratch));
3203 current_buffer->directory =
3204 build_ext_string (initial_directory, Qfile_name);
3207 /* #### is this correct? */
3208 temp = get_minibuffer (0);
3209 XBUFFER (temp)->directory = current_buffer->directory;
3210 #endif /* FSFmacs */