emacs: src/alloc.c comparison

comparison src/alloc.c @ 51683:fb960854a12c

(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.

author	Stefan Monnier <monnier@iro.umontreal.ca>
date	Fri, 27 Jun 2003 21:54:20 +0000
parents	0f333fd92a1d
children	17c015f1f795

comparison

equal deleted inserted replaced

-:f4620c9305c7
+:fb960854a12c
 #define MARK_STRING(S)		((S)->size |= MARKBIT)
 #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.  */
 int consing_since_gc;
 if (!val && nbytes)
 memory_full ();
 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.  */
 static void
 lisp_free (block)
 free (block);
 #if GC_MARK_STACK && !defined GC_MALLOC_CHECK
 mem_delete (mem_find (block));
 #endif
 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.
 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)))
 abort ();
 return nbytes;
 	case Lisp_Vectorlike:
 	  /* Note: can't check GC_BUFFERP before we know it's a
 	     buffer because checking that dereferences the pointer
 	     PO which might point anywhere.  */
 	  if (live_vector_p (m, po))
-	    mark_p = (!GC_SUBRP (obj)
+	    mark_p = !GC_SUBRP (obj) && !VECTOR_MARKED_P (XVECTOR (obj));
-		      && !(XVECTOR (obj)->size & ARRAY_MARK_FLAG));
 	  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:
 	  mark_p = (live_misc_p (m, po) && !XMARKER (obj)->gcmarkbit);
 	  break;
 	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)
+	  if (live_buffer_p (m, p) && !VECTOR_MARKED_P((struct buffer *)p))
-	      && !XMARKBIT (((struct buffer *) p)->name))
 	    XSETVECTOR (obj, p);
 	  break;
 	case MEM_TYPE_CONS:
 	  if (live_cons_p (m, p)
 	case MEM_TYPE_WINDOW:
 	  if (live_vector_p (m, p))
 	    {
 	      Lisp_Object tem;
 	      XSETVECTOR (tem, p);
-	      if (!GC_SUBRP (tem)
+	      if (!GC_SUBRP (tem) && !VECTOR_MARKED_P (XVECTOR (tem)))
-		  && !(XVECTOR (tem)->size & ARRAY_MARK_FLAG))
 		obj = tem;
 	    }
 	  break;
 	default:
 else
 	i = backlist->nargs - 1;
 for (; i >= 0; i--)
 	XUNMARK (backlist->args[i]);
 }
-XUNMARK (buffer_defaults.name);
+VECTOR_UNMARK (&buffer_defaults);
-XUNMARK (buffer_local_symbols.name);
+VECTOR_UNMARK (&buffer_local_symbols);
 #if GC_MARK_STACK == GC_USE_GCPROS_CHECK_ZOMBIES && 0
 dump_zombies ();
 #endif
 	abort ();
 #endif /* GC_CHECK_MARKED_OBJECTS */
 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)
 		{
 		  struct buffer *b;
 	{
 	  register struct Lisp_Vector *ptr = XVECTOR (obj);
 	  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 */
 	    {
 	      if (i != COMPILED_CONSTANTS)
 		mark_object (&ptr->contents[i]);
 	  goto loop;
 	}
 else if (GC_FRAMEP (obj))
 	{
 	  register struct frame *ptr = XFRAME (obj);
-	  register EMACS_INT size = ptr->size;
+	  if (VECTOR_MARKED_P (ptr)) break;   /* Already marked */
-	  if (size & ARRAY_MARK_FLAG) break;   /* Already marked */
+	  VECTOR_MARK (ptr);		      /* Else mark it */
-	  ptr->size |= ARRAY_MARK_FLAG; /* Else mark it */
 	  CHECK_LIVE (live_vector_p);
 	  mark_object (&ptr->name);
 	  mark_object (&ptr->icon_name);
 	  mark_object (&ptr->title);
 	}
 else if (GC_BOOL_VECTOR_P (obj))
 	{
 	  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.  */
 	  for (i = 0;
 	       (char *) &ptr->contents[i] < (char *) &w->current_matrix;
 	    }
 	}
 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.
 	     Being in the next_weak chain
 	     should not keep the hash table alive.
 	  /* If hash table is not weak, mark all keys and values.
 	     For weak tables, mark only the vector.  */
 	  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
 	{
 	  register struct Lisp_Vector *ptr = XVECTOR (obj);
 	  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;
 	  for (i = 0; i < size; i++) /* and then mark its elements */
 	    mark_object (&ptr->contents[i]);
 {
 register struct buffer *buffer = XBUFFER (buf);
 register Lisp_Object *ptr;
 Lisp_Object base_buffer;
-/* This is the buffer's markbit */
+VECTOR_MARK (buffer);
-mark_object (&buffer->name);
-XMARK (buffer->name);
 MARK_INTERVAL_TREE (BUF_INTERVALS (buffer));
 if (CONSP (buffer->undo_list))
 {
 mark_object (&XCDR_AS_LVALUE (tail));
 }
 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);
 /* If this is an indirect buffer, mark its base buffer.  */
 }
 break;
 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:
 survives_p = XMARKBIT (XCAR (obj));
 break;
 	for (i = 0; i < lim; i++)
 	  {
 	    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.
 		   We could leave the type alone, since nobody checks it,
 		   but this might catch bugs faster.  */
 /* Free all unmarked buffers */
 {
 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;
 	  else
 	    all_buffers = buffer->next;
 	  lisp_free (buffer);
 	  buffer = next;
 	}
 else
 	{
-	  XUNMARK (buffer->name);
+	  VECTOR_UNMARK (buffer);
 	  UNMARK_BALANCE_INTERVALS (BUF_INTERVALS (buffer));
 	  prev = buffer, buffer = buffer->next;
 	}
 }
 {
 register struct Lisp_Vector *vector = all_vectors, *prev = 0, *next;
 total_vector_size = 0;
 while (vector)
-if (!(vector->size & ARRAY_MARK_FLAG))
+if (!VECTOR_MARKED_P (vector))
 	{
 	  if (prev)
 	    prev->next = vector->next;
 	  else
 	    all_vectors = vector->next;
 	  vector = next;
 	}
 else
 	{
-	  vector->size &= ~ARRAY_MARK_FLAG;
+	  VECTOR_UNMARK (vector);
 	  if (vector->size & PSEUDOVECTOR_FLAG)
 	    total_vector_size += (PSEUDOVECTOR_SIZE_MASK & vector->size);
 	  else
 	    total_vector_size += vector->size;
 	  prev = vector, vector = vector->next;

Mercurial > emacs

comparison src/alloc.c @ 51683:fb960854a12c