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.
79 #include "file-coding.h"
84 #include "process.h" /* for kill_buffer_processes */
85 #ifdef REGION_CACHE_NEEDS_WORK
86 #include "region-cache.h"
88 #include "select.h" /* for select_notify_buffer_kill */
89 #include "specifier.h"
91 #include "sysdep.h" /* for getwd */
96 struct buffer *current_buffer; /* the current buffer */
98 /* This structure holds the default values of the buffer-local variables
99 defined with DEFVAR_BUFFER_LOCAL, that have special slots in each buffer.
100 The default value occupies the same slot in this structure
101 as an individual buffer's value occupies in that buffer.
102 Setting the default value also goes through the alist of buffers
103 and stores into each buffer that does not say it has a local value. */
104 Lisp_Object Vbuffer_defaults;
105 static void *buffer_defaults_saved_slots;
107 /* This structure marks which slots in a buffer have corresponding
108 default values in Vbuffer_defaults.
109 Each such slot has a nonzero value in this structure.
110 The value has only one nonzero bit.
112 When a buffer has its own local value for a slot,
113 the bit for that slot (found in the same slot in this structure)
114 is turned on in the buffer's local_var_flags slot.
116 If a slot in this structure is 0, then there is a DEFVAR_BUFFER_LOCAL
117 for the slot, but there is no default value for it; the corresponding
118 slot in Vbuffer_defaults is not used except to initialize newly-created
121 If a slot is -1, then there is a DEFVAR_BUFFER_LOCAL for it
122 as well as a default value which is used to initialize newly-created
123 buffers and as a reset-value when local-vars are killed.
125 If a slot is -2, there is no DEFVAR_BUFFER_LOCAL for it.
126 (The slot is always local, but there's no lisp variable for it.)
127 The default value is only used to initialize newly-creation buffers.
129 If a slot is -3, then there is no DEFVAR_BUFFER_LOCAL for it but
130 there is a default which is used to initialize newly-creation
131 buffers and as a reset-value when local-vars are killed. */
132 struct buffer buffer_local_flags;
134 /* This is the initial (startup) directory, as used for the *scratch* buffer.
135 We're making this a global to make others aware of the startup directory.
136 `initial_directory' is stored in external format.
138 char initial_directory[MAXPATHLEN+1];
140 /* This structure holds the names of symbols whose values may be
141 buffer-local. It is indexed and accessed in the same way as the above. */
142 static Lisp_Object Vbuffer_local_symbols;
143 static void *buffer_local_symbols_saved_slots;
145 /* Alist of all buffer names vs the buffers. */
146 /* This used to be a variable, but is no longer,
147 to prevent lossage due to user rplac'ing this alist or its elements.
148 Note that there is a per-frame copy of this as well; the frame slot
149 and the global variable contain the same data, but possibly in different
150 orders, so that the buffer ordering can be per-frame.
152 Lisp_Object Vbuffer_alist;
154 /* Functions to call before and after each text change. */
155 Lisp_Object Qbefore_change_functions;
156 Lisp_Object Qafter_change_functions;
157 Lisp_Object Vbefore_change_functions;
158 Lisp_Object Vafter_change_functions;
160 /* #### Obsolete, for compatibility */
161 Lisp_Object Qbefore_change_function;
162 Lisp_Object Qafter_change_function;
163 Lisp_Object Vbefore_change_function;
164 Lisp_Object Vafter_change_function;
167 Lisp_Object Vtransient_mark_mode;
170 /* t means ignore all read-only text properties.
171 A list means ignore such a property if its value is a member of the list.
172 Any non-nil value means ignore buffer-read-only. */
173 Lisp_Object Vinhibit_read_only;
175 /* List of functions to call that can query about killing a buffer.
176 If any of these functions returns nil, we don't kill it. */
177 Lisp_Object Vkill_buffer_query_functions;
179 /* Non-nil means delete a buffer's auto-save file when the buffer is saved. */
180 int delete_auto_save_files;
182 Lisp_Object Qbuffer_live_p;
183 Lisp_Object Qbuffer_or_string_p;
185 /* List of functions to call before changing an unmodified buffer. */
186 Lisp_Object Vfirst_change_hook;
187 Lisp_Object Qfirst_change_hook;
189 Lisp_Object Qfundamental_mode;
190 Lisp_Object Qmode_class;
191 Lisp_Object Qpermanent_local;
193 Lisp_Object Qprotected_field;
195 Lisp_Object QSFundamental; /* A string "Fundamental" */
196 Lisp_Object QSscratch; /* "*scratch*" */
197 Lisp_Object Qdefault_directory;
199 Lisp_Object Qkill_buffer_hook;
201 Lisp_Object Qrename_auto_save_file;
203 Lisp_Object Qget_file_buffer;
204 Lisp_Object Qchange_major_mode_hook, Vchange_major_mode_hook;
206 Lisp_Object Qfind_file_compare_truenames;
208 Lisp_Object Qswitch_to_buffer;
210 /* Two thresholds controlling how much undo information to keep. */
212 int undo_high_threshold;
214 int find_file_compare_truenames;
215 int find_file_use_truenames;
218 static void reset_buffer_local_variables (struct buffer *, int first_time);
219 static void nuke_all_buffer_slots (struct buffer *b, Lisp_Object zap);
222 make_buffer (struct buffer *buf)
225 XSETBUFFER (obj, buf);
230 mark_buffer (Lisp_Object obj)
232 struct buffer *buf = XBUFFER (obj);
234 /* Truncate undo information. */
235 buf->undo_list = truncate_undo_list (buf->undo_list,
237 undo_high_threshold);
239 #define MARKED_SLOT(x) mark_object (buf->x)
240 #include "bufslots.h"
243 mark_object (buf->extent_info);
245 mark_object (buf->text->line_number_cache);
247 /* Don't mark normally through the children slot.
248 (Actually, in this case, it doesn't matter.) */
249 if (! EQ (buf->indirect_children, Qnull_pointer))
250 mark_conses_in_list (buf->indirect_children);
252 return buf->base_buffer ? make_buffer (buf->base_buffer) : Qnil;
256 print_buffer (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
258 struct buffer *b = XBUFFER (obj);
262 if (!BUFFER_LIVE_P (b))
263 error ("printing unreadable object #<killed buffer>");
265 error ("printing unreadable object #<buffer %s>",
266 XSTRING_DATA (b->name));
268 else if (!BUFFER_LIVE_P (b))
269 write_c_string ("#<killed buffer>", printcharfun);
272 write_c_string ("#<buffer ", printcharfun);
273 print_internal (b->name, printcharfun, 1);
274 write_c_string (">", printcharfun);
278 print_internal (b->name, printcharfun, 0);
282 /* We do not need a finalize method to handle a buffer's children list
283 because all buffers have `kill-buffer' applied to them before
284 they disappear, and the children removal happens then. */
285 DEFINE_LRECORD_IMPLEMENTATION ("buffer", buffer,
286 mark_buffer, print_buffer, 0, 0, 0, 0,
289 DEFUN ("bufferp", Fbufferp, 1, 1, 0, /*
290 Return t if OBJECT is an editor buffer.
294 return BUFFERP (object) ? Qt : Qnil;
297 DEFUN ("buffer-live-p", Fbuffer_live_p, 1, 1, 0, /*
298 Return t if OBJECT is an editor buffer that has not been deleted.
302 return BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object)) ? Qt : Qnil;
306 nsberror (Lisp_Object spec)
309 error ("No buffer named %s", XSTRING_DATA (spec));
310 signal_simple_error ("Invalid buffer argument", spec);
313 DEFUN ("buffer-list", Fbuffer_list, 0, 1, 0, /*
314 Return a list of all existing live buffers.
315 The order is specific to the selected frame; if the optional FRAME
316 argument is provided, the ordering for that frame is returned instead.
317 If the FRAME argument is t, then the global (non-frame) ordering is
322 return Fmapcar (Qcdr,
323 EQ (frame, Qt) ? Vbuffer_alist :
324 decode_frame (frame)->buffer_alist);
328 get_buffer (Lisp_Object name, int error_if_deleted_or_does_not_exist)
332 if (!BUFFER_LIVE_P (XBUFFER (name)))
334 if (error_if_deleted_or_does_not_exist)
346 name = LISP_GETTEXT (name); /* I18N3 */
348 buf = Fcdr (Fassoc (name, Vbuffer_alist));
350 if (NILP (buf) && error_if_deleted_or_does_not_exist)
357 decode_buffer (Lisp_Object buffer, int allow_string)
360 return current_buffer;
362 if (allow_string && STRINGP (buffer))
363 return XBUFFER (get_buffer (buffer, 1));
365 CHECK_LIVE_BUFFER (buffer);
366 return XBUFFER (buffer);
369 DEFUN ("decode-buffer", Fdecode_buffer, 1, 1, 0, /*
370 Validate BUFFER or if BUFFER is nil, return the current buffer.
371 If BUFFER is a valid buffer or a string representing a valid buffer,
372 the corresponding buffer object will be returned. Otherwise an error
377 struct buffer *b = decode_buffer (buffer, 1);
378 XSETBUFFER (buffer, b);
384 /* Like Fassoc, but use Fstring_equal to compare
385 (which ignores text properties),
386 and don't ever QUIT. */
389 assoc_ignore_text_properties (REGISTER Lisp_Object key, Lisp_Object list)
391 REGISTER Lisp_Object tail;
392 for (tail = list; !NILP (tail); tail = Fcdr (tail))
394 REGISTER Lisp_Object elt, tem;
396 tem = Fstring_equal (Fcar (elt), key);
405 DEFUN ("get-buffer", Fget_buffer, 1, 1, 0, /*
406 Return the buffer named BUFFER-NAME (a string), or nil if there is none.
407 BUFFER-NAME may also be a buffer; if so, the value is that buffer.
412 /* #### Doc string should indicate that the buffer name will get
416 /* #### This might return a dead buffer. This is gross. This is
417 called FSF compatibility. */
418 if (BUFFERP (buffer_name))
420 return get_buffer (buffer_name, 0);
421 /* FSFmacs 19.29 calls assoc_ignore_text_properties() here.
426 DEFUN ("get-file-buffer", Fget_file_buffer, 1, 1, 0, /*
427 Return the buffer visiting file FILENAME (a string).
428 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
429 If there is no such live buffer, return nil.
431 Normally, the comparison is done by canonicalizing FILENAME (using
432 `expand-file-name') and comparing that to the value of `buffer-file-name'
433 for each existing buffer. However, If `find-file-compare-truenames' is
434 non-nil, FILENAME will be converted to its truename and the search will be
435 done on each buffer's value of `buffer-file-truename' instead of
436 `buffer-file-name'. Otherwise, if `find-file-use-truenames' is non-nil,
437 FILENAME will be converted to its truename and used for searching, but
438 the search will still be done on `buffer-file-name'.
442 /* This function can GC. GC checked and fixed 7-11-2000 ben. */
443 REGISTER Lisp_Object buf;
447 /* DO NOT translate the filename. */
450 CHECK_STRING (filename);
451 filename = Fexpand_file_name (filename, Qnil);
453 /* If the file name has special constructs in it,
454 call the corresponding file handler. */
455 Lisp_Object handler = Ffind_file_name_handler (filename, Qget_file_buffer);
459 return call2 (handler, Qget_file_buffer, filename);
464 if (find_file_compare_truenames || find_file_use_truenames)
466 struct gcpro ngcpro1, ngcpro2, ngcpro3;
467 Lisp_Object fn = Qnil;
468 Lisp_Object dn = Qnil;
470 NGCPRO3 (fn, dn, filename);
471 fn = Ffile_truename (filename, Qnil);
474 dn = Ffile_name_directory (filename);
475 fn = Ffile_truename (dn, Qnil);
476 if (! NILP (fn)) dn = fn;
477 /* Formerly the two calls below were combined, but that is
478 not GC-safe because the first call returns unprotected
479 data and the second call can GC. --ben */
480 fn = Ffile_name_nondirectory (filename);
481 fn = Fexpand_file_name (fn, dn);
488 LIST_LOOP_2 (elt, Vbuffer_alist)
491 if (!BUFFERP (buf)) continue;
492 if (!STRINGP (XBUFFER (buf)->filename)) continue;
493 if (!NILP (Fstring_equal (filename,
494 (find_file_compare_truenames
495 ? XBUFFER (buf)->file_truename
496 : XBUFFER (buf)->filename))))
505 push_buffer_alist (Lisp_Object name, Lisp_Object buf)
507 Lisp_Object cons = Fcons (name, buf);
508 Lisp_Object frmcons, devcons, concons;
510 Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (cons, Qnil));
511 FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
514 f = XFRAME (XCAR (frmcons));
515 f->buffer_alist = nconc2 (f->buffer_alist, Fcons (cons, Qnil));
520 delete_from_buffer_alist (Lisp_Object buf)
522 Lisp_Object cons = Frassq (buf, Vbuffer_alist);
523 Lisp_Object frmcons, devcons, concons;
525 return; /* abort() ? */
526 Vbuffer_alist = delq_no_quit (cons, Vbuffer_alist);
528 FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
531 f = XFRAME (XCAR (frmcons));
532 f->buffer_alist = delq_no_quit (cons, f->buffer_alist);
537 get_truename_buffer (REGISTER Lisp_Object filename)
539 /* This function can GC. GC correct 7-11-00 ben */
540 /* FSFmacs has its own code here and doesn't call get-file-buffer.
541 That's because their equivalent of find-file-compare-truenames
542 (find-file-existing-other-name) isn't looked at in get-file-buffer.
543 This way is more correct. */
544 int count = specpdl_depth ();
546 specbind (Qfind_file_compare_truenames, Qt);
547 return unbind_to (count, Fget_file_buffer (filename));
550 static struct buffer *
551 allocate_buffer (void)
553 struct buffer *b = alloc_lcrecord_type (struct buffer, &lrecord_buffer);
555 copy_lcrecord (b, XBUFFER (Vbuffer_defaults));
561 finish_init_buffer (struct buffer *b, Lisp_Object name)
567 name = Fcopy_sequence (name);
568 /* #### This really does not need to be called. We already
569 initialized the buffer-local variables in allocate_buffer().
570 local_var_alist is set to Qnil at the same point, in
571 nuke_all_buffer_slots(). */
572 reset_buffer_local_variables (b, 1);
573 b->directory = current_buffer ? current_buffer->directory : Qnil;
575 b->last_window_start = 1;
578 if (string_byte (XSTRING (name), 0) != ' ')
583 /* initialize the extent list */
584 init_buffer_extents (b);
586 /* Put this in the alist of all live buffers. */
587 push_buffer_alist (name, buf);
589 init_buffer_markers (b);
591 b->generated_modeline_string = Fmake_string (make_int (84), make_int (' '));
592 b->modeline_extent_table = make_lisp_hash_table (20, HASH_TABLE_KEY_WEAK,
598 DEFUN ("get-buffer-create", Fget_buffer_create, 1, 1, 0, /*
599 Return the buffer named NAME, or create such a buffer and return it.
600 A new buffer is created if there is no live buffer named NAME.
601 If NAME starts with a space, the new buffer does not keep undo information.
602 If NAME is a buffer instead of a string, then it is the value returned.
603 The value is never nil.
607 /* This function can GC */
609 REGISTER struct buffer *b;
612 /* #### Doc string should indicate that the buffer name will get
616 name = LISP_GETTEXT (name);
617 buf = Fget_buffer (name);
621 if (XSTRING_LENGTH (name) == 0)
622 error ("Empty string for buffer name is not allowed");
624 b = allocate_buffer ();
626 b->text = &b->own_text;
628 b->indirect_children = Qnil;
629 init_buffer_text (b);
631 return finish_init_buffer (b, name);
634 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer, 2, 2,
635 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ", /*
636 Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
637 BASE-BUFFER should be an existing buffer (or buffer name).
638 NAME should be a string which is not the name of an existing buffer.
640 If BASE-BUFFER is itself an indirect buffer, the base buffer for that buffer
641 is made the base buffer for the newly created buffer. (Thus, there will
642 never be indirect buffers whose base buffers are themselves indirect.)
646 /* This function can GC */
648 /* #### The above interactive specification is totally bogus,
649 because it offers an existing buffer as default answer to the
650 second question. However, the second argument may not BE an
654 base_buffer = get_buffer (base_buffer, 1);
657 /* #### Doc string should indicate that the buffer name will get
661 name = LISP_GETTEXT (name);
662 if (!NILP (Fget_buffer (name)))
663 signal_simple_error ("Buffer name already in use", name);
664 if (XSTRING_LENGTH (name) == 0)
665 error ("Empty string for buffer name is not allowed");
667 b = allocate_buffer ();
669 b->base_buffer = BUFFER_BASE_BUFFER (XBUFFER (base_buffer));
671 /* Use the base buffer's text object. */
672 b->text = b->base_buffer->text;
673 b->indirect_children = Qnil;
674 b->base_buffer->indirect_children =
675 Fcons (make_buffer (b), b->base_buffer->indirect_children);
676 init_buffer_text (b);
678 return finish_init_buffer (b, name);
684 reset_buffer_local_variables (struct buffer *b, int first_time)
686 struct buffer *def = XBUFFER (Vbuffer_defaults);
688 b->local_var_flags = 0;
689 /* For each slot that has a default value,
690 copy that into the slot. */
691 #define MARKED_SLOT(slot) \
692 { int mask = XINT (buffer_local_flags.slot); \
693 if ((mask > 0 || mask == -1 || mask == -3) \
695 || NILP (Fget (XBUFFER (Vbuffer_local_symbols)->slot, \
696 Qpermanent_local, Qnil)))) \
697 b->slot = def->slot; \
699 #include "bufslots.h"
704 /* We split this away from generate-new-buffer, because rename-buffer
705 and set-visited-file-name ought to be able to use this to really
706 rename the buffer properly. */
708 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name, 1, 2, 0, /*
709 Return a string that is the name of no existing buffer based on NAME.
710 If there is no live buffer named NAME, then return NAME.
711 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
712 until an unused name is found, and then return that name.
713 Optional second argument IGNORE specifies a name that is okay to use
714 \(if it is in the sequence to be tried)
715 even if a buffer with that name exists.
719 REGISTER Lisp_Object gentemp, tem;
725 name = LISP_GETTEXT (name);
727 /* #### Doc string should indicate that the buffer name will get
731 tem = Fget_buffer (name);
738 sprintf (number, "<%d>", ++count);
739 gentemp = concat2 (name, build_string (number));
742 tem = Fstring_equal (gentemp, ignore);
746 tem = Fget_buffer (gentemp);
753 DEFUN ("buffer-name", Fbuffer_name, 0, 1, 0, /*
754 Return the name of BUFFER, as a string.
755 With no argument or nil as argument, return the name of the current buffer.
759 /* For compatibility, we allow a dead buffer here.
760 Earlier versions of Emacs didn't provide buffer-live-p. */
762 return current_buffer->name;
763 CHECK_BUFFER (buffer);
764 return XBUFFER (buffer)->name;
767 DEFUN ("buffer-file-name", Fbuffer_file_name, 0, 1, 0, /*
768 Return name of file BUFFER is visiting, or nil if none.
769 No argument or nil as argument means use the current buffer.
773 /* For compatibility, we allow a dead buffer here. Yuck! */
775 return current_buffer->filename;
776 CHECK_BUFFER (buffer);
777 return XBUFFER (buffer)->filename;
780 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer, 0, 1, 0, /*
781 Return the base buffer of indirect buffer BUFFER.
782 If BUFFER is not indirect, return nil.
786 struct buffer *buf = decode_buffer (buffer, 0);
788 return buf->base_buffer ? make_buffer (buf->base_buffer) : Qnil;
791 DEFUN ("buffer-indirect-children", Fbuffer_indirect_children, 0, 1, 0, /*
792 Return a list of all indirect buffers whose base buffer is BUFFER.
793 If BUFFER is indirect, the return value will always be nil; see
794 `make-indirect-buffer'.
798 struct buffer *buf = decode_buffer (buffer, 0);
800 return Fcopy_sequence (buf->indirect_children);
803 DEFUN ("buffer-local-variables", Fbuffer_local_variables, 0, 1, 0, /*
804 Return an alist of variables that are buffer-local in BUFFER.
805 Most elements look like (SYMBOL . VALUE), describing one variable.
806 For a symbol that is locally unbound, just the symbol appears in the value.
807 Note that storing new VALUEs in these elements doesn't change the variables.
808 No argument or nil as argument means use current buffer as BUFFER.
812 struct buffer *buf = decode_buffer (buffer, 0);
813 Lisp_Object result = Qnil;
817 for (tail = buf->local_var_alist; CONSP (tail); tail = XCDR (tail))
819 Lisp_Object elt = XCAR (tail);
820 /* Reference each variable in the alist in buf.
821 If inquiring about the current buffer, this gets the current values,
822 so store them into the alist so the alist is up to date.
823 If inquiring about some other buffer, this swaps out any values
824 for that buffer, making the alist up to date automatically. */
825 Lisp_Object val = find_symbol_value (XCAR (elt));
826 /* Use the current buffer value only if buf is the current buffer. */
827 if (buf != current_buffer)
830 /* If symbol is unbound, put just the symbol in the list. */
832 result = Fcons (XCAR (elt), result);
833 /* Otherwise, put (symbol . value) in the list. */
835 result = Fcons (Fcons (XCAR (elt), val), result);
839 /* Add on all the variables stored in special slots. */
841 struct buffer *syms = XBUFFER (Vbuffer_local_symbols);
842 #define MARKED_SLOT(slot) \
843 { int mask = XINT (buffer_local_flags.slot); \
844 if (mask == 0 || mask == -1 \
845 || ((mask > 0) && (buf->local_var_flags & mask))) \
846 result = Fcons (Fcons (syms->slot, buf->slot), result); \
848 #include "bufslots.h"
855 DEFUN ("buffer-modified-p", Fbuffer_modified_p, 0, 1, 0, /*
856 Return t if BUFFER was modified since its file was last read or saved.
857 No argument or nil as argument means use current buffer as BUFFER.
861 struct buffer *buf = decode_buffer (buffer, 0);
863 return BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf) ? Qt : Qnil;
866 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p, 1, 2, 0, /*
867 Mark BUFFER as modified or unmodified according to FLAG.
868 A non-nil FLAG means mark the buffer modified. No argument or nil
869 as BUFFER means use current buffer.
873 /* This function can GC */
874 struct buffer *buf = decode_buffer (buffer, 0);
876 #ifdef CLASH_DETECTION
877 /* If buffer becoming modified, lock the file.
878 If buffer becoming unmodified, unlock the file. */
880 Lisp_Object fn = buf->file_truename;
883 int already = BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf);
884 if (already == NILP (flag))
886 int count = specpdl_depth ();
887 /* lock_file() and unlock_file() currently use current_buffer */
888 /* #### - dmoore, what if lock_file or unlock_file kill
889 the current buffer? */
890 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
891 set_buffer_internal (buf);
892 if (!already && !NILP (flag))
894 else if (already && NILP (flag))
896 unbind_to (count, Qnil);
899 #endif /* CLASH_DETECTION */
901 /* This is often called when the buffer contents are altered but we
902 don't want to treat the changes that way (e.g. selective
903 display). We still need to make sure redisplay realizes that the
904 contents have potentially altered and it needs to do some
906 buf = decode_buffer (buffer, 0);
908 BUF_SAVE_MODIFF (buf) = NILP (flag) ? BUF_MODIFF (buf) : 0;
909 MARK_MODELINE_CHANGED;
914 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick, 0, 1, 0, /*
915 Return BUFFER's tick counter, incremented for each change in text.
916 Each buffer has a tick counter which is incremented each time the text in
917 that buffer is changed. It wraps around occasionally.
918 No argument or nil as argument means use current buffer as BUFFER.
922 struct buffer *buf = decode_buffer (buffer, 0);
924 return make_int (BUF_MODIFF (buf));
927 DEFUN ("rename-buffer", Frename_buffer, 1, 2,
928 "sRename buffer (to new name): \nP", /*
929 Change current buffer's name to NEWNAME (a string).
930 If second arg UNIQUE is nil or omitted, it is an error if a
931 buffer named NEWNAME already exists.
932 If UNIQUE is non-nil, come up with a new name using
933 `generate-new-buffer-name'.
934 Interactively, one can set UNIQUE with a prefix argument.
935 Returns the name we actually gave the buffer.
936 This does not change the name of the visited file (if any).
940 /* This function can GC */
941 Lisp_Object tem, buf;
944 /* #### Doc string should indicate that the buffer name will get
947 CHECK_STRING (newname);
948 newname = LISP_GETTEXT (newname);
950 if (XSTRING_LENGTH (newname) == 0)
951 error ("Empty string is invalid as a buffer name");
953 tem = Fget_buffer (newname);
954 /* Don't short-circuit if UNIQUE is t. That is a useful way to rename
955 the buffer automatically so you can create another with the original name.
956 It makes UNIQUE equivalent to
957 (rename-buffer (generate-new-buffer-name NEWNAME)). */
958 /* XEmacs change: added check for nil */
959 if (NILP (unique) && !NILP (tem) && XBUFFER (tem) == current_buffer)
960 return current_buffer->name;
964 newname = Fgenerate_new_buffer_name (newname, current_buffer->name);
966 error ("Buffer name \"%s\" is in use",
967 XSTRING_DATA (newname));
970 current_buffer->name = newname;
972 /* Catch redisplay's attention. Unless we do this, the modelines for
973 any windows displaying current_buffer will stay unchanged. */
974 MARK_MODELINE_CHANGED;
976 buf = Fcurrent_buffer ();
978 /* The aconses in the Vbuffer_alist are shared with frame->buffer_alist,
979 so this will change it in the per-frame ordering as well. */
980 Fsetcar (Frassq (buf, Vbuffer_alist), newname);
982 if (NILP (current_buffer->filename)
983 && !NILP (current_buffer->auto_save_file_name))
984 call0 (Qrename_auto_save_file);
985 /* refetch since that last call may have done GC */
986 /* (hypothetical relocating GC) */
987 return current_buffer->name;
990 DEFUN ("other-buffer", Fother_buffer, 0, 3, 0, /*
991 Return most recently selected buffer other than BUFFER.
992 Buffers not visible in windows are preferred to visible buffers,
993 unless optional third argument VISIBLE-OK is non-nil.
994 If no other buffer exists, the buffer `*scratch*' is returned.
995 If BUFFER is omitted or nil, some interesting buffer is returned.
997 The ordering is for this frame; If second optional argument FRAME
998 is provided, then the ordering is for that frame. If the second arg
999 is t, then the global ordering is returned.
1001 Note: In FSF Emacs, this function takes two arguments: BUFFER and
1004 (buffer, frame, visible_ok))
1006 /* This function can GC */
1007 Lisp_Object tail, buf, notsogood, tem;
1013 alist = Vbuffer_alist;
1016 struct frame *f = decode_frame (frame);
1018 XSETFRAME (frame, f);
1019 alist = f->buffer_alist;
1022 for (tail = alist; !NILP (tail); tail = Fcdr (tail))
1024 buf = Fcdr (Fcar (tail));
1025 if (EQ (buf, buffer))
1027 if (string_byte (XSTRING (XBUFFER (buf)->name), 0) == ' ')
1029 /* If FRAME has a buffer_predicate,
1030 disregard buffers that don't fit the predicate. */
1033 tem = XFRAME (frame)->buffer_predicate;
1036 tem = call1 (tem, buf);
1042 if (NILP (visible_ok))
1044 /* get-buffer-window will handle nil or t frame */
1045 tem = Fget_buffer_window (buf, frame, Qnil);
1051 if (NILP (notsogood))
1054 if (!NILP (notsogood))
1056 return Fget_buffer_create (QSscratch);
1059 DEFUN ("buffer-disable-undo", Fbuffer_disable_undo, 0, 1, "", /*
1060 Stop keeping undo information for BUFFER.
1061 Any undo records it already has are discarded.
1062 No argument or nil as argument means do this for the current buffer.
1066 /* Allowing nil is an RMSism */
1067 struct buffer *real_buf = decode_buffer (buffer, 1);
1068 real_buf->undo_list = Qt;
1072 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo, 0, 1, "", /*
1073 Start keeping undo information for BUFFER.
1074 No argument or nil as argument means do this for the current buffer.
1078 /* Allowing nil is an RMSism */
1079 struct buffer *real_buf = decode_buffer (buffer, 1);
1080 if (EQ (real_buf->undo_list, Qt))
1081 real_buf->undo_list = Qnil;
1086 DEFUN ("kill-buffer", Fkill_buffer, 1, 1, "bKill buffer: ", /*
1087 Kill the buffer BUFFER.
1088 The argument may be a buffer or may be the name of a buffer.
1089 An argument of nil means kill the current buffer.
1091 Value is t if the buffer is actually killed, nil if user says no.
1093 The value of `kill-buffer-hook' (which may be local to that buffer),
1094 if not void, is a list of functions to be called, with no arguments,
1095 before the buffer is actually killed. The buffer to be killed is current
1096 when the hook functions are called.
1098 Any processes that have this buffer as the `process-buffer' are killed
1099 with `delete-process'.
1103 /* This function can call lisp */
1105 REGISTER struct buffer *b;
1106 struct gcpro gcpro1, gcpro2;
1109 buf = Fcurrent_buffer ();
1110 else if (BUFFERP (buffer))
1114 buf = get_buffer (buffer, 0);
1115 if (NILP (buf)) nsberror (buffer);
1120 /* OK to delete an already-deleted buffer. */
1121 if (!BUFFER_LIVE_P (b))
1124 /* Don't kill the minibuffer now current. */
1125 if (EQ (buf, Vminibuffer_zero))
1128 /* Or the echo area. */
1129 if (EQ (buf, Vecho_area_buffer))
1132 /* Query if the buffer is still modified. */
1133 if (INTERACTIVE && !NILP (b->filename)
1134 && BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
1140 (emacs_doprnt_string_c
1141 ((const Bufbyte *) GETTEXT ("Buffer %s modified; kill anyway? "),
1142 Qnil, -1, XSTRING_DATA (b->name))));
1146 b = XBUFFER (buf); /* Hypothetical relocating GC. */
1149 /* Run hooks with the buffer to be killed temporarily selected,
1150 unless the buffer is already dead (could have been deleted
1151 in the question above).
1153 if (BUFFER_LIVE_P (b))
1155 int speccount = specpdl_depth ();
1156 Lisp_Object tail = Qnil;
1159 record_unwind_protect (save_excursion_restore, save_excursion_save ());
1162 /* First run the query functions; if any query is answered no,
1163 don't kill the buffer. */
1164 EXTERNAL_LIST_LOOP (tail, Vkill_buffer_query_functions)
1166 if (NILP (call0 (Fcar (tail))))
1169 return unbind_to (speccount, Qnil);
1173 /* Then run the hooks. */
1174 run_hook (Qkill_buffer_hook);
1176 /* Inform the selection code that a buffer just got killed.
1177 We do this in C because (a) it's faster, and (b) it needs
1178 to access data internal to select.c that can't be seen from
1179 Lisp (so the Lisp code would just call into C anyway. */
1180 select_notify_buffer_kill (buf);
1182 unbind_to (speccount, Qnil);
1184 b = XBUFFER (buf); /* Hypothetical relocating GC. */
1187 /* We have no more questions to ask. Verify that it is valid
1188 to kill the buffer. This must be done after the questions
1189 since anything can happen within yes-or-no-p. */
1191 /* Might have been deleted during the last question above */
1192 if (!BUFFER_LIVE_P (b))
1195 /* Don't kill the minibuffer now current. */
1196 if (EQ (buf, XWINDOW (minibuf_window)->buffer))
1199 /* When we kill a base buffer, kill all its indirect buffers.
1200 We do it at this stage so nothing terrible happens if they
1201 ask questions or their hooks get errors. */
1202 if (! b->base_buffer)
1208 LIST_LOOP (rest, b->indirect_children)
1210 Fkill_buffer (XCAR (rest));
1211 /* Keep indirect_children updated in case a
1212 query-function/hook throws. */
1213 b->indirect_children = XCDR (rest);
1219 /* Make this buffer not be current.
1220 In the process, notice if this is the sole visible buffer
1221 and give up if so. */
1222 if (b == current_buffer)
1224 Fset_buffer (Fother_buffer (buf, Qnil, Qnil));
1225 if (b == current_buffer)
1229 /* Now there is no question: we can kill the buffer. */
1231 #ifdef CLASH_DETECTION
1232 /* Unlock this buffer's file, if it is locked. unlock_buffer
1233 can both GC and kill the current buffer, and wreak general
1234 havok by running lisp code. */
1240 if (!BUFFER_LIVE_P (b))
1243 if (b == current_buffer)
1245 Fset_buffer (Fother_buffer (buf, Qnil, Qnil));
1246 if (b == current_buffer)
1249 #endif /* CLASH_DETECTION */
1252 int speccount = specpdl_depth ();
1253 specbind (Qinhibit_quit, Qt);
1255 kill_buffer_processes (buf);
1257 delete_from_buffer_alist (buf);
1259 /* #### This is a problem if this buffer is in a dedicated window.
1260 Need to undedicate any windows of this buffer first (and delete them?)
1262 Freplace_buffer_in_windows (buf, Qnil, Qnil);
1264 font_lock_buffer_was_killed (b);
1266 /* Delete any auto-save file, if we saved it in this session. */
1267 if (STRINGP (b->auto_save_file_name)
1268 && b->auto_save_modified != 0
1269 && BUF_SAVE_MODIFF (b) < b->auto_save_modified)
1271 if (delete_auto_save_files != 0)
1273 /* deleting the auto save file might kill b! */
1274 /* #### dmoore - fix this crap, we do this same gcpro and
1275 buffer liveness check multiple times. Let's get a
1276 macro or something for it. */
1278 internal_delete_file (b->auto_save_file_name);
1282 if (!BUFFER_LIVE_P (b))
1285 if (b == current_buffer)
1287 Fset_buffer (Fother_buffer (buf, Qnil, Qnil));
1288 if (b == current_buffer)
1294 uninit_buffer_markers (b);
1296 kill_buffer_local_variables (b);
1299 uninit_buffer_text (b);
1300 b->undo_list = Qnil;
1301 uninit_buffer_extents (b);
1304 #ifdef ERROR_CHECK_BUFPOS
1305 assert (!NILP (memq_no_quit (buf, b->base_buffer->indirect_children)));
1307 b->base_buffer->indirect_children =
1308 delq_no_quit (buf, b->base_buffer->indirect_children);
1311 /* Clear away all Lisp objects, so that they
1312 won't be protected from GC. */
1313 nuke_all_buffer_slots (b, Qnil);
1315 unbind_to (speccount, Qnil);
1320 DEFUN ("record-buffer", Frecord_buffer, 1, 1, 0, /*
1321 Place buffer BUFFER first in the buffer order.
1322 Call this function when a buffer is selected "visibly".
1324 This function changes the global buffer order and the per-frame buffer
1325 order for the selected frame. The buffer order keeps track of recency
1326 of selection so that `other-buffer' will return a recently selected
1327 buffer. See `other-buffer' for more information.
1331 REGISTER Lisp_Object lynk, prev;
1332 struct frame *f = selected_frame ();
1335 for (lynk = Vbuffer_alist; CONSP (lynk); lynk = XCDR (lynk))
1337 if (EQ (XCDR (XCAR (lynk)), buffer))
1341 /* Effectively do Vbuffer_alist = delq_no_quit (lynk, Vbuffer_alist) */
1343 Vbuffer_alist = XCDR (Vbuffer_alist);
1345 XCDR (prev) = XCDR (XCDR (prev));
1346 XCDR (lynk) = Vbuffer_alist;
1347 Vbuffer_alist = lynk;
1349 /* That was the global one. Now do the same thing for the
1350 per-frame buffer-alist. */
1352 for (lynk = f->buffer_alist; CONSP (lynk); lynk = XCDR (lynk))
1354 if (EQ (XCDR (XCAR (lynk)), buffer))
1358 /* Effectively do f->buffer_alist = delq_no_quit (lynk, f->buffer_alist) */
1360 f->buffer_alist = XCDR (f->buffer_alist);
1362 XCDR (prev) = XCDR (XCDR (prev));
1363 XCDR (lynk) = f->buffer_alist;
1364 f->buffer_alist = lynk;
1369 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode, 1, 1, 0, /*
1370 Set an appropriate major mode for BUFFER, according to `default-major-mode'.
1371 Use this function before selecting the buffer, since it may need to inspect
1372 the current buffer's major mode.
1376 int speccount = specpdl_depth ();
1377 Lisp_Object function = XBUFFER (Vbuffer_defaults)->major_mode;
1379 if (NILP (function))
1381 Lisp_Object tem = Fget (current_buffer->major_mode, Qmode_class, Qnil);
1383 function = current_buffer->major_mode;
1386 if (NILP (function) || EQ (function, Qfundamental_mode))
1389 /* To select a nonfundamental mode,
1390 select the buffer temporarily and then call the mode function. */
1392 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
1394 Fset_buffer (buffer);
1397 return unbind_to (speccount, Qnil);
1401 switch_to_buffer (Lisp_Object bufname, Lisp_Object norecord)
1403 call2 (Qswitch_to_buffer, bufname, norecord);
1407 DEFUN ("current-buffer", Fcurrent_buffer, 0, 0, 0, /*
1408 Return the current buffer as a Lisp object.
1413 XSETBUFFER (buffer, current_buffer);
1417 /* Set the current buffer to B. */
1420 set_buffer_internal (struct buffer *b)
1422 REGISTER struct buffer *old_buf;
1423 REGISTER Lisp_Object tail;
1425 if (current_buffer == b)
1428 INVALIDATE_PIXEL_TO_GLYPH_CACHE;
1430 old_buf = current_buffer;
1432 invalidate_current_column (); /* invalidate indentation cache */
1436 /* Put the undo list back in the base buffer, so that it appears
1437 that an indirect buffer shares the undo list of its base. */
1438 if (old_buf->base_buffer)
1439 old_buf->base_buffer->undo_list = old_buf->undo_list;
1442 /* Get the undo list from the base buffer, so that it appears
1443 that an indirect buffer shares the undo list of its base. */
1445 b->undo_list = b->base_buffer->undo_list;
1447 /* Look down buffer's list of local Lisp variables
1448 to find and update any that forward into C variables. */
1450 LIST_LOOP (tail, b->local_var_alist)
1452 Lisp_Object sym = XCAR (XCAR (tail));
1453 Lisp_Object valcontents = XSYMBOL (sym)->value;
1454 if (SYMBOL_VALUE_MAGIC_P (valcontents))
1456 /* Just reference the variable
1457 to cause it to become set for this buffer. */
1458 /* Use find_symbol_value_quickly to avoid an unnecessary O(n)
1460 (void) find_symbol_value_quickly (XCAR (tail), 1);
1464 /* Do the same with any others that were local to the previous buffer */
1468 LIST_LOOP (tail, old_buf->local_var_alist)
1470 Lisp_Object sym = XCAR (XCAR (tail));
1471 Lisp_Object valcontents = XSYMBOL (sym)->value;
1473 if (SYMBOL_VALUE_MAGIC_P (valcontents))
1475 /* Just reference the variable
1476 to cause it to become set for this buffer. */
1477 /* Use find_symbol_value_quickly with find_it_p as 0 to avoid an
1478 unnecessary O(n) lookup which is guaranteed to be worst case.
1479 Any symbols which are local are guaranteed to have been
1480 handled in the previous loop, above. */
1481 (void) find_symbol_value_quickly (sym, 0);
1487 DEFUN ("set-buffer", Fset_buffer, 1, 1, 0, /*
1488 Make the buffer BUFFER current for editing operations.
1489 BUFFER may be a buffer or the name of an existing buffer.
1490 See also `save-excursion' when you want to make a buffer current temporarily.
1491 This function does not display the buffer, so its effect ends
1492 when the current command terminates.
1493 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.
1497 buffer = get_buffer (buffer, 0);
1499 error ("Selecting deleted or non-existent buffer");
1500 set_buffer_internal (XBUFFER (buffer));
1505 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only, 0, 3, 0, /*
1506 Signal a `buffer-read-only' error if BUFFER is read-only.
1507 Optional argument BUFFER defaults to the current buffer.
1509 If optional argument START is non-nil, all extents in the buffer
1510 which overlap that part of the buffer are checked to ensure none has a
1511 `read-only' property. (Extents that lie completely within the range,
1512 however, are not checked.) END defaults to the value of START.
1514 If START and END are equal, the range checked is [START, END] (i.e.
1515 closed on both ends); otherwise, the range checked is (START, END)
1516 \(open on both ends), except that extents that lie completely within
1517 [START, END] are not checked. See `extent-in-region-p' for a fuller
1520 (buffer, start, end))
1522 struct buffer *b = decode_buffer (buffer, 0);
1531 get_buffer_range_char (b, start, end, &s, &e, 0);
1533 barf_if_buffer_read_only (b, s, e);
1539 bury_buffer_1 (Lisp_Object buffer, Lisp_Object before,
1540 Lisp_Object *buffer_alist)
1542 Lisp_Object aelt = rassq_no_quit (buffer, *buffer_alist);
1543 Lisp_Object lynk = memq_no_quit (aelt, *buffer_alist);
1544 Lisp_Object iter, before_before;
1546 *buffer_alist = delq_no_quit (aelt, *buffer_alist);
1547 for (before_before = Qnil, iter = *buffer_alist;
1548 !NILP (iter) && !EQ (XCDR (XCAR (iter)), before);
1549 before_before = iter, iter = XCDR (iter))
1552 if (!NILP (before_before))
1553 XCDR (before_before) = lynk;
1555 *buffer_alist = lynk;
1558 DEFUN ("bury-buffer", Fbury_buffer, 0, 2, "", /*
1559 Put BUFFER at the end of the list of all buffers.
1560 There it is the least likely candidate for `other-buffer' to return;
1561 thus, the least likely buffer for \\[switch-to-buffer] to select by default.
1562 If BUFFER is nil or omitted, bury the current buffer.
1563 Also, if BUFFER is nil or omitted, remove the current buffer from the
1564 selected window if it is displayed there.
1565 Because of this, you may need to specify (current-buffer) as
1566 BUFFER when calling from minibuffer.
1567 If BEFORE is non-nil, it specifies a buffer before which BUFFER
1568 will be placed, instead of being placed at the end.
1572 /* This function can GC */
1573 struct buffer *buf = decode_buffer (buffer, 1);
1574 /* If we're burying the current buffer, unshow it. */
1575 /* Note that the behavior of (bury-buffer nil) and
1576 (bury-buffer (current-buffer)) is not the same.
1577 This is illogical but is historical. Changing it
1578 breaks mh-e and TeX and such packages. */
1580 switch_to_buffer (Fother_buffer (Fcurrent_buffer (), Qnil, Qnil), Qnil);
1581 XSETBUFFER (buffer, buf);
1584 before = get_buffer (before, 1);
1586 if (EQ (before, buffer))
1587 error ("Cannot place a buffer before itself");
1589 bury_buffer_1 (buffer, before, &Vbuffer_alist);
1590 bury_buffer_1 (buffer, before, &selected_frame ()->buffer_alist);
1596 DEFUN ("erase-buffer", Ferase_buffer, 0, 1, "*", /*
1597 Delete the entire contents of the BUFFER.
1598 Any clipping restriction in effect (see `narrow-to-region') is removed,
1599 so the buffer is truly empty after this.
1600 BUFFER defaults to the current buffer if omitted.
1604 /* This function can GC */
1605 struct buffer *b = decode_buffer (buffer, 1);
1606 /* #### yuck yuck yuck. This is gross. The old echo-area code,
1607 however, was the only place that called erase_buffer() with a
1608 non-zero NO_CLIP argument.
1610 Someone needs to fix up the redisplay code so it is smarter
1611 about this, so that the NO_CLIP junk isn't necessary. */
1612 int no_clip = (b == XBUFFER (Vecho_area_buffer));
1614 INVALIDATE_PIXEL_TO_GLYPH_CACHE;
1616 widen_buffer (b, no_clip);
1617 buffer_delete_range (b, BUF_BEG (b), BUF_Z (b), 0);
1618 b->last_window_start = 1;
1620 /* Prevent warnings, or suspension of auto saving, that would happen
1621 if future size is less than past size. Use of erase-buffer
1622 implies that the future text is not really related to the past text. */
1623 b->saved_size = Qzero;
1625 zmacs_region_stays = 0;
1631 DEFUN ("kill-all-local-variables", Fkill_all_local_variables, 0, 0, 0, /*
1632 Switch to Fundamental mode by killing current buffer's local variables.
1633 Most local variable bindings are eliminated so that the default values
1634 become effective once more. Also, the syntax table is set from
1635 `standard-syntax-table', the category table is set from
1636 `standard-category-table' (if support for Mule exists), local keymap is set
1637 to nil, the abbrev table is set from `fundamental-mode-abbrev-table',
1638 and all specifier specifications whose locale is the current buffer
1639 are removed. This function also forces redisplay of the modeline.
1641 Every function to select a new major mode starts by
1642 calling this function.
1644 As a special exception, local variables whose names have
1645 a non-nil `permanent-local' property are not eliminated by this function.
1647 The first thing this function does is run
1648 the normal hook `change-major-mode-hook'.
1652 /* This function can GC */
1653 run_hook (Qchange_major_mode_hook);
1655 reset_buffer_local_variables (current_buffer, 0);
1657 kill_buffer_local_variables (current_buffer);
1659 kill_specifier_buffer_locals (Fcurrent_buffer ());
1661 /* Force modeline redisplay. Useful here because all major mode
1662 commands call this function. */
1663 MARK_MODELINE_CHANGED;
1668 #ifdef MEMORY_USAGE_STATS
1679 compute_buffer_text_usage (struct buffer *b, struct overhead_stats *ovstats)
1681 int was_requested = b->text->z - 1;
1682 size_t gap = b->text->gap_size + b->text->end_gap_size;
1683 size_t malloc_use = malloced_storage_size (b->text->beg, was_requested + gap, 0);
1685 ovstats->gap_overhead += gap;
1686 ovstats->was_requested += was_requested;
1687 ovstats->malloc_overhead += malloc_use - (was_requested + gap);
1692 compute_buffer_usage (struct buffer *b, struct buffer_stats *stats,
1693 struct overhead_stats *ovstats)
1696 stats->other += malloced_storage_size (b, sizeof (*b), ovstats);
1697 stats->text += compute_buffer_text_usage (b, ovstats);
1698 stats->markers += compute_buffer_marker_usage (b, ovstats);
1699 stats->extents += compute_buffer_extent_usage (b, ovstats);
1702 DEFUN ("buffer-memory-usage", Fbuffer_memory_usage, 1, 1, 0, /*
1703 Return stats about the memory usage of buffer BUFFER.
1704 The values returned are in the form of an alist of usage types and byte
1705 counts. The byte counts attempt to encompass all the memory used
1706 by the buffer (separate from the memory logically associated with a
1707 buffer or frame), including internal structures and any malloc()
1708 overhead associated with them. In practice, the byte counts are
1709 underestimated because certain memory usage is very hard to determine
1710 \(e.g. the amount of memory used inside the Xt library or inside the
1711 X server) and because there is other stuff that might logically
1712 be associated with a window, buffer, or frame (e.g. window configurations,
1713 glyphs) but should not obviously be included in the usage counts.
1715 Multiple slices of the total memory usage may be returned, separated
1716 by a nil. Each slice represents a particular view of the memory, a
1717 particular way of partitioning it into groups. Within a slice, there
1718 is no overlap between the groups of memory, and each slice collectively
1719 represents all the memory concerned.
1723 struct buffer_stats stats;
1724 struct overhead_stats ovstats;
1725 Lisp_Object val = Qnil;
1727 CHECK_BUFFER (buffer); /* dead buffers should be allowed, no? */
1729 compute_buffer_usage (XBUFFER (buffer), &stats, &ovstats);
1731 val = acons (Qtext, make_int (stats.text), val);
1732 val = acons (Qmarkers, make_int (stats.markers), val);
1733 val = acons (Qextents, make_int (stats.extents), val);
1734 val = acons (Qother, make_int (stats.other), val);
1735 val = Fcons (Qnil, val);
1736 val = acons (Qactually_requested, make_int (ovstats.was_requested), val);
1737 val = acons (Qmalloc_overhead, make_int (ovstats.malloc_overhead), val);
1738 val = acons (Qgap_overhead, make_int (ovstats.gap_overhead), val);
1739 val = acons (Qdynarr_overhead, make_int (ovstats.dynarr_overhead), val);
1741 return Fnreverse (val);
1744 #endif /* MEMORY_USAGE_STATS */
1747 /************************************************************************/
1748 /* Implement TO_EXTERNAL_FORMAT, TO_INTERNAL_FORMAT */
1749 /************************************************************************/
1751 /* This implementation should probably be elsewhere, but it can't be
1752 in file-coding.c since that file is only available if FILE_CODING
1756 coding_system_is_binary (Lisp_Object coding_system)
1758 Lisp_Coding_System *cs = XCODING_SYSTEM (coding_system);
1760 (CODING_SYSTEM_TYPE (cs) == CODESYS_NO_CONVERSION &&
1761 CODING_SYSTEM_EOL_TYPE (cs) == EOL_LF &&
1762 EQ (CODING_SYSTEM_POST_READ_CONVERSION (cs), Qnil) &&
1763 EQ (CODING_SYSTEM_PRE_WRITE_CONVERSION (cs), Qnil));
1766 #define coding_system_is_binary(coding_system) 1
1771 Dynarr_declare (Bufbyte_dynarr *);
1772 } Bufbyte_dynarr_dynarr;
1776 Dynarr_declare (Extbyte_dynarr *);
1777 } Extbyte_dynarr_dynarr;
1779 static Extbyte_dynarr_dynarr *conversion_out_dynarr_list;
1780 static Bufbyte_dynarr_dynarr *conversion_in_dynarr_list;
1782 static int dfc_convert_to_external_format_in_use;
1783 static int dfc_convert_to_internal_format_in_use;
1786 dfc_convert_to_external_format_reset_in_use (Lisp_Object value)
1788 dfc_convert_to_external_format_in_use = XINT (value);
1793 dfc_convert_to_internal_format_reset_in_use (Lisp_Object value)
1795 dfc_convert_to_internal_format_in_use = XINT (value);
1800 dfc_convert_to_external_format (dfc_conversion_type source_type,
1801 dfc_conversion_data *source,
1803 Lisp_Object coding_system,
1805 dfc_conversion_type sink_type,
1806 dfc_conversion_data *sink)
1808 int count = specpdl_depth ();
1809 Extbyte_dynarr *conversion_out_dynarr;
1811 type_checking_assert
1812 (((source_type == DFC_TYPE_DATA) ||
1813 (source_type == DFC_TYPE_LISP_LSTREAM && LSTREAMP (source->lisp_object)) ||
1814 (source_type == DFC_TYPE_LISP_STRING && STRINGP (source->lisp_object)))
1816 ((sink_type == DFC_TYPE_DATA) ||
1817 (sink_type == DFC_TYPE_LISP_LSTREAM && LSTREAMP (source->lisp_object))));
1819 record_unwind_protect (dfc_convert_to_external_format_reset_in_use,
1820 make_int (dfc_convert_to_external_format_in_use));
1821 if (Dynarr_length (conversion_out_dynarr_list) <=
1822 dfc_convert_to_external_format_in_use)
1823 Dynarr_add (conversion_out_dynarr_list, Dynarr_new (Extbyte));
1824 conversion_out_dynarr = Dynarr_at (conversion_out_dynarr_list,
1825 dfc_convert_to_external_format_in_use);
1826 dfc_convert_to_external_format_in_use++;
1827 Dynarr_reset (conversion_out_dynarr);
1830 coding_system = Fget_coding_system (coding_system);
1833 /* Here we optimize in the case where the coding system does no
1834 conversion. However, we don't want to optimize in case the source
1835 or sink is an lstream, since writing to an lstream can cause a
1836 garbage collection, and this could be problematic if the source
1837 is a lisp string. */
1838 if (source_type != DFC_TYPE_LISP_LSTREAM &&
1839 sink_type != DFC_TYPE_LISP_LSTREAM &&
1840 coding_system_is_binary (coding_system))
1845 if (source_type == DFC_TYPE_LISP_STRING)
1847 ptr = XSTRING_DATA (source->lisp_object);
1848 len = XSTRING_LENGTH (source->lisp_object);
1852 ptr = (Bufbyte *) source->data.ptr;
1853 len = source->data.len;
1859 for (end = ptr + len; ptr < end;)
1863 (*ptr < 0xc0) ? *ptr :
1864 ((*ptr & 0x1f) << 6) | (*(ptr+1) & 0x3f);
1867 (BYTE_ASCII_P (*ptr)) ? *ptr :
1868 (*ptr == LEADING_BYTE_CONTROL_1) ? (*(ptr+1) - 0x20) :
1869 (*ptr == LEADING_BYTE_LATIN_ISO8859_1) ? (*(ptr+1)) :
1873 Dynarr_add (conversion_out_dynarr, (Extbyte) c);
1876 bufpos_checking_assert (ptr == end);
1879 Dynarr_add_many (conversion_out_dynarr, ptr, len);
1885 Lisp_Object streams_to_delete[3];
1886 int delete_count = 0;
1887 Lisp_Object instream, outstream;
1888 Lstream *reader, *writer;
1889 struct gcpro gcpro1, gcpro2;
1891 if (source_type == DFC_TYPE_LISP_LSTREAM)
1892 instream = source->lisp_object;
1893 else if (source_type == DFC_TYPE_DATA)
1894 streams_to_delete[delete_count++] = instream =
1895 make_fixed_buffer_input_stream (source->data.ptr, source->data.len);
1898 type_checking_assert (source_type == DFC_TYPE_LISP_STRING);
1899 streams_to_delete[delete_count++] = instream =
1900 make_lisp_string_input_stream (source->lisp_object, 0, -1);
1903 if (sink_type == DFC_TYPE_LISP_LSTREAM)
1904 outstream = sink->lisp_object;
1907 type_checking_assert (sink_type == DFC_TYPE_DATA);
1908 streams_to_delete[delete_count++] = outstream =
1909 make_dynarr_output_stream
1910 ((unsigned_char_dynarr *) conversion_out_dynarr);
1914 streams_to_delete[delete_count++] = outstream =
1915 make_encoding_output_stream (XLSTREAM (outstream), coding_system);
1918 reader = XLSTREAM (instream);
1919 writer = XLSTREAM (outstream);
1920 /* decoding_stream will gc-protect outstream */
1921 GCPRO2 (instream, outstream);
1925 ssize_t size_in_bytes;
1926 char tempbuf[1024]; /* some random amount */
1928 size_in_bytes = Lstream_read (reader, tempbuf, sizeof (tempbuf));
1930 if (size_in_bytes == 0)
1932 else if (size_in_bytes < 0)
1933 error ("Error converting to external format");
1935 size_in_bytes = Lstream_write (writer, tempbuf, size_in_bytes);
1937 if (size_in_bytes <= 0)
1938 error ("Error converting to external format");
1941 /* Closing writer will close any stream at the other end of writer. */
1942 Lstream_close (writer);
1943 Lstream_close (reader);
1946 /* The idea is that this function will create no garbage. */
1947 while (delete_count)
1948 Lstream_delete (XLSTREAM (streams_to_delete [--delete_count]));
1951 unbind_to (count, Qnil);
1953 if (sink_type != DFC_TYPE_LISP_LSTREAM)
1955 sink->data.len = Dynarr_length (conversion_out_dynarr);
1956 Dynarr_add (conversion_out_dynarr, '\0'); /* NUL-terminate! */
1957 sink->data.ptr = Dynarr_atp (conversion_out_dynarr, 0);
1962 dfc_convert_to_internal_format (dfc_conversion_type source_type,
1963 dfc_conversion_data *source,
1965 Lisp_Object coding_system,
1967 dfc_conversion_type sink_type,
1968 dfc_conversion_data *sink)
1970 int count = specpdl_depth ();
1971 Bufbyte_dynarr *conversion_in_dynarr;
1973 type_checking_assert
1974 ((source_type == DFC_TYPE_DATA ||
1975 source_type == DFC_TYPE_LISP_LSTREAM)
1977 (sink_type == DFC_TYPE_DATA ||
1978 sink_type == DFC_TYPE_LISP_LSTREAM));
1980 record_unwind_protect (dfc_convert_to_internal_format_reset_in_use,
1981 make_int (dfc_convert_to_internal_format_in_use));
1982 if (Dynarr_length (conversion_in_dynarr_list) <=
1983 dfc_convert_to_internal_format_in_use)
1984 Dynarr_add (conversion_in_dynarr_list, Dynarr_new (Bufbyte));
1985 conversion_in_dynarr = Dynarr_at (conversion_in_dynarr_list,
1986 dfc_convert_to_internal_format_in_use);
1987 dfc_convert_to_internal_format_in_use++;
1988 Dynarr_reset (conversion_in_dynarr);
1991 coding_system = Fget_coding_system (coding_system);
1994 if (source_type != DFC_TYPE_LISP_LSTREAM &&
1995 sink_type != DFC_TYPE_LISP_LSTREAM &&
1996 coding_system_is_binary (coding_system))
1999 const Bufbyte *ptr = (const Bufbyte *) source->data.ptr;
2000 Bytecount len = source->data.len;
2001 const Bufbyte *end = ptr + len;
2003 for (; ptr < end; ptr++)
2008 if (BYTE_ASCII_P (c))
2009 Dynarr_add (conversion_in_dynarr, c);
2012 Dynarr_add (conversion_in_dynarr, (c >> 6) | 0xC0);
2013 Dynarr_add (conversion_in_dynarr, (c & 0x3F) | 0x80);
2016 if (BYTE_ASCII_P (c))
2017 Dynarr_add (conversion_in_dynarr, c);
2018 else if (BYTE_C1_P (c))
2020 Dynarr_add (conversion_in_dynarr, LEADING_BYTE_CONTROL_1);
2021 Dynarr_add (conversion_in_dynarr, c + 0x20);
2025 Dynarr_add (conversion_in_dynarr, LEADING_BYTE_LATIN_ISO8859_1);
2026 Dynarr_add (conversion_in_dynarr, c);
2031 Dynarr_add_many (conversion_in_dynarr, source->data.ptr, source->data.len);
2036 Lisp_Object streams_to_delete[3];
2037 int delete_count = 0;
2038 Lisp_Object instream, outstream;
2039 Lstream *reader, *writer;
2040 struct gcpro gcpro1, gcpro2;
2042 if (source_type == DFC_TYPE_LISP_LSTREAM)
2043 instream = source->lisp_object;
2046 type_checking_assert (source_type == DFC_TYPE_DATA);
2047 streams_to_delete[delete_count++] = instream =
2048 make_fixed_buffer_input_stream (source->data.ptr, source->data.len);
2051 if (sink_type == DFC_TYPE_LISP_LSTREAM)
2052 outstream = sink->lisp_object;
2055 type_checking_assert (sink_type == DFC_TYPE_DATA);
2056 streams_to_delete[delete_count++] = outstream =
2057 make_dynarr_output_stream
2058 ((unsigned_char_dynarr *) conversion_in_dynarr);
2062 streams_to_delete[delete_count++] = outstream =
2063 make_decoding_output_stream (XLSTREAM (outstream), coding_system);
2066 reader = XLSTREAM (instream);
2067 writer = XLSTREAM (outstream);
2068 /* outstream will gc-protect its sink stream, if necessary */
2069 GCPRO2 (instream, outstream);
2073 ssize_t size_in_bytes;
2074 char tempbuf[1024]; /* some random amount */
2076 size_in_bytes = Lstream_read (reader, tempbuf, sizeof (tempbuf));
2078 if (size_in_bytes == 0)
2080 else if (size_in_bytes < 0)
2081 error ("Error converting to internal format");
2083 size_in_bytes = Lstream_write (writer, tempbuf, size_in_bytes);
2085 if (size_in_bytes <= 0)
2086 error ("Error converting to internal format");
2089 /* Closing writer will close any stream at the other end of writer. */
2090 Lstream_close (writer);
2091 Lstream_close (reader);
2094 /* The idea is that this function will create no garbage. */
2095 while (delete_count)
2096 Lstream_delete (XLSTREAM (streams_to_delete [--delete_count]));
2099 unbind_to (count, Qnil);
2101 if (sink_type != DFC_TYPE_LISP_LSTREAM)
2103 sink->data.len = Dynarr_length (conversion_in_dynarr);
2104 Dynarr_add (conversion_in_dynarr, '\0'); /* NUL-terminate! */
2105 sink->data.ptr = Dynarr_atp (conversion_in_dynarr, 0);
2111 syms_of_buffer (void)
2113 INIT_LRECORD_IMPLEMENTATION (buffer);
2115 defsymbol (&Qbuffer_live_p, "buffer-live-p");
2116 defsymbol (&Qbuffer_or_string_p, "buffer-or-string-p");
2117 defsymbol (&Qmode_class, "mode-class");
2118 defsymbol (&Qrename_auto_save_file, "rename-auto-save-file");
2119 defsymbol (&Qkill_buffer_hook, "kill-buffer-hook");
2120 defsymbol (&Qpermanent_local, "permanent-local");
2122 defsymbol (&Qfirst_change_hook, "first-change-hook");
2123 defsymbol (&Qbefore_change_functions, "before-change-functions");
2124 defsymbol (&Qafter_change_functions, "after-change-functions");
2126 /* #### Obsolete, for compatibility */
2127 defsymbol (&Qbefore_change_function, "before-change-function");
2128 defsymbol (&Qafter_change_function, "after-change-function");
2130 defsymbol (&Qdefault_directory, "default-directory");
2132 defsymbol (&Qget_file_buffer, "get-file-buffer");
2133 defsymbol (&Qchange_major_mode_hook, "change-major-mode-hook");
2135 defsymbol (&Qfundamental_mode, "fundamental-mode");
2137 defsymbol (&Qfind_file_compare_truenames, "find-file-compare-truenames");
2139 defsymbol (&Qswitch_to_buffer, "switch-to-buffer");
2142 DEFSUBR (Fbuffer_live_p);
2143 DEFSUBR (Fbuffer_list);
2144 DEFSUBR (Fdecode_buffer);
2145 DEFSUBR (Fget_buffer);
2146 DEFSUBR (Fget_file_buffer);
2147 DEFSUBR (Fget_buffer_create);
2148 DEFSUBR (Fmake_indirect_buffer);
2150 DEFSUBR (Fgenerate_new_buffer_name);
2151 DEFSUBR (Fbuffer_name);
2152 DEFSUBR (Fbuffer_file_name);
2153 DEFSUBR (Fbuffer_base_buffer);
2154 DEFSUBR (Fbuffer_indirect_children);
2155 DEFSUBR (Fbuffer_local_variables);
2156 DEFSUBR (Fbuffer_modified_p);
2157 DEFSUBR (Fset_buffer_modified_p);
2158 DEFSUBR (Fbuffer_modified_tick);
2159 DEFSUBR (Frename_buffer);
2160 DEFSUBR (Fother_buffer);
2161 DEFSUBR (Fbuffer_disable_undo);
2162 DEFSUBR (Fbuffer_enable_undo);
2163 DEFSUBR (Fkill_buffer);
2164 DEFSUBR (Ferase_buffer);
2165 DEFSUBR (Frecord_buffer);
2166 DEFSUBR (Fset_buffer_major_mode);
2167 DEFSUBR (Fcurrent_buffer);
2168 DEFSUBR (Fset_buffer);
2169 DEFSUBR (Fbarf_if_buffer_read_only);
2170 DEFSUBR (Fbury_buffer);
2171 DEFSUBR (Fkill_all_local_variables);
2172 #ifdef MEMORY_USAGE_STATS
2173 DEFSUBR (Fbuffer_memory_usage);
2176 DEFERROR (Qprotected_field, "Attempt to modify a protected field",
2181 reinit_vars_of_buffer (void)
2183 conversion_in_dynarr_list = Dynarr_new2 (Bufbyte_dynarr_dynarr,
2185 conversion_out_dynarr_list = Dynarr_new2 (Extbyte_dynarr_dynarr,
2188 staticpro_nodump (&Vbuffer_alist);
2189 Vbuffer_alist = Qnil;
2193 /* initialize the buffer routines */
2195 vars_of_buffer (void)
2197 /* This function can GC */
2198 reinit_vars_of_buffer ();
2200 staticpro (&QSFundamental);
2201 staticpro (&QSscratch);
2203 QSFundamental = build_string ("Fundamental");
2204 QSscratch = build_string (DEFER_GETTEXT ("*scratch*"));
2206 DEFVAR_LISP ("change-major-mode-hook", &Vchange_major_mode_hook /*
2207 List of hooks to be run before killing local variables in a buffer.
2208 This should be used by any mode that temporarily alters the contents or
2209 the read-only state of the buffer. See also `kill-all-local-variables'.
2211 Vchange_major_mode_hook = Qnil;
2213 DEFVAR_BOOL ("find-file-compare-truenames", &find_file_compare_truenames /*
2214 If this is true, then the `find-file' command will check the truenames
2215 of all visited files when deciding whether a given file is already in
2216 a buffer, instead of just `buffer-file-name'. This means that if you
2217 attempt to visit another file which is a symbolic link to a file which
2218 is already in a buffer, the existing buffer will be found instead of a
2219 newly-created one. This works if any component of the pathname
2220 (including a non-terminal component) is a symbolic link as well, but
2221 doesn't work with hard links (nothing does).
2223 See also the variable `find-file-use-truenames'.
2225 #if defined(CYGWIN) || defined(WIN32_NATIVE)
2226 find_file_compare_truenames = 1;
2228 find_file_compare_truenames = 0;
2231 DEFVAR_BOOL ("find-file-use-truenames", &find_file_use_truenames /*
2232 If this is true, then a buffer's visited file-name will always be
2233 chased back to the real file; it will never be a symbolic link, and there
2234 will never be a symbolic link anywhere in its directory path.
2235 That is, the buffer-file-name and buffer-file-truename will be equal.
2236 This doesn't work with hard links.
2238 See also the variable `find-file-compare-truenames'.
2240 find_file_use_truenames = 0;
2242 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions /*
2243 List of functions to call before each text change.
2244 Two arguments are passed to each function: the positions of
2245 the beginning and end of the range of old text to be changed.
2246 \(For an insertion, the beginning and end are at the same place.)
2247 No information is given about the length of the text after the change.
2249 Buffer changes made while executing the `before-change-functions'
2250 don't call any before-change or after-change functions.
2252 Vbefore_change_functions = Qnil;
2254 /* FSF Emacs has the following additional doc at the end of
2255 before-change-functions and after-change-functions:
2257 That's because these variables are temporarily set to nil.
2258 As a result, a hook function cannot straightforwardly alter the value of
2259 these variables. See the Emacs Lisp manual for a way of
2260 accomplishing an equivalent result by using other variables.
2262 But this doesn't apply under XEmacs because things are
2265 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions /*
2266 List of functions to call after each text change.
2267 Three arguments are passed to each function: the positions of
2268 the beginning and end of the range of changed text,
2269 and the length of the pre-change text replaced by that range.
2270 \(For an insertion, the pre-change length is zero;
2271 for a deletion, that length is the number of characters deleted,
2272 and the post-change beginning and end are at the same place.)
2274 Buffer changes made while executing `after-change-functions'
2275 don't call any before-change or after-change functions.
2277 Vafter_change_functions = Qnil;
2279 DEFVAR_LISP ("before-change-function", &Vbefore_change_function /*
2281 */ ); /* obsoleteness will be documented */
2282 Vbefore_change_function = Qnil;
2284 DEFVAR_LISP ("after-change-function", &Vafter_change_function /*
2286 */ ); /* obsoleteness will be documented */
2287 Vafter_change_function = Qnil;
2289 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook /*
2290 A list of functions to call before changing a buffer which is unmodified.
2291 The functions are run using the `run-hooks' function.
2293 Vfirst_change_hook = Qnil;
2296 xxDEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode /*
2297 *Non-nil means deactivate the mark when the buffer contents change.
2299 Vtransient_mark_mode = Qnil;
2300 #endif /* FSFmacs */
2302 DEFVAR_INT ("undo-threshold", &undo_threshold /*
2303 Keep no more undo information once it exceeds this size.
2304 This threshold is applied when garbage collection happens.
2305 The size is counted as the number of bytes occupied,
2306 which includes both saved text and other data.
2308 undo_threshold = 20000;
2310 DEFVAR_INT ("undo-high-threshold", &undo_high_threshold /*
2311 Don't keep more than this much size of undo information.
2312 A command which pushes past this size is itself forgotten.
2313 This threshold is applied when garbage collection happens.
2314 The size is counted as the number of bytes occupied,
2315 which includes both saved text and other data.
2317 undo_high_threshold = 30000;
2319 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only /*
2320 *Non-nil means disregard read-only status of buffers or characters.
2321 If the value is t, disregard `buffer-read-only' and all `read-only'
2322 text properties. If the value is a list, disregard `buffer-read-only'
2323 and disregard a `read-only' extent property or text property if the
2324 property value is a member of the list.
2326 Vinhibit_read_only = Qnil;
2328 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions /*
2329 List of functions called with no args to query before killing a buffer.
2331 Vkill_buffer_query_functions = Qnil;
2333 DEFVAR_BOOL ("delete-auto-save-files", &delete_auto_save_files /*
2334 *Non-nil means delete auto-save file when a buffer is saved or killed.
2336 delete_auto_save_files = 1;
2339 /* The docstrings for DEFVAR_* are recorded externally by make-docfile. */
2341 /* Renamed from DEFVAR_PER_BUFFER because FSFmacs D_P_B takes
2342 a bogus extra arg, which confuses an otherwise identical make-docfile.c */
2343 #define DEFVAR_BUFFER_LOCAL_1(lname, field_name, forward_type, magicfun) do { \
2344 static const struct symbol_value_forward I_hate_C = \
2345 { /* struct symbol_value_forward */ \
2346 { /* struct symbol_value_magic */ \
2347 { /* struct lcrecord_header */ \
2348 { /* struct lrecord_header */ \
2349 lrecord_type_symbol_value_forward, /* lrecord_type_index */ \
2351 1, /* c_readonly bit */ \
2352 1 /* lisp_readonly bit */ \
2358 &(buffer_local_flags.field_name), \
2365 int offset = ((char *)symbol_value_forward_forward (&I_hate_C) - \
2366 (char *)&buffer_local_flags); \
2367 defvar_magic (lname, &I_hate_C); \
2369 *((Lisp_Object *)(offset + (char *)XBUFFER (Vbuffer_local_symbols))) \
2374 #define DEFVAR_BUFFER_LOCAL_MAGIC(lname, field_name, magicfun) \
2375 DEFVAR_BUFFER_LOCAL_1 (lname, field_name, \
2376 SYMVAL_CURRENT_BUFFER_FORWARD, magicfun)
2377 #define DEFVAR_BUFFER_LOCAL(lname, field_name) \
2378 DEFVAR_BUFFER_LOCAL_MAGIC (lname, field_name, 0)
2379 #define DEFVAR_CONST_BUFFER_LOCAL_MAGIC(lname, field_name, magicfun) \
2380 DEFVAR_BUFFER_LOCAL_1 (lname, field_name, \
2381 SYMVAL_CONST_CURRENT_BUFFER_FORWARD, magicfun)
2382 #define DEFVAR_CONST_BUFFER_LOCAL(lname, field_name) \
2383 DEFVAR_CONST_BUFFER_LOCAL_MAGIC (lname, field_name, 0)
2385 #define DEFVAR_BUFFER_DEFAULTS_MAGIC(lname, field_name, magicfun) \
2386 DEFVAR_SYMVAL_FWD (lname, &(buffer_local_flags.field_name), \
2387 SYMVAL_DEFAULT_BUFFER_FORWARD, magicfun)
2388 #define DEFVAR_BUFFER_DEFAULTS(lname, field_name) \
2389 DEFVAR_BUFFER_DEFAULTS_MAGIC (lname, field_name, 0)
2392 nuke_all_buffer_slots (struct buffer *b, Lisp_Object zap)
2396 b->extent_info = Qnil;
2397 b->indirect_children = Qnil;
2398 b->own_text.line_number_cache = Qnil;
2400 #define MARKED_SLOT(x) b->x = zap
2401 #include "bufslots.h"
2406 common_init_complex_vars_of_buffer (void)
2408 /* Make sure all markable slots in buffer_defaults
2409 are initialized reasonably, so mark_buffer won't choke. */
2410 struct buffer *defs = alloc_lcrecord_type (struct buffer, &lrecord_buffer);
2411 struct buffer *syms = alloc_lcrecord_type (struct buffer, &lrecord_buffer);
2413 staticpro_nodump (&Vbuffer_defaults);
2414 staticpro_nodump (&Vbuffer_local_symbols);
2415 XSETBUFFER (Vbuffer_defaults, defs);
2416 XSETBUFFER (Vbuffer_local_symbols, syms);
2418 nuke_all_buffer_slots (syms, Qnil);
2419 nuke_all_buffer_slots (defs, Qnil);
2420 defs->text = &defs->own_text;
2421 syms->text = &syms->own_text;
2423 /* Set up the non-nil default values of various buffer slots.
2424 Must do these before making the first buffer. */
2425 defs->major_mode = Qfundamental_mode;
2426 defs->mode_name = QSFundamental;
2427 defs->abbrev_table = Qnil; /* real default setup by Lisp code */
2429 defs->case_table = Vstandard_case_table;
2431 defs->category_table = Vstandard_category_table;
2433 defs->syntax_table = Vstandard_syntax_table;
2434 defs->mirror_syntax_table =
2435 XCHAR_TABLE (Vstandard_syntax_table)->mirror_table;
2436 defs->modeline_format = build_string ("%-"); /* reset in loaddefs.el */
2437 defs->case_fold_search = Qt;
2438 defs->selective_display_ellipses = Qt;
2439 defs->tab_width = make_int (8);
2440 defs->ctl_arrow = Qt;
2441 defs->fill_column = make_int (70);
2442 defs->left_margin = Qzero;
2443 defs->saved_size = Qzero; /* lisp code wants int-or-nil */
2445 defs->auto_save_modified = 0;
2446 defs->auto_save_failure_time = -1;
2447 defs->invisibility_spec = Qt;
2449 defs->indirect_children = Qnil;
2450 syms->indirect_children = Qnil;
2453 /* 0 means var is always local. Default used only at creation.
2454 * -1 means var is always local. Default used only at reset and
2456 * -2 means there's no lisp variable corresponding to this slot
2457 * and the default is only used at creation.
2458 * -3 means no Lisp variable. Default used only at reset and creation.
2459 * >0 is mask. Var is local if ((buffer->local_var_flags & mask) != 0)
2460 * Otherwise default is used.
2462 Lisp_Object always_local_no_default = make_int (0);
2463 Lisp_Object always_local_resettable = make_int (-1);
2464 Lisp_Object resettable = make_int (-3);
2466 /* Assign the local-flags to the slots that have default values.
2467 The local flag is a bit that is used in the buffer
2468 to say that it has its own local value for the slot.
2469 The local flag bits are in the local_var_flags slot of the
2472 nuke_all_buffer_slots (&buffer_local_flags, make_int (-2));
2473 buffer_local_flags.filename = always_local_no_default;
2474 buffer_local_flags.directory = always_local_no_default;
2475 buffer_local_flags.backed_up = always_local_no_default;
2476 buffer_local_flags.saved_size = always_local_no_default;
2477 buffer_local_flags.auto_save_file_name = always_local_no_default;
2478 buffer_local_flags.read_only = always_local_no_default;
2480 buffer_local_flags.major_mode = always_local_resettable;
2481 buffer_local_flags.mode_name = always_local_resettable;
2482 buffer_local_flags.undo_list = always_local_no_default;
2484 buffer_local_flags.mark_active = always_local_resettable;
2486 buffer_local_flags.point_before_scroll = always_local_resettable;
2487 buffer_local_flags.file_truename = always_local_no_default;
2488 buffer_local_flags.invisibility_spec = always_local_resettable;
2489 buffer_local_flags.file_format = always_local_resettable;
2490 buffer_local_flags.generated_modeline_string = always_local_no_default;
2492 buffer_local_flags.keymap = resettable;
2493 buffer_local_flags.case_table = resettable;
2494 buffer_local_flags.syntax_table = resettable;
2496 buffer_local_flags.category_table = resettable;
2499 buffer_local_flags.modeline_format = make_int (1<<0);
2500 buffer_local_flags.abbrev_mode = make_int (1<<1);
2501 buffer_local_flags.overwrite_mode = make_int (1<<2);
2502 buffer_local_flags.case_fold_search = make_int (1<<3);
2503 buffer_local_flags.auto_fill_function = make_int (1<<4);
2504 buffer_local_flags.selective_display = make_int (1<<5);
2505 buffer_local_flags.selective_display_ellipses = make_int (1<<6);
2506 buffer_local_flags.tab_width = make_int (1<<7);
2507 buffer_local_flags.truncate_lines = make_int (1<<8);
2508 buffer_local_flags.ctl_arrow = make_int (1<<9);
2509 buffer_local_flags.fill_column = make_int (1<<10);
2510 buffer_local_flags.left_margin = make_int (1<<11);
2511 buffer_local_flags.abbrev_table = make_int (1<<12);
2512 #ifdef REGION_CACHE_NEEDS_WORK
2513 buffer_local_flags.cache_long_line_scans = make_int (1<<13);
2516 buffer_local_flags.buffer_file_coding_system = make_int (1<<14);
2519 /* #### Warning: 1<<31 is the largest number currently allowable
2520 due to the XINT() handling of this value. With some
2521 rearrangement you can get 3 more bits. */
2525 #define BUFFER_SLOTS_SIZE (offsetof (struct buffer, BUFFER_SLOTS_LAST_NAME) - offsetof (struct buffer, BUFFER_SLOTS_FIRST_NAME) + sizeof (Lisp_Object))
2526 #define BUFFER_SLOTS_COUNT (BUFFER_SLOTS_SIZE / sizeof (Lisp_Object))
2529 reinit_complex_vars_of_buffer (void)
2531 struct buffer *defs, *syms;
2533 common_init_complex_vars_of_buffer ();
2535 defs = XBUFFER (Vbuffer_defaults);
2536 syms = XBUFFER (Vbuffer_local_symbols);
2537 memcpy (&defs->BUFFER_SLOTS_FIRST_NAME,
2538 buffer_defaults_saved_slots,
2540 memcpy (&syms->BUFFER_SLOTS_FIRST_NAME,
2541 buffer_local_symbols_saved_slots,
2546 static const struct lrecord_description buffer_slots_description_1[] = {
2547 { XD_LISP_OBJECT_ARRAY, 0, BUFFER_SLOTS_COUNT },
2551 static const struct struct_description buffer_slots_description = {
2553 buffer_slots_description_1
2557 complex_vars_of_buffer (void)
2559 struct buffer *defs, *syms;
2561 common_init_complex_vars_of_buffer ();
2563 defs = XBUFFER (Vbuffer_defaults);
2564 syms = XBUFFER (Vbuffer_local_symbols);
2565 buffer_defaults_saved_slots = &defs->BUFFER_SLOTS_FIRST_NAME;
2566 buffer_local_symbols_saved_slots = &syms->BUFFER_SLOTS_FIRST_NAME;
2567 dumpstruct (&buffer_defaults_saved_slots, &buffer_slots_description);
2568 dumpstruct (&buffer_local_symbols_saved_slots, &buffer_slots_description);
2570 DEFVAR_BUFFER_DEFAULTS ("default-modeline-format", modeline_format /*
2571 Default value of `modeline-format' for buffers that don't override it.
2572 This is the same as (default-value 'modeline-format).
2575 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode", abbrev_mode /*
2576 Default value of `abbrev-mode' for buffers that do not override it.
2577 This is the same as (default-value 'abbrev-mode).
2580 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow", ctl_arrow /*
2581 Default value of `ctl-arrow' for buffers that do not override it.
2582 This is the same as (default-value 'ctl-arrow).
2585 #if 0 /* #### make this a specifier! */
2586 DEFVAR_BUFFER_DEFAULTS ("default-display-direction", display_direction /*
2587 Default display-direction for buffers that do not override it.
2588 This is the same as (default-value 'display-direction).
2589 Note: This is not yet implemented.
2593 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines", truncate_lines /*
2594 Default value of `truncate-lines' for buffers that do not override it.
2595 This is the same as (default-value 'truncate-lines).
2598 DEFVAR_BUFFER_DEFAULTS ("default-fill-column", fill_column /*
2599 Default value of `fill-column' for buffers that do not override it.
2600 This is the same as (default-value 'fill-column).
2603 DEFVAR_BUFFER_DEFAULTS ("default-left-margin", left_margin /*
2604 Default value of `left-margin' for buffers that do not override it.
2605 This is the same as (default-value 'left-margin).
2608 DEFVAR_BUFFER_DEFAULTS ("default-tab-width", tab_width /*
2609 Default value of `tab-width' for buffers that do not override it.
2610 This is the same as (default-value 'tab-width).
2613 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search", case_fold_search /*
2614 Default value of `case-fold-search' for buffers that don't override it.
2615 This is the same as (default-value 'case-fold-search).
2618 DEFVAR_BUFFER_LOCAL ("modeline-format", modeline_format /*
2619 Template for displaying modeline for current buffer.
2620 Each buffer has its own value of this variable.
2621 Value may be a string, symbol, glyph, generic specifier, list or cons cell.
2622 For a symbol, its value is processed (but it is ignored if t or nil).
2623 A string appearing directly as the value of a symbol is processed verbatim
2624 in that the %-constructs below are not recognized.
2625 For a glyph, it is inserted as is.
2626 For a generic specifier (i.e. a specifier of type `generic'), its instance
2627 is computed in the current window using the equivalent of `specifier-instance'
2628 and the value is processed.
2629 For a list whose car is a symbol, the symbol's value is taken,
2630 and if that is non-nil, the cadr of the list is processed recursively.
2631 Otherwise, the caddr of the list (if there is one) is processed.
2632 For a list whose car is a string or list, each element is processed
2633 recursively and the results are effectively concatenated.
2634 For a list whose car is an integer, the cdr of the list is processed
2635 and padded (if the number is positive) or truncated (if negative)
2636 to the width specified by that number.
2637 For a list whose car is an extent, the cdr of the list is processed
2638 normally but the results are displayed using the face of the
2639 extent, and mouse clicks over this section are processed using the
2640 keymap of the extent. (In addition, if the extent has a help-echo
2641 property, that string will be echoed when the mouse moves over this
2642 section.) If extents are nested, all keymaps are properly consulted
2643 when processing mouse clicks, but multiple faces are not correctly
2644 merged (only the first face is used), and lists of faces are not
2645 correctly handled. See `generated-modeline-string' for more information.
2646 A string is printed verbatim in the modeline except for %-constructs:
2647 (%-constructs are processed when the string is the entire modeline-format
2648 or when it is found in a cons-cell or a list)
2649 %b -- print buffer name. %c -- print the current column number.
2650 %f -- print visited file name.
2651 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
2652 % means buffer is read-only and * means it is modified.
2653 For a modified read-only buffer, %* gives % and %+ gives *.
2654 %s -- print process status. %l -- print the current line number.
2655 %S -- print name of selected frame (only meaningful under X Windows).
2656 %p -- print percent of buffer above top of window, or Top, Bot or All.
2657 %P -- print percent of buffer above bottom of window, perhaps plus Top,
2658 or print Bottom or All.
2659 %n -- print Narrow if appropriate.
2660 %C -- under XEmacs/mule, print the mnemonic for `buffer-file-coding-system'.
2661 %[ -- print one [ for each recursive editing level. %] similar.
2662 %% -- print %. %- -- print infinitely many dashes.
2663 Decimal digits after the % specify field width to which to pad.
2666 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode /*
2667 *Major mode for new buffers. Defaults to `fundamental-mode'.
2668 nil here means use current buffer's major mode.
2671 DEFVAR_BUFFER_DEFAULTS ("fundamental-mode-abbrev-table", abbrev_table /*
2672 The abbrev table of mode-specific abbrevs for Fundamental Mode.
2675 DEFVAR_BUFFER_LOCAL ("major-mode", major_mode /*
2676 Symbol for current buffer's major mode.
2679 DEFVAR_BUFFER_LOCAL ("mode-name", mode_name /*
2680 Pretty name of current buffer's major mode (a string).
2683 DEFVAR_BUFFER_LOCAL ("abbrev-mode", abbrev_mode /*
2684 Non-nil turns on automatic expansion of abbrevs as they are inserted.
2685 Automatically becomes buffer-local when set in any fashion.
2688 DEFVAR_BUFFER_LOCAL ("case-fold-search", case_fold_search /*
2689 *Non-nil if searches should ignore case.
2690 Automatically becomes buffer-local when set in any fashion.
2692 BUG: Under XEmacs/Mule, translations to or from non-ASCII characters
2693 (this includes chars in the range 128 - 255) are ignored by
2694 the string/buffer-searching routines. Thus, `case-fold-search'
2695 will not correctly conflate a-umlaut and A-umlaut even if the
2696 case tables call for this.
2699 DEFVAR_BUFFER_LOCAL ("fill-column", fill_column /*
2700 *Column beyond which automatic line-wrapping should happen.
2701 Automatically becomes buffer-local when set in any fashion.
2704 DEFVAR_BUFFER_LOCAL ("left-margin", left_margin /*
2705 *Column for the default indent-line-function to indent to.
2706 Linefeed indents to this column in Fundamental mode.
2707 Automatically becomes buffer-local when set in any fashion.
2708 Do not confuse this with the specifier `left-margin-width';
2709 that controls the size of a margin that is displayed outside
2713 DEFVAR_BUFFER_LOCAL_MAGIC ("tab-width", tab_width /*
2714 *Distance between tab stops (for display of tab characters), in columns.
2715 Automatically becomes buffer-local when set in any fashion.
2716 */ , redisplay_variable_changed);
2718 DEFVAR_BUFFER_LOCAL_MAGIC ("ctl-arrow", ctl_arrow /*
2719 *Non-nil means display control chars with uparrow.
2720 Nil means use backslash and octal digits.
2721 An integer means characters >= ctl-arrow are assumed to be printable, and
2722 will be displayed as a single glyph.
2723 Any other value is the same as 160 - the code SPC with the high bit on.
2725 The interpretation of this variable is likely to change in the future.
2727 Automatically becomes buffer-local when set in any fashion.
2728 This variable does not apply to characters whose display is specified
2729 in the current display table (if there is one).
2730 */ , redisplay_variable_changed);
2732 #if 0 /* #### Make this a specifier! */
2733 xxDEFVAR_BUFFER_LOCAL ("display-direction", display_direction /*
2734 *Non-nil means lines in the buffer are displayed right to left.
2735 Nil means left to right. (Not yet implemented.)
2737 #endif /* Not yet implemented */
2739 DEFVAR_BUFFER_LOCAL_MAGIC ("truncate-lines", truncate_lines /*
2740 *Non-nil means do not display continuation lines;
2741 give each line of text one frame line.
2742 Automatically becomes buffer-local when set in any fashion.
2744 Note that this is overridden by the variable
2745 `truncate-partial-width-windows' if that variable is non-nil
2746 and this buffer is not full-frame width.
2747 */ , redisplay_variable_changed);
2749 DEFVAR_BUFFER_LOCAL ("default-directory", directory /*
2750 Name of default directory of current buffer. Should end with slash.
2751 Each buffer has its own value of this variable.
2755 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system", buffer_file_coding_system /*
2756 Default value of `buffer-file-coding-system' for buffers that do not override it.
2757 This is the same as (default-value 'buffer-file-coding-system).
2758 This value is used both for buffers without associated files and
2759 for buffers whose files do not have any apparent coding system.
2760 See `buffer-file-coding-system'.
2763 DEFVAR_BUFFER_LOCAL ("buffer-file-coding-system", buffer_file_coding_system /*
2764 *Current coding system for the current buffer.
2765 When the buffer is written out into a file, this coding system will be
2766 used for the encoding. Automatically buffer-local when set in any
2767 fashion. This is normally set automatically when a file is loaded in
2768 based on the determined coding system of the file (assuming that
2769 `buffer-file-coding-system-for-read' is set to `undecided', which
2770 calls for automatic determination of the file's coding system).
2771 Normally the modeline indicates the current file coding system using
2772 its mnemonic abbreviation.
2774 The default value for this variable (which is normally used for
2775 buffers without associated files) is also used when automatic
2776 detection of a file's encoding is called for and there was no
2777 discernible encoding in the file (i.e. it was entirely or almost
2778 entirely ASCII). The default value should generally *not* be set to
2779 nil (equivalent to `no-conversion'), because if extended characters
2780 are ever inserted into the buffer, they will be lost when the file is
2781 written out. A good choice is `iso-2022-8' (the simple ISO 2022 8-bit
2782 encoding), which will write out ASCII and Latin-1 characters in the
2783 standard (and highly portable) fashion and use standard escape
2784 sequences for other charsets. Another reasonable choice is
2785 `escape-quoted', which is equivalent to `iso-2022-8' but prefixes
2786 certain control characters with ESC to make sure they are not
2787 interpreted as escape sequences when read in. This latter coding
2788 system results in more "correct" output in the presence of control
2789 characters in the buffer, in the sense that when read in again using
2790 the same coding system, the result will virtually always match the
2791 original contents of the buffer, which is not the case with
2792 `iso-2022-8'; but the output is less portable when dealing with binary
2793 data -- there may be stray ESC characters when the file is read by
2796 `buffer-file-coding-system' does *not* control the coding system used when
2797 a file is read in. Use the variables `buffer-file-coding-system-for-read'
2798 and `buffer-file-coding-system-alist' for that. From a Lisp program, if
2799 you wish to unilaterally specify the coding system used for one
2800 particular operation, you should bind the variable
2801 `coding-system-for-read' rather than changing the other two
2802 variables just mentioned, which are intended to be used for
2803 global environment specification.
2805 #endif /* FILE_CODING */
2807 DEFVAR_BUFFER_LOCAL ("auto-fill-function", auto_fill_function /*
2808 Function called (if non-nil) to perform auto-fill.
2809 It is called after self-inserting a space at a column beyond `fill-column'.
2810 Each buffer has its own value of this variable.
2811 NOTE: This variable is not an ordinary hook;
2812 It may not be a list of functions.
2815 DEFVAR_BUFFER_LOCAL ("buffer-file-name", filename /*
2816 Name of file visited in current buffer, or nil if not visiting a file.
2817 Each buffer has its own value of this variable.
2822 Abbreviated truename of file visited in current buffer, or nil if none.
2823 The truename of a file is calculated by `file-truename'
2824 and then abbreviated with `abbreviate-file-name'.
2825 Each buffer has its own value of this variable.
2827 #endif /* FSFmacs */
2829 DEFVAR_BUFFER_LOCAL ("buffer-file-truename", file_truename /*
2830 The real name of the file visited in the current buffer,
2831 or nil if not visiting a file. This is the result of passing
2832 buffer-file-name to the `file-truename' function. Every buffer has
2833 its own value of this variable. This variable is automatically
2834 maintained by the functions that change the file name associated
2838 DEFVAR_BUFFER_LOCAL ("buffer-auto-save-file-name", auto_save_file_name /*
2839 Name of file for auto-saving current buffer,
2840 or nil if buffer should not be auto-saved.
2841 Each buffer has its own value of this variable.
2844 DEFVAR_BUFFER_LOCAL ("buffer-read-only", read_only /*
2845 Non-nil if this buffer is read-only.
2846 Each buffer has its own value of this variable.
2849 DEFVAR_BUFFER_LOCAL ("buffer-backed-up", backed_up /*
2850 Non-nil if this buffer's file has been backed up.
2851 Backing up is done before the first time the file is saved.
2852 Each buffer has its own value of this variable.
2855 DEFVAR_BUFFER_LOCAL ("buffer-saved-size", saved_size /*
2856 Length of current buffer when last read in, saved or auto-saved.
2858 Each buffer has its own value of this variable.
2861 DEFVAR_BUFFER_LOCAL_MAGIC ("selective-display", selective_display /*
2862 Non-nil enables selective display:
2863 Integer N as value means display only lines
2864 that start with less than n columns of space.
2865 A value of t means, after a ^M, all the rest of the line is invisible.
2866 Then ^M's in the file are written into files as newlines.
2868 Automatically becomes buffer-local when set in any fashion.
2869 */, redisplay_variable_changed);
2872 DEFVAR_BUFFER_LOCAL_MAGIC ("selective-display-ellipses",
2873 selective_display_ellipses /*
2874 t means display ... on previous line when a line is invisible.
2875 Automatically becomes buffer-local when set in any fashion.
2876 */, redisplay_variable_changed);
2879 DEFVAR_BUFFER_LOCAL ("local-abbrev-table", abbrev_table /*
2880 Local (mode-specific) abbrev table of current buffer.
2883 DEFVAR_BUFFER_LOCAL ("overwrite-mode", overwrite_mode /*
2884 Non-nil if self-insertion should replace existing text.
2885 The value should be one of `overwrite-mode-textual',
2886 `overwrite-mode-binary', or nil.
2887 If it is `overwrite-mode-textual', self-insertion still
2888 inserts at the end of a line, and inserts when point is before a tab,
2889 until the tab is filled in.
2890 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.
2891 Automatically becomes buffer-local when set in any fashion.
2893 Normally, you shouldn't modify this variable by hand, but use the functions
2894 `overwrite-mode' and `binary-overwrite-mode' instead. However, you can
2895 customize the default value from the options menu.
2899 /* Adds the following to the doc string for buffer-undo-list:
2901 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
2902 was modified between BEG and END. PROPERTY is the property name,
2903 and VALUE is the old value.
2905 #endif /* FSFmacs */
2907 DEFVAR_BUFFER_LOCAL ("buffer-undo-list", undo_list /*
2908 List of undo entries in current buffer.
2909 Recent changes come first; older changes follow newer.
2911 An entry (START . END) represents an insertion which begins at
2912 position START and ends at position END.
2914 An entry (TEXT . POSITION) represents the deletion of the string TEXT
2915 from (abs POSITION). If POSITION is positive, point was at the front
2916 of the text being deleted; if negative, point was at the end.
2918 An entry (t HIGH . LOW) indicates that the buffer previously had
2919 "unmodified" status. HIGH and LOW are the high and low 16-bit portions
2920 of the visited file's modification time, as of that time. If the
2921 modification time of the most recent save is different, this entry is
2924 An entry of the form EXTENT indicates that EXTENT was attached in
2925 the buffer. Undoing an entry of this form detaches EXTENT.
2927 An entry of the form (EXTENT START END) indicates that EXTENT was
2928 detached from the buffer. Undoing an entry of this form attaches
2929 EXTENT from START to END.
2931 An entry of the form POSITION indicates that point was at the buffer
2932 location given by the integer. Undoing an entry of this form places
2935 nil marks undo boundaries. The undo command treats the changes
2936 between two undo boundaries as a single step to be undone.
2938 If the value of the variable is t, undo information is not recorded.
2942 xxDEFVAR_BUFFER_LOCAL ("mark-active", mark_active /*
2943 Non-nil means the mark and region are currently active in this buffer.
2944 Automatically local in all buffers.
2946 #endif /* FSFmacs */
2948 #ifdef REGION_CACHE_NEEDS_WORK
2949 xxDEFVAR_BUFFER_LOCAL ("cache-long-line-scans", cache_long_line_scans /*
2950 Non-nil means that Emacs should use caches to handle long lines more quickly.
2951 This variable is buffer-local, in all buffers.
2953 Normally, the line-motion functions work by scanning the buffer for
2954 newlines. Columnar operations (like move-to-column and
2955 compute-motion) also work by scanning the buffer, summing character
2956 widths as they go. This works well for ordinary text, but if the
2957 buffer's lines are very long (say, more than 500 characters), these
2958 motion functions will take longer to execute. Emacs may also take
2959 longer to update the display.
2961 If cache-long-line-scans is non-nil, these motion functions cache the
2962 results of their scans, and consult the cache to avoid rescanning
2963 regions of the buffer until the text is modified. The caches are most
2964 beneficial when they prevent the most searching---that is, when the
2965 buffer contains long lines and large regions of characters with the
2966 same, fixed screen width.
2968 When cache-long-line-scans is non-nil, processing short lines will
2969 become slightly slower (because of the overhead of consulting the
2970 cache), and the caches will use memory roughly proportional to the
2971 number of newlines and characters whose screen width varies.
2973 The caches require no explicit maintenance; their accuracy is
2974 maintained internally by the Emacs primitives. Enabling or disabling
2975 the cache should not affect the behavior of any of the motion
2976 functions; it should only affect their performance.
2978 #endif /* REGION_CACHE_NEEDS_WORK */
2980 DEFVAR_BUFFER_LOCAL ("point-before-scroll", point_before_scroll /*
2981 Value of point before the last series of scroll operations, or nil.
2984 DEFVAR_BUFFER_LOCAL ("buffer-file-format", file_format /*
2985 List of formats to use when saving this buffer.
2986 Formats are defined by `format-alist'. This variable is
2987 set when a file is visited. Automatically local in all buffers.
2990 DEFVAR_BUFFER_LOCAL_MAGIC ("buffer-invisibility-spec", invisibility_spec /*
2991 Invisibility spec of this buffer.
2992 The default is t, which means that text is invisible
2993 if it has (or is covered by an extent with) a non-nil `invisible' property.
2994 If the value is a list, a text character is invisible if its `invisible'
2995 property is an element in that list.
2996 If an element is a cons cell of the form (PROPERTY . ELLIPSIS),
2997 then characters with property value PROPERTY are invisible,
2998 and they have an ellipsis as well if ELLIPSIS is non-nil.
2999 Note that the actual characters used for the ellipsis are controllable
3000 using `invisible-text-glyph', and default to "...".
3001 */, redisplay_variable_changed);
3003 DEFVAR_CONST_BUFFER_LOCAL ("generated-modeline-string",
3004 generated_modeline_string /*
3005 String of characters in this buffer's modeline as of the last redisplay.
3006 Each time the modeline is recomputed, the resulting characters are
3007 stored in this string, which is resized as necessary. You may not
3008 set this variable, and modifying this string will not change the
3009 modeline; you have to change `modeline-format' if you want that.
3011 For each extent in `modeline-format' that is encountered when
3012 processing the modeline, a corresponding extent is placed in
3013 `generated-modeline-string' and covers the text over which the
3014 extent in `modeline-format' applies. The extent in
3015 `generated-modeline-string' is made a child of the extent in
3016 `modeline-format', which means that it inherits all properties from
3017 that extent. Note that the extents in `generated-modeline-string'
3018 are managed automatically. You should not explicitly put any extents
3019 in `generated-modeline-string'; if you do, they will disappear the
3020 next time the modeline is processed.
3022 For extents in `modeline-format', the following properties are currently
3026 Affects the face of the modeline text. Currently, faces do
3027 not merge properly; only the most recently encountered face
3028 is used. This is a bug.
3031 Affects the disposition of button events over the modeline
3032 text. Multiple applicable keymaps *are* handled properly,
3033 and `modeline-map' still applies to any events that don't
3034 have bindings in extent-specific keymaps.
3037 If a string, causes the string to be displayed when the mouse
3038 moves over the text.
3041 /* Check for DEFVAR_BUFFER_LOCAL without initializing the corresponding
3042 slot of buffer_local_flags and vice-versa. Must be done after all
3043 DEFVAR_BUFFER_LOCAL() calls. */
3044 #define MARKED_SLOT(slot) \
3045 if ((XINT (buffer_local_flags.slot) != -2 && \
3046 XINT (buffer_local_flags.slot) != -3) \
3047 != !(NILP (XBUFFER (Vbuffer_local_symbols)->slot))) \
3049 #include "bufslots.h"
3053 Lisp_Object scratch = Fget_buffer_create (QSscratch);
3054 Fset_buffer (scratch);
3055 /* Want no undo records for *scratch* until after Emacs is dumped */
3056 Fbuffer_disable_undo (scratch);
3060 #ifndef WIN32_NATIVE
3061 /* Is PWD another name for `.' ? */
3063 directory_is_current_directory (Extbyte *pwd)
3065 Bufbyte *pwd_internal;
3066 Bytecount pwd_internal_len;
3067 struct stat dotstat, pwdstat;
3069 TO_INTERNAL_FORMAT (DATA, (pwd, strlen ((char *)pwd) + 1),
3070 ALLOCA, (pwd_internal, pwd_internal_len),
3073 return (IS_DIRECTORY_SEP (*pwd_internal)
3074 && xemacs_stat ((char *) pwd_internal, &pwdstat) == 0
3075 && xemacs_stat (".", &dotstat) == 0
3076 && dotstat.st_ino == pwdstat.st_ino
3077 && dotstat.st_dev == pwdstat.st_dev
3078 && pwd_internal_len < MAXPATHLEN);
3083 init_initial_directory (void)
3085 /* This function can GC */
3087 #ifndef WIN32_NATIVE
3091 initial_directory[0] = 0;
3093 /* If PWD is accurate, use it instead of calling getcwd. This is faster
3094 when PWD is right, and may avoid a fatal error. */
3095 #ifndef WIN32_NATIVE
3096 if ((pwd = (Extbyte *) getenv ("PWD")) != NULL
3097 && directory_is_current_directory (pwd))
3098 strcpy (initial_directory, (char *) pwd);
3101 if (getcwd (initial_directory, MAXPATHLEN) == NULL)
3102 fatal ("`getcwd' failed: %s\n", strerror (errno));
3104 /* Make sure pwd is DIRECTORY_SEP-terminated.
3105 Maybe this should really use some standard subroutine
3106 whose definition is filename syntax dependent. */
3108 int len = strlen (initial_directory);
3110 if (! IS_DIRECTORY_SEP (initial_directory[len - 1]))
3112 initial_directory[len] = DIRECTORY_SEP;
3113 initial_directory[len + 1] = '\0';
3117 #ifdef CORRECT_DIR_SEPS
3118 CORRECT_DIR_SEPS (initial_directory);
3125 /* This function can GC */
3127 Fset_buffer (Fget_buffer_create (QSscratch));
3129 current_buffer->directory =
3130 build_ext_string (initial_directory, Qfile_name);
3133 /* #### is this correct? */
3134 temp = get_minibuffer (0);
3135 XBUFFER (temp)->directory = current_buffer->directory;
3136 #endif /* FSFmacs */