xemacs-beta: src/lrecord.h comparison

comparison src/lrecord.h @ 424:11054d720c21 r21-2-20

Import from CVS: tag r21-2-20

author	cvs
date	Mon, 13 Aug 2007 11:26:11 +0200
parents	41dbb7a9d5f2
children

comparison

equal deleted inserted replaced

-:28d9c139be4c
+:11054d720c21
 struct lcrecord_header lcheader;
 Lisp_Object chain;
 };
 /* see alloc.c for an explanation */
-Lisp_Object this_one_is_unmarkable (Lisp_Object obj,
+Lisp_Object this_one_is_unmarkable (Lisp_Object obj);
-				    void (*markobj) (Lisp_Object));
 struct lrecord_implementation
 {
 CONST char *name;
 /* This function is called at GC time, to make sure that all Lisp_Objects
 marked (don't call the mark_object function explicitly on it,
 because the GC routines will do this).  Doing it this way reduces
 recursion, so the object returned should preferably be the one
 with the deepest level of Lisp_Object pointers.  This function
 can be NULL, meaning no GC marking is necessary. */
-Lisp_Object (*marker) (Lisp_Object, void (*mark_object) (Lisp_Object));
+Lisp_Object (*marker) (Lisp_Object);
 /* This can be NULL if the object is an lcrecord; the
 default_object_printer() in print.c will be used. */
 void (*printer) (Lisp_Object, Lisp_Object printcharfun, int escapeflag);
 /* This function is called at GC time when the object is about to
 be freed, and at dump time (FOR_DISKSAVE will be non-zero in this
 A lrecord external description  is an array  of values.  The  first
 value of each line is a type, the second  the offset in the lrecord
 structure.  Following values  are parameters, their  presence, type
 and number is type-dependant.
-The description ends with a "XD_END" record.
+The description ends with a "XD_END" or "XD_SPECIFIER_END" record.
 Some example descriptions :
 static const struct lrecord_description cons_description[] = {
 { XD_LISP_OBJECT, offsetof(struct Lisp_Cons, car), 2 },
 { XD_END }
 };
 Which means "two lisp objects starting at the 'car' element"
 static const struct lrecord_description string_description[] = {
-{ XD_STRING_DATA, offsetof(Lisp_String, data) },
+{ XD_BYTECOUNT,       offsetof(Lisp_String, size) },
-{ XD_LISP_OBJECT, offsetof(Lisp_String, plist), 1 },
+{ XD_OPAQUE_DATA_PTR, offsetof(Lisp_String, data), XD_INDIRECT(0, 1) },
+{ XD_LISP_OBJECT,     offsetof(Lisp_String, plist), 1 },
 { XD_END }
 };
-"A string data pointer at 'data', one lisp object at 'plist'"
+"A pointer to string data at 'data', the size of the pointed array being the value
+of the size variable plus 1, and one lisp object at 'plist'"
 The existing types :
 XD_LISP_OBJECT
 Lisp objects.  The third element is the count.  This is also the type to use
 for pointers to other lrecords.
-XD_STRING_DATA
+XD_LO_RESET_NIL
-Pointer to string data.
+Lisp objects which will be reset to Qnil when dumping.  Useful for cleaning
+up caches.
+XD_LO_LINK
+Link in a linked list of objects of the same type.
 XD_OPAQUE_PTR
 Pointer to undumpable data.  Must be NULL when dumping.
 XD_STRUCT_PTR
 Pointer to described struct.  Parameters are number of structures and
 XD_OPAQUE_DATA_PTR
 Pointer to dumpable opaque data.  Parameter is the size of the data.
 Pointed data must be relocatable without changes.
+XD_C_STRING
+Pointer to a C string.
+XD_DOC_STRING
+Pointer to a doc string (C string if positive, opaque value if negative)
+XD_INT_RESET
+An integer which will be reset to a given value in the dump file.
 XD_SIZE_T
 size_t value.  Used for counts.
 XD_INT
 int value.  Used for counts.
 XD_LONG
 long value.  Used for counts.
+XD_BYTECOUNT
+bytecount value.  Used for counts.
 XD_END
 Special type indicating the end of the array.
+XD_SPECIFIER_END
+Special type indicating the end of the array for a specifier.  Extra
+description is going to be fetched from the specifier methods.
 Special macros:
-XD_INDIRECT(line)
+XD_INDIRECT(line, delta)
-Usable where a "count" or "size" is requested.  Gives the value of the element
+Usable where  a "count" or "size"  is requested.  Gives the value of
-which is at line number 'line' in the description (count starts at zero).
+the element which is at line number 'line' in the description (count
+starts at zero) and adds delta to it.
-XD_PARENT_INDIRECT(line)
-Same as XD_INDIRECT but the element number refers to the parent structure.
-Usable only in struct descriptions.
 */
 enum lrecord_description_type {
 XD_LISP_OBJECT,
-XD_STRING_DATA,
+XD_LO_RESET_NIL,
+XD_LO_LINK,
 XD_OPAQUE_PTR,
 XD_STRUCT_PTR,
 XD_OPAQUE_DATA_PTR,
+XD_C_STRING,
+XD_DOC_STRING,
+XD_INT_RESET,
 XD_SIZE_T,
 XD_INT,
 XD_LONG,
-XD_END
+XD_BYTECOUNT,
+XD_END,
+XD_SPECIFIER_END
 };
 struct lrecord_description {
 enum lrecord_description_type type;
 int offset;
 struct struct_description {
 size_t size;
 const struct lrecord_description *description;
 };
-#define XD_INDIRECT(count) (-1-(count))
+#define XD_INDIRECT(val, delta) (-1-((val)|(delta<<8)))
-#define XD_PARENT_INDIRECT(count) (-1000-(count))
+#define XD_IS_INDIRECT(code) (code<0)
+#define XD_INDIRECT_VAL(code) ((-1-code) & 255)
+#define XD_INDIRECT_DELTA(code) (((-1-code)>>8) & 255)
 #define XD_DYNARR_DESC(base_type, sub_desc) \
-{ XD_STRUCT_PTR, offsetof(base_type, base), XD_INDIRECT(1), sub_desc }, \
+{ XD_STRUCT_PTR, offsetof(base_type, base), XD_INDIRECT(1, 0), sub_desc }, \
-{ XD_INT,        offsetof(base_type, max) }
+{ XD_INT,        offsetof(base_type, cur) }, \
+{ XD_INT_RESET,  offsetof(base_type, max), XD_INDIRECT(1, 0) }
 /* Declaring the following structures as const puts them in the
 text (read-only) segment, which makes debugging inconvenient
 because this segment is not mapped when processing a core-
 dump file */
 CONST_IF_NOT_DEBUG struct lrecord_implementation lrecord_##c_name =	\
 { name, marker, printer, nuker, equal, hash, desc,			\
 getprop, putprop, remprop, props, size, sizer,			\
 &(lrecord_##c_name##_lrecord_type_index), basic_p }			\
-#define LRECORDP(a) (XTYPE ((a)) == Lisp_Type_Record)
+#define LRECORDP(a) (XTYPE (a) == Lisp_Type_Record)
 #define XRECORD_LHEADER(a) ((struct lrecord_header *) XPNTR (a))
 #define RECORD_TYPEP(x, ty) \
 (LRECORDP (x) && \
 lrecord_implementations_table[XRECORD_LHEADER (x)->type] == (ty))
 lrecord_##c_name;						\
 INLINE structtype *error_check_##c_name (Lisp_Object obj);	\
 INLINE structtype *						\
 error_check_##c_name (Lisp_Object obj)				\
 {								\
-assert (RECORD_TYPEP (obj, &lrecord_##c_name) ||		\
+assert (RECORD_TYPEP (obj, &lrecord_##c_name));		\
-	  MARKED_RECORD_P (obj));				\
 return (structtype *) XPNTR (obj);				\
 }								\
 extern Lisp_Object Q##c_name##p
 # define DECLARE_NONRECORD(c_name, type_enum, structtype)	\
 INLINE structtype *error_check_##c_name (Lisp_Object obj);	\
 INLINE structtype *						\
 error_check_##c_name (Lisp_Object obj)				\
 {								\
-assert (XGCTYPE (obj) == type_enum);				\
+assert (XTYPE (obj) == type_enum);				\
 return (structtype *) XPNTR (obj);				\
 }								\
 extern Lisp_Object Q##c_name##p
 # define XRECORD(x, c_name, structtype) error_check_##c_name (x)
 # define XNONRECORD(x, c_name, type_enum, structtype) error_check_##c_name (x)
 # define XSETRECORD(var, p, c_name) do				\
 {								\
 XSETOBJ (var, Lisp_Type_Record, p);				\
-assert (RECORD_TYPEP (var, &lrecord_##c_name) ||		\
+assert (RECORD_TYPEP (var, &lrecord_##c_name));		\
-	  MARKED_RECORD_P (var));				\
 } while (0)
 #else /* not ERROR_CHECK_TYPECHECK */
 # define DECLARE_LRECORD(c_name, structtype)			\
 # define XSETRECORD(var, p, c_name) XSETOBJ (var, Lisp_Type_Record, p)
 #endif /* not ERROR_CHECK_TYPECHECK */
 #define RECORDP(x, c_name) RECORD_TYPEP (x, &lrecord_##c_name)
-#define GC_RECORDP(x, c_name) gc_record_type_p (x, &lrecord_##c_name)
 /* Note: we now have two different kinds of type-checking macros.
 The "old" kind has now been renamed CONCHECK_foo.  The reason for
 this is that the CONCHECK_foo macros signal a continuable error,
 allowing the user (through debug-on-error) to substitute a different
 void *alloc_lcrecord (size_t size, CONST struct lrecord_implementation *);
 #define alloc_lcrecord_type(type, lrecord_implementation) \
 ((type *) alloc_lcrecord (sizeof (type), lrecord_implementation))
-int gc_record_type_p (Lisp_Object frob,
-		      CONST struct lrecord_implementation *type);
 /* Copy the data from one lcrecord structure into another, but don't
 overwrite the header information. */
 #define copy_lcrecord(dst, src)					\
 memcpy ((char *) dst + sizeof (struct lcrecord_header),	\

Mercurial > hg > xemacs-beta

comparison src/lrecord.h @ 424:11054d720c21 r21-2-20