X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Flisp-union.h;h=e85366832efa110ce444a4bb540b5c72f25a7dbb;hb=2265c01ed23e9411a4e24786273599d1426d63e2;hp=14067810af7d28aea9d7560989cdccafc2445017;hpb=6883ee56ec887c2c48abe5b06b5e66aa74031910;p=chise%2Fxemacs-chise.git.1

diff --git a/src/lisp-union.h b/src/lisp-union.h
index 1406781..e853668 100644
--- a/src/lisp-union.h
+++ b/src/lisp-union.h
@@ -23,20 +23,17 @@ Boston, MA 02111-1307, USA.  */
 
 /* Definition of Lisp_Object type as a union.
    The declaration order of the objects within the struct members
-   of the union is dependent on ENDIAN-ness and USE_MINIMAL_TAGBITS.
+   of the union is dependent on ENDIAN-ness.
    See lisp-disunion.h for more details.  */
 
 typedef
 union Lisp_Object
 {
   /* if non-valbits are at lower addresses */
-#if defined(WORDS_BIGENDIAN) == defined(USE_MINIMAL_TAGBITS)
+#ifdef WORDS_BIGENDIAN
   struct
   {
     EMACS_UINT val : VALBITS;
-#if GCMARKBITS > 0
-    unsigned int markbit: GCMARKBITS;
-#endif
     enum_field (Lisp_Type) type : GCTYPEBITS;
   } gu;
 
@@ -55,9 +52,6 @@ union Lisp_Object
   struct
   {
     enum_field (Lisp_Type) type : GCTYPEBITS;
-#if GCMARKBITS > 0
-    unsigned int markbit: GCMARKBITS;
-#endif
     EMACS_UINT val : VALBITS;
   } gu;
 
@@ -82,53 +76,54 @@ union Lisp_Object
      GCC to accept any (yes, any) pointer as the argument of
      a function declared to accept a Lisp_Object. */
   struct nosuchstruct *v;
-  CONST struct nosuchstruct *cv;
+  const struct nosuchstruct *cv;
 }
 Lisp_Object;
 
 #define XCHARVAL(x) ((x).gu.val)
 
-#ifdef USE_MINIMAL_TAGBITS
 # define XSETINT(var, value) do {	\
-  Lisp_Object *_xzx = &(var);		\
-  _xzx->s.val = (value);		\
-  _xzx->s.bits = 1;			\
+  EMACS_INT xset_value = (value);	\
+  Lisp_Object *xset_var = &(var);	\
+  xset_var->s.bits = 1;			\
+  xset_var->s.val = xset_value;		\
 } while (0)
 # define XSETCHAR(var, value) do {	\
-  Lisp_Object *_xzx = &(var);		\
-  _xzx->gu.val = (EMACS_UINT) (value);	\
-  _xzx->gu.type = Lisp_Type_Char;	\
+  Emchar xset_value = (value);		\
+  Lisp_Object *xset_var = &(var);	\
+  xset_var->gu.type = Lisp_Type_Char;	\
+  xset_var->gu.val = xset_value;	\
 } while (0)
-# define XSETOBJ(var, vartype, value)	\
-  ((void) ((var).ui = (EMACS_UINT) (value)))
-# define XPNTRVAL(x) ((x).ui)
-#else /* ! USE_MINIMAL_TAGBITS */
-# define XSETOBJ(var, vartype, value) do {	\
-  Lisp_Object *_xzx = &(var);			\
-  _xzx->gu.val = (EMACS_UINT) (value);		\
-  _xzx->gu.type = (vartype);			\
-  _xzx->gu.markbit = 0;				\
+# define XSETOBJ(var, value) do {		\
+  EMACS_UINT xset_value = (EMACS_UINT) (value);	\
+  (var).ui = xset_value;			\
 } while (0)
-# define XSETINT(var, value) XSETOBJ (var, Lisp_Type_Int, value)
-# define XSETCHAR(var, value) XSETOBJ (var, Lisp_Type_Char, value)
-# define XPNTRVAL(x) ((x).gu.val)
-#endif /* ! USE_MINIMAL_TAGBITS */
+# define XPNTRVAL(x) ((x).ui)
 
-INLINE Lisp_Object make_int (EMACS_INT val);
-INLINE Lisp_Object
+INLINE_HEADER Lisp_Object make_int (EMACS_INT val);
+INLINE_HEADER Lisp_Object
 make_int (EMACS_INT val)
 {
   Lisp_Object obj;
-  XSETINT(obj, val);
+  XSETINT (obj, val);
   return obj;
 }
 
-INLINE Lisp_Object make_char (Emchar val);
-INLINE Lisp_Object
+INLINE_HEADER Lisp_Object make_char (Emchar val);
+INLINE_HEADER Lisp_Object
 make_char (Emchar val)
 {
   Lisp_Object obj;
-  XSETCHAR(obj, val);
+  XSETCHAR (obj, val);
+  return obj;
+}
+
+INLINE_HEADER Lisp_Object wrap_object (void *ptr);
+INLINE_HEADER Lisp_Object
+wrap_object (void *ptr)
+{
+  Lisp_Object obj;
+  XSETOBJ (obj, ptr);
   return obj;
 }
 
@@ -137,37 +132,22 @@ extern Lisp_Object Qnull_pointer, Qzero;
 #define XREALINT(x) ((x).s.val)
 #define XUINT(x) ((x).u.val)
 #define XTYPE(x) ((x).gu.type)
-#define XGCTYPE(x) XTYPE (x)
 #define EQ(x,y) ((x).v == (y).v)
 
-#ifdef USE_MINIMAL_TAGBITS
 #define INTP(x) ((x).s.bits)
-#define GC_EQ(x,y) EQ (x, y)
-#else
-#define INTP(x) (XTYPE(x) == Lisp_Type_Int)
-#define GC_EQ(x,y) ((x).gu.val == (y).gu.val && XTYPE (x) == XTYPE (y))
-#endif
-
-#if GCMARKBITS > 0
-/* XMARKBIT accesses the markbit.  Markbits are used only in
-   particular slots of particular structure types.  Other markbits are
-   always zero.  Outside of garbage collection, all mark bits are
-   always zero. */
-# define XMARKBIT(x) ((x).gu.markbit)
-# define XMARK(x) ((void) (XMARKBIT (x) = 1))
-# define XUNMARK(x) ((void) (XMARKBIT (x) = 0))
-#else
-# define XUNMARK(x) DO_NOTHING
-#endif
+#define INT_PLUS(x,y)  make_int (XINT (x) + XINT (y))
+#define INT_MINUS(x,y) make_int (XINT (x) - XINT (y))
+#define INT_PLUS1(x)   make_int (XINT (x) + 1)
+#define INT_MINUS1(x)  make_int (XINT (x) - 1)
 
 /* Convert between a (void *) and a Lisp_Object, as when the
    Lisp_Object is passed to a toolkit callback function */
 #define VOID_TO_LISP(larg,varg) \
      ((void) ((larg).v = (struct nosuchstruct *) (varg)))
 #define CVOID_TO_LISP(larg,varg) \
-     ((void) ((larg).cv = (CONST struct nosuchstruct *) (varg)))
+     ((void) ((larg).cv = (const struct nosuchstruct *) (varg)))
 #define LISP_TO_VOID(larg) ((void *) ((larg).v))
-#define LISP_TO_CVOID(larg) ((CONST void *) ((larg).cv))
+#define LISP_TO_CVOID(larg) ((const void *) ((larg).cv))
 
 /* Convert a Lisp_Object into something that can't be used as an
    lvalue.  Useful for type-checking. */