1 /* Buffer manipulation primitives for XEmacs.
2 Copyright (C) 1985-1989, 1992-1995 Free Software Foundation, Inc.
3 Copyright (C) 1995 Sun Microsystems, Inc.
4 Copyright (C) 1995, 1996 Ben Wing.
5 Copyright (C) 1999,2000,2001 MORIOKA Tomohiko
7 This file is part of XEmacs.
9 XEmacs is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 XEmacs is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with XEmacs; see the file COPYING. If not, write to
21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* Synched up with: Mule 2.0, FSF 19.30. */
29 JWZ: some changes for Lemacs, long ago. (e.g. separate buffer
31 Mly: a few changes for buffer-local vars, 19.8 or 19.9.
32 Ben Wing: some changes and cleanups for Mule, 19.12.
33 MORIOKA Tomohiko: some changes for XEmacs UTF-2000.
36 /* This file contains functions that work with buffer objects.
37 Functions that manipulate a buffer's text, however, are not
40 1) The low-level functions that actually know about the
41 implementation of a buffer's text are located in insdel.c.
42 2) The higher-level (mostly Lisp) functions that manipulate a
43 buffer's text are in editfns.c.
44 3) The highest-level Lisp commands are in cmds.c.
48 -- Functions that know about syntax tables (forward-word,
49 scan-sexps, etc.) are in syntax.c, as are functions
50 that manipulate syntax tables.
51 -- Functions that know about case tables (upcase, downcase,
52 etc.) are in casefiddle.c. Functions that manipulate
53 case tables (case-table-p, set-case-table, etc.) are
55 -- Functions that do searching and replacing are in
56 search.c. The low-level functions that implement
57 regular expressions are in regex.c.
61 -- Some file and process functions (in fileio.c and process.c)
62 copy text from or insert text into a buffer; they call
63 low-level functions in insdel.c to do this.
64 -- insdel.c calls low-level functions in undo.c and extents.c
65 to record buffer modifications for undoing and to handle
66 extent adjustment and extent-data creation and insertion.
81 #include "file-coding.h"
86 #include "process.h" /* for kill_buffer_processes */
87 #ifdef REGION_CACHE_NEEDS_WORK
88 #include "region-cache.h"
90 #include "select.h" /* for select_notify_buffer_kill */
91 #include "specifier.h"
93 #include "sysdep.h" /* for getwd */
98 struct buffer *current_buffer; /* the current buffer */
100 /* This structure holds the default values of the buffer-local variables
101 defined with DEFVAR_BUFFER_LOCAL, that have special slots in each buffer.
102 The default value occupies the same slot in this structure
103 as an individual buffer's value occupies in that buffer.
104 Setting the default value also goes through the alist of buffers
105 and stores into each buffer that does not say it has a local value. */
106 Lisp_Object Vbuffer_defaults;
107 static void *buffer_defaults_saved_slots;
109 /* This structure marks which slots in a buffer have corresponding
110 default values in Vbuffer_defaults.
111 Each such slot has a nonzero value in this structure.
112 The value has only one nonzero bit.
114 When a buffer has its own local value for a slot,
115 the bit for that slot (found in the same slot in this structure)
116 is turned on in the buffer's local_var_flags slot.
118 If a slot in this structure is 0, then there is a DEFVAR_BUFFER_LOCAL
119 for the slot, but there is no default value for it; the corresponding
120 slot in Vbuffer_defaults is not used except to initialize newly-created
123 If a slot is -1, then there is a DEFVAR_BUFFER_LOCAL for it
124 as well as a default value which is used to initialize newly-created
125 buffers and as a reset-value when local-vars are killed.
127 If a slot is -2, there is no DEFVAR_BUFFER_LOCAL for it.
128 (The slot is always local, but there's no lisp variable for it.)
129 The default value is only used to initialize newly-creation buffers.
131 If a slot is -3, then there is no DEFVAR_BUFFER_LOCAL for it but
132 there is a default which is used to initialize newly-creation
133 buffers and as a reset-value when local-vars are killed. */
134 struct buffer buffer_local_flags;
136 /* This is the initial (startup) directory, as used for the *scratch* buffer.
137 We're making this a global to make others aware of the startup directory.
138 `initial_directory' is stored in external format.
140 char initial_directory[MAXPATHLEN+1];
142 /* This structure holds the names of symbols whose values may be
143 buffer-local. It is indexed and accessed in the same way as the above. */
144 static Lisp_Object Vbuffer_local_symbols;
145 static void *buffer_local_symbols_saved_slots;
147 /* Alist of all buffer names vs the buffers. */
148 /* This used to be a variable, but is no longer,
149 to prevent lossage due to user rplac'ing this alist or its elements.
150 Note that there is a per-frame copy of this as well; the frame slot
151 and the global variable contain the same data, but possibly in different
152 orders, so that the buffer ordering can be per-frame.
154 Lisp_Object Vbuffer_alist;
156 /* Functions to call before and after each text change. */
157 Lisp_Object Qbefore_change_functions;
158 Lisp_Object Qafter_change_functions;
159 Lisp_Object Vbefore_change_functions;
160 Lisp_Object Vafter_change_functions;
162 /* #### Obsolete, for compatibility */
163 Lisp_Object Qbefore_change_function;
164 Lisp_Object Qafter_change_function;
165 Lisp_Object Vbefore_change_function;
166 Lisp_Object Vafter_change_function;
169 Lisp_Object Vtransient_mark_mode;
172 /* t means ignore all read-only text properties.
173 A list means ignore such a property if its value is a member of the list.
174 Any non-nil value means ignore buffer-read-only. */
175 Lisp_Object Vinhibit_read_only;
177 /* List of functions to call that can query about killing a buffer.
178 If any of these functions returns nil, we don't kill it. */
179 Lisp_Object Vkill_buffer_query_functions;
181 /* Non-nil means delete a buffer's auto-save file when the buffer is saved. */
182 int delete_auto_save_files;
184 Lisp_Object Qbuffer_live_p;
185 Lisp_Object Qbuffer_or_string_p;
187 /* List of functions to call before changing an unmodified buffer. */
188 Lisp_Object Vfirst_change_hook;
189 Lisp_Object Qfirst_change_hook;
191 Lisp_Object Qfundamental_mode;
192 Lisp_Object Qmode_class;
193 Lisp_Object Qpermanent_local;
195 Lisp_Object Qprotected_field;
197 Lisp_Object QSFundamental; /* A string "Fundamental" */
198 Lisp_Object QSscratch; /* "*scratch*" */
199 Lisp_Object Qdefault_directory;
201 Lisp_Object Qkill_buffer_hook;
203 Lisp_Object Qrename_auto_save_file;
205 Lisp_Object Qget_file_buffer;
206 Lisp_Object Qchange_major_mode_hook, Vchange_major_mode_hook;
208 Lisp_Object Qfind_file_compare_truenames;
210 Lisp_Object Qswitch_to_buffer;
212 /* Two thresholds controlling how much undo information to keep. */
213 Fixnum undo_threshold;
214 Fixnum undo_high_threshold;
216 int find_file_compare_truenames;
217 int find_file_use_truenames;
220 static void reset_buffer_local_variables (struct buffer *, int first_time);
221 static void nuke_all_buffer_slots (struct buffer *b, Lisp_Object zap);
224 make_buffer (struct buffer *buf)
227 XSETBUFFER (obj, buf);
232 mark_buffer (Lisp_Object obj)
234 struct buffer *buf = XBUFFER (obj);
236 /* Truncate undo information. */
237 buf->undo_list = truncate_undo_list (buf->undo_list,
239 undo_high_threshold);
241 #define MARKED_SLOT(x) mark_object (buf->x)
242 #include "bufslots.h"
245 mark_object (buf->extent_info);
247 mark_object (buf->text->line_number_cache);
249 /* Don't mark normally through the children slot.
250 (Actually, in this case, it doesn't matter.) */
251 if (! EQ (buf->indirect_children, Qnull_pointer))
252 mark_conses_in_list (buf->indirect_children);
254 return buf->base_buffer ? make_buffer (buf->base_buffer) : Qnil;
258 print_buffer (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
260 struct buffer *b = XBUFFER (obj);
264 if (!BUFFER_LIVE_P (b))
265 error ("printing unreadable object #<killed buffer>");
267 error ("printing unreadable object #<buffer %s>",
268 XSTRING_DATA (b->name));
270 else if (!BUFFER_LIVE_P (b))
271 write_c_string ("#<killed buffer>", printcharfun);
274 write_c_string ("#<buffer ", printcharfun);
275 print_internal (b->name, printcharfun, 1);
276 write_c_string (">", printcharfun);
280 print_internal (b->name, printcharfun, 0);
284 /* We do not need a finalize method to handle a buffer's children list
285 because all buffers have `kill-buffer' applied to them before
286 they disappear, and the children removal happens then. */
287 DEFINE_LRECORD_IMPLEMENTATION ("buffer", buffer,
288 mark_buffer, print_buffer, 0, 0, 0, 0,
291 DEFUN ("bufferp", Fbufferp, 1, 1, 0, /*
292 Return t if OBJECT is an editor buffer.
296 return BUFFERP (object) ? Qt : Qnil;
299 DEFUN ("buffer-live-p", Fbuffer_live_p, 1, 1, 0, /*
300 Return t if OBJECT is an editor buffer that has not been deleted.
304 return BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object)) ? Qt : Qnil;
308 nsberror (Lisp_Object spec)
311 error ("No buffer named %s", XSTRING_DATA (spec));
312 signal_simple_error ("Invalid buffer argument", spec);
315 DEFUN ("buffer-list", Fbuffer_list, 0, 1, 0, /*
316 Return a list of all existing live buffers.
317 The order is specific to the selected frame; if the optional FRAME
318 argument is provided, the ordering for that frame is returned instead.
319 If the FRAME argument is t, then the global (non-frame) ordering is
324 return Fmapcar (Qcdr,
325 EQ (frame, Qt) ? Vbuffer_alist :
326 decode_frame (frame)->buffer_alist);
330 get_buffer (Lisp_Object name, int error_if_deleted_or_does_not_exist)
334 if (!BUFFER_LIVE_P (XBUFFER (name)))
336 if (error_if_deleted_or_does_not_exist)
348 name = LISP_GETTEXT (name); /* I18N3 */
350 buf = Fcdr (Fassoc (name, Vbuffer_alist));
352 if (NILP (buf) && error_if_deleted_or_does_not_exist)
359 decode_buffer (Lisp_Object buffer, int allow_string)
361 if (NILP (buffer) || (!POINTER_TYPE_P( XTYPE(buffer))))
362 return current_buffer;
364 if (allow_string && STRINGP (buffer))
365 return XBUFFER (get_buffer (buffer, 1));
367 CHECK_LIVE_BUFFER (buffer);
368 return XBUFFER (buffer);
371 DEFUN ("decode-buffer", Fdecode_buffer, 1, 1, 0, /*
372 Validate BUFFER or if BUFFER is nil, return the current buffer.
373 If BUFFER is a valid buffer or a string representing a valid buffer,
374 the corresponding buffer object will be returned. Otherwise an error
379 struct buffer *b = decode_buffer (buffer, 1);
380 XSETBUFFER (buffer, b);
386 /* Like Fassoc, but use Fstring_equal to compare
387 (which ignores text properties),
388 and don't ever QUIT. */
391 assoc_ignore_text_properties (REGISTER Lisp_Object key, Lisp_Object list)
393 REGISTER Lisp_Object tail;
394 for (tail = list; !NILP (tail); tail = Fcdr (tail))
396 REGISTER Lisp_Object elt, tem;
398 tem = Fstring_equal (Fcar (elt), key);
407 DEFUN ("get-buffer", Fget_buffer, 1, 1, 0, /*
408 Return the buffer named BUFFER-NAME (a string), or nil if there is none.
409 BUFFER-NAME may also be a buffer; if so, the value is that buffer.
414 /* #### Doc string should indicate that the buffer name will get
418 /* #### This might return a dead buffer. This is gross. This is
419 called FSF compatibility. */
420 if (BUFFERP (buffer_name))
422 return get_buffer (buffer_name, 0);
423 /* FSFmacs 19.29 calls assoc_ignore_text_properties() here.
428 DEFUN ("get-file-buffer", Fget_file_buffer, 1, 1, 0, /*
429 Return the buffer visiting file FILENAME (a string).
430 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
431 If there is no such live buffer, return nil.
433 Normally, the comparison is done by canonicalizing FILENAME (using
434 `expand-file-name') and comparing that to the value of `buffer-file-name'
435 for each existing buffer. However, If `find-file-compare-truenames' is
436 non-nil, FILENAME will be converted to its truename and the search will be
437 done on each buffer's value of `buffer-file-truename' instead of
438 `buffer-file-name'. Otherwise, if `find-file-use-truenames' is non-nil,
439 FILENAME will be converted to its truename and used for searching, but
440 the search will still be done on `buffer-file-name'.
444 /* This function can GC. GC checked and fixed 7-11-2000 ben. */
445 REGISTER Lisp_Object buf;
449 /* DO NOT translate the filename. */
452 CHECK_STRING (filename);
453 filename = Fexpand_file_name (filename, Qnil);
455 /* If the file name has special constructs in it,
456 call the corresponding file handler. */
457 Lisp_Object handler = Ffind_file_name_handler (filename, Qget_file_buffer);
461 return call2 (handler, Qget_file_buffer, filename);
466 if (find_file_compare_truenames || find_file_use_truenames)
468 struct gcpro ngcpro1, ngcpro2, ngcpro3;
469 Lisp_Object fn = Qnil;
470 Lisp_Object dn = Qnil;
472 NGCPRO3 (fn, dn, filename);
473 fn = Ffile_truename (filename, Qnil);
476 dn = Ffile_name_directory (filename);
477 fn = Ffile_truename (dn, Qnil);
478 if (! NILP (fn)) dn = fn;
479 /* Formerly the two calls below were combined, but that is
480 not GC-safe because the first call returns unprotected
481 data and the second call can GC. --ben */
482 fn = Ffile_name_nondirectory (filename);
483 fn = Fexpand_file_name (fn, dn);
490 LIST_LOOP_2 (elt, Vbuffer_alist)
493 if (!BUFFERP (buf)) continue;
494 if (!STRINGP (XBUFFER (buf)->filename)) continue;
495 if (!NILP (Fstring_equal (filename,
496 (find_file_compare_truenames
497 ? XBUFFER (buf)->file_truename
498 : XBUFFER (buf)->filename))))
507 push_buffer_alist (Lisp_Object name, Lisp_Object buf)
509 Lisp_Object cons = Fcons (name, buf);
510 Lisp_Object frmcons, devcons, concons;
512 Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (cons, Qnil));
513 FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
516 f = XFRAME (XCAR (frmcons));
517 f->buffer_alist = nconc2 (f->buffer_alist, Fcons (cons, Qnil));
522 delete_from_buffer_alist (Lisp_Object buf)
524 Lisp_Object cons = Frassq (buf, Vbuffer_alist);
525 Lisp_Object frmcons, devcons, concons;
527 return; /* abort() ? */
528 Vbuffer_alist = delq_no_quit (cons, Vbuffer_alist);
530 FRAME_LOOP_NO_BREAK (frmcons, devcons, concons)
533 f = XFRAME (XCAR (frmcons));
534 f->buffer_alist = delq_no_quit (cons, f->buffer_alist);
539 get_truename_buffer (REGISTER Lisp_Object filename)
541 /* This function can GC. GC correct 7-11-00 ben */
542 /* FSFmacs has its own code here and doesn't call get-file-buffer.
543 That's because their equivalent of find-file-compare-truenames
544 (find-file-existing-other-name) isn't looked at in get-file-buffer.
545 This way is more correct. */
546 int count = specpdl_depth ();
548 specbind (Qfind_file_compare_truenames, Qt);
549 return unbind_to (count, Fget_file_buffer (filename));
552 static struct buffer *
553 allocate_buffer (void)
555 struct buffer *b = alloc_lcrecord_type (struct buffer, &lrecord_buffer);
557 copy_lcrecord (b, XBUFFER (Vbuffer_defaults));
563 finish_init_buffer (struct buffer *b, Lisp_Object name)
569 name = Fcopy_sequence (name);
570 /* #### This really does not need to be called. We already
571 initialized the buffer-local variables in allocate_buffer().
572 local_var_alist is set to Qnil at the same point, in
573 nuke_all_buffer_slots(). */
574 reset_buffer_local_variables (b, 1);
575 b->directory = current_buffer ? current_buffer->directory : Qnil;
577 b->last_window_start = 1;
580 if (string_byte (XSTRING (name), 0) != ' ')
585 /* initialize the extent list */
586 init_buffer_extents (b);
588 /* Put this in the alist of all live buffers. */
589 push_buffer_alist (name, buf);
591 init_buffer_markers (b);
593 b->generated_modeline_string = Fmake_string (make_int (84), make_int (' '));
594 b->modeline_extent_table = make_lisp_hash_table (20, HASH_TABLE_KEY_WEAK,
600 DEFUN ("get-buffer-create", Fget_buffer_create, 1, 1, 0, /*
601 Return the buffer named NAME, or create such a buffer and return it.
602 A new buffer is created if there is no live buffer named NAME.
603 If NAME starts with a space, the new buffer does not keep undo information.
604 If NAME is a buffer instead of a string, then it is the value returned.
605 The value is never nil.
609 /* This function can GC */
611 REGISTER struct buffer *b;
614 /* #### Doc string should indicate that the buffer name will get
618 name = LISP_GETTEXT (name);
619 buf = Fget_buffer (name);
623 if (XSTRING_LENGTH (name) == 0)
624 error ("Empty string for buffer name is not allowed");
626 b = allocate_buffer ();
628 b->text = &b->own_text;
630 b->indirect_children = Qnil;
631 init_buffer_text (b);
633 return finish_init_buffer (b, name);
636 DEFUN ("make-indirect-buffer", Fmake_indirect_buffer, 2, 2,
637 "bMake indirect buffer (to buffer): \nBName of indirect buffer: ", /*
638 Create and return an indirect buffer for buffer BASE-BUFFER, named NAME.
639 BASE-BUFFER should be an existing buffer (or buffer name).
640 NAME should be a string which is not the name of an existing buffer.
642 If BASE-BUFFER is itself an indirect buffer, the base buffer for that buffer
643 is made the base buffer for the newly created buffer. (Thus, there will
644 never be indirect buffers whose base buffers are themselves indirect.)
648 /* This function can GC */
650 /* #### The above interactive specification is totally bogus,
651 because it offers an existing buffer as default answer to the
652 second question. However, the second argument may not BE an
656 base_buffer = get_buffer (base_buffer, 1);
659 /* #### Doc string should indicate that the buffer name will get
663 name = LISP_GETTEXT (name);
664 if (!NILP (Fget_buffer (name)))
665 signal_simple_error ("Buffer name already in use", name);
666 if (XSTRING_LENGTH (name) == 0)
667 error ("Empty string for buffer name is not allowed");
669 b = allocate_buffer ();
671 b->base_buffer = BUFFER_BASE_BUFFER (XBUFFER (base_buffer));
673 /* Use the base buffer's text object. */
674 b->text = b->base_buffer->text;
675 b->indirect_children = Qnil;
676 b->base_buffer->indirect_children =
677 Fcons (make_buffer (b), b->base_buffer->indirect_children);
678 init_buffer_text (b);
680 return finish_init_buffer (b, name);
686 reset_buffer_local_variables (struct buffer *b, int first_time)
688 struct buffer *def = XBUFFER (Vbuffer_defaults);
690 b->local_var_flags = 0;
691 /* For each slot that has a default value,
692 copy that into the slot. */
693 #define MARKED_SLOT(slot) \
694 { int mask = XINT (buffer_local_flags.slot); \
695 if ((mask > 0 || mask == -1 || mask == -3) \
697 || NILP (Fget (XBUFFER (Vbuffer_local_symbols)->slot, \
698 Qpermanent_local, Qnil)))) \
699 b->slot = def->slot; \
701 #include "bufslots.h"
706 /* We split this away from generate-new-buffer, because rename-buffer
707 and set-visited-file-name ought to be able to use this to really
708 rename the buffer properly. */
710 DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name, 1, 2, 0, /*
711 Return a string that is the name of no existing buffer based on NAME.
712 If there is no live buffer named NAME, then return NAME.
713 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
714 until an unused name is found, and then return that name.
715 Optional second argument IGNORE specifies a name that is okay to use
716 \(if it is in the sequence to be tried)
717 even if a buffer with that name exists.
721 REGISTER Lisp_Object gentemp, tem;
727 name = LISP_GETTEXT (name);
729 /* #### Doc string should indicate that the buffer name will get
733 tem = Fget_buffer (name);
740 sprintf (number, "<%d>", ++count);
741 gentemp = concat2 (name, build_string (number));
744 tem = Fstring_equal (gentemp, ignore);
748 tem = Fget_buffer (gentemp);
755 DEFUN ("buffer-name", Fbuffer_name, 0, 1, 0, /*
756 Return the name of BUFFER, as a string.
757 With no argument or nil as argument, return the name of the current buffer.
761 /* For compatibility, we allow a dead buffer here.
762 Earlier versions of Emacs didn't provide buffer-live-p. */
764 return current_buffer->name;
765 CHECK_BUFFER (buffer);
766 return XBUFFER (buffer)->name;
769 DEFUN ("buffer-file-name", Fbuffer_file_name, 0, 1, 0, /*
770 Return name of file BUFFER is visiting, or nil if none.
771 No argument or nil as argument means use the current buffer.
775 /* For compatibility, we allow a dead buffer here. Yuck! */
777 return current_buffer->filename;
778 CHECK_BUFFER (buffer);
779 return XBUFFER (buffer)->filename;
782 DEFUN ("buffer-base-buffer", Fbuffer_base_buffer, 0, 1, 0, /*
783 Return the base buffer of indirect buffer BUFFER.
784 If BUFFER is not indirect, return nil.
788 struct buffer *buf = decode_buffer (buffer, 0);
790 return buf->base_buffer ? make_buffer (buf->base_buffer) : Qnil;
793 DEFUN ("buffer-indirect-children", Fbuffer_indirect_children, 0, 1, 0, /*
794 Return a list of all indirect buffers whose base buffer is BUFFER.
795 If BUFFER is indirect, the return value will always be nil; see
796 `make-indirect-buffer'.
800 struct buffer *buf = decode_buffer (buffer, 0);
802 return Fcopy_sequence (buf->indirect_children);
805 DEFUN ("buffer-local-variables", Fbuffer_local_variables, 0, 1, 0, /*
806 Return an alist of variables that are buffer-local in BUFFER.
807 Most elements look like (SYMBOL . VALUE), describing one variable.
808 For a symbol that is locally unbound, just the symbol appears in the value.
809 Note that storing new VALUEs in these elements doesn't change the variables.
810 No argument or nil as argument means use current buffer as BUFFER.
814 struct buffer *buf = decode_buffer (buffer, 0);
815 Lisp_Object result = Qnil;
819 for (tail = buf->local_var_alist; CONSP (tail); tail = XCDR (tail))
821 Lisp_Object elt = XCAR (tail);
822 /* Reference each variable in the alist in buf.
823 If inquiring about the current buffer, this gets the current values,
824 so store them into the alist so the alist is up to date.
825 If inquiring about some other buffer, this swaps out any values
826 for that buffer, making the alist up to date automatically. */
827 Lisp_Object val = find_symbol_value (XCAR (elt));
828 /* Use the current buffer value only if buf is the current buffer. */
829 if (buf != current_buffer)
832 /* If symbol is unbound, put just the symbol in the list. */
834 result = Fcons (XCAR (elt), result);
835 /* Otherwise, put (symbol . value) in the list. */
837 result = Fcons (Fcons (XCAR (elt), val), result);
841 /* Add on all the variables stored in special slots. */
843 struct buffer *syms = XBUFFER (Vbuffer_local_symbols);
844 #define MARKED_SLOT(slot) \
845 { int mask = XINT (buffer_local_flags.slot); \
846 if (mask == 0 || mask == -1 \
847 || ((mask > 0) && (buf->local_var_flags & mask))) \
848 result = Fcons (Fcons (syms->slot, buf->slot), result); \
850 #include "bufslots.h"
857 DEFUN ("buffer-modified-p", Fbuffer_modified_p, 0, 1, 0, /*
858 Return t if BUFFER was modified since its file was last read or saved.
859 No argument or nil as argument means use current buffer as BUFFER.
863 struct buffer *buf = decode_buffer (buffer, 0);
865 return BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf) ? Qt : Qnil;
868 DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p, 1, 2, 0, /*
869 Mark BUFFER as modified or unmodified according to FLAG.
870 A non-nil FLAG means mark the buffer modified. No argument or nil
871 as BUFFER means use current buffer.
875 /* This function can GC */
876 struct buffer *buf = decode_buffer (buffer, 0);
878 #ifdef CLASH_DETECTION
879 /* If buffer becoming modified, lock the file.
880 If buffer becoming unmodified, unlock the file. */
882 Lisp_Object fn = buf->file_truename;
885 int already = BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf);
886 if (already == NILP (flag))
888 int count = specpdl_depth ();
889 /* lock_file() and unlock_file() currently use current_buffer */
890 /* #### - dmoore, what if lock_file or unlock_file kill
891 the current buffer? */
892 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
893 set_buffer_internal (buf);
894 if (!already && !NILP (flag))
896 else if (already && NILP (flag))
898 unbind_to (count, Qnil);
901 #endif /* CLASH_DETECTION */
903 /* This is often called when the buffer contents are altered but we
904 don't want to treat the changes that way (e.g. selective
905 display). We still need to make sure redisplay realizes that the
906 contents have potentially altered and it needs to do some
908 buf = decode_buffer (buffer, 0);
910 BUF_SAVE_MODIFF (buf) = NILP (flag) ? BUF_MODIFF (buf) : 0;
911 MARK_MODELINE_CHANGED;
916 DEFUN ("buffer-modified-tick", Fbuffer_modified_tick, 0, 1, 0, /*
917 Return BUFFER's tick counter, incremented for each change in text.
918 Each buffer has a tick counter which is incremented each time the text in
919 that buffer is changed. It wraps around occasionally.
920 No argument or nil as argument means use current buffer as BUFFER.
924 struct buffer *buf = decode_buffer (buffer, 0);
926 return make_int (BUF_MODIFF (buf));
929 DEFUN ("rename-buffer", Frename_buffer, 1, 2,
930 "sRename buffer (to new name): \nP", /*
931 Change current buffer's name to NEWNAME (a string).
932 If second arg UNIQUE is nil or omitted, it is an error if a
933 buffer named NEWNAME already exists.
934 If UNIQUE is non-nil, come up with a new name using
935 `generate-new-buffer-name'.
936 Interactively, one can set UNIQUE with a prefix argument.
937 Returns the name we actually gave the buffer.
938 This does not change the name of the visited file (if any).
942 /* This function can GC */
943 Lisp_Object tem, buf;
946 /* #### Doc string should indicate that the buffer name will get
949 CHECK_STRING (newname);
950 newname = LISP_GETTEXT (newname);
952 if (XSTRING_LENGTH (newname) == 0)
953 error ("Empty string is invalid as a buffer name");
955 tem = Fget_buffer (newname);
956 /* Don't short-circuit if UNIQUE is t. That is a useful way to rename
957 the buffer automatically so you can create another with the original name.
958 It makes UNIQUE equivalent to
959 (rename-buffer (generate-new-buffer-name NEWNAME)). */
960 /* XEmacs change: added check for nil */
961 if (NILP (unique) && !NILP (tem) && XBUFFER (tem) == current_buffer)
962 return current_buffer->name;
966 newname = Fgenerate_new_buffer_name (newname, current_buffer->name);
968 error ("Buffer name \"%s\" is in use",
969 XSTRING_DATA (newname));
972 current_buffer->name = newname;
974 /* Catch redisplay's attention. Unless we do this, the modelines for
975 any windows displaying current_buffer will stay unchanged. */
976 MARK_MODELINE_CHANGED;
978 buf = Fcurrent_buffer ();
980 /* The aconses in the Vbuffer_alist are shared with frame->buffer_alist,
981 so this will change it in the per-frame ordering as well. */
982 Fsetcar (Frassq (buf, Vbuffer_alist), newname);
984 if (NILP (current_buffer->filename)
985 && !NILP (current_buffer->auto_save_file_name))
986 call0 (Qrename_auto_save_file);
987 /* refetch since that last call may have done GC */
988 /* (hypothetical relocating GC) */
989 return current_buffer->name;
992 DEFUN ("other-buffer", Fother_buffer, 0, 3, 0, /*
993 Return most recently selected buffer other than BUFFER.
994 Buffers not visible in windows are preferred to visible buffers,
995 unless optional third argument VISIBLE-OK is non-nil.
996 If no other buffer exists, the buffer `*scratch*' is returned.
997 If BUFFER is omitted or nil, some interesting buffer is returned.
999 The ordering is for this frame; If second optional argument FRAME
1000 is provided, then the ordering is for that frame. If the second arg
1001 is t, then the global ordering is returned.
1003 Note: In FSF Emacs, this function takes two arguments: BUFFER and
1006 (buffer, frame, visible_ok))
1008 /* This function can GC */
1009 Lisp_Object tail, buf, notsogood, tem;
1015 alist = Vbuffer_alist;
1018 struct frame *f = decode_frame (frame);
1020 XSETFRAME (frame, f);
1021 alist = f->buffer_alist;
1024 for (tail = alist; !NILP (tail); tail = Fcdr (tail))
1026 buf = Fcdr (Fcar (tail));
1027 if (EQ (buf, buffer))
1029 if (string_byte (XSTRING (XBUFFER (buf)->name), 0) == ' ')
1031 /* If FRAME has a buffer_predicate,
1032 disregard buffers that don't fit the predicate. */
1035 tem = XFRAME (frame)->buffer_predicate;
1038 tem = call1 (tem, buf);
1044 if (NILP (visible_ok))
1046 /* get-buffer-window will handle nil or t frame */
1047 tem = Fget_buffer_window (buf, frame, Qnil);
1053 if (NILP (notsogood))
1056 if (!NILP (notsogood))
1058 return Fget_buffer_create (QSscratch);
1061 DEFUN ("buffer-disable-undo", Fbuffer_disable_undo, 0, 1, "", /*
1062 Stop keeping undo information for BUFFER.
1063 Any undo records it already has are discarded.
1064 No argument or nil as argument means do this for the current buffer.
1068 /* Allowing nil is an RMSism */
1069 struct buffer *real_buf = decode_buffer (buffer, 1);
1070 real_buf->undo_list = Qt;
1074 DEFUN ("buffer-enable-undo", Fbuffer_enable_undo, 0, 1, "", /*
1075 Start keeping undo information for BUFFER.
1076 No argument or nil as argument means do this for the current buffer.
1080 /* Allowing nil is an RMSism */
1081 struct buffer *real_buf = decode_buffer (buffer, 1);
1082 if (EQ (real_buf->undo_list, Qt))
1083 real_buf->undo_list = Qnil;
1088 DEFUN ("kill-buffer", Fkill_buffer, 1, 1, "bKill buffer: ", /*
1089 Kill the buffer BUFFER.
1090 The argument may be a buffer or may be the name of a buffer.
1091 An argument of nil means kill the current buffer.
1093 Value is t if the buffer is actually killed, nil if user says no.
1095 The value of `kill-buffer-hook' (which may be local to that buffer),
1096 if not void, is a list of functions to be called, with no arguments,
1097 before the buffer is actually killed. The buffer to be killed is current
1098 when the hook functions are called.
1100 Any processes that have this buffer as the `process-buffer' are killed
1101 with `delete-process'.
1105 /* This function can call lisp */
1107 REGISTER struct buffer *b;
1108 struct gcpro gcpro1, gcpro2;
1111 buf = Fcurrent_buffer ();
1112 else if (BUFFERP (buffer))
1116 buf = get_buffer (buffer, 0);
1117 if (NILP (buf)) nsberror (buffer);
1122 /* OK to delete an already-deleted buffer. */
1123 if (!BUFFER_LIVE_P (b))
1126 /* Don't kill the minibuffer now current. */
1127 if (EQ (buf, Vminibuffer_zero))
1130 /* Or the echo area. */
1131 if (EQ (buf, Vecho_area_buffer))
1134 /* Query if the buffer is still modified. */
1135 if (INTERACTIVE && !NILP (b->filename)
1136 && BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
1142 (emacs_doprnt_string_c
1143 ((const Bufbyte *) GETTEXT ("Buffer %s modified; kill anyway? "),
1144 Qnil, -1, XSTRING_DATA (b->name))));
1148 b = XBUFFER (buf); /* Hypothetical relocating GC. */
1151 /* Run hooks with the buffer to be killed temporarily selected,
1152 unless the buffer is already dead (could have been deleted
1153 in the question above).
1155 if (BUFFER_LIVE_P (b))
1157 int speccount = specpdl_depth ();
1158 Lisp_Object tail = Qnil;
1161 record_unwind_protect (save_excursion_restore, save_excursion_save ());
1164 /* First run the query functions; if any query is answered no,
1165 don't kill the buffer. */
1166 EXTERNAL_LIST_LOOP (tail, Vkill_buffer_query_functions)
1168 if (NILP (call0 (Fcar (tail))))
1171 return unbind_to (speccount, Qnil);
1175 /* Then run the hooks. */
1176 run_hook (Qkill_buffer_hook);
1178 /* Inform the selection code that a buffer just got killed.
1179 We do this in C because (a) it's faster, and (b) it needs
1180 to access data internal to select.c that can't be seen from
1181 Lisp (so the Lisp code would just call into C anyway. */
1182 select_notify_buffer_kill (buf);
1184 unbind_to (speccount, Qnil);
1186 b = XBUFFER (buf); /* Hypothetical relocating GC. */
1189 /* We have no more questions to ask. Verify that it is valid
1190 to kill the buffer. This must be done after the questions
1191 since anything can happen within yes-or-no-p. */
1193 /* Might have been deleted during the last question above */
1194 if (!BUFFER_LIVE_P (b))
1197 /* Don't kill the minibuffer now current. */
1198 if (EQ (buf, XWINDOW (minibuf_window)->buffer))
1201 /* When we kill a base buffer, kill all its indirect buffers.
1202 We do it at this stage so nothing terrible happens if they
1203 ask questions or their hooks get errors. */
1204 if (! b->base_buffer)
1210 LIST_LOOP (rest, b->indirect_children)
1212 Fkill_buffer (XCAR (rest));
1213 /* Keep indirect_children updated in case a
1214 query-function/hook throws. */
1215 b->indirect_children = XCDR (rest);
1221 /* Make this buffer not be current.
1222 In the process, notice if this is the sole visible buffer
1223 and give up if so. */
1224 if (b == current_buffer)
1226 Fset_buffer (Fother_buffer (buf, Qnil, Qnil));
1227 if (b == current_buffer)
1231 /* Now there is no question: we can kill the buffer. */
1233 #ifdef CLASH_DETECTION
1234 /* Unlock this buffer's file, if it is locked. unlock_buffer
1235 can both GC and kill the current buffer, and wreak general
1236 havok by running lisp code. */
1242 if (!BUFFER_LIVE_P (b))
1245 if (b == current_buffer)
1247 Fset_buffer (Fother_buffer (buf, Qnil, Qnil));
1248 if (b == current_buffer)
1251 #endif /* CLASH_DETECTION */
1254 int speccount = specpdl_depth ();
1255 specbind (Qinhibit_quit, Qt);
1257 kill_buffer_processes (buf);
1259 delete_from_buffer_alist (buf);
1261 /* Undedicate any windows of this buffer, and make sure no windows
1264 undedicate_windows (buf, Qt);
1267 Freplace_buffer_in_windows (buf, Qnil, Qall);
1270 font_lock_buffer_was_killed (b);
1272 /* Delete any auto-save file, if we saved it in this session. */
1273 if (STRINGP (b->auto_save_file_name)
1274 && b->auto_save_modified != 0
1275 && BUF_SAVE_MODIFF (b) < b->auto_save_modified)
1277 if (delete_auto_save_files != 0)
1279 /* deleting the auto save file might kill b! */
1280 /* #### dmoore - fix this crap, we do this same gcpro and
1281 buffer liveness check multiple times. Let's get a
1282 macro or something for it. */
1284 internal_delete_file (b->auto_save_file_name);
1288 if (!BUFFER_LIVE_P (b))
1291 if (b == current_buffer)
1293 Fset_buffer (Fother_buffer (buf, Qnil, Qnil));
1294 if (b == current_buffer)
1300 uninit_buffer_markers (b);
1302 kill_buffer_local_variables (b);
1305 uninit_buffer_text (b);
1306 b->undo_list = Qnil;
1307 uninit_buffer_extents (b);
1310 #ifdef ERROR_CHECK_BUFPOS
1311 assert (!NILP (memq_no_quit (buf, b->base_buffer->indirect_children)));
1313 b->base_buffer->indirect_children =
1314 delq_no_quit (buf, b->base_buffer->indirect_children);
1317 /* Clear away all Lisp objects, so that they
1318 won't be protected from GC. */
1319 nuke_all_buffer_slots (b, Qnil);
1321 unbind_to (speccount, Qnil);
1326 DEFUN ("record-buffer", Frecord_buffer, 1, 1, 0, /*
1327 Place buffer BUFFER first in the buffer order.
1328 Call this function when a buffer is selected "visibly".
1330 This function changes the global buffer order and the per-frame buffer
1331 order for the selected frame. The buffer order keeps track of recency
1332 of selection so that `other-buffer' will return a recently selected
1333 buffer. See `other-buffer' for more information.
1337 REGISTER Lisp_Object lynk, prev;
1338 struct frame *f = selected_frame ();
1341 for (lynk = Vbuffer_alist; CONSP (lynk); lynk = XCDR (lynk))
1343 if (EQ (XCDR (XCAR (lynk)), buffer))
1347 /* Effectively do Vbuffer_alist = delq_no_quit (lynk, Vbuffer_alist) */
1349 Vbuffer_alist = XCDR (Vbuffer_alist);
1351 XCDR (prev) = XCDR (XCDR (prev));
1352 XCDR (lynk) = Vbuffer_alist;
1353 Vbuffer_alist = lynk;
1355 /* That was the global one. Now do the same thing for the
1356 per-frame buffer-alist. */
1358 for (lynk = f->buffer_alist; CONSP (lynk); lynk = XCDR (lynk))
1360 if (EQ (XCDR (XCAR (lynk)), buffer))
1364 /* Effectively do f->buffer_alist = delq_no_quit (lynk, f->buffer_alist) */
1366 f->buffer_alist = XCDR (f->buffer_alist);
1368 XCDR (prev) = XCDR (XCDR (prev));
1369 XCDR (lynk) = f->buffer_alist;
1370 f->buffer_alist = lynk;
1375 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode, 1, 1, 0, /*
1376 Set an appropriate major mode for BUFFER, according to `default-major-mode'.
1377 Use this function before selecting the buffer, since it may need to inspect
1378 the current buffer's major mode.
1382 int speccount = specpdl_depth ();
1383 Lisp_Object function = XBUFFER (Vbuffer_defaults)->major_mode;
1385 if (NILP (function))
1387 Lisp_Object tem = Fget (current_buffer->major_mode, Qmode_class, Qnil);
1389 function = current_buffer->major_mode;
1392 if (NILP (function) || EQ (function, Qfundamental_mode))
1395 /* To select a nonfundamental mode,
1396 select the buffer temporarily and then call the mode function. */
1398 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
1400 Fset_buffer (buffer);
1403 return unbind_to (speccount, Qnil);
1407 switch_to_buffer (Lisp_Object bufname, Lisp_Object norecord)
1409 call2 (Qswitch_to_buffer, bufname, norecord);
1413 DEFUN ("current-buffer", Fcurrent_buffer, 0, 0, 0, /*
1414 Return the current buffer as a Lisp object.
1419 XSETBUFFER (buffer, current_buffer);
1423 /* Set the current buffer to B. */
1426 set_buffer_internal (struct buffer *b)
1428 REGISTER struct buffer *old_buf;
1429 REGISTER Lisp_Object tail;
1431 if (current_buffer == b)
1434 INVALIDATE_PIXEL_TO_GLYPH_CACHE;
1436 old_buf = current_buffer;
1438 invalidate_current_column (); /* invalidate indentation cache */
1442 /* Put the undo list back in the base buffer, so that it appears
1443 that an indirect buffer shares the undo list of its base. */
1444 if (old_buf->base_buffer)
1445 old_buf->base_buffer->undo_list = old_buf->undo_list;
1448 /* Get the undo list from the base buffer, so that it appears
1449 that an indirect buffer shares the undo list of its base. */
1451 b->undo_list = b->base_buffer->undo_list;
1453 /* Look down buffer's list of local Lisp variables
1454 to find and update any that forward into C variables. */
1456 LIST_LOOP (tail, b->local_var_alist)
1458 Lisp_Object sym = XCAR (XCAR (tail));
1459 Lisp_Object valcontents = XSYMBOL (sym)->value;
1460 if (SYMBOL_VALUE_MAGIC_P (valcontents))
1462 /* Just reference the variable
1463 to cause it to become set for this buffer. */
1464 /* Use find_symbol_value_quickly to avoid an unnecessary O(n)
1466 (void) find_symbol_value_quickly (XCAR (tail), 1);
1470 /* Do the same with any others that were local to the previous buffer */
1474 LIST_LOOP (tail, old_buf->local_var_alist)
1476 Lisp_Object sym = XCAR (XCAR (tail));
1477 Lisp_Object valcontents = XSYMBOL (sym)->value;
1479 if (SYMBOL_VALUE_MAGIC_P (valcontents))
1481 /* Just reference the variable
1482 to cause it to become set for this buffer. */
1483 /* Use find_symbol_value_quickly with find_it_p as 0 to avoid an
1484 unnecessary O(n) lookup which is guaranteed to be worst case.
1485 Any symbols which are local are guaranteed to have been
1486 handled in the previous loop, above. */
1487 (void) find_symbol_value_quickly (sym, 0);
1493 DEFUN ("set-buffer", Fset_buffer, 1, 1, 0, /*
1494 Make the buffer BUFFER current for editing operations.
1495 BUFFER may be a buffer or the name of an existing buffer.
1496 See also `save-excursion' when you want to make a buffer current temporarily.
1497 This function does not display the buffer, so its effect ends
1498 when the current command terminates.
1499 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.
1503 buffer = get_buffer (buffer, 0);
1505 error ("Selecting deleted or non-existent buffer");
1506 set_buffer_internal (XBUFFER (buffer));
1511 DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only, 0, 3, 0, /*
1512 Signal a `buffer-read-only' error if BUFFER is read-only.
1513 Optional argument BUFFER defaults to the current buffer.
1515 If optional argument START is non-nil, all extents in the buffer
1516 which overlap that part of the buffer are checked to ensure none has a
1517 `read-only' property. (Extents that lie completely within the range,
1518 however, are not checked.) END defaults to the value of START.
1520 If START and END are equal, the range checked is [START, END] (i.e.
1521 closed on both ends); otherwise, the range checked is (START, END)
1522 \(open on both ends), except that extents that lie completely within
1523 [START, END] are not checked. See `extent-in-region-p' for a fuller
1526 (buffer, start, end))
1528 struct buffer *b = decode_buffer (buffer, 0);
1537 get_buffer_range_char (b, start, end, &s, &e, 0);
1539 barf_if_buffer_read_only (b, s, e);
1545 bury_buffer_1 (Lisp_Object buffer, Lisp_Object before,
1546 Lisp_Object *buffer_alist)
1548 Lisp_Object aelt = rassq_no_quit (buffer, *buffer_alist);
1549 Lisp_Object lynk = memq_no_quit (aelt, *buffer_alist);
1550 Lisp_Object iter, before_before;
1552 *buffer_alist = delq_no_quit (aelt, *buffer_alist);
1553 for (before_before = Qnil, iter = *buffer_alist;
1554 !NILP (iter) && !EQ (XCDR (XCAR (iter)), before);
1555 before_before = iter, iter = XCDR (iter))
1558 if (!NILP (before_before))
1559 XCDR (before_before) = lynk;
1561 *buffer_alist = lynk;
1564 DEFUN ("bury-buffer", Fbury_buffer, 0, 2, "", /*
1565 Put BUFFER at the end of the list of all buffers.
1566 There it is the least likely candidate for `other-buffer' to return;
1567 thus, the least likely buffer for \\[switch-to-buffer] to select by default.
1568 If BUFFER is nil or omitted, bury the current buffer.
1569 Also, if BUFFER is nil or omitted, remove the current buffer from the
1570 selected window if it is displayed there.
1571 Because of this, you may need to specify (current-buffer) as
1572 BUFFER when calling from minibuffer.
1573 If BEFORE is non-nil, it specifies a buffer before which BUFFER
1574 will be placed, instead of being placed at the end.
1578 /* This function can GC */
1579 struct buffer *buf = decode_buffer (buffer, 1);
1580 /* If we're burying the current buffer, unshow it. */
1581 /* Note that the behavior of (bury-buffer nil) and
1582 (bury-buffer (current-buffer)) is not the same.
1583 This is illogical but is historical. Changing it
1584 breaks mh-e and TeX and such packages. */
1586 switch_to_buffer (Fother_buffer (Fcurrent_buffer (), Qnil, Qnil), Qnil);
1587 XSETBUFFER (buffer, buf);
1590 before = get_buffer (before, 1);
1592 if (EQ (before, buffer))
1593 error ("Cannot place a buffer before itself");
1595 bury_buffer_1 (buffer, before, &Vbuffer_alist);
1596 bury_buffer_1 (buffer, before, &selected_frame ()->buffer_alist);
1602 DEFUN ("erase-buffer", Ferase_buffer, 0, 1, "*", /*
1603 Delete the entire contents of the BUFFER.
1604 Any clipping restriction in effect (see `narrow-to-region') is removed,
1605 so the buffer is truly empty after this.
1606 BUFFER defaults to the current buffer if omitted.
1610 /* This function can GC */
1611 struct buffer *b = decode_buffer (buffer, 1);
1612 /* #### yuck yuck yuck. This is gross. The old echo-area code,
1613 however, was the only place that called erase_buffer() with a
1614 non-zero NO_CLIP argument.
1616 Someone needs to fix up the redisplay code so it is smarter
1617 about this, so that the NO_CLIP junk isn't necessary. */
1618 int no_clip = (b == XBUFFER (Vecho_area_buffer));
1620 INVALIDATE_PIXEL_TO_GLYPH_CACHE;
1622 widen_buffer (b, no_clip);
1623 buffer_delete_range (b, BUF_BEG (b), BUF_Z (b), 0);
1624 b->last_window_start = 1;
1626 /* Prevent warnings, or suspension of auto saving, that would happen
1627 if future size is less than past size. Use of erase-buffer
1628 implies that the future text is not really related to the past text. */
1629 b->saved_size = Qzero;
1636 DEFUN ("kill-all-local-variables", Fkill_all_local_variables, 0, 0, 0, /*
1637 Switch to Fundamental mode by killing current buffer's local variables.
1638 Most local variable bindings are eliminated so that the default values
1639 become effective once more. Also, the syntax table is set from
1640 `standard-syntax-table', the category table is set from
1641 `standard-category-table' (if support for Mule exists), local keymap is set
1642 to nil, the abbrev table is set from `fundamental-mode-abbrev-table',
1643 and all specifier specifications whose locale is the current buffer
1644 are removed. This function also forces redisplay of the modeline.
1646 Every function to select a new major mode starts by
1647 calling this function.
1649 As a special exception, local variables whose names have
1650 a non-nil `permanent-local' property are not eliminated by this function.
1652 The first thing this function does is run
1653 the normal hook `change-major-mode-hook'.
1657 /* This function can GC */
1658 run_hook (Qchange_major_mode_hook);
1660 reset_buffer_local_variables (current_buffer, 0);
1662 kill_buffer_local_variables (current_buffer);
1664 kill_specifier_buffer_locals (Fcurrent_buffer ());
1666 /* Force modeline redisplay. Useful here because all major mode
1667 commands call this function. */
1668 MARK_MODELINE_CHANGED;
1673 #ifdef MEMORY_USAGE_STATS
1684 compute_buffer_text_usage (struct buffer *b, struct overhead_stats *ovstats)
1686 int was_requested = b->text->z - 1;
1687 size_t gap = b->text->gap_size + b->text->end_gap_size;
1688 size_t malloc_use = malloced_storage_size (b->text->beg, was_requested + gap, 0);
1690 ovstats->gap_overhead += gap;
1691 ovstats->was_requested += was_requested;
1692 ovstats->malloc_overhead += malloc_use - (was_requested + gap);
1697 compute_buffer_usage (struct buffer *b, struct buffer_stats *stats,
1698 struct overhead_stats *ovstats)
1701 stats->other += malloced_storage_size (b, sizeof (*b), ovstats);
1702 stats->text += compute_buffer_text_usage (b, ovstats);
1703 stats->markers += compute_buffer_marker_usage (b, ovstats);
1704 stats->extents += compute_buffer_extent_usage (b, ovstats);
1707 DEFUN ("buffer-memory-usage", Fbuffer_memory_usage, 1, 1, 0, /*
1708 Return stats about the memory usage of buffer BUFFER.
1709 The values returned are in the form of an alist of usage types and byte
1710 counts. The byte counts attempt to encompass all the memory used
1711 by the buffer (separate from the memory logically associated with a
1712 buffer or frame), including internal structures and any malloc()
1713 overhead associated with them. In practice, the byte counts are
1714 underestimated because certain memory usage is very hard to determine
1715 \(e.g. the amount of memory used inside the Xt library or inside the
1716 X server) and because there is other stuff that might logically
1717 be associated with a window, buffer, or frame (e.g. window configurations,
1718 glyphs) but should not obviously be included in the usage counts.
1720 Multiple slices of the total memory usage may be returned, separated
1721 by a nil. Each slice represents a particular view of the memory, a
1722 particular way of partitioning it into groups. Within a slice, there
1723 is no overlap between the groups of memory, and each slice collectively
1724 represents all the memory concerned.
1728 struct buffer_stats stats;
1729 struct overhead_stats ovstats;
1730 Lisp_Object val = Qnil;
1732 CHECK_BUFFER (buffer); /* dead buffers should be allowed, no? */
1734 compute_buffer_usage (XBUFFER (buffer), &stats, &ovstats);
1736 val = acons (Qtext, make_int (stats.text), val);
1737 val = acons (Qmarkers, make_int (stats.markers), val);
1738 val = acons (Qextents, make_int (stats.extents), val);
1739 val = acons (Qother, make_int (stats.other), val);
1740 val = Fcons (Qnil, val);
1741 val = acons (Qactually_requested, make_int (ovstats.was_requested), val);
1742 val = acons (Qmalloc_overhead, make_int (ovstats.malloc_overhead), val);
1743 val = acons (Qgap_overhead, make_int (ovstats.gap_overhead), val);
1744 val = acons (Qdynarr_overhead, make_int (ovstats.dynarr_overhead), val);
1746 return Fnreverse (val);
1749 #endif /* MEMORY_USAGE_STATS */
1752 /************************************************************************/
1753 /* Implement TO_EXTERNAL_FORMAT, TO_INTERNAL_FORMAT */
1754 /************************************************************************/
1756 /* This implementation should probably be elsewhere, but it can't be
1757 in file-coding.c since that file is only available if FILE_CODING
1761 coding_system_is_binary (Lisp_Object coding_system)
1763 Lisp_Coding_System *cs = XCODING_SYSTEM (coding_system);
1765 (CODING_SYSTEM_TYPE (cs) == CODESYS_NO_CONVERSION &&
1766 CODING_SYSTEM_EOL_TYPE (cs) == EOL_LF &&
1767 EQ (CODING_SYSTEM_POST_READ_CONVERSION (cs), Qnil) &&
1768 EQ (CODING_SYSTEM_PRE_WRITE_CONVERSION (cs), Qnil));
1771 #define coding_system_is_binary(coding_system) 1
1776 Dynarr_declare (Bufbyte_dynarr *);
1777 } Bufbyte_dynarr_dynarr;
1781 Dynarr_declare (Extbyte_dynarr *);
1782 } Extbyte_dynarr_dynarr;
1784 static Extbyte_dynarr_dynarr *conversion_out_dynarr_list;
1785 static Bufbyte_dynarr_dynarr *conversion_in_dynarr_list;
1787 static int dfc_convert_to_external_format_in_use;
1788 static int dfc_convert_to_internal_format_in_use;
1791 dfc_convert_to_external_format_reset_in_use (Lisp_Object value)
1793 dfc_convert_to_external_format_in_use = XINT (value);
1798 dfc_convert_to_internal_format_reset_in_use (Lisp_Object value)
1800 dfc_convert_to_internal_format_in_use = XINT (value);
1805 dfc_convert_to_external_format (dfc_conversion_type source_type,
1806 dfc_conversion_data *source,
1808 Lisp_Object coding_system,
1810 dfc_conversion_type sink_type,
1811 dfc_conversion_data *sink)
1813 int count = specpdl_depth ();
1814 Extbyte_dynarr *conversion_out_dynarr;
1816 type_checking_assert
1817 (((source_type == DFC_TYPE_DATA) ||
1818 (source_type == DFC_TYPE_LISP_LSTREAM && LSTREAMP (source->lisp_object)) ||
1819 (source_type == DFC_TYPE_LISP_STRING && STRINGP (source->lisp_object)))
1821 ((sink_type == DFC_TYPE_DATA) ||
1822 (sink_type == DFC_TYPE_LISP_LSTREAM && LSTREAMP (source->lisp_object))));
1824 record_unwind_protect (dfc_convert_to_external_format_reset_in_use,
1825 make_int (dfc_convert_to_external_format_in_use));
1826 if (Dynarr_length (conversion_out_dynarr_list) <=
1827 dfc_convert_to_external_format_in_use)
1828 Dynarr_add (conversion_out_dynarr_list, Dynarr_new (Extbyte));
1829 conversion_out_dynarr = Dynarr_at (conversion_out_dynarr_list,
1830 dfc_convert_to_external_format_in_use);
1831 dfc_convert_to_external_format_in_use++;
1832 Dynarr_reset (conversion_out_dynarr);
1835 coding_system = Fget_coding_system (coding_system);
1838 /* Here we optimize in the case where the coding system does no
1839 conversion. However, we don't want to optimize in case the source
1840 or sink is an lstream, since writing to an lstream can cause a
1841 garbage collection, and this could be problematic if the source
1842 is a lisp string. */
1843 if (source_type != DFC_TYPE_LISP_LSTREAM &&
1844 sink_type != DFC_TYPE_LISP_LSTREAM &&
1845 coding_system_is_binary (coding_system))
1850 if (source_type == DFC_TYPE_LISP_STRING)
1852 ptr = XSTRING_DATA (source->lisp_object);
1853 len = XSTRING_LENGTH (source->lisp_object);
1857 ptr = (Bufbyte *) source->data.ptr;
1858 len = source->data.len;
1864 for (end = ptr + len; ptr < end;)
1868 (*ptr < 0xc0) ? *ptr :
1869 ((*ptr & 0x1f) << 6) | (*(ptr+1) & 0x3f);
1872 (BYTE_ASCII_P (*ptr)) ? *ptr :
1873 (*ptr == LEADING_BYTE_CONTROL_1) ? (*(ptr+1) - 0x20) :
1874 (*ptr == LEADING_BYTE_LATIN_ISO8859_1) ? (*(ptr+1)) :
1878 Dynarr_add (conversion_out_dynarr, (Extbyte) c);
1881 bufpos_checking_assert (ptr == end);
1884 Dynarr_add_many (conversion_out_dynarr, ptr, len);
1890 Lisp_Object streams_to_delete[3];
1891 int delete_count = 0;
1892 Lisp_Object instream, outstream;
1893 Lstream *reader, *writer;
1894 struct gcpro gcpro1, gcpro2;
1896 if (source_type == DFC_TYPE_LISP_LSTREAM)
1897 instream = source->lisp_object;
1898 else if (source_type == DFC_TYPE_DATA)
1899 streams_to_delete[delete_count++] = instream =
1900 make_fixed_buffer_input_stream (source->data.ptr, source->data.len);
1903 type_checking_assert (source_type == DFC_TYPE_LISP_STRING);
1904 streams_to_delete[delete_count++] = instream =
1905 make_lisp_string_input_stream (source->lisp_object, 0, -1);
1908 if (sink_type == DFC_TYPE_LISP_LSTREAM)
1909 outstream = sink->lisp_object;
1912 type_checking_assert (sink_type == DFC_TYPE_DATA);
1913 streams_to_delete[delete_count++] = outstream =
1914 make_dynarr_output_stream
1915 ((unsigned_char_dynarr *) conversion_out_dynarr);
1919 streams_to_delete[delete_count++] = outstream =
1920 make_encoding_output_stream (XLSTREAM (outstream), coding_system);
1923 reader = XLSTREAM (instream);
1924 writer = XLSTREAM (outstream);
1925 /* decoding_stream will gc-protect outstream */
1926 GCPRO2 (instream, outstream);
1930 Lstream_data_count size_in_bytes;
1931 char tempbuf[1024]; /* some random amount */
1933 size_in_bytes = Lstream_read (reader, tempbuf, sizeof (tempbuf));
1935 if (size_in_bytes == 0)
1937 else if (size_in_bytes < 0)
1938 error ("Error converting to external format");
1940 size_in_bytes = Lstream_write (writer, tempbuf, size_in_bytes);
1942 if (size_in_bytes <= 0)
1943 error ("Error converting to external format");
1946 /* Closing writer will close any stream at the other end of writer. */
1947 Lstream_close (writer);
1948 Lstream_close (reader);
1951 /* The idea is that this function will create no garbage. */
1952 while (delete_count)
1953 Lstream_delete (XLSTREAM (streams_to_delete [--delete_count]));
1956 unbind_to (count, Qnil);
1958 if (sink_type != DFC_TYPE_LISP_LSTREAM)
1960 sink->data.len = Dynarr_length (conversion_out_dynarr);
1961 Dynarr_add (conversion_out_dynarr, '\0'); /* NUL-terminate! */
1962 sink->data.ptr = Dynarr_atp (conversion_out_dynarr, 0);
1967 dfc_convert_to_internal_format (dfc_conversion_type source_type,
1968 dfc_conversion_data *source,
1970 Lisp_Object coding_system,
1972 dfc_conversion_type sink_type,
1973 dfc_conversion_data *sink)
1975 int count = specpdl_depth ();
1976 Bufbyte_dynarr *conversion_in_dynarr;
1978 type_checking_assert
1979 ((source_type == DFC_TYPE_DATA ||
1980 source_type == DFC_TYPE_LISP_LSTREAM)
1982 (sink_type == DFC_TYPE_DATA ||
1983 sink_type == DFC_TYPE_LISP_LSTREAM));
1985 record_unwind_protect (dfc_convert_to_internal_format_reset_in_use,
1986 make_int (dfc_convert_to_internal_format_in_use));
1987 if (Dynarr_length (conversion_in_dynarr_list) <=
1988 dfc_convert_to_internal_format_in_use)
1989 Dynarr_add (conversion_in_dynarr_list, Dynarr_new (Bufbyte));
1990 conversion_in_dynarr = Dynarr_at (conversion_in_dynarr_list,
1991 dfc_convert_to_internal_format_in_use);
1992 dfc_convert_to_internal_format_in_use++;
1993 Dynarr_reset (conversion_in_dynarr);
1996 coding_system = Fget_coding_system (coding_system);
1999 if (source_type != DFC_TYPE_LISP_LSTREAM &&
2000 sink_type != DFC_TYPE_LISP_LSTREAM &&
2001 coding_system_is_binary (coding_system))
2004 const Bufbyte *ptr = (const Bufbyte *) source->data.ptr;
2005 Bytecount len = source->data.len;
2006 const Bufbyte *end = ptr + len;
2008 for (; ptr < end; ptr++)
2013 if (BYTE_ASCII_P (c))
2014 Dynarr_add (conversion_in_dynarr, c);
2017 Dynarr_add (conversion_in_dynarr, (c >> 6) | 0xC0);
2018 Dynarr_add (conversion_in_dynarr, (c & 0x3F) | 0x80);
2021 if (BYTE_ASCII_P (c))
2022 Dynarr_add (conversion_in_dynarr, c);
2023 else if (BYTE_C1_P (c))
2025 Dynarr_add (conversion_in_dynarr, LEADING_BYTE_CONTROL_1);
2026 Dynarr_add (conversion_in_dynarr, c + 0x20);
2030 Dynarr_add (conversion_in_dynarr, LEADING_BYTE_LATIN_ISO8859_1);
2031 Dynarr_add (conversion_in_dynarr, c);
2036 Dynarr_add_many (conversion_in_dynarr, source->data.ptr, source->data.len);
2041 Lisp_Object streams_to_delete[3];
2042 int delete_count = 0;
2043 Lisp_Object instream, outstream;
2044 Lstream *reader, *writer;
2045 struct gcpro gcpro1, gcpro2;
2047 if (source_type == DFC_TYPE_LISP_LSTREAM)
2048 instream = source->lisp_object;
2051 type_checking_assert (source_type == DFC_TYPE_DATA);
2052 streams_to_delete[delete_count++] = instream =
2053 make_fixed_buffer_input_stream (source->data.ptr, source->data.len);
2056 if (sink_type == DFC_TYPE_LISP_LSTREAM)
2057 outstream = sink->lisp_object;
2060 type_checking_assert (sink_type == DFC_TYPE_DATA);
2061 streams_to_delete[delete_count++] = outstream =
2062 make_dynarr_output_stream
2063 ((unsigned_char_dynarr *) conversion_in_dynarr);
2067 streams_to_delete[delete_count++] = outstream =
2068 make_decoding_output_stream (XLSTREAM (outstream), coding_system);
2071 reader = XLSTREAM (instream);
2072 writer = XLSTREAM (outstream);
2073 /* outstream will gc-protect its sink stream, if necessary */
2074 GCPRO2 (instream, outstream);
2078 Lstream_data_count size_in_bytes;
2079 char tempbuf[1024]; /* some random amount */
2081 size_in_bytes = Lstream_read (reader, tempbuf, sizeof (tempbuf));
2083 if (size_in_bytes == 0)
2085 else if (size_in_bytes < 0)
2086 error ("Error converting to internal format");
2088 size_in_bytes = Lstream_write (writer, tempbuf, size_in_bytes);
2090 if (size_in_bytes <= 0)
2091 error ("Error converting to internal format");
2094 /* Closing writer will close any stream at the other end of writer. */
2095 Lstream_close (writer);
2096 Lstream_close (reader);
2099 /* The idea is that this function will create no garbage. */
2100 while (delete_count)
2101 Lstream_delete (XLSTREAM (streams_to_delete [--delete_count]));
2104 unbind_to (count, Qnil);
2106 if (sink_type != DFC_TYPE_LISP_LSTREAM)
2108 sink->data.len = Dynarr_length (conversion_in_dynarr);
2109 Dynarr_add (conversion_in_dynarr, '\0'); /* NUL-terminate! */
2110 sink->data.ptr = Dynarr_atp (conversion_in_dynarr, 0);
2116 syms_of_buffer (void)
2118 INIT_LRECORD_IMPLEMENTATION (buffer);
2120 defsymbol (&Qbuffer_live_p, "buffer-live-p");
2121 defsymbol (&Qbuffer_or_string_p, "buffer-or-string-p");
2122 defsymbol (&Qmode_class, "mode-class");
2123 defsymbol (&Qrename_auto_save_file, "rename-auto-save-file");
2124 defsymbol (&Qkill_buffer_hook, "kill-buffer-hook");
2125 defsymbol (&Qpermanent_local, "permanent-local");
2127 defsymbol (&Qfirst_change_hook, "first-change-hook");
2128 defsymbol (&Qbefore_change_functions, "before-change-functions");
2129 defsymbol (&Qafter_change_functions, "after-change-functions");
2131 /* #### Obsolete, for compatibility */
2132 defsymbol (&Qbefore_change_function, "before-change-function");
2133 defsymbol (&Qafter_change_function, "after-change-function");
2135 defsymbol (&Qdefault_directory, "default-directory");
2137 defsymbol (&Qget_file_buffer, "get-file-buffer");
2138 defsymbol (&Qchange_major_mode_hook, "change-major-mode-hook");
2140 defsymbol (&Qfundamental_mode, "fundamental-mode");
2142 defsymbol (&Qfind_file_compare_truenames, "find-file-compare-truenames");
2144 defsymbol (&Qswitch_to_buffer, "switch-to-buffer");
2147 DEFSUBR (Fbuffer_live_p);
2148 DEFSUBR (Fbuffer_list);
2149 DEFSUBR (Fdecode_buffer);
2150 DEFSUBR (Fget_buffer);
2151 DEFSUBR (Fget_file_buffer);
2152 DEFSUBR (Fget_buffer_create);
2153 DEFSUBR (Fmake_indirect_buffer);
2155 DEFSUBR (Fgenerate_new_buffer_name);
2156 DEFSUBR (Fbuffer_name);
2157 DEFSUBR (Fbuffer_file_name);
2158 DEFSUBR (Fbuffer_base_buffer);
2159 DEFSUBR (Fbuffer_indirect_children);
2160 DEFSUBR (Fbuffer_local_variables);
2161 DEFSUBR (Fbuffer_modified_p);
2162 DEFSUBR (Fset_buffer_modified_p);
2163 DEFSUBR (Fbuffer_modified_tick);
2164 DEFSUBR (Frename_buffer);
2165 DEFSUBR (Fother_buffer);
2166 DEFSUBR (Fbuffer_disable_undo);
2167 DEFSUBR (Fbuffer_enable_undo);
2168 DEFSUBR (Fkill_buffer);
2169 DEFSUBR (Ferase_buffer);
2170 DEFSUBR (Frecord_buffer);
2171 DEFSUBR (Fset_buffer_major_mode);
2172 DEFSUBR (Fcurrent_buffer);
2173 DEFSUBR (Fset_buffer);
2174 DEFSUBR (Fbarf_if_buffer_read_only);
2175 DEFSUBR (Fbury_buffer);
2176 DEFSUBR (Fkill_all_local_variables);
2177 #ifdef MEMORY_USAGE_STATS
2178 DEFSUBR (Fbuffer_memory_usage);
2181 DEFERROR (Qprotected_field, "Attempt to modify a protected field",
2186 reinit_vars_of_buffer (void)
2188 conversion_in_dynarr_list = Dynarr_new2 (Bufbyte_dynarr_dynarr,
2190 conversion_out_dynarr_list = Dynarr_new2 (Extbyte_dynarr_dynarr,
2193 staticpro_nodump (&Vbuffer_alist);
2194 Vbuffer_alist = Qnil;
2198 /* initialize the buffer routines */
2200 vars_of_buffer (void)
2202 /* This function can GC */
2203 reinit_vars_of_buffer ();
2205 staticpro (&QSFundamental);
2206 staticpro (&QSscratch);
2208 QSFundamental = build_string ("Fundamental");
2209 QSscratch = build_string (DEFER_GETTEXT ("*scratch*"));
2211 DEFVAR_LISP ("change-major-mode-hook", &Vchange_major_mode_hook /*
2212 List of hooks to be run before killing local variables in a buffer.
2213 This should be used by any mode that temporarily alters the contents or
2214 the read-only state of the buffer. See also `kill-all-local-variables'.
2216 Vchange_major_mode_hook = Qnil;
2218 DEFVAR_BOOL ("find-file-compare-truenames", &find_file_compare_truenames /*
2219 If this is true, then the `find-file' command will check the truenames
2220 of all visited files when deciding whether a given file is already in
2221 a buffer, instead of just `buffer-file-name'. This means that if you
2222 attempt to visit another file which is a symbolic link to a file which
2223 is already in a buffer, the existing buffer will be found instead of a
2224 newly-created one. This works if any component of the pathname
2225 (including a non-terminal component) is a symbolic link as well, but
2226 doesn't work with hard links (nothing does).
2228 See also the variable `find-file-use-truenames'.
2230 #if defined(CYGWIN) || defined(WIN32_NATIVE)
2231 find_file_compare_truenames = 1;
2233 find_file_compare_truenames = 0;
2236 DEFVAR_BOOL ("find-file-use-truenames", &find_file_use_truenames /*
2237 If this is true, then a buffer's visited file-name will always be
2238 chased back to the real file; it will never be a symbolic link, and there
2239 will never be a symbolic link anywhere in its directory path.
2240 That is, the buffer-file-name and buffer-file-truename will be equal.
2241 This doesn't work with hard links.
2243 See also the variable `find-file-compare-truenames'.
2245 find_file_use_truenames = 0;
2247 DEFVAR_LISP ("before-change-functions", &Vbefore_change_functions /*
2248 List of functions to call before each text change.
2249 Two arguments are passed to each function: the positions of
2250 the beginning and end of the range of old text to be changed.
2251 \(For an insertion, the beginning and end are at the same place.)
2252 No information is given about the length of the text after the change.
2254 Buffer changes made while executing the `before-change-functions'
2255 don't call any before-change or after-change functions.
2257 Vbefore_change_functions = Qnil;
2259 /* FSF Emacs has the following additional doc at the end of
2260 before-change-functions and after-change-functions:
2262 That's because these variables are temporarily set to nil.
2263 As a result, a hook function cannot straightforwardly alter the value of
2264 these variables. See the Emacs Lisp manual for a way of
2265 accomplishing an equivalent result by using other variables.
2267 But this doesn't apply under XEmacs because things are
2270 DEFVAR_LISP ("after-change-functions", &Vafter_change_functions /*
2271 List of functions to call after each text change.
2272 Three arguments are passed to each function: the positions of
2273 the beginning and end of the range of changed text,
2274 and the length of the pre-change text replaced by that range.
2275 \(For an insertion, the pre-change length is zero;
2276 for a deletion, that length is the number of characters deleted,
2277 and the post-change beginning and end are at the same place.)
2279 Buffer changes made while executing `after-change-functions'
2280 don't call any before-change or after-change functions.
2282 Vafter_change_functions = Qnil;
2284 DEFVAR_LISP ("before-change-function", &Vbefore_change_function /*
2286 */ ); /* obsoleteness will be documented */
2287 Vbefore_change_function = Qnil;
2289 DEFVAR_LISP ("after-change-function", &Vafter_change_function /*
2291 */ ); /* obsoleteness will be documented */
2292 Vafter_change_function = Qnil;
2294 DEFVAR_LISP ("first-change-hook", &Vfirst_change_hook /*
2295 A list of functions to call before changing a buffer which is unmodified.
2296 The functions are run using the `run-hooks' function.
2298 Vfirst_change_hook = Qnil;
2301 xxDEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode /*
2302 *Non-nil means deactivate the mark when the buffer contents change.
2304 Vtransient_mark_mode = Qnil;
2305 #endif /* FSFmacs */
2307 DEFVAR_INT ("undo-threshold", &undo_threshold /*
2308 Keep no more undo information once it exceeds this size.
2309 This threshold is applied when garbage collection happens.
2310 The size is counted as the number of bytes occupied,
2311 which includes both saved text and other data.
2313 undo_threshold = 20000;
2315 DEFVAR_INT ("undo-high-threshold", &undo_high_threshold /*
2316 Don't keep more than this much size of undo information.
2317 A command which pushes past this size is itself forgotten.
2318 This threshold is applied when garbage collection happens.
2319 The size is counted as the number of bytes occupied,
2320 which includes both saved text and other data.
2322 undo_high_threshold = 30000;
2324 DEFVAR_LISP ("inhibit-read-only", &Vinhibit_read_only /*
2325 *Non-nil means disregard read-only status of buffers or characters.
2326 If the value is t, disregard `buffer-read-only' and all `read-only'
2327 text properties. If the value is a list, disregard `buffer-read-only'
2328 and disregard a `read-only' extent property or text property if the
2329 property value is a member of the list.
2331 Vinhibit_read_only = Qnil;
2333 DEFVAR_LISP ("kill-buffer-query-functions", &Vkill_buffer_query_functions /*
2334 List of functions called with no args to query before killing a buffer.
2336 Vkill_buffer_query_functions = Qnil;
2338 DEFVAR_BOOL ("delete-auto-save-files", &delete_auto_save_files /*
2339 *Non-nil means delete auto-save file when a buffer is saved or killed.
2341 delete_auto_save_files = 1;
2344 /* The docstrings for DEFVAR_* are recorded externally by make-docfile. */
2346 /* Renamed from DEFVAR_PER_BUFFER because FSFmacs D_P_B takes
2347 a bogus extra arg, which confuses an otherwise identical make-docfile.c */
2348 #define DEFVAR_BUFFER_LOCAL_1(lname, field_name, forward_type, magicfun) do { \
2349 static const struct symbol_value_forward I_hate_C = \
2350 { /* struct symbol_value_forward */ \
2351 { /* struct symbol_value_magic */ \
2352 { /* struct lcrecord_header */ \
2353 { /* struct lrecord_header */ \
2354 lrecord_type_symbol_value_forward, /* lrecord_type_index */ \
2356 1, /* c_readonly bit */ \
2357 1 /* lisp_readonly bit */ \
2363 &(buffer_local_flags.field_name), \
2370 int offset = ((char *)symbol_value_forward_forward (&I_hate_C) - \
2371 (char *)&buffer_local_flags); \
2372 defvar_magic (lname, &I_hate_C); \
2374 *((Lisp_Object *)(offset + (char *)XBUFFER (Vbuffer_local_symbols))) \
2379 #define DEFVAR_BUFFER_LOCAL_MAGIC(lname, field_name, magicfun) \
2380 DEFVAR_BUFFER_LOCAL_1 (lname, field_name, \
2381 SYMVAL_CURRENT_BUFFER_FORWARD, magicfun)
2382 #define DEFVAR_BUFFER_LOCAL(lname, field_name) \
2383 DEFVAR_BUFFER_LOCAL_MAGIC (lname, field_name, 0)
2384 #define DEFVAR_CONST_BUFFER_LOCAL_MAGIC(lname, field_name, magicfun) \
2385 DEFVAR_BUFFER_LOCAL_1 (lname, field_name, \
2386 SYMVAL_CONST_CURRENT_BUFFER_FORWARD, magicfun)
2387 #define DEFVAR_CONST_BUFFER_LOCAL(lname, field_name) \
2388 DEFVAR_CONST_BUFFER_LOCAL_MAGIC (lname, field_name, 0)
2390 #define DEFVAR_BUFFER_DEFAULTS_MAGIC(lname, field_name, magicfun) \
2391 DEFVAR_SYMVAL_FWD (lname, &(buffer_local_flags.field_name), \
2392 SYMVAL_DEFAULT_BUFFER_FORWARD, magicfun)
2393 #define DEFVAR_BUFFER_DEFAULTS(lname, field_name) \
2394 DEFVAR_BUFFER_DEFAULTS_MAGIC (lname, field_name, 0)
2397 nuke_all_buffer_slots (struct buffer *b, Lisp_Object zap)
2401 b->extent_info = Qnil;
2402 b->indirect_children = Qnil;
2403 b->own_text.line_number_cache = Qnil;
2405 #define MARKED_SLOT(x) b->x = zap
2406 #include "bufslots.h"
2411 common_init_complex_vars_of_buffer (void)
2413 /* Make sure all markable slots in buffer_defaults
2414 are initialized reasonably, so mark_buffer won't choke. */
2415 struct buffer *defs = alloc_lcrecord_type (struct buffer, &lrecord_buffer);
2416 struct buffer *syms = alloc_lcrecord_type (struct buffer, &lrecord_buffer);
2418 staticpro_nodump (&Vbuffer_defaults);
2419 staticpro_nodump (&Vbuffer_local_symbols);
2420 XSETBUFFER (Vbuffer_defaults, defs);
2421 XSETBUFFER (Vbuffer_local_symbols, syms);
2423 nuke_all_buffer_slots (syms, Qnil);
2424 nuke_all_buffer_slots (defs, Qnil);
2425 defs->text = &defs->own_text;
2426 syms->text = &syms->own_text;
2428 /* Set up the non-nil default values of various buffer slots.
2429 Must do these before making the first buffer. */
2430 defs->major_mode = Qfundamental_mode;
2431 defs->mode_name = QSFundamental;
2432 defs->abbrev_table = Qnil; /* real default setup by Lisp code */
2434 defs->case_table = Vstandard_case_table;
2436 defs->category_table = Vstandard_category_table;
2438 defs->syntax_table = Vstandard_syntax_table;
2440 defs->mirror_syntax_table =
2441 XCHAR_TABLE (Vstandard_syntax_table)->mirror_table;
2443 defs->modeline_format = build_string ("%-"); /* reset in loaddefs.el */
2444 defs->case_fold_search = Qt;
2445 defs->selective_display_ellipses = Qt;
2446 defs->tab_width = make_int (8);
2447 defs->ctl_arrow = Qt;
2448 defs->fill_column = make_int (70);
2449 defs->left_margin = Qzero;
2450 defs->saved_size = Qzero; /* lisp code wants int-or-nil */
2452 defs->auto_save_modified = 0;
2453 defs->auto_save_failure_time = -1;
2454 defs->invisibility_spec = Qt;
2455 defs->buffer_local_face_property = 0;
2457 defs->indirect_children = Qnil;
2458 syms->indirect_children = Qnil;
2461 /* 0 means var is always local. Default used only at creation.
2462 * -1 means var is always local. Default used only at reset and
2464 * -2 means there's no lisp variable corresponding to this slot
2465 * and the default is only used at creation.
2466 * -3 means no Lisp variable. Default used only at reset and creation.
2467 * >0 is mask. Var is local if ((buffer->local_var_flags & mask) != 0)
2468 * Otherwise default is used.
2470 Lisp_Object always_local_no_default = make_int (0);
2471 Lisp_Object always_local_resettable = make_int (-1);
2472 Lisp_Object resettable = make_int (-3);
2474 /* Assign the local-flags to the slots that have default values.
2475 The local flag is a bit that is used in the buffer
2476 to say that it has its own local value for the slot.
2477 The local flag bits are in the local_var_flags slot of the
2480 nuke_all_buffer_slots (&buffer_local_flags, make_int (-2));
2481 buffer_local_flags.filename = always_local_no_default;
2482 buffer_local_flags.directory = always_local_no_default;
2483 buffer_local_flags.backed_up = always_local_no_default;
2484 buffer_local_flags.saved_size = always_local_no_default;
2485 buffer_local_flags.auto_save_file_name = always_local_no_default;
2486 buffer_local_flags.read_only = always_local_no_default;
2488 buffer_local_flags.major_mode = always_local_resettable;
2489 buffer_local_flags.mode_name = always_local_resettable;
2490 buffer_local_flags.undo_list = always_local_no_default;
2492 buffer_local_flags.mark_active = always_local_resettable;
2494 buffer_local_flags.point_before_scroll = always_local_resettable;
2495 buffer_local_flags.file_truename = always_local_no_default;
2496 buffer_local_flags.invisibility_spec = always_local_resettable;
2497 buffer_local_flags.file_format = always_local_resettable;
2498 buffer_local_flags.generated_modeline_string = always_local_no_default;
2500 buffer_local_flags.keymap = resettable;
2501 buffer_local_flags.case_table = resettable;
2502 buffer_local_flags.syntax_table = resettable;
2504 buffer_local_flags.category_table = resettable;
2507 buffer_local_flags.modeline_format = make_int (1<<0);
2508 buffer_local_flags.abbrev_mode = make_int (1<<1);
2509 buffer_local_flags.overwrite_mode = make_int (1<<2);
2510 buffer_local_flags.case_fold_search = make_int (1<<3);
2511 buffer_local_flags.auto_fill_function = make_int (1<<4);
2512 buffer_local_flags.selective_display = make_int (1<<5);
2513 buffer_local_flags.selective_display_ellipses = make_int (1<<6);
2514 buffer_local_flags.tab_width = make_int (1<<7);
2515 buffer_local_flags.truncate_lines = make_int (1<<8);
2516 buffer_local_flags.ctl_arrow = make_int (1<<9);
2517 buffer_local_flags.fill_column = make_int (1<<10);
2518 buffer_local_flags.left_margin = make_int (1<<11);
2519 buffer_local_flags.abbrev_table = make_int (1<<12);
2520 #ifdef REGION_CACHE_NEEDS_WORK
2521 buffer_local_flags.cache_long_line_scans = make_int (1<<13);
2524 buffer_local_flags.buffer_file_coding_system = make_int (1<<14);
2527 /* #### Warning: 1<<31 is the largest number currently allowable
2528 due to the XINT() handling of this value. With some
2529 rearrangement you can get 3 more bits.
2531 #### 3 more? 34 bits???? -ben */
2535 #define BUFFER_SLOTS_SIZE (offsetof (struct buffer, BUFFER_SLOTS_LAST_NAME) - offsetof (struct buffer, BUFFER_SLOTS_FIRST_NAME) + sizeof (Lisp_Object))
2536 #define BUFFER_SLOTS_COUNT (BUFFER_SLOTS_SIZE / sizeof (Lisp_Object))
2539 reinit_complex_vars_of_buffer (void)
2541 struct buffer *defs, *syms;
2543 common_init_complex_vars_of_buffer ();
2545 defs = XBUFFER (Vbuffer_defaults);
2546 syms = XBUFFER (Vbuffer_local_symbols);
2547 memcpy (&defs->BUFFER_SLOTS_FIRST_NAME,
2548 buffer_defaults_saved_slots,
2550 memcpy (&syms->BUFFER_SLOTS_FIRST_NAME,
2551 buffer_local_symbols_saved_slots,
2556 static const struct lrecord_description buffer_slots_description_1[] = {
2557 { XD_LISP_OBJECT_ARRAY, 0, BUFFER_SLOTS_COUNT },
2561 static const struct struct_description buffer_slots_description = {
2563 buffer_slots_description_1
2567 complex_vars_of_buffer (void)
2569 struct buffer *defs, *syms;
2571 common_init_complex_vars_of_buffer ();
2573 defs = XBUFFER (Vbuffer_defaults);
2574 syms = XBUFFER (Vbuffer_local_symbols);
2575 buffer_defaults_saved_slots = &defs->BUFFER_SLOTS_FIRST_NAME;
2576 buffer_local_symbols_saved_slots = &syms->BUFFER_SLOTS_FIRST_NAME;
2577 dump_add_root_struct_ptr (&buffer_defaults_saved_slots, &buffer_slots_description);
2578 dump_add_root_struct_ptr (&buffer_local_symbols_saved_slots, &buffer_slots_description);
2580 DEFVAR_BUFFER_DEFAULTS ("default-modeline-format", modeline_format /*
2581 Default value of `modeline-format' for buffers that don't override it.
2582 This is the same as (default-value 'modeline-format).
2585 DEFVAR_BUFFER_DEFAULTS ("default-abbrev-mode", abbrev_mode /*
2586 Default value of `abbrev-mode' for buffers that do not override it.
2587 This is the same as (default-value 'abbrev-mode).
2590 DEFVAR_BUFFER_DEFAULTS ("default-ctl-arrow", ctl_arrow /*
2591 Default value of `ctl-arrow' for buffers that do not override it.
2592 This is the same as (default-value 'ctl-arrow).
2595 #if 0 /* #### make this a specifier! */
2596 DEFVAR_BUFFER_DEFAULTS ("default-display-direction", display_direction /*
2597 Default display-direction for buffers that do not override it.
2598 This is the same as (default-value 'display-direction).
2599 Note: This is not yet implemented.
2603 DEFVAR_BUFFER_DEFAULTS ("default-truncate-lines", truncate_lines /*
2604 Default value of `truncate-lines' for buffers that do not override it.
2605 This is the same as (default-value 'truncate-lines).
2608 DEFVAR_BUFFER_DEFAULTS ("default-fill-column", fill_column /*
2609 Default value of `fill-column' for buffers that do not override it.
2610 This is the same as (default-value 'fill-column).
2613 DEFVAR_BUFFER_DEFAULTS ("default-left-margin", left_margin /*
2614 Default value of `left-margin' for buffers that do not override it.
2615 This is the same as (default-value 'left-margin).
2618 DEFVAR_BUFFER_DEFAULTS ("default-tab-width", tab_width /*
2619 Default value of `tab-width' for buffers that do not override it.
2620 This is the same as (default-value 'tab-width).
2623 DEFVAR_BUFFER_DEFAULTS ("default-case-fold-search", case_fold_search /*
2624 Default value of `case-fold-search' for buffers that don't override it.
2625 This is the same as (default-value 'case-fold-search).
2628 DEFVAR_BUFFER_LOCAL ("modeline-format", modeline_format /*
2629 Template for displaying modeline for current buffer.
2630 Each buffer has its own value of this variable.
2631 Value may be a string, symbol, glyph, generic specifier, list or cons cell.
2632 For a symbol, its value is processed (but it is ignored if t or nil).
2633 A string appearing directly as the value of a symbol is processed verbatim
2634 in that the %-constructs below are not recognized.
2635 For a glyph, it is inserted as is.
2636 For a generic specifier (i.e. a specifier of type `generic'), its instance
2637 is computed in the current window using the equivalent of `specifier-instance'
2638 and the value is processed.
2639 For a list whose car is a symbol, the symbol's value is taken,
2640 and if that is non-nil, the cadr of the list is processed recursively.
2641 Otherwise, the caddr of the list (if there is one) is processed.
2642 For a list whose car is a string or list, each element is processed
2643 recursively and the results are effectively concatenated.
2644 For a list whose car is an integer, the cdr of the list is processed
2645 and padded (if the number is positive) or truncated (if negative)
2646 to the width specified by that number.
2647 For a list whose car is an extent, the cdr of the list is processed
2648 normally but the results are displayed using the face of the
2649 extent, and mouse clicks over this section are processed using the
2650 keymap of the extent. (In addition, if the extent has a help-echo
2651 property, that string will be echoed when the mouse moves over this
2652 section.) If extents are nested, all keymaps are properly consulted
2653 when processing mouse clicks, but multiple faces are not correctly
2654 merged (only the first face is used), and lists of faces are not
2655 correctly handled. See `generated-modeline-string' for more information.
2656 A string is printed verbatim in the modeline except for %-constructs:
2657 (%-constructs are processed when the string is the entire modeline-format
2658 or when it is found in a cons-cell or a list)
2659 %b -- print buffer name. %c -- print the current column number.
2660 %f -- print visited file name.
2661 %* -- print %, * or hyphen. %+ -- print *, % or hyphen.
2662 % means buffer is read-only and * means it is modified.
2663 For a modified read-only buffer, %* gives % and %+ gives *.
2664 %s -- print process status. %l -- print the current line number.
2665 %S -- print name of selected frame (only meaningful under X Windows).
2666 %p -- print percent of buffer above top of window, or Top, Bot or All.
2667 %P -- print percent of buffer above bottom of window, perhaps plus Top,
2668 or print Bottom or All.
2669 %n -- print Narrow if appropriate.
2670 %C -- under XEmacs/mule, print the mnemonic for `buffer-file-coding-system'.
2671 %[ -- print one [ for each recursive editing level. %] similar.
2672 %% -- print %. %- -- print infinitely many dashes.
2673 Decimal digits after the % specify field width to which to pad.
2676 DEFVAR_BUFFER_DEFAULTS ("default-major-mode", major_mode /*
2677 *Major mode for new buffers. Defaults to `fundamental-mode'.
2678 nil here means use current buffer's major mode.
2681 DEFVAR_BUFFER_DEFAULTS ("fundamental-mode-abbrev-table", abbrev_table /*
2682 The abbrev table of mode-specific abbrevs for Fundamental Mode.
2685 DEFVAR_BUFFER_LOCAL ("major-mode", major_mode /*
2686 Symbol for current buffer's major mode.
2689 DEFVAR_BUFFER_LOCAL ("mode-name", mode_name /*
2690 Pretty name of current buffer's major mode (a string).
2693 DEFVAR_BUFFER_LOCAL ("abbrev-mode", abbrev_mode /*
2694 Non-nil turns on automatic expansion of abbrevs as they are inserted.
2695 Automatically becomes buffer-local when set in any fashion.
2698 DEFVAR_BUFFER_LOCAL ("case-fold-search", case_fold_search /*
2699 *Non-nil if searches should ignore case.
2700 Automatically becomes buffer-local when set in any fashion.
2703 DEFVAR_BUFFER_LOCAL ("fill-column", fill_column /*
2704 *Column beyond which automatic line-wrapping should happen.
2705 Automatically becomes buffer-local when set in any fashion.
2708 DEFVAR_BUFFER_LOCAL ("left-margin", left_margin /*
2709 *Column for the default indent-line-function to indent to.
2710 Linefeed indents to this column in Fundamental mode.
2711 Automatically becomes buffer-local when set in any fashion.
2712 Do not confuse this with the specifier `left-margin-width';
2713 that controls the size of a margin that is displayed outside
2717 DEFVAR_BUFFER_LOCAL_MAGIC ("tab-width", tab_width /*
2718 *Distance between tab stops (for display of tab characters), in columns.
2719 Automatically becomes buffer-local when set in any fashion.
2720 */ , redisplay_variable_changed);
2722 DEFVAR_BUFFER_LOCAL_MAGIC ("ctl-arrow", ctl_arrow /*
2723 *Non-nil means display control chars with uparrow.
2724 Nil means use backslash and octal digits.
2725 An integer means characters >= ctl-arrow are assumed to be printable, and
2726 will be displayed as a single glyph.
2727 Any other value is the same as 160 - the code SPC with the high bit on.
2729 The interpretation of this variable is likely to change in the future.
2731 Automatically becomes buffer-local when set in any fashion.
2732 This variable does not apply to characters whose display is specified
2733 in the current display table (if there is one).
2734 */ , redisplay_variable_changed);
2736 #if 0 /* #### Make this a specifier! */
2737 xxDEFVAR_BUFFER_LOCAL ("display-direction", display_direction /*
2738 *Non-nil means lines in the buffer are displayed right to left.
2739 Nil means left to right. (Not yet implemented.)
2741 #endif /* Not yet implemented */
2743 DEFVAR_BUFFER_LOCAL_MAGIC ("truncate-lines", truncate_lines /*
2744 *Non-nil means do not display continuation lines;
2745 give each line of text one frame line.
2746 Automatically becomes buffer-local when set in any fashion.
2748 Note that this is overridden by the variable
2749 `truncate-partial-width-windows' if that variable is non-nil
2750 and this buffer is not full-frame width.
2751 */ , redisplay_variable_changed);
2753 DEFVAR_BUFFER_LOCAL ("default-directory", directory /*
2754 Name of default directory of current buffer. Should end with slash.
2755 Each buffer has its own value of this variable.
2759 DEFVAR_BUFFER_DEFAULTS ("default-buffer-file-coding-system", buffer_file_coding_system /*
2760 Default value of `buffer-file-coding-system' for buffers that do not override it.
2761 This is the same as (default-value 'buffer-file-coding-system).
2762 This value is used both for buffers without associated files and
2763 for buffers whose files do not have any apparent coding system.
2764 See `buffer-file-coding-system'.
2767 DEFVAR_BUFFER_LOCAL ("buffer-file-coding-system", buffer_file_coding_system /*
2768 *Current coding system for the current buffer.
2769 When the buffer is written out into a file, this coding system will be
2770 used for the encoding. Automatically buffer-local when set in any
2771 fashion. This is normally set automatically when a file is loaded in
2772 based on the determined coding system of the file (assuming that
2773 `buffer-file-coding-system-for-read' is set to `undecided', which
2774 calls for automatic determination of the file's coding system).
2775 Normally the modeline indicates the current file coding system using
2776 its mnemonic abbreviation.
2778 The default value for this variable (which is normally used for
2779 buffers without associated files) is also used when automatic
2780 detection of a file's encoding is called for and there was no
2781 discernible encoding in the file (i.e. it was entirely or almost
2782 entirely ASCII). The default value should generally *not* be set to
2783 nil (equivalent to `no-conversion'), because if extended characters
2784 are ever inserted into the buffer, they will be lost when the file is
2785 written out. A good choice is `iso-2022-8' (the simple ISO 2022 8-bit
2786 encoding), which will write out ASCII and Latin-1 characters in the
2787 standard (and highly portable) fashion and use standard escape
2788 sequences for other charsets. Another reasonable choice is
2789 `escape-quoted', which is equivalent to `iso-2022-8' but prefixes
2790 certain control characters with ESC to make sure they are not
2791 interpreted as escape sequences when read in. This latter coding
2792 system results in more "correct" output in the presence of control
2793 characters in the buffer, in the sense that when read in again using
2794 the same coding system, the result will virtually always match the
2795 original contents of the buffer, which is not the case with
2796 `iso-2022-8'; but the output is less portable when dealing with binary
2797 data -- there may be stray ESC characters when the file is read by
2800 `buffer-file-coding-system' does *not* control the coding system used when
2801 a file is read in. Use the variables `buffer-file-coding-system-for-read'
2802 and `buffer-file-coding-system-alist' for that. From a Lisp program, if
2803 you wish to unilaterally specify the coding system used for one
2804 particular operation, you should bind the variable
2805 `coding-system-for-read' rather than changing the other two
2806 variables just mentioned, which are intended to be used for
2807 global environment specification.
2809 #endif /* FILE_CODING */
2811 DEFVAR_BUFFER_LOCAL ("auto-fill-function", auto_fill_function /*
2812 Function called (if non-nil) to perform auto-fill.
2813 It is called after self-inserting a space at a column beyond `fill-column'.
2814 Each buffer has its own value of this variable.
2815 NOTE: This variable is not an ordinary hook;
2816 It may not be a list of functions.
2819 DEFVAR_BUFFER_LOCAL ("buffer-file-name", filename /*
2820 Name of file visited in current buffer, or nil if not visiting a file.
2821 Each buffer has its own value of this variable.
2826 Abbreviated truename of file visited in current buffer, or nil if none.
2827 The truename of a file is calculated by `file-truename'
2828 and then abbreviated with `abbreviate-file-name'.
2829 Each buffer has its own value of this variable.
2831 #endif /* FSFmacs */
2833 DEFVAR_BUFFER_LOCAL ("buffer-file-truename", file_truename /*
2834 The real name of the file visited in the current buffer,
2835 or nil if not visiting a file. This is the result of passing
2836 buffer-file-name to the `file-truename' function. Every buffer has
2837 its own value of this variable. This variable is automatically
2838 maintained by the functions that change the file name associated
2842 DEFVAR_BUFFER_LOCAL ("buffer-auto-save-file-name", auto_save_file_name /*
2843 Name of file for auto-saving current buffer,
2844 or nil if buffer should not be auto-saved.
2845 Each buffer has its own value of this variable.
2848 DEFVAR_BUFFER_LOCAL ("buffer-read-only", read_only /*
2849 Non-nil if this buffer is read-only.
2850 Each buffer has its own value of this variable.
2853 DEFVAR_BUFFER_LOCAL ("buffer-backed-up", backed_up /*
2854 Non-nil if this buffer's file has been backed up.
2855 Backing up is done before the first time the file is saved.
2856 Each buffer has its own value of this variable.
2859 DEFVAR_BUFFER_LOCAL ("buffer-saved-size", saved_size /*
2860 Length of current buffer when last read in, saved or auto-saved.
2862 Each buffer has its own value of this variable.
2865 DEFVAR_BUFFER_LOCAL_MAGIC ("selective-display", selective_display /*
2866 Non-nil enables selective display:
2867 Integer N as value means display only lines
2868 that start with less than n columns of space.
2869 A value of t means, after a ^M, all the rest of the line is invisible.
2870 Then ^M's in the file are written into files as newlines.
2872 Automatically becomes buffer-local when set in any fashion.
2873 */, redisplay_variable_changed);
2876 DEFVAR_BUFFER_LOCAL_MAGIC ("selective-display-ellipses",
2877 selective_display_ellipses /*
2878 t means display ... on previous line when a line is invisible.
2879 Automatically becomes buffer-local when set in any fashion.
2880 */, redisplay_variable_changed);
2883 DEFVAR_BUFFER_LOCAL ("local-abbrev-table", abbrev_table /*
2884 Local (mode-specific) abbrev table of current buffer.
2887 DEFVAR_BUFFER_LOCAL ("overwrite-mode", overwrite_mode /*
2888 Non-nil if self-insertion should replace existing text.
2889 The value should be one of `overwrite-mode-textual',
2890 `overwrite-mode-binary', or nil.
2891 If it is `overwrite-mode-textual', self-insertion still
2892 inserts at the end of a line, and inserts when point is before a tab,
2893 until the tab is filled in.
2894 If `overwrite-mode-binary', self-insertion replaces newlines and tabs too.
2895 Automatically becomes buffer-local when set in any fashion.
2897 Normally, you shouldn't modify this variable by hand, but use the functions
2898 `overwrite-mode' and `binary-overwrite-mode' instead. However, you can
2899 customize the default value from the options menu.
2903 /* Adds the following to the doc string for buffer-undo-list:
2905 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
2906 was modified between BEG and END. PROPERTY is the property name,
2907 and VALUE is the old value.
2909 #endif /* FSFmacs */
2911 DEFVAR_BUFFER_LOCAL ("buffer-undo-list", undo_list /*
2912 List of undo entries in current buffer.
2913 Recent changes come first; older changes follow newer.
2915 An entry (START . END) represents an insertion which begins at
2916 position START and ends at position END.
2918 An entry (TEXT . POSITION) represents the deletion of the string TEXT
2919 from (abs POSITION). If POSITION is positive, point was at the front
2920 of the text being deleted; if negative, point was at the end.
2922 An entry (t HIGH . LOW) indicates that the buffer previously had
2923 "unmodified" status. HIGH and LOW are the high and low 16-bit portions
2924 of the visited file's modification time, as of that time. If the
2925 modification time of the most recent save is different, this entry is
2928 An entry of the form EXTENT indicates that EXTENT was attached in
2929 the buffer. Undoing an entry of this form detaches EXTENT.
2931 An entry of the form (EXTENT START END) indicates that EXTENT was
2932 detached from the buffer. Undoing an entry of this form attaches
2933 EXTENT from START to END.
2935 An entry of the form POSITION indicates that point was at the buffer
2936 location given by the integer. Undoing an entry of this form places
2939 nil marks undo boundaries. The undo command treats the changes
2940 between two undo boundaries as a single step to be undone.
2942 If the value of the variable is t, undo information is not recorded.
2946 xxDEFVAR_BUFFER_LOCAL ("mark-active", mark_active /*
2947 Non-nil means the mark and region are currently active in this buffer.
2948 Automatically local in all buffers.
2950 #endif /* FSFmacs */
2952 #ifdef REGION_CACHE_NEEDS_WORK
2953 xxDEFVAR_BUFFER_LOCAL ("cache-long-line-scans", cache_long_line_scans /*
2954 Non-nil means that Emacs should use caches to handle long lines more quickly.
2955 This variable is buffer-local, in all buffers.
2957 Normally, the line-motion functions work by scanning the buffer for
2958 newlines. Columnar operations (like move-to-column and
2959 compute-motion) also work by scanning the buffer, summing character
2960 widths as they go. This works well for ordinary text, but if the
2961 buffer's lines are very long (say, more than 500 characters), these
2962 motion functions will take longer to execute. Emacs may also take
2963 longer to update the display.
2965 If cache-long-line-scans is non-nil, these motion functions cache the
2966 results of their scans, and consult the cache to avoid rescanning
2967 regions of the buffer until the text is modified. The caches are most
2968 beneficial when they prevent the most searching---that is, when the
2969 buffer contains long lines and large regions of characters with the
2970 same, fixed screen width.
2972 When cache-long-line-scans is non-nil, processing short lines will
2973 become slightly slower (because of the overhead of consulting the
2974 cache), and the caches will use memory roughly proportional to the
2975 number of newlines and characters whose screen width varies.
2977 The caches require no explicit maintenance; their accuracy is
2978 maintained internally by the Emacs primitives. Enabling or disabling
2979 the cache should not affect the behavior of any of the motion
2980 functions; it should only affect their performance.
2982 #endif /* REGION_CACHE_NEEDS_WORK */
2984 DEFVAR_BUFFER_LOCAL ("point-before-scroll", point_before_scroll /*
2985 Value of point before the last series of scroll operations, or nil.
2988 DEFVAR_BUFFER_LOCAL ("buffer-file-format", file_format /*
2989 List of formats to use when saving this buffer.
2990 Formats are defined by `format-alist'. This variable is
2991 set when a file is visited. Automatically local in all buffers.
2994 DEFVAR_BUFFER_LOCAL_MAGIC ("buffer-invisibility-spec", invisibility_spec /*
2995 Invisibility spec of this buffer.
2996 The default is t, which means that text is invisible
2997 if it has (or is covered by an extent with) a non-nil `invisible' property.
2998 If the value is a list, a text character is invisible if its `invisible'
2999 property is an element in that list.
3000 If an element is a cons cell of the form (PROPERTY . ELLIPSIS),
3001 then characters with property value PROPERTY are invisible,
3002 and they have an ellipsis as well if ELLIPSIS is non-nil.
3003 Note that the actual characters used for the ellipsis are controllable
3004 using `invisible-text-glyph', and default to "...".
3005 */, redisplay_variable_changed);
3007 DEFVAR_CONST_BUFFER_LOCAL ("generated-modeline-string",
3008 generated_modeline_string /*
3009 String of characters in this buffer's modeline as of the last redisplay.
3010 Each time the modeline is recomputed, the resulting characters are
3011 stored in this string, which is resized as necessary. You may not
3012 set this variable, and modifying this string will not change the
3013 modeline; you have to change `modeline-format' if you want that.
3015 For each extent in `modeline-format' that is encountered when
3016 processing the modeline, a corresponding extent is placed in
3017 `generated-modeline-string' and covers the text over which the
3018 extent in `modeline-format' applies. The extent in
3019 `generated-modeline-string' is made a child of the extent in
3020 `modeline-format', which means that it inherits all properties from
3021 that extent. Note that the extents in `generated-modeline-string'
3022 are managed automatically. You should not explicitly put any extents
3023 in `generated-modeline-string'; if you do, they will disappear the
3024 next time the modeline is processed.
3026 For extents in `modeline-format', the following properties are currently
3030 Affects the face of the modeline text. Currently, faces do
3031 not merge properly; only the most recently encountered face
3032 is used. This is a bug.
3035 Affects the disposition of button events over the modeline
3036 text. Multiple applicable keymaps *are* handled properly,
3037 and `modeline-map' still applies to any events that don't
3038 have bindings in extent-specific keymaps.
3041 If a string, causes the string to be displayed when the mouse
3042 moves over the text.
3045 /* Check for DEFVAR_BUFFER_LOCAL without initializing the corresponding
3046 slot of buffer_local_flags and vice-versa. Must be done after all
3047 DEFVAR_BUFFER_LOCAL() calls. */
3048 #define MARKED_SLOT(slot) \
3049 if ((XINT (buffer_local_flags.slot) != -2 && \
3050 XINT (buffer_local_flags.slot) != -3) \
3051 != !(NILP (XBUFFER (Vbuffer_local_symbols)->slot))) \
3053 #include "bufslots.h"
3057 Lisp_Object scratch = Fget_buffer_create (QSscratch);
3058 Fset_buffer (scratch);
3059 /* Want no undo records for *scratch* until after Emacs is dumped */
3060 Fbuffer_disable_undo (scratch);
3064 #ifndef WIN32_NATIVE
3065 /* Is PWD another name for `.' ? */
3067 directory_is_current_directory (Extbyte *pwd)
3069 Bufbyte *pwd_internal;
3070 Bytecount pwd_internal_len;
3071 struct stat dotstat, pwdstat;
3073 TO_INTERNAL_FORMAT (DATA, (pwd, strlen ((char *)pwd) + 1),
3074 ALLOCA, (pwd_internal, pwd_internal_len),
3077 return (IS_DIRECTORY_SEP (*pwd_internal)
3078 && xemacs_stat ((char *) pwd_internal, &pwdstat) == 0
3079 && xemacs_stat (".", &dotstat) == 0
3080 && dotstat.st_ino == pwdstat.st_ino
3081 && dotstat.st_dev == pwdstat.st_dev
3082 && pwd_internal_len < MAXPATHLEN);
3087 init_initial_directory (void)
3089 /* This function can GC */
3091 #ifndef WIN32_NATIVE
3095 initial_directory[0] = 0;
3097 /* If PWD is accurate, use it instead of calling getcwd. This is faster
3098 when PWD is right, and may avoid a fatal error. */
3099 #ifndef WIN32_NATIVE
3100 if ((pwd = (Extbyte *) getenv ("PWD")) != NULL
3101 && directory_is_current_directory (pwd))
3102 strcpy (initial_directory, (char *) pwd);
3105 if (getcwd (initial_directory, MAXPATHLEN) == NULL)
3106 fatal ("`getcwd' failed: %s\n", strerror (errno));
3108 /* Make sure pwd is DIRECTORY_SEP-terminated.
3109 Maybe this should really use some standard subroutine
3110 whose definition is filename syntax dependent. */
3112 int len = strlen (initial_directory);
3114 if (! IS_DIRECTORY_SEP (initial_directory[len - 1]))
3116 initial_directory[len] = DIRECTORY_SEP;
3117 initial_directory[len + 1] = '\0';
3121 #ifdef CORRECT_DIR_SEPS
3122 CORRECT_DIR_SEPS (initial_directory);
3129 /* This function can GC */
3131 Fset_buffer (Fget_buffer_create (QSscratch));
3133 current_buffer->directory =
3134 build_ext_string (initial_directory, Qfile_name);
3137 /* #### is this correct? */
3138 temp = get_minibuffer (0);
3139 XBUFFER (temp)->directory = current_buffer->directory;
3140 #endif /* FSFmacs */