xemacs-beta: src/buffer.c comparison

comparison src/buffer.c @ 183:e121b013d1f0 r20-3b18

Import from CVS: tag r20-3b18

author	cvs
date	Mon, 13 Aug 2007 09:54:23 +0200
parents	2d532a89d707
children	3d6bfa290dbd

comparison

equal deleted inserted replaced

-:f07455f06202
+:e121b013d1f0
 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.
 If a slot is -2, there is no DEFVAR_BUFFER_LOCAL for it.
 (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.
 */
 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 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)
 else
 {
 print_internal (b->name, printcharfun, 0);
 }
 }
 DEFUN ("bufferp", Fbufferp, 1, 1, 0, /*
 T if OBJECT is an editor buffer.
 */
 (object))
 {
 if (!BUFFER_LIVE_P (XBUFFER (name)))
 {
 if (error_if_deleted_or_does_not_exist)
 nsberror (name);
-return (Qnil);
+return Qnil;
 }
 return name;
 }
 else
 {
 GCPRO1 (name);
 buf = Fcdr (Fassoc (name, Vbuffer_alist));
 UNGCPRO;
 if (NILP (buf) && error_if_deleted_or_does_not_exist)
 	nsberror (name);
-return (buf);
+return buf;
 }
 }
 struct buffer *
 decode_buffer (Lisp_Object buffer, int allow_string)
 {
 if (NILP (buffer))
-{
+return current_buffer;
-return current_buffer;
-}
+if (allow_string && STRINGP (buffer))
-else if (STRINGP (buffer))
+return XBUFFER (get_buffer (buffer, 1));
-{
-if (allow_string)
-	return XBUFFER (get_buffer (buffer, 1));
-else
-	CHECK_BUFFER (buffer);    /* This will cause a wrong-type error. */
-}
 CHECK_LIVE_BUFFER (buffer);
 return XBUFFER (buffer);
 }
 	return elt;
 }
 return Qnil;
 }
-#endif
+#endif /* FSFmacs */
 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.
 /* #### This might return a dead buffer.  This is gross.  This is
 called FSF compatibility. */
 if (BUFFERP (name))
 return name;
-return (get_buffer (name, 0));
+return get_buffer (name, 0);
 /* FSFmacs 19.29 calls assoc_ignore_text_properties() here.
 Bleagh!! */
 }
 translated. */
 #endif
 tem = Fget_buffer (name);
 if (NILP (tem))
-return (name);
+return name;
 count = 1;
 while (1)
 {
 sprintf (number, "<%d>", ++count);
 if (!NILP (tem))
 return gentemp;
 }
 tem = Fget_buffer (gentemp);
 if (NILP (tem))
-	return (gentemp);
+	return gentemp;
 }
 }
 DEFUN ("buffer-name", Fbuffer_name, 0, 1, 0, /*
 result = Fcons (Fcons (syms->slot, buf->slot), result);	\
 }
 #include "bufslots.h"
 #undef MARKED_SLOT
 }
-return (result);
+return result;
 }
 DEFUN ("buffer-dedicated-frame", Fbuffer_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.
 /* XEmacs addition: if the frame is dead, silently make it go away. */
 if (!NILP (buf->dedicated_frame) &&
 !FRAME_LIVE_P (XFRAME (buf->dedicated_frame)))
 buf->dedicated_frame = Qnil;
 return buf->dedicated_frame;
 }
 DEFUN ("set-buffer-dedicated-frame", Fset_buffer_dedicated_frame, 2, 2, 0, /*
 For this BUFFER, set the FRAME dedicated to it.
 {
 /* This function can GC */
 struct buffer *buf = decode_buffer (buffer, 0);
 #ifdef ENERGIZE
 Lisp_Object starting_flag =
 (BUF_SAVE_MODIFF (buf) < BUF_MODIFF (buf)) ? Qt : Qnil;
 Lisp_Object argument_flag = (NILP (flag)) ? Qnil : Qt;
 #endif
 #ifdef CLASH_DETECTION
 /* If buffer becoming modified, lock the file.
 If buffer becoming unmodified, unlock the file.  */
 No argument or nil as argument means use current buffer as BUFFER.
 */
 (buffer))
 {
 struct buffer *buf = decode_buffer (buffer, 0);
 return make_int (BUF_MODIFF (buf));
 }
 DEFUN ("rename-buffer", Frename_buffer, 1, 2,
 "sRename buffer (to new name): \nP", /*
 	continue;
 /* If FRAME has a buffer_predicate,
 	 disregard buffers that don't fit the predicate.  */
 if (FRAMEP (frame))
 	{
 	  tem = XFRAME (frame)->buffer_predicate;
 	  if (!NILP (tem))
 	    {
 	      tem = call1 (tem, buf);
 	      if (NILP (tem))
 		continue;
 	 kill-buffer-hook, but the user might mess that up.
 	 */
 if (EQ (Vwindow_system, Qx))
 	call0 (intern ("xselect-kill-buffer-hook"));
 /* #### generalize me! */
-#endif
+#endif /* HAVE_X_WINDOWS */
 unbind_to (speccount, Qnil);
 UNGCPRO;
 b = XBUFFER (buf);        /* Hypothetical relocating GC. */
 }
 LIST_LOOP (rest, b->indirect_children)
 	Fkill_buffer (XCAR (rest));
 UNGCPRO;
 }
 /* Make this buffer not be current.
 In the process, notice if this is the sole visible buffer
 and give up if so.  */
 if (b == current_buffer)
 {
 	       macro or something for it. */
 	    GCPRO1 (buf);
 	    internal_delete_file (b->auto_save_file_name);
 	    UNGCPRO;
 	    b = XBUFFER (buf);
 	    if (!BUFFER_LIVE_P (b))
 	      return Qnil;
 	    if (b == current_buffer)
 	      {
 if (!noninteractive && initialized)
 {
 extern Lisp_Object Ffep_force_on (), Ffep_force_off (), Ffep_get_mode ();
 old_buf->fep_mode = Ffep_get_mode ();
 if (!NILP (current_buffer->fep_mode))
 	Ffep_force_on ();
 else
 	Ffep_force_off ();
 }
-#endif
+#endif /* HAVE_FEP */
 if (old_buf)
 {
 /* Put the undo list back in the base buffer, so that it appears
 	 that an indirect buffer shares the undo list of its base.  */
 	end = start;
 get_buffer_range_char (b, start, end, &s, &e, 0);
 }
 barf_if_buffer_read_only (b, s, e);
-return (Qnil);
+return Qnil;
 }
 static void
 bury_buffer_1 (Lisp_Object buffer, Lisp_Object before,
 	       Lisp_Object *buffer_alist)
 #if 0 /* FSFmacs */
 xxDEFVAR_LISP ("transient-mark-mode", &Vtransient_mark_mode /*
 *Non-nil means deactivate the mark when the buffer contents change.
 */ );
 Vtransient_mark_mode = Qnil;
-#endif
+#endif /* FSFmacs */
 DEFVAR_INT ("undo-threshold", &undo_threshold /*
 Keep no more undo information once it exceeds this size.
 This threshold is applied when garbage collection happens.
 The size is counted as the number of bytes occupied,
 *Non-nil means delete auto-save file when a buffer is saved or killed.
 */ );
 delete_auto_save_files = 1;
 }
 /* DOC is ignored because it is snagged and recorded externally
 *  by make-docfile */
 /* Renamed from DEFVAR_PER_BUFFER because FSFmacs D_P_B takes
 *  a bogus extra arg, which confuses an otherwise identical make-docfile.c */
 /* Declaring this stuff as const produces 'Cannot reinitialize' messages
 from SunPro C's fix-and-continue feature (a way neato feature that
 SYMVAL_CONST_CURRENT_BUFFER_FORWARD }, magicfun };		\
 defvar_buffer_local ((lname), &I_hate_C);				\
 } while (0)
 static void
 defvar_buffer_local (CONST char *namestring,
 CONST struct symbol_value_forward *m)
 {
 int offset = ((char *)symbol_value_forward_forward (m)
 - (char *)&buffer_local_flags);
 defvar_mumble (namestring, m, sizeof (*m));
 *((Lisp_Object *)(offset + (char *)XBUFFER (Vbuffer_local_symbols)))
 = intern (namestring);
 }
 /* DOC is ignored because it is snagged and recorded externally
 *  by make-docfile */
 #define DEFVAR_BUFFER_DEFAULTS(lname, field_name)			\
 do { static CONST_IF_NOT_DEBUG struct symbol_value_forward I_hate_C	\
 = { { { { lrecord_symbol_value_forward },			\
 (void *) &(buffer_local_flags.field_name), 69 },		\
 staticpro (&Vbuffer_defaults);
 staticpro (&Vbuffer_local_symbols);
 XSETBUFFER (Vbuffer_defaults, defs);
 XSETBUFFER (Vbuffer_local_symbols, syms);
 nuke_all_buffer_slots (syms, Qnil);
 nuke_all_buffer_slots (defs, Qnil);
 defs->text = &defs->own_text;
 syms->text = &syms->own_text;
 /* Set up the non-nil default values of various buffer slots.
 Must do these before making the first buffer.
 */
 defs->major_mode = Qfundamental_mode;
 defs->mode_name = QSFundamental;
 #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;
-#endif
+#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;
 defs->save_length = 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;
 {
 /*  0 means var is always local.  Default used only at creation.
 * -1 means var is always local.  Default used only at reset and
 *    creation.
 * -2 means there's no lisp variable corresponding to this slot
 *              Otherwise default is used.
 */
 Lisp_Object always_local_no_default = make_int (0);
 Lisp_Object always_local_resettable = make_int (-1);
 Lisp_Object resettable = make_int (-3);
 /* Assign the local-flags to the slots that have default values.
 The local flag is a bit that is used in the buffer
 to say that it has its own local value for the slot.
 The local flag bits are in the local_var_flags slot of the
 buffer.  */
 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.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;
 buffer_local_flags.undo_list = always_local_no_default;
 #if 0 /* FSFmacs */
 buffer_local_flags.mark_active = always_local_resettable;
 buffer_local_flags.point_before_scroll = always_local_resettable;
 buffer_local_flags.file_truename = always_local_no_default;
 buffer_local_flags.invisibility_spec = always_local_resettable;
 buffer_local_flags.file_format = always_local_resettable;
 buffer_local_flags.generated_modeline_string = always_local_no_default;
 buffer_local_flags.keymap = resettable;
 buffer_local_flags.downcase_table = resettable;
 buffer_local_flags.upcase_table = resettable;
 buffer_local_flags.case_canon_table = resettable;
 buffer_local_flags.case_eqv_table = resettable;
 buffer_local_flags.syntax_table = resettable;
 #ifdef MULE
 buffer_local_flags.category_table = resettable;
 #endif
 buffer_local_flags.modeline_format = make_int (1);
 buffer_local_flags.abbrev_mode = make_int (2);
 buffer_local_flags.overwrite_mode = make_int (4);
 buffer_local_flags.case_fold_search = make_int (8);
 buffer_local_flags.auto_fill_function = make_int (0x10);
 #endif
 buffer_local_flags.buffer_file_type = make_int (0x4000);
 #ifdef MULE
 buffer_local_flags.buffer_file_coding_system = make_int (0x8000);
 #endif
 /* #### Warning, 0x4000000 (that's six zeroes) is the largest number
 currently allowable due to the XINT() handling of this value.
 With some rearrangement you can get 4 more bits. */
 }
 #if 0 /* #### Make this a specifier! */
 xxDEFVAR_BUFFER_LOCAL ("display-direction", display_direction /*
 *Non-nil means lines in the buffer are displayed right to left.
 Nil means left to right. (Not yet implemented.)
 */ );
-#endif
+#endif /* Not yet implemented */
 DEFVAR_BUFFER_LOCAL_MAGIC ("truncate-lines", truncate_lines /*
 *Non-nil means do not display continuation lines;
 give each line of text one frame line.
 Automatically becomes buffer-local when set in any fashion.
 Each buffer has its own value of this variable.
 */
 #endif /* FSFmacs */
 DEFVAR_BUFFER_LOCAL ("buffer-file-truename", file_truename /*
 The real name of the file visited in the current buffer,
 or nil if not visiting a file.  This is the result of passing
 buffer-file-name to the `file-truename' function.  Every buffer has
 its own value of this variable.  This variable is automatically
 maintained by the functions that change the file name associated
 with a buffer.
 */ );
 DEFVAR_BUFFER_LOCAL ("buffer-auto-save-file-name", auto_save_file_name /*
 Name of file for auto-saving current buffer,
 An entry (nil PROPERTY VALUE BEG . END) indicates that a text property
 was modified between BEG and END.  PROPERTY is the property name,
 and VALUE is the old value.
 */
-#endif
+#endif /* FSFmacs */
 DEFVAR_BUFFER_LOCAL ("buffer-undo-list", undo_list /*
 List of undo entries in current buffer.
 Recent changes come first; older changes follow newer.
 #if 0 /* FSFmacs */
 xxDEFVAR_BUFFER_LOCAL ("mark-active", mark_active /*
 Non-nil means the mark and region are currently active in this buffer.
 Automatically local in all buffers.
 */ );
-#endif
+#endif /* FSFmacs */
 #ifdef REGION_CACHE_NEEDS_WORK
 xxDEFVAR_BUFFER_LOCAL ("cache-long-line-scans", cache_long_line_scans /*
 Non-nil means that Emacs should use caches to handle long lines more quickly.
 This variable is buffer-local, in all buffers.
 /* Reset Vbuffer_alist again so that the above buf is magically
 invisible */
 Vbuffer_alist = Qnil;
 /* Want no undo records for prin1_to_string_buffer */
 Fbuffer_disable_undo (Vprin1_to_string_buffer);
 {
 Lisp_Object scratch =
 Fset_buffer (Fget_buffer_create (QSscratch));
 /* Want no undo records for *scratch* until after Emacs is dumped */
 Fbuffer_disable_undo (scratch);
 #if 0 /* FSFmacs */
 /* #### is this correct? */
 temp = get_minibuffer (0);
 XBUFFER (temp)->directory = current_buffer->directory;
-#endif
+#endif /* FSFmacs */
 }

Mercurial > hg > xemacs-beta

comparison src/buffer.c @ 183:e121b013d1f0 r20-3b18