emacs: src/alloc.c comparison

comparison src/alloc.c @ 90970:3371fc48749b

Replace uses of GC_* macros with the non-GC_ versions.

author	Stefan Monnier <monnier@iro.umontreal.ca>
date	Fri, 29 Jun 2007 03:37:33 +0000
parents	e9f94688a064
children	a66921565bcb

comparison

equal deleted inserted replaced

-:0848217e8e8a
+:3371fc48749b
 if (m != MEM_NIL)
 {
 int mark_p = 0;
-switch (XGCTYPE (obj))
+switch (XTYPE (obj))
 	{
 	case Lisp_String:
 	  mark_p = (live_string_p (m, po)
 		    && !STRING_MARKED_P ((struct Lisp_String *) po));
 	  break;
 	case Lisp_Float:
 	  mark_p = (live_float_p (m, po) && !FLOAT_MARKED_P (XFLOAT (obj)));
 	  break;
 	case Lisp_Vectorlike:
-	  /* Note: can't check GC_BUFFERP before we know it's a
+	  /* Note: can't check 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) && !VECTOR_MARKED_P (XVECTOR (obj));
+	    mark_p = !SUBRP (obj) && !VECTOR_MARKED_P (XVECTOR (obj));
 	  else if (live_buffer_p (m, po))
-	    mark_p = GC_BUFFERP (obj) && !VECTOR_MARKED_P (XBUFFER (obj));
+	    mark_p = 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_WINDOW:
 	  if (live_vector_p (m, p))
 	    {
 	      Lisp_Object tem;
 	      XSETVECTOR (tem, p);
-	      if (!GC_SUBRP (tem) && !VECTOR_MARKED_P (XVECTOR (tem)))
+	      if (!SUBRP (tem) && !VECTOR_MARKED_P (XVECTOR (tem)))
 		obj = tem;
 	    }
 	  break;
 	default:
 	  abort ();
 	}
-if (!GC_NILP (obj))
+if (!NILP (obj))
 	mark_object (obj);
 }
 }
 	    Lisp_Object tail, prev;
 	    tail = nextb->undo_list;
 	    prev = Qnil;
 	    while (CONSP (tail))
 	      {
-		if (GC_CONSP (XCAR (tail))
+		if (CONSP (XCAR (tail))
-		    && GC_MARKERP (XCAR (XCAR (tail)))
+		    && MARKERP (XCAR (XCAR (tail)))
 		    && !XMARKER (XCAR (XCAR (tail)))->gcmarkbit)
 		  {
 		    if (NILP (prev))
 		      nextb->undo_list = tail = XCDR (tail);
 		    else
 	  {
 	    struct glyph *glyph = row->glyphs[area];
 	    struct glyph *end_glyph = glyph + row->used[area];
 	    for (; glyph < end_glyph; ++glyph)
-	      if (GC_STRINGP (glyph->object)
+	      if (STRINGP (glyph->object)
 		  && !STRING_MARKED_P (XSTRING (glyph->object)))
 		mark_object (glyph->object);
 	  }
 }
 }
 #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)))
+switch (SWITCH_ENUM_CAST (XTYPE (obj)))
 {
 case Lisp_String:
 {
 	register struct Lisp_String *ptr = XSTRING (obj);
 	CHECK_ALLOCATED_AND_LIVE (live_string_p);
 break;
 case Lisp_Vectorlike:
 #ifdef GC_CHECK_MARKED_OBJECTS
 m = mem_find (po);
-if (m == MEM_NIL && !GC_SUBRP (obj)
+if (m == MEM_NIL && !SUBRP (obj)
 	  && po != &buffer_defaults
 	  && po != &buffer_local_symbols)
 	abort ();
 #endif /* GC_CHECK_MARKED_OBJECTS */
-if (GC_BUFFERP (obj))
+if (BUFFERP (obj))
 	{
 	  if (!VECTOR_MARKED_P (XBUFFER (obj)))
 	    {
 #ifdef GC_CHECK_MARKED_OBJECTS
 	      if (po != &buffer_defaults && po != &buffer_local_symbols)
 		}
 #endif /* GC_CHECK_MARKED_OBJECTS */
 	      mark_buffer (obj);
 	    }
 	}
-else if (GC_SUBRP (obj))
+else if (SUBRP (obj))
 	break;
-else if (GC_COMPILEDP (obj))
+else if (COMPILEDP (obj))
 	/* We could treat this just like a vector, but it is better to
 	   save the COMPILED_CONSTANTS element for last and avoid
 	   recursion there.  */
 	{
 	  register struct Lisp_Vector *ptr = XVECTOR (obj);
 		mark_object (ptr->contents[i]);
 	    }
 	  obj = ptr->contents[COMPILED_CONSTANTS];
 	  goto loop;
 	}
-else if (GC_FRAMEP (obj))
+else if (FRAMEP (obj))
 	{
 	  register struct frame *ptr = XFRAME (obj);
 	  if (VECTOR_MARKED_P (ptr)) break;   /* Already marked */
 	  VECTOR_MARK (ptr);		      /* Else mark it */
 	  mark_object (ptr->tool_bar_items);
 	  mark_object (ptr->desired_tool_bar_string);
 	  mark_object (ptr->current_tool_bar_string);
 #endif /* HAVE_WINDOW_SYSTEM */
 	}
-else if (GC_BOOL_VECTOR_P (obj))
+else if (BOOL_VECTOR_P (obj))
 	{
 	  register struct Lisp_Vector *ptr = XVECTOR (obj);
 	  if (VECTOR_MARKED_P (ptr))
 	    break;   /* Already marked */
 	  CHECK_LIVE (live_vector_p);
 	  VECTOR_MARK (ptr);	/* Else mark it */
 	}
-else if (GC_WINDOWP (obj))
+else if (WINDOWP (obj))
 	{
 	  register struct Lisp_Vector *ptr = XVECTOR (obj);
 	  struct window *w = XWINDOW (obj);
 	  register int i;
 	    {
 	      mark_glyph_matrix (w->current_matrix);
 	      mark_glyph_matrix (w->desired_matrix);
 	    }
 	}
-else if (GC_HASH_TABLE_P (obj))
+else if (HASH_TABLE_P (obj))
 	{
 	  struct Lisp_Hash_Table *h = XHASH_TABLE (obj);
 	  /* Stop if already marked.  */
 	  if (VECTOR_MARKED_P (h))
 	  mark_object (h->user_hash_function);
 	  mark_object (h->user_cmp_function);
 	  /* If hash table is not weak, mark all keys and values.
 	     For weak tables, mark only the vector.  */
-	  if (GC_NILP (h->weak))
+	  if (NILP (h->weak))
 	    mark_object (h->key_and_value);
 	  else
 	    VECTOR_MARK (XVECTOR (h->key_and_value));
 	}
 else
 survives_gc_p (obj)
 Lisp_Object obj;
 {
 int survives_p;
-switch (XGCTYPE (obj))
+switch (XTYPE (obj))
 {
 case Lisp_Int:
 survives_p = 1;
 break;
 case Lisp_String:
 survives_p = STRING_MARKED_P (XSTRING (obj));
 break;
 case Lisp_Vectorlike:
-survives_p = GC_SUBRP (obj) || VECTOR_MARKED_P (XVECTOR (obj));
+survives_p = SUBRP (obj) || VECTOR_MARKED_P (XVECTOR (obj));
 break;
 case Lisp_Cons:
 survives_p = CONS_MARKED_P (XCONS (obj));
 break;

Mercurial > emacs

comparison src/alloc.c @ 90970:3371fc48749b