From: Erwin Janssen Date: Tue, 20 Sep 2016 11:34:44 +0000 (+0200) Subject: Replace `Void_t` with `void` X-Git-Tag: untagged-5fc0363bc76319758ff6~1^2^2~14 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=85154368112896a4fe08fcadaae46ee0cc26afc8;p=graphviz Replace `Void_t` with `void` There used to be a check that defined `Void_t` as `void` when standard C was used and `char` otherwise. Since we are always compiling with standard C and `void` is a valid type, there is no reason to keep this typedef. --- diff --git a/ast_common.h.in b/ast_common.h.in index e1a1962a9..cb35cbdbb 100644 --- a/ast_common.h.in +++ b/ast_common.h.in @@ -77,11 +77,6 @@ #define __INLINE__ __inline #endif -/* Void_t is defined so that Void_t* can address any type */ -#ifndef Void_t -#define Void_t void -#endif /*Void_t */ - /* dynamic linked library external scope handling */ #undef extern #if defined(_dll_import) && !defined(__EXPORT__) && _DLL_BLD diff --git a/cmd/tools/gvpack.c b/cmd/tools/gvpack.c index cda9c0bac..6b61cad98 100644 --- a/cmd/tools/gvpack.c +++ b/cmd/tools/gvpack.c @@ -422,7 +422,7 @@ static void cloneCluster(Agraph_t * old, Agraph_t * new) /* freef: * Generic free function for dictionaries. */ -static void freef(Dt_t * dt, Void_t * obj, Dtdisc_t * disc) +static void freef(Dt_t * dt, void * obj, Dtdisc_t * disc) { free(obj); } diff --git a/features/common b/features/common index f5a025ee4..837061ed0 100644 --- a/features/common +++ b/features/common @@ -86,11 +86,6 @@ cat{ #define __INLINE__ __inline #endif - /* Void_t is defined so that Void_t* can address any type */ - #ifndef Void_t - #define Void_t void - #endif /*Void_t*/ - /* dynamic linked library external scope handling */ #undef extern #if _dll_import && !defined(__EXPORT__) && _DLL_BLD diff --git a/lib/cdt/cdt.3 b/lib/cdt/cdt.3 index 9c137567e..ce349b1d1 100644 --- a/lib/cdt/cdt.3 +++ b/lib/cdt/cdt.3 @@ -27,7 +27,6 @@ .Ce .Ss "DICTIONARY TYPES" .Cs -Void_t*; Dt_t; Dtdisc_t; Dtmethod_t; @@ -59,37 +58,37 @@ Dtmethod_t* Dtdeque; .Cs #define DTOFFSET(struct_s,member) #define DTDISC(disc,key,size,link,makef,freef,comparf,hashf,memoryf,eventf) -typedef Void_t* (*Dtmake_f)(Dt_t*, Void_t*, Dtdisc_t*); -typedef void (*Dtfree_f)(Dt_t*, Void_t*, Dtdisc_t*); -typedef int (*Dtcompar_f)(Dt_t*, Void_t*, Void_t*, Dtdisc_t*); -typedef unsigned int (*Dthash_f)(Dt_t*, Void_t*, Dtdisc_t*); -typedef Void_t* (*Dtmemory_f)(Dt_t*, Void_t*, size_t, Dtdisc_t*); -typedef int (*Dtevent_f)(Dt_t*, int, Void_t*, Dtdisc_t*); +typedef void* (*Dtmake_f)(Dt_t*, void*, Dtdisc_t*); +typedef void (*Dtfree_f)(Dt_t*, void*, Dtdisc_t*); +typedef int (*Dtcompar_f)(Dt_t*, void*, void*, Dtdisc_t*); +typedef unsigned int (*Dthash_f)(Dt_t*, void*, Dtdisc_t*); +typedef void* (*Dtmemory_f)(Dt_t*, void*, size_t, Dtdisc_t*); +typedef int (*Dtevent_f)(Dt_t*, int, void*, Dtdisc_t*); .Ce .Ss "OBJECT OPERATIONS" .Cs -Void_t* dtinsert(Dt_t* dt, Void_t* obj); -Void_t* dtappend(Dt_t* dt, Void_t* obj); -Void_t* dtdelete(Dt_t* dt, Void_t* obj); -Void_t* dtattach(Dt_t* dt, Void_t* obj); -Void_t* dtdetach(Dt_t* dt, Void_t* obj); -Void_t* dtsearch(Dt_t* dt, Void_t* obj); -Void_t* dtmatch(Dt_t* dt, Void_t* key); -Void_t* dtfirst(Dt_t* dt); -Void_t* dtnext(Dt_t* dt, Void_t* obj); -Void_t* dtlast(Dt_t* dt); -Void_t* dtprev(Dt_t* dt, Void_t* obj); -Void_t* dtfinger(Dt_t* dt); -Void_t* dtrenew(Dt_t* dt, Void_t* obj); -int dtwalk(Dt_t* dt, int (*userf)(Dt_t*, Void_t*, Void_t*), Void_t*); +void* dtinsert(Dt_t* dt, void* obj); +void* dtappend(Dt_t* dt, void* obj); +void* dtdelete(Dt_t* dt, void* obj); +void* dtattach(Dt_t* dt, void* obj); +void* dtdetach(Dt_t* dt, void* obj); +void* dtsearch(Dt_t* dt, void* obj); +void* dtmatch(Dt_t* dt, void* key); +void* dtfirst(Dt_t* dt); +void* dtnext(Dt_t* dt, void* obj); +void* dtlast(Dt_t* dt); +void* dtprev(Dt_t* dt, void* obj); +void* dtfinger(Dt_t* dt); +void* dtrenew(Dt_t* dt, void* obj); +int dtwalk(Dt_t* dt, int (*userf)(Dt_t*, void*, void*), void*); Dtlink_t* dtflatten(Dt_t* dt); Dtlink_t* dtlink(Dt_t*, Dtlink_t* link); -Void_t* dtobj(Dt_t* dt, Dtlink_t* link); +void* dtobj(Dt_t* dt, Dtlink_t* link); Dtlink_t* dtextract(Dt_t* dt); int dtrestore(Dt_t* dt, Dtlink_t* link); -#define DTTREESEARCH(Dt_t* dt, Void_t* obj, action) -#define DTTREEMATCH(Dt_t* dt, Void_t* key, action) +#define DTTREESEARCH(Dt_t* dt, void* obj, action) +#define DTTREEMATCH(Dt_t* dt, void* key, action) .Ce .Ss "DICTIONARY STATUS" .Cs @@ -111,11 +110,6 @@ unordered set/multiset, ordered set/multiset, list, stack, and queue. .PP .Ss "DICTIONARY TYPES" .PP -.Ss " Void_t*" -This type is used to pass objects between \fICdt\fP and application code. -\f5Void_t\fP is defined as \f5void\fP for ANSI-C and C++ -and \f5char\fP for other compilation environments. -.PP .Ss " Dt_t" This is the type of a dictionary handle. .PP @@ -263,11 +257,11 @@ defined in the type \f5Dtdisc_t\fP: Each object \f5obj\fP is identified by a key used for object comparison or hashing. \f5key\fP should be non-negative and defines an offset into \f5obj\fP. If \f5size\fP is negative, the key is a null-terminated -string with starting address \f5*(Void_t**)((char*)obj+key)\fP. +string with starting address \f5*(void**)((char*)obj+key)\fP. If \f5size\fP is zero, the key is a null-terminated string with starting address -\f5(Void_t*)((char*)obj+key)\fP. +\f5(void*)((char*)obj+key)\fP. Finally, if \f5size\fP is positive, the key is a byte array of length \f5size\fP -starting at \f5(Void_t*)((char*)obj+key)\fP. +starting at \f5(void*)((char*)obj+key)\fP. .PP .Ss " int link" Let \f5obj\fP be an object to be inserted into \f5dt\fP as discussed below. @@ -276,17 +270,17 @@ to hold \f5obj\fP. Otherwise, \f5obj\fP should have a \f5Dtlink_t\fP structure embedded \f5link\fP bytes into it, i.e., at address \f5(Dtlink_t*)((char*)obj+link)\fP. .PP -.Ss " Void_t* (*makef)(Dt_t* dt, Void_t* obj, Dtdisc_t* disc)" +.Ss " void* (*makef)(Dt_t* dt, void* obj, Dtdisc_t* disc)" If \f5makef\fP is not \f5NULL\fP, \f5dtinsert(dt,obj)\fP or \f5dtappend()\fP will call it to make a copy of \f5obj\fP suitable for insertion into \f5dt\fP. If \f5makef\fP is \f5NULL\fP, \f5obj\fP itself will be inserted into \f5dt\fP. .PP -.Ss " void (*freef)(Dt_t* dt, Void_t* obj, Dtdisc_t* disc)" +.Ss " void (*freef)(Dt_t* dt, void* obj, Dtdisc_t* disc)" If not \f5NULL\fP, \f5freef\fP is used to destroy data associated with \f5obj\fP. .PP -.Ss "int (*comparf)(Dt_t* dt, Void_t* key1, Void_t* key2, Dtdisc_t* disc)" +.Ss "int (*comparf)(Dt_t* dt, void* key1, void* key2, Dtdisc_t* disc)" If not \f5NULL\fP, \f5comparf\fP is used to compare two keys. Its return value should be \f5<0\fP, \f5=0\fP, or \f5>0\fP to indicate whether \f5key1\fP is smaller, equal to, or larger than \f5key2\fP. @@ -296,14 +290,14 @@ indicates equality and a non-zero value indicates inequality. If \f5(*comparf)()\fP is \f5NULL\fP, an internal function is used to compare the keys as defined by the \f5Dtdisc_t.size\fP field. .PP -.Ss " unsigned int (*hashf)(Dt_t* dt, Void_t* key, Dtdisc_t* disc)" +.Ss " unsigned int (*hashf)(Dt_t* dt, void* key, Dtdisc_t* disc)" If not \f5NULL\fP, \f5hashf\fP is used to compute the hash value of \f5key\fP. It is required that keys compared equal will also have same hash values. If \f5hashf\fP is \f5NULL\fP, an internal function is used to hash the key as defined by the \f5Dtdisc_t.size\fP field. .PP -.Ss " Void_t* (*memoryf)(Dt_t* dt, Void_t* addr, size_t size, Dtdisc_t* disc)" +.Ss " void* (*memoryf)(Dt_t* dt, void* addr, size_t size, Dtdisc_t* disc)" If not \f5NULL\fP, \f5memoryf\fP is used to allocate and free memory. When \f5addr\fP is \f5NULL\fP, a memory segment of size \f5size\fP is requested. If \f5addr\fP is not \f5NULL\fP and \f5size\fP is zero, \f5addr\fP is to be freed. @@ -311,7 +305,7 @@ If \f5addr\fP is not \f5NULL\fP and \f5size\fP is positive, \f5addr\fP is to be resized to the given size. If \f5memoryf\fP is \f5NULL\fP, \fImalloc(3)\fP is used. .PP -.Ss " int (*eventf)(Dt_t* dt, int type, Void_t* data, Dtdisc_t* disc)" +.Ss " int (*eventf)(Dt_t* dt, int type, void* data, Dtdisc_t* disc)" If not \f5NULL\fP, \f5eventf\fP announces various events. Each event may have particular handling of the return values from \f5eventf\fP. But a negative return value typically means failure. @@ -322,9 +316,9 @@ Following are the events: If \f5eventf\fP returns negative, the opening process terminates with failure. If \f5eventf\fP returns zero, the opening process proceeds in a default manner. A positive return value indicates special treatment of memory as follows. -If \f5*(Void_t**)data\fP is set to point to some memory segment +If \f5*(void**)data\fP is set to point to some memory segment as discussed in \f5memoryf\fP, that segment of memory is used to start -the dictionary. If \f5*(Void_t**)data\fP is \f5NULL\fP, +the dictionary. If \f5*(void**)data\fP is \f5NULL\fP, all memory including that of the dictionary handle itself will be allocated via \f5memoryf\fP. .Tp @@ -383,8 +377,8 @@ with the given values. .PP .Ss "OBJECT OPERATIONS" .PP -.Ss " Void_t* dtinsert(Dt_t* dt, Void_t* obj)" -.Ss " Void_t* dtappend(Dt_t* dt, Void_t* obj)" +.Ss " void* dtinsert(Dt_t* dt, void* obj)" +.Ss " void* dtappend(Dt_t* dt, void* obj)" These functions add an object prototyped by \f5obj\fP into \f5dt\fP. \f5dtinsert()\fP and \f5dtappend()\fP perform the same function for all methods except for \f5Dtlist\fP. See \f5Dtlist\fP for details. @@ -396,7 +390,7 @@ See \f5Dtdisc_t.makef\fP for object construction. The new object or a matching object as noted will be returned on success while \f5NULL\fP is returned on error. .PP -.Ss " Void_t* dtdelete(Dt_t* dt, Void_t* obj)" +.Ss " void* dtdelete(Dt_t* dt, void* obj)" If \f5obj\fP is \f5NULL\fP, methods \f5Dtstack\fP and \f5Dtqueue\fP delete respectively stack top or queue head while other methods do nothing. If \f5obj\fP is not \f5NULL\fP, there are two cases. @@ -409,24 +403,24 @@ See \f5Dtdisc_t.freef\fP for object destruction. \f5dtdelete()\fP returns the deleted object (even if it was deallocated) or \f5NULL\fP on error. .PP -.Ss " Void_t* dtattach(Dt_t* dt, Void_t* obj)" +.Ss " void* dtattach(Dt_t* dt, void* obj)" This function is similar to \f5dtinsert()\fP but \f5obj\fP itself will be inserted into \f5dt\fP even if a discipline function \f5makef\fP is defined. .PP -.Ss " Void_t* dtdetach(Dt_t* dt, Void_t* obj)" +.Ss " void* dtdetach(Dt_t* dt, void* obj)" This function is similar to \f5dtdelete()\fP but the object to be deleted from \f5dt\fP will not be freed (via the discipline \f5freef\fP function). .PP -.Ss " Void_t* dtsearch(Dt_t* dt, Void_t* obj)" -.Ss " Void_t* dtmatch(Dt_t* dt, Void_t* key)" +.Ss " void* dtsearch(Dt_t* dt, void* obj)" +.Ss " void* dtmatch(Dt_t* dt, void* key)" These functions find an object matching \f5obj\fP or \f5key\fP either from \f5dt\fP or from some dictionary accessible from \f5dt\fP via a viewpath (see \f5dtview()\fP.) \f5dtsearch()\fP and \f5dtmatch()\fP return the matching object or \f5NULL\fP on failure. .PP -.Ss " Void_t* dtfirst(Dt_t* dt)" -.Ss " Void_t* dtnext(Dt_t* dt, Void_t* obj)" +.Ss " void* dtfirst(Dt_t* dt)" +.Ss " void* dtnext(Dt_t* dt, void* obj)" \f5dtfirst()\fP returns the first object in \f5dt\fP. \f5dtnext()\fP returns the object following \f5obj\fP. Objects are ordered based on the storage method in use. @@ -450,14 +444,14 @@ balanced by a \f5dtnext()/dtprev()\fP call as described. Nested loops will require multiple balancing, once per loop. If loop balancing is not done carefully, either performance is degraded or unexpected behaviors may result. -.Ss " Void_t* dtlast(Dt_t* dt)" -.Ss " Void_t* dtprev(Dt_t* dt, Void_t* obj)" +.Ss " void* dtlast(Dt_t* dt)" +.Ss " void* dtprev(Dt_t* dt, void* obj)" \f5dtlast()\fP and \f5dtprev()\fP are like \f5dtfirst()\fP and \f5dtnext()\fP but work in reverse order. Note that dictionaries on a viewpath are still walked in order but objects in each dictionary are walked in reverse order. .PP -.Ss " Void_t* dtfinger(Dt_t* dt)" +.Ss " void* dtfinger(Dt_t* dt)" This function returns the \fIcurrent object\fP of \f5dt\fP, if any. The current object is defined after a successful call to one of \f5dtsearch()\fP, \f5dtmatch()\fP, \f5dtinsert()\fP, @@ -466,12 +460,12 @@ As a side effect of this implementation of \fICdt\fP, when a dictionary is based on \f5Dtoset\fP and \f5Dtobag\fP, the current object is always defined and is the root of the tree. .PP -.Ss " Void_t* dtrenew(Dt_t* dt, Void_t* obj)" +.Ss " void* dtrenew(Dt_t* dt, void* obj)" This function repositions and perhaps rehashes an object \f5obj\fP after its key has been changed. \f5dtrenew()\fP only works if \f5obj\fP is the current object (see \f5dtfinger()\fP). .PP -.Ss " dtwalk(Dt_t* dt, int (*userf)(Dt_t*, Void_t*, Void_t*), Void_t* data)" +.Ss " dtwalk(Dt_t* dt, int (*userf)(Dt_t*, void*, void*), void* data)" This function calls \f5(*userf)(walk,obj,data)\fP on each object in \f5dt\fP and other dictionaries viewable from it. \f5walk\fP is the dictionary containing \f5obj\fP. @@ -481,7 +475,7 @@ If \f5userf()\fP returns a \f5<0\fP value, .PP .Ss " Dtlink_t* dtflatten(Dt_t* dt)" .Ss " Dtlink_t* dtlink(Dt_t* dt, Dtlink_t* link)" -.Ss " Void_t* dtobj(Dt_t* dt, Dtlink_t* link)" +.Ss " void* dtobj(Dt_t* dt, Dtlink_t* link)" Using \f5dtfirst()/dtnext()\fP or \f5dtlast()/dtprev()\fP to walk a single dictionary can incur significant cost due to function calls. For efficient walking of a single directory (i.e., no viewpathing), @@ -492,7 +486,7 @@ Objects in \f5dt\fP are made into a linked list and walked as follows: .Ce .PP Note that \f5dtflatten()\fP returns a list of type \f5Dtlink_t*\fP, -not \f5Void_t*\fP. That is, it returns a dictionary holder pointer, +not \f5void*\fP. That is, it returns a dictionary holder pointer, not a user object pointer (although both are the same if the discipline field \f5link\fP is zero.) The macro function \f5dtlink()\fP @@ -515,8 +509,8 @@ in an application that creates many concurrent dictionaries. It is important that the same discipline and method are in use at both extraction and restoration. Otherwise, undefined behaviors may result. .PP -.Ss " #define DTTREESEARCH(Dt_t* dt, Void_t* obj, action)" -.Ss " #define DTTREEMATCH(Dt_t* dt, Void_t* key, action)" +.Ss " #define DTTREESEARCH(Dt_t* dt, void* obj, action)" +.Ss " #define DTTREEMATCH(Dt_t* dt, void* key, action)" These macro functions are analogues of \f5dtsearch()\fP and \f5dtmatch()\fP but they can only be used on a dictionary based on a binary search tree, i.e., \f5Dtoset\fP or \f5Dtobag\fP. diff --git a/lib/cdt/cdt.h b/lib/cdt/cdt.h index 8156010cc..360d0146d 100644 --- a/lib/cdt/cdt.h +++ b/lib/cdt/cdt.h @@ -8,10 +8,6 @@ #define CDT_VERSION 20050420L -#ifndef Void_t -#define Void_t void -#endif - #include /* size_t */ #include @@ -37,13 +33,13 @@ typedef struct _dtdata_s Dtdata_t; typedef struct _dt_s Dt_t; typedef struct _dt_s Dict_t; /* for libdict compatibility */ typedef struct _dtstat_s Dtstat_t; -typedef Void_t* (*Dtmemory_f)(Dt_t*,Void_t*,size_t,Dtdisc_t*); -typedef Void_t* (*Dtsearch_f)(Dt_t*,Void_t*,int); -typedef Void_t* (*Dtmake_f)(Dt_t*,Void_t*,Dtdisc_t*); -typedef void (*Dtfree_f)(Dt_t*,Void_t*,Dtdisc_t*); -typedef int (*Dtcompar_f)(Dt_t*,Void_t*,Void_t*,Dtdisc_t*); -typedef unsigned int (*Dthash_f)(Dt_t*,Void_t*,Dtdisc_t*); -typedef int (*Dtevent_f)(Dt_t*,int,Void_t*,Dtdisc_t*); +typedef void* (*Dtmemory_f)(Dt_t*,void*,size_t,Dtdisc_t*); +typedef void* (*Dtsearch_f)(Dt_t*,void*,int); +typedef void* (*Dtmake_f)(Dt_t*,void*,Dtdisc_t*); +typedef void (*Dtfree_f)(Dt_t*,void*,Dtdisc_t*); +typedef int (*Dtcompar_f)(Dt_t*,void*,void*,Dtdisc_t*); +typedef unsigned int (*Dthash_f)(Dt_t*,void*,Dtdisc_t*); +typedef int (*Dtevent_f)(Dt_t*,int,void*,Dtdisc_t*); struct _dtlink_s { Dtlink_t* right; /* right child */ @@ -56,7 +52,7 @@ struct _dtlink_s /* private structure to hold an object */ struct _dthold_s { Dtlink_t hdr; /* header */ - Void_t* obj; /* user object */ + void* obj; /* user object */ }; /* method to manipulate dictionary structure */ @@ -110,7 +106,7 @@ struct _dt_s int nview; /* number of parent view dictionaries */ Dt_t* view; /* next on viewpath */ Dt_t* walk; /* dictionary being walked */ - Void_t* user; /* for user's usage */ + void* user; /* for user's usage */ }; /* structure to get status of a dictionary */ @@ -214,13 +210,13 @@ extern int dtrestore(Dt_t*, Dtlink_t*); extern int dttreeset(Dt_t*, int, int); -extern int dtwalk(Dt_t*, int(*)(Dt_t*,Void_t*,Void_t*), Void_t*); +extern int dtwalk(Dt_t*, int(*)(Dt_t*,void*,void*), void*); -extern Void_t* dtrenew(Dt_t*, Void_t*); +extern void* dtrenew(Dt_t*, void*); extern int dtsize(Dt_t*); extern int dtstat(Dt_t*, Dtstat_t*, int); -extern unsigned int dtstrhash(unsigned int, Void_t*, int); +extern unsigned int dtstrhash(unsigned int, void*, int); #undef extern _END_EXTERNS_ @@ -230,8 +226,8 @@ _END_EXTERNS_ #define _DTDSC(dc,ky,sz,lk,cmpf) \ (ky = dc->key, sz = dc->size, lk = dc->link, cmpf = dc->comparf) #define _DTLNK(o,lk) ((Dtlink_t*)((char*)(o) + lk) ) -#define _DTOBJ(e,lk) (lk < 0 ? ((Dthold_t*)(e))->obj : (Void_t*)((char*)(e) - lk) ) -#define _DTKEY(o,ky,sz) (Void_t*)(sz < 0 ? *((char**)((char*)(o)+ky)) : ((char*)(o)+ky)) +#define _DTOBJ(e,lk) (lk < 0 ? ((Dthold_t*)(e))->obj : (void*)((char*)(e) - lk) ) +#define _DTKEY(o,ky,sz) (void*)(sz < 0 ? *((char**)((char*)(o)+ky)) : ((char*)(o)+ky)) #define _DTCMP(dt,k1,k2,dc,cmpf,sz) \ (cmpf ? (*cmpf)(dt,k1,k2,dc) : \ @@ -240,7 +236,7 @@ _END_EXTERNS_ /* special search function for tree structure only */ #define _DTMTCH(dt,key,action) \ - do { Dtlink_t* _e; Void_t *_o, *_k, *_key; Dtdisc_t* _dc; \ + do { Dtlink_t* _e; void *_o, *_k, *_key; Dtdisc_t* _dc; \ int _ky, _sz, _lk, _cmp; Dtcompar_f _cmpf; \ _dc = (dt)->disc; _DTDSC(_dc, _ky, _sz, _lk, _cmpf); \ _key = (key); \ @@ -249,11 +245,11 @@ _END_EXTERNS_ if((_cmp = _DTCMP((dt), _key, _k, _dc, _cmpf, _sz)) == 0) \ break; \ } \ - action (_e ? _o : (Void_t*)0); \ + action (_e ? _o : (void*)0); \ } while(0) #define _DTSRCH(dt,obj,action) \ - do { Dtlink_t* _e; Void_t *_o, *_k, *_key; Dtdisc_t* _dc; \ + do { Dtlink_t* _e; void *_o, *_k, *_key; Dtdisc_t* _dc; \ int _ky, _sz, _lk, _cmp; Dtcompar_f _cmpf; \ _dc = (dt)->disc; _DTDSC(_dc, _ky, _sz, _lk, _cmpf); \ _key = _DTKEY(obj, _ky, _sz); \ @@ -262,11 +258,11 @@ _END_EXTERNS_ if((_cmp = _DTCMP((dt), _key, _k, _dc, _cmpf, _sz)) == 0) \ break; \ } \ - action (_e ? _o : (Void_t*)0); \ + action (_e ? _o : (void*)0); \ } while(0) -#define DTTREEMATCH(dt,key,action) _DTMTCH(_DT(dt),(Void_t*)(key),action) -#define DTTREESEARCH(dt,obj,action) _DTSRCH(_DT(dt),(Void_t*)(obj),action) +#define DTTREEMATCH(dt,key,action) _DTMTCH(_DT(dt),(void*)(key),action) +#define DTTREESEARCH(dt,obj,action) _DTSRCH(_DT(dt),(void*)(obj),action) #define dtvnext(d) (_DT(d)->view) #define dtvcount(d) (_DT(d)->nview) @@ -274,22 +270,22 @@ _END_EXTERNS_ #define dtlink(d,e) (((Dtlink_t*)(e))->right) #define dtobj(d,e) _DTOBJ((e), _DT(d)->disc->link) -#define dtfinger(d) (_DT(d)->data->here ? dtobj((d),_DT(d)->data->here):(Void_t*)(0)) - -#define dtfirst(d) (*(_DT(d)->searchf))((d),(Void_t*)(0),DT_FIRST) -#define dtnext(d,o) (*(_DT(d)->searchf))((d),(Void_t*)(o),DT_NEXT) -#define dtleast(d,o) (*(_DT(d)->searchf))((d),(Void_t*)(o),DT_SEARCH|DT_NEXT) -#define dtlast(d) (*(_DT(d)->searchf))((d),(Void_t*)(0),DT_LAST) -#define dtprev(d,o) (*(_DT(d)->searchf))((d),(Void_t*)(o),DT_PREV) -#define dtmost(d,o) (*(_DT(d)->searchf))((d),(Void_t*)(o),DT_SEARCH|DT_PREV) -#define dtsearch(d,o) (*(_DT(d)->searchf))((d),(Void_t*)(o),DT_SEARCH) -#define dtmatch(d,o) (*(_DT(d)->searchf))((d),(Void_t*)(o),DT_MATCH) -#define dtinsert(d,o) (*(_DT(d)->searchf))((d),(Void_t*)(o),DT_INSERT) -#define dtappend(d,o) (*(_DT(d)->searchf))((d),(Void_t*)(o),DT_INSERT|DT_APPEND) -#define dtdelete(d,o) (*(_DT(d)->searchf))((d),(Void_t*)(o),DT_DELETE) -#define dtattach(d,o) (*(_DT(d)->searchf))((d),(Void_t*)(o),DT_ATTACH) -#define dtdetach(d,o) (*(_DT(d)->searchf))((d),(Void_t*)(o),DT_DETACH) -#define dtclear(d) (*(_DT(d)->searchf))((d),(Void_t*)(0),DT_CLEAR) +#define dtfinger(d) (_DT(d)->data->here ? dtobj((d),_DT(d)->data->here):(void*)(0)) + +#define dtfirst(d) (*(_DT(d)->searchf))((d),(void*)(0),DT_FIRST) +#define dtnext(d,o) (*(_DT(d)->searchf))((d),(void*)(o),DT_NEXT) +#define dtleast(d,o) (*(_DT(d)->searchf))((d),(void*)(o),DT_SEARCH|DT_NEXT) +#define dtlast(d) (*(_DT(d)->searchf))((d),(void*)(0),DT_LAST) +#define dtprev(d,o) (*(_DT(d)->searchf))((d),(void*)(o),DT_PREV) +#define dtmost(d,o) (*(_DT(d)->searchf))((d),(void*)(o),DT_SEARCH|DT_PREV) +#define dtsearch(d,o) (*(_DT(d)->searchf))((d),(void*)(o),DT_SEARCH) +#define dtmatch(d,o) (*(_DT(d)->searchf))((d),(void*)(o),DT_MATCH) +#define dtinsert(d,o) (*(_DT(d)->searchf))((d),(void*)(o),DT_INSERT) +#define dtappend(d,o) (*(_DT(d)->searchf))((d),(void*)(o),DT_INSERT|DT_APPEND) +#define dtdelete(d,o) (*(_DT(d)->searchf))((d),(void*)(o),DT_DELETE) +#define dtattach(d,o) (*(_DT(d)->searchf))((d),(void*)(o),DT_ATTACH) +#define dtdetach(d,o) (*(_DT(d)->searchf))((d),(void*)(o),DT_DETACH) +#define dtclear(d) (*(_DT(d)->searchf))((d),(void*)(0),DT_CLEAR) #define dtfound(d) (_DT(d)->type & DT_FOUND) #define DT_PRIME 17109811 /* 2#00000001 00000101 00010011 00110011 */ diff --git a/lib/cdt/dtclose.c b/lib/cdt/dtclose.c index 8eff06e5f..def656b9a 100644 --- a/lib/cdt/dtclose.c +++ b/lib/cdt/dtclose.c @@ -15,29 +15,29 @@ int dtclose(reg Dt_t* dt) /* announce the close event to see if we should continue */ disc = dt->disc; if(disc->eventf && - (ev = (*disc->eventf)(dt,DT_CLOSE,NIL(Void_t*),disc)) < 0) + (ev = (*disc->eventf)(dt,DT_CLOSE,NIL(void*),disc)) < 0) return -1; if(dt->view) /* turn off viewing */ dtview(dt,NIL(Dt_t*)); if(ev == 0) /* release all allocated data */ - { (void)(*(dt->meth->searchf))(dt,NIL(Void_t*),DT_CLEAR); + { (void)(*(dt->meth->searchf))(dt,NIL(void*),DT_CLEAR); if(dtsize(dt) > 0) return -1; if(dt->data->ntab > 0) - (*dt->memoryf)(dt,(Void_t*)dt->data->htab,0,disc); - (*dt->memoryf)(dt,(Void_t*)dt->data,0,disc); + (*dt->memoryf)(dt,(void*)dt->data->htab,0,disc); + (*dt->memoryf)(dt,(void*)dt->data,0,disc); } if(dt->type == DT_MALLOC) - free((Void_t*)dt); + free((void*)dt); else if(ev == 0 && dt->type == DT_MEMORYF) - (*dt->memoryf)(dt, (Void_t*)dt, 0, disc); + (*dt->memoryf)(dt, (void*)dt, 0, disc); if(disc->eventf) - (void)(*disc->eventf)(dt, DT_ENDCLOSE, NIL(Void_t*), disc); + (void)(*disc->eventf)(dt, DT_ENDCLOSE, NIL(void*), disc); return 0; } diff --git a/lib/cdt/dtdisc.c b/lib/cdt/dtdisc.c index 5a07bbcdf..a7685e5c7 100644 --- a/lib/cdt/dtdisc.c +++ b/lib/cdt/dtdisc.c @@ -7,16 +7,16 @@ ** Written by Kiem-Phong Vo (5/26/96) */ -static Void_t* dtmemory(Dt_t* dt,Void_t* addr,size_t size,Dtdisc_t* disc) +static void* dtmemory(Dt_t* dt,void* addr,size_t size,Dtdisc_t* disc) { if(addr) { if(size == 0) { free(addr); - return NIL(Void_t*); + return NIL(void*); } else return realloc(addr,size); } - else return size > 0 ? malloc(size) : NIL(Void_t*); + else return size > 0 ? malloc(size) : NIL(void*); } Dtdisc_t* dtdisc(Dt_t* dt, Dtdisc_t* disc, int type) @@ -40,7 +40,7 @@ Dtdisc_t* dtdisc(Dt_t* dt, Dtdisc_t* disc, int type) UNFLATTEN(dt); - if(old->eventf && (*old->eventf)(dt,DT_DISC,(Void_t*)disc,old) < 0) + if(old->eventf && (*old->eventf)(dt,DT_DISC,(void*)disc,old) < 0) return NIL(Dtdisc_t*); dt->disc = disc; @@ -80,10 +80,10 @@ Dtdisc_t* dtdisc(Dt_t* dt, Dtdisc_t* disc, int type) { t = r->right; if(!(type&DT_SAMEHASH)) /* new hash value */ { k = (char*)_DTOBJ(r,disc->link); - k = _DTKEY((Void_t*)k,disc->key,disc->size); + k = _DTKEY((void*)k,disc->key,disc->size); r->hash = _DTHSH(dt,k,disc,disc->size); } - (void)(*searchf)(dt,(Void_t*)r,DT_RENEW); + (void)(*searchf)(dt,(void*)r,DT_RENEW); r = t; } } diff --git a/lib/cdt/dthash.c b/lib/cdt/dthash.c index 8babf1613..3e3a043ef 100644 --- a/lib/cdt/dthash.c +++ b/lib/cdt/dthash.c @@ -70,10 +70,10 @@ static void dthtab(Dt_t* dt) } } -static Void_t* dthash(Dt_t* dt, reg Void_t* obj, int type) +static void* dthash(Dt_t* dt, reg void* obj, int type) { reg Dtlink_t *t, *r = NULL, *p; - reg Void_t *k, *key; + reg void *k, *key; reg uint hsh; reg int lk, sz, ky; reg Dtcompar_f cmpf; @@ -91,7 +91,7 @@ static Void_t* dthash(Dt_t* dt, reg Void_t* obj, int type) goto end_walk; if(dt->data->size <= 0 || !(type&(DT_CLEAR|DT_FIRST|DT_LAST)) ) - return NIL(Void_t*); + return NIL(void*); ends = (s = dt->data->htab) + dt->data->ntab; if(type&DT_CLEAR) @@ -106,14 +106,14 @@ static Void_t* dthash(Dt_t* dt, reg Void_t* obj, int type) if(disc->freef) (*disc->freef)(dt,_DTOBJ(t,lk),disc); if(disc->link < 0) - (*dt->memoryf)(dt,(Void_t*)t,0,disc); + (*dt->memoryf)(dt,(void*)t,0,disc); t = r; } } dt->data->here = NIL(Dtlink_t*); dt->data->size = 0; dt->data->loop = 0; - return NIL(Void_t*); + return NIL(void*); } else /* computing the first/last object */ { t = NIL(Dtlink_t*); @@ -125,14 +125,14 @@ static Void_t* dthash(Dt_t* dt, reg Void_t* obj, int type) dt->data->loop += 1; dt->data->here = t; - return t ? _DTOBJ(t,lk) : NIL(Void_t*); + return t ? _DTOBJ(t,lk) : NIL(void*); } } /* allow apps to delete an object "actually" in the dictionary */ if(dt->meth->type == DT_BAG && (type&(DT_DELETE|DT_DETACH)) ) { if(!dtsearch(dt,obj) ) - return NIL(Void_t*); + return NIL(void*); s = dt->data->htab + HINDEX(dt->data->ntab,dt->data->here->hash); r = NIL(Dtlink_t*); @@ -187,7 +187,7 @@ static Void_t* dthash(Dt_t* dt, reg Void_t* obj, int type) if(type&(DT_MATCH|DT_SEARCH|DT_VSEARCH)) { if(!t) - return NIL(Void_t*); + return NIL(void*); if(p && (dt->data->type&DT_SET) && dt->data->loop <= 0) { /* move-to-front heuristic */ p->right = t->right; @@ -205,18 +205,18 @@ static Void_t* dthash(Dt_t* dt, reg Void_t* obj, int type) if(disc->makef && (type&DT_INSERT) && !(obj = (*disc->makef)(dt,obj,disc)) ) - return NIL(Void_t*); + return NIL(void*); if(lk >= 0) r = _DTLNK(obj,lk); else { r = (Dtlink_t*)(*dt->memoryf) - (dt,NIL(Void_t*),sizeof(Dthold_t),disc); + (dt,NIL(void*),sizeof(Dthold_t),disc); if(r) ((Dthold_t*)r)->obj = obj; else { if(disc->makef && disc->freef && (type&DT_INSERT)) (*disc->freef)(dt,obj,disc); - return NIL(Void_t*); + return NIL(void*); } } r->hash = hsh; @@ -230,8 +230,8 @@ static Void_t* dthash(Dt_t* dt, reg Void_t* obj, int type) if(disc->freef && (type&DT_INSERT)) (*disc->freef)(dt,obj,disc); if(disc->link < 0) - (*disc->memoryf)(dt,(Void_t*)r,0,disc); - return NIL(Void_t*); + (*disc->memoryf)(dt,(void*)r,0,disc); + return NIL(void*); } s = dt->data->htab + HINDEX(dt->data->ntab,hsh); if(t) @@ -277,7 +277,7 @@ static Void_t* dthash(Dt_t* dt, reg Void_t* obj, int type) dt->data->loop = 0; if(dt->data->size > HLOAD(dt->data->ntab) && dt->data->loop <= 0) dthtab(dt); - return NIL(Void_t*); + return NIL(void*); } else { dt->data->type |= DT_WALK; @@ -291,15 +291,15 @@ static Void_t* dthash(Dt_t* dt, reg Void_t* obj, int type) { if(disc->freef) (*disc->freef)(dt,obj,disc); if(disc->link < 0) - (*dt->memoryf)(dt,(Void_t*)r,0,disc); - return t ? _DTOBJ(t,lk) : NIL(Void_t*); + (*dt->memoryf)(dt,(void*)r,0,disc); + return t ? _DTOBJ(t,lk) : NIL(void*); } } else /*if(type&(DT_DELETE|DT_DETACH))*/ { /* take an element out of the dictionary */ do_delete: if(!t) - return NIL(Void_t*); + return NIL(void*); else if(p) p->right = t->right; else if((p = *s) == t) @@ -315,7 +315,7 @@ static Void_t* dthash(Dt_t* dt, reg Void_t* obj, int type) if(disc->freef && (type&DT_DELETE)) (*disc->freef)(dt,obj,disc); if(disc->link < 0) - (*dt->memoryf)(dt,(Void_t*)t,0,disc); + (*dt->memoryf)(dt,(void*)t,0,disc); return obj; } } diff --git a/lib/cdt/dtlist.c b/lib/cdt/dtlist.c index a49de2c82..f52d0969f 100644 --- a/lib/cdt/dtlist.c +++ b/lib/cdt/dtlist.c @@ -5,13 +5,13 @@ ** Written by Kiem-Phong Vo (05/25/96) */ -static Void_t* dtlist(reg Dt_t* dt, reg Void_t* obj, reg int type) +static void* dtlist(reg Dt_t* dt, reg void* obj, reg int type) { reg int lk, sz, ky; reg Dtcompar_f cmpf; reg Dtdisc_t* disc; reg Dtlink_t *r, *t; - reg Void_t *key, *k; + reg void *key, *k; UNFLATTEN(dt); disc = dt->disc; _DTDSC(disc,ky,sz,lk,cmpf); @@ -24,11 +24,11 @@ static Void_t* dtlist(reg Dt_t* dt, reg Void_t* obj, reg int type) r = r->left; dt->data->here = r; } - return r ? _DTOBJ(r,lk) : NIL(Void_t*); + return r ? _DTOBJ(r,lk) : NIL(void*); } else if(type&(DT_DELETE|DT_DETACH)) { if((dt->data->type&(DT_LIST|DT_DEQUE)) || !(r = dt->data->head)) - return NIL(Void_t*); + return NIL(void*); else goto dt_delete; } else if(type&DT_CLEAR) @@ -38,31 +38,31 @@ static Void_t* dtlist(reg Dt_t* dt, reg Void_t* obj, reg int type) if(disc->freef) (*disc->freef)(dt,_DTOBJ(r,lk),disc); if(disc->link < 0) - (*dt->memoryf)(dt,(Void_t*)r,0,disc); + (*dt->memoryf)(dt,(void*)r,0,disc); } } dt->data->head = dt->data->here = NIL(Dtlink_t*); dt->data->size = 0; - return NIL(Void_t*); + return NIL(void*); } - else return NIL(Void_t*); + else return NIL(void*); } if(type&(DT_INSERT|DT_ATTACH)) { if(disc->makef && (type&DT_INSERT) && !(obj = (*disc->makef)(dt,obj,disc)) ) - return NIL(Void_t*); + return NIL(void*); if(lk >= 0) r = _DTLNK(obj,lk); else { r = (Dtlink_t*)(*dt->memoryf) - (dt,NIL(Void_t*),sizeof(Dthold_t),disc); + (dt,NIL(void*),sizeof(Dthold_t),disc); if(r) ((Dthold_t*)r)->obj = obj; else { if(disc->makef && disc->freef && (type&DT_INSERT)) (*disc->freef)(dt,obj,disc); - return NIL(Void_t*); + return NIL(void*); } } @@ -130,7 +130,7 @@ static Void_t* dtlist(reg Dt_t* dt, reg Void_t* obj, reg int type) } if(!r) - return NIL(Void_t*); + return NIL(void*); dt->type |= DT_FOUND; if(type&(DT_DELETE|DT_DETACH)) @@ -155,7 +155,7 @@ static Void_t* dtlist(reg Dt_t* dt, reg Void_t* obj, reg int type) if(disc->freef && (type&DT_DELETE)) (*disc->freef)(dt,obj,disc); if(disc->link < 0) - (*dt->memoryf)(dt,(Void_t*)r,0,disc); + (*dt->memoryf)(dt,(void*)r,0,disc); return obj; } else if(type&DT_NEXT) @@ -164,7 +164,7 @@ static Void_t* dtlist(reg Dt_t* dt, reg Void_t* obj, reg int type) r = r == dt->data->head ? NIL(Dtlink_t*) : r->left; dt->data->here = r; - return r ? _DTOBJ(r,lk) : NIL(Void_t*); + return r ? _DTOBJ(r,lk) : NIL(void*); } #ifndef KPVDEL /* to be remove next round */ diff --git a/lib/cdt/dtmethod.c b/lib/cdt/dtmethod.c index 9e3d11ba5..b9ac26a22 100644 --- a/lib/cdt/dtmethod.c +++ b/lib/cdt/dtmethod.c @@ -15,7 +15,7 @@ Dtmethod_t* dtmethod(Dt_t* dt, Dtmethod_t* meth) return oldmeth; if(disc->eventf && - (*disc->eventf)(dt,DT_METH,(Void_t*)meth,disc) < 0) + (*disc->eventf)(dt,DT_METH,(void*)meth,disc) < 0) return NIL(Dtmethod_t*); dt->data->minp = 0; @@ -27,7 +27,7 @@ Dtmethod_t* dtmethod(Dt_t* dt, Dtmethod_t* meth) dt->data->head = NIL(Dtlink_t*); else if(dt->data->type&(DT_SET|DT_BAG) ) { if(dt->data->ntab > 0) - (*dt->memoryf)(dt,(Void_t*)dt->data->htab,0,disc); + (*dt->memoryf)(dt,(void*)dt->data->htab,0,disc); dt->data->ntab = 0; dt->data->htab = NIL(Dtlink_t**); } @@ -53,7 +53,7 @@ Dtmethod_t* dtmethod(Dt_t* dt, Dtmethod_t* meth) { dt->data->size = 0; while(list) { r = list->right; - (*meth->searchf)(dt,(Void_t*)list,DT_RENEW); + (*meth->searchf)(dt,(void*)list,DT_RENEW); list = r; } } @@ -67,11 +67,11 @@ Dtmethod_t* dtmethod(Dt_t* dt, Dtmethod_t* meth) while(list) { r = list->right; if(rehash) - { reg Void_t* key = _DTOBJ(list,disc->link); + { reg void* key = _DTOBJ(list,disc->link); key = _DTKEY(key,disc->key,disc->size); list->hash = _DTHSH(dt,key,disc,disc->size); } - (void)(*meth->searchf)(dt,(Void_t*)list,DT_RENEW); + (void)(*meth->searchf)(dt,(void*)list,DT_RENEW); list = r; } } diff --git a/lib/cdt/dtopen.c b/lib/cdt/dtopen.c index e750a4643..388c76c68 100644 --- a/lib/cdt/dtopen.c +++ b/lib/cdt/dtopen.c @@ -27,12 +27,12 @@ Dt_t* dtopen(Dtdisc_t* disc, Dtmethod_t* meth) dt->type = DT_MALLOC; dt->nview = 0; dt->view = dt->walk = NIL(Dt_t*); - dt->user = NIL(Void_t*); + dt->user = NIL(void*); if(disc->eventf) { /* if shared/persistent dictionary, get existing data */ data = NIL(Dtdata_t*); - if((e = (*disc->eventf)(dt,DT_OPEN,(Void_t*)(&data),disc)) < 0) + if((e = (*disc->eventf)(dt,DT_OPEN,(void*)(&data),disc)) < 0) goto err_open; else if(e > 0) { if(data) @@ -44,7 +44,7 @@ Dt_t* dtopen(Dtdisc_t* disc, Dtmethod_t* meth) if(!disc->memoryf) goto err_open; - free((Void_t*)dt); + free((void*)dt); if(!(dt = (*disc->memoryf)(0, 0, sizeof(Dt_t), disc)) ) return NIL(Dt_t*); dt->searchf = NIL(Dtsearch_f); @@ -58,9 +58,9 @@ Dt_t* dtopen(Dtdisc_t* disc, Dtmethod_t* meth) } /* allocate sharable data */ - if(!(data = (Dtdata_t*)(dt->memoryf)(dt,NIL(Void_t*),sizeof(Dtdata_t),disc)) ) + if(!(data = (Dtdata_t*)(dt->memoryf)(dt,NIL(void*),sizeof(Dtdata_t),disc)) ) { err_open: - free((Void_t*)dt); + free((void*)dt); return NIL(Dt_t*); } @@ -76,7 +76,7 @@ done: dt->meth = meth; if(disc->eventf) - (*disc->eventf)(dt, DT_ENDOPEN, (Void_t*)dt, disc); + (*disc->eventf)(dt, DT_ENDOPEN, (void*)dt, disc); return dt; } diff --git a/lib/cdt/dtrenew.c b/lib/cdt/dtrenew.c index d51fff2c1..5a8be6058 100644 --- a/lib/cdt/dtrenew.c +++ b/lib/cdt/dtrenew.c @@ -6,16 +6,16 @@ ** Written by Kiem-Phong Vo (5/25/96) */ -Void_t* dtrenew(Dt_t* dt, reg Void_t* obj) +void* dtrenew(Dt_t* dt, reg void* obj) { - reg Void_t* key; + reg void* key; reg Dtlink_t *e, *t, **s; reg Dtdisc_t* disc = dt->disc; UNFLATTEN(dt); if(!(e = dt->data->here) || _DTOBJ(e,disc->link) != obj) - return NIL(Void_t*); + return NIL(void*); if(dt->data->type&(DT_STACK|DT_QUEUE|DT_LIST)) return obj; @@ -48,5 +48,5 @@ Void_t* dtrenew(Dt_t* dt, reg Void_t* obj) } dt->data->size -= 1; - return (*dt->meth->searchf)(dt,(Void_t*)e,DT_RENEW) ? obj : NIL(Void_t*); + return (*dt->meth->searchf)(dt,(void*)e,DT_RENEW) ? obj : NIL(void*); } diff --git a/lib/cdt/dtrestore.c b/lib/cdt/dtrestore.c index 1564f74c9..b79224b6d 100644 --- a/lib/cdt/dtrestore.c +++ b/lib/cdt/dtrestore.c @@ -41,7 +41,7 @@ int dtrestore(reg Dt_t* dt, reg Dtlink_t* list) { dt->data->size = 0; while(list) { t = list->right; - (*searchf)(dt,(Void_t*)list,DT_RENEW); + (*searchf)(dt,(void*)list,DT_RENEW); list = t; } } diff --git a/lib/cdt/dtstrhash.c b/lib/cdt/dtstrhash.c index c50c20c89..e94436eea 100644 --- a/lib/cdt/dtstrhash.c +++ b/lib/cdt/dtstrhash.c @@ -13,7 +13,7 @@ ** Written by Kiem-Phong Vo (02/28/03) */ -uint dtstrhash(reg uint h, Void_t* args, reg int n) +uint dtstrhash(reg uint h, void* args, reg int n) { reg unsigned char* s = (unsigned char*)args; diff --git a/lib/cdt/dttree.c b/lib/cdt/dttree.c index cffeade48..8803618f4 100644 --- a/lib/cdt/dttree.c +++ b/lib/cdt/dttree.c @@ -8,11 +8,11 @@ ** Written by Kiem-Phong Vo (5/25/96) */ -static Void_t* dttree(Dt_t* dt, Void_t* obj, int type) +static void* dttree(Dt_t* dt, void* obj, int type) { Dtlink_t *root, *t; int cmp, lk, sz, ky; - Void_t *o, *k, *key; + void *o, *k, *key; Dtlink_t *l, *r, *me = NULL, link; int n, minp, turn[DT_MINP]; Dtcompar_f cmpf; @@ -25,7 +25,7 @@ static Void_t* dttree(Dt_t* dt, Void_t* obj, int type) root = dt->data->here; if(!obj) { if(!root || !(type&(DT_CLEAR|DT_FIRST|DT_LAST)) ) - return NIL(Void_t*); + return NIL(void*); if(type&DT_CLEAR) /* delete all objects */ { if(disc->freef || disc->link < 0) @@ -36,13 +36,13 @@ static Void_t* dttree(Dt_t* dt, Void_t* obj, int type) if(disc->freef) (*disc->freef)(dt,_DTOBJ(root,lk),disc); if(disc->link < 0) - (*dt->memoryf)(dt,(Void_t*)root,0,disc); + (*dt->memoryf)(dt,(void*)root,0,disc); } while((root = t) ); } dt->data->size = 0; dt->data->here = NIL(Dtlink_t*); - return NIL(Void_t*); + return NIL(void*); } else /* computing largest/smallest element */ { if(type&DT_LAST) @@ -103,7 +103,7 @@ static Void_t* dttree(Dt_t* dt, Void_t* obj, int type) else { turn[n] = cmp; if(!(t = cmp < 0 ? t->left : t->right) ) - return NIL(Void_t*); + return NIL(void*); } } @@ -260,7 +260,7 @@ static Void_t* dttree(Dt_t* dt, Void_t* obj, int type) if(disc->freef && (type&DT_DELETE)) (*disc->freef)(dt,obj,disc); if(disc->link < 0) - (*dt->memoryf)(dt,(Void_t*)root,0,disc); + (*dt->memoryf)(dt,(void*)root,0,disc); if((dt->data->size -= 1) < 0) dt->data->size = -1; goto no_root; @@ -280,7 +280,7 @@ static Void_t* dttree(Dt_t* dt, Void_t* obj, int type) { if(disc->freef) (*disc->freef)(dt,obj,disc); if(disc->link < 0) - (*dt->memoryf)(dt,(Void_t*)me,0,disc); + (*dt->memoryf)(dt,(void*)me,0,disc); } else { me->left = NIL(Dtlink_t*); @@ -306,7 +306,7 @@ static Void_t* dttree(Dt_t* dt, Void_t* obj, int type) r = t; r->left = link.right; dt->data->here = link.left; - return (type&DT_DELETE) ? obj : NIL(Void_t*); + return (type&DT_DELETE) ? obj : NIL(void*); } else if(type&(DT_INSERT|DT_ATTACH)) { dt_insert: @@ -317,7 +317,7 @@ static Void_t* dttree(Dt_t* dt, Void_t* obj, int type) root = _DTLNK(obj,lk); else { root = (Dtlink_t*)(*dt->memoryf) - (dt,NIL(Void_t*),sizeof(Dthold_t),disc); + (dt,NIL(void*),sizeof(Dthold_t),disc); if(root) ((Dthold_t*)root)->obj = obj; else if(disc->makef && disc->freef && @@ -338,12 +338,12 @@ static Void_t* dttree(Dt_t* dt, Void_t* obj, int type) goto has_root; } else /*if(type&DT_DELETE)*/ - { obj = NIL(Void_t*); + { obj = NIL(void*); goto no_root; } } - return NIL(Void_t*); + return NIL(void*); } /* make this method available */ diff --git a/lib/cdt/dtview.c b/lib/cdt/dtview.c index dc348fc53..fd9313356 100644 --- a/lib/cdt/dtview.c +++ b/lib/cdt/dtview.c @@ -6,10 +6,10 @@ */ -static Void_t* dtvsearch(Dt_t* dt, reg Void_t* obj, reg int type) +static void* dtvsearch(Dt_t* dt, reg void* obj, reg int type) { Dt_t *d, *p; - Void_t *o, *n, *ok, *nk; + void *o, *n, *ok, *nk; int cmp, lk, sz, ky; Dtcompar_f cmpf; @@ -28,9 +28,9 @@ static Void_t* dtvsearch(Dt_t* dt, reg Void_t* obj, reg int type) if(dt->meth->type & (DT_OBAG|DT_OSET) ) { if(!(type & (DT_FIRST|DT_LAST|DT_NEXT|DT_PREV)) ) - return NIL(Void_t*); + return NIL(void*); - n = nk = NIL(Void_t*); p = NIL(Dt_t*); + n = nk = NIL(void*); p = NIL(Dt_t*); for(d = dt; d; d = d->view) { if(!(o = (*d->meth->searchf)(d, obj, type)) ) continue; @@ -56,7 +56,7 @@ static Void_t* dtvsearch(Dt_t* dt, reg Void_t* obj, reg int type) /* non-ordered methods */ if(!(type & (DT_NEXT|DT_PREV)) ) - return NIL(Void_t*); + return NIL(void*); if(!dt->walk || obj != _DTOBJ(dt->walk->data->here, dt->walk->disc->link) ) { for(d = dt; d; d = d->view) @@ -64,7 +64,7 @@ static Void_t* dtvsearch(Dt_t* dt, reg Void_t* obj, reg int type) break; dt->walk = d; if(!(obj = o) ) - return NIL(Void_t*); + return NIL(void*); } for(d = dt->walk, obj = (*d->meth->searchf)(d, obj, type);; ) @@ -79,10 +79,10 @@ static Void_t* dtvsearch(Dt_t* dt, reg Void_t* obj, reg int type) } if(!(d = dt->walk = d->view) ) /* move on to next dictionary */ - return NIL(Void_t*); + return NIL(void*); else if(type&DT_NEXT) - obj = (*(d->meth->searchf))(d,NIL(Void_t*),DT_FIRST); - else obj = (*(d->meth->searchf))(d,NIL(Void_t*),DT_LAST); + obj = (*(d->meth->searchf))(d,NIL(void*),DT_FIRST); + else obj = (*(d->meth->searchf))(d,NIL(void*),DT_LAST); } } diff --git a/lib/cdt/dtwalk.c b/lib/cdt/dtwalk.c index b8aca7270..fca39e7ca 100644 --- a/lib/cdt/dtwalk.c +++ b/lib/cdt/dtwalk.c @@ -6,9 +6,9 @@ ** Written by Kiem-Phong Vo (5/25/96) */ -int dtwalk(reg Dt_t* dt, int (*userf)(Dt_t*, Void_t*, Void_t*), Void_t* data) +int dtwalk(reg Dt_t* dt, int (*userf)(Dt_t*, void*, void*), void* data) { - reg Void_t *obj, *next; + reg void *obj, *next; reg Dt_t* walk; reg int rv; diff --git a/lib/cdt/features/common b/lib/cdt/features/common index 5c15fcb7b..0e465f82d 100644 --- a/lib/cdt/features/common +++ b/lib/cdt/features/common @@ -88,11 +88,6 @@ cat{ #define __INLINE__ __inline #endif - /* Void_t is defined so that Void_t* can address any type */ - #ifndef Void_t - #define Void_t void - #endif /*Void_t*/ - /* dynamic linked library external scope handling */ #undef extern #if _dll_import && !defined(__EXPORT__) && _DLL_BLD diff --git a/lib/cgraph/attr.c b/lib/cgraph/attr.c index d7f7f8c78..768249f55 100644 --- a/lib/cgraph/attr.c +++ b/lib/cgraph/attr.c @@ -21,7 +21,7 @@ #define MINATTR 4 /* minimum allocation */ -static void freesym(Dict_t * d, Void_t * obj, Dtdisc_t * disc); +static void freesym(Dict_t * d, void * obj, Dtdisc_t * disc); Dtdisc_t AgDataDictDisc = { (int) offsetof(Agsym_t, name), /* use symbol name as key */ @@ -216,7 +216,7 @@ static void freeattr(Agobj_t * obj, Agattr_t * attr) agfree(g, attr->str); } -static void freesym(Dict_t * d, Void_t * obj, Dtdisc_t * disc) +static void freesym(Dict_t * d, void * obj, Dtdisc_t * disc) { Agsym_t *sym; diff --git a/lib/cgraph/cghdr.h b/lib/cgraph/cghdr.h index 84c728244..8a706cb43 100644 --- a/lib/cgraph/cghdr.h +++ b/lib/cgraph/cghdr.h @@ -112,9 +112,9 @@ Dict_t *agdtopen(Agraph_t * g, Dtdisc_t * disc, Dtmethod_t * method); void agdtdisc(Agraph_t * g, Dict_t * dict, Dtdisc_t * disc); long agdtdelete(Agraph_t * g, Dict_t * dict, void *obj); int agdtclose(Agraph_t * g, Dict_t * dict); -void *agdictobjmem(Dict_t * dict, Void_t * p, size_t size, +void *agdictobjmem(Dict_t * dict, void * p, size_t size, Dtdisc_t * disc); -void agdictobjfree(Dict_t * dict, Void_t * p, Dtdisc_t * disc); +void agdictobjfree(Dict_t * dict, void * p, Dtdisc_t * disc); /* name-value pair operations */ Agdatadict_t *agdatadict(Agraph_t * g, int cflag); diff --git a/lib/cgraph/utils.c b/lib/cgraph/utils.c index e1a90fd2f..24d76e296 100644 --- a/lib/cgraph/utils.c +++ b/lib/cgraph/utils.c @@ -16,7 +16,7 @@ static Agraph_t *Ag_dictop_G; /* only indirect call through dtopen() is expected */ -void *agdictobjmem(Dict_t * dict, Void_t * p, size_t size, Dtdisc_t * disc) +void *agdictobjmem(Dict_t * dict, void * p, size_t size, Dtdisc_t * disc) { Agraph_t *g; @@ -37,7 +37,7 @@ void *agdictobjmem(Dict_t * dict, Void_t * p, size_t size, Dtdisc_t * disc) return NIL(void *); } -void agdictobjfree(Dict_t * dict, Void_t * p, Dtdisc_t * disc) +void agdictobjfree(Dict_t * dict, void * p, Dtdisc_t * disc) { Agraph_t *g; @@ -70,7 +70,7 @@ long agdtdelete(Agraph_t * g, Dict_t * dict, void *obj) return (long) dtdelete(dict, obj); } -int agobjfinalize(Void_t * obj) +int agobjfinalize(void * obj) { agfree(Ag_dictop_G, obj); return 0; diff --git a/lib/common/intset.c b/lib/common/intset.c index 526d1acf1..edd3e3fbb 100644 --- a/lib/common/intset.c +++ b/lib/common/intset.c @@ -17,12 +17,12 @@ #include #include -static Void_t* +static void* mkIntItem(Dt_t* d,intitem* obj,Dtdisc_t* disc) { intitem* np = NEW(intitem); np->id = obj->id; - return (Void_t*)np; + return (void*)np; } static void diff --git a/lib/common/textspan.c b/lib/common/textspan.c index 85dfdfbf2..5799a26c4 100644 --- a/lib/common/textspan.c +++ b/lib/common/textspan.c @@ -226,7 +226,7 @@ pointf textspan_size(GVC_t *gvc, textspan_t * span) return span->size; } -static Void_t* textfont_makef(Dt_t* dt, Void_t* obj, Dtdisc_t* disc) +static void* textfont_makef(Dt_t* dt, void* obj, Dtdisc_t* disc) { textfont_t *f1 = (textfont_t*)obj; textfont_t *f2 = calloc(1,sizeof(textfont_t)); @@ -243,7 +243,7 @@ static Void_t* textfont_makef(Dt_t* dt, Void_t* obj, Dtdisc_t* disc) return f2; } -static void textfont_freef(Dt_t* dt, Void_t* obj, Dtdisc_t* disc) +static void textfont_freef(Dt_t* dt, void* obj, Dtdisc_t* disc) { textfont_t *f = (textfont_t*)obj; @@ -252,7 +252,7 @@ static void textfont_freef(Dt_t* dt, Void_t* obj, Dtdisc_t* disc) free(f); } -static int textfont_comparf (Dt_t* dt, Void_t* key1, Void_t* key2, Dtdisc_t* disc) +static int textfont_comparf (Dt_t* dt, void* key1, void* key2, Dtdisc_t* disc) { int rc; textfont_t *f1 = (textfont_t*)key1, *f2 = (textfont_t*)key2; diff --git a/lib/fdpgen/grid.c b/lib/fdpgen/grid.c index 639b3694b..8a14e9cf8 100644 --- a/lib/fdpgen/grid.c +++ b/lib/fdpgen/grid.c @@ -232,7 +232,7 @@ void addGrid(Grid * g, int i, int j, Agnode_t * n) } } -typedef int (*walkfn_t) (Dt_t *, Void_t *, Void_t *); +typedef int (*walkfn_t) (Dt_t *, void *, void *); /* walkGrid: * Apply function walkf to each cell in the grid. diff --git a/lib/gvc/gvusershape.c b/lib/gvc/gvusershape.c index adc60e676..3476c230b 100644 --- a/lib/gvc/gvusershape.c +++ b/lib/gvc/gvusershape.c @@ -543,7 +543,7 @@ static void pdf_size (usershape_t *us) } } -static void usershape_close (Dict_t * dict, Void_t * p, Dtdisc_t * disc) +static void usershape_close (Dict_t * dict, void * p, Dtdisc_t * disc) { usershape_t *us = (usershape_t *)p; diff --git a/lib/gvpr/queue.c b/lib/gvpr/queue.c index 38f16512a..33db3875d 100644 --- a/lib/gvpr/queue.c +++ b/lib/gvpr/queue.c @@ -25,7 +25,7 @@ typedef struct { void *np; } nsitem; -static Void_t *makef(Dt_t * d, nsitem * obj, Dtdisc_t * disc) +static void *makef(Dt_t * d, nsitem * obj, Dtdisc_t * disc) { nsitem *p; diff --git a/lib/label/xlabels.c b/lib/label/xlabels.c index 24d792866..26146b977 100644 --- a/lib/label/xlabels.c +++ b/lib/label/xlabels.c @@ -23,13 +23,13 @@ extern int Verbose; -static int icompare(Dt_t *, Void_t *, Void_t *, Dtdisc_t *); +static int icompare(Dt_t *, void *, void *, Dtdisc_t *); Dtdisc_t Hdisc = { offsetof(HDict_t, key), sizeof(int), -1, 0, 0, icompare, 0, 0, 0 }; -static int icompare(Dt_t * dt, Void_t * v1, Void_t * v2, Dtdisc_t * disc) +static int icompare(Dt_t * dt, void * v1, void * v2, Dtdisc_t * disc) { int k1 = *((int *) v1), k2 = *((int *) v2); return k1 - k2; @@ -612,7 +612,7 @@ static void xlhdxunload(XLabels_t * xlp) { int size=dtsize(xlp->hdx), freed=0; while(dtsize(xlp->hdx) ) { - Void_t*vp=dtfinger(xlp->hdx); + void*vp=dtfinger(xlp->hdx); assert(vp); if(vp) { dtdetach(xlp->hdx, vp); diff --git a/lib/sfio/Sfio_dc/sfdcdio.c b/lib/sfio/Sfio_dc/sfdcdio.c index c42a40c2e..80aeeaf6c 100644 --- a/lib/sfio/Sfio_dc/sfdcdio.c +++ b/lib/sfio/Sfio_dc/sfdcdio.c @@ -31,7 +31,7 @@ typedef struct _direct_s { #define P2I(p) (Sfulong_t)((char*)(p) - (char*)0) #ifdef HAVE_STRUCT_DIOATTR -static ssize_t diordwr(Sfio_t * f, Void_t * buf, size_t n, Direct_t * di, +static ssize_t diordwr(Sfio_t * f, void * buf, size_t n, Direct_t * di, int type) { size_t rw, done; @@ -58,7 +58,7 @@ static ssize_t diordwr(Sfio_t * f, Void_t * buf, size_t n, Direct_t * di, if (rv > 0) { rw -= rv; done += rv; - buf = (Void_t *) ((char *) buf + rv); + buf = (void *) ((char *) buf + rv); } if (rv < io || rw < di->dio.d_miniosz) @@ -80,18 +80,18 @@ static ssize_t diordwr(Sfio_t * f, Void_t * buf, size_t n, Direct_t * di, return done ? done : rv; } -static ssize_t dioread(Sfio_t * f, Void_t * buf, size_t n, Sfdisc_t * disc) +static ssize_t dioread(Sfio_t * f, void * buf, size_t n, Sfdisc_t * disc) { return diordwr(f, buf, n, (Direct_t *) disc, SF_READ); } -static ssize_t diowrite(Sfio_t * f, const Void_t * buf, size_t n, +static ssize_t diowrite(Sfio_t * f, const void * buf, size_t n, Sfdisc_t * disc) { - return diordwr(f, (Void_t *) buf, n, (Direct_t *) disc, SF_WRITE); + return diordwr(f, (void *) buf, n, (Direct_t *) disc, SF_WRITE); } -static int dioexcept(Sfio_t * f, int type, Void_t * data, Sfdisc_t * disc) +static int dioexcept(Sfio_t * f, int type, void * data, Sfdisc_t * disc) { Direct_t *di = (Direct_t *) disc; @@ -114,7 +114,7 @@ int sfdcdio(Sfio_t * f, size_t bufsize) #else int cntl; struct dioattr dio; - Void_t *buf; + void *buf; Direct_t *di; if (f->extent < 0 || (f->flags & SF_STRING)) @@ -142,7 +142,7 @@ int sfdcdio(Sfio_t * f, size_t bufsize) if (!(di = (Direct_t *) malloc(sizeof(Direct_t)))) goto no_direct; - if (!(buf = (Void_t *) memalign(dio.d_mem, bufsize))) { + if (!(buf = (void *) memalign(dio.d_mem, bufsize))) { free(di); goto no_direct; } diff --git a/lib/sfio/Sfio_dc/sfdcfilter.c b/lib/sfio/Sfio_dc/sfdcfilter.c index 39605d120..84b327f23 100644 --- a/lib/sfio/Sfio_dc/sfdcfilter.c +++ b/lib/sfio/Sfio_dc/sfdcfilter.c @@ -38,7 +38,7 @@ typedef struct _filter_s { * @param n number of bytes requested * @param disc discipline */ -static ssize_t filterread(Sfio_t * f, Void_t * buf, size_t n, +static ssize_t filterread(Sfio_t * f, void * buf, size_t n, Sfdisc_t * disc) { Filter_t *fi; @@ -87,7 +87,7 @@ static ssize_t filterread(Sfio_t * f, Void_t * buf, size_t n, * @param n number of bytes requested * @param disc discipline */ -static ssize_t filterwrite(Sfio_t * f, const Void_t * buf, size_t n, +static ssize_t filterwrite(Sfio_t * f, const void * buf, size_t n, Sfdisc_t * disc) { return -1; @@ -105,7 +105,7 @@ static Sfoff_t filterseek(Sfio_t * f, Sfoff_t addr, int offset, } /* on close, remove the discipline */ -static int filterexcept(Sfio_t * f, int type, Void_t * data, +static int filterexcept(Sfio_t * f, int type, void * data, Sfdisc_t * disc) { if (type == SF_FINAL || type == SF_DPOP) { @@ -130,7 +130,7 @@ int sfdcfilter(Sfio_t * f, const char *cmd) return -1; /* unbuffered so that write data will get to the pipe right away */ - sfsetbuf(filter, NIL(Void_t *), 0); + sfsetbuf(filter, NIL(void *), 0); /* make the write descriptor nonblocking */ sfset(filter, SF_READ, 0); diff --git a/lib/sfio/Sfio_dc/sfdclzw.c b/lib/sfio/Sfio_dc/sfdclzw.c index 88869bf4d..62dbf8fd4 100644 --- a/lib/sfio/Sfio_dc/sfdclzw.c +++ b/lib/sfio/Sfio_dc/sfdclzw.c @@ -206,7 +206,7 @@ static code_int getcode(Sfio_t * f, LZW_Disc * disc) } -static int lzwExcept(Sfio_t * f, int type, Void_t * data, Sfdisc_t * disc) +static int lzwExcept(Sfio_t * f, int type, void * data, Sfdisc_t * disc) { if (type == SF_FINAL || type == SF_DPOP) free(disc); @@ -221,7 +221,7 @@ static int lzwExcept(Sfio_t * f, int type, Void_t * data, Sfdisc_t * disc) * with those of the compress() routine. See the definitions above. */ -ssize_t lzwRead(Sfio_t * f, Void_t * iobuf, size_t iocnt, +ssize_t lzwRead(Sfio_t * f, void * iobuf, size_t iocnt, Sfdisc_t * sfdisc) { LZW_Disc *disc = (LZW_Disc *) sfdisc; @@ -335,7 +335,7 @@ static Sfoff_t lzwSeek(Sfio_t * f, Sfoff_t offset, int whence, } -static ssize_t lzwWrite(Sfio_t * f, const Void_t * buf, size_t count, +static ssize_t lzwWrite(Sfio_t * f, const void * buf, size_t count, Sfdisc_t * disc) { return (ssize_t) (-1); diff --git a/lib/sfio/Sfio_dc/sfdcseekable.c b/lib/sfio/Sfio_dc/sfdcseekable.c index 6f5ebbb7e..753979b16 100644 --- a/lib/sfio/Sfio_dc/sfdcseekable.c +++ b/lib/sfio/Sfio_dc/sfdcseekable.c @@ -30,7 +30,7 @@ typedef struct _skable_s { * @param n number of bytes to read * @param disc discipline */ -static ssize_t skwrite(Sfio_t * f, const Void_t * buf, size_t n, +static ssize_t skwrite(Sfio_t * f, const void * buf, size_t n, Sfdisc_t * disc) { return (ssize_t) (-1); @@ -42,7 +42,7 @@ static ssize_t skwrite(Sfio_t * f, const Void_t * buf, size_t n, * @param n number of bytes to read * @param disc discipline */ -static ssize_t skread(Sfio_t * f, Void_t * buf, size_t n, Sfdisc_t * disc) +static ssize_t skread(Sfio_t * f, void * buf, size_t n, Sfdisc_t * disc) { Seek_t *sk; Sfio_t *sf; @@ -127,7 +127,7 @@ static Sfoff_t skseek(Sfio_t * f, Sfoff_t addr, int type, Sfdisc_t * disc) } /* on close, remove the discipline */ -static int skexcept(Sfio_t * f, int type, Void_t * data, Sfdisc_t * disc) +static int skexcept(Sfio_t * f, int type, void * data, Sfdisc_t * disc) { if (type == SF_FINAL || type == SF_DPOP) { sfclose(((Seek_t *) disc)->shadow); diff --git a/lib/sfio/Sfio_dc/sfdcslow.c b/lib/sfio/Sfio_dc/sfdcslow.c index 65aaf1e9b..48e461afc 100644 --- a/lib/sfio/Sfio_dc/sfdcslow.c +++ b/lib/sfio/Sfio_dc/sfdcslow.c @@ -19,7 +19,7 @@ ** Written by Glenn Fowler (03/18/1998). */ -static int slowexcept(Sfio_t * f, int type, Void_t * v, Sfdisc_t * disc) +static int slowexcept(Sfio_t * f, int type, void * v, Sfdisc_t * disc) { NOTUSED(f); NOTUSED(v); diff --git a/lib/sfio/Sfio_dc/sfdcsubstream.c b/lib/sfio/Sfio_dc/sfdcsubstream.c index ab9000ad6..b1fe7ff5e 100644 --- a/lib/sfio/Sfio_dc/sfdcsubstream.c +++ b/lib/sfio/Sfio_dc/sfdcsubstream.c @@ -29,7 +29,7 @@ typedef struct _subfile_s { Sfoff_t here; /* current seek location */ } Subfile_t; -static ssize_t streamio(Sfio_t * f, Void_t * buf, size_t n, +static ssize_t streamio(Sfio_t * f, void * buf, size_t n, Sfdisc_t * disc, int type) { reg Subfile_t *su; @@ -67,13 +67,13 @@ static ssize_t streamio(Sfio_t * f, Void_t * buf, size_t n, return io; } -static ssize_t streamwrite(Sfio_t * f, const Void_t * buf, size_t n, +static ssize_t streamwrite(Sfio_t * f, const void * buf, size_t n, Sfdisc_t * disc) { - return streamio(f, (Void_t *) buf, n, disc, SF_WRITE); + return streamio(f, (void *) buf, n, disc, SF_WRITE); } -static ssize_t streamread(Sfio_t * f, Void_t * buf, size_t n, +static ssize_t streamread(Sfio_t * f, void * buf, size_t n, Sfdisc_t * disc) { return streamio(f, buf, n, disc, SF_READ); @@ -117,7 +117,7 @@ static Sfoff_t streamseek(Sfio_t * f, Sfoff_t pos, int type, return (su->here = pos); } -static int streamexcept(Sfio_t * f, int type, Void_t * data, +static int streamexcept(Sfio_t * f, int type, void * data, Sfdisc_t * disc) { if (type == SF_FINAL || type == SF_DPOP) diff --git a/lib/sfio/Sfio_dc/sfdctee.c b/lib/sfio/Sfio_dc/sfdctee.c index bca96f9dd..8cc611d94 100644 --- a/lib/sfio/Sfio_dc/sfdctee.c +++ b/lib/sfio/Sfio_dc/sfdctee.c @@ -34,7 +34,7 @@ typedef struct _tee_s { * @param size the data size * @param disc the tee discipline */ -static ssize_t teewrite(Sfio_t * f, const Void_t * buf, size_t size, +static ssize_t teewrite(Sfio_t * f, const void * buf, size_t size, Sfdisc_t * disc) { reg Tee_t *te = (Tee_t *) disc; @@ -48,7 +48,7 @@ static ssize_t teewrite(Sfio_t * f, const Void_t * buf, size_t size, } /* on close, remove the discipline */ -static int teeexcept(Sfio_t * f, int type, Void_t * data, Sfdisc_t * disc) +static int teeexcept(Sfio_t * f, int type, void * data, Sfdisc_t * disc) { if (type == SF_FINAL || type == SF_DPOP) free(disc); diff --git a/lib/sfio/Sfio_dc/sfdcunion.c b/lib/sfio/Sfio_dc/sfdcunion.c index dce65e872..b20810edd 100644 --- a/lib/sfio/Sfio_dc/sfdcunion.c +++ b/lib/sfio/Sfio_dc/sfdcunion.c @@ -42,7 +42,7 @@ typedef struct _union_s { * @param n number of bytes to read * @param disc discipline */ -static ssize_t unwrite(Sfio_t * f, const Void_t * buf, size_t n, +static ssize_t unwrite(Sfio_t * f, const void * buf, size_t n, Sfdisc_t * disc) { return -1; @@ -54,7 +54,7 @@ static ssize_t unwrite(Sfio_t * f, const Void_t * buf, size_t n, * @param n number of bytes to read * @param disc discipline */ -static ssize_t unread(Sfio_t * f, Void_t * buf, size_t n, Sfdisc_t * disc) +static ssize_t unread(Sfio_t * f, void * buf, size_t n, Sfdisc_t * disc) { reg Union_t *un; reg ssize_t r, m; @@ -123,7 +123,7 @@ static Sfoff_t unseek(Sfio_t * f, Sfoff_t addr, int type, Sfdisc_t * disc) } /* on close, remove the discipline */ -static int unexcept(Sfio_t * f, int type, Void_t * data, Sfdisc_t * disc) +static int unexcept(Sfio_t * f, int type, void * data, Sfdisc_t * disc) { if (type == SF_FINAL || type == SF_DPOP) free(disc); diff --git a/lib/sfio/features/common b/lib/sfio/features/common index 7f27e5526..865b189a4 100644 --- a/lib/sfio/features/common +++ b/lib/sfio/features/common @@ -86,11 +86,6 @@ cat{ #define __INLINE__ __inline #endif - /* Void_t is defined so that Void_t* can address any type */ - #ifndef Void_t - #define Void_t void - #endif /*Void_t*/ - /* dynamic linked library external scope handling */ #undef extern #if _dll_import && !defined(__EXPORT__) && _DLL_BLD diff --git a/lib/sfio/sfclose.c b/lib/sfio/sfclose.c index 31ab15d7e..fdc22ec76 100644 --- a/lib/sfio/sfclose.c +++ b/lib/sfio/sfclose.c @@ -21,7 +21,7 @@ int sfclose(reg Sfio_t * f) { reg int local, ex, rv; - Void_t *data = NIL(Void_t *); + void *data = NIL(void *); SFMTXSTART(f, -1); @@ -58,7 +58,7 @@ int sfclose(reg Sfio_t * f) /* raise discipline exceptions */ if (f->disc && (ex = - SFRAISE(f, local ? SF_NEW : SF_CLOSING, NIL(Void_t *))) != 0) + SFRAISE(f, local ? SF_NEW : SF_CLOSING, NIL(void *))) != 0) SFMTXRETURN(f, ex); if (!local && f->pool) { /* remove from pool */ @@ -95,7 +95,7 @@ int sfclose(reg Sfio_t * f) else #endif if (f->flags & SF_MALLOC) - data = (Void_t *) f->data; + data = (void *) f->data; f->data = NIL(uchar *); f->size = -1; @@ -134,7 +134,7 @@ int sfclose(reg Sfio_t * f) } if (!local) { - if (f->disc && (ex = SFRAISE(f, SF_FINAL, NIL(Void_t *))) != 0) { + if (f->disc && (ex = SFRAISE(f, SF_FINAL, NIL(void *))) != 0) { rv = ex; goto done; } @@ -143,7 +143,7 @@ int sfclose(reg Sfio_t * f) free(f); else { f->disc = NIL(Sfdisc_t *); - f->stdio = NIL(Void_t *); + f->stdio = NIL(void *); f->mode = SF_AVAIL; } } diff --git a/lib/sfio/sfcvt.c b/lib/sfio/sfcvt.c index 46c90c904..b9020ee4d 100644 --- a/lib/sfio/sfcvt.c +++ b/lib/sfio/sfcvt.c @@ -30,7 +30,7 @@ static char *Inf = "Inf", *Zero = "0"; * @param sign return sign * @param format conversion format */ -char *_sfcvt(Void_t * dv, int n_digit, int *decpt, int *sign, int format) +char *_sfcvt(void * dv, int n_digit, int *decpt, int *sign, int format) { reg char *sp; reg long n, v; diff --git a/lib/sfio/sfdisc.c b/lib/sfio/sfdisc.c index fc9f739c8..e1492e66f 100644 --- a/lib/sfio/sfdisc.c +++ b/lib/sfio/sfdisc.c @@ -80,7 +80,7 @@ Sfdisc_t *sfdisc(reg Sfio_t * f, reg Sfdisc_t * disc) disc = d->disc; if (d->exceptf) { SFOPEN(f, 0); - if ((*(d->exceptf)) (f, SF_DPOP, (Void_t *) disc, d) < 0) + if ((*(d->exceptf)) (f, SF_DPOP, (void *) disc, d) < 0) goto done; SFLOCK(f, 0); } @@ -91,7 +91,7 @@ Sfdisc_t *sfdisc(reg Sfio_t * f, reg Sfdisc_t * disc) d = f->disc; if (d && d->exceptf) { SFOPEN(f, 0); - if ((*(d->exceptf)) (f, SF_DPUSH, (Void_t *) disc, d) < 0) + if ((*(d->exceptf)) (f, SF_DPUSH, (void *) disc, d) < 0) goto done; SFLOCK(f, 0); } @@ -126,12 +126,12 @@ Sfdisc_t *sfdisc(reg Sfio_t * f, reg Sfdisc_t * disc) SETLOCAL(f); f->bits &= ~SF_NULL; /* turn off /dev/null handling */ if ((f->bits & SF_MMAP) || (f->mode & SF_INIT)) - sfsetbuf(f, NIL(Void_t *), (size_t) SF_UNBOUND); + sfsetbuf(f, NIL(void *), (size_t) SF_UNBOUND); else if (f->data == f->tiny) - sfsetbuf(f, NIL(Void_t *), 0); + sfsetbuf(f, NIL(void *), 0); else { int flags = f->flags; - sfsetbuf(f, (Void_t *) f->data, f->size); + sfsetbuf(f, (void *) f->data, f->size); f->flags |= (flags & SF_MALLOC); } } diff --git a/lib/sfio/sfhdr.h b/lib/sfio/sfhdr.h index 3a16f7217..6d3e8eddd 100644 --- a/lib/sfio/sfhdr.h +++ b/lib/sfio/sfhdr.h @@ -496,7 +496,7 @@ extern "C" { double d; float f; char c, *s, **sp; - Void_t *vp; + void *vp; Sffmt_t *ft; } Argv_t; @@ -652,8 +652,8 @@ extern "C" { ((v) || (f)->extent < 0 || \ ((f)->flags&(SF_SHARE|SF_APPENDWR|SF_WHOLE)) ) ) #define SFSK(f,a,o,d) (SETLOCAL(f),sfsk(f,(Sfoff_t)a,o,d)) -#define SFRD(f,b,n,d) (SETLOCAL(f),sfrd(f,(Void_t*)b,n,d)) -#define SFWR(f,b,n,d) (SETLOCAL(f),sfwr(f,(Void_t*)b,n,d)) +#define SFRD(f,b,n,d) (SETLOCAL(f),sfrd(f,(void*)b,n,d)) +#define SFWR(f,b,n,d) (SETLOCAL(f),sfwr(f,(void*)b,n,d)) #define SFSYNC(f) (SETLOCAL(f),sfsync(f)) #define SFCLOSE(f) (SETLOCAL(f),sfclose(f)) #define SFFLSBUF(f,n) (SETLOCAL(f),_sfflsbuf(f,n)) @@ -878,7 +878,7 @@ extern "C" { /* note that MEMCPY advances the associated pointers */ #define MEMCPY(to,fr,n) \ switch(n) \ - { default : memcpy((Void_t*)to,(Void_t*)fr,n); to += n; fr += n; break; \ + { default : memcpy((void*)to,(void*)fr,n); to += n; fr += n; break; \ case 7 : *to++ = *fr++; \ case 6 : *to++ = *fr++; \ case 5 : *to++ = *fr++; \ @@ -889,7 +889,7 @@ extern "C" { } #define MEMSET(s,c,n) \ switch(n) \ - { default : memset((Void_t*)s,(int)c,n); s += n; break; \ + { default : memset((void*)s,(int)c,n); s += n; break; \ case 7 : *s++ = c; \ case 6 : *s++ = c; \ case 5 : *s++ = c; \ @@ -909,7 +909,7 @@ extern "C" { extern int _sfexcept(Sfio_t *, int, ssize_t, Sfdisc_t *); extern Sfrsrv_t *_sfrsrv(Sfio_t *, ssize_t); extern int _sfsetpool(Sfio_t *); - extern char *_sfcvt(Void_t *, int, int *, int *, int); + extern char *_sfcvt(void *, int, int *, int *, int); extern char **_sfgetpath(char *); extern Sfdouble_t _sfstrtod(const char *, char **); @@ -930,8 +930,8 @@ extern "C" { #endif #if !defined(_hdr_mman) && !_sys_mman - extern Void_t *mmap(Void_t *, size_t, int, int, int, off_t); - extern int munmap(Void_t *, size_t); + extern void *mmap(void *, size_t, int, int, int, off_t); + extern int munmap(void *, size_t); #endif #if !defined(_PACKAGE_ast) diff --git a/lib/sfio/sfio.h b/lib/sfio/sfio.h index 77fb26466..c15e0ff76 100644 --- a/lib/sfio/sfio.h +++ b/lib/sfio/sfio.h @@ -107,11 +107,11 @@ extern "C" { typedef struct _sfdisc_s Sfdisc_t; typedef ssize_t(*Sfread_f) - (Sfio_t *, Void_t *, size_t, Sfdisc_t *); + (Sfio_t *, void *, size_t, Sfdisc_t *); typedef ssize_t(*Sfwrite_f) - (Sfio_t *, const Void_t *, size_t, Sfdisc_t *); + (Sfio_t *, const void *, size_t, Sfdisc_t *); typedef Sfoff_t(*Sfseek_f) (Sfio_t *, Sfoff_t, int, Sfdisc_t *); - typedef int (*Sfexcept_f) (Sfio_t *, int, Void_t *, Sfdisc_t *); + typedef int (*Sfexcept_f) (Sfio_t *, int, void *, Sfdisc_t *); /* discipline structure */ struct _sfdisc_s { @@ -141,8 +141,8 @@ extern "C" { /* formatting environment */ typedef struct _sffmt_s Sffmt_t; - typedef int (*Sffmtext_f)(Sfio_t *, Void_t *, Sffmt_t *); - typedef int (*Sffmtevent_f)(Sfio_t *, int, Void_t *, Sffmt_t *); + typedef int (*Sffmtext_f)(Sfio_t *, void *, Sffmt_t *); + typedef int (*Sffmtevent_f)(Sfio_t *, int, void *, Sffmt_t *); struct _sffmt_s { long version; /* version of this structure */ Sffmtext_f extf; /* function to process arguments */ @@ -161,7 +161,7 @@ extern "C" { char *t_str; /* type string */ ssize_t n_str; /* length of t_str */ - Void_t *noop; /* as yet unused */ + void *noop; /* as yet unused */ }; #define sffmtversion(fe,type) \ (type ? ((fe)->version = SFIO_VERSION) : (fe)->version) @@ -301,7 +301,7 @@ extern "C" { #define extern __EXPORT__ #endif - extern Sfio_t *sfnew(Sfio_t *, Void_t *, size_t, int, int); + extern Sfio_t *sfnew(Sfio_t *, void *, size_t, int, int); extern Sfio_t *sfopen(Sfio_t *, const char *, const char *); extern Sfio_t *sfpopen(Sfio_t *, const char *, const char *); extern Sfio_t *sfstack(Sfio_t *, Sfio_t *); @@ -309,18 +309,18 @@ extern "C" { extern Sfio_t *sftmp(size_t); extern int sfpurge(Sfio_t *); extern int sfpoll(Sfio_t **, int, int); - extern Void_t *sfreserve(Sfio_t *, ssize_t, int); + extern void *sfreserve(Sfio_t *, ssize_t, int); extern int sfsync(Sfio_t *); extern int sfclrlock(Sfio_t *); - extern Void_t *sfsetbuf(Sfio_t *, Void_t *, size_t); + extern void *sfsetbuf(Sfio_t *, void *, size_t); extern Sfdisc_t *sfdisc(Sfio_t *, Sfdisc_t *); - extern int sfraise(Sfio_t *, int, Void_t *); + extern int sfraise(Sfio_t *, int, void *); extern int sfnotify(void (*)(Sfio_t *, int, int)); extern int sfset(Sfio_t *, int, int); extern int sfsetfd(Sfio_t *, int); extern Sfio_t *sfpool(Sfio_t *, Sfio_t *, int); - extern ssize_t sfread(Sfio_t *, Void_t *, size_t); - extern ssize_t sfwrite(Sfio_t *, const Void_t *, size_t); + extern ssize_t sfread(Sfio_t *, void *, size_t); + extern ssize_t sfwrite(Sfio_t *, const void *, size_t); extern Sfoff_t sfmove(Sfio_t *, Sfio_t *, Sfoff_t, int); extern int sfclose(Sfio_t *); extern Sfoff_t sftell(Sfio_t *); @@ -344,10 +344,10 @@ extern "C" { extern int sfmutex(Sfio_t *, int); /* io functions with discipline continuation */ - extern ssize_t sfrd(Sfio_t *, Void_t *, size_t, Sfdisc_t *); - extern ssize_t sfwr(Sfio_t *, const Void_t *, size_t, Sfdisc_t *); + extern ssize_t sfrd(Sfio_t *, void *, size_t, Sfdisc_t *); + extern ssize_t sfwr(Sfio_t *, const void *, size_t, Sfdisc_t *); extern Sfoff_t sfsk(Sfio_t *, Sfoff_t, int, Sfdisc_t *); - extern ssize_t sfpkrd(int, Void_t *, size_t, int, long, int); + extern ssize_t sfpkrd(int, void *, size_t, int, long, int); /* portable handling of primitive types */ extern int sfdlen(Sfdouble_t); diff --git a/lib/sfio/sfio_t.h b/lib/sfio/sfio_t.h index e1bf84d16..efa4855fc 100644 --- a/lib/sfio/sfio_t.h +++ b/lib/sfio/sfio_t.h @@ -38,8 +38,8 @@ extern "C" { struct _sfpool_s* pool; /* the pool containing this */ \ struct _sfrsrv_s* rsrv; /* reserved buffer */ \ struct _sfproc_s* proc; /* coprocess id, etc. */ \ - Void_t* mutex; /* mutex for thread-safety */ \ - Void_t* stdio; /* stdio FILE if any */ \ + void* mutex; /* mutex for thread-safety */ \ + void* stdio; /* stdio FILE if any */ \ Sfoff_t lpos; /* last seek position */ \ size_t iosz; /* prefer size for I/O */ @@ -77,7 +77,7 @@ extern "C" { (struct _sfrsrv_s*)0, /* rsrv */ \ (struct _sfproc_s*)0, /* proc */ \ (mutex), /* mutex */ \ - (Void_t*)0, /* stdio */ \ + (void*)0, /* stdio */ \ (Sfoff_t)0, /* lpos */ \ (size_t)0 /* iosz */ \ } @@ -105,7 +105,7 @@ extern "C" { (f)->rsrv = (struct _sfrsrv_s*)0, /* rsrv */ \ (f)->proc = (struct _sfproc_s*)0, /* proc */ \ (f)->mutex = (mtx), /* mutex */ \ - (f)->stdio = (Void_t*)0, /* stdio */ \ + (f)->stdio = (void*)0, /* stdio */ \ (f)->lpos = (Sfoff_t)0, /* lpos */ \ (f)->iosz = (size_t)0 /* iosz */ \ ) diff --git a/lib/sfio/sfmode.c b/lib/sfio/sfmode.c index 74018c3f8..f629dbdf5 100644 --- a/lib/sfio/sfmode.c +++ b/lib/sfio/sfmode.c @@ -68,7 +68,7 @@ static void _sfcleanup(void) SFMTXLOCK(f); /* let application know that we are leaving */ - (void) SFRAISE(f, SF_ATEXIT, NIL(Void_t *)); + (void) SFRAISE(f, SF_ATEXIT, NIL(void *)); if (f->flags & SF_STRING) continue; @@ -80,7 +80,7 @@ static void _sfcleanup(void) (void) _sfmode(f, SF_WRITE, 1); if (((f->bits & SF_MMAP) && f->data) || ((f->mode & SF_WRITE) && f->next == f->data)) - (void) SFSETBUF(f, NIL(Void_t *), 0); + (void) SFSETBUF(f, NIL(void *), 0); f->mode |= pool; SFMTXUNLOCK(f); @@ -118,10 +118,10 @@ int _sfsetpool(Sfio_t * f) goto done; /* move old array to new one */ - memcpy((Void_t *) array, (Void_t *) p->sf, + memcpy((void *) array, (void *) p->sf, p->n_sf * sizeof(Sfio_t *)); if (p->sf != p->array) - free((Void_t *) p->sf); + free((void *) p->sf); p->sf = array; p->s_sf = n; @@ -283,13 +283,13 @@ static int _sfpmode(Sfio_t * f, int type) } } if (p->ndata > 0) - memcpy((Void_t *) p->rdata, (Void_t *) f->next, p->ndata); + memcpy((void *) p->rdata, (void *) f->next, p->ndata); f->endb = f->data; } else { /* restore read data */ if (p->ndata > f->size) /* may lose data!!! */ p->ndata = f->size; if (p->ndata > 0) { - memcpy((Void_t *) f->data, (Void_t *) p->rdata, p->ndata); + memcpy((void *) f->data, (void *) p->rdata, p->ndata); f->endb = f->data + p->ndata; p->ndata = 0; } @@ -344,7 +344,7 @@ int _sfmode(reg Sfio_t * f, reg int wanted, reg int local) f->mode &= ~SF_GETR; #ifdef MAP_TYPE if ((f->bits & SF_MMAP) && (f->tiny[0] += 1) >= (4 * SF_NMAP)) { /* turn off mmap to avoid page faulting */ - sfsetbuf(f, (Void_t *) f->tiny, (size_t) SF_UNBOUND); + sfsetbuf(f, (void *) f->tiny, (size_t) SF_UNBOUND); f->tiny[0] = 0; } else #endif @@ -496,7 +496,7 @@ int _sfmode(reg Sfio_t * f, reg int wanted, reg int local) if (f->bits & SF_MMAP) { if (f->data) SFMUNMAP(f, f->data, f->endb - f->data); - (void) SFSETBUF(f, (Void_t *) f->tiny, (size_t) SF_UNBOUND); + (void) SFSETBUF(f, (void *) f->tiny, (size_t) SF_UNBOUND); } #endif if (f->data == f->tiny) { diff --git a/lib/sfio/sfmove.c b/lib/sfio/sfmove.c index e94fbd3a4..0da8e5194 100644 --- a/lib/sfio/sfmove.c +++ b/lib/sfio/sfmove.c @@ -114,7 +114,7 @@ Sfoff_t sfmove(Sfio_t * fr, Sfio_t * fw, Sfoff_t n, reg int rc) goto done_filbuf; else if (n > 1 && !fr->disc) { r = sfpkrd(fr->file, - (Void_t *) fr->data, + (void *) fr->data, fr->size, rc, -1, (int) (-n)); if (r <= 0) goto one_r; @@ -181,7 +181,7 @@ Sfoff_t sfmove(Sfio_t * fr, Sfio_t * fw, Sfoff_t n, reg int rc) r = cp - next; if (fr->mode & SF_PKRD) { /* advance the read point by proper amount */ fr->mode &= ~SF_PKRD; - (void) read(fr->file, (Void_t *) next, r); + (void) read(fr->file, (void *) next, r); fr->here += r; if (!direct) fr->endb = cp; @@ -195,7 +195,7 @@ Sfoff_t sfmove(Sfio_t * fr, Sfio_t * fw, Sfoff_t n, reg int rc) else if ((w = endb - cp) > 0) { /* move left-over to read stream */ if (w > fr->size) w = fr->size; - memcpy((Void_t *) fr->data, (Void_t *) cp, w); + memcpy((void *) fr->data, (void *) cp, w); fr->endb = fr->data + w; if ((w = endb - (cp + w)) > 0) (void) SFSK(fr, (Sfoff_t) (-w), SEEK_CUR, fr->disc); @@ -205,9 +205,9 @@ Sfoff_t sfmove(Sfio_t * fr, Sfio_t * fw, Sfoff_t n, reg int rc) if (direct == SF_WRITE) fw->next += r; else if (r <= (fw->endb - fw->next)) { - memcpy((Void_t *) fw->next, (Void_t *) next, r); + memcpy((void *) fw->next, (void *) next, r); fw->next += r; - } else if ((w = SFWRITE(fw, (Void_t *) next, r)) != r) { /* a write error happened */ + } else if ((w = SFWRITE(fw, (void *) next, r)) != r) { /* a write error happened */ if (w > 0) { r -= w; if (rc < 0) diff --git a/lib/sfio/sfnew.c b/lib/sfio/sfnew.c index dda63e28e..854b42521 100644 --- a/lib/sfio/sfnew.c +++ b/lib/sfio/sfnew.c @@ -27,7 +27,7 @@ * @param file file descriptor to read/write from * @param flags type of file stream */ -Sfio_t *sfnew(Sfio_t * oldf, Void_t * buf, size_t size, int file, +Sfio_t *sfnew(Sfio_t * oldf, void * buf, size_t size, int file, int flags) { reg Sfio_t *f; @@ -60,7 +60,7 @@ Sfio_t *sfnew(Sfio_t * oldf, Void_t * buf, size_t size, int file, if (f->data && ((flags & SF_STRING) || size != (size_t) SF_UNBOUND)) { if (sflags & SF_MALLOC) - free((Void_t *) f->data); + free((void *) f->data); f->data = NIL(uchar *); } if (!f->data) diff --git a/lib/sfio/sfnputc.c b/lib/sfio/sfnputc.c index 7fd24fc80..fb136040e 100644 --- a/lib/sfio/sfnputc.c +++ b/lib/sfio/sfnputc.c @@ -57,7 +57,7 @@ ssize_t sfnputc(reg Sfio_t * f, reg int c, reg size_t n) } for (;;) { /* hard write of data */ - if ((p = SFWRITE(f, (Void_t *) ps, p)) <= 0 || (n -= p) <= 0) { + if ((p = SFWRITE(f, (void *) ps, p)) <= 0 || (n -= p) <= 0) { w -= n; goto done; } diff --git a/lib/sfio/sfpkrd.c b/lib/sfio/sfpkrd.c index 6ce4333eb..d38ed84e3 100644 --- a/lib/sfio/sfpkrd.c +++ b/lib/sfio/sfpkrd.c @@ -38,7 +38,7 @@ * <0: no peeking, if rc>=0, get -action records, * =0: no peeking, if rc>=0, must get a single record */ -ssize_t sfpkrd(int fd, Void_t * argbuf, size_t n, int rc, long tm, +ssize_t sfpkrd(int fd, void * argbuf, size_t n, int rc, long tm, int action) { reg ssize_t r; diff --git a/lib/sfio/sfpoll.c b/lib/sfio/sfpoll.c index 55f05f3a3..cb6b0c653 100644 --- a/lib/sfio/sfpoll.c +++ b/lib/sfio/sfpoll.c @@ -151,7 +151,7 @@ int sfpoll(Sfio_t ** fa, reg int n, int tm) break; } - free((Void_t *) fds); + free((void *) fds); } #endif /*_lib_poll*/ @@ -205,7 +205,7 @@ int sfpoll(Sfio_t ** fa, reg int n, int tm) if (status[c] <= 0) continue; if ((d = fa[c]->disc) && d->exceptf) { - if ((r = (*d->exceptf) (fa[c], SF_READY, (Void_t *) 0, d)) < 0) + if ((r = (*d->exceptf) (fa[c], SF_READY, (void *) 0, d)) < 0) goto done; else if (r > 0) goto retry; @@ -225,6 +225,6 @@ int sfpoll(Sfio_t ** fa, reg int n, int tm) } done: - free((Void_t *) status); + free((void *) status); return r; } diff --git a/lib/sfio/sfpool.c b/lib/sfio/sfpool.c index 064cb8a70..dffb2d67f 100644 --- a/lib/sfio/sfpool.c +++ b/lib/sfio/sfpool.c @@ -31,7 +31,7 @@ static int delpool(reg Sfpool_t * p) POOLMTXSTART(p); if (p->s_sf && p->sf != p->array) - free((Void_t *) p->sf); + free((void *) p->sf); p->mode = SF_AVAIL; POOLMTXRETURN(p, 0); diff --git a/lib/sfio/sfpopen.c b/lib/sfio/sfpopen.c index b439bf1e8..dbf17d75f 100644 --- a/lib/sfio/sfpopen.c +++ b/lib/sfio/sfpopen.c @@ -155,7 +155,7 @@ Sfio_t *sfpopen(Sfio_t * f, const char *command, const char *mode) av[3] = 0; if (!(proc = procopen(0, av, 0, 0, flags))) return 0; - if (!(f = sfnew(f, NIL(Void_t *), (size_t) SF_UNBOUND, + if (!(f = sfnew(f, NIL(void *), (size_t) SF_UNBOUND, (sflags & SF_READ) ? proc->rfd : proc->wfd, sflags)) || ((f->bits |= bits), _sfpopen(f, (sflags & SF_READ) ? proc->wfd : -1, proc->pid)) < 0) @@ -213,7 +213,7 @@ Sfio_t *sfpopen(Sfio_t * f, const char *command, const char *mode) /* make the streams */ if (! (f = - sfnew(f, NIL(Void_t *), (size_t) SF_UNBOUND, parent[pkeep], + sfnew(f, NIL(void *), (size_t) SF_UNBOUND, parent[pkeep], sflags))) goto error; CLOSE(parent[!pkeep]); diff --git a/lib/sfio/sfpurge.c b/lib/sfio/sfpurge.c index dc0117cda..58da67e7b 100644 --- a/lib/sfio/sfpurge.c +++ b/lib/sfio/sfpurge.c @@ -29,7 +29,7 @@ int sfpurge(reg Sfio_t * f) SFMTXRETURN(f, -1); if ((f->flags & SF_IOCHECK) && f->disc && f->disc->exceptf) - (void) (*f->disc->exceptf) (f, SF_PURGE, (Void_t *) ((int) 1), + (void) (*f->disc->exceptf) (f, SF_PURGE, (void *) ((int) 1), f->disc); if (f->disc == _Sfudisc) @@ -79,7 +79,7 @@ int sfpurge(reg Sfio_t * f) done: if ((f->flags & SF_IOCHECK) && f->disc && f->disc->exceptf) - (void) (*f->disc->exceptf) (f, SF_PURGE, (Void_t *) ((int) 0), + (void) (*f->disc->exceptf) (f, SF_PURGE, (void *) ((int) 0), f->disc); SFMTXRETURN(f, 0); diff --git a/lib/sfio/sfputd.c b/lib/sfio/sfputd.c index beee7a493..dfe48a0a6 100644 --- a/lib/sfio/sfputd.c +++ b/lib/sfio/sfputd.c @@ -81,7 +81,7 @@ int _sfputd(Sfio_t * f, Sfdouble_t v) /* write out coded bytes */ n = ends - s + 1; - w = SFWRITE(f, (Void_t *) s, n) == n ? w + n : -1; + w = SFWRITE(f, (void *) s, n) == n ? w + n : -1; SFOPEN(f, 0); SFMTXRETURN(f, w); diff --git a/lib/sfio/sfputl.c b/lib/sfio/sfputl.c index 668c6e0fd..14a86906e 100644 --- a/lib/sfio/sfputl.c +++ b/lib/sfio/sfputl.c @@ -49,7 +49,7 @@ int _sfputl(reg Sfio_t * f, Sflong_t v) n = (ps - s) + 1; if (n > 8 || SFWPEEK(f, ps, p) < n) - n = SFWRITE(f, (Void_t *) s, n); /* write the hard way */ + n = SFWRITE(f, (void *) s, n); /* write the hard way */ else { switch (n) { case 8: diff --git a/lib/sfio/sfputm.c b/lib/sfio/sfputm.c index 372da9cc5..517fcb331 100644 --- a/lib/sfio/sfputm.c +++ b/lib/sfio/sfputm.c @@ -46,7 +46,7 @@ int _sfputm(reg Sfio_t * f, Sfulong_t v, Sfulong_t max) n = (ps - s) + 1; if (n > 8 || SFWPEEK(f, ps, p) < n) - n = SFWRITE(f, (Void_t *) s, n); /* write the hard way */ + n = SFWRITE(f, (void *) s, n); /* write the hard way */ else { switch (n) { case 8: diff --git a/lib/sfio/sfputr.c b/lib/sfio/sfputr.c index 7f784868a..ecde41431 100644 --- a/lib/sfio/sfputr.c +++ b/lib/sfio/sfputr.c @@ -101,7 +101,7 @@ ssize_t sfputr(reg Sfio_t * f, const char *s, reg int rc) if (n > w) n = w; f->next -= n; - (void) SFWRITE(f, (Void_t *) f->next, n); + (void) SFWRITE(f, (void *) f->next, n); } SFOPEN(f, 0); diff --git a/lib/sfio/sfputu.c b/lib/sfio/sfputu.c index 8791ac7c4..2324d5456 100644 --- a/lib/sfio/sfputu.c +++ b/lib/sfio/sfputu.c @@ -45,7 +45,7 @@ int _sfputu(reg Sfio_t * f, Sfulong_t v) n = (ps - s) + 1; if (n > 8 || SFWPEEK(f, ps, p) < n) - n = SFWRITE(f, (Void_t *) s, n); /* write the hard way */ + n = SFWRITE(f, (void *) s, n); /* write the hard way */ else { switch (n) { case 8: diff --git a/lib/sfio/sfraise.c b/lib/sfio/sfraise.c index a8b814898..9abecaa29 100644 --- a/lib/sfio/sfraise.c +++ b/lib/sfio/sfraise.c @@ -23,7 +23,7 @@ * @param data associated data * @param */ -int sfraise(Sfio_t * f, int type, Void_t * data) +int sfraise(Sfio_t * f, int type, void * data) { reg Sfdisc_t *disc, *next, *d; reg int local, rv; diff --git a/lib/sfio/sfrd.c b/lib/sfio/sfrd.c index 0dbc72ef7..56055894f 100644 --- a/lib/sfio/sfrd.c +++ b/lib/sfio/sfrd.c @@ -46,7 +46,7 @@ static void _sfwrsync(void) } } -ssize_t sfrd(reg Sfio_t * f, reg Void_t * buf, reg size_t n, +ssize_t sfrd(reg Sfio_t * f, reg void * buf, reg size_t n, Sfdisc_t * disc) { Sfoff_t r; @@ -193,11 +193,11 @@ ssize_t sfrd(reg Sfio_t * f, reg Void_t * buf, reg size_t n, (void) SFSK(f, f->here, SEEK_SET, dc); /* make a buffer */ - (void) SFSETBUF(f, (Void_t *) f->tiny, + (void) SFSETBUF(f, (void *) f->tiny, (size_t) SF_UNBOUND); if (!buf) { - buf = (Void_t *) f->data; + buf = (void *) f->data; n = f->size; } } diff --git a/lib/sfio/sfread.c b/lib/sfio/sfread.c index 5aba2fde1..eb8d1c2df 100644 --- a/lib/sfio/sfread.c +++ b/lib/sfio/sfread.c @@ -24,7 +24,7 @@ * @param n number of bytes to be read * @param */ -ssize_t sfread(reg Sfio_t * f, Void_t * buf, reg size_t n) +ssize_t sfread(reg Sfio_t * f, void * buf, reg size_t n) { reg uchar *s, *begs; reg ssize_t r; diff --git a/lib/sfio/sfreserve.c b/lib/sfio/sfreserve.c index c0b7ce7d4..0ac6d3e04 100644 --- a/lib/sfio/sfreserve.c +++ b/lib/sfio/sfreserve.c @@ -23,14 +23,14 @@ * @param size size of peek * @param type LOCKR: lock stream, LASTR: last record */ -Void_t *sfreserve(reg Sfio_t * f, ssize_t size, int type) +void *sfreserve(reg Sfio_t * f, ssize_t size, int type) { reg ssize_t n, sz; reg Sfrsrv_t *rsrv; - reg Void_t *data; + reg void *data; reg int mode; - SFMTXSTART(f, NIL(Void_t *)); + SFMTXSTART(f, NIL(void *)); /* initialize io states */ rsrv = NIL(Sfrsrv_t *); @@ -41,17 +41,17 @@ Void_t *sfreserve(reg Sfio_t * f, ssize_t size, int type) if ((rsrv = f->rsrv) && (n = -rsrv->slen) > 0) { rsrv->slen = 0; _Sfi = f->val = n; - SFMTXRETURN(f, (Void_t *) rsrv->data); + SFMTXRETURN(f, (void *) rsrv->data); } else - SFMTXRETURN(f, NIL(Void_t *)); + SFMTXRETURN(f, NIL(void *)); } if (type > 0 && !(type == SF_LOCKR || type == 1)) - SFMTXRETURN(f, NIL(Void_t *)); + SFMTXRETURN(f, NIL(void *)); if ((sz = size) == 0 && type != 0) { /* only return the current status and possibly lock stream */ if ((f->mode & SF_RDWR) != f->mode && _sfmode(f, 0, 0) < 0) - SFMTXRETURN(f, NIL(Void_t *)); + SFMTXRETURN(f, NIL(void *)); SFLOCK(f, 0); if ((n = f->endb - f->next) < 0) @@ -122,7 +122,7 @@ Void_t *sfreserve(reg Sfio_t * f, ssize_t size, int type) n = sz; } else { /*if(f->mode&SF_READ) */ if (type <= 0 && (rsrv = _sfrsrv(f, sz)) && - (n = SFREAD(f, (Void_t *) rsrv->data, sz)) < sz) + (n = SFREAD(f, (void *) rsrv->data, sz)) < sz) rsrv->slen = -n; } } @@ -134,13 +134,13 @@ Void_t *sfreserve(reg Sfio_t * f, ssize_t size, int type) SFOPEN(f, 0); if ((sz > 0 && n < sz) || (n == 0 && type <= 0)) - SFMTXRETURN(f, NIL(Void_t *)); + SFMTXRETURN(f, NIL(void *)); - if ((data = rsrv ? (Void_t *) rsrv->data : (Void_t *) f->next)) { + if ((data = rsrv ? (void *) rsrv->data : (void *) f->next)) { if (type > 0) { f->mode |= SF_PEEK; f->endr = f->endw = f->data; - } else if (data == (Void_t *) f->next) + } else if (data == (void *) f->next) f->next += (size >= 0 ? size : n); } diff --git a/lib/sfio/sfresize.c b/lib/sfio/sfresize.c index 665080f6f..5d353e5aa 100644 --- a/lib/sfio/sfresize.c +++ b/lib/sfio/sfresize.c @@ -33,7 +33,7 @@ int sfresize(Sfio_t * f, Sfoff_t size) if (f->extent >= size) { if ((f->flags & SF_MALLOC) && (f->next - f->data) <= size) { size_t s = (((size_t) size + 1023) / 1024) * 1024; - Void_t *d; + void *d; if (s < f->size && (d = realloc(f->data, s))) { f->data = d; f->size = s; diff --git a/lib/sfio/sfseek.c b/lib/sfio/sfseek.c index 1a61e3214..8dc08ea85 100644 --- a/lib/sfio/sfseek.c +++ b/lib/sfio/sfseek.c @@ -187,7 +187,7 @@ Sfoff_t sfseek(Sfio_t * f, Sfoff_t p, int type) if (f->bits & SF_MMAP) { /* if mmap is not great, stop mmaping if moving around too much */ #if _mmap_worthy < 2 if ((f->next - f->data) < ((f->endb - f->data) / 4)) { - SFSETBUF(f, (Void_t *) f->tiny, (size_t) SF_UNBOUND); + SFSETBUF(f, (void *) f->tiny, (size_t) SF_UNBOUND); hardseek = 1; /* this forces a hard seek below */ } else #endif diff --git a/lib/sfio/sfsetbuf.c b/lib/sfio/sfsetbuf.c index e76b58e2b..e603db80c 100644 --- a/lib/sfio/sfsetbuf.c +++ b/lib/sfio/sfsetbuf.c @@ -49,7 +49,7 @@ _END_EXTERNS_ * @param buf new buffer * @param size buffer size, -1 for default size */ -Void_t *sfsetbuf(reg Sfio_t * f, reg Void_t * buf, reg size_t size) +void *sfsetbuf(reg Sfio_t * f, reg void * buf, reg size_t size) { reg int sf_malloc; reg uchar *obuf; @@ -63,28 +63,28 @@ Void_t *sfsetbuf(reg Sfio_t * f, reg Void_t * buf, reg size_t size) SFONCE(); - SFMTXSTART(f, NIL(Void_t *)); + SFMTXSTART(f, NIL(void *)); GETLOCAL(f, local); if (size == 0 && buf) { /* special case to get buffer info */ _Sfi = f->val = (f->bits & SF_MMAP) ? (f->endb - f->data) : f->size; - SFMTXRETURN(f, (Void_t *) f->data); + SFMTXRETURN(f, (void *) f->data); } /* cleanup actions already done, don't allow write buffering any more */ if (_Sfexiting && !(f->flags & SF_STRING) && (f->mode & SF_WRITE)) { - buf = NIL(Void_t *); + buf = NIL(void *); size = 0; } if ((init = f->mode & SF_INIT)) { if (!f->pool && _sfsetpool(f) < 0) - SFMTXRETURN(f, NIL(Void_t *)); + SFMTXRETURN(f, NIL(void *)); } else if ((f->mode & SF_RDWR) != SFMODE(f, local) && _sfmode(f, 0, local) < 0) - SFMTXRETURN(f, NIL(Void_t *)); + SFMTXRETURN(f, NIL(void *)); if (init) f->mode = (f->mode & SF_RDWR) | SF_LOCK; @@ -94,14 +94,14 @@ Void_t *sfsetbuf(reg Sfio_t * f, reg Void_t * buf, reg size_t size) /* make sure there is no hidden read data */ if (f->proc && (f->flags & SF_READ) && (f->mode & SF_WRITE) && _sfmode(f, SF_READ, local) < 0) - SFMTXRETURN(f, NIL(Void_t *)); + SFMTXRETURN(f, NIL(void *)); /* synchronize first */ SFLOCK(f, local); rv = SFSYNC(f); SFOPEN(f, local); if (rv < 0) - SFMTXRETURN(f, NIL(Void_t *)); + SFMTXRETURN(f, NIL(void *)); /* turn off the SF_SYNCED bit because buffer is changing */ f->mode &= ~SF_SYNCED; @@ -273,19 +273,19 @@ Void_t *sfsetbuf(reg Sfio_t * f, reg Void_t * buf, reg size_t size) else if ((ssize_t) (size = _Sfpage) < blksize) size = blksize; - buf = NIL(Void_t *); + buf = NIL(void *); } sf_malloc = 0; if (size > 0 && !buf && !(f->bits & SF_MMAP)) { /* try to allocate a buffer */ if (obuf && size == (size_t) osize && init) { - buf = (Void_t *) obuf; + buf = (void *) obuf; obuf = NIL(uchar *); sf_malloc = (oflags & SF_MALLOC); } if (!buf) { /* do allocation */ while (!buf && size > 0) { - if ((buf = (Void_t *) malloc(size))) + if ((buf = (void *) malloc(size))) break; else size /= 2; @@ -297,7 +297,7 @@ Void_t *sfsetbuf(reg Sfio_t * f, reg Void_t * buf, reg size_t size) if (size == 0 && !(f->flags & SF_STRING) && !(f->bits & SF_MMAP) && (f->mode & SF_READ)) { /* use the internal buffer */ size = sizeof(f->tiny); - buf = (Void_t *) f->tiny; + buf = (void *) f->tiny; } /* set up new buffer */ @@ -318,7 +318,7 @@ Void_t *sfsetbuf(reg Sfio_t * f, reg Void_t * buf, reg size_t size) f->flags = (f->flags & ~SF_MALLOC) | sf_malloc; if (obuf && obuf != f->data && osize > 0 && (oflags & SF_MALLOC)) { - free((Void_t *) obuf); + free((void *) obuf); obuf = NIL(uchar *); } @@ -326,5 +326,5 @@ Void_t *sfsetbuf(reg Sfio_t * f, reg Void_t * buf, reg size_t size) SFOPEN(f, local); - SFMTXRETURN(f, (Void_t *) obuf); + SFMTXRETURN(f, (void *) obuf); } diff --git a/lib/sfio/sfswap.c b/lib/sfio/sfswap.c index 524fbd88d..cdc3912c7 100644 --- a/lib/sfio/sfswap.c +++ b/lib/sfio/sfswap.c @@ -76,9 +76,9 @@ Sfio_t *sfswap(reg Sfio_t * f1, reg Sfio_t * f2) f2flags = f2->flags; /* swap image and pool entries */ - memcpy((Void_t *) (&tmp), (Void_t *) f1, sizeof(Sfio_t)); - memcpy((Void_t *) f1, (Void_t *) f2, sizeof(Sfio_t)); - memcpy((Void_t *) f2, (Void_t *) (&tmp), sizeof(Sfio_t)); + memcpy((void *) (&tmp), (void *) f1, sizeof(Sfio_t)); + memcpy((void *) f1, (void *) f2, sizeof(Sfio_t)); + memcpy((void *) f2, (void *) (&tmp), sizeof(Sfio_t)); if (f2pool >= 0) f1->pool->sf[f2pool] = f1; if (f1pool >= 0) diff --git a/lib/sfio/sfsync.c b/lib/sfio/sfsync.c index 3309b8f15..608e45dca 100644 --- a/lib/sfio/sfsync.c +++ b/lib/sfio/sfsync.c @@ -94,7 +94,7 @@ int sfsync(reg Sfio_t * f) for (; f; f = f->push) { if ((f->flags & SF_IOCHECK) && f->disc && f->disc->exceptf) - (void) (*f->disc->exceptf) (f, SF_SYNC, (Void_t *) ((int) 1), + (void) (*f->disc->exceptf) (f, SF_SYNC, (void *) ((int) 1), f->disc); SFLOCK(f, local); @@ -138,7 +138,7 @@ int sfsync(reg Sfio_t * f) SFOPEN(f, local); if ((f->flags & SF_IOCHECK) && f->disc && f->disc->exceptf) - (void) (*f->disc->exceptf) (f, SF_SYNC, (Void_t *) ((int) 0), + (void) (*f->disc->exceptf) (f, SF_SYNC, (void *) ((int) 0), f->disc); } diff --git a/lib/sfio/sftable.c b/lib/sfio/sftable.c index 1aef9efae..79a8ddb91 100644 --- a/lib/sfio/sftable.c +++ b/lib/sfio/sftable.c @@ -322,7 +322,7 @@ static Fmtpos_t *sffmtpos(Sfio_t * f, const char *form, va_list args, memcpy(ft, &fp[n].ft, sizeof(Sffmt_t)); va_copy(ft->args, args); ft->flags |= SFFMT_ARGPOS; - v = (*ft->extf) (f, (Void_t *) (&fp[n].argv), ft); + v = (*ft->extf) (f, (void *) (&fp[n].argv), ft); va_copy(args, ft->args); memcpy(&fp[n].ft, ft, sizeof(Sffmt_t)); if (v < 0) { @@ -348,7 +348,7 @@ static Fmtpos_t *sffmtpos(Sfio_t * f, const char *form, va_list args, if (ft) memcpy(&savft, ft, sizeof(Sffmt_t)); } else if (type > 0) /* from sfvscanf */ - fp[n].argv.vp = va_arg(args, Void_t *); + fp[n].argv.vp = va_arg(args, void *); else switch (_Sftype[fp[n].ft.fmt]) { case SFFMT_INT: @@ -372,7 +372,7 @@ static Fmtpos_t *sffmtpos(Sfio_t * f, const char *form, va_list args, fp[n].argv.d = va_arg(args, double); break; case SFFMT_POINTER: - fp[n].argv.vp = va_arg(args, Void_t *); + fp[n].argv.vp = va_arg(args, void *); break; case SFFMT_BYTE: if (fp[n].ft.base >= 0) diff --git a/lib/sfio/sftmp.c b/lib/sfio/sftmp.c index 054117725..3616432a4 100644 --- a/lib/sfio/sftmp.c +++ b/lib/sfio/sftmp.c @@ -44,7 +44,7 @@ struct _file_s { static File_t *File; /* list pf temp files */ -static int _tmprmfile(Sfio_t * f, int type, Void_t * val, Sfdisc_t * disc) +static int _tmprmfile(Sfio_t * f, int type, void * val, Sfdisc_t * disc) { reg File_t *ff, *last; @@ -71,7 +71,7 @@ static int _tmprmfile(Sfio_t * f, int type, Void_t * val, Sfdisc_t * disc) while (remove(ff->name) < 0 && errno == EINTR) errno = 0; - free((Void_t *) ff); + free((void *) ff); } vtmtxunlock(_Sfmutex); } @@ -86,7 +86,7 @@ static void _rmfiles(void) vtmtxlock(_Sfmutex); for (ff = File; ff; ff = next) { next = ff->next; - _tmprmfile(ff->f, SF_CLOSING, NIL(Void_t *), ff->f->disc); + _tmprmfile(ff->f, SF_CLOSING, NIL(void *), ff->f->disc); } vtmtxunlock(_Sfmutex); } @@ -252,7 +252,7 @@ static int _tmpfd(Sfio_t * f) return fd; } -static int _tmpexcept(Sfio_t * f, int type, Void_t * val, Sfdisc_t * disc) +static int _tmpexcept(Sfio_t * f, int type, void * val, Sfdisc_t * disc) { reg int fd, m; reg Sfio_t *sf; @@ -280,7 +280,7 @@ static int _tmpexcept(Sfio_t * f, int type, Void_t * val, Sfdisc_t * disc) /* make sure that the notify function won't be called here since we are only interested in creating the file, not the stream */ _Sfnotify = 0; - sf = sfnew(&newf, NIL(Void_t *), (size_t) SF_UNBOUND, fd, + sf = sfnew(&newf, NIL(void *), (size_t) SF_UNBOUND, fd, SF_READ | SF_WRITE); _Sfnotify = notifyf; if (!sf) @@ -298,8 +298,8 @@ static int _tmpexcept(Sfio_t * f, int type, Void_t * val, Sfdisc_t * disc) sfset(sf, (f->mode & (SF_READ | SF_WRITE)), 1); /* now remake the old stream into the new image */ - memcpy((Void_t *) (&savf), (Void_t *) f, sizeof(Sfio_t)); - memcpy((Void_t *) f, (Void_t *) sf, sizeof(Sfio_t)); + memcpy((void *) (&savf), (void *) f, sizeof(Sfio_t)); + memcpy((void *) f, (void *) sf, sizeof(Sfio_t)); f->push = savf.push; f->pool = savf.pool; f->rsrv = savf.rsrv; @@ -310,12 +310,12 @@ static int _tmpexcept(Sfio_t * f, int type, Void_t * val, Sfdisc_t * disc) if (savf.data) { SFSTRSIZE(&savf); if (!(savf.flags & SF_MALLOC)) - (void) sfsetbuf(f, (Void_t *) savf.data, savf.size); + (void) sfsetbuf(f, (void *) savf.data, savf.size); if (savf.extent > 0) - (void) sfwrite(f, (Void_t *) savf.data, (size_t) savf.extent); + (void) sfwrite(f, (void *) savf.data, (size_t) savf.extent); (void) sfseek(f, (Sfoff_t) (savf.next - savf.data), 0); if ((savf.flags & SF_MALLOC)) - free((Void_t *) savf.data); + free((void *) savf.data); } /* announce change of status */ @@ -355,7 +355,7 @@ Sfio_t *sftmp(reg size_t s) f->disc = &Tmpdisc; /* make the file now */ - if (s == 0 && _tmpexcept(f, SF_DPOP, NIL(Void_t *), f->disc) < 0) { + if (s == 0 && _tmpexcept(f, SF_DPOP, NIL(void *), f->disc) < 0) { sfclose(f); return NIL(Sfio_t *); } diff --git a/lib/sfio/sfungetc.c b/lib/sfio/sfungetc.c index ff48288cb..d96839508 100644 --- a/lib/sfio/sfungetc.c +++ b/lib/sfio/sfungetc.c @@ -17,7 +17,7 @@ ** ** Written by Kiem-Phong Vo. */ -static int _uexcept(reg Sfio_t * f, reg int type, Void_t * val, +static int _uexcept(reg Sfio_t * f, reg int type, void * val, reg Sfdisc_t * disc) { NOTUSED(val); diff --git a/lib/sfio/sfvprintf.c b/lib/sfio/sfvprintf.c index 405ab52cb..7d80a38e5 100644 --- a/lib/sfio/sfvprintf.c +++ b/lib/sfio/sfvprintf.c @@ -83,7 +83,7 @@ int sfvprintf(Sfio_t * f, const char *form, va_list args) #define SFwrite(f,s,n) \ { if((endd-d) >= n) { MEMCPY(d,s,n); } \ else \ - { SFEND(f); n_output += (w = SFWRITE(f,(Void_t*)s,n)) > 0 ? w : 0; SFBUF(f); \ + { SFEND(f); n_output += (w = SFWRITE(f,(void*)s,n)) > 0 ? w : 0; SFBUF(f); \ if(n != w) goto done; \ } \ } @@ -180,7 +180,7 @@ int sfvprintf(Sfio_t * f, const char *form, va_list args) FMTSET(ft, form, args, LEFTP, 0, 0, 0, 0, 0, NIL(char *), 0); n = (*ft->extf) - (f, (Void_t *) & argv, ft); + (f, (void *) & argv, ft); if (n < 0) goto pop_fmt; if (!(ft->flags & SFFMT_VALUE)) @@ -263,7 +263,7 @@ int sfvprintf(Sfio_t * f, const char *form, va_list args) else if (ft && ft->extf) { FMTSET(ft, form, args, '.', dot, 0, 0, 0, 0, NIL(char *), 0); - if ((*ft->extf) (f, (Void_t *) (&argv), ft) < 0) + if ((*ft->extf) (f, (void *) (&argv), ft) < 0) goto pop_fmt; if (ft->flags & SFFMT_VALUE) v = argv.i; @@ -325,7 +325,7 @@ int sfvprintf(Sfio_t * f, const char *form, va_list args) else if (ft && ft->extf) { FMTSET(ft, form, args, 'I', sizeof(int), 0, 0, 0, 0, NIL(char *), 0); - if ((*ft->extf) (f, (Void_t *) (&argv), ft) < 0) + if ((*ft->extf) (f, (void *) (&argv), ft) < 0) goto pop_fmt; if (ft->flags & SFFMT_VALUE) size = argv.i; @@ -401,7 +401,7 @@ int sfvprintf(Sfio_t * f, const char *form, va_list args) t_str, n_str); SFEND(f); SFOPEN(f, 0); - v = (*ft->extf) (f, (Void_t *) (&argv), ft); + v = (*ft->extf) (f, (void *) (&argv), ft); SFLOCK(f, 0); SFBUF(f); @@ -440,7 +440,7 @@ int sfvprintf(Sfio_t * f, const char *form, va_list args) argv.d = va_arg(args, double); break; case SFFMT_POINTER: - argv.vp = va_arg(args, Void_t *); + argv.vp = va_arg(args, void *); break; case SFFMT_BYTE: if (base >= 0) @@ -469,7 +469,7 @@ int sfvprintf(Sfio_t * f, const char *form, va_list args) goto pop_fmt; if (!argv.ft->form && ft) { /* change extension functions */ if (ft->eventf && - (*ft->eventf) (f, SF_DPOP, (Void_t *) form, ft) < 0) + (*ft->eventf) (f, SF_DPOP, (void *) form, ft) < 0) continue; fmstk->ft = ft = argv.ft; } else { /* stack a new environment */ @@ -1013,8 +1013,8 @@ int sfvprintf(Sfio_t * f, const char *form, va_list args) while ((fm = fmstk)) { /* pop the format stack and continue */ if (fm->eventf) { if (!form || !form[0]) - (*fm->eventf) (f, SF_FINAL, NIL(Void_t *), ft); - else if ((*fm->eventf) (f, SF_DPOP, (Void_t *) form, ft) < 0) + (*fm->eventf) (f, SF_FINAL, NIL(void *), ft); + else if ((*fm->eventf) (f, SF_DPOP, (void *) form, ft) < 0) goto loop_fmt; } @@ -1037,7 +1037,7 @@ int sfvprintf(Sfio_t * f, const char *form, va_list args) free(fp); while ((fm = fmstk)) { if (fm->eventf) - (*fm->eventf) (f, SF_FINAL, NIL(Void_t *), fm->ft); + (*fm->eventf) (f, SF_FINAL, NIL(void *), fm->ft); fmstk = fm->next; free(fm); } @@ -1051,7 +1051,7 @@ int sfvprintf(Sfio_t * f, const char *form, va_list args) if ((((flags = f->flags) & SF_SHARE) && !(flags & SF_PUBLIC)) || (n > 0 && (d == (uchar *) data || (flags & SF_LINE)))) - (void) SFWRITE(f, (Void_t *) d, n); + (void) SFWRITE(f, (void *) d, n); else f->next += n; diff --git a/lib/sfio/sfvscanf.c b/lib/sfio/sfvscanf.c index f624c12b2..c36e74b31 100644 --- a/lib/sfio/sfvscanf.c +++ b/lib/sfio/sfvscanf.c @@ -95,7 +95,7 @@ int sfvscanf(Sfio_t * f, reg const char *form, va_list args) va_list oargs; int argp, argn; - Void_t *value; /* location to assign scanned value */ + void *value; /* location to assign scanned value */ char *t_str; ssize_t n_str; int rs; @@ -103,7 +103,7 @@ int sfvscanf(Sfio_t * f, reg const char *form, va_list args) #define SFBUF(f) (_sfbuf(f,&rs), (data = d = f->next), (endd = f->endb) ) #define SFLEN(f) (d-data) #define SFEND(f) ((n_input += d-data), \ - (rs > 0 ? SFREAD(f,(Void_t*)data,d-data) : ((f->next = d), 0)) ) + (rs > 0 ? SFREAD(f,(void*)data,d-data) : ((f->next = d), 0)) ) #define SFGETC(f,c) ((c) = (d < endd || (SFEND(f), SFBUF(f), d < endd)) ? \ (int)(*d++) : -1 ) #define SFUNGETC(f,c) (--d) @@ -179,7 +179,7 @@ int sfvscanf(Sfio_t * f, reg const char *form, va_list args) width = dot = 0; t_str = NIL(char *); n_str = 0; - value = NIL(Void_t *); + value = NIL(void *); argp = -1; loop_flags: /* LOOP FOR FLAGS, WIDTH, BASE, TYPE */ @@ -218,7 +218,7 @@ int sfvscanf(Sfio_t * f, reg const char *form, va_list args) FMTSET(ft, form, args, LEFTP, 0, 0, 0, 0, 0, NIL(char *), 0); n = (*ft->extf) - (f, (Void_t *) & argv, ft); + (f, (void *) & argv, ft); if (n < 0) goto pop_fmt; if (!(ft->flags & SFFMT_VALUE)) @@ -260,7 +260,7 @@ int sfvscanf(Sfio_t * f, reg const char *form, va_list args) else if (ft && ft->extf) { FMTSET(ft, form, args, '.', dot, 0, 0, 0, 0, NIL(char *), 0); - if ((*ft->extf) (f, (Void_t *) (&argv), ft) < 0) + if ((*ft->extf) (f, (void *) (&argv), ft) < 0) goto pop_fmt; if (ft->flags & SFFMT_VALUE) v = argv.i; @@ -324,7 +324,7 @@ int sfvscanf(Sfio_t * f, reg const char *form, va_list args) else if (ft && ft->extf) { FMTSET(ft, form, args, 'I', sizeof(int), 0, 0, 0, 0, NIL(char *), 0); - if ((*ft->extf) (f, (Void_t *) (&argv), ft) < 0) + if ((*ft->extf) (f, (void *) (&argv), ft) < 0) goto pop_fmt; if (ft->flags & SFFMT_VALUE) size = argv.i; @@ -403,7 +403,7 @@ int sfvscanf(Sfio_t * f, reg const char *form, va_list args) n_str); SFEND(f); SFOPEN(f, 0); - v = (*ft->extf) (f, (Void_t *) & argv, ft); + v = (*ft->extf) (f, (void *) & argv, ft); SFLOCK(f, 0); SFBUF(f); @@ -434,7 +434,7 @@ int sfvscanf(Sfio_t * f, reg const char *form, va_list args) continue; if (!argv.ft->form && ft) { /* change extension functions */ if (ft->eventf && - (*ft->eventf) (f, SF_DPOP, (Void_t *) form, ft) < 0) + (*ft->eventf) (f, SF_DPOP, (void *) form, ft) < 0) continue; fmstk->ft = ft = argv.ft; } else { /* stack a new environment */ @@ -468,7 +468,7 @@ int sfvscanf(Sfio_t * f, reg const char *form, va_list args) /* get the address to assign value */ if (!value && !(flags & SFFMT_SKIP)) - value = va_arg(args, Void_t *); + value = va_arg(args, void *); if (fmt == 'n') { /* return length of consumed input */ #if !_ast_intmax_long @@ -667,9 +667,9 @@ int sfvscanf(Sfio_t * f, reg const char *form, va_list args) if (fmt == 'p') #if _more_void_int - *((Void_t **) value) = (Void_t *) ((ulong) argv.lu); + *((void **) value) = (void *) ((ulong) argv.lu); #else - *((Void_t **) value) = (Void_t *) ((uint) argv.lu); + *((void **) value) = (void *) ((uint) argv.lu); #endif #if !_ast_intmax_long else if (FMTCMP(size, Sflong_t, Sflong_t)) @@ -757,8 +757,8 @@ int sfvscanf(Sfio_t * f, reg const char *form, va_list args) while ((fm = fmstk)) { /* pop the format stack and continue */ if (fm->eventf) { if (!form || !form[0]) - (*fm->eventf) (f, SF_FINAL, NIL(Void_t *), ft); - else if ((*fm->eventf) (f, SF_DPOP, (Void_t *) form, ft) < 0) + (*fm->eventf) (f, SF_FINAL, NIL(void *), ft); + else if ((*fm->eventf) (f, SF_DPOP, (void *) form, ft) < 0) goto loop_fmt; } @@ -781,7 +781,7 @@ int sfvscanf(Sfio_t * f, reg const char *form, va_list args) free(fp); while ((fm = fmstk)) { if (fm->eventf) - (*fm->eventf) (f, SF_FINAL, NIL(Void_t *), fm->ft); + (*fm->eventf) (f, SF_FINAL, NIL(void *), fm->ft); fmstk = fm->next; free(fm); } diff --git a/lib/sfio/sfwr.c b/lib/sfio/sfwr.c index 0c260317d..2ec8ef12b 100644 --- a/lib/sfio/sfwr.c +++ b/lib/sfio/sfwr.c @@ -104,7 +104,7 @@ static ssize_t sfoutput(Sfio_t * f, reg char *buf, reg size_t n) return w > 0 ? w : -1; } -ssize_t sfwr(reg Sfio_t * f, reg const Void_t * buf, reg size_t n, +ssize_t sfwr(reg Sfio_t * f, reg const void * buf, reg size_t n, reg Sfdisc_t * disc) { reg ssize_t w; diff --git a/lib/sfio/sfwrite.c b/lib/sfio/sfwrite.c index e69e9e1f9..d6d0527df 100644 --- a/lib/sfio/sfwrite.c +++ b/lib/sfio/sfwrite.c @@ -23,7 +23,7 @@ * @param buf buffer to be written * @param n number of bytes */ -ssize_t sfwrite(reg Sfio_t * f, const Void_t * buf, reg size_t n) +ssize_t sfwrite(reg Sfio_t * f, const void * buf, reg size_t n) { reg uchar *s, *begs, *next; reg ssize_t w; diff --git a/lib/sfio/vthread.h b/lib/sfio/vthread.h index 1a994825e..06c11955d 100644 --- a/lib/sfio/vthread.h +++ b/lib/sfio/vthread.h @@ -103,7 +103,7 @@ extern "C" { _BEGIN_EXTERNS_ extern Vthread_t *vtopen(Vthread_t *, int); extern int vtclose(Vthread_t *); - extern int vtset(Vthread_t *, int, Void_t *); + extern int vtset(Vthread_t *, int, void *); extern int vtrun(Vthread_t *, void *(*)(void *), void *); extern int vtkill(Vthread_t *); extern int vtwait(Vthread_t *); @@ -117,7 +117,7 @@ extern "C" { extern int vtmtxunlock(Vtmutex_t *); extern int vtmtxclrlock(Vtmutex_t *); - extern Void_t *vtstatus(Vthread_t *); + extern void *vtstatus(Vthread_t *); extern int vterror(Vthread_t *); extern int vtmtxerror(Vtmutex_t *); extern int vtonceerror(Vtonce_t *); @@ -141,7 +141,7 @@ extern "C" { size_t stack; /* stack size */ int state; /* execution state */ int error; /* error status */ - Void_t *exit; /* exit value */ + void *exit; /* exit value */ }; /* structure for exactly once execution */ @@ -197,7 +197,7 @@ extern "C" { #define vtmtxunlock(mtx) (void)(-1) #define vtmtxclrlock(mtx) (void)(-1) -#define vtstatus(vt) ((Void_t*)0) +#define vtstatus(vt) ((void*)0) #define vterror(vt) (0) #define vtmtxerror(mtx) (0) #define vtonceerror(once) (0) diff --git a/lib/vmalloc/features/common b/lib/vmalloc/features/common index 7f27e5526..865b189a4 100644 --- a/lib/vmalloc/features/common +++ b/lib/vmalloc/features/common @@ -86,11 +86,6 @@ cat{ #define __INLINE__ __inline #endif - /* Void_t is defined so that Void_t* can address any type */ - #ifndef Void_t - #define Void_t void - #endif /*Void_t*/ - /* dynamic linked library external scope handling */ #undef extern #if _dll_import && !defined(__EXPORT__) && _DLL_BLD diff --git a/lib/vmalloc/malloc.c b/lib/vmalloc/malloc.c index d535d66b3..cec8b7021 100644 --- a/lib/vmalloc/malloc.c +++ b/lib/vmalloc/malloc.c @@ -198,7 +198,7 @@ static int vmflinit(void) env += 1; else if (env[0] == '0' && (env[1] == 'x' || env[1] == 'X')) { if ((addr = atou(&env)) != 0) - vmdbwatch((Void_t *) addr); + vmdbwatch((void *) addr); } else { _Vmdbcheck = atou(&env); setcheck = 1; @@ -244,7 +244,7 @@ static int vmflinit(void) return 0; } -Void_t *malloc(reg size_t size) +void *malloc(reg size_t size) { VMFLINIT(); return (*Vmregion->meth.allocf) (Vmregion, size); @@ -254,39 +254,39 @@ Void_t *malloc(reg size_t size) * @param data block to be reallocated * @param size new size */ -Void_t *realloc(reg Void_t * data, reg size_t size) +void *realloc(reg void * data, reg size_t size) { VMFLINIT(); return (*Vmregion->meth.resizef) (Vmregion, data, size, VM_RSCOPY | VM_RSMOVE); } -void free(reg Void_t * data) +void free(reg void * data) { VMFLINIT(); (void) (*Vmregion->meth.freef) (Vmregion, data); } -Void_t *calloc(reg size_t n_obj, reg size_t s_obj) +void *calloc(reg size_t n_obj, reg size_t s_obj) { VMFLINIT(); - return (*Vmregion->meth.resizef) (Vmregion, NIL(Void_t *), + return (*Vmregion->meth.resizef) (Vmregion, NIL(void *), n_obj * s_obj, VM_RSZERO); } -void cfree(reg Void_t * data) +void cfree(reg void * data) { VMFLINIT(); (void) (*Vmregion->meth.freef) (Vmregion, data); } -Void_t *memalign(reg size_t align, reg size_t size) +void *memalign(reg size_t align, reg size_t size) { VMFLINIT(); return (*Vmregion->meth.alignf) (Vmregion, size, align); } -Void_t *valloc(reg size_t size) +void *valloc(reg size_t size) { VMFLINIT(); GETPAGESIZE(_Vmpagesize); @@ -369,7 +369,7 @@ struct _alloca_s { Vmuchar_t data[1]; }; -Void_t *alloca(size_t size) +void *alloca(size_t size) { char array[ALIGN]; char *file; @@ -399,7 +399,7 @@ Void_t *alloca(size_t size) f->head.head.next = Frame; Frame = f; - return (Void_t *) f->data; + return (void *) f->data; } #endif /*!_lib_alloca || _mal_alloca */ diff --git a/lib/vmalloc/vmalloc.h b/lib/vmalloc/vmalloc.h index 266860ee1..c546f2d0a 100644 --- a/lib/vmalloc/vmalloc.h +++ b/lib/vmalloc/vmalloc.h @@ -35,10 +35,10 @@ extern "C" { typedef struct _vmstat_s Vmstat_t; typedef struct _vmdisc_s Vmdisc_t; typedef struct _vmethod_s Vmethod_t; - typedef Void_t *(*Vmemory_f) - (Vmalloc_t *, Void_t *, size_t, size_t, Vmdisc_t *); + typedef void *(*Vmemory_f) + (Vmalloc_t *, void *, size_t, size_t, Vmdisc_t *); typedef int (*Vmexcept_f) - (Vmalloc_t *, int, Void_t *, Vmdisc_t *); + (Vmalloc_t *, int, void *, Vmdisc_t *); struct _vmstat_s { int n_busy; /* number of busy blocks */ @@ -58,13 +58,13 @@ extern "C" { }; struct _vmethod_s { - Void_t *(*allocf) (Vmalloc_t *, size_t); - Void_t *(*resizef) (Vmalloc_t *, Void_t *, size_t, int); - int (*freef) (Vmalloc_t *, Void_t *); - long (*addrf) (Vmalloc_t *, Void_t *); - long (*sizef) (Vmalloc_t *, Void_t *); + void *(*allocf) (Vmalloc_t *, size_t); + void *(*resizef) (Vmalloc_t *, void *, size_t, int); + int (*freef) (Vmalloc_t *, void *); + long (*addrf) (Vmalloc_t *, void *); + long (*sizef) (Vmalloc_t *, void *); int (*compactf) (Vmalloc_t *); - Void_t *(*alignf) (Vmalloc_t *, size_t, size_t); + void *(*alignf) (Vmalloc_t *, size_t, size_t); unsigned short meth; }; @@ -142,19 +142,19 @@ extern "C" { extern Vmdisc_t *vmdisc(Vmalloc_t *, Vmdisc_t *); - extern Void_t *vmalloc(Vmalloc_t *, size_t); - extern Void_t *vmalign(Vmalloc_t *, size_t, size_t); - extern Void_t *vmresize(Vmalloc_t *, Void_t *, size_t, int); - extern int vmfree(Vmalloc_t *, Void_t *); + extern void *vmalloc(Vmalloc_t *, size_t); + extern void *vmalign(Vmalloc_t *, size_t, size_t); + extern void *vmresize(Vmalloc_t *, void *, size_t, int); + extern int vmfree(Vmalloc_t *, void *); - extern long vmaddr(Vmalloc_t *, Void_t *); - extern long vmsize(Vmalloc_t *, Void_t *); + extern long vmaddr(Vmalloc_t *, void *); + extern long vmsize(Vmalloc_t *, void *); - extern Vmalloc_t *vmregion(Void_t *); - extern Void_t *vmsegment(Vmalloc_t *, Void_t *); + extern Vmalloc_t *vmregion(void *); + extern void *vmsegment(Vmalloc_t *, void *); extern int vmset(Vmalloc_t *, int, int); - extern Void_t *vmdbwatch(Void_t *); + extern void *vmdbwatch(void *); extern int vmdbcheck(Vmalloc_t *); extern int vmprofile(Vmalloc_t *, int); @@ -165,7 +165,7 @@ extern "C" { extern int vmstat(Vmalloc_t *, Vmstat_t *); extern int vmwalk(Vmalloc_t *, - int (*)(Vmalloc_t *, Void_t *, size_t, + int (*)(Vmalloc_t *, void *, size_t, Vmdisc_t *)); extern char *vmstrdup(Vmalloc_t *, const char *); @@ -181,15 +181,15 @@ extern "C" { (*(_VM_(vm)->meth.allocf))((vm),(sz)) ) #define vmresize(vm,d,sz,type) (_VMFL_(vm), \ (*(_VM_(vm)->meth.resizef))\ - ((vm),(Void_t*)(d),(sz),(type)) ) + ((vm),(void*)(d),(sz),(type)) ) #define vmfree(vm,d) (_VMFL_(vm), \ - (*(_VM_(vm)->meth.freef))((vm),(Void_t*)(d)) ) + (*(_VM_(vm)->meth.freef))((vm),(void*)(d)) ) #define vmalign(vm,sz,align) (_VMFL_(vm), \ (*(_VM_(vm)->meth.alignf))((vm),(sz),(align)) ) #define malloc(s) (_VMFL_(Vmregion), malloc((size_t)(s)) ) -#define realloc(d,s) (_VMFL_(Vmregion), realloc((Void_t*)(d),(size_t)(s)) ) +#define realloc(d,s) (_VMFL_(Vmregion), realloc((void*)(d),(size_t)(s)) ) #define calloc(n,s) (_VMFL_(Vmregion), calloc((size_t)n, (size_t)(s)) ) -#define free(d) (_VMFL_(Vmregion), free((Void_t*)(d)) ) +#define free(d) (_VMFL_(Vmregion), free((void*)(d)) ) #define memalign(a,s) (_VMFL_(Vmregion), memalign((size_t)(a),(size_t)(s)) ) #define valloc(s) (_VMFL_(Vmregion), valloc((size_t)(s) ) #define cfree(d) free(d) @@ -200,16 +200,16 @@ extern "C" { #endif #ifndef vmresize #define vmresize(vm,d,sz,type) (*(_VM_(vm)->meth.resizef))\ - ((vm),(Void_t*)(d),(sz),(type)) + ((vm),(void*)(d),(sz),(type)) #endif #ifndef vmfree -#define vmfree(vm,d) (*(_VM_(vm)->meth.freef))((vm),(Void_t*)(d)) +#define vmfree(vm,d) (*(_VM_(vm)->meth.freef))((vm),(void*)(d)) #endif #ifndef vmalign #define vmalign(vm,sz,align) (*(_VM_(vm)->meth.alignf))((vm),(sz),(align)) #endif -#define vmaddr(vm,addr) (*(_VM_(vm)->meth.addrf))((vm),(Void_t*)(addr)) -#define vmsize(vm,addr) (*(_VM_(vm)->meth.sizef))((vm),(Void_t*)(addr)) +#define vmaddr(vm,addr) (*(_VM_(vm)->meth.addrf))((vm),(void*)(addr)) +#define vmsize(vm,addr) (*(_VM_(vm)->meth.sizef))((vm),(void*)(addr)) #define vmcompact(vm) (*(_VM_(vm)->meth.compactf))((vm)) #define vmoldof(v,p,t,n,x) (t*)vmresize((v), (p), sizeof(t)*(n)+(x), \ (VM_RSMOVE) ) diff --git a/lib/vmalloc/vmbest.c b/lib/vmalloc/vmbest.c index 92fb55328..f5ab6b9bb 100644 --- a/lib/vmalloc/vmbest.c +++ b/lib/vmalloc/vmbest.c @@ -485,7 +485,7 @@ static int bestreclaim(reg Vmdata_t * vd, Block_t * wanted, int c) * @param vm region allocating from * @param size desired block size */ -static Void_t *bestalloc(Vmalloc_t * vm, reg size_t size) +static void *bestalloc(Vmalloc_t * vm, reg size_t size) { reg Vmdata_t *vd = vm->data; reg size_t s; @@ -498,7 +498,7 @@ static Void_t *bestalloc(Vmalloc_t * vm, reg size_t size) if (!(local = vd->mode & VM_TRUST)) { GETLOCAL(vd, local); if (ISLOCK(vd, local)) - return NIL(Void_t *); + return NIL(void *); SETLOCK(vd, local); orgsize = size; } @@ -578,7 +578,7 @@ static Void_t *bestalloc(Vmalloc_t * vm, reg size_t size) vd->mode &= ~VM_AGAIN; else { CLRLOCK(vd, local); - return NIL(Void_t *); + return NIL(void *); } } @@ -627,7 +627,7 @@ static Void_t *bestalloc(Vmalloc_t * vm, reg size_t size) * @param vm region allocating from * @param addr address to check */ -static long bestaddr(Vmalloc_t * vm, Void_t * addr) +static long bestaddr(Vmalloc_t * vm, void * addr) { reg Seg_t *seg; reg Block_t *b, *endb; @@ -682,7 +682,7 @@ static long bestaddr(Vmalloc_t * vm, Void_t * addr) return offset; } -static int bestfree(Vmalloc_t * vm, Void_t * data) +static int bestfree(Vmalloc_t * vm, void * data) { reg Vmdata_t *vd = vm->data; reg Block_t *bp, **cache; @@ -738,7 +738,7 @@ static int bestfree(Vmalloc_t * vm, Void_t * data) * @param size new size * @param type !=0 to move, <0 for not copy */ -static Void_t *bestresize(Vmalloc_t * vm, Void_t * data, reg size_t size, +static void *bestresize(Vmalloc_t * vm, void * data, reg size_t size, int type) { reg Vmdata_t *vd = vm->data; @@ -746,7 +746,7 @@ static Void_t *bestresize(Vmalloc_t * vm, Void_t * data, reg size_t size, reg size_t s, bs; reg int local, *d, *ed; size_t oldsize = 0, orgsize = 0; - Void_t *orgdata; + void *orgdata; orgdata = 0; /**/ COUNT(N_resize); @@ -760,15 +760,15 @@ static Void_t *bestresize(Vmalloc_t * vm, Void_t * data, reg size_t size, } if (size == 0) { (void) bestfree(vm, data); - return NIL(Void_t *); + return NIL(void *); } if (!(local = vd->mode & VM_TRUST)) { GETLOCAL(vd, local); if (ISLOCK(vd, local)) - return NIL(Void_t *); + return NIL(void *); if (!local && KPVADDR(vm, data, bestaddr) != 0) - return NIL(Void_t *); + return NIL(void *); SETLOCK(vd, local); orgdata = data; /* for tracing */ @@ -841,7 +841,7 @@ static Void_t *bestresize(Vmalloc_t * vm, Void_t * data, reg size_t size, goto do_free; } else if (s < size) { if (!(type & (VM_RSMOVE | VM_RSCOPY))) /* see if old data is moveable */ - data = NIL(Void_t *); + data = NIL(void *); else { ed = (int *) data; if (size < ((s & ~BITS) + bs)) @@ -885,7 +885,7 @@ static Void_t *bestresize(Vmalloc_t * vm, Void_t * data, reg size_t size, * @param vm region allocating from * @param addr address to check */ -static long bestsize(Vmalloc_t * vm, Void_t * addr) +static long bestsize(Vmalloc_t * vm, void * addr) { reg Seg_t *seg; reg Block_t *b, *endb; @@ -991,7 +991,7 @@ static int bestcompact(Vmalloc_t * vm) return 0; } -static Void_t *bestalign(Vmalloc_t * vm, size_t size, size_t align) +static void *bestalign(Vmalloc_t * vm, size_t size, size_t align) { reg Vmuchar_t *data; reg Block_t *tp, *np; @@ -1001,12 +1001,12 @@ static Void_t *bestalign(Vmalloc_t * vm, size_t size, size_t align) reg Vmdata_t *vd = vm->data; if (size <= 0 || align <= 0) - return NIL(Void_t *); + return NIL(void *); if (!(local = vd->mode & VM_TRUST)) { GETLOCAL(vd, local); if (ISLOCK(vd, local)) - return NIL(Void_t *); + return NIL(void *); SETLOCK(vd, local); orgsize = size; orgalign = align; @@ -1081,7 +1081,7 @@ static Void_t *bestalign(Vmalloc_t * vm, size_t size, size_t align) /**/ ASSERT(!vd->root || vmchktree(vd->root)); - return (Void_t *) data; + return (void *) data; } /* A discipline to get memory using sbrk() or VirtualAlloc on win32 */ @@ -1092,7 +1092,7 @@ static Void_t *bestalign(Vmalloc_t * vm, size_t size, size_t align) * @param nsize new size * @param disc discipline structure */ -static Void_t *sbrkmem(Vmalloc_t * vm, Void_t * caddr, +static void *sbrkmem(Vmalloc_t * vm, void * caddr, size_t csize, size_t nsize, Vmdisc_t * disc) { #if _std_malloc || _BLD_INSTRUMENT || cray @@ -1100,23 +1100,23 @@ static Void_t *sbrkmem(Vmalloc_t * vm, Void_t * caddr, NOTUSED(disc); if (csize == 0) - return (Void_t *) malloc(nsize); + return (void *) malloc(nsize); if (nsize == 0) free(caddr); - return NIL(Void_t *); + return NIL(void *); #else #if defined(_WIN32) NOTUSED(vm); NOTUSED(disc); if (csize == 0) - return (Void_t *) VirtualAlloc(NIL(LPVOID), nsize, MEM_COMMIT, + return (void *) VirtualAlloc(NIL(LPVOID), nsize, MEM_COMMIT, PAGE_READWRITE); else if (nsize == 0) return VirtualFree((LPVOID) caddr, 0, - MEM_RELEASE) ? caddr : NIL(Void_t *); + MEM_RELEASE) ? caddr : NIL(void *); else - return NIL(Void_t *); + return NIL(void *); #else reg Vmuchar_t *addr; reg ssize_t size; @@ -1125,7 +1125,7 @@ static Void_t *sbrkmem(Vmalloc_t * vm, Void_t * caddr, /* sbrk, see if still own current address */ if (csize > 0 && sbrk(0) != (Vmuchar_t *) caddr + csize) - return NIL(Void_t *); + return NIL(void *); /* do this because sbrk() uses 'ssize_t' argument */ size = @@ -1133,9 +1133,9 @@ static Void_t *sbrkmem(Vmalloc_t * vm, Void_t * caddr, csize ? (ssize_t) (nsize - csize) : -(ssize_t) (csize - nsize); if ((addr = sbrk(size)) == (Vmuchar_t *) (-1)) - return NIL(Void_t *); + return NIL(void *); else - return csize == 0 ? (Void_t *) addr : caddr; + return csize == 0 ? (void *) addr : caddr; #endif #endif } diff --git a/lib/vmalloc/vmclose.c b/lib/vmalloc/vmclose.c index 673dc805e..439e37436 100644 --- a/lib/vmalloc/vmclose.c +++ b/lib/vmalloc/vmclose.c @@ -31,7 +31,7 @@ int vmclose(Vmalloc_t * vm) return -1; if (vm->disc->exceptf && - (*vm->disc->exceptf) (vm, VM_CLOSE, NIL(Void_t *), vm->disc) < 0) + (*vm->disc->exceptf) (vm, VM_CLOSE, NIL(void *), vm->disc) < 0) return -1; /* make this region inaccessible until it disappears */ diff --git a/lib/vmalloc/vmdcheap.c b/lib/vmalloc/vmdcheap.c index 1bf1f0cad..c1d52e75c 100644 --- a/lib/vmalloc/vmdcheap.c +++ b/lib/vmalloc/vmdcheap.c @@ -24,7 +24,7 @@ * @param nsize new size * @param disc discipline structure */ -static Void_t *heapmem(Vmalloc_t * vm, Void_t * caddr, +static void *heapmem(Vmalloc_t * vm, void * caddr, size_t csize, size_t nsize, Vmdisc_t * disc) { NOTUSED(vm); @@ -33,7 +33,7 @@ static Void_t *heapmem(Vmalloc_t * vm, Void_t * caddr, if (csize == 0) return vmalloc(Vmheap, nsize); else if (nsize == 0) - return vmfree(Vmheap, caddr) >= 0 ? caddr : NIL(Void_t *); + return vmfree(Vmheap, caddr) >= 0 ? caddr : NIL(void *); else return vmresize(Vmheap, caddr, nsize, 0); } diff --git a/lib/vmalloc/vmdebug.c b/lib/vmalloc/vmdebug.c index 05d36594a..561f02c25 100644 --- a/lib/vmalloc/vmdebug.c +++ b/lib/vmalloc/vmdebug.c @@ -43,7 +43,7 @@ static Dbfile_t *Dbfile; /* global watch list */ #define S_WATCH 32 static int Dbnwatch; -static Void_t *Dbwatch[S_WATCH]; +static void *Dbwatch[S_WATCH]; /* types of warnings reported by dbwarn() */ #define DB_CHECK 0 @@ -81,7 +81,7 @@ static void vmdbwarn(Vmalloc_t * vm, char *mesg, int n) * @param line line number of call * @param type operation being done */ -static void dbwarn(Vmalloc_t * vm, Void_t * data, int where, char *file, +static void dbwarn(Vmalloc_t * vm, void * data, int where, char *file, int line, int type) { char buf[1024], *bufp, *endbuf, *s; @@ -168,7 +168,7 @@ static void dbwarn(Vmalloc_t * vm, Void_t * data, int where, char *file, } /* check for watched address and issue warnings */ -static void dbwatch(Vmalloc_t * vm, Void_t * data, char *file, int line, +static void dbwatch(Vmalloc_t * vm, void * data, char *file, int line, int type) { reg int n; @@ -234,7 +234,7 @@ static void dbsetinfo(Vmuchar_t * data, size_t size, char *file, int line) ** This returns -(offset+1) if block is already freed, +(offset+1) ** if block is live, 0 if no match. */ -static long dbaddr(Vmalloc_t * vm, Void_t * addr) +static long dbaddr(Vmalloc_t * vm, void * addr) { reg Block_t *b = NULL, *endb = NULL; reg Seg_t *seg; @@ -291,7 +291,7 @@ static long dbaddr(Vmalloc_t * vm, Void_t * addr) } -static long dbsize(Vmalloc_t * vm, Void_t * addr) +static long dbsize(Vmalloc_t * vm, void * addr) { reg Block_t *b, *endb; reg Seg_t *seg; @@ -310,7 +310,7 @@ static long dbsize(Vmalloc_t * vm, Void_t * addr) (Vmuchar_t *) addr >= (Vmuchar_t *) endb) continue; while (b < endb) { - if (addr == (Void_t *) DB2DEBUG(DATA(b))) { + if (addr == (void *) DB2DEBUG(DATA(b))) { if (ISBUSY(SIZE(b)) && !ISJUNK(SIZE(b))) size = (long) DBSIZE(addr); goto done; @@ -324,7 +324,7 @@ static long dbsize(Vmalloc_t * vm, Void_t * addr) return size; } -static Void_t *dballoc(Vmalloc_t * vm, size_t size) +static void *dballoc(Vmalloc_t * vm, size_t size) { reg size_t s; reg Vmuchar_t *data; @@ -336,7 +336,7 @@ static Void_t *dballoc(Vmalloc_t * vm, size_t size) if (ISLOCK(vd, 0)) { dbwarn(vm, NIL(Vmuchar_t *), 0, file, line, DB_ALLOC); - return NIL(Void_t *); + return NIL(void *); } SETLOCK(vd, 0); @@ -366,11 +366,11 @@ static Void_t *dballoc(Vmalloc_t * vm, size_t size) done: CLRLOCK(vd, 0); - return (Void_t *) data; + return (void *) data; } -static int dbfree(Vmalloc_t * vm, Void_t * data) +static int dbfree(Vmalloc_t * vm, void * data) { char *file; int line; @@ -418,7 +418,7 @@ static int dbfree(Vmalloc_t * vm, Void_t * data) *ip++ = 0; CLRLOCK(vd, 0); - return (*(Vmbest->freef)) (vm, (Void_t *) DB2BEST(data)); + return (*(Vmbest->freef)) (vm, (void *) DB2BEST(data)); } /* Resizing an existing block */ @@ -428,7 +428,7 @@ static int dbfree(Vmalloc_t * vm, Void_t * data) * @param size new size * @param type !=0 for movable, >0 for copy */ -static Void_t *dbresize(Vmalloc_t * vm, Void_t * addr, reg size_t size, +static void *dbresize(Vmalloc_t * vm, void * addr, reg size_t size, int type) { reg Vmuchar_t *data; @@ -445,14 +445,14 @@ static Void_t *dbresize(Vmalloc_t * vm, Void_t * addr, reg size_t size, } if (size == 0) { (void) dbfree(vm, addr); - return NIL(Void_t *); + return NIL(void *); } VMFILELINE(vm, file, line); if (ISLOCK(vd, 0)) { dbwarn(vm, NIL(Vmuchar_t *), 0, file, line, DB_RESIZE); - return NIL(Void_t *); + return NIL(void *); } SETLOCK(vd, 0); @@ -465,7 +465,7 @@ static Void_t *dbresize(Vmalloc_t * vm, Void_t * addr, reg size_t size, dbwarn(vm, (Vmuchar_t *) addr, offset == -1L ? 0 : 1, file, line, DB_RESIZE); CLRLOCK(vd, 0); - return NIL(Void_t *); + return NIL(void *); } if (Dbnwatch > 0) @@ -481,7 +481,7 @@ static Void_t *dbresize(Vmalloc_t * vm, Void_t * addr, reg size_t size, s = ROUND(size, ALIGN) + DB_EXTRA; if (s < sizeof(Body_t)) s = sizeof(Body_t); - data = (Vmuchar_t *) KPVRESIZE(vm, (Void_t *) data, s, + data = (Vmuchar_t *) KPVRESIZE(vm, (void *) data, s, (type & ~VM_RSZERO), (*(Vmbest->resizef))); if (!data) { /* failed, reset data for old block */ @@ -508,7 +508,7 @@ static Void_t *dbresize(Vmalloc_t * vm, Void_t * addr, reg size_t size, *d++ = 0; } while (d < ed); } - return (Void_t *) data; + return (void *) data; } /* compact any residual free space */ @@ -574,12 +574,12 @@ int vmdbcheck(Vmalloc_t * vm) * * @param addr address to insert */ -Void_t *vmdbwatch(Void_t * addr) +void *vmdbwatch(void * addr) { reg int n; - reg Void_t *out; + reg void *out; - out = NIL(Void_t *); + out = NIL(void *); if (!addr) Dbnwatch = 0; else { @@ -600,7 +600,7 @@ Void_t *vmdbwatch(Void_t * addr) return out; } -static Void_t *dbalign(Vmalloc_t * vm, size_t size, size_t align) +static void *dbalign(Vmalloc_t * vm, size_t size, size_t align) { reg Vmuchar_t *data; reg size_t s; @@ -611,11 +611,11 @@ static Void_t *dbalign(Vmalloc_t * vm, size_t size, size_t align) VMFILELINE(vm, file, line); if (size <= 0 || align <= 0) - return NIL(Void_t *); + return NIL(void *); if (!(vd->mode & VM_TRUST)) { if (ISLOCK(vd, 0)) - return NIL(Void_t *); + return NIL(void *); SETLOCK(vd, 0); } @@ -637,7 +637,7 @@ static Void_t *dbalign(Vmalloc_t * vm, size_t size, size_t align) done: CLRLOCK(vd, 0); - return (Void_t *) data; + return (void *) data; } static Vmethod_t _Vmdebug = { diff --git a/lib/vmalloc/vmdisc.c b/lib/vmalloc/vmdisc.c index adfcd2fc7..c729b9177 100644 --- a/lib/vmalloc/vmdisc.c +++ b/lib/vmalloc/vmdisc.c @@ -27,7 +27,7 @@ Vmdisc_t *vmdisc(Vmalloc_t * vm, Vmdisc_t * disc) if (disc->memoryf != old->memoryf) return NIL(Vmdisc_t *); if (old->exceptf && - (*old->exceptf) (vm, VM_DISC, (Void_t *) disc, old) != 0) + (*old->exceptf) (vm, VM_DISC, (void *) disc, old) != 0) return NIL(Vmdisc_t *); vm->disc = disc; } diff --git a/lib/vmalloc/vmhdr.h b/lib/vmalloc/vmhdr.h index 909aec780..b8e8b97db 100644 --- a/lib/vmalloc/vmhdr.h +++ b/lib/vmalloc/vmhdr.h @@ -271,7 +271,7 @@ extern "C" { struct _seg_s { Vmalloc_t *vm; /* the region that holds this */ Seg_t *next; /* next segment */ - Void_t *addr; /* starting segment address */ + void *addr; /* starting segment address */ size_t extent; /* extent of segment */ Vmuchar_t *baddr; /* bottom of usable memory */ size_t size; /* allocable size */ @@ -292,7 +292,7 @@ extern "C" { #define RIGHT(b) ((b)->body.body.right) #define VM(b) (SEG(b)->vm) -#define DATA(b) ((Void_t*)((b)->body.data) ) +#define DATA(b) ((void*)((b)->body.data) ) #define BLOCK(d) ((Block_t*)((char*)(d) - sizeof(Head_t)) ) #define SELF(b) ((Block_t**)((b)->body.data + SIZE(b) - sizeof(Block_t*)) ) #define LAST(b) (*((Block_t**)(((char*)(b)) - sizeof(Block_t*)) ) ) @@ -388,7 +388,7 @@ extern "C" { /* clear and copy functions */ #define INTCOPY(to,fr,n) \ switch(n/sizeof(int)) \ - { default: memcpy((Void_t*)to,(Void_t*)fr,n); break; \ + { default: memcpy((void*)to,(void*)fr,n); break; \ case 7: *to++ = *fr++; \ case 6: *to++ = *fr++; \ case 5: *to++ = *fr++; \ @@ -399,7 +399,7 @@ extern "C" { } #define INTZERO(d,n) \ switch(n/sizeof(int)) \ - { default: memset((Void_t*)d,0,n); break; \ + { default: memset((void*)d,0,n); break; \ case 7: *d++ = 0; \ case 6: *d++ = 0; \ case 5: *d++ = 0; \ diff --git a/lib/vmalloc/vmlast.c b/lib/vmalloc/vmlast.c index c46757368..fa941b96a 100644 --- a/lib/vmalloc/vmlast.c +++ b/lib/vmalloc/vmlast.c @@ -18,7 +18,7 @@ ** Written by Kiem-Phong Vo, kpv@research.att.com, 01/16/94. */ -static Void_t *lastalloc(Vmalloc_t * vm, size_t size) +static void *lastalloc(Vmalloc_t * vm, size_t size) { reg Block_t *tp, *next; reg Seg_t *seg, *last; @@ -30,7 +30,7 @@ static Void_t *lastalloc(Vmalloc_t * vm, size_t size) if (!(local = vd->mode & VM_TRUST)) { GETLOCAL(vd, local); if (ISLOCK(vd, local)) - return NIL(Void_t *); + return NIL(void *); SETLOCK(vd, local); orgsize = size; } @@ -75,10 +75,10 @@ static Void_t *lastalloc(Vmalloc_t * vm, size_t size) done: CLRLOCK(vd, local); - return (Void_t *) tp; + return (void *) tp; } -static int lastfree(Vmalloc_t * vm, reg Void_t * data) +static int lastfree(Vmalloc_t * vm, reg void * data) { reg Seg_t *seg; reg Block_t *fp; @@ -93,7 +93,7 @@ static int lastfree(Vmalloc_t * vm, reg Void_t * data) return -1; SETLOCK(vd, 0); } - if (data != (Void_t *) vd->free) { + if (data != (void *) vd->free) { if (!local && vm->disc->exceptf) (void) (*vm->disc->exceptf) (vm, VM_BADADDR, data, vm->disc); CLRLOCK(vd, 0); @@ -122,7 +122,7 @@ static int lastfree(Vmalloc_t * vm, reg Void_t * data) return 0; } -static Void_t *lastresize(Vmalloc_t * vm, reg Void_t * data, size_t size, +static void *lastresize(Vmalloc_t * vm, reg void * data, size_t size, int type) { reg Block_t *tp; @@ -132,8 +132,8 @@ static Void_t *lastresize(Vmalloc_t * vm, reg Void_t * data, size_t size, reg ssize_t s, ds; reg Vmdata_t *vd = vm->data; reg int local; - reg Void_t *addr; - Void_t *orgdata = 0; + reg void *addr; + void *orgdata = 0; size_t orgsize = 0; if (!data) { @@ -143,27 +143,27 @@ static Void_t *lastresize(Vmalloc_t * vm, reg Void_t * data, size_t size, } if (size <= 0) { (void) lastfree(vm, data); - return NIL(Void_t *); + return NIL(void *); } if (!(local = vd->mode & VM_TRUST)) { if (ISLOCK(vd, 0)) - return NIL(Void_t *); + return NIL(void *); SETLOCK(vd, 0); orgdata = data; orgsize = size; } - if (data == (Void_t *) vd->free) + if (data == (void *) vd->free) seg = vd->seg; else { /* see if it was one of ours */ for (seg = vd->seg; seg; seg = seg->next) - if (data >= seg->addr && data < (Void_t *) seg->baddr) + if (data >= seg->addr && data < (void *) seg->baddr) break; if (!seg || (VLONG(data) % ALIGN) != 0 || (seg->last && (Vmuchar_t *) data > (Vmuchar_t *) seg->last)) { CLRLOCK(vd, 0); - return NIL(Void_t *); + return NIL(void *); } } @@ -202,12 +202,12 @@ static Void_t *lastresize(Vmalloc_t * vm, reg Void_t * data, size_t size, } else { do_alloc: if (!(type & (VM_RSMOVE | VM_RSCOPY))) - data = NIL(Void_t *); + data = NIL(void *); else { tp = vd->free; if (!(addr = KPVALLOC(vm, size, lastalloc))) { vd->free = tp; - data = NIL(Void_t *); + data = NIL(void *); } else { if (type & VM_RSCOPY) { ed = (int *) data; @@ -261,26 +261,26 @@ static Void_t *lastresize(Vmalloc_t * vm, reg Void_t * data, size_t size, } -static long lastaddr(Vmalloc_t * vm, Void_t * addr) +static long lastaddr(Vmalloc_t * vm, void * addr) { reg Vmdata_t *vd = vm->data; if (!(vd->mode & VM_TRUST) && ISLOCK(vd, 0)) return -1L; - if (!vd->free || addr < (Void_t *) vd->free - || addr >= (Void_t *) vd->seg->baddr) + if (!vd->free || addr < (void *) vd->free + || addr >= (void *) vd->seg->baddr) return -1L; else return (Vmuchar_t *) addr - (Vmuchar_t *) vd->free; } -static long lastsize(Vmalloc_t * vm, Void_t * addr) +static long lastsize(Vmalloc_t * vm, void * addr) { reg Vmdata_t *vd = vm->data; if (!(vd->mode & VM_TRUST) && ISLOCK(vd, 0)) return -1L; - if (!vd->free || addr != (Void_t *) vd->free) + if (!vd->free || addr != (void *) vd->free) return -1L; else if (vd->seg->free) return (Vmuchar_t *) vd->seg->free - (Vmuchar_t *) addr; @@ -325,7 +325,7 @@ static int lastcompact(Vmalloc_t * vm) return 0; } -static Void_t *lastalign(Vmalloc_t * vm, size_t size, size_t align) +static void *lastalign(Vmalloc_t * vm, size_t size, size_t align) { reg Vmuchar_t *data; reg size_t s, orgsize = 0, orgalign = 0; @@ -335,12 +335,12 @@ static Void_t *lastalign(Vmalloc_t * vm, size_t size, size_t align) reg Vmdata_t *vd = vm->data; if (size <= 0 || align <= 0) - return NIL(Void_t *); + return NIL(void *); if (!(local = vd->mode & VM_TRUST)) { GETLOCAL(vd, local); if (ISLOCK(vd, local)) - return NIL(Void_t *); + return NIL(void *); SETLOCK(vd, local); orgsize = size; orgalign = align; @@ -381,7 +381,7 @@ static Void_t *lastalign(Vmalloc_t * vm, size_t size, size_t align) done: CLRLOCK(vd, local); - return (Void_t *) data; + return (void *) data; } /* Public method for free-1 allocation */ diff --git a/lib/vmalloc/vmopen.c b/lib/vmalloc/vmopen.c index bec6f1f71..97c7ffbdf 100644 --- a/lib/vmalloc/vmopen.c +++ b/lib/vmalloc/vmopen.c @@ -62,7 +62,7 @@ Vmalloc_t *vmopen(Vmdisc_t * disc, Vmethod_t * meth, int mode) if (disc->exceptf) { addr = NIL(Vmuchar_t *); if ((e = - (*disc->exceptf) (vm, VM_OPEN, (Void_t *) (&addr), + (*disc->exceptf) (vm, VM_OPEN, (void *) (&addr), disc)) != 0) { if (e < 0 || !addr) goto open_error; @@ -90,7 +90,7 @@ Vmalloc_t *vmopen(Vmdisc_t * disc, Vmethod_t * meth, int mode) /* get space for region data */ s = ROUND(sizeof(Vminit_t), incr); - if (!(addr = (Vmuchar_t *) (*memoryf) (vm, NIL(Void_t *), 0, s, disc))) { + if (!(addr = (Vmuchar_t *) (*memoryf) (vm, NIL(void *), 0, s, disc))) { vmfree(Vmheap, vm); return NIL(Vmalloc_t *); } @@ -125,7 +125,7 @@ Vmalloc_t *vmopen(Vmdisc_t * disc, Vmethod_t * meth, int mode) seg = vd->seg; seg->next = NIL(Seg_t *); seg->vm = vm; - seg->addr = (Void_t *) (addr - (a ? ALIGN - a : 0)); + seg->addr = (void *) (addr - (a ? ALIGN - a : 0)); seg->extent = s; seg->baddr = addr + s - (a ? ALIGN : 0); seg->size = s; /* this size is larger than usual so that the segment diff --git a/lib/vmalloc/vmpool.c b/lib/vmalloc/vmpool.c index 09e6c2077..e0b1c9b33 100644 --- a/lib/vmalloc/vmpool.c +++ b/lib/vmalloc/vmpool.c @@ -24,7 +24,7 @@ ** Written by Kiem-Phong Vo, kpv@research.att.com, 01/16/94. */ -static Void_t *poolalloc(Vmalloc_t * vm, reg size_t size) +static void *poolalloc(Vmalloc_t * vm, reg size_t size) { reg Vmdata_t *vd = vm->data; reg Block_t *tp, *next; @@ -33,17 +33,17 @@ static Void_t *poolalloc(Vmalloc_t * vm, reg size_t size) reg int local; if (size <= 0) - return NIL(Void_t *); + return NIL(void *); else if (size != vd->pool) { if (vd->pool <= 0) vd->pool = size; else - return NIL(Void_t *); + return NIL(void *); } if (!(local = vd->mode & VM_TRUST)) { if (ISLOCK(vd, 0)) - return NIL(Void_t *); + return NIL(void *); SETLOCK(vd, 0); } @@ -94,10 +94,10 @@ static Void_t *poolalloc(Vmalloc_t * vm, reg size_t size) (*_Vmtrace) (vm, NIL(Vmuchar_t *), (Vmuchar_t *) tp, vd->pool, 0); CLRLOCK(vd, 0); - return (Void_t *) tp; + return (void *) tp; } -static long pooladdr(Vmalloc_t * vm, reg Void_t * addr) +static long pooladdr(Vmalloc_t * vm, reg void * addr) { reg Block_t *bp, *tp; reg Vmuchar_t *laddr, *baddr; @@ -141,7 +141,7 @@ static long pooladdr(Vmalloc_t * vm, reg Void_t * addr) return offset; } -static int poolfree(reg Vmalloc_t * vm, reg Void_t * data) +static int poolfree(reg Vmalloc_t * vm, reg void * data) { reg Block_t *bp; reg Vmdata_t *vd = vm->data; @@ -177,7 +177,7 @@ static int poolfree(reg Vmalloc_t * vm, reg Void_t * data) return 0; } -static Void_t *poolresize(Vmalloc_t * vm, Void_t * data, size_t size, +static void *poolresize(Vmalloc_t * vm, void * data, size_t size, int type) { reg Vmdata_t *vd = vm->data; @@ -196,18 +196,18 @@ static Void_t *poolresize(Vmalloc_t * vm, Void_t * data, size_t size, } if (size == 0) { (void) poolfree(vm, data); - return NIL(Void_t *); + return NIL(void *); } if (!(vd->mode & VM_TRUST)) { if (ISLOCK(vd, 0)) - return NIL(Void_t *); + return NIL(void *); if (size != vd->pool || KPVADDR(vm, data, pooladdr) != 0) { if (vm->disc->exceptf) (void) (*vm->disc->exceptf) (vm, VM_BADADDR, data, vm->disc); - return NIL(Void_t *); + return NIL(void *); } if ((vd->mode & VM_TRACE) && _Vmtrace) @@ -218,7 +218,7 @@ static Void_t *poolresize(Vmalloc_t * vm, Void_t * data, size_t size, return data; } -static long poolsize(Vmalloc_t * vm, Void_t * addr) +static long poolsize(Vmalloc_t * vm, void * addr) { return pooladdr(vm, addr) == 0 ? (long) vm->data->pool : -1L; } @@ -259,12 +259,12 @@ static int poolcompact(Vmalloc_t * vm) return 0; } -static Void_t *poolalign(Vmalloc_t * vm, size_t size, size_t align) +static void *poolalign(Vmalloc_t * vm, size_t size, size_t align) { NOTUSED(vm); NOTUSED(size); NOTUSED(align); - return NIL(Void_t *); + return NIL(void *); } /* Public interface */ diff --git a/lib/vmalloc/vmprivate.c b/lib/vmalloc/vmprivate.c index 33f675e56..5cb14dc4d 100644 --- a/lib/vmalloc/vmprivate.c +++ b/lib/vmalloc/vmprivate.c @@ -78,7 +78,7 @@ static Block_t *vmextend(reg Vmalloc_t * vm, size_t size, while (!addr) { /* try to get space */ if ((addr = - (Vmuchar_t *) (*memoryf) (vm, NIL(Void_t *), 0, size, + (Vmuchar_t *) (*memoryf) (vm, NIL(void *), 0, size, vm->disc))) break; @@ -89,7 +89,7 @@ static Block_t *vmextend(reg Vmalloc_t * vm, size_t size, int rv, lock; lock = vd->mode & VM_LOCK; vd->mode &= ~VM_LOCK; - rv = (*exceptf) (vm, VM_NOMEM, (Void_t *) size, vm->disc); + rv = (*exceptf) (vm, VM_NOMEM, (void *) size, vm->disc); vd->mode |= lock; if (rv <= 0) { if (rv == 0) @@ -136,7 +136,7 @@ static Block_t *vmextend(reg Vmalloc_t * vm, size_t size, seg = (Seg_t *) addr; seg->vm = vm; - seg->addr = (Void_t *) (addr - (s ? ALIGN - s : 0)); + seg->addr = (void *) (addr - (s ? ALIGN - s : 0)); seg->extent = size; seg->baddr = addr + size - (s ? 2 * ALIGN : 0); seg->free = NIL(Block_t *); @@ -194,7 +194,7 @@ static Block_t *vmextend(reg Vmalloc_t * vm, size_t size, */ static int vmtruncate(Vmalloc_t * vm, Seg_t * seg, size_t size, int exact) { - reg Void_t *caddr; + reg void *caddr; reg Seg_t *last; reg Vmdata_t *vd = vm->data; reg Vmemory_f memoryf = vm->disc->memoryf; diff --git a/lib/vmalloc/vmprofile.c b/lib/vmalloc/vmprofile.c index 38dd357c1..5bc9db8ed 100644 --- a/lib/vmalloc/vmprofile.c +++ b/lib/vmalloc/vmprofile.c @@ -414,17 +414,17 @@ int vmprofile(Vmalloc_t * vm, int fd) return 0; } -static Void_t *pfalloc(Vmalloc_t * vm, size_t size) +static void *pfalloc(Vmalloc_t * vm, size_t size) { reg size_t s; - reg Void_t *data; + reg void *data; reg char *file; reg int line; reg Vmdata_t *vd = vm->data; VMFILELINE(vm, file, line); if (!(vd->mode & VM_TRUST) && ISLOCK(vd, 0)) - return NIL(Void_t *); + return NIL(void *); SETLOCK(vd, 0); s = ROUND(size, ALIGN) + PF_EXTRA; @@ -443,7 +443,7 @@ static Void_t *pfalloc(Vmalloc_t * vm, size_t size) return data; } -static int pffree(Vmalloc_t * vm, Void_t * data) +static int pffree(Vmalloc_t * vm, void * data) { reg Pfobj_t *pf; reg size_t s; @@ -489,12 +489,12 @@ static int pffree(Vmalloc_t * vm, Void_t * data) return (*(Vmbest->freef)) (vm, data); } -static Void_t *pfresize(Vmalloc_t * vm, Void_t * data, size_t size, +static void *pfresize(Vmalloc_t * vm, void * data, size_t size, int type) { reg Pfobj_t *pf; reg size_t s, news; - reg Void_t *addr; + reg void *addr; reg char *file; reg int line; reg size_t oldsize; @@ -507,13 +507,13 @@ static Void_t *pfresize(Vmalloc_t * vm, Void_t * data, size_t size, } if (size == 0) { (void) pffree(vm, data); - return NIL(Void_t *); + return NIL(void *); } VMFILELINE(vm, file, line); if (!(vd->mode & VM_TRUST)) { if (ISLOCK(vd, 0)) - return NIL(Void_t *); + return NIL(void *); SETLOCK(vd, 0); } @@ -521,7 +521,7 @@ static Void_t *pfresize(Vmalloc_t * vm, Void_t * data, size_t size, if (vm->disc->exceptf) (void) (*vm->disc->exceptf) (vm, VM_BADADDR, data, vm->disc); CLRLOCK(vd, 0); - return NIL(Void_t *); + return NIL(void *); } pf = PFOBJ(data); @@ -570,12 +570,12 @@ static Void_t *pfresize(Vmalloc_t * vm, Void_t * data, size_t size, return addr; } -static long pfsize(Vmalloc_t * vm, Void_t * addr) +static long pfsize(Vmalloc_t * vm, void * addr) { return (*Vmbest->addrf) (vm, addr) != 0 ? -1L : (long) PFSIZE(addr); } -static long pfaddr(Vmalloc_t * vm, Void_t * addr) +static long pfaddr(Vmalloc_t * vm, void * addr) { return (*Vmbest->addrf) (vm, addr); } @@ -585,10 +585,10 @@ static int pfcompact(Vmalloc_t * vm) return (*Vmbest->compactf) (vm); } -static Void_t *pfalign(Vmalloc_t * vm, size_t size, size_t align) +static void *pfalign(Vmalloc_t * vm, size_t size, size_t align) { reg size_t s; - reg Void_t *data; + reg void *data; reg char *file; reg int line; reg Vmdata_t *vd = vm->data; @@ -596,7 +596,7 @@ static Void_t *pfalign(Vmalloc_t * vm, size_t size, size_t align) VMFILELINE(vm, file, line); if (!(vd->mode & VM_TRUST) && ISLOCK(vd, 0)) - return NIL(Void_t *); + return NIL(void *); SETLOCK(vd, 0); s = (size <= TINYSIZE ? TINYSIZE : ROUND(size, ALIGN)) + PF_EXTRA; diff --git a/lib/vmalloc/vmregion.c b/lib/vmalloc/vmregion.c index 1f7d8c46a..82da03799 100644 --- a/lib/vmalloc/vmregion.c +++ b/lib/vmalloc/vmregion.c @@ -18,7 +18,7 @@ ** ** Written by Kiem-Phong Vo, kpv@research.att.com, 01/16/94. */ -Vmalloc_t *vmregion(reg Void_t * addr) +Vmalloc_t *vmregion(reg void * addr) { return addr ? VM(BLOCK(addr)) : NIL(Vmalloc_t *); } diff --git a/lib/vmalloc/vmsegment.c b/lib/vmalloc/vmsegment.c index 8e11db263..4debe1f20 100644 --- a/lib/vmalloc/vmsegment.c +++ b/lib/vmalloc/vmsegment.c @@ -22,14 +22,14 @@ * @param vm region * @param addr address */ -Void_t *vmsegment(Vmalloc_t * vm, Void_t * addr) +void *vmsegment(Vmalloc_t * vm, void * addr) { reg Seg_t *seg; reg Vmdata_t *vd = vm->data; if (!(vd->mode & VM_TRUST)) { if (ISLOCK(vd, 0)) - return NIL(Void_t *); + return NIL(void *); SETLOCK(vd, 0); } @@ -39,5 +39,5 @@ Void_t *vmsegment(Vmalloc_t * vm, Void_t * addr) break; CLRLOCK(vd, 0); - return seg ? (Void_t *) seg->addr : NIL(Void_t *); + return seg ? (void *) seg->addr : NIL(void *); } diff --git a/lib/vmalloc/vmwalk.c b/lib/vmalloc/vmwalk.c index a07dbce25..54b0ace89 100644 --- a/lib/vmalloc/vmwalk.c +++ b/lib/vmalloc/vmwalk.c @@ -19,7 +19,7 @@ */ int vmwalk(Vmalloc_t * vm, - int (*segf) (Vmalloc_t *, Void_t *, size_t, Vmdisc_t *)) + int (*segf) (Vmalloc_t *, void *, size_t, Vmdisc_t *)) { reg Seg_t *seg; reg int rv; diff --git a/windows/include/ast_common.h b/windows/include/ast_common.h index 6d552f6a9..d521988e5 100644 --- a/windows/include/ast_common.h +++ b/windows/include/ast_common.h @@ -64,11 +64,6 @@ #define __INLINE__ __inline #endif -/* Void_t is defined so that Void_t* can address any type */ -#ifndef Void_t -#define Void_t void -#endif /*Void_t */ - /* dynamic linked library external scope handling */ #undef extern #if defined(_dll_import) && !defined(__EXPORT__) && defined(_DLL_BLD)