]> git.eshelyaron.com Git - emacs.git/commitdiff
(PURE_BEF_ATTRS, PURE_AFT_ATTRS): New macros, by default empty.
authorThien-Thi Nguyen <ttn@gnuvola.org>
Sun, 2 May 2004 00:16:24 +0000 (00:16 +0000)
committerThien-Thi Nguyen <ttn@gnuvola.org>
Sun, 2 May 2004 00:16:24 +0000 (00:16 +0000)
(pure): Use new macros in decl.
[VMS, __GNUC__] (PURE_AFT_ATTRS): Define.
[VMS, not __GNUC__] (PURE_BEF_ATTRS): Define.

src/ChangeLog
src/alloc.c

index 6b428fb9c1ac8a9a36a4e2e7f4a654eed7bc250f..5b9a6fab0c8b6de7330d996e5a446a03f4621688 100644 (file)
@@ -1,3 +1,10 @@
+2004-05-02  Thien-Thi Nguyen  <ttn@gnu.org>
+
+       * alloc.c (PURE_BEF_ATTRS, PURE_AFT_ATTRS): New macros, by default empty.
+       (pure): Use new macros in decl.
+       (PURE_AFT_ATTRS) [VMS, __GNUC__]: Define.
+       (PURE_BEF_ATTRS) [VMS, not __GNUC__]: Define.
+
 2003-03-18  Francesco Potort\e,Al\e(B  <pot@gnu.org>
 
        * Version 21.3 released.
index 9497676560609e7cfba88f8647cbe75338a304d7..a71c75ca154159a26d54b97cac3a7fc83b060888 100644 (file)
@@ -188,10 +188,25 @@ Lisp_Object Vpurify_flag;
 
 /* Force it into data space! */
 
-EMACS_INT pure[PURESIZE / sizeof (EMACS_INT)] = {0,};
+#define PURE_BEF_ATTRS /* empty */
+#define PURE_AFT_ATTRS /* empty */
+
+#ifdef VMS
+#ifdef __GNUC__
+#undef PURE_AFT_ATTRS
+#define PURE_AFT_ATTRS asm("_$PsectAttributes_NOOVR$$EMACSPURE")
+#else /* not __GNUC__ */
+#undef PURE_BEF_ATTRS
+#define PURE_BEF_ATTRS globaldef {"EMACSPURE"}
+#endif /* not __GNUC__ */
+#endif /* VMS */
+
+PURE_BEF_ATTRS
+EMACS_INT pure[PURESIZE / sizeof (EMACS_INT)] PURE_AFT_ATTRS = {0,};
+
 #define PUREBEG (char *) pure
 
-#else /* not HAVE_SHM */
+#else /* HAVE_SHM */
 
 #define pure PURE_SEG_BITS   /* Use shared memory segment */
 #define PUREBEG (char *)PURE_SEG_BITS
@@ -205,7 +220,7 @@ EMACS_INT pure[PURESIZE / sizeof (EMACS_INT)] = {0,};
 
 EMACS_INT pure_size;
 
-#endif /* not HAVE_SHM */
+#endif /* HAVE_SHM */
 
 /* Value is non-zero if P points into pure space.  */
 
@@ -338,7 +353,7 @@ struct mem_node
 
   /* Node color.  */
   enum {MEM_BLACK, MEM_RED} color;
-  
+
   /* Memory type.  */
   enum mem_type type;
 };
@@ -590,14 +605,14 @@ lisp_malloc (nbytes, type)
 #ifdef GC_MALLOC_CHECK
   allocated_mem_type = type;
 #endif
-  
+
   val = (void *) malloc (nbytes);
 
 #if GC_MARK_STACK && !defined GC_MALLOC_CHECK
   if (val && type != MEM_TYPE_NON_LISP)
     mem_insert (val, (char *) val + nbytes, type);
 #endif
-   
+
   UNBLOCK_INPUT;
   if (!val && nbytes)
     memory_full ();
@@ -611,7 +626,7 @@ lisp_malloc (nbytes, type)
 struct buffer *
 allocate_buffer ()
 {
-  struct buffer *b 
+  struct buffer *b
     = (struct buffer *) lisp_malloc (sizeof (struct buffer),
                                     MEM_TYPE_BUFFER);
   VALIDATE_LISP_STORAGE (b, sizeof *b);
@@ -668,7 +683,7 @@ emacs_blocked_free (ptr)
   if (ptr)
     {
       struct mem_node *m;
-  
+
       m = mem_find (ptr);
       if (m == MEM_NIL || m->start != ptr)
        {
@@ -683,10 +698,10 @@ emacs_blocked_free (ptr)
        }
     }
 #endif /* GC_MALLOC_CHECK */
-  
+
   __free_hook = old_free_hook;
   free (ptr);
-  
+
   /* If we released our reserve (due to running out of memory),
      and we have a fair amount free once again,
      try to set aside another reserve in case we run out once more.  */
@@ -756,7 +771,7 @@ emacs_blocked_malloc (size)
       }
   }
 #endif /* GC_MALLOC_CHECK */
-  
+
   __malloc_hook = emacs_blocked_malloc;
   UNBLOCK_INPUT;
 
@@ -791,9 +806,9 @@ emacs_blocked_realloc (ptr, size)
 
       mem_delete (m);
     }
-  
+
   /* fprintf (stderr, "%p -> realloc\n", ptr); */
-  
+
   /* Prevent malloc from registering blocks.  */
   dont_register_blocks = 1;
 #endif /* GC_MALLOC_CHECK */
@@ -814,10 +829,10 @@ emacs_blocked_realloc (ptr, size)
     /* Can't handle zero size regions in the red-black tree.  */
     mem_insert (value, (char *) value + max (size, 1), MEM_TYPE_NON_LISP);
   }
-  
+
   /* fprintf (stderr, "%p <- realloc\n", value); */
 #endif /* GC_MALLOC_CHECK */
-  
+
   __realloc_hook = emacs_blocked_realloc;
   UNBLOCK_INPUT;
 
@@ -1063,13 +1078,13 @@ struct sdata
   struct Lisp_String *string;
 
 #ifdef GC_CHECK_STRING_BYTES
-  
+
   EMACS_INT nbytes;
   unsigned char data[1];
-  
+
 #define SDATA_NBYTES(S)        (S)->nbytes
 #define SDATA_DATA(S)  (S)->data
-  
+
 #else /* not GC_CHECK_STRING_BYTES */
 
   union
@@ -1080,7 +1095,7 @@ struct sdata
     /* When STRING is null.  */
     EMACS_INT nbytes;
   } u;
-  
+
 
 #define SDATA_NBYTES(S)        (S)->u.nbytes
 #define SDATA_DATA(S)  (S)->u.data
@@ -1159,7 +1174,7 @@ static int total_string_size;
    S must be live, i.e. S->data must not be null.  S->data is actually
    a pointer to the `u.data' member of its sdata structure; the
    structure starts at a constant offset in front of that.  */
-   
+
 #ifdef GC_CHECK_STRING_BYTES
 
 #define SDATA_OF_STRING(S) \
@@ -1232,7 +1247,7 @@ string_bytes (s)
     abort ();
   return nbytes;
 }
-    
+
 /* Check validity Lisp strings' string_bytes member in B.  */
 
 void
@@ -1240,25 +1255,25 @@ check_sblock (b)
      struct sblock *b;
 {
   struct sdata *from, *end, *from_end;
-      
+
   end = b->next_free;
-      
+
   for (from = &b->first_data; from < end; from = from_end)
     {
       /* Compute the next FROM here because copying below may
         overwrite data we need to compute it.  */
       int nbytes;
-      
+
       /* Check that the string size recorded in the string is the
         same as the one recorded in the sdata structure. */
       if (from->string)
        CHECK_STRING_BYTES (from->string);
-      
+
       if (from->string)
        nbytes = GC_STRING_BYTES (from->string);
       else
        nbytes = SDATA_NBYTES (from);
-      
+
       nbytes = SDATA_SIZE (nbytes);
       from_end = (struct sdata *) ((char *) from + nbytes);
     }
@@ -1283,7 +1298,7 @@ check_string_bytes (all_p)
          if (s)
            CHECK_STRING_BYTES (s);
        }
-      
+
       for (b = oldest_sblock; b; b = b->next)
        check_sblock (b);
     }
@@ -1389,12 +1404,12 @@ allocate_string_data (s, nchars, nbytes)
 #endif
 
       b = (struct sblock *) lisp_malloc (size, MEM_TYPE_NON_LISP);
-      
+
 #ifdef DOUG_LEA_MALLOC
       /* Back to a reasonable maximum of mmap'ed areas. */
       mallopt (M_MMAP_MAX, MMAP_MAX_AREAS);
 #endif
-  
+
       b->next_free = &b->first_data;
       b->first_data.string = NULL;
       b->next = large_sblocks;
@@ -1422,7 +1437,7 @@ allocate_string_data (s, nchars, nbytes)
 
   old_data = s->data ? SDATA_OF_STRING (s) : NULL;
   old_nbytes = GC_STRING_BYTES (s);
-  
+
   data = b->next_free;
   data->string = s;
   s->data = SDATA_DATA (data);
@@ -1433,7 +1448,7 @@ allocate_string_data (s, nchars, nbytes)
   s->size_byte = nbytes;
   s->data[nbytes] = '\0';
   b->next_free = (struct sdata *) ((char *) data + needed);
-  
+
   /* If S had already data assigned, mark that as free by setting its
      string back-pointer to null, and recording the size of the data
      in it.  */
@@ -1454,7 +1469,7 @@ sweep_strings ()
 {
   struct string_block *b, *next;
   struct string_block *live_blocks = NULL;
-  
+
   string_free_list = NULL;
   total_strings = total_free_strings = 0;
   total_string_size = 0;
@@ -1478,7 +1493,7 @@ sweep_strings ()
                {
                  /* String is live; unmark it and its intervals.  */
                  UNMARK_STRING (s);
-                 
+
                  if (!NULL_INTERVAL_P (s->intervals))
                    UNMARK_BALANCE_INTERVALS (s->intervals);
 
@@ -1550,7 +1565,7 @@ free_large_strings ()
 {
   struct sblock *b, *next;
   struct sblock *live_blocks = NULL;
-  
+
   for (b = large_sblocks; b; b = next)
     {
       next = b->next;
@@ -1591,7 +1606,7 @@ compact_small_strings ()
     {
       end = b->next_free;
       xassert ((char *) end <= (char *) b + SBLOCK_SIZE);
-      
+
       for (from = &b->first_data; from < end; from = from_end)
        {
          /* Compute the next FROM here because copying below may
@@ -1605,15 +1620,15 @@ compact_small_strings ()
              && GC_STRING_BYTES (from->string) != SDATA_NBYTES (from))
            abort ();
 #endif /* GC_CHECK_STRING_BYTES */
-         
+
          if (from->string)
            nbytes = GC_STRING_BYTES (from->string);
          else
            nbytes = SDATA_NBYTES (from);
-         
+
          nbytes = SDATA_SIZE (nbytes);
          from_end = (struct sdata *) ((char *) from + nbytes);
-         
+
          /* FROM->string non-null means it's alive.  Copy its data.  */
          if (from->string)
            {
@@ -1627,7 +1642,7 @@ compact_small_strings ()
                  to = &tb->first_data;
                  to_end = (struct sdata *) ((char *) to + nbytes);
                }
-             
+
              /* Copy, and update the string's `data' pointer.  */
              if (from != to)
                {
@@ -1694,7 +1709,7 @@ Both LENGTH and INIT must be numbers.")
          p += len;
        }
     }
-  
+
   *p = 0;
   return val;
 }
@@ -1722,16 +1737,16 @@ LENGTH must be a number.  INIT matters only in whether it is t or nil.")
      slot `size' of the struct Lisp_Bool_Vector.  */
   val = Fmake_vector (make_number (length_in_elts + 1), Qnil);
   p = XBOOL_VECTOR (val);
-  
+
   /* Get rid of any bits that would cause confusion.  */
   p->vector_size = 0;
   XSETBOOL_VECTOR (val, p);
   p->size = XFASTINT (length);
-  
+
   real_init = (NILP (init) ? 0 : -1);
   for (i = 0; i < length_in_chars ; i++)
     p->data[i] = real_init;
-  
+
   /* Clear the extraneous bits in the last byte.  */
   if (XINT (length) != length_in_chars * BITS_PER_CHAR)
     XBOOL_VECTOR (val)->data[length_in_chars - 1]
@@ -1976,7 +1991,7 @@ make_float (float_value)
        }
       XSETFLOAT (val, &float_block->floats[float_block_index++]);
     }
-  
+
   XFLOAT_DATA (val) = float_value;
   XSETFASTINT (XFLOAT (val)->type, 0); /* bug chasing -wsr */
   consing_since_gc += sizeof (struct Lisp_Float);
@@ -2083,7 +2098,7 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0,
        }
       XSETCONS (val, &cons_block->conses[cons_block_index++]);
     }
-  
+
   XCAR (val) = car;
   XCDR (val) = cdr;
   consing_since_gc += sizeof (struct Lisp_Cons);
@@ -2167,17 +2182,17 @@ DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,
        {
          val = Fcons (init, val);
          --size;
-      
+
          if (size > 0)
            {
              val = Fcons (init, val);
              --size;
-      
+
              if (size > 0)
                {
                  val = Fcons (init, val);
                  --size;
-      
+
                  if (size > 0)
                    {
                      val = Fcons (init, val);
@@ -2189,7 +2204,7 @@ DEFUN ("make-list", Fmake_list, Smake_list, 2, 2, 0,
 
       QUIT;
     }
-  
+
   return val;
 }
 
@@ -2225,15 +2240,15 @@ allocate_vectorlike (len, type)
      a dumped Emacs.  */
   mallopt (M_MMAP_MAX, 0);
 #endif
-  
+
   nbytes = sizeof *p + (len - 1) * sizeof p->contents[0];
   p = (struct Lisp_Vector *) lisp_malloc (nbytes, type);
-  
+
 #ifdef DOUG_LEA_MALLOC
   /* Back to a reasonable maximum of mmap'ed areas.  */
   mallopt (M_MMAP_MAX, MMAP_MAX_AREAS);
 #endif
-  
+
   VALIDATE_LISP_STORAGE (p, 0);
   consing_since_gc += nbytes;
   vector_cells_consed += len;
@@ -2265,11 +2280,11 @@ allocate_hash_table ()
   EMACS_INT len = VECSIZE (struct Lisp_Hash_Table);
   struct Lisp_Vector *v = allocate_vectorlike (len, MEM_TYPE_HASH_TABLE);
   EMACS_INT i;
-  
+
   v->size = len;
   for (i = 0; i < len; ++i)
     v->contents[i] = Qnil;
-  
+
   return (struct Lisp_Hash_Table *) v;
 }
 
@@ -2280,11 +2295,11 @@ allocate_window ()
   EMACS_INT len = VECSIZE (struct window);
   struct Lisp_Vector *v = allocate_vectorlike (len, MEM_TYPE_WINDOW);
   EMACS_INT i;
-  
+
   for (i = 0; i < len; ++i)
     v->contents[i] = Qnil;
   v->size = len;
-  
+
   return (struct window *) v;
 }
 
@@ -2295,7 +2310,7 @@ allocate_frame ()
   EMACS_INT len = VECSIZE (struct frame);
   struct Lisp_Vector *v = allocate_vectorlike (len, MEM_TYPE_FRAME);
   EMACS_INT i;
-  
+
   for (i = 0; i < len; ++i)
     v->contents[i] = make_number (0);
   v->size = len;
@@ -2309,11 +2324,11 @@ allocate_process ()
   EMACS_INT len = VECSIZE (struct Lisp_Process);
   struct Lisp_Vector *v = allocate_vectorlike (len, MEM_TYPE_PROCESS);
   EMACS_INT i;
-  
+
   for (i = 0; i < len; ++i)
     v->contents[i] = Qnil;
   v->size = len;
-  
+
   return (struct Lisp_Process *) v;
 }
 
@@ -2324,11 +2339,11 @@ allocate_other_vector (len)
 {
   struct Lisp_Vector *v = allocate_vectorlike (len, MEM_TYPE_VECTOR);
   EMACS_INT i;
-  
+
   for (i = 0; i < len; ++i)
     v->contents[i] = Qnil;
   v->size = len;
-  
+
   return v;
 }
 
@@ -2538,7 +2553,7 @@ Its value and function definition are void, and its property list is nil.")
        }
       XSETSYMBOL (val, &symbol_block->symbols[symbol_block_index++]);
     }
-  
+
   p = XSYMBOL (val);
   p->name = XSTRING (name);
   p->obarray = Qnil;
@@ -2617,7 +2632,7 @@ allocate_misc ()
        }
       XSETMISC (val, &marker_block->markers[marker_block_index++]);
     }
-  
+
   consing_since_gc += sizeof (union Lisp_Misc);
   misc_objects_consed++;
   return val;
@@ -2682,7 +2697,7 @@ make_event_array (nargs, args)
      characters, so we can make a string.  */
   {
     Lisp_Object result;
-    
+
     result = Fmake_string (make_number (nargs), make_number (0));
     for (i = 0; i < nargs; i++)
       {
@@ -2691,7 +2706,7 @@ make_event_array (nargs, args)
        if (XINT (args[i]) & CHAR_META)
          XSTRING (result)->data[i] |= 0x80;
       }
-    
+
     return result;
   }
 }
@@ -2763,7 +2778,7 @@ mem_insert (start, end, type)
   parent = NULL;
 
 #if GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS
-     
+
   while (c != MEM_NIL)
     {
       if (start >= c->start && start < c->end)
@@ -2771,15 +2786,15 @@ mem_insert (start, end, type)
       parent = c;
       c = start < c->start ? c->left : c->right;
     }
-     
+
 #else /* GC_MARK_STACK == GC_MARK_STACK_CHECK_GCPROS */
-     
+
   while (c != MEM_NIL)
     {
       parent = c;
       c = start < c->start ? c->left : c->right;
     }
-     
+
 #endif /* GC_MARK_STACK == GC_MARK_STACK_CHECK_GCPROS */
 
   /* Create a new node.  */
@@ -2805,7 +2820,7 @@ mem_insert (start, end, type)
       else
        parent->right = x;
     }
-  else 
+  else
     mem_root = x;
 
   /* Re-establish red-black tree properties.  */
@@ -2826,13 +2841,13 @@ mem_insert_fixup (x)
     {
       /* X is red and its parent is red.  This is a violation of
         red-black tree property #3.  */
-      
+
       if (x->parent == x->parent->parent->left)
        {
          /* We're on the left side of our grandparent, and Y is our
             "uncle".  */
          struct mem_node *y = x->parent->parent->right;
-         
+
          if (y->color == MEM_RED)
            {
              /* Uncle and parent are red but should be black because
@@ -2862,7 +2877,7 @@ mem_insert_fixup (x)
        {
          /* This is the symmetrical case of above.  */
          struct mem_node *y = x->parent->parent->left;
-         
+
          if (y->color == MEM_RED)
            {
              x->parent->color = MEM_BLACK;
@@ -2877,7 +2892,7 @@ mem_insert_fixup (x)
                  x = x->parent;
                  mem_rotate_right (x);
                }
-             
+
              x->parent->color = MEM_BLACK;
              x->parent->parent->color = MEM_RED;
              mem_rotate_left (x->parent->parent);
@@ -2891,8 +2906,8 @@ mem_insert_fixup (x)
 }
 
 
-/*   (x)                   (y)     
-     / \                   / \     
+/*   (x)                   (y)
+     / \                   / \
     a   (y)      ===>    (x)  c
         / \              / \
        b   c            a   b  */
@@ -2931,10 +2946,10 @@ mem_rotate_left (x)
 }
 
 
-/*     (x)                (Y)     
-       / \                / \               
-     (y)  c      ===>    a  (x)          
-     / \                    / \          
+/*     (x)                (Y)
+       / \                / \
+     (y)  c      ===>    a  (x)
+     / \                    / \
     a   b                  b   c  */
 
 static void
@@ -2946,7 +2961,7 @@ mem_rotate_right (x)
   x->left = y->right;
   if (y->right != MEM_NIL)
     y->right->parent = x;
-  
+
   if (y != MEM_NIL)
     y->parent = x->parent;
   if (x->parent)
@@ -2958,7 +2973,7 @@ mem_rotate_right (x)
     }
   else
     mem_root = y;
-  
+
   y->right = x;
   if (x != MEM_NIL)
     x->parent = y;
@@ -3007,7 +3022,7 @@ mem_delete (z)
       z->end = y->end;
       z->type = y->type;
     }
-  
+
   if (y->color == MEM_BLACK)
     mem_delete_fixup (x);
 
@@ -3031,7 +3046,7 @@ mem_delete_fixup (x)
       if (x == x->parent->left)
        {
          struct mem_node *w = x->parent->right;
-         
+
          if (w->color == MEM_RED)
            {
              w->color = MEM_BLACK;
@@ -3039,7 +3054,7 @@ mem_delete_fixup (x)
              mem_rotate_left (x->parent);
              w = x->parent->right;
             }
-         
+
          if (w->left->color == MEM_BLACK && w->right->color == MEM_BLACK)
            {
              w->color = MEM_RED;
@@ -3064,7 +3079,7 @@ mem_delete_fixup (x)
       else
        {
          struct mem_node *w = x->parent->left;
-         
+
          if (w->color == MEM_RED)
            {
              w->color = MEM_BLACK;
@@ -3072,7 +3087,7 @@ mem_delete_fixup (x)
              mem_rotate_right (x->parent);
              w = x->parent->left;
             }
-         
+
          if (w->right->color == MEM_BLACK && w->left->color == MEM_BLACK)
            {
              w->color = MEM_RED;
@@ -3087,7 +3102,7 @@ mem_delete_fixup (x)
                  mem_rotate_left (w);
                  w = x->parent->left;
                 }
-             
+
              w->color = x->parent->color;
              x->parent->color = MEM_BLACK;
              w->left->color = MEM_BLACK;
@@ -3096,7 +3111,7 @@ mem_delete_fixup (x)
             }
         }
     }
-  
+
   x->color = MEM_BLACK;
 }
 
@@ -3164,7 +3179,7 @@ live_symbol_p (m, p)
     {
       struct symbol_block *b = (struct symbol_block *) m->start;
       int offset = (char *) p - (char *) &b->symbols[0];
-      
+
       /* P must point to the start of a Lisp_Symbol, not be
         one of the unused cells in the current symbol block,
         and not be on the free-list.  */
@@ -3191,7 +3206,7 @@ live_float_p (m, p)
     {
       struct float_block *b = (struct float_block *) m->start;
       int offset = (char *) p - (char *) &b->floats[0];
-      
+
       /* P must point to the start of a Lisp_Float, not be
         one of the unused cells in the current float block,
         and not be on the free-list.  */
@@ -3218,7 +3233,7 @@ live_misc_p (m, p)
     {
       struct marker_block *b = (struct marker_block *) m->start;
       int offset = (char *) p - (char *) &b->markers[0];
-      
+
       /* P must point to the start of a Lisp_Misc, not be
         one of the unused cells in the current misc block,
         and not be on the free-list.  */
@@ -3320,7 +3335,7 @@ mark_maybe_object (obj)
 {
   void *po = (void *) XPNTR (obj);
   struct mem_node *m = mem_find (po);
-      
+
   if (m != MEM_NIL)
     {
       int mark_p = 0;
@@ -3366,12 +3381,12 @@ mark_maybe_object (obj)
                case Lisp_Misc_Marker:
                  mark_p = !XMARKBIT (XMARKER (obj)->chain);
                  break;
-                     
+
                case Lisp_Misc_Buffer_Local_Value:
                case Lisp_Misc_Some_Buffer_Local_Value:
                  mark_p = !XMARKBIT (XBUFFER_LOCAL_VALUE (obj)->realvalue);
                  break;
-                     
+
                case Lisp_Misc_Overlay:
                  mark_p = !XMARKBIT (XOVERLAY (obj)->plist);
                  break;
@@ -3410,30 +3425,30 @@ mark_maybe_pointer (p)
      assume that Lisp data is aligned on even addresses.  */
   if ((EMACS_INT) p & 1)
     return;
-      
+
   m = mem_find (p);
   if (m != MEM_NIL)
     {
       Lisp_Object obj = Qnil;
-      
+
       switch (m->type)
        {
        case MEM_TYPE_NON_LISP:
          /* Nothing to do; not a pointer to Lisp memory.  */
          break;
-         
+
        case MEM_TYPE_BUFFER:
          if (live_buffer_p (m, p)
              && !XMARKBIT (((struct buffer *) p)->name))
            XSETVECTOR (obj, p);
          break;
-         
+
        case MEM_TYPE_CONS:
          if (live_cons_p (m, p)
              && !XMARKBIT (((struct Lisp_Cons *) p)->car))
            XSETCONS (obj, p);
          break;
-         
+
        case MEM_TYPE_STRING:
          if (live_string_p (m, p)
              && !STRING_MARKED_P ((struct Lisp_String *) p))
@@ -3445,20 +3460,20 @@ mark_maybe_pointer (p)
            {
              Lisp_Object tem;
              XSETMISC (tem, p);
-             
+
              switch (XMISCTYPE (tem))
                {
                case Lisp_Misc_Marker:
                  if (!XMARKBIT (XMARKER (tem)->chain))
                    obj = tem;
                  break;
-                     
+
                case Lisp_Misc_Buffer_Local_Value:
                case Lisp_Misc_Some_Buffer_Local_Value:
                  if (!XMARKBIT (XBUFFER_LOCAL_VALUE (tem)->realvalue))
                    obj = tem;
                  break;
-                     
+
                case Lisp_Misc_Overlay:
                  if (!XMARKBIT (XOVERLAY (tem)->plist))
                    obj = tem;
@@ -3466,19 +3481,19 @@ mark_maybe_pointer (p)
                }
            }
          break;
-         
+
        case MEM_TYPE_SYMBOL:
          if (live_symbol_p (m, p)
              && !XMARKBIT (((struct Lisp_Symbol *) p)->plist))
            XSETSYMBOL (obj, p);
          break;
-         
+
        case MEM_TYPE_FLOAT:
          if (live_float_p (m, p)
              && !XMARKBIT (((struct Lisp_Float *) p)->type))
            XSETFLOAT (obj, p);
          break;
-         
+
        case MEM_TYPE_VECTOR:
        case MEM_TYPE_PROCESS:
        case MEM_TYPE_HASH_TABLE:
@@ -3506,7 +3521,7 @@ mark_maybe_pointer (p)
 
 /* Mark Lisp objects referenced from the address range START..END.  */
 
-static void 
+static void
 mark_memory (start, end)
      void *start, *end;
 {
@@ -3547,7 +3562,7 @@ mark_memory (start, end)
      Here, `obj' isn't really used, and the compiler optimizes it
      away.  The only reference to the life string is through the
      pointer `s'.  */
-  
+
   for (pp = (void **) start; (void *) pp < end; ++pp)
     mark_maybe_pointer (*pp);
 }
@@ -3725,14 +3740,14 @@ mark_stack ()
 #ifdef sparc
   asm ("ta 3");
 #endif
-  
+
   /* Save registers that we need to see on the stack.  We need to see
      registers used to hold register variables and registers used to
      pass parameters.  */
 #ifdef GC_SAVE_REGISTERS_ON_STACK
   GC_SAVE_REGISTERS_ON_STACK (end);
 #else /* not GC_SAVE_REGISTERS_ON_STACK */
-  
+
 #ifndef GC_SETJMP_WORKS  /* If it hasn't been checked yet that
                            setjmp will definitely work, test it
                            and print a message with the result
@@ -3743,7 +3758,7 @@ mark_stack ()
       test_setjmp ();
     }
 #endif /* GC_SETJMP_WORKS */
-  
+
   setjmp (j);
   end = stack_grows_down_p ? (char *) &j + sizeof j : (char *) &j;
 #endif /* not GC_SAVE_REGISTERS_ON_STACK */
@@ -3809,7 +3824,7 @@ pure_alloc (size, type)
        = (ALIGN ((EMACS_UINT) (beg + pure_bytes_used), alignment)
           - (EMACS_UINT) beg);
     }
-    
+
   nbytes = ALIGN (size, sizeof (EMACS_INT));
   if (pure_bytes_used + nbytes > PURESIZE)
     error ("Pure Lisp storage exhausted");
@@ -4075,7 +4090,7 @@ Garbage collection happens automatically if you cons more than\n\
           Qt tends to return NULL, which effectively turns undo back on.
           So don't call truncate_undo_list if undo_list is Qt.  */
        if (! EQ (nextb->undo_list, Qt))
-         nextb->undo_list 
+         nextb->undo_list
            = truncate_undo_list (nextb->undo_list, undo_limit,
                                  undo_strong_limit);
        nextb = nextb->next;
@@ -4110,7 +4125,7 @@ Garbage collection happens automatically if you cons more than\n\
          XMARK (tail->var[i]);
        }
 #endif
-  
+
   mark_byte_stack ();
   for (bind = specpdl; bind != specpdl_ptr; bind++)
     {
@@ -4121,12 +4136,12 @@ Garbage collection happens automatically if you cons more than\n\
     {
       mark_object (&catch->tag);
       mark_object (&catch->val);
-    }  
+    }
   for (handler = handlerlist; handler; handler = handler->next)
     {
       mark_object (&handler->handler);
       mark_object (&handler->var);
-    }  
+    }
   for (backlist = backtrace_list; backlist; backlist = backlist->next)
     {
       if (!XMARKBIT (*backlist->function))
@@ -4144,7 +4159,7 @@ Garbage collection happens automatically if you cons more than\n\
            mark_object (&backlist->args[i]);
            XMARK (backlist->args[i]);
          }
-    }  
+    }
   mark_kboards ();
 
   /* Look thru every buffer's undo list
@@ -4201,7 +4216,7 @@ Garbage collection happens automatically if you cons more than\n\
     for (i = 0; i < tail->nvars; i++)
       XUNMARK (tail->var[i]);
 #endif
-  
+
   unmark_byte_stack ();
   for (backlist = backtrace_list; backlist; backlist = backlist->next)
     {
@@ -4212,7 +4227,7 @@ Garbage collection happens automatically if you cons more than\n\
        i = backlist->nargs - 1;
       for (; i >= 0; i--)
        XUNMARK (backlist->args[i]);
-    }  
+    }
   XUNMARK (buffer_defaults.name);
   XUNMARK (buffer_local_symbols.name);
 
@@ -4258,7 +4273,7 @@ Garbage collection happens automatically if you cons more than\n\
   {
     /* Compute average percentage of zombies.  */
     double nlive = 0;
-      
+
     for (i = 0; i < 7; ++i)
       nlive += XFASTINT (XCAR (total[i]));
 
@@ -4292,7 +4307,7 @@ mark_glyph_matrix (matrix)
          {
            struct glyph *glyph = row->glyphs[area];
            struct glyph *end_glyph = glyph + row->used[area];
-           
+
            for (; glyph < end_glyph; ++glyph)
              if (GC_STRINGP (glyph->object)
                  && !STRING_MARKED_P (XSTRING (glyph->object)))
@@ -4334,7 +4349,7 @@ mark_image (img)
      struct image *img;
 {
   mark_object (&img->spec);
-  
+
   if (!NILP (img->data.lisp_val))
     mark_object (&img->data.lisp_val);
 }
@@ -4415,13 +4430,13 @@ mark_object (argptr)
     CHECK_ALLOCATED ();                                \
     CHECK_LIVE (LIVEP);                                \
   } while (0)                                  \
-  
+
 #else /* not GC_CHECK_MARKED_OBJECTS */
-  
+
 #define CHECK_ALLOCATED()              (void) 0
 #define CHECK_LIVE(LIVEP)              (void) 0
 #define CHECK_ALLOCATED_AND_LIVE(LIVEP)        (void) 0
-  
+
 #endif /* not GC_CHECK_MARKED_OBJECTS */
 
   switch (SWITCH_ENUM_CAST (XGCTYPE (obj)))
@@ -4448,7 +4463,7 @@ mark_object (argptr)
          && po != &buffer_local_symbols)
        abort ();
 #endif /* GC_CHECK_MARKED_OBJECTS */
-      
+
       if (GC_BUFFERP (obj))
        {
          if (!XMARKBIT (XBUFFER (obj)->name))
@@ -4479,7 +4494,7 @@ mark_object (argptr)
 
          if (size & ARRAY_MARK_FLAG)
            break;   /* Already marked */
-         
+
          CHECK_LIVE (live_vector_p);
          ptr->size |= ARRAY_MARK_FLAG; /* Else mark it */
          size &= PSEUDOVECTOR_SIZE_MASK;
@@ -4572,11 +4587,11 @@ mark_object (argptr)
        {
          struct Lisp_Hash_Table *h = XHASH_TABLE (obj);
          EMACS_INT size = h->size;
-         
+
          /* Stop if already marked.  */
          if (size & ARRAY_MARK_FLAG)
            break;
-         
+
          /* Mark it.  */
          CHECK_LIVE (live_vector_p);
          h->size |= ARRAY_MARK_FLAG;
@@ -4598,7 +4613,7 @@ mark_object (argptr)
            mark_object (&h->key_and_value);
          else
            XVECTOR (h->key_and_value)->size |= ARRAY_MARK_FLAG;
-           
+
        }
       else
        {
@@ -4632,7 +4647,7 @@ mark_object (argptr)
        if (!PURE_POINTER_P (ptr->name))
          MARK_STRING (ptr->name);
        MARK_INTERVAL_TREE (ptr->name->intervals);
-       
+
        /* Note that we do not mark the obarray of the symbol.
           It is safe not to do so because nothing accesses that
           slot except to check whether it is nil.  */
@@ -4802,7 +4817,7 @@ mark_buffer (buf)
   /* If this is an indirect buffer, mark its base buffer.  */
   if (buffer->base_buffer && !XMARKBIT (buffer->base_buffer->name))
     {
-      XSETBUFFER (base_buffer, buffer->base_buffer); 
+      XSETBUFFER (base_buffer, buffer->base_buffer);
       mark_buffer (base_buffer);
     }
 }
@@ -4843,7 +4858,7 @@ survives_gc_p (obj)
      Lisp_Object obj;
 {
   int survives_p;
-  
+
   switch (XGCTYPE (obj))
     {
     case Lisp_Int:
@@ -4860,12 +4875,12 @@ survives_gc_p (obj)
        case Lisp_Misc_Marker:
          survives_p = XMARKBIT (obj);
          break;
-         
+
        case Lisp_Misc_Buffer_Local_Value:
        case Lisp_Misc_Some_Buffer_Local_Value:
          survives_p = XMARKBIT (XBUFFER_LOCAL_VALUE (obj)->realvalue);
          break;
-         
+
        case Lisp_Misc_Intfwd:
        case Lisp_Misc_Boolfwd:
        case Lisp_Misc_Objfwd:
@@ -4873,7 +4888,7 @@ survives_gc_p (obj)
        case Lisp_Misc_Kboard_Objfwd:
          survives_p = 1;
          break;
-         
+
        case Lisp_Misc_Overlay:
          survives_p = XMARKBIT (XOVERLAY (obj)->plist);
          break;
@@ -4939,7 +4954,7 @@ gc_sweep ()
     register int num_free = 0, num_used = 0;
 
     cons_free_list = 0;
-  
+
     for (cblk = cons_block; cblk; cblk = *cprev)
       {
        register int i;
@@ -4989,7 +5004,7 @@ gc_sweep ()
     register int num_free = 0, num_used = 0;
 
     float_free_list = 0;
-  
+
     for (fblk = float_block; fblk; fblk = *fprev)
       {
        register int i;
@@ -5089,7 +5104,7 @@ gc_sweep ()
     register int num_free = 0, num_used = 0;
 
     symbol_free_list = NULL;
-  
+
     for (sblk = symbol_block; sblk; sblk = *sprev)
       {
        int this_free = 0;
@@ -5102,7 +5117,7 @@ gc_sweep ()
               it might be pointed to by pure bytecode which we don't trace,
               so we conservatively assume that it is live.  */
            int pure_p = PURE_POINTER_P (sym->name);
-           
+
            if (!XMARKBIT (sym->plist) && !pure_p)
              {
                *(struct Lisp_Symbol **) &sym->value = symbol_free_list;
@@ -5120,7 +5135,7 @@ gc_sweep ()
                XUNMARK (sym->plist);
              }
          }
-       
+
        lim = SYMBOL_BLOCK_SIZE;
        /* If this block contains only free symbols and we have already
           seen more than two blocks worth of free symbols then deallocate
@@ -5152,7 +5167,7 @@ gc_sweep ()
     register int num_free = 0, num_used = 0;
 
     marker_free_list = 0;
-  
+
     for (mblk = marker_block; mblk; mblk = *mprev)
       {
        register int i;
@@ -5282,7 +5297,7 @@ gc_sweep ()
          prev = vector, vector = vector->next;
        }
   }
-  
+
 #ifdef GC_CHECK_STRING_BYTES
   if (!noninteractive)
     check_string_bytes (1);