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.
This commit is contained in:
Martin Liska
parent
9ddd44b586
commit
50b009c5da
@ -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
|
||||
|
||||
@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -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 bzero (PTR, size_t);
|
||||
void *malloc (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;
|
||||
|
||||
@ -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,
|
||||
sizeof (PTR *));
|
||||
htab->entries = (void **) (*htab->alloc_with_arg_f) (htab->alloc_arg, nsize,
|
||||
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;
|
||||
PTR *olimit;
|
||||
PTR *p;
|
||||
PTR *nentries;
|
||||
void **oentries;
|
||||
void **olimit;
|
||||
void **p;
|
||||
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,
|
||||
sizeof (PTR *));
|
||||
nentries = (void **) (*htab->alloc_with_arg_f) (htab->alloc_arg, nsize,
|
||||
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
|
||||
htab_find_with_hash (htab_t htab, const PTR element, hashval_t hash)
|
||||
void *
|
||||
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
|
||||
htab_find (htab_t htab, const PTR element)
|
||||
void *
|
||||
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 *
|
||||
htab_find_slot_with_hash (htab_t htab, const PTR element,
|
||||
void **
|
||||
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 *
|
||||
htab_find_slot (htab_t htab, const PTR element, enum insert_option insert)
|
||||
void **
|
||||
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;
|
||||
PTR *limit;
|
||||
void **slot;
|
||||
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;
|
||||
|
||||
@ -18,15 +18,15 @@ returned.
|
||||
#include <ansidecl.h>
|
||||
#include <stddef.h>
|
||||
|
||||
PTR
|
||||
memchr (register const PTR src_void, int c, size_t length)
|
||||
void *
|
||||
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;
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -18,8 +18,8 @@ Copies @var{length} bytes from memory region @var{in} to region
|
||||
|
||||
void bcopy (const void*, void*, size_t);
|
||||
|
||||
PTR
|
||||
memcpy (PTR out, const PTR in, size_t length)
|
||||
void *
|
||||
memcpy (void *out, const void *in, size_t length)
|
||||
{
|
||||
bcopy(in, out, length);
|
||||
return out;
|
||||
|
||||
@ -18,8 +18,8 @@ Copies @var{count} bytes from memory area @var{from} to memory area
|
||||
|
||||
void bcopy (const void*, void*, size_t);
|
||||
|
||||
PTR
|
||||
memmove (PTR s1, const PTR s2, size_t n)
|
||||
void *
|
||||
memmove (void *s1, const void *s2, size_t n)
|
||||
{
|
||||
bcopy (s2, s1, n);
|
||||
return s1;
|
||||
|
||||
@ -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
|
||||
mempcpy (PTR dst, const PTR src, size_t len)
|
||||
void *
|
||||
mempcpy (void *dst, const void *src, size_t len)
|
||||
{
|
||||
return (char *) memcpy (dst, src, len) + len;
|
||||
}
|
||||
|
||||
@ -16,8 +16,8 @@ Sets the first @var{count} bytes of @var{s} to the constant byte
|
||||
#include <ansidecl.h>
|
||||
#include <stddef.h>
|
||||
|
||||
PTR
|
||||
memset (PTR dest, register int val, register size_t len)
|
||||
void *
|
||||
memset (void *dest, register int val, register size_t len)
|
||||
{
|
||||
register unsigned char *ptr = (unsigned char*)dest;
|
||||
while (len-- > 0)
|
||||
|
||||
@ -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 free (PTR);
|
||||
extern void *malloc (size_t);
|
||||
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;
|
||||
|
||||
@ -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
|
||||
initstate (unsigned int seed, PTR arg_state, unsigned long n)
|
||||
void *
|
||||
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
|
||||
setstate (PTR arg_state)
|
||||
void *
|
||||
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;
|
||||
|
||||
@ -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
|
||||
`string1' or just past its end. This works if PTR is NULL, which is
|
||||
/* True if `size1' is non-NULL and void *is pointing anywhere inside
|
||||
`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) \
|
||||
|
||||
@ -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 free (PTR);
|
||||
extern void *malloc (size_t);
|
||||
extern void free (void *);
|
||||
#endif
|
||||
|
||||
const char *
|
||||
|
||||
@ -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)
|
||||
|
||||
@ -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 PTR memcpy (PTR, const PTR, size_t);
|
||||
extern void *malloc (size_t);
|
||||
extern void *memcpy (void *, const void *, size_t);
|
||||
|
||||
char *
|
||||
strdup(const char *s)
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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 PTR memcpy (PTR, const PTR, size_t);
|
||||
extern void *malloc (size_t);
|
||||
extern void *memcpy (void *, const void *, size_t);
|
||||
|
||||
char *
|
||||
strndup (const char *s, size_t n)
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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"
|
||||
|
||||
@ -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')
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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
|
||||
xrealloc (PTR oldmem, size_t size)
|
||||
void *
|
||||
xrealloc (void *oldmem, size_t size)
|
||||
{
|
||||
PTR newmem;
|
||||
void *newmem;
|
||||
|
||||
if (size == 0)
|
||||
size = 1;
|
||||
|
||||
@ -31,11 +31,11 @@ allocated, the remaining memory is zeroed.
|
||||
# endif
|
||||
#endif
|
||||
|
||||
PTR
|
||||
xmemdup (const PTR input, size_t copy_size, size_t alloc_size)
|
||||
void *
|
||||
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);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user