Eliminate uses of GC_PTR, a holdover from libgc 6.x.

* libguile/bdw-gc.h (GC_PTR): Don't define.
* libguile/finalizers.c (scm_i_set_finalizer): Use void* instead of
  GC_PTR.
* libguile/foreign.c (pointer_finalizer_trampoline): Likewise.
* libguile/guardians.c (finalize_guarded, scm_i_guard): Likewise.
* libguile/numbers.c (finalize_bignum): Likewise.
* libguile/ports.c (finalize_port, finalize_iconv_descriptors): Likewise.
* libguile/smob.c (finalize_smob): Likewise.
* libguile/struct.c (struct_finalizer_trampoline): Likewise.
* libguile/weak-set.c (move_weak_entry, resize_set):
  (weak_set_add_x, weak_set_remove_x): Likewise, but also change some
  casts that should've been GC_PTR* to void**, and don't cast pointer
  values to void*.
* libguile/weak-table.c (register_disappearing_links):
  (unregister_disappearing_links, move_disappearing_links): Likewise.
* libguile/weak-vector.c (scm_c_weak_vector_set_x): Likewise.

libguile/bdw-gc.h

@@ -46,10 +46,7 @@
 # error Boehm-GC version 7.2 or better is needed
 #endif
 
-#if (defined GC_VERSION_MAJOR) && (GC_VERSION_MAJOR >= 7)
+#define GC_PTR  do_not_use_GC_PTR do_not_use_GC_PTR do_not_use_GC_PTR
-/* This type was provided by `libgc' 6.x.  */
-typedef void *GC_PTR;
-#endif
 
 
 /* Return true if PTR points to the heap.  */

libguile/finalizers.c

@@ -58,7 +58,7 @@ void
 scm_i_set_finalizer (void *obj, scm_t_finalizer_proc proc, void *data)
 {
   GC_finalization_proc prev;
-  GC_PTR prev_data;
+  void *prev_data;
   GC_REGISTER_FINALIZER_NO_ORDER (obj, proc, data, &prev, &prev_data);
 }
 

libguile/foreign.c

@@ -96,7 +96,7 @@ register_weak_reference (SCM from, SCM to)
 }
 
 static void
-pointer_finalizer_trampoline (GC_PTR ptr, GC_PTR data)
+pointer_finalizer_trampoline (void *ptr, void *data)
 {
   scm_t_pointer_finalizer finalizer = data;
   finalizer (SCM_POINTER_VALUE (SCM_PACK_POINTER (ptr)));

libguile/guardians.c

@@ -103,7 +103,7 @@ guardian_print (SCM guardian, SCM port, scm_print_state *pstate SCM_UNUSED)
 /* Handle finalization of OBJ which is guarded by the guardians listed in
    GUARDIAN_LIST.  */
 static void
-finalize_guarded (GC_PTR ptr, GC_PTR finalizer_data)
+finalize_guarded (void *ptr, void *finalizer_data)
 {
   SCM cell_pool;
   SCM obj, guardian_list, proxied_finalizer;
@@ -166,7 +166,7 @@ finalize_guarded (GC_PTR ptr, GC_PTR finalizer_data)
       /* Re-register the finalizer that was in place before we installed this
 	 one.  */
       GC_finalization_proc finalizer, prev_finalizer;
-      GC_PTR finalizer_data, prev_finalizer_data;
+      void *finalizer_data, *prev_finalizer_data;
 
       finalizer = (GC_finalization_proc) SCM_UNPACK_POINTER (SCM_CAR (proxied_finalizer));
       finalizer_data = SCM_UNPACK_POINTER (SCM_CDR (proxied_finalizer));
@@ -206,7 +206,7 @@ scm_i_guard (SCM guardian, SCM obj)
 	 the very beginning of an object's lifetime (e.g., see `SCM_NEWSMOB')
 	 or by this function.  */
       GC_finalization_proc prev_finalizer;
-      GC_PTR prev_data;
+      void *prev_data;
       SCM guardians_for_obj, finalizer_data;
 
       g->live++;

libguile/numbers.c

@@ -179,7 +179,7 @@ static mpz_t z_negative_one;
 
 /* Clear the `mpz_t' embedded in bignum PTR.  */
 static void
-finalize_bignum (GC_PTR ptr, GC_PTR data)
+finalize_bignum (void *ptr, void *data)
 {
   SCM bignum;
 

libguile/ports.c

@@ -553,7 +553,7 @@ do_free (void *body_data)
 
 /* Finalize the object (a port) pointed to by PTR.  */
 static void
-finalize_port (GC_PTR ptr, GC_PTR data)
+finalize_port (void *ptr, void *data)
 {
   SCM port = SCM_PACK_POINTER (ptr);
 
@@ -848,7 +848,7 @@ scm_i_default_port_encoding (void)
 }
 
 static void
-finalize_iconv_descriptors (GC_PTR ptr, GC_PTR data)
+finalize_iconv_descriptors (void *ptr, void *data)
 {
   close_iconv_descriptors (ptr);
 }

libguile/smob.c

@@ -377,7 +377,7 @@ scm_gc_mark (SCM o)
 
 /* Finalize SMOB by calling its SMOB type's free function, if any.  */
 static void
-finalize_smob (GC_PTR ptr, GC_PTR data)
+finalize_smob (void *ptr, void *data)
 {
   SCM smob;
   size_t (* free_smob) (SCM);

libguile/struct.c

@@ -411,7 +411,7 @@ SCM_DEFINE (scm_struct_vtable_p, "struct-vtable?", 1, 0, 0,
 
 /* Finalization: invoke the finalizer of the struct pointed to by PTR.  */
 static void
-struct_finalizer_trampoline (GC_PTR ptr, GC_PTR unused_data)
+struct_finalizer_trampoline (void *ptr, void *unused_data)
 {
   SCM obj = PTR2SCM (ptr);
   scm_t_struct_finalize finalize = SCM_STRUCT_FINALIZER (obj);

libguile/weak-set.c

@@ -174,11 +174,11 @@ move_weak_entry (scm_t_weak_entry *from, scm_t_weak_entry *to)
       if (copy.key && SCM_HEAP_OBJECT_P (SCM_PACK (copy.key)))
         {
 #ifdef HAVE_GC_MOVE_DISAPPEARING_LINK
-          GC_move_disappearing_link ((GC_PTR) &from->key, (GC_PTR) &to->key);
+          GC_move_disappearing_link ((void **) &from->key, (void **) &to->key);
 #else
-          GC_unregister_disappearing_link ((GC_PTR) &from->key);
+          GC_unregister_disappearing_link ((void **) &from->key);
-          SCM_I_REGISTER_DISAPPEARING_LINK ((GC_PTR) &to->key,
+          SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &to->key,
-                                            (GC_PTR) to->key);
+					    (void *) to->key);
 #endif
         }
     }
@@ -418,8 +418,8 @@ resize_set (scm_t_weak_set *set)
       new_entries[new_k].key = copy.key;
 
       if (SCM_HEAP_OBJECT_P (SCM_PACK (copy.key)))
-        SCM_I_REGISTER_DISAPPEARING_LINK ((GC_PTR) &new_entries[new_k].key,
+        SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &new_entries[new_k].key,
-                                          (GC_PTR) new_entries[new_k].key);
+                                          (void *) new_entries[new_k].key);
     }
 }
 
@@ -579,8 +579,8 @@ weak_set_add_x (scm_t_weak_set *set, unsigned long hash,
   entries[k].key = SCM_UNPACK (obj);
 
   if (SCM_HEAP_OBJECT_P (obj))
-    SCM_I_REGISTER_DISAPPEARING_LINK ((GC_PTR) &entries[k].key,
+    SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &entries[k].key,
-                                      (GC_PTR) SCM2PTR (obj));
+                                      SCM2PTR (obj));
 
   return obj;
 }
@@ -631,7 +631,7 @@ weak_set_remove_x (scm_t_weak_set *set, unsigned long hash,
               entries[k].key = 0;
 
               if (SCM_HEAP_OBJECT_P (SCM_PACK (copy.key)))
-                GC_unregister_disappearing_link ((GC_PTR) &entries[k].key);
+                GC_unregister_disappearing_link ((void **) &entries[k].key);
 
               if (--set->n_items < set->lower)
                 resize_set (set);

libguile/weak-table.c

@@ -130,14 +130,14 @@ register_disappearing_links (scm_t_weak_entry *entry,
   if (SCM_UNPACK (k) && SCM_HEAP_OBJECT_P (k)
       && (kind == SCM_WEAK_TABLE_KIND_KEY
           || kind == SCM_WEAK_TABLE_KIND_BOTH))
-    SCM_I_REGISTER_DISAPPEARING_LINK ((GC_PTR) &entry->key,
+    SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &entry->key,
-                                      (GC_PTR) SCM2PTR (k));
+                                      SCM2PTR (k));
 
   if (SCM_UNPACK (v) && SCM_HEAP_OBJECT_P (v)
       && (kind == SCM_WEAK_TABLE_KIND_VALUE
           || kind == SCM_WEAK_TABLE_KIND_BOTH))
-    SCM_I_REGISTER_DISAPPEARING_LINK ((GC_PTR) &entry->value,
+    SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &entry->value,
-                                      (GC_PTR) SCM2PTR (v));
+                                      SCM2PTR (v));
 }
 
 static void
@@ -145,10 +145,10 @@ unregister_disappearing_links (scm_t_weak_entry *entry,
                                scm_t_weak_table_kind kind)
 {
   if (kind == SCM_WEAK_TABLE_KIND_KEY || kind == SCM_WEAK_TABLE_KIND_BOTH)
-    GC_unregister_disappearing_link ((GC_PTR) &entry->key);
+    GC_unregister_disappearing_link ((void **) &entry->key);
 
   if (kind == SCM_WEAK_TABLE_KIND_VALUE || kind == SCM_WEAK_TABLE_KIND_BOTH)
-    GC_unregister_disappearing_link ((GC_PTR) &entry->value);
+    GC_unregister_disappearing_link ((void **) &entry->value);
 }
 
 static void
@@ -159,10 +159,10 @@ move_disappearing_links (scm_t_weak_entry *from, scm_t_weak_entry *to,
       && SCM_HEAP_OBJECT_P (key))
     {
 #ifdef HAVE_GC_MOVE_DISAPPEARING_LINK
-      GC_move_disappearing_link ((GC_PTR) &from->key, (GC_PTR) &to->key);
+      GC_move_disappearing_link ((void **) &from->key, (void **) &to->key);
 #else
-      GC_unregister_disappearing_link (&from->key);
+      GC_unregister_disappearing_link ((void **) &from->key);
-      SCM_I_REGISTER_DISAPPEARING_LINK (&to->key, SCM2PTR (key));
+      SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &to->key, SCM2PTR (key));
 #endif
     }
 
@@ -170,10 +170,10 @@ move_disappearing_links (scm_t_weak_entry *from, scm_t_weak_entry *to,
       && SCM_HEAP_OBJECT_P (value))
     {
 #ifdef HAVE_GC_MOVE_DISAPPEARING_LINK
-      GC_move_disappearing_link ((GC_PTR) &from->value, (GC_PTR) &to->value);
+      GC_move_disappearing_link ((void **) &from->value, (void **) &to->value);
 #else
-      GC_unregister_disappearing_link (&from->value);
+      GC_unregister_disappearing_link ((void **) &from->value);
-      SCM_I_REGISTER_DISAPPEARING_LINK (&to->value, SCM2PTR (value));
+      SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &to->value, SCM2PTR (value));
 #endif
     }
 }

libguile/weak-vector.c

@@ -171,13 +171,12 @@ scm_c_weak_vector_set_x (SCM wv, size_t k, SCM x)
   elts = SCM_I_VECTOR_WELTS (wv);
 
   if (prev && SCM_HEAP_OBJECT_P (SCM_PACK_POINTER (prev)))
-    GC_unregister_disappearing_link ((GC_PTR) &elts[k]);
+    GC_unregister_disappearing_link ((void **) &elts[k]);
   
   elts[k] = x;
 
   if (SCM_HEAP_OBJECT_P (x))
-    SCM_I_REGISTER_DISAPPEARING_LINK ((GC_PTR) &elts[k],
+    SCM_I_REGISTER_DISAPPEARING_LINK ((void **) &elts[k], SCM2PTR (x));
-                                      (GC_PTR) SCM2PTR (x));
 }