xemacs-beta: src/buffer.c comparison

comparison src/buffer.c @ 272:c5d627a313b1 r21-0b34

Import from CVS: tag r21-0b34

author	cvs
date	Mon, 13 Aug 2007 10:28:48 +0200
parents	405dd6d1825b
children	6330739388db

comparison

equal deleted inserted replaced

-:c7b7086b0a39
+:c5d627a313b1
 #include "insdel.h"
 #include "process.h"            /* for kill_buffer_processes */
 #ifdef REGION_CACHE_NEEDS_WORK
 #include "region-cache.h"
 #endif
-#include "symeval.h"
 #include "syntax.h"
 #include "sysdep.h"	/* for getwd */
 #include "window.h"
 #include "sysfile.h"
 Setting the default value also goes through the alist of buffers
 and stores into each buffer that does not say it has a local value.  */
 Lisp_Object Vbuffer_defaults;
 /* This structure marks which slots in a buffer have corresponding
-default values in buffer_defaults.
+default values in Vbuffer_defaults.
 Each such slot has a nonzero value in this structure.
 The value has only one nonzero bit.
 When a buffer has its own local value for a slot,
 the bit for that slot (found in the same slot in this structure)
 is turned on in the buffer's local_var_flags slot.
 If a slot in this structure is 0, then there is a DEFVAR_BUFFER_LOCAL
 for the slot, but there is no default value for it; the corresponding
-slot in buffer_defaults is not used except to initialize newly-created
+slot in Vbuffer_defaults is not used except to initialize newly-created
 buffers.
 If a slot is -1, then there is a DEFVAR_BUFFER_LOCAL for it
 as well as a default value which is used to initialize newly-created
 buffers and as a reset-value when local-vars are killed.
 (The slot is always local, but there's no lisp variable for it.)
 The default value is only used to initialize newly-creation buffers.
 If a slot is -3, then there is no DEFVAR_BUFFER_LOCAL for it but
 there is a default which is used to initialize newly-creation
-buffers and as a reset-value when local-vars are killed.
+buffers and as a reset-value when local-vars are killed.  */
-*/
 struct buffer buffer_local_flags;
 /* This structure holds the names of symbols whose values may be
 buffer-local.  It is indexed and accessed in the same way as the above. */
 static Lisp_Object Vbuffer_local_symbols;
 int find_file_use_truenames;
 static void reset_buffer_local_variables (struct buffer *, int first_time);
 static void nuke_all_buffer_slots (struct buffer *b, Lisp_Object zap);
