xemacs-beta: src/buffer.c comparison

comparison src/buffer.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	0293115a14e9
children	4103f0995bd7

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 print_internal (b->name, printcharfun, 0);
 }
 }
-DEFUN ("bufferp", Fbufferp, Sbufferp, 1, 1, 0 /*
+DEFUN ("bufferp", Fbufferp, 1, 1, 0, /*
 T if OBJECT is an editor buffer.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 if (BUFFERP (object))
 return Qt;
 return Qnil;
 }
-DEFUN ("buffer-live-p", Fbuffer_live_p, Sbuffer_live_p, 1, 1, 0 /*
+DEFUN ("buffer-live-p", Fbuffer_live_p, 1, 1, 0, /*
 T if OBJECT is an editor buffer that has not been deleted.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 if (BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object)))
 return Qt;
 return Qnil;
 }
 if (STRINGP (spec))
 error ("No buffer named %s", XSTRING_DATA (spec));
 signal_simple_error ("Invalid buffer argument", spec);
 }
-DEFUN ("buffer-list", Fbuffer_list, Sbuffer_list, 0, 1, 0 /*
+DEFUN ("buffer-list", Fbuffer_list, 0, 1, 0, /*
 Return a list of all existing live buffers.
 The order is specific to the selected frame; if the optional FRAME
 argument is provided, the ordering for that frame is returned instead.
 If the FRAME argument is t, then the global (non-frame) ordering is
 returned instead.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 Lisp_Object list;
 if (EQ (frame, Qt))
 list = Vbuffer_alist;
 else
 CHECK_LIVE_BUFFER (buffer);
 return XBUFFER (buffer);
 }
-DEFUN ("decode-buffer", Fdecode_buffer, Sdecode_buffer, 1, 1, 0 /*
+DEFUN ("decode-buffer", Fdecode_buffer, 1, 1, 0, /*
 Validate BUFFER or if BUFFER is nil, return the current buffer.
 If BUFFER is a valid buffer or a string representing a valid buffer,
 the corresponding buffer object will be returned.  Otherwise an error
 will be signaled.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 1);
 XSETBUFFER (buffer, b);
 return buffer;
 }
 return Qnil;
 }
 #endif
-DEFUN ("get-buffer", Fget_buffer, Sget_buffer, 1, 1, 0 /*
+DEFUN ("get-buffer", Fget_buffer, 1, 1, 0, /*
 Return the buffer named NAME (a string).
 If there is no live buffer named NAME, return nil.
 NAME may also be a buffer; if so, the value is that buffer.
-*/ )
+*/
-(name)
+(name))
-Lisp_Object name;
 {
 #ifdef I18N3
 /* #### Doc string should indicate that the buffer name will get
 translated. */
 #endif
 /* FSFmacs 19.29 calls assoc_ignore_text_properties() here.
 Bleagh!! */
 }
-DEFUN ("get-file-buffer", Fget_file_buffer, Sget_file_buffer, 1, 1, 0 /*
+DEFUN ("get-file-buffer", Fget_file_buffer, 1, 1, 0, /*
 Return the buffer visiting file FILENAME (a string).
 The buffer's `buffer-file-name' must match exactly the expansion of FILENAME.
 If there is no such live buffer, return nil.
 Normally, the comparison is done by canonicalizing FILENAME (using
 non-nil, FILENAME will be converted to its truename and the search will be
 done on each buffer's value of `buffer-file-truename' instead of
 `buffer-file-name'.  Otherwise, if `find-file-use-truenames' is non-nil,
 FILENAME will be converted to its truename and used for searching, but
 the search will still be done on `buffer-file-name'.
-*/ )
+*/
-(filename)
+(filename))
-Lisp_Object filename;
 {
 /* This function can GC */
 REGISTER Lisp_Object tail, buf, tem;
 struct gcpro gcpro1;
 						  HASHTABLE_EQ);
 return buf;
 }
-DEFUN ("get-buffer-create", Fget_buffer_create, Sget_buffer_create, 1, 1, 0 /*
+DEFUN ("get-buffer-create", Fget_buffer_create, 1, 1, 0, /*
 Return the buffer named NAME, or create such a buffer and return it.
 A new buffer is created if there is no live buffer named NAME.
 If NAME starts with a space, the new buffer does not keep undo information.
 If NAME is a buffer instead of a string, then it is the value returned.
 The value is never nil.
-*/ )
+*/
-(name)
+(name))
-Lisp_Object name;
 {
 /* This function can GC */
 Lisp_Object buf;
 REGISTER struct buffer *b;
 init_buffer_text (b, 0);
 return finish_init_buffer (b, name);
 }
