(VECTOR_MARK, VECTOR_UNMARK, VECTOR_MARKED_P): New macros.

(GC_STRING_BYTES): Don't mask markbit (it's only used on `size').
(allocate_buffer): Move.
(string_bytes): Don't mask markbit of `size_byte'.
(mark_maybe_object, mark_maybe_pointer, Fgarbage_collect)
(mark_object, mark_buffer, survives_gc_p, gc_sweep):
Use the `size' field of buffers (rather than the `name' field) for
the mark bit, as is done for all other vectorlike objects.
Use the new macros to access the mark bit of vectorlike objects.

2 files changed, 59 insertions, 54 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 33dbe6c8a2f..84facf45775 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,15 @@
+2003-06-27  Stefan Monnier  <monnier@cs.yale.edu>
+
+        * alloc.c (VECTOR_MARK, VECTOR_UNMARK, VECTOR_MARKED_P): New macros.
+        (GC_STRING_BYTES): Don't mask markbit (it's only used on `size').
+        (allocate_buffer): Move.
+        (string_bytes): Don't mask markbit of `size_byte'.
+        (mark_maybe_object, mark_maybe_pointer, Fgarbage_collect)
+        (mark_object, mark_buffer, survives_gc_p, gc_sweep):
+        Use the `size' field of buffers (rather than the `name' field) for
+        the mark bit, as is done for all other vectorlike objects.
+        Use the new macros to access the mark bit of vectorlike objects.
+
 2003-06-26  Richard M. Stallman  <rms@gnu.org>
 
         * puresize.h (BASE_PURESIZE): Increment base size.
diff --git a/src/alloc.c b/src/alloc.c
index 886c489e21f..fabc1280fa8 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -95,12 +95,16 @@ static __malloc_size_t bytes_used_when_full;
 #define UNMARK_STRING(S)        ((S)->size &= ~MARKBIT)
 #define STRING_MARKED_P(S)      ((S)->size & MARKBIT)
 
+#define VECTOR_MARK(V)          ((V)->size |= ARRAY_MARK_FLAG)
+#define VECTOR_UNMARK(V)        ((V)->size &= ~ARRAY_MARK_FLAG)
+#define VECTOR_MARKED_P(V)      ((V)->size & ARRAY_MARK_FLAG)
+
 /* Value is the number of bytes/chars of S, a pointer to a struct
    Lisp_String.  This must be used instead of STRING_BYTES (S) or
    S->size during GC, because S->size contains the mark bit for
    strings.  */
 
-#define GC_STRING_BYTES(S)      (STRING_BYTES (S) & ~MARKBIT)
+#define GC_STRING_BYTES(S)      (STRING_BYTES (S))
 #define GC_STRING_CHARS(S)      ((S)->size & ~MARKBIT)
 
 /* Number of bytes of consing done since the last gc.  */
@@ -616,20 +620,6 @@ lisp_malloc (nbytes, type)
   return val;
 }
 
-
-/* Return a new buffer structure allocated from the heap with
-   a call to lisp_malloc.  */
-
-struct buffer *
-allocate_buffer ()
-{
-  struct buffer *b
-    = (struct buffer *) lisp_malloc (sizeof (struct buffer),
-                                     MEM_TYPE_BUFFER);
-  return b;
-}
-
-
 /* Free BLOCK.  This must be called to free memory allocated with a
    call to lisp_malloc.  */
 
@@ -645,6 +635,19 @@ lisp_free (block)
   UNBLOCK_INPUT;
 }
 
+
+/* Return a new buffer structure allocated from the heap with
+   a call to lisp_malloc.  */
+
+struct buffer *
+allocate_buffer ()
+{
+  struct buffer *b
+    = (struct buffer *) lisp_malloc (sizeof (struct buffer),
+                                     MEM_TYPE_BUFFER);
+  return b;
+}
+
 
 /* Arranging to disable input signals while we're in malloc.
 
@@ -1223,7 +1226,7 @@ int
 string_bytes (s)
      struct Lisp_String *s;
 {
-  int nbytes = (s->size_byte < 0 ? s->size : s->size_byte) & ~MARKBIT;
+  int nbytes = (s->size_byte < 0 ? s->size & ~MARKBIT : s->size_byte);
   if (!PURE_POINTER_P (s)
       && s->data
       && nbytes != SDATA_NBYTES (SDATA_OF_STRING (s)))
@@ -3400,10 +3403,9 @@ mark_maybe_object (obj)
              buffer because checking that dereferences the pointer
              PO which might point anywhere.  */
           if (live_vector_p (m, po))
-            mark_p = (!GC_SUBRP (obj)
-                      && !(XVECTOR (obj)->size & ARRAY_MARK_FLAG));
+            mark_p = !GC_SUBRP (obj) && !VECTOR_MARKED_P (XVECTOR (obj));
           else if (live_buffer_p (m, po))
-            mark_p = GC_BUFFERP (obj) && !XMARKBIT (XBUFFER (obj)->name);
+            mark_p = GC_BUFFERP (obj) && !VECTOR_MARKED_P (XBUFFER (obj));
           break;
 
         case Lisp_Misc:
@@ -3454,8 +3456,7 @@ mark_maybe_pointer (p)
           break;
 
         case MEM_TYPE_BUFFER:
-          if (live_buffer_p (m, p)
-              && !XMARKBIT (((struct buffer *) p)->name))
+          if (live_buffer_p (m, p) && !VECTOR_MARKED_P((struct buffer *)p))
             XSETVECTOR (obj, p);
           break;
 
@@ -3496,8 +3497,7 @@ mark_maybe_pointer (p)
             {
               Lisp_Object tem;
               XSETVECTOR (tem, p);
-              if (!GC_SUBRP (tem)
-                  && !(XVECTOR (tem)->size & ARRAY_MARK_FLAG))
+              if (!GC_SUBRP (tem) && !VECTOR_MARKED_P (XVECTOR (tem)))
                 obj = tem;
             }
           break;
@@ -4286,8 +4286,8 @@ Garbage collection happens automatically if you cons more than
       for (; i >= 0; i--)
         XUNMARK (backlist->args[i]);
     }
-  XUNMARK (buffer_defaults.name);
-  XUNMARK (buffer_local_symbols.name);
+  VECTOR_UNMARK (&buffer_defaults);
+  VECTOR_UNMARK (&buffer_local_symbols);
 
 #if GC_MARK_STACK == GC_USE_GCPROS_CHECK_ZOMBIES && 0
   dump_zombies ();
@@ -4548,7 +4548,7 @@ mark_object (argptr)
 
       if (GC_BUFFERP (obj))
         {
-          if (!XMARKBIT (XBUFFER (obj)->name))
+          if (!VECTOR_MARKED_P (XBUFFER (obj)))
             {
 #ifdef GC_CHECK_MARKED_OBJECTS
               if (po != &buffer_defaults && po != &buffer_local_symbols)
@@ -4574,11 +4574,11 @@ mark_object (argptr)
           register EMACS_INT size = ptr->size;
           register int i;
 
-          if (size & ARRAY_MARK_FLAG)
+          if (VECTOR_MARKED_P (ptr))
             break;   /* Already marked */
 
           CHECK_LIVE (live_vector_p);
-          ptr->size |= ARRAY_MARK_FLAG; /* Else mark it */
+          VECTOR_MARK (ptr);    /* Else mark it */
           size &= PSEUDOVECTOR_SIZE_MASK;
           for (i = 0; i < size; i++) /* and then mark its elements */
             {
@@ -4593,10 +4593,9 @@ mark_object (argptr)
       else if (GC_FRAMEP (obj))
         {
           register struct frame *ptr = XFRAME (obj);
-          register EMACS_INT size = ptr->size;
 
-          if (size & ARRAY_MARK_FLAG) break;   /* Already marked */
-          ptr->size |= ARRAY_MARK_FLAG; /* Else mark it */
+          if (VECTOR_MARKED_P (ptr)) break;   /* Already marked */
+          VECTOR_MARK (ptr);                  /* Else mark it */
 
           CHECK_LIVE (live_vector_p);
           mark_object (&ptr->name);
@@ -4627,25 +4626,24 @@ mark_object (argptr)
         {
           register struct Lisp_Vector *ptr = XVECTOR (obj);
 
-          if (ptr->size & ARRAY_MARK_FLAG)
+          if (VECTOR_MARKED_P (ptr))
             break;   /* Already marked */
           CHECK_LIVE (live_vector_p);
-          ptr->size |= ARRAY_MARK_FLAG; /* Else mark it */
+          VECTOR_MARK (ptr);    /* Else mark it */
         }
       else if (GC_WINDOWP (obj))
         {
           register struct Lisp_Vector *ptr = XVECTOR (obj);
           struct window *w = XWINDOW (obj);
-          register EMACS_INT size = ptr->size;
           register int i;
 
           /* Stop if already marked.  */
-          if (size & ARRAY_MARK_FLAG)
+          if (VECTOR_MARKED_P (ptr))
             break;
 
           /* Mark it.  */
           CHECK_LIVE (live_vector_p);
-          ptr->size |= ARRAY_MARK_FLAG;
+          VECTOR_MARK (ptr);
 
           /* There is no Lisp data above The member CURRENT_MATRIX in
              struct WINDOW.  Stop marking when that slot is reached.  */
@@ -4668,15 +4666,14 @@ mark_object (argptr)
       else if (GC_HASH_TABLE_P (obj))
         {
           struct Lisp_Hash_Table *h = XHASH_TABLE (obj);
-          EMACS_INT size = h->size;
 
           /* Stop if already marked.  */
-          if (size & ARRAY_MARK_FLAG)
+          if (VECTOR_MARKED_P (h))
             break;
 
           /* Mark it.  */
           CHECK_LIVE (live_vector_p);
-          h->size |= ARRAY_MARK_FLAG;
+          VECTOR_MARK (h);
 
           /* Mark contents.  */
           /* Do not mark next_free or next_weak.
@@ -4698,8 +4695,7 @@ mark_object (argptr)
           if (GC_NILP (h->weak))
             mark_object (&h->key_and_value);
           else
-            XVECTOR (h->key_and_value)->size |= ARRAY_MARK_FLAG;
-
+            VECTOR_MARK (XVECTOR (h->key_and_value));
         }
       else
         {
@@ -4707,9 +4703,9 @@ mark_object (argptr)
           register EMACS_INT size = ptr->size;
           register int i;
 
-          if (size & ARRAY_MARK_FLAG) break; /* Already marked */
+          if (VECTOR_MARKED_P (ptr)) break; /* Already marked */
           CHECK_LIVE (live_vector_p);
-          ptr->size |= ARRAY_MARK_FLAG; /* Else mark it */
+          VECTOR_MARK (ptr);    /* Else mark it */
           if (size & PSEUDOVECTOR_FLAG)
             size &= PSEUDOVECTOR_SIZE_MASK;
 
@@ -4854,9 +4850,7 @@ mark_buffer (buf)
   register Lisp_Object *ptr;
   Lisp_Object base_buffer;
 
-  /* This is the buffer's markbit */
-  mark_object (&buffer->name);
-  XMARK (buffer->name);
+  VECTOR_MARK (buffer);
 
   MARK_INTERVAL_TREE (BUF_INTERVALS (buffer));
 
@@ -4896,7 +4890,7 @@ mark_buffer (buf)
   else
     mark_object (&buffer->undo_list);
 
-  for (ptr = &buffer->name + 1;
+  for (ptr = &buffer->name;
        (char *)ptr < (char *)buffer + sizeof (struct buffer);
        ptr++)
     mark_object (ptr);
@@ -4942,11 +4936,11 @@ survives_gc_p (obj)
 
     case Lisp_Vectorlike:
       if (GC_BUFFERP (obj))
-        survives_p = XMARKBIT (XBUFFER (obj)->name);
+        survives_p = VECTOR_MARKED_P (XBUFFER (obj));
       else if (GC_SUBRP (obj))
         survives_p = 1;
       else
-        survives_p = XVECTOR (obj)->size & ARRAY_MARK_FLAG;
+        survives_p = VECTOR_MARKED_P (XVECTOR (obj));
       break;
 
     case Lisp_Cons:
@@ -5212,7 +5206,6 @@ gc_sweep ()
           {
             if (!mblk->markers[i].u_marker.gcmarkbit)
               {
-                Lisp_Object tem;
                 if (mblk->markers[i].u_marker.type == Lisp_Misc_Marker)
                   unchain_marker (&mblk->markers[i].u_marker);
                 /* Set the type of the freed object to Lisp_Misc_Free.
@@ -5257,7 +5250,7 @@ gc_sweep ()
     register struct buffer *buffer = all_buffers, *prev = 0, *next;
 
     while (buffer)
-      if (!XMARKBIT (buffer->name))
+      if (!VECTOR_MARKED_P (buffer))
         {
           if (prev)
             prev->next = buffer->next;
@@ -5269,7 +5262,7 @@ gc_sweep ()
         }
       else
         {
-          XUNMARK (buffer->name);
+          VECTOR_UNMARK (buffer);
           UNMARK_BALANCE_INTERVALS (BUF_INTERVALS (buffer));
           prev = buffer, buffer = buffer->next;
         }
@@ -5281,7 +5274,7 @@ gc_sweep ()
     total_vector_size = 0;
 
     while (vector)
-      if (!(vector->size & ARRAY_MARK_FLAG))
+      if (!VECTOR_MARKED_P (vector))
         {
           if (prev)
             prev->next = vector->next;
@@ -5295,7 +5288,7 @@ gc_sweep ()
         }
       else
         {
-          vector->size &= ~ARRAY_MARK_FLAG;
+          VECTOR_UNMARK (vector);
           if (vector->size & PSEUDOVECTOR_FLAG)
             total_vector_size += (PSEUDOVECTOR_SIZE_MASK & vector->size);
           else