-static Lisp_Object mark_buffer (Lisp_Object, void (*) (Lisp_Object));
-static void print_buffer (Lisp_Object, Lisp_Object, int);
+Lisp_Object
+make_buffer (struct buffer *buf)
+{
+Lisp_Object obj;
+XSETBUFFER (obj, buf);
+return obj;
+}
+static Lisp_Object
+mark_buffer (Lisp_Object obj, void (*markobj) (Lisp_Object))
+{
+struct buffer *buf = XBUFFER (obj);
+/* Truncate undo information. */
+buf->undo_list = truncate_undo_list (buf->undo_list,
+undo_threshold,
+undo_high_threshold);
+#define MARKED_SLOT(x) ((markobj) (buf->x));
+#include "bufslots.h"
+#undef MARKED_SLOT
+((markobj) (buf->extent_info));
+/* Don't mark normally through the children slot.
+(Actually, in this case, it doesn't matter.)  */
+if (! EQ (buf->indirect_children, Qnull_pointer))
+mark_conses_in_list (buf->indirect_children);
+return buf->base_buffer ? make_buffer (buf->base_buffer) : Qnil;
+}
+static void
+print_buffer (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
+{
+struct buffer *b = XBUFFER (obj);
+if (print_readably)
+{
+if (!BUFFER_LIVE_P (b))
+	error ("printing unreadable object #<killed buffer>");
+else
+	error ("printing unreadable object #<buffer %s>",
+	       XSTRING_DATA (b->name));
+}
+else if (!BUFFER_LIVE_P (b))
+write_c_string ("#<killed buffer>", printcharfun);
+else if (escapeflag)
+{
+write_c_string ("#<buffer ", printcharfun);
+print_internal (b->name, printcharfun, 1);
+write_c_string (">", printcharfun);
+}
+else
+{
+print_internal (b->name, printcharfun, 0);
+}
+}
 /* We do not need a finalize method to handle a buffer's children list
 because all buffers have `kill-buffer' applied to them before
 they disappear, and the children removal happens then. */
 DEFINE_LRECORD_IMPLEMENTATION ("buffer", buffer,
 mark_buffer, print_buffer, 0, 0, 0,
 			       struct buffer);
-Lisp_Object
-make_buffer (struct buffer *buf)
-{
-Lisp_Object obj;
-XSETBUFFER (obj, buf);
-return obj;
-}
-static Lisp_Object
-mark_buffer (Lisp_Object obj, void (*markobj) (Lisp_Object))
-{
-struct buffer *buf = XBUFFER (obj);
-/* Truncate undo information. */
-buf->undo_list = truncate_undo_list (buf->undo_list,
-undo_threshold,
-undo_high_threshold);
-#define MARKED_SLOT(x) ((markobj) (buf->x));
-#include "bufslots.h"
-#undef MARKED_SLOT
-((markobj) (buf->extent_info));
-/* Don't mark normally through the children slot.
-(Actually, in this case, it doesn't matter.)
-*/
-if (! EQ (buf->indirect_children, Qnull_pointer))
-mark_conses_in_list (buf->indirect_children);
-if (buf->base_buffer)
-{
-Lisp_Object base_buf_obj = Qnil;
-XSETBUFFER (base_buf_obj, buf->base_buffer);
-return base_buf_obj;
-}
-else
-return Qnil;
-}
-static void
-print_buffer (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
-{
-struct buffer *b = XBUFFER (obj);
-if (print_readably)
-{
-if (!BUFFER_LIVE_P (b))
-	error ("printing unreadable object #<killed buffer>");
-else
-	error ("printing unreadable object #<buffer %s>",
-	       XSTRING_DATA (b->name));
-}
-else if (!BUFFER_LIVE_P (b))
-write_c_string ("#<killed buffer>", printcharfun);
-else if (escapeflag)
-{
-write_c_string ("#<buffer ", printcharfun);
-print_internal (b->name, printcharfun, 1);
-write_c_string (">", printcharfun);
-}
-else
-{
-print_internal (b->name, printcharfun, 0);
-}
-}
 DEFUN ("bufferp", Fbufferp, 1, 1, 0, /*
-T if OBJECT is an editor buffer.
+Return t if OBJECT is an editor buffer.
 */
 (object))
 {
-if (BUFFERP (object))
+return BUFFERP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("buffer-live-p", Fbuffer_live_p, 1, 1, 0, /*
-T if OBJECT is an editor buffer that has not been deleted.
+Return t if OBJECT is an editor buffer that has not been deleted.
 */
 (object))
 {
-if (BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object)))
+return BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object)) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 static void
 nsberror (Lisp_Object spec)
 {
 }
 Lisp_Object
 get_buffer (Lisp_Object name, int error_if_deleted_or_does_not_exist)
 {
-Lisp_Object buf;
 if (BUFFERP (name))
 {
 if (!BUFFER_LIVE_P (XBUFFER (name)))
 {
 if (error_if_deleted_or_does_not_exist)
 }
 return name;
 }
 else
 {
+Lisp_Object buf;
 struct gcpro gcpro1;
 CHECK_STRING (name);
 name = LISP_GETTEXT (name); /* I18N3 */
 GCPRO1 (name);
 }
 #include "bufslots.h"
 #undef MARKED_SLOT
 #if 0
 #define STRING256_P(obj) \
-(STRINGP (obj) && string_char_length (XSTRING (obj)) == 256)
+(STRINGP (obj) && XSTRING_CHAR_LENGTH (obj) == 256)
 /* If the standard case table has been altered and invalidated,
 fix up its insides first.  */
 if (!(STRING256_P(Vascii_upcase_table) &&
 	STRING256_P(Vascii_canon_table) &&
 	STRING256_P(Vascii_eqv_table)))
 If BUFFER is not indirect, return nil.
 */
 (buffer))
 {
 struct buffer *buf = decode_buffer (buffer, 0);
-struct buffer *base = buf->base_buffer;
-Lisp_Object base_buffer = Qnil;
+return buf->base_buffer ? make_buffer (buf->base_buffer) : Qnil;
-if (! base)
-return Qnil;
-XSETBUFFER (base_buffer, base);
-return base_buffer;
 }
 DEFUN ("buffer-indirect-children", Fbuffer_indirect_children, 0, 1, 0, /*
 Return a list of all indirect buffers whose base buffer is BUFFER.
 If BUFFER is indirect, the return value will always be nil; see
 	}
 }
 }
 DEFUN ("set-buffer", Fset_buffer, 1, 1, 0, /*
-Make the buffer BUFNAME current for editing operations.
+Make the buffer BUFFER current for editing operations.
-BUFNAME may be a buffer or the name of an existing buffer.
+BUFFER may be a buffer or the name of an existing buffer.
 See also `save-excursion' when you want to make a buffer current temporarily.
 This function does not display the buffer, so its effect ends
 when the current command terminates.
 Use `switch-to-buffer' or `pop-to-buffer' to switch buffers permanently.
 */
-(bufname))
+(buffer))
 {
-Lisp_Object buffer;
+buffer = get_buffer (buffer, 0);
-buffer = get_buffer (bufname, 0);
 if (NILP (buffer))
 error ("Selecting deleted or non-existent buffer");
 set_buffer_internal (XBUFFER (buffer));
 return buffer;
 }
 `read-only' property. (Extents that lie completely within the range,
 however, are not checked.) END defaults to the value of START.
 If START and END are equal, the range checked is [START, END] (i.e.
 closed on both ends); otherwise, the range checked is (START, END)
-(open on both ends), except that extents that lie completely within
+\(open on both ends), except that extents that lie completely within
 [START, END] are not checked.  See `extent-in-region-p' for a fuller
 discussion.
 */
 (buffer, start, end))
 {
 b->last_window_start = 1;
 /* Prevent warnings, or suspension of auto saving, that would happen
 if future size is less than past size.  Use of erase-buffer
 implies that the future text is not really related to the past text.  */
-b->save_length = Qzero;
+b->saved_size = Qzero;
 zmacs_region_stays = 0;
 return Qnil;
 }
 int markers;
 int extents;
 int other;
 };
-static int
+static size_t
 compute_buffer_text_usage (struct buffer *b, struct overhead_stats *ovstats)
 {
-int malloc_use;
+int was_requested = b->text->z - 1;
-int was_requested;
+size_t gap = b->text->gap_size + b->text->end_gap_size;
-int gap;
+size_t malloc_use = malloced_storage_size (b->text->beg, was_requested + gap, 0);
-was_requested = b->text->z - 1;
+ovstats->gap_overhead    += gap;
-gap = b->text->gap_size + b->text->end_gap_size;
+ovstats->was_requested   += was_requested;
-malloc_use = malloced_storage_size (b->text->beg, was_requested + gap, 0);
-ovstats->gap_overhead += gap;
-ovstats->was_requested += was_requested;
 ovstats->malloc_overhead += malloc_use - (was_requested + gap);
 return malloc_use;
 }
 static void
 compute_buffer_usage (struct buffer *b, struct buffer_stats *stats,
 		      struct overhead_stats *ovstats)
 {
-memset (stats, 0, sizeof (*stats));
+xzero (*stats);
-stats->other += malloced_storage_size (b, sizeof (struct buffer), ovstats);
+stats->other   += malloced_storage_size (b, sizeof (*b), ovstats);
-stats->text += compute_buffer_text_usage (b, ovstats);
+stats->text    += compute_buffer_text_usage   (b, ovstats);
 stats->markers += compute_buffer_marker_usage (b, ovstats);
 stats->extents += compute_buffer_extent_usage (b, ovstats);
 }
 DEFUN ("buffer-memory-usage", Fbuffer_memory_usage, 1, 1, 0, /*
 Return stats about the memory usage of buffer BUFFER.
-The values returned are in the form an alist of usage types and byte
+The values returned are in the form of an alist of usage types and byte
 counts.  The byte counts attempt to encompass all the memory used
 by the buffer (separate from the memory logically associated with a
 buffer or frame), including internal structures and any malloc()
 overhead associated with them.  In practice, the byte counts are
 underestimated because certain memory usage is very hard to determine
-(e.g. the amount of memory used inside the Xt library or inside the
+\(e.g. the amount of memory used inside the Xt library or inside the
 X server) and because there is other stuff that might logically
 be associated with a window, buffer, or frame (e.g. window configurations,
 glyphs) but should not obviously be included in the usage counts.
 Multiple slices of the total memory usage may be returned, separated
 */
 (buffer))
 {
 struct buffer_stats stats;
 struct overhead_stats ovstats;
+Lisp_Object val = Qnil;
 CHECK_BUFFER (buffer); /* dead buffers should be allowed, no? */
-memset (&ovstats, 0, sizeof (ovstats));
+xzero (ovstats);
 compute_buffer_usage (XBUFFER (buffer), &stats, &ovstats);
-return nconc2 (list4 (Fcons (Qtext, make_int (stats.text)),
+val = acons (Qtext,    make_int (stats.text),    val);
-			Fcons (Qmarkers, make_int (stats.markers)),
+val = acons (Qmarkers, make_int (stats.markers), val);
-			Fcons (Qextents, make_int (stats.extents)),
+val = acons (Qextents, make_int (stats.extents), val);
-			Fcons (Qother, make_int (stats.other))),
+val = acons (Qother,   make_int (stats.other),   val);
-		 list5 (Qnil,
+val = Fcons (Qnil, val);
-			Fcons (Qactually_requested,
+val = acons (Qactually_requested, make_int (ovstats.was_requested),   val);
-			       make_int (ovstats.was_requested)),
+val = acons (Qmalloc_overhead,    make_int (ovstats.malloc_overhead), val);
-			Fcons (Qmalloc_overhead,
+val = acons (Qgap_overhead,       make_int (ovstats.gap_overhead),    val);
-			       make_int (ovstats.malloc_overhead)),
+val = acons (Qdynarr_overhead,    make_int (ovstats.dynarr_overhead), val);
-			Fcons (Qgap_overhead,
-			       make_int (ovstats.malloc_overhead)),
+return Fnreverse (val);
-			Fcons (Qdynarr_overhead,
-			       make_int (ovstats.dynarr_overhead))));
 }
 #endif /* MEMORY_USAGE_STATS */
 void
 #ifdef MULE
 defs->mirror_downcase_table = Vmirror_ascii_downcase_table;
 defs->mirror_upcase_table = Vmirror_ascii_upcase_table;
 defs->mirror_case_canon_table = Vmirror_ascii_canon_table;
 defs->mirror_case_eqv_table = Vmirror_ascii_eqv_table;
+defs->category_table = Vstandard_category_table;
 #endif /* MULE */
 defs->syntax_table = Vstandard_syntax_table;
 defs->mirror_syntax_table =
 XCHAR_TABLE (Vstandard_syntax_table)->mirror_table;
-#ifdef MULE
-defs->category_table = Vstandard_category_table;
-#endif
 defs->modeline_format = build_string ("%-");  /* reset in loaddefs.el */
 defs->case_fold_search = Qt;
 defs->selective_display_ellipses = Qt;
 defs->tab_width = make_int (8);
 defs->ctl_arrow = Qt;
 defs->fill_column = make_int (70);
 defs->left_margin = Qzero;
-defs->save_length = Qzero;       /* lisp code wants int-or-nil */
+defs->saved_size = Qzero;	/* lisp code wants int-or-nil */
 defs->modtime = 0;
 defs->auto_save_modified = 0;
 defs->auto_save_failure_time = -1;
 defs->invisibility_spec = Qt;
 nuke_all_buffer_slots (&buffer_local_flags, make_int (-2));
 buffer_local_flags.filename = always_local_no_default;
 buffer_local_flags.directory = always_local_no_default;
 buffer_local_flags.backed_up = always_local_no_default;
-buffer_local_flags.save_length = always_local_no_default;
+buffer_local_flags.saved_size = always_local_no_default;
 buffer_local_flags.auto_save_file_name = always_local_no_default;
 buffer_local_flags.read_only = always_local_no_default;
 buffer_local_flags.major_mode = always_local_resettable;
 buffer_local_flags.mode_name = always_local_resettable;
 Non-nil if this buffer's file has been backed up.
 Backing up is done before the first time the file is saved.
 Each buffer has its own value of this variable.
 */ );
-DEFVAR_BUFFER_LOCAL ("buffer-saved-size", save_length /*
+DEFVAR_BUFFER_LOCAL ("buffer-saved-size", saved_size /*
 Length of current buffer when last read in, saved or auto-saved.
 0 initially.
 Each buffer has its own value of this variable.
 */ );
 /* Check for DEFVAR_BUFFER_LOCAL without initializing the corresponding
 slot of buffer_local_flags and vice-versa.  Must be done after all
 DEFVAR_BUFFER_LOCAL() calls. */
 #define MARKED_SLOT(slot)					\
 if ((XINT (buffer_local_flags.slot) != -2 &&			\
 XINT (buffer_local_flags.slot) != -3)			\
 != !(NILP (XBUFFER (Vbuffer_local_symbols)->slot)))	\
 abort ()
 #include "bufslots.h"
 #undef MARKED_SLOT
 {
-Lisp_Object scratch =
+Lisp_Object scratch = Fget_buffer_create (QSscratch);
-Fset_buffer (Fget_buffer_create (QSscratch));
+Fset_buffer (scratch);
 /* Want no undo records for *scratch* until after Emacs is dumped */
 Fbuffer_disable_undo (scratch);
 }
 }
 #ifdef DOS_NT
 #define CORRECT_DIR_SEPS(s) \
 do { if ('/' == DIRECTORY_SEP) dostounix_filename (s); \
 else unixtodos_filename (s); \
 } while (0)
 CORRECT_DIR_SEPS(buf);
 #endif
 current_buffer->directory = build_string (buf);
 #if 0 /* FSFmacs */

Mercurial > hg > xemacs-beta

comparison src/buffer.c @ 272:c5d627a313b1 r21-0b34