-DEFUN ("make-indirect-buffer",
+DEFUN ("make-indirect-buffer", Fmake_indirect_buffer, 2, 2,
-Fmake_indirect_buffer, Smake_indirect_buffer, 2, 2,
+"bMake indirect buffer (to buffer): \nBName of indirect buffer: ", /*
-"bMake indirect buffer (to buffer): \nBName of indirect buffer: " /*
 Create and return an indirect buffer for buffer BASE, named NAME.
 BASE should be an existing buffer (or buffer name).
 NAME should be a string which is not the name of an existing buffer.
 If BASE is an indirect buffer itself, the base buffer for that buffer
 is made the base buffer for the newly created buffer. (Thus, there will
 never be indirect buffers whose base buffers are themselves indirect.)
-*/ )
+*/
-(base_buffer, name)
+(base_buffer, name))
-Lisp_Object base_buffer, name;
 {
 error ("make-indirect-buffer not yet implemented, oops");
 return Qnil;
 #if 0 /* #### implement this!  Need various changes in insdel.c */
 /* We split this away from generate-new-buffer, because rename-buffer
 and set-visited-file-name ought to be able to use this to really
 rename the buffer properly.  */
-DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name,
+DEFUN ("generate-new-buffer-name", Fgenerate_new_buffer_name, 1, 2, 0, /*
-Sgenerate_new_buffer_name,
-1, 2, 0 /*
 Return a string that is the name of no existing buffer based on NAME.
 If there is no live buffer named NAME, then return NAME.
 Otherwise modify name by appending `<NUMBER>', incrementing NUMBER
 until an unused name is found, and then return that name.
 Optional second argument IGNORE specifies a name that is okay to use
 \(if it is in the sequence to be tried)
 even if a buffer with that name exists.
-*/ )
+*/
-(name, ignore)
+(name, ignore))
-Lisp_Object name, ignore;
 {
 REGISTER Lisp_Object gentemp, tem;
 int count;
 char number[10];
 	return (gentemp);
 }
 }
-DEFUN ("buffer-name", Fbuffer_name, Sbuffer_name, 0, 1, 0 /*
+DEFUN ("buffer-name", Fbuffer_name, 0, 1, 0, /*
 Return the name of BUFFER, as a string.
 With no argument or nil as argument, return the name of the current buffer.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 /* For compatibility, we allow a dead buffer here.
 Earlier versions of Emacs didn't provide buffer-live-p. */
 if (NILP (buffer))
 return current_buffer->name;
 CHECK_BUFFER (buffer);
 return XBUFFER (buffer)->name;
 }
-DEFUN ("buffer-file-name", Fbuffer_file_name, Sbuffer_file_name, 0, 1, 0 /*
+DEFUN ("buffer-file-name", Fbuffer_file_name, 0, 1, 0, /*
 Return name of file BUFFER is visiting, or nil if none.
 No argument or nil as argument means use the current buffer.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 /* For compatibility, we allow a dead buffer here.  Yuck! */
 if (NILP (buffer))
 return current_buffer->filename;
 CHECK_BUFFER (buffer);
 return XBUFFER (buffer)->filename;
 }
-DEFUN ("buffer-base-buffer", Fbuffer_base_buffer, Sbuffer_base_buffer,
+DEFUN ("buffer-base-buffer", Fbuffer_base_buffer, 0, 1, 0, /*
-0, 1, 0 /*
 Return the base buffer of indirect buffer BUFFER.
 If BUFFER is not indirect, return nil.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *buf = decode_buffer (buffer, 0);
 struct buffer *base = buf->base_buffer;
 Lisp_Object base_buffer = Qnil;
 return Qnil;
 XSETBUFFER (base_buffer, base);
 return base_buffer;
 }
-DEFUN ("buffer-indirect-children", Fbuffer_indirect_children,
+DEFUN ("buffer-indirect-children", Fbuffer_indirect_children, 0, 1, 0, /*
-Sbuffer_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
 `make-indirect-buffer'.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *buf = decode_buffer (buffer, 0);
 return Fcopy_sequence (buf->indirect_children);
 }
 }
 return 0;
 }
-DEFUN ("buffer-local-variables", Fbuffer_local_variables,
+DEFUN ("buffer-local-variables", Fbuffer_local_variables, 0, 1, 0, /*
-Sbuffer_local_variables, 0, 1, 0 /*
 Return an alist of variables that are buffer-local in BUFFER.
 Most elements look like (SYMBOL . VALUE), describing one variable.
 For a symbol that is locally unbound, just the symbol appears in the value.
 Note that storing new VALUEs in these elements doesn't change the variables.
 No argument or nil as argument means use current buffer as BUFFER.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *buf = decode_buffer (buffer, 0);
 Lisp_Object result = Qnil;
 {
 #undef MARKED_SLOT
 }
 return (result);
 }
-DEFUN ("buffer-dedicated-frame", Fbuffer_dedicated_frame,
+DEFUN ("buffer-dedicated-frame", Fbuffer_dedicated_frame, 0, 1, 0, /*
-Sbuffer_dedicated_frame,
-0, 1, 0 /*
 Return the frame dedicated to this BUFFER, or nil if there is none.
 No argument or nil as argument means use current buffer as BUFFER.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *buf = decode_buffer (buffer, 0);
 /* XEmacs addition: if the frame is dead, silently make it go away. */
 if (!NILP (buf->dedicated_frame) &&
 buf->dedicated_frame = Qnil;
 return buf->dedicated_frame;
 }
-DEFUN ("set-buffer-dedicated-frame", Fset_buffer_dedicated_frame,
+DEFUN ("set-buffer-dedicated-frame", Fset_buffer_dedicated_frame, 2, 2, 0, /*
-Sset_buffer_dedicated_frame,
-2, 2, 0 /*
 For this BUFFER, set the FRAME dedicated to it.
 FRAME must be a frame or nil.
-*/ )
+*/
-(buffer, frame)
+(buffer, frame))
-Lisp_Object buffer, frame;
 {
 struct buffer *buf = decode_buffer (buffer, 0);
 if (!NILP (frame))
 CHECK_LIVE_FRAME (frame); /* XEmacs change */
 return buf->dedicated_frame = frame;
 }
-DEFUN ("buffer-modified-p", Fbuffer_modified_p, Sbuffer_modified_p,
+DEFUN ("buffer-modified-p", Fbuffer_modified_p, 0, 1, 0, /*
-0, 1, 0 /*
 Return t if BUFFER was modified since its file was last read or saved.
 No argument or nil as argument means use current buffer as BUFFER.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *buf = decode_buffer (buffer, 0);
 return BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf) ? Qt : Qnil;
 }
-DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p, Sset_buffer_modified_p,
+DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p, 1, 2, 0, /*
-1, 2, 0 /*
 Mark BUFFER as modified or unmodified according to FLAG.
 A non-nil FLAG means mark the buffer modified.  No argument or nil
 as BUFFER means use current buffer.
-*/ )
+*/
-(flag, buffer)
+(flag, buffer))
-Lisp_Object flag, buffer;
 {
 /* This function can GC */
 Lisp_Object fn;
 struct buffer *buf = decode_buffer (buffer, 0);
 #endif /* ENERGIZE */
 return flag;
 }
-DEFUN ("buffer-modified-tick", Fbuffer_modified_tick, Sbuffer_modified_tick,
+DEFUN ("buffer-modified-tick", Fbuffer_modified_tick, 0, 1, 0, /*
-0, 1, 0 /*
 Return BUFFER's tick counter, incremented for each change in text.
 Each buffer has a tick counter which is incremented each time the text in
 that buffer is changed.  It wraps around occasionally.
 No argument or nil as argument means use current buffer as BUFFER.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *buf = decode_buffer (buffer, 0);
 return make_int (BUF_MODIFF (buf));
 }
-DEFUN ("rename-buffer", Frename_buffer, Srename_buffer, 1, 2,
+DEFUN ("rename-buffer", Frename_buffer, 1, 2,
-"sRename buffer (to new name): \nP" /*
+"sRename buffer (to new name): \nP", /*
 Change current buffer's name to NEWNAME (a string).
 If second arg UNIQUE is nil or omitted, it is an error if a
 buffer named NEWNAME already exists.
 If UNIQUE is non-nil, come up with a new name using
 `generate-new-buffer-name'.
 Interactively, one can set UNIQUE with a prefix argument.
 Returns the name we actually gave the buffer.
 This does not change the name of the visited file (if any).
-*/ )
+*/
-(newname, unique)
+(newname, unique))
-Lisp_Object newname, unique;
 {
 /* This function can GC */
 Lisp_Object tem, buf;
 #ifdef I18N3
 /* refetch since that last call may have done GC */
 /* (hypothetical relocating GC) */
 return current_buffer->name;
 }
-DEFUN ("other-buffer", Fother_buffer, Sother_buffer, 0, 3, 0 /*
+DEFUN ("other-buffer", Fother_buffer, 0, 3, 0, /*
 Return most recently selected buffer other than BUFFER.
 Buffers not visible in windows are preferred to visible buffers,
 unless optional third argument VISIBLE-OK is non-nil.
 If no other buffer exists, the buffer `*scratch*' is returned.
 If BUFFER is omitted or nil, some interesting buffer is returned.
 is provided, then the ordering is for that frame.  If the second arg
 is t, then the global ordering is returned.
 Note: In FSF Emacs, this function takes two arguments: BUFFER and
 VISIBLE-OK.
-*/ )
+*/
-(buffer, frame, visible_ok)
+(buffer, frame, visible_ok))
-Lisp_Object buffer, frame, visible_ok;
 {
 /* This function can GC */
 Lisp_Object tail, buf, notsogood, tem;
 Lisp_Object alist;
 return Fget_buffer_create (QSscratch);
 }
 /* XEmacs change: Make this argument required because this is a dangerous
 function. */
-DEFUN ("buffer-disable-undo", Fbuffer_disable_undo, Sbuffer_disable_undo, 1, 1, "" /*
+DEFUN ("buffer-disable-undo", Fbuffer_disable_undo, 1, 1, "", /*
 Make BUFFER stop keeping undo information.
 Any undo records it already has are discarded.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 /* Allowing nil is an RMSism */
 struct buffer *real_buf = decode_buffer (buffer, 1);
 real_buf->undo_list = Qt;
 return Qnil;
 }
-DEFUN ("buffer-enable-undo", Fbuffer_enable_undo, Sbuffer_enable_undo,
+DEFUN ("buffer-enable-undo", Fbuffer_enable_undo, 0, 1, "", /*
-0, 1, "" /*
 Start keeping undo information for buffer BUFFER.
 No argument or nil as argument means do this for the current buffer.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 /* Allowing nil is an RMSism */
 struct buffer *real_buf = decode_buffer (buffer, 1);
 if (EQ (real_buf->undo_list, Qt))
 real_buf->undo_list = Qnil;
 return Qnil;
 }
-DEFUN ("kill-buffer", Fkill_buffer, Skill_buffer, 1, 1, "bKill buffer: " /*
+DEFUN ("kill-buffer", Fkill_buffer, 1, 1, "bKill buffer: ", /*
 Kill the buffer BUFNAME.
 The argument may be a buffer or may be the name of a buffer.
 An argument of nil means kill the current buffer.
 Value is t if the buffer is actually killed, nil if user says no.
 before the buffer is actually killed.  The buffer to be killed is current
 when the hook functions are called.
 Any processes that have this buffer as the `process-buffer' are killed
 with `delete-process'.
-*/ )
+*/
-(bufname)
+(bufname))
-Lisp_Object bufname;
 {
 /* This function can GC */
 Lisp_Object buf;
 REGISTER struct buffer *b;
 struct gcpro gcpro1, gcpro2;
 unbind_to (speccount, Qnil);
 }
 return Qt;
 }
-DEFUN ("record-buffer", Frecord_buffer,
+DEFUN ("record-buffer", Frecord_buffer, 1, 1, 0, /*
-Srecord_buffer, 1, 1, 0 /*
 Place buffer BUF first in the buffer order.
 Call this function when a buffer is selected \"visibly\".
 This function changes the global buffer order and the per-frame buffer
 order for the selected frame.  The buffer order keeps track of recency
 of selection so that `other-buffer' will return a recently selected
 buffer.  See `other-buffer' for more information.
-*/ )
+*/
-(buf)
+(buf))
-Lisp_Object buf;
 {
 REGISTER Lisp_Object lynk, prev;
 struct frame *f = selected_frame ();
 prev = Qnil;
 XCDR (lynk) = f->buffer_alist;
 f->buffer_alist = lynk;
 return Qnil;
 }
-DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode,
+DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode, 1, 1, 0, /*
-Sset_buffer_major_mode, 1, 1, 0 /*
 Set an appropriate major mode for BUFFER, according to `default-major-mode'.
 Use this function before selecting the buffer, since it may need to inspect
 the current buffer's major mode.
-*/ )
+*/
-(buf)
+(buf))
-Lisp_Object buf;
 {
 int speccount = specpdl_depth ();
 REGISTER Lisp_Object function, tem;
 function = XBUFFER (Vbuffer_defaults)->major_mode;
 {
 call2 (Qswitch_to_buffer, bufname, norecord);
 }
-DEFUN ("current-buffer", Fcurrent_buffer, Scurrent_buffer, 0, 0, 0 /*
+DEFUN ("current-buffer", Fcurrent_buffer, 0, 0, 0, /*
 Return the current buffer as a Lisp object.
-*/ )
+*/
-()
+())
 {
 Lisp_Object buf;
 XSETBUFFER (buf, current_buffer);
 return buf;
 }
 	    }
 	}
 }
 }
-DEFUN ("set-buffer", Fset_buffer, Sset_buffer, 1, 1, 0 /*
+DEFUN ("set-buffer", Fset_buffer, 1, 1, 0, /*
 Make the buffer BUFNAME current for editing operations.
 BUFNAME 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)
+(bufname))
-Lisp_Object bufname;
 {
 Lisp_Object buffer;
 buffer = get_buffer (bufname, 0);
 if (NILP (buffer))
 error ("Selecting deleted or non-existent buffer");
 set_buffer_internal (XBUFFER (buffer));
 return buffer;
 }
-DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only,
+DEFUN ("barf-if-buffer-read-only", Fbarf_if_buffer_read_only, 0, 3, 0, /*
-				   Sbarf_if_buffer_read_only, 0, 3, 0 /*
 Signal a `buffer-read-only' error if the buffer is read-only.
 Optional argument BUFFER defaults to the current buffer.
 If optional argument START is non-nil, all extents in the buffer
 which overlap that part of the buffer are checked to ensure none has a
 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
 [START, END] are not checked.  See `extent-in-region-p' for a fuller
 discussion.
-*/ )
+*/
-(buffer, start, end)
+(buffer, start, end))
-Lisp_Object buffer, start, end;
 {
 struct buffer *b = decode_buffer (buffer, 0);
 Bufpos s, e;
 if (NILP (start))
 XCDR (before_before) = lynk;
 else
 *buffer_alist = lynk;
 }
-DEFUN ("bury-buffer", Fbury_buffer, Sbury_buffer, 0, 2, "" /*
+DEFUN ("bury-buffer", Fbury_buffer, 0, 2, "", /*
 Put BUFFER at the end of the list of all buffers.
 There it is the least likely candidate for `other-buffer' to return;
 thus, the least likely buffer for \\[switch-to-buffer] to select by default.
 If BUFFER is nil or omitted, bury the current buffer.
 Also, if BUFFER is nil or omitted, remove the current buffer from the
 selected window if it is displayed there.
 If BEFORE is non-nil, it specifies a buffer before which BUFFER
 will be placed, instead of being placed at the end.
-*/ )
+*/
-(buffer, before)
+(buffer, before))
-Lisp_Object buffer, before;
 {
 /* This function can GC */
 struct buffer *buf = decode_buffer (buffer, 1);
 /* If we're burying the current buffer, unshow it.  */
 /* Note that the behavior of (bury-buffer nil) and
 return Qnil;
 }
-DEFUN ("erase-buffer", Ferase_buffer, Serase_buffer, 0, 1, "*" /*
+DEFUN ("erase-buffer", Ferase_buffer, 0, 1, "*", /*
 Delete the entire contents of the BUFFER.
 Any clipping restriction in effect (see `narrow-to-region') is removed,
 so the buffer is truly empty after this.
 BUFFER defaults to the current buffer if omitted.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 /* This function can GC */
 struct buffer *b = decode_buffer (buffer, 1);
 /* #### yuck yuck yuck.  This is gross.  The old echo-area code,
 however, was the only place that called erase_buffer() with a
 return Qnil;
 }
-DEFUN ("kill-all-local-variables", Fkill_all_local_variables,
+DEFUN ("kill-all-local-variables", Fkill_all_local_variables, 0, 0, 0, /*
-Skill_all_local_variables, 0, 0, 0 /*
 Switch to Fundamental mode by killing current buffer's local variables.
 Most local variable bindings are eliminated so that the default values
 become effective once more.  Also, the syntax table is set from
 `standard-syntax-table', local keymap is set to nil,
 the abbrev table is set from `fundamental-mode-abbrev-table',
 As a special exception, local variables whose names have
 a non-nil `permanent-local' property are not eliminated by this function.
 The first thing this function does is run
 the normal hook `change-major-mode-hook'.
-*/ )
+*/
-()
+())
 {
 /* This function can GC */
 run_hook (Qchange_major_mode_hook);
 reset_buffer_local_variables (current_buffer, 0);
 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, Sbuffer_memory_usage,
+DEFUN ("buffer-memory-usage", Fbuffer_memory_usage, 1, 1, 0, /*
-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
 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()
 Multiple slices of the total memory usage may be returned, separated
 by a nil.  Each slice represents a particular view of the memory, a
 particular way of partitioning it into groups.  Within a slice, there
 is no overlap between the groups of memory, and each slice collectively
 represents all the memory concerned.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer_stats stats;
 struct overhead_stats ovstats;
 CHECK_BUFFER (buffer); /* dead buffers should be allowed, no? */
 defsymbol (&Qfind_file_compare_truenames, "find-file-compare-truenames");
 defsymbol (&Qswitch_to_buffer, "switch-to-buffer");
-defsubr (&Sbufferp);
+DEFSUBR (Fbufferp);
-defsubr (&Sbuffer_live_p);
+DEFSUBR (Fbuffer_live_p);
-defsubr (&Sbuffer_list);
+DEFSUBR (Fbuffer_list);
-defsubr (&Sdecode_buffer);
+DEFSUBR (Fdecode_buffer);
-defsubr (&Sget_buffer);
+DEFSUBR (Fget_buffer);
-defsubr (&Sget_file_buffer);
+DEFSUBR (Fget_file_buffer);
-defsubr (&Sget_buffer_create);
+DEFSUBR (Fget_buffer_create);
-defsubr (&Smake_indirect_buffer);
+DEFSUBR (Fmake_indirect_buffer);
-defsubr (&Sgenerate_new_buffer_name);
+DEFSUBR (Fgenerate_new_buffer_name);
-defsubr (&Sbuffer_name);
+DEFSUBR (Fbuffer_name);
-defsubr (&Sbuffer_file_name);
+DEFSUBR (Fbuffer_file_name);
-defsubr (&Sbuffer_base_buffer);
+DEFSUBR (Fbuffer_base_buffer);
-defsubr (&Sbuffer_indirect_children);
+DEFSUBR (Fbuffer_indirect_children);
-defsubr (&Sbuffer_local_variables);
+DEFSUBR (Fbuffer_local_variables);
-defsubr (&Sbuffer_dedicated_frame);
+DEFSUBR (Fbuffer_dedicated_frame);
-defsubr (&Sset_buffer_dedicated_frame);
+DEFSUBR (Fset_buffer_dedicated_frame);
-defsubr (&Sbuffer_modified_p);
+DEFSUBR (Fbuffer_modified_p);
-defsubr (&Sset_buffer_modified_p);
+DEFSUBR (Fset_buffer_modified_p);
-defsubr (&Sbuffer_modified_tick);
+DEFSUBR (Fbuffer_modified_tick);
-defsubr (&Srename_buffer);
+DEFSUBR (Frename_buffer);
-defsubr (&Sother_buffer);
+DEFSUBR (Fother_buffer);
-defsubr (&Sbuffer_disable_undo);
+DEFSUBR (Fbuffer_disable_undo);
-defsubr (&Sbuffer_enable_undo);
+DEFSUBR (Fbuffer_enable_undo);
-defsubr (&Skill_buffer);
+DEFSUBR (Fkill_buffer);
-defsubr (&Serase_buffer);
+DEFSUBR (Ferase_buffer);
-defsubr (&Srecord_buffer);
+DEFSUBR (Frecord_buffer);
-defsubr (&Sset_buffer_major_mode);
+DEFSUBR (Fset_buffer_major_mode);
-defsubr (&Scurrent_buffer);
+DEFSUBR (Fcurrent_buffer);
-defsubr (&Sset_buffer);
+DEFSUBR (Fset_buffer);
-defsubr (&Sbarf_if_buffer_read_only);
+DEFSUBR (Fbarf_if_buffer_read_only);
-defsubr (&Sbury_buffer);
+DEFSUBR (Fbury_buffer);
-defsubr (&Skill_all_local_variables);
+DEFSUBR (Fkill_all_local_variables);
 #ifdef MEMORY_USAGE_STATS
-defsubr (&Sbuffer_memory_usage);
+DEFSUBR (Fbuffer_memory_usage);
 #endif
 deferror (&Qprotected_field, "protected-field",
 	    "Attempt to modify a protected field", Qerror);
 }

Mercurial > hg > xemacs-beta

comparison src/buffer.c @ 20:859a2309aef8 r19-15b93