xemacs-beta: src/alloc.c comparison

comparison src/alloc.c @ 934:c925bacdda60

[xemacs-hg @ 2002-07-29 09:21:12 by michaels] 2002-07-17 Marcus Crestani <crestani@informatik.uni-tuebingen.de> Markus Kaltenbach <makalten@informatik.uni-tuebingen.de> Mike Sperber <mike@xemacs.org> configure flag to turn these changes on: --use-kkcc First we added a dumpable flag to lrecord_implementation. It shows, if the object is dumpable and should be processed by the dumper. * lrecord.h (struct lrecord_implementation): added dumpable flag (MAKE_LRECORD_IMPLEMENTATION): fitted the different makro definitions to the new lrecord_implementation and their calls. Then we changed mark_object, that it no longer needs a mark method for those types that have pdump descritions. * alloc.c: (mark_object): If the object has a description, the new mark algorithm is called, and the object is marked according to its description. Otherwise it uses the mark method like before. These procedures mark objects according to their descriptions. They are modeled on the corresponding pdumper procedures. (mark_with_description): (get_indirect_count): (structure_size): (mark_struct_contents): These procedures still call mark_object, this is needed while there are Lisp_Objects without descriptions left. We added pdump descriptions for many Lisp_Objects: * extents.c: extent_auxiliary_description * database.c: database_description * gui.c: gui_item_description * scrollbar.c: scrollbar_instance_description * toolbar.c: toolbar_button_description * event-stream.c: command_builder_description * mule-charset.c: charset_description * device-msw.c: devmode_description * dialog-msw.c: mswindows_dialog_id_description * eldap.c: ldap_description * postgresql.c: pgconn_description pgresult_description * tooltalk.c: tooltalk_message_description tooltalk_pattern_description * ui-gtk.c: emacs_ffi_description emacs_gtk_object_description * events.c: * events.h: * event-stream.c: * event-Xt.c: * event-gtk.c: * event-tty.c: To write a pdump description for Lisp_Event, we converted every struct in the union event to a Lisp_Object. So we created nine new Lisp_Objects: Lisp_Key_Data, Lisp_Button_Data, Lisp_Motion_Data, Lisp_Process_Data, Lisp_Timeout_Data, Lisp_Eval_Data, Lisp_Misc_User_Data, Lisp_Magic_Data, Lisp_Magic_Eval_Data. We also wrote makro selectors and mutators for the fields of the new designed Lisp_Event and added everywhere these new abstractions. We implemented XD_UNION support in (mark_with_description), so we can describe exspecially console/device specific data with XD_UNION. To describe with XD_UNION, we added a field to these objects, which holds the variant type of the object. This field is initialized in the appendant constructor. The variant is an integer, it has also to be described in an description, if XD_UNION is used. XD_UNION is used in following descriptions: * console.c: console_description (get_console_variant): returns the variant (create_console): added variant initialization * console.h (console_variant): the different console types * console-impl.h (struct console): added enum console_variant contype * device.c: device_description (Fmake_device): added variant initialization * device-impl.h (struct device): added enum console_variant devtype * objects.c: image_instance_description font_instance_description (Fmake_color_instance): added variant initialization (Fmake_font_instance): added variant initialization * objects-impl.h (struct Lisp_Color_Instance): added color_instance_type * objects-impl.h (struct Lisp_Font_Instance): added font_instance_type * process.c: process_description (make_process_internal): added variant initialization * process.h (process_variant): the different process types

author	michaels
date	Mon, 29 Jul 2002 09:21:25 +0000
parents	ccc3177ef10b
children	345b7d75cab4

comparison

equal deleted inserted replaced

-:f6bc42928b34
+:c925bacdda60
 #include "specifier.h"
 #include "sysfile.h"
 #include "sysdep.h"
 #include "window.h"
 #include "console-stream.h"
+#ifdef USE_KKCC
+#include "file-coding.h"
+#endif /* USE_KKCC */
 #ifdef DOUG_LEA_MALLOC
 #include <malloc.h>
 #endif
 { XD_LISP_OBJECT, offsetof (Lisp_Cons, car_) },
 { XD_LISP_OBJECT, offsetof (Lisp_Cons, cdr_) },
 { XD_END }
 };
+#ifdef USE_KKCC
+DEFINE_BASIC_LRECORD_IMPLEMENTATION ("cons", cons,
+				     1, /*dumpable-flag*/
+				     mark_cons, print_cons, 0,
+				     cons_equal,
+				     /*
+				      * No `hash' method needed.
+				      * internal_hash knows how to
+				      * handle conses.
+				      */
+				     0,
+				     cons_description,
+				     Lisp_Cons);
+#else /* not USE_KKCC */
 DEFINE_BASIC_LRECORD_IMPLEMENTATION ("cons", cons,
 				     mark_cons, print_cons, 0,
 				     cons_equal,
 				     /*
 				      * No `hash' method needed.
 				      * handle conses.
 				      */
 				     0,
 				     cons_description,
 				     Lisp_Cons);
+#endif /* not USE_KKCC */
 DEFUN ("cons", Fcons, 2, 2, 0, /*
 Create a new cons, give it CAR and CDR as components, and return it.
 */
 (car, cdr))
 { XD_LONG,              offsetof (Lisp_Vector, size) },
 { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Vector, contents), XD_INDIRECT(0, 0) },
 { XD_END }
 };
+#ifdef USE_KKCC
+DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION("vector", vector,
+				       1, /*dumpable-flag*/
+				       mark_vector, print_vector, 0,
+				       vector_equal,
+				       vector_hash,
+				       vector_description,
+				       size_vector, Lisp_Vector);
+#else /* not USE_KKCC */
 DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION("vector", vector,
 				       mark_vector, print_vector, 0,
 				       vector_equal,
 				       vector_hash,
 				       vector_description,
 				       size_vector, Lisp_Vector);
+#endif /* not USE_KKCC */
 /* #### should allocate `small' vectors from a frob-block */
 static Lisp_Vector *
 make_vector_internal (Elemcount sizei)
 {
 /* no vector_next */
 set_lheader_implementation (&e->lheader, &lrecord_event);
 return wrap_event (e);
 }
+#ifdef USE_KKCC
+DECLARE_FIXED_TYPE_ALLOC (key_data, Lisp_Key_Data);
+#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_key_data 1000
+Lisp_Object
+allocate_key_data (void)
+{
+Lisp_Key_Data *d;
+ALLOCATE_FIXED_TYPE (key_data, Lisp_Key_Data, d);
+set_lheader_implementation (&d->lheader, &lrecord_key_data);
+return wrap_key_data(d);
+}
+DECLARE_FIXED_TYPE_ALLOC (button_data, Lisp_Button_Data);
+#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_button_data 1000
+Lisp_Object
+allocate_button_data (void)
+{
+Lisp_Button_Data *d;
+ALLOCATE_FIXED_TYPE (button_data, Lisp_Button_Data, d);
+set_lheader_implementation (&d->lheader, &lrecord_button_data);
+return wrap_button_data(d);
+}
+DECLARE_FIXED_TYPE_ALLOC (motion_data, Lisp_Motion_Data);
+#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_motion_data 1000
+Lisp_Object
+allocate_motion_data (void)
+{
+Lisp_Motion_Data *d;
+ALLOCATE_FIXED_TYPE (motion_data, Lisp_Motion_Data, d);
+set_lheader_implementation (&d->lheader, &lrecord_motion_data);
+return wrap_motion_data(d);
+}
+DECLARE_FIXED_TYPE_ALLOC (process_data, Lisp_Process_Data);
+#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_process_data 1000
+Lisp_Object
+allocate_process_data (void)
+{
+Lisp_Process_Data *d;
+ALLOCATE_FIXED_TYPE (process_data, Lisp_Process_Data, d);
+set_lheader_implementation (&d->lheader, &lrecord_process_data);
+return wrap_process_data(d);
+}
+DECLARE_FIXED_TYPE_ALLOC (timeout_data, Lisp_Timeout_Data);
+#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_timeout_data 1000
+Lisp_Object
+allocate_timeout_data (void)
+{
+Lisp_Timeout_Data *d;
+ALLOCATE_FIXED_TYPE (timeout_data, Lisp_Timeout_Data, d);
+set_lheader_implementation (&d->lheader, &lrecord_timeout_data);
+return wrap_timeout_data(d);
+}
+DECLARE_FIXED_TYPE_ALLOC (magic_data, Lisp_Magic_Data);
+#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_magic_data 1000
+Lisp_Object
+allocate_magic_data (void)
+{
+Lisp_Magic_Data *d;
+ALLOCATE_FIXED_TYPE (magic_data, Lisp_Magic_Data, d);
+set_lheader_implementation (&d->lheader, &lrecord_magic_data);
+return wrap_magic_data(d);
+}
+DECLARE_FIXED_TYPE_ALLOC (magic_eval_data, Lisp_Magic_Eval_Data);
+#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_magic_eval_data 1000
+Lisp_Object
+allocate_magic_eval_data (void)
+{
+Lisp_Magic_Eval_Data *d;
+ALLOCATE_FIXED_TYPE (magic_eval_data, Lisp_Magic_Eval_Data, d);
+set_lheader_implementation (&d->lheader, &lrecord_magic_eval_data);
+return wrap_magic_eval_data(d);
+}
+DECLARE_FIXED_TYPE_ALLOC (eval_data, Lisp_Eval_Data);
+#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_eval_data 1000
+Lisp_Object
+allocate_eval_data (void)
+{
+Lisp_Eval_Data *d;
+ALLOCATE_FIXED_TYPE (eval_data, Lisp_Eval_Data, d);
+set_lheader_implementation (&d->lheader, &lrecord_eval_data);
+return wrap_eval_data(d);
+}
+DECLARE_FIXED_TYPE_ALLOC (misc_user_data, Lisp_Misc_User_Data);
+#define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_misc_user_data 1000
+Lisp_Object
+allocate_misc_user_data (void)
+{
+Lisp_Misc_User_Data *d;
+ALLOCATE_FIXED_TYPE (misc_user_data, Lisp_Misc_User_Data, d);
+set_lheader_implementation (&d->lheader, &lrecord_misc_user_data);
+return wrap_misc_user_data(d);
+}
+#endif /* USE_KKCC */
 /************************************************************************/
 /*			 Marker allocation				*/
 /************************************************************************/
 /* No `finalize', or `hash' methods.
 internal_hash() already knows how to hash strings and finalization
 is done with the ADDITIONAL_FREE_string macro, which is the
 standard way to do finalization when using
 SWEEP_FIXED_TYPE_BLOCK(). */
+#ifdef USE_KKCC
+DEFINE_BASIC_LRECORD_IMPLEMENTATION_WITH_PROPS ("string", string,
+						1, /*dumpable-flag*/
+						mark_string, print_string,
+						0, string_equal, 0,
+						string_description,
+						string_getprop,
+						string_putprop,
+						string_remprop,
+						string_plist,
+						Lisp_String);
+#else /* not USE_KKCC */
 DEFINE_BASIC_LRECORD_IMPLEMENTATION_WITH_PROPS ("string", string,
 						mark_string, print_string,
 						0, string_equal, 0,
 						string_description,
 						string_getprop,
 						string_putprop,
 						string_remprop,
 						string_plist,
 						Lisp_String);
+#endif /* not USE_KKCC */
 /* String blocks contain this many useful bytes. */
 #define STRING_CHARS_BLOCK_SIZE					\
 ((Bytecount) (8192 - MALLOC_OVERHEAD -			\
 	        ((2 * sizeof (struct string_chars_block *))	\
 	         + sizeof (EMACS_INT))))
 }
 return Qnil;
 }
+#ifdef USE_KKCC
+DEFINE_LRECORD_IMPLEMENTATION ("lcrecord-list", lcrecord_list,
+			       0, /*dumpable-flag*/
+			       mark_lcrecord_list, internal_object_printer,
+			       0, 0, 0, 0, struct lcrecord_list);
+#else /* not USE_KKCC */
 DEFINE_LRECORD_IMPLEMENTATION ("lcrecord-list", lcrecord_list,
 			       mark_lcrecord_list, internal_object_printer,
 			       0, 0, 0, 0, struct lcrecord_list);
+#endif /* not USE_KKCC */
 Lisp_Object
 make_lcrecord_list (Elemcount size,
 		    const struct lrecord_implementation *implementation)
 {
 struct lcrecord_list *p =
 } while (0)
 #else
 #define GC_CHECK_LHEADER_INVARIANTS(lheader)
 #endif
+#ifdef USE_KKCC
+/* The following functions implement the new mark algorithm.
+They mark objects according to their descriptions. They
+are modeled on the corresponding pdumper procedures. */
+static void mark_struct_contents (const void *data,
+						   const struct struct_description *
+						   sdesc,
+						   int count);
+/* This function extracts the value of a count variable described somewhere
+else in the description. It is converted corresponding to the type */
+static EMACS_INT
+get_indirect_count (EMACS_INT code,
+			  const struct lrecord_description *idesc,
+			  const void *idata)
+{
+EMACS_INT count;
+const void *irdata;
+int line = XD_INDIRECT_VAL (code);
+int delta = XD_INDIRECT_DELTA (code);
+irdata = ((char *)idata) + idesc[line].offset;
+switch (idesc[line].type)
+{
+case XD_BYTECOUNT:
+count = *(Bytecount *)irdata;
+break;
+case XD_ELEMCOUNT:
+count = *(Elemcount *)irdata;
+break;
+case XD_HASHCODE:
+count = *(Hashcode *)irdata;
+break;
+case XD_INT:
+count = *(int *)irdata;
+break;
+case XD_LONG:
+count = *(long *)irdata;
+break;
+default:
+stderr_out ("Unsupported count type : %d (line = %d, code = %ld)\n",
+		  idesc[line].type, line, (long)code);
+count = 0; /* warning suppression */
+abort ();
+}
+count += delta;
+return count;
+}
+/* This function is called to mark the elements of an object. It processes
+the description of the object and calls mark object with every described
+object. */
+static void
+mark_with_description (const void *lheader, const struct lrecord_description *desc)
+{
+int pos;
+static const Lisp_Object *last_occured_object = (Lisp_Object *) 0;
+static int mark_last_occured_object = 0;
+reprocess_desc:
+for (pos=0; desc[pos].type != XD_END; pos++)
+{
+const void *rdata = (const char *)lheader + desc[pos].offset;
+switch (desc[pos].type) {
+case XD_LISP_OBJECT:
+	{
+	  const Lisp_Object *stored_obj = (const Lisp_Object *)rdata;
+	  if (!(*stored_obj)){
+	    break;
+	  }
+	  if (desc[pos+1].type == XD_END)
+	    {
+	      mark_last_occured_object = 1;
+	      last_occured_object = stored_obj;
+	      break;
+	    }
+	  else
+	    {
+	      mark_object (*stored_obj);
+	    }
+	  break;
+	}
+case XD_LISP_OBJECT_ARRAY:
+	{
+	  int i;
+	  EMACS_INT count = desc[pos].data1;
+	  if (XD_IS_INDIRECT (count))
+	    count = get_indirect_count (count, desc, lheader);
+	  for (i = 0; i < count; i++)
+	    {
+	      const Lisp_Object *stored_obj = ((const Lisp_Object *)rdata) + i;
+	      if (!(*stored_obj))
+		{
+		  break;
+		}
+	      mark_object (*stored_obj);
+	    }
+	  break;
+	}
+case XD_SPECIFIER_END:
+	desc = ((const Lisp_Specifier *)lheader)->methods->extra_description;
+	goto reprocess_desc;
+	break;
+case XD_CODING_SYSTEM_END:
+	desc = ((const Lisp_Coding_System *)lheader)->methods->extra_description;
+	goto reprocess_desc;
+	break;
+case XD_BYTECOUNT:
+	break;
+case XD_ELEMCOUNT:
+	break;
+case XD_HASHCODE:
+	break;
+case XD_INT:
+	break;
+case XD_LONG:
+	break;
+case XD_INT_RESET:
+	break;
+case XD_LO_LINK:
+	break;
+case XD_OPAQUE_PTR:
+	break;
+case XD_OPAQUE_DATA_PTR:
+	break;
+case XD_C_STRING:
+	break;
+case XD_DOC_STRING:
+	break;
+case XD_STRUCT_PTR:
+	{
+	  EMACS_INT count = desc[pos].data1;
+	  const struct struct_description *sdesc = desc[pos].data2;
+	  const char *dobj = *(const char **)rdata;
+	  if (dobj)
+	    {
+	      if (XD_IS_INDIRECT (count))
+		count = get_indirect_count (count, desc, lheader);
+	      mark_struct_contents (dobj, sdesc, count);
+	    }
+	  break;
+	}
+case XD_STRUCT_ARRAY:
+	{
+	  EMACS_INT count = desc[pos].data1;
+	  const struct struct_description *sdesc = desc[pos].data2;
+	  if (XD_IS_INDIRECT (count))
+	    count = get_indirect_count (count, desc, lheader);
+	  mark_struct_contents (rdata, sdesc, count);
+	  break;
+	}
+case XD_UNION:
+	{
+	  int count = 0;
+	  int variant = desc[pos].data1;
+	  const struct struct_description *sdesc = desc[pos].data2;
+	  const char *dobj = *(const char **)rdata;
+	  if (XD_IS_INDIRECT (variant))
+	    variant = get_indirect_count (variant, desc, lheader);
+	  for (count=0; sdesc[count].size != XD_END; count++)
+	    {
+	      if (sdesc[count].size == variant)
+		{
+		  mark_with_description(dobj, sdesc[count].description);
+		  break;
+		}
+	    }
+	  break;
+	}
+default:
+	stderr_out ("Unsupported description type : %d\n", desc[pos].type);
+	abort ();
+}
+}
+if (mark_last_occured_object)
+{
+mark_object(*last_occured_object);
+mark_last_occured_object = 0;
+}
+}
+/* This function calculates the size of a described struct. */
+static Bytecount
+structure_size (const void *obj, const struct struct_description *sdesc)
+{
+int max_offset = -1;
+int max_offset_pos = -1;
+int size_at_max = 0;
+int pos;
+const struct lrecord_description *desc;
+void *rdata;
+if (sdesc->size)
+return sdesc->size;
+desc = sdesc->description;
+for (pos = 0; desc[pos].type != XD_END; pos++)
+{
+if (desc[pos].offset == max_offset)
+	{
+	  stderr_out ("Two relocatable elements at same offset?\n");
+	  abort ();
+	}
+else if (desc[pos].offset > max_offset)
+	{
+	  max_offset = desc[pos].offset;
+	  max_offset_pos = pos;
+	}
+}
+if (max_offset_pos < 0)
+return 0;
+pos = max_offset_pos;
+rdata = (char *) obj + desc[pos].offset;
+switch (desc[pos].type)
+{
+case XD_LISP_OBJECT_ARRAY:
+{
+	EMACS_INT val = desc[pos].data1;
+	if (XD_IS_INDIRECT (val))
+	  val = get_indirect_count (val, desc, obj);
+	size_at_max = val * sizeof (Lisp_Object);
+	break;
+}
+case XD_LISP_OBJECT:
+case XD_LO_LINK:
+size_at_max = sizeof (Lisp_Object);
+break;
+case XD_OPAQUE_PTR:
+size_at_max = sizeof (void *);
+break;
+case XD_STRUCT_PTR:
+{
+	EMACS_INT val = desc[pos].data1;
+	if (XD_IS_INDIRECT (val))
+	  val = get_indirect_count (val, desc, obj);
+	size_at_max = val * sizeof (void *);
+	break;
+}
+break;
+case XD_STRUCT_ARRAY:
+{
+	EMACS_INT val = desc[pos].data1;
+	if (XD_IS_INDIRECT (val))
+	  val = get_indirect_count (val, desc, obj);
+	size_at_max = val * structure_size (rdata, desc[pos].data2);
+	break;
+}
+break;
+case XD_OPAQUE_DATA_PTR:
+size_at_max = sizeof (void *);
+break;
+case XD_UNION:
+abort ();
+break;
+case XD_C_STRING:
+size_at_max = sizeof (void *);
+break;
+case XD_DOC_STRING:
+size_at_max = sizeof (void *);
+break;
+case XD_INT_RESET:
+size_at_max = sizeof (int);
+break;
+case XD_BYTECOUNT:
+size_at_max = sizeof (Bytecount);
+break;
+case XD_ELEMCOUNT:
+size_at_max = sizeof (Elemcount);
+break;
+case XD_HASHCODE:
+size_at_max = sizeof (Hashcode);
+break;
+case XD_INT:
+size_at_max = sizeof (int);
+break;
+case XD_LONG:
+size_at_max = sizeof (long);
+break;
+case XD_SPECIFIER_END:
+case XD_CODING_SYSTEM_END:
+stderr_out
+	("Should not be seeing XD_SPECIFIER_END or\n"
+	 "XD_CODING_SYSTEM_END outside of struct Lisp_Specifier\n"
+	 "and struct Lisp_Coding_System.\n");
+abort ();
+default:
+stderr_out ("Unsupported dump type : %d\n", desc[pos].type);
+abort ();
+}
+return ALIGN_SIZE (max_offset + size_at_max, ALIGNOF (max_align_t));
+}
+/* This function loops all elements of a struct pointer and calls
+mark_with_description with each element. */
+static void
+mark_struct_contents (const void *data,
+				const struct struct_description *sdesc,
+				int count)
+{
+int i;
+Bytecount elsize;
+elsize = structure_size (data, sdesc);
+for (i = 0; i < count; i++)
+{
+mark_with_description (((char *) data) + elsize * i,
+					  sdesc->description);
+}
+}
+#endif /* USE_KKCC */
 /* Mark reference to a Lisp_Object.  If the object referred to has not been
 seen yet, recursively mark all the references contained in it. */
 void
 mark_object (Lisp_Object obj)
 /* if (PURIFIED (XPNTR (obj))) return; */
 if (XTYPE (obj) == Lisp_Type_Record)
 {
 struct lrecord_header *lheader = XRECORD_LHEADER (obj);
+#ifdef USE_KKCC
+const struct lrecord_implementation *imp;
+const struct lrecord_description *desc;
+#endif /* USE_KKCC */
 GC_CHECK_LHEADER_INVARIANTS (lheader);
 gc_checking_assert (LHEADER_IMPLEMENTATION (lheader)->basic_p ||
 			  ! ((struct lcrecord_header *) lheader)->free);
 	 so that we only need to check the mark bit here. */
 if (! MARKED_RECORD_HEADER_P (lheader))
 	{
 	  MARK_RECORD_HEADER (lheader);
-	  if (RECORD_MARKER (lheader))
+#ifdef USE_KKCC
+	  imp = LHEADER_IMPLEMENTATION (lheader);
+	  desc = imp->description;
+	  if (desc) /* && !CONSP(obj))*/  /* KKCC cons special case */
 	    {
-	      obj = RECORD_MARKER (lheader) (obj);
+	      mark_with_description (lheader, desc);
-	      if (!NILP (obj)) goto tail_recurse;
 	    }
+	  else
+	    {
+#endif /* USE_KKCC */
+	      if (RECORD_MARKER (lheader))
+		{
+		  obj = RECORD_MARKER (lheader) (obj);
+		  if (!NILP (obj)) goto tail_recurse;
+		}
+#ifdef USE_KKCC
+	    }
+#endif /* USE_KKCC */
 	}
 }
 }
 /* mark all of the conses in a list and mark the final cdr; but
 #define ADDITIONAL_FREE_event(ptr)
 SWEEP_FIXED_TYPE_BLOCK (event, Lisp_Event);
 }
+#ifdef USE_KKCC
+static void
+sweep_key_data (void)
+{
+#define UNMARK_key_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_key_data(ptr)
+SWEEP_FIXED_TYPE_BLOCK (key_data, Lisp_Key_Data);
+}
+static void
+sweep_button_data (void)
+{
+#define UNMARK_button_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_button_data(ptr)
+SWEEP_FIXED_TYPE_BLOCK (button_data, Lisp_Button_Data);
+}
+static void
+sweep_motion_data (void)
+{
+#define UNMARK_motion_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_motion_data(ptr)
+SWEEP_FIXED_TYPE_BLOCK (motion_data, Lisp_Motion_Data);
+}
+static void
+sweep_process_data (void)
+{
+#define UNMARK_process_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_process_data(ptr)
+SWEEP_FIXED_TYPE_BLOCK (process_data, Lisp_Process_Data);
+}
+static void
+sweep_timeout_data (void)
+{
+#define UNMARK_timeout_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_timeout_data(ptr)
+SWEEP_FIXED_TYPE_BLOCK (timeout_data, Lisp_Timeout_Data);
+}
+static void
+sweep_magic_data (void)
+{
+#define UNMARK_magic_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_magic_data(ptr)
+SWEEP_FIXED_TYPE_BLOCK (magic_data, Lisp_Magic_Data);
+}
+static void
+sweep_magic_eval_data (void)
+{
+#define UNMARK_magic_eval_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_magic_eval_data(ptr)
+SWEEP_FIXED_TYPE_BLOCK (magic_eval_data, Lisp_Magic_Eval_Data);
+}
+static void
+sweep_eval_data (void)
+{
+#define UNMARK_eval_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_eval_data(ptr)
+SWEEP_FIXED_TYPE_BLOCK (eval_data, Lisp_Eval_Data);
+}
+static void
+sweep_misc_user_data (void)
+{
+#define UNMARK_misc_user_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
+#define ADDITIONAL_FREE_misc_user_data(ptr)
+SWEEP_FIXED_TYPE_BLOCK (misc_user_data, Lisp_Misc_User_Data);
+}
+#endif /* USE_KKCC */
 static void
 sweep_markers (void)
 {
 #define UNMARK_marker(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_marker(ptr)					\
 Dechain each one first from the buffer into which it points. */
 sweep_markers ();
 sweep_events ();
+#ifdef USE_KKCC
+sweep_key_data ();
+sweep_button_data ();
+sweep_motion_data ();
+sweep_process_data ();
+sweep_timeout_data ();
+sweep_magic_data ();
+sweep_magic_eval_data ();
+sweep_eval_data ();
+sweep_misc_user_data ();
+#endif /* USE_KKCC */
 #ifdef PDUMP
 pdump_objects_unmark ();
 #endif
 }
 ())
 {
 Lisp_Object pl = Qnil;
 int i;
 int gc_count_vector_total_size = 0;
 garbage_collect_1 ();
 for (i = 0; i < lrecord_type_count; i++)
 {
 if (lcrecord_stats[i].bytes_in_use != 0
 init_float_alloc ();
 #endif /* LISP_FLOAT_TYPE */
 init_marker_alloc ();
 init_extent_alloc ();
 init_event_alloc ();
+#ifdef USE_KKCC
+init_key_data_alloc ();
+init_button_data_alloc ();
+init_motion_data_alloc ();
+init_process_data_alloc ();
+init_timeout_data_alloc ();
+init_magic_data_alloc ();
+init_magic_eval_data_alloc ();
+init_eval_data_alloc ();
+init_misc_user_data_alloc ();
+#endif /* USE_KKCC */
 ignore_malloc_warnings = 0;
 if (staticpros_nodump)
 Dynarr_free (staticpros_nodump);

Mercurial > hg > xemacs-beta

comparison src/alloc.c @ 934:c925bacdda60