libiberty: stop using PTR macro

include/ChangeLog:

	* hashtab.h (HTAB_EMPTY_ENTRY): Use void * instead PTR.
	(HTAB_DELETED_ENTRY): Likewise.

libiberty/ChangeLog:

	* alloca.c (C_alloca): Use void * instead PTR.
	* calloc.c (malloc): Likewise.
	(bzero): Likewise.
	(calloc): Likewise.
	* hashtab.c (find_empty_slot_for_expand): Likewise.
	(eq_pointer): Likewise.
	(htab_create_alloc_ex): Likewise.
	(htab_create_typed_alloc): Likewise.
	(htab_set_functions_ex): Likewise.
	(htab_delete): Likewise.
	(htab_empty): Likewise.
	(htab_expand): Likewise.
	(htab_find_with_hash): Likewise.
	(htab_find): Likewise.
	(htab_find_slot_with_hash): Likewise.
	(htab_find_slot): Likewise.
	(htab_remove_elt): Likewise.
	(htab_remove_elt_with_hash): Likewise.
	(htab_clear_slot): Likewise.
	(htab_traverse_noresize): Likewise.
	(htab_traverse): Likewise.
	(htab_hash_string): Likewise.
	(iterative_hash): Likewise.
	(hash_pointer): Likewise.
	* memchr.c (memchr): Likewise.
	* memcmp.c (memcmp): Likewise.
	* memcpy.c (memcpy): Likewise.
	* memmove.c (memmove): Likewise.
	* mempcpy.c (memcpy): Likewise.
	(mempcpy): Likewise.
	* memset.c (memset): Likewise.
	* objalloc.c (malloc): Likewise.
	(free): Likewise.
	(objalloc_create): Likewise.
	(_objalloc_alloc): Likewise.
	(objalloc_free_block): Likewise.
	* random.c (PTR): Likewise.
	(void): Likewise.
	(initstate): Likewise.
	(setstate): Likewise.
	* regex.c: Likewise.
	* spaces.c (malloc): Likewise.
	(free): Likewise.
	* stpcpy.c (memcpy): Likewise.
	* strdup.c (malloc): Likewise.
	(memcpy): Likewise.
	* strerror.c (malloc): Likewise.
	(memset): Likewise.
	* strndup.c (malloc): Likewise.
	(memcpy): Likewise.
	* strsignal.c (malloc): Likewise.
	(memset): Likewise.
	* vasprintf.c (malloc): Likewise.
	* vprintf-support.c: Likewise.
	* xatexit.c (malloc): Likewise.
	* xmalloc.c (xmalloc): Likewise.
	(xcalloc): Likewise.
	(xrealloc): Likewise.
	* xmemdup.c (xmemdup): Likewise.

include/hashtab.h

@@ -79,12 +79,12 @@ typedef void (*htab_free_with_arg) (void *, void *);
 
 /* This macro defines reserved value for empty table entry.  */
 
-#define HTAB_EMPTY_ENTRY    ((PTR) 0)
+#define HTAB_EMPTY_ENTRY    ((void *) 0)
 
 /* This macro defines reserved value for table entry which contained
    a deleted element. */
 
-#define HTAB_DELETED_ENTRY  ((PTR) 1)
+#define HTAB_DELETED_ENTRY  ((void *) 1)
 
 /* Hash tables are of the following type.  The structure
    (implementation) of this type is not needed for using the hash

libiberty/alloca.c

@@ -158,7 +158,7 @@ static header *last_alloca_header = NULL;	/* -> last alloca header.  */
 
 /* @undocumented C_alloca */
 
-PTR
+void *
 C_alloca (size_t size)
 {
   auto char probe;		/* Probes stack depth: */
@@ -181,7 +181,7 @@ C_alloca (size_t size)
 	{
 	  register header *np = hp->h.next;
 
-	  free ((PTR) hp);	/* Collect garbage.  */
+	  free ((void *) hp);	/* Collect garbage.  */
 
 	  hp = np;		/* -> next header.  */
 	}
@@ -210,7 +210,7 @@ C_alloca (size_t size)
 
     /* User storage begins just after header.  */
 
-    return (PTR) ((char *) new_storage + sizeof (header));
+    return (void *) ((char *) new_storage + sizeof (header));
   }
 }
 

libiberty/calloc.c

@@ -16,13 +16,13 @@ Uses @code{malloc} to allocate storage for @var{nelem} objects of
 #include <stddef.h>
 
 /* For systems with larger pointers than ints, this must be declared.  */
-PTR malloc (size_t);
+void *malloc (size_t);
-void bzero (PTR, size_t);
+void bzero (void *, size_t);
 
-PTR
+void *
 calloc (size_t nelem, size_t elsize)
 {
-  register PTR ptr;  
+  register void *ptr;
 
   if (nelem == 0 || elsize == 0)
     nelem = elsize = 1;

libiberty/hashtab.c

@@ -73,7 +73,7 @@ static hashval_t htab_mod_m2 (hashval_t, htab_t);
 static hashval_t hash_pointer (const void *);
 static int eq_pointer (const void *, const void *);
 static int htab_expand (htab_t);
-static PTR *find_empty_slot_for_expand (htab_t, hashval_t);
+static void **find_empty_slot_for_expand (htab_t, hashval_t);
 
 /* At some point, we could make these be NULL, and modify the
    hash-table routines to handle NULL specially; that would avoid
@@ -196,7 +196,7 @@ higher_prime_index (unsigned long n)
 /* Returns non-zero if P1 and P2 are equal.  */
 
 static int
-eq_pointer (const PTR p1, const PTR p2)
+eq_pointer (const void *p1, const void *p2)
 {
   return p1 == p2;
 }
@@ -304,7 +304,7 @@ htab_create_alloc_ex (size_t size, htab_hash hash_f, htab_eq eq_f,
   result = (htab_t) (*alloc_f) (alloc_arg, 1, sizeof (struct htab));
   if (result == NULL)
     return NULL;
-  result->entries = (PTR *) (*alloc_f) (alloc_arg, size, sizeof (PTR));
+  result->entries = (void **) (*alloc_f) (alloc_arg, size, sizeof (void *));
   if (result->entries == NULL)
     {
       if (free_f != NULL)
@@ -357,7 +357,7 @@ htab_create_typed_alloc (size_t size, htab_hash hash_f, htab_eq eq_f,
   result = (htab_t) (*alloc_tab_f) (1, sizeof (struct htab));
   if (result == NULL)
     return NULL;
-  result->entries = (PTR *) (*alloc_f) (size, sizeof (PTR));
+  result->entries = (void **) (*alloc_f) (size, sizeof (void *));
   if (result->entries == NULL)
     {
       if (free_f != NULL)
@@ -379,7 +379,7 @@ htab_create_typed_alloc (size_t size, htab_hash hash_f, htab_eq eq_f,
 
 void
 htab_set_functions_ex (htab_t htab, htab_hash hash_f, htab_eq eq_f,
-                       htab_del del_f, PTR alloc_arg,
+                       htab_del del_f, void *alloc_arg,
                        htab_alloc_with_arg alloc_f, htab_free_with_arg free_f)
 {
   htab->hash_f = hash_f;
@@ -412,7 +412,7 @@ void
 htab_delete (htab_t htab)
 {
   size_t size = htab_size (htab);
-  PTR *entries = htab->entries;
+  void **entries = htab->entries;
   int i;
 
   if (htab->del_f)
@@ -438,7 +438,7 @@ void
 htab_empty (htab_t htab)
 {
   size_t size = htab_size (htab);
-  PTR *entries = htab->entries;
+  void **entries = htab->entries;
   int i;
 
   if (htab->del_f)
@@ -447,9 +447,9 @@ htab_empty (htab_t htab)
 	(*htab->del_f) (entries[i]);
 
   /* Instead of clearing megabyte, downsize the table.  */
-  if (size > 1024*1024 / sizeof (PTR))
+  if (size > 1024*1024 / sizeof (void *))
     {
-      int nindex = higher_prime_index (1024 / sizeof (PTR));
+      int nindex = higher_prime_index (1024 / sizeof (void *));
       int nsize = prime_tab[nindex].prime;
 
       if (htab->free_f != NULL)
@@ -457,15 +457,15 @@ htab_empty (htab_t htab)
       else if (htab->free_with_arg_f != NULL)
 	(*htab->free_with_arg_f) (htab->alloc_arg, htab->entries);
       if (htab->alloc_with_arg_f != NULL)
-	htab->entries = (PTR *) (*htab->alloc_with_arg_f) (htab->alloc_arg, nsize,
+	htab->entries = (void **) (*htab->alloc_with_arg_f) (htab->alloc_arg, nsize,
-						           sizeof (PTR *));
+						           sizeof (void **));
       else
-	htab->entries = (PTR *) (*htab->alloc_f) (nsize, sizeof (PTR *));
+	htab->entries = (void **) (*htab->alloc_f) (nsize, sizeof (void **));
      htab->size = nsize;
      htab->size_prime_index = nindex;
     }
   else
-    memset (entries, 0, size * sizeof (PTR));
+    memset (entries, 0, size * sizeof (void *));
   htab->n_deleted = 0;
   htab->n_elements = 0;
 }
@@ -477,12 +477,12 @@ htab_empty (htab_t htab)
    This function also assumes there are no deleted entries in the table.
    HASH is the hash value for the element to be inserted.  */
 
-static PTR *
+static void **
 find_empty_slot_for_expand (htab_t htab, hashval_t hash)
 {
   hashval_t index = htab_mod (hash, htab);
   size_t size = htab_size (htab);
-  PTR *slot = htab->entries + index;
+  void **slot = htab->entries + index;
   hashval_t hash2;
 
   if (*slot == HTAB_EMPTY_ENTRY)
@@ -516,10 +516,10 @@ find_empty_slot_for_expand (htab_t htab, hashval_t hash)
 static int
 htab_expand (htab_t htab)
 {
-  PTR *oentries;
+  void **oentries;
-  PTR *olimit;
+  void **olimit;
-  PTR *p;
+  void **p;
-  PTR *nentries;
+  void **nentries;
   size_t nsize, osize, elts;
   unsigned int oindex, nindex;
 
@@ -543,10 +543,10 @@ htab_expand (htab_t htab)
     }
 
   if (htab->alloc_with_arg_f != NULL)
-    nentries = (PTR *) (*htab->alloc_with_arg_f) (htab->alloc_arg, nsize,
+    nentries = (void **) (*htab->alloc_with_arg_f) (htab->alloc_arg, nsize,
-						  sizeof (PTR *));
+						  sizeof (void **));
   else
-    nentries = (PTR *) (*htab->alloc_f) (nsize, sizeof (PTR *));
+    nentries = (void **) (*htab->alloc_f) (nsize, sizeof (void **));
   if (nentries == NULL)
     return 0;
   htab->entries = nentries;
@@ -558,11 +558,11 @@ htab_expand (htab_t htab)
   p = oentries;
   do
     {
-      PTR x = *p;
+      void *x = *p;
 
       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
 	{
-	  PTR *q = find_empty_slot_for_expand (htab, (*htab->hash_f) (x));
+	  void **q = find_empty_slot_for_expand (htab, (*htab->hash_f) (x));
 
 	  *q = x;
 	}
@@ -581,12 +581,12 @@ htab_expand (htab_t htab)
 /* This function searches for a hash table entry equal to the given
    element.  It cannot be used to insert or delete an element.  */
 
-PTR
+void *
-htab_find_with_hash (htab_t htab, const PTR element, hashval_t hash)
+htab_find_with_hash (htab_t htab, const void *element, hashval_t hash)
 {
   hashval_t index, hash2;
   size_t size;
-  PTR entry;
+  void *entry;
 
   htab->searches++;
   size = htab_size (htab);
@@ -615,8 +615,8 @@ htab_find_with_hash (htab_t htab, const PTR element, hashval_t hash)
 /* Like htab_find_slot_with_hash, but compute the hash value from the
    element.  */
 
-PTR
+void *
-htab_find (htab_t htab, const PTR element)
+htab_find (htab_t htab, const void *element)
 {
   return htab_find_with_hash (htab, element, (*htab->hash_f) (element));
 }
@@ -629,14 +629,14 @@ htab_find (htab_t htab, const PTR element)
    slot.  When inserting an entry, NULL may be returned if memory
    allocation fails.  */
 
-PTR *
+void **
-htab_find_slot_with_hash (htab_t htab, const PTR element,
+htab_find_slot_with_hash (htab_t htab, const void *element,
                           hashval_t hash, enum insert_option insert)
 {
-  PTR *first_deleted_slot;
+  void **first_deleted_slot;
   hashval_t index, hash2;
   size_t size;
-  PTR entry;
+  void *entry;
 
   size = htab_size (htab);
   if (insert == INSERT && size * 3 <= htab->n_elements * 4)
@@ -697,8 +697,8 @@ htab_find_slot_with_hash (htab_t htab, const PTR element,
 /* Like htab_find_slot_with_hash, but compute the hash value from the
    element.  */
 
-PTR *
+void **
-htab_find_slot (htab_t htab, const PTR element, enum insert_option insert)
+htab_find_slot (htab_t htab, const void *element, enum insert_option insert)
 {
   return htab_find_slot_with_hash (htab, element, (*htab->hash_f) (element),
 				   insert);
@@ -709,7 +709,7 @@ htab_find_slot (htab_t htab, const PTR element, enum insert_option insert)
    element in the hash table, this function does nothing.  */
 
 void
-htab_remove_elt (htab_t htab, const PTR element)
+htab_remove_elt (htab_t htab, const void *element)
 {
   htab_remove_elt_with_hash (htab, element, (*htab->hash_f) (element));
 }
@@ -720,9 +720,9 @@ htab_remove_elt (htab_t htab, const PTR element)
    function does nothing.  */
 
 void
-htab_remove_elt_with_hash (htab_t htab, const PTR element, hashval_t hash)
+htab_remove_elt_with_hash (htab_t htab, const void *element, hashval_t hash)
 {
-  PTR *slot;
+  void **slot;
 
   slot = htab_find_slot_with_hash (htab, element, hash, NO_INSERT);
   if (slot == NULL)
@@ -740,7 +740,7 @@ htab_remove_elt_with_hash (htab_t htab, const PTR element, hashval_t hash)
    again.  */
 
 void
-htab_clear_slot (htab_t htab, PTR *slot)
+htab_clear_slot (htab_t htab, void **slot)
 {
   if (slot < htab->entries || slot >= htab->entries + htab_size (htab)
       || *slot == HTAB_EMPTY_ENTRY || *slot == HTAB_DELETED_ENTRY)
@@ -759,17 +759,17 @@ htab_clear_slot (htab_t htab, PTR *slot)
    argument.  */
 
 void
-htab_traverse_noresize (htab_t htab, htab_trav callback, PTR info)
+htab_traverse_noresize (htab_t htab, htab_trav callback, void *info)
 {
-  PTR *slot;
+  void **slot;
-  PTR *limit;
+  void **limit;
   
   slot = htab->entries;
   limit = slot + htab_size (htab);
 
   do
     {
-      PTR x = *slot;
+      void *x = *slot;
 
       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
 	if (!(*callback) (slot, info))
@@ -782,7 +782,7 @@ htab_traverse_noresize (htab_t htab, htab_trav callback, PTR info)
    too empty to improve effectivity of subsequent calls.  */
 
 void
-htab_traverse (htab_t htab, htab_trav callback, PTR info)
+htab_traverse (htab_t htab, htab_trav callback, void *info)
 {
   size_t size = htab_size (htab);
   if (htab_elements (htab) * 8 < size && size > 32)
@@ -829,7 +829,7 @@ htab_collisions (htab_t htab)
    function they just started using for Perl's hashes.  */
 
 hashval_t
-htab_hash_string (const PTR p)
+htab_hash_string (const void *p)
 {
   const unsigned char *str = (const unsigned char *) p;
   hashval_t r = 0;
@@ -926,7 +926,7 @@ acceptable.  Do NOT use for cryptographic purposes.
 */
 
 hashval_t
-iterative_hash (const PTR k_in /* the key */,
+iterative_hash (const void *k_in /* the key */,
                 register size_t  length /* the length of the key */,
                 register hashval_t initval /* the previous hash, or
                                               an arbitrary value */)
@@ -990,7 +990,7 @@ iterative_hash (const PTR k_in /* the key */,
 /* Returns a hash code for pointer P. Simplified version of evahash */
 
 static hashval_t
-hash_pointer (const PTR p)
+hash_pointer (const void *p)
 {
   intptr_t v = (intptr_t) p;
   unsigned a, b, c;

libiberty/memchr.c

@@ -18,15 +18,15 @@ returned.
 #include <ansidecl.h>
 #include <stddef.h>
 
-PTR
+void *
-memchr (register const PTR src_void, int c, size_t length)
+memchr (register const void *src_void, int c, size_t length)
 {
   const unsigned char *src = (const unsigned char *)src_void;
   
   while (length-- > 0)
   {
     if (*src == c)
-     return (PTR)src;
+     return (void *)src;
     src++;
   }
   return NULL;

libiberty/memcmp.c

@@ -20,7 +20,7 @@ as if comparing unsigned char arrays.
 #include <stddef.h>
 
 int
-memcmp (const PTR str1, const PTR str2, size_t count)
+memcmp (const void *str1, const void *str2, size_t count)
 {
   register const unsigned char *s1 = (const unsigned char*)str1;
   register const unsigned char *s2 = (const unsigned char*)str2;

libiberty/memcpy.c

@@ -18,8 +18,8 @@ Copies @var{length} bytes from memory region @var{in} to region
 
 void bcopy (const void*, void*, size_t);
 
-PTR
+void *
-memcpy (PTR out, const PTR in, size_t length)
+memcpy (void *out, const void *in, size_t length)
 {
     bcopy(in, out, length);
     return out;

libiberty/memmove.c

@@ -18,8 +18,8 @@ Copies @var{count} bytes from memory area @var{from} to memory area
 
 void bcopy (const void*, void*, size_t);
 
-PTR
+void *
-memmove (PTR s1, const PTR s2, size_t n)
+memmove (void *s1, const void *s2, size_t n)
 {
   bcopy (s2, s1, n);
   return s1;

libiberty/mempcpy.c

@@ -33,10 +33,10 @@ Copies @var{length} bytes from memory region @var{in} to region
 #include <ansidecl.h>
 #include <stddef.h>
 
-extern PTR memcpy (PTR, const PTR, size_t);
+extern void *memcpy (void *, const void *, size_t);
 
-PTR
+void *
-mempcpy (PTR dst, const PTR src, size_t len)
+mempcpy (void *dst, const void *src, size_t len)
 {
   return (char *) memcpy (dst, src, len) + len;
 }

libiberty/memset.c

@@ -16,8 +16,8 @@ Sets the first @var{count} bytes of @var{s} to the constant byte
 #include <ansidecl.h>
 #include <stddef.h>
 
-PTR
+void *
-memset (PTR dest, register int val, register size_t len)
+memset (void *dest, register int val, register size_t len)
 {
   register unsigned char *ptr = (unsigned char*)dest;
   while (len-- > 0)

libiberty/objalloc.c

@@ -37,8 +37,8 @@ Boston, MA 02110-1301, USA.  */
 #include <stdlib.h>
 #else
 /* For systems with larger pointers than ints, this must be declared.  */
-extern PTR malloc (size_t);
+extern void *malloc (size_t);
-extern void free (PTR);
+extern void free (void *);
 #endif
 
 #endif
@@ -92,7 +92,7 @@ objalloc_create (void)
   if (ret == NULL)
     return NULL;
 
-  ret->chunks = (PTR) malloc (CHUNK_SIZE);
+  ret->chunks = (void *) malloc (CHUNK_SIZE);
   if (ret->chunks == NULL)
     {
       free (ret);
@@ -111,7 +111,7 @@ objalloc_create (void)
 
 /* Allocate space from an objalloc structure.  */
 
-PTR
+void *
 _objalloc_alloc (struct objalloc *o, unsigned long original_len)
 {
   unsigned long len = original_len;
@@ -132,7 +132,7 @@ _objalloc_alloc (struct objalloc *o, unsigned long original_len)
     {
       o->current_ptr += len;
       o->current_space -= len;
-      return (PTR) (o->current_ptr - len);
+      return (void *) (o->current_ptr - len);
     }
 
   if (len >= BIG_REQUEST)
@@ -148,9 +148,9 @@ _objalloc_alloc (struct objalloc *o, unsigned long original_len)
       chunk->next = (struct objalloc_chunk *) o->chunks;
       chunk->current_ptr = o->current_ptr;
 
-      o->chunks = (PTR) chunk;
+      o->chunks = (void *) chunk;
 
-      return (PTR) (ret + CHUNK_HEADER_SIZE);
+      return (void *) (ret + CHUNK_HEADER_SIZE);
     }
   else
     {
@@ -165,7 +165,7 @@ _objalloc_alloc (struct objalloc *o, unsigned long original_len)
       o->current_ptr = (char *) chunk + CHUNK_HEADER_SIZE;
       o->current_space = CHUNK_SIZE - CHUNK_HEADER_SIZE;
 
-      o->chunks = (PTR) chunk;
+      o->chunks = (void *) chunk;
 
       return objalloc_alloc (o, len);
     }
@@ -195,7 +195,7 @@ objalloc_free (struct objalloc *o)
    recently allocated blocks.  */
 
 void
-objalloc_free_block (struct objalloc *o, PTR block)
+objalloc_free_block (struct objalloc *o, void *block)
 {
   struct objalloc_chunk *p, *small;
   char *b = (char *) block;
@@ -257,7 +257,7 @@ objalloc_free_block (struct objalloc *o, PTR block)
 
       if (first == NULL)
 	first = p;
-      o->chunks = (PTR) first;
+      o->chunks = (void *) first;
 
       /* Now start allocating from this small block again.  */
       o->current_ptr = b;
@@ -287,7 +287,7 @@ objalloc_free_block (struct objalloc *o, PTR block)
 	  q = next;
 	}
 
-      o->chunks = (PTR) p;
+      o->chunks = (void *) p;
 
       while (p->current_ptr != NULL)
 	p = p->next;

libiberty/random.c

@@ -68,12 +68,12 @@ control over the state of the random number generator.
 #define	LONG_MAX   ((long)(ULONG_MAX >> 1))   /* 0x7FFFFFFF for 32-bits*/
 
 #ifdef __STDC__
-#  define PTR void *
+#  define void *void *
 #  ifndef NULL
 #    define NULL (void *) 0
 #  endif
 #else
-#  define PTR char *
+#  define void *char *
 #  ifndef NULL
 #    define NULL (void *) 0
 #  endif
@@ -254,10 +254,10 @@ srandom (unsigned int x)
    Note: The first thing we do is save the current state, if any, just like
    setstate so that it doesn't matter when initstate is called.
    Returns a pointer to the old state.  */
-PTR
+void *
-initstate (unsigned int seed, PTR arg_state, unsigned long n)
+initstate (unsigned int seed, void *arg_state, unsigned long n)
 {
-  PTR ostate = (PTR) &state[-1];
+  void *ostate = (void *) &state[-1];
 
   if (rand_type == TYPE_0)
     state[-1] = rand_type;
@@ -320,13 +320,13 @@ initstate (unsigned int seed, PTR arg_state, unsigned long n)
    same state as the current state
    Returns a pointer to the old state information.  */
 
-PTR
+void *
-setstate (PTR arg_state)
+setstate (void *arg_state)
 {
   register long int *new_state = (long int *) arg_state;
   register int type = new_state[0] % MAX_TYPES;
   register int rear = new_state[0] / MAX_TYPES;
-  PTR ostate = (PTR) &state[-1];
+  void *ostate = (void *) &state[-1];
 
   if (rand_type == TYPE_0)
     state[-1] = rand_type;

libiberty/regex.c

@@ -384,8 +384,8 @@ typedef unsigned long int uintptr_t;
 # endif /* not using relocating allocator */
 
 
-/* True if `size1' is non-NULL and PTR is pointing anywhere inside
+/* True if `size1' is non-NULL and void *is pointing anywhere inside
-   `string1' or just past its end.  This works if PTR is NULL, which is
+   `string1' or just past its end.  This works if void *is NULL, which is
    a good thing.  */
 # define FIRST_STRING_P(ptr) 					\
   (size1 && string1 <= (ptr) && (ptr) <= string1 + size1)
@@ -5256,7 +5256,7 @@ PREFIX(re_search_2) (struct re_pattern_buffer *bufp, const char *string1,
 }
 
 #ifdef WCHAR
-/* This converts PTR, a pointer into one of the search wchar_t strings
+/* This converts void *, a pointer into one of the search wchar_t strings
    `string1' and `string2' into an multibyte string offset from the
    beginning of that string. We use mbs_offset to optimize.
    See convert_mbs_to_wcs.  */
@@ -5266,7 +5266,7 @@ PREFIX(re_search_2) (struct re_pattern_buffer *bufp, const char *string1,
    : ((regoff_t)((mbs_offset2 != NULL? mbs_offset2[(ptr)-string2] : 0)	\
 		 + csize1)))
 #else /* BYTE */
-/* This converts PTR, a pointer into one of the search strings `string1'
+/* This converts void *, a pointer into one of the search strings `string1'
    and `string2' into an offset from the beginning of that string.  */
 # define POINTER_TO_OFFSET(ptr)			\
   (FIRST_STRING_P (ptr)				\

libiberty/spaces.c

@@ -40,8 +40,8 @@ valid until at least the next call.
 #include <unixlib.h>
 #else
 /* For systems with larger pointers than ints, these must be declared.  */
-extern PTR malloc (size_t);
+extern void *malloc (size_t);
-extern void free (PTR);
+extern void free (void *);
 #endif
 
 const char *

libiberty/stpcpy.c

@@ -33,7 +33,7 @@ Copies the string @var{src} into @var{dst}.  Returns a pointer to
 #include <stddef.h>
 
 extern size_t strlen (const char *);
-extern PTR memcpy (PTR, const PTR, size_t);
+extern void *memcpy (void *, const void *, size_t);
 
 char *
 stpcpy (char *dst, const char *src)

libiberty/strdup.c

@@ -13,8 +13,8 @@ Returns a pointer to a copy of @var{s} in memory obtained from
 #include <stddef.h>
 
 extern size_t	strlen (const char*);
-extern PTR	malloc (size_t);
+extern void *malloc (size_t);
-extern PTR	memcpy (PTR, const PTR, size_t);
+extern void *memcpy (void *, const void *, size_t);
 
 char *
 strdup(const char *s)

libiberty/strerror.c

@@ -30,13 +30,13 @@
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #else
-extern PTR malloc ();
+extern void *malloc ();
 #endif
 
 #ifdef HAVE_STRING_H
 #include <string.h>
 #else
-extern PTR memset ();
+extern void *memset ();
 #endif
 
 #ifndef MAX

libiberty/strndup.c

@@ -34,8 +34,8 @@ memory was available.  The result is always NUL terminated.
 #include <stddef.h>
 
 extern size_t	strnlen (const char *s, size_t maxlen);
-extern PTR	malloc (size_t);
+extern void *malloc (size_t);
-extern PTR	memcpy (PTR, const PTR, size_t);
+extern void *memcpy (void *, const void *, size_t);
 
 char *
 strndup (const char *s, size_t n)

libiberty/strsignal.c

@@ -26,13 +26,13 @@
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #else
-extern PTR malloc ();
+extern void *malloc ();
 #endif
 
 #ifdef HAVE_STRING_H
 #include <string.h>
 #else
-extern PTR memset ();
+extern void *memset ();
 #endif
 
 /* Undefine the macro we used to hide the definition of sys_siglist

libiberty/vasprintf.c

@@ -33,7 +33,7 @@ Floor, Boston, MA 02110-1301, USA.  */
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #else
-extern PTR malloc ();
+extern void *malloc ();
 #endif
 #include "libiberty.h"
 #include "vprintf-support.h"

libiberty/vprintf-support.c

@@ -49,7 +49,7 @@ libiberty_vprintf_buffer_size (const char *format, va_list args)
 #ifdef va_copy
   va_copy (ap, args);
 #else
-  memcpy ((PTR) &ap, (PTR) &args, sizeof (va_list));
+  memcpy ((void *) &ap, (void *) &args, sizeof (va_list));
 #endif
 
   while (*p != '\0')

libiberty/xatexit.c

@@ -37,7 +37,7 @@ failure.  If you use @code{xatexit} to register functions, you must use
 #include <unixlib.h>
 #else
 /* For systems with larger pointers than ints, this must be declared.  */
-PTR malloc (size_t);
+void *malloc (size_t);
 #endif
 
 static void xatexit_cleanup (void);

libiberty/xmalloc.c

@@ -139,10 +139,10 @@ xmalloc_failed (size_t size)
   xexit (1);
 }  
 
-PTR
+void *
 xmalloc (size_t size)
 {
-  PTR newmem;
+  void *newmem;
 
   if (size == 0)
     size = 1;
@@ -153,10 +153,10 @@ xmalloc (size_t size)
   return (newmem);
 }
 
-PTR
+void *
 xcalloc (size_t nelem, size_t elsize)
 {
-  PTR newmem;
+  void *newmem;
 
   if (nelem == 0 || elsize == 0)
     nelem = elsize = 1;
@@ -168,10 +168,10 @@ xcalloc (size_t nelem, size_t elsize)
   return (newmem);
 }
 
-PTR
+void *
-xrealloc (PTR oldmem, size_t size)
+xrealloc (void *oldmem, size_t size)
 {
-  PTR newmem;
+  void *newmem;
 
   if (size == 0)
     size = 1;

libiberty/xmemdup.c

@@ -31,11 +31,11 @@ allocated, the remaining memory is zeroed.
 # endif
 #endif
 
-PTR
+void *
-xmemdup (const PTR input, size_t copy_size, size_t alloc_size)
+xmemdup (const void *input, size_t copy_size, size_t alloc_size)
 {
-  PTR output = xmalloc (alloc_size);
+  void *output = xmalloc (alloc_size);
   if (alloc_size > copy_size)
     memset ((char *) output + copy_size, 0, alloc_size - copy_size);
-  return (PTR) memcpy (output, input, copy_size);
+  return (void *) memcpy (output, input, copy_size);
 }