Change (interal) function signature of TclpAlloc/TclpRealloc/TclpFree, using (void *) in stead of (char *)

5 files changed, 43 insertions, 43 deletions

diff --git a/generic/tclAlloc.c b/generic/tclAlloc.c
index 0c0ab7b..c1e7b28 100644
--- a/generic/tclAlloc.c
+++ b/generic/tclAlloc.c
@@ -249,7 +249,7 @@ TclFinalizeAllocSubsystem(void)
  *----------------------------------------------------------------------
  */
 
-char *
+void *
 TclpAlloc(
     unsigned int numBytes)	/* Number of bytes to allocate. */
 {
@@ -446,7 +446,7 @@ MoreCore(
 
 void
 TclpFree(
-    char *oldPtr)		/* Pointer to memory to free. */
+    void *oldPtr)		/* Pointer to memory to free. */
 {
     size_t size;
     union overhead *overPtr;
@@ -509,9 +509,9 @@ TclpFree(
  *----------------------------------------------------------------------
  */
 
-char *
+void *
 TclpRealloc(
-    char *oldPtr,		/* Pointer to alloced block. */
+    void *oldPtr,		/* Pointer to alloced block. */
     unsigned int numBytes)	/* New size of memory. */
 {
     int i;
@@ -581,7 +581,7 @@ TclpRealloc(
 #endif
 
 	Tcl_MutexUnlock(allocMutexPtr);
-	return (char *)(overPtr+1);
+	return (void *)(overPtr+1);
     }
     maxSize = 1 << (i+3);
     expensive = 0;
@@ -592,7 +592,7 @@ TclpRealloc(
     }
 
     if (expensive) {
-	char *newPtr;
+	void *newPtr;
 
 	Tcl_MutexUnlock(allocMutexPtr);
 
@@ -692,11 +692,11 @@ mstats(
  *----------------------------------------------------------------------
  */
 
-char *
+void *
 TclpAlloc(
     unsigned int numBytes)	/* Number of bytes to allocate. */
 {
-    return (char *) malloc(numBytes);
+    return malloc(numBytes);
 }
 
 /*
@@ -717,7 +717,7 @@ TclpAlloc(
 
 void
 TclpFree(
-    char *oldPtr)		/* Pointer to memory to free. */
+    void *oldPtr)		/* Pointer to memory to free. */
 {
     free(oldPtr);
     return;
@@ -739,12 +739,12 @@ TclpFree(
  *----------------------------------------------------------------------
  */
 
-char *
+void *
 TclpRealloc(
-    char *oldPtr,		/* Pointer to alloced block. */
+    void *oldPtr,		/* Pointer to alloced block. */
     unsigned int numBytes)	/* New size of memory. */
 {
-    return (char *) realloc(oldPtr, numBytes);
+    return realloc(oldPtr, numBytes);
 }
 
 #endif /* !USE_TCLALLOC */
diff --git a/generic/tclCkalloc.c b/generic/tclCkalloc.c
index c1ff631..0092c83 100644
--- a/generic/tclCkalloc.c
+++ b/generic/tclCkalloc.c
@@ -633,7 +633,7 @@ Tcl_DbCkfree(
 
     if (memp->tagPtr != NULL) {
 	if ((memp->tagPtr->refCount-- <= 1) && (curTagPtr != memp->tagPtr)) {
-	    TclpFree((char *) memp->tagPtr);
+	    TclpFree(memp->tagPtr);
 	}
     }
 
@@ -650,7 +650,7 @@ Tcl_DbCkfree(
     if (allocHead == memp) {
 	allocHead = memp->flink;
     }
-    TclpFree((char *) memp);
+    TclpFree(memp);
     Tcl_MutexUnlock(ckallocMutexPtr);
 }
 
@@ -914,7 +914,7 @@ MemoryCmd(
 	    return TCL_ERROR;
 	}
 	if ((curTagPtr != NULL) && (curTagPtr->refCount == 0)) {
-	    TclpFree((char *) curTagPtr);
+	    TclpFree(curTagPtr);
 	}
 	len = strlen(TclGetString(objv[2]));
 	curTagPtr = (MemTag *) TclpAlloc(TAG_SIZE(len));
@@ -1052,7 +1052,7 @@ char *
 Tcl_Alloc(
     unsigned int size)
 {
-    char *result = TclpAlloc(size);
+    char *result = (char *)TclpAlloc(size);
 
     /*
      * Most systems will not alloc(0), instead bumping it to one so that NULL
@@ -1076,7 +1076,7 @@ Tcl_DbCkalloc(
     const char *file,
     int line)
 {
-    char *result = TclpAlloc(size);
+    char *result = (char *)TclpAlloc(size);
 
     if ((result == NULL) && size) {
 	fflush(stdout);
@@ -1100,7 +1100,7 @@ char *
 Tcl_AttemptAlloc(
     unsigned int size)
 {
-    return TclpAlloc(size);
+    return (char *)TclpAlloc(size);
 }
 
 char *
@@ -1109,7 +1109,7 @@ Tcl_AttemptDbCkalloc(
     TCL_UNUSED(const char *) /*file*/,
     TCL_UNUSED(int) /*line*/)
 {
-    return TclpAlloc(size);
+    return (char *)TclpAlloc(size);
 }
 
 /*
@@ -1128,7 +1128,7 @@ Tcl_Realloc(
     char *ptr,
     unsigned int size)
 {
-    char *result = TclpRealloc(ptr, size);
+    char *result = (char *)TclpRealloc(ptr, size);
 
     if ((result == NULL) && size) {
 	Tcl_Panic("unable to realloc %u bytes", size);
@@ -1143,7 +1143,7 @@ Tcl_DbCkrealloc(
     const char *file,
     int line)
 {
-    char *result = TclpRealloc(ptr, size);
+    char *result = (char *)TclpRealloc(ptr, size);
 
     if ((result == NULL) && size) {
 	fflush(stdout);
@@ -1168,7 +1168,7 @@ Tcl_AttemptRealloc(
     char *ptr,
     unsigned int size)
 {
-    return TclpRealloc(ptr, size);
+    return (char *)TclpRealloc(ptr, size);
 }
 
 char *
@@ -1178,7 +1178,7 @@ Tcl_AttemptDbCkrealloc(
     TCL_UNUSED(const char *) /*file*/,
     TCL_UNUSED(int) /*line*/)
 {
-    return TclpRealloc(ptr, size);
+    return (char *)TclpRealloc(ptr, size);
 }
 
 /*
@@ -1282,7 +1282,7 @@ TclFinalizeMemorySubsystem(void)
     Tcl_MutexLock(ckallocMutexPtr);
 
     if (curTagPtr != NULL) {
-	TclpFree((char *) curTagPtr);
+	TclpFree(curTagPtr);
 	curTagPtr = NULL;
     }
     allocHead = NULL;
diff --git a/generic/tclInt.decls b/generic/tclInt.decls
index ec6b77f..5640fab 100644
--- a/generic/tclInt.decls
+++ b/generic/tclInt.decls
@@ -289,7 +289,7 @@ declare 64 {
 #    int TclpAccess(const char *path, int mode)
 #}
 declare 69 {
-    char *TclpAlloc(unsigned int size)
+    void *TclpAlloc(unsigned int size)
 }
 #declare 70 {
 #    int TclpCopyFile(const char *source, const char *dest)
@@ -305,7 +305,7 @@ declare 69 {
 #    int TclpDeleteFile(const char *path)
 #}
 declare 74 {
-    void TclpFree(char *ptr)
+    void TclpFree(void *ptr)
 }
 declare 75 {
     unsigned long TclpGetClicks(void)
@@ -330,7 +330,7 @@ declare 77 {deprecated {}} {
 #	    char *modeString, int permissions)
 #}
 declare 81 {
-    char *TclpRealloc(char *ptr, unsigned int size)
+    void *TclpRealloc(void *ptr, unsigned int size)
 }
 #declare 82 {
 #    int TclpRemoveDirectory(const char *path, int recursive,
diff --git a/generic/tclIntDecls.h b/generic/tclIntDecls.h
index d3941fd..8ba0c4c 100644
--- a/generic/tclIntDecls.h
+++ b/generic/tclIntDecls.h
@@ -208,13 +208,13 @@ EXTERN int		TclObjInvoke(Tcl_Interp *interp, int objc,
 /* Slot 67 is reserved */
 /* Slot 68 is reserved */
 /* 69 */
-EXTERN char *		TclpAlloc(unsigned int size);
+EXTERN void *		TclpAlloc(unsigned int size);
 /* Slot 70 is reserved */
 /* Slot 71 is reserved */
 /* Slot 72 is reserved */
 /* Slot 73 is reserved */
 /* 74 */
-EXTERN void		TclpFree(char *ptr);
+EXTERN void		TclpFree(void *ptr);
 /* 75 */
 EXTERN unsigned long	TclpGetClicks(void);
 /* 76 */
@@ -226,7 +226,7 @@ void			TclpGetTime(Tcl_Time *time);
 /* Slot 79 is reserved */
 /* Slot 80 is reserved */
 /* 81 */
-EXTERN char *		TclpRealloc(char *ptr, unsigned int size);
+EXTERN void *		TclpRealloc(void *ptr, unsigned int size);
 /* Slot 82 is reserved */
 /* Slot 83 is reserved */
 /* Slot 84 is reserved */
@@ -734,19 +734,19 @@ typedef struct TclIntStubs {
     void (*reserved66)(void);
     void (*reserved67)(void);
     void (*reserved68)(void);
-    char * (*tclpAlloc) (unsigned int size); /* 69 */
+    void * (*tclpAlloc) (unsigned int size); /* 69 */
     void (*reserved70)(void);
     void (*reserved71)(void);
     void (*reserved72)(void);
     void (*reserved73)(void);
-    void (*tclpFree) (char *ptr); /* 74 */
+    void (*tclpFree) (void *ptr); /* 74 */
     unsigned long (*tclpGetClicks) (void); /* 75 */
     unsigned long (*tclpGetSeconds) (void); /* 76 */
     TCL_DEPRECATED_API("") void (*tclpGetTime) (Tcl_Time *time); /* 77 */
     void (*reserved78)(void);
     void (*reserved79)(void);
     void (*reserved80)(void);
-    char * (*tclpRealloc) (char *ptr, unsigned int size); /* 81 */
+    void * (*tclpRealloc) (void *ptr, unsigned int size); /* 81 */
     void (*reserved82)(void);
     void (*reserved83)(void);
     void (*reserved84)(void);
diff --git a/generic/tclThreadAlloc.c b/generic/tclThreadAlloc.c
index df685eb..1248f5d 100644
--- a/generic/tclThreadAlloc.c
+++ b/generic/tclThreadAlloc.c
@@ -134,8 +134,8 @@ static void	LockBucket(Cache *cachePtr, int bucket);
 static void	UnlockBucket(Cache *cachePtr, int bucket);
 static void	PutBlocks(Cache *cachePtr, int bucket, int numMove);
 static int	GetBlocks(Cache *cachePtr, int bucket);
-static Block *	Ptr2Block(char *ptr);
-static char *	Block2Ptr(Block *blockPtr, int bucket, unsigned int reqSize);
+static Block *	Ptr2Block(void *ptr);
+static void *	Block2Ptr(Block *blockPtr, int bucket, unsigned int reqSize);
 static void	MoveObjs(Cache *fromPtr, Cache *toPtr, int numMove);
 static void	PutObjs(Cache *fromPtr, int numMove);
 
@@ -299,7 +299,7 @@ TclFreeAllocCache(
  *----------------------------------------------------------------------
  */
 
-char *
+void *
 TclpAlloc(
     unsigned int reqSize)
 {
@@ -378,7 +378,7 @@ TclpAlloc(
 
 void
 TclpFree(
-    char *ptr)
+    void *ptr)
 {
     Cache *cachePtr;
     Block *blockPtr;
@@ -435,9 +435,9 @@ TclpFree(
  *----------------------------------------------------------------------
  */
 
-char *
+void *
 TclpRealloc(
-    char *ptr,
+    void *ptr,
     unsigned int reqSize)
 {
     Cache *cachePtr;
@@ -510,7 +510,7 @@ TclpRealloc(
 	memcpy(newPtr, ptr, reqSize);
 	TclpFree(ptr);
     }
-    return (char *)newPtr;
+    return newPtr;
 }
 
 /*
@@ -804,7 +804,7 @@ PutObjs(
  *----------------------------------------------------------------------
  */
 
-static char *
+static void *
 Block2Ptr(
     Block *blockPtr,
     int bucket,
@@ -819,12 +819,12 @@ Block2Ptr(
 #if RCHECK
     ((unsigned char *)(ptr))[reqSize] = MAGIC;
 #endif
-    return (char *) ptr;
+    return ptr;
 }
 
 static Block *
 Ptr2Block(
-    char *ptr)
+    void *ptr)
 {
     Block *blockPtr;