Remove casts from uses of ckalloc/ckfree/... now that Tcl declares them to be

using useful casts internally.

1 files changed, 78 insertions, 91 deletions

diff --git a/generic/tkTextBTree.c b/generic/tkTextBTree.c
index cd1da60..ab529a7 100644
--- a/generic/tkTextBTree.c
+++ b/generic/tkTextBTree.c
@@ -275,9 +275,9 @@ TkBTreeCreate(
      * of the tree.
      */
 
-    rootPtr = (Node *) ckalloc(sizeof(Node));
-    linePtr = (TkTextLine *) ckalloc(sizeof(TkTextLine));
-    linePtr2 = (TkTextLine *) ckalloc(sizeof(TkTextLine));
+    rootPtr = ckalloc(sizeof(Node));
+    linePtr = ckalloc(sizeof(TkTextLine));
+    linePtr2 = ckalloc(sizeof(TkTextLine));
 
     rootPtr->parentPtr = NULL;
     rootPtr->nextPtr = NULL;
@@ -298,7 +298,7 @@ TkBTreeCreate(
 
     linePtr->parentPtr = rootPtr;
     linePtr->nextPtr = linePtr2;
-    segPtr = (TkTextSegment *) ckalloc(CSEG_SIZE(1));
+    segPtr = ckalloc(CSEG_SIZE(1));
     linePtr->segPtr = segPtr;
     segPtr->typePtr = &tkTextCharType;
     segPtr->nextPtr = NULL;
@@ -308,7 +308,7 @@ TkBTreeCreate(
 
     linePtr2->parentPtr = rootPtr;
     linePtr2->nextPtr = NULL;
-    segPtr = (TkTextSegment *) ckalloc(CSEG_SIZE(1));
+    segPtr = ckalloc(CSEG_SIZE(1));
     linePtr2->segPtr = segPtr;
     segPtr->typePtr = &tkTextCharType;
     segPtr->nextPtr = NULL;
@@ -316,7 +316,7 @@ TkBTreeCreate(
     segPtr->body.chars[0] = '\n';
     segPtr->body.chars[1] = 0;
 
-    treePtr = (BTree *) ckalloc(sizeof(BTree));
+    treePtr = ckalloc(sizeof(BTree));
     treePtr->sharedTextPtr = sharedTextPtr;
     treePtr->rootPtr = rootPtr;
     treePtr->clients = 0;
@@ -480,10 +480,10 @@ TkBTreeDestroy(
 
     DestroyNode(treePtr->rootPtr);
     if (treePtr->startEnd != NULL) {
-	ckfree((char *) treePtr->startEnd);
-	ckfree((char *) treePtr->startEndRef);
+	ckfree(treePtr->startEnd);
+	ckfree(treePtr->startEndRef);
     }
-    ckfree((char *) treePtr);
+    ckfree(treePtr);
 }
 
 /*
@@ -545,7 +545,7 @@ TkBTreeRemoveClient(
 	 */
 
 	DestroyNode(treePtr->rootPtr);
-	ckfree((char *) treePtr);
+	ckfree(treePtr);
 	return;
     } else if (pixelReference == -1) {
 	/*
@@ -634,11 +634,9 @@ AdjustStartEndRefs(
 	    i++;
 	}
 	treePtr->startEndCount = count;
-	treePtr->startEnd = (TkTextLine **)
-		ckrealloc((char *) treePtr->startEnd,
+	treePtr->startEnd = ckrealloc(treePtr->startEnd,
 		sizeof(TkTextLine *) * count);
-	treePtr->startEndRef = (TkText **)
-		ckrealloc((char *) treePtr->startEndRef,
+	treePtr->startEndRef = ckrealloc(treePtr->startEndRef,
 		sizeof(TkText *) * count);
     }
     if ((action & TEXT_ADD_REFS)
@@ -654,11 +652,9 @@ AdjustStartEndRefs(
 
 	count = treePtr->startEndCount;
 
-	treePtr->startEnd = (TkTextLine **)
-		ckrealloc((char *) treePtr->startEnd,
+	treePtr->startEnd = ckrealloc(treePtr->startEnd,
 		sizeof(TkTextLine *) * count);
-	treePtr->startEndRef = (TkText **)
-		ckrealloc((char *) treePtr->startEndRef,
+	treePtr->startEndRef = ckrealloc(treePtr->startEndRef,
 		sizeof(TkText *) * count);
 
 	if (textPtr->start != NULL) {
@@ -741,7 +737,7 @@ AdjustPixelClient(
 		*counting = 0;
 	    }
 	    if (newPixelReferences != treePtr->pixelReferences) {
-		linePtr->pixels = (int *) ckrealloc((char *) linePtr->pixels,
+		linePtr->pixels = ckrealloc(linePtr->pixels,
 			sizeof(int) * 2 * newPixelReferences);
 	    }
 
@@ -758,7 +754,7 @@ AdjustPixelClient(
 	}
     }
     if (newPixelReferences != treePtr->pixelReferences) {
-	nodePtr->numPixels = (int *) ckrealloc((char *) nodePtr->numPixels,
+	nodePtr->numPixels = ckrealloc(nodePtr->numPixels,
 		sizeof(int) * newPixelReferences);
     }
     nodePtr->numPixels[useReference] = pixelCount;
@@ -807,7 +803,7 @@ RemovePixelClient(
     if (treePtr->pixelReferences == 1) {
 	nodePtr->numPixels = NULL;
     } else {
-	nodePtr->numPixels = (int *) ckrealloc((char *) nodePtr->numPixels,
+	nodePtr->numPixels = ckrealloc(nodePtr->numPixels,
 		sizeof(int) * (treePtr->pixelReferences - 1));
     }
     if (nodePtr->level != 0) {
@@ -828,7 +824,7 @@ RemovePixelClient(
 	    if (treePtr->pixelReferences == 1) {
 		linePtr->pixels = NULL;
 	    } else {
-		linePtr->pixels = (int *) ckrealloc((char *) linePtr->pixels,
+		linePtr->pixels = ckrealloc(linePtr->pixels,
 			sizeof(int) * 2 * (treePtr->pixelReferences-1));
 	    }
 	    linePtr = linePtr->nextPtr;
@@ -869,8 +865,8 @@ DestroyNode(
 		linePtr->segPtr = segPtr->nextPtr;
 		segPtr->typePtr->deleteProc(segPtr, linePtr, 1);
 	    }
-	    ckfree((char *) linePtr->pixels);
-	    ckfree((char *) linePtr);
+	    ckfree(linePtr->pixels);
+	    ckfree(linePtr);
 	}
     } else {
 	register Node *childPtr;
@@ -882,8 +878,8 @@ DestroyNode(
 	}
     }
     DeleteSummaries(nodePtr->summaryPtr);
-    ckfree((char *) nodePtr->numPixels);
-    ckfree((char *) nodePtr);
+    ckfree(nodePtr->numPixels);
+    ckfree(nodePtr);
 }
 
 /*
@@ -912,7 +908,7 @@ DeleteSummaries(
 
     while (summaryPtr != NULL) {
 	nextPtr = summaryPtr->nextPtr;
-	ckfree((char *) summaryPtr);
+	ckfree(summaryPtr);
 	summaryPtr = nextPtr;
     }
 }
@@ -1049,8 +1045,7 @@ TkBTreeInsertChars(
 
     changeToLineCount = 0;
     if (treePtr->pixelReferences > PIXEL_CLIENTS) {
-	changeToPixelCount = (int *)
-		ckalloc(sizeof(int) * treePtr->pixelReferences);
+	changeToPixelCount = ckalloc(sizeof(int) * treePtr->pixelReferences);
     } else {
 	changeToPixelCount = pixels;
     }
@@ -1066,7 +1061,7 @@ TkBTreeInsertChars(
 	    }
 	}
 	chunkSize = eol-string;
-	segPtr = (TkTextSegment *) ckalloc(CSEG_SIZE(chunkSize));
+	segPtr = ckalloc(CSEG_SIZE(chunkSize));
 	segPtr->typePtr = &tkTextCharType;
 	if (curPtr == NULL) {
 	    segPtr->nextPtr = linePtr->segPtr;
@@ -1088,8 +1083,8 @@ TkBTreeInsertChars(
 	 * the remainder of the old line to it.
 	 */
 
-	newLinePtr = (TkTextLine *) ckalloc(sizeof(TkTextLine));
-	newLinePtr->pixels = (int *)
+	newLinePtr = ckalloc(sizeof(TkTextLine));
+	newLinePtr->pixels =
 		ckalloc(sizeof(int) * 2 * treePtr->pixelReferences);
 
 	newLinePtr->parentPtr = linePtr->parentPtr;
@@ -1149,7 +1144,7 @@ TkBTreeInsertChars(
 	}
     }
     if (treePtr->pixelReferences > PIXEL_CLIENTS) {
-	ckfree((char *) changeToPixelCount);
+	ckfree(changeToPixelCount);
     }
 
     nodePtr = linePtr->parentPtr;
@@ -1421,8 +1416,8 @@ TkBTreeDeleteIndexRange(
 			checkCount++;
 		    }
 		}
-		ckfree((char *) curLinePtr->pixels);
-		ckfree((char *) curLinePtr);
+		ckfree(curLinePtr->pixels);
+		ckfree(curLinePtr);
 	    }
 	    curLinePtr = nextLinePtr;
 	    segPtr = curLinePtr->segPtr;
@@ -1446,7 +1441,7 @@ TkBTreeDeleteIndexRange(
 		    prevNodePtr->nextPtr = curNodePtr->nextPtr;
 		}
 		parentPtr->numChildren--;
-		ckfree((char *) curNodePtr);
+		ckfree(curNodePtr);
 		curNodePtr = parentPtr;
 	    }
 	    curNodePtr = curLinePtr->parentPtr;
@@ -1541,8 +1536,8 @@ TkBTreeDeleteIndexRange(
 		checkCount++;
 	    }
 	}
-	ckfree((char *) index2Ptr->linePtr->pixels);
-	ckfree((char *) index2Ptr->linePtr);
+	ckfree(index2Ptr->linePtr->pixels);
+	ckfree(index2Ptr->linePtr);
 
 	Rebalance((BTree *) index2Ptr->tree, curNodePtr);
     }
@@ -2137,7 +2132,7 @@ TkBTreeTag(
 
     oldState = TkBTreeCharTagged(index1Ptr, tagPtr);
     if ((add != 0) ^ oldState) {
-	segPtr = (TkTextSegment *) ckalloc(TSEG_SIZE);
+	segPtr = ckalloc(TSEG_SIZE);
 	segPtr->typePtr = (add) ? &tkTextToggleOnType : &tkTextToggleOffType;
 	prevPtr = SplitSeg(index1Ptr);
 	if (prevPtr == NULL) {
@@ -2182,7 +2177,7 @@ TkBTreeTag(
 	} else {
 	    changed = 0;
 	}
-	ckfree((char *) segPtr);
+	ckfree(segPtr);
 
 	/*
 	 * The code below is a bit tricky. After deleting a toggle we
@@ -2208,7 +2203,7 @@ TkBTreeTag(
 	}
     }
     if ((add != 0) ^ oldState) {
-	segPtr = (TkTextSegment *) ckalloc(TSEG_SIZE);
+	segPtr = ckalloc(TSEG_SIZE);
 	segPtr->typePtr = (add) ? &tkTextToggleOffType : &tkTextToggleOnType;
 	prevPtr = SplitSeg(index2Ptr);
 	if (prevPtr == NULL) {
@@ -2333,7 +2328,7 @@ ChangeNodeToggleCount(
 	    } else {
 		prevPtr->nextPtr = summaryPtr->nextPtr;
 	    }
-	    ckfree((char *) summaryPtr);
+	    ckfree(summaryPtr);
 	} else {
 	    /*
 	     * This tag isn't currently in the summary information list.
@@ -2352,7 +2347,7 @@ ChangeNodeToggleCount(
 
 		Node *rootNodePtr = tagPtr->tagRootPtr;
 
-		summaryPtr = (Summary *) ckalloc(sizeof(Summary));
+		summaryPtr = ckalloc(sizeof(Summary));
 		summaryPtr->tagPtr = tagPtr;
 		summaryPtr->toggleCount = tagPtr->toggleCount - delta;
 		summaryPtr->nextPtr = rootNodePtr->summaryPtr;
@@ -2361,7 +2356,7 @@ ChangeNodeToggleCount(
 		rootLevel = rootNodePtr->level;
 		tagPtr->tagRootPtr = rootNodePtr;
 	    }
-	    summaryPtr = (Summary *) ckalloc(sizeof(Summary));
+	    summaryPtr = ckalloc(sizeof(Summary));
 	    summaryPtr->tagPtr = tagPtr;
 	    summaryPtr->toggleCount = delta;
 	    summaryPtr->nextPtr = nodePtr->summaryPtr;
@@ -2418,7 +2413,7 @@ ChangeNodeToggleCount(
 	    } else {
 		prevPtr->nextPtr = summaryPtr->nextPtr;
 	    }
-	    ckfree((char *) summaryPtr);
+	    ckfree(summaryPtr);
 	    tagPtr->tagRootPtr = node2Ptr;
 	    break;
 	}
@@ -3337,10 +3332,8 @@ TkBTreeGetTags(
 
     tagInfo.numTags = 0;
     tagInfo.arraySize = NUM_TAG_INFOS;
-    tagInfo.tagPtrs = (TkTextTag **)
-	    ckalloc((unsigned) NUM_TAG_INFOS * sizeof(TkTextTag *));
-    tagInfo.counts = (int *)
-	    ckalloc((unsigned) NUM_TAG_INFOS * sizeof(int));
+    tagInfo.tagPtrs = ckalloc(NUM_TAG_INFOS * sizeof(TkTextTag *));
+    tagInfo.counts = ckalloc(NUM_TAG_INFOS * sizeof(int));
 
     /*
      * Record tag toggles within the line of indexPtr but preceding indexPtr.
@@ -3425,9 +3418,9 @@ TkBTreeGetTags(
 	}
     }
     *numTagsPtr = dst;
-    ckfree((char *) tagInfo.counts);
+    ckfree(tagInfo.counts);
     if (dst == 0) {
-	ckfree((char *) tagInfo.tagPtrs);
+	ckfree(tagInfo.tagPtrs);
 	return NULL;
     }
     return tagInfo.tagPtrs;
@@ -3484,8 +3477,7 @@ TkTextIsElided(
     int elide;
 
     if (elideInfo == NULL) {
-	infoPtr = (TkTextElideInfo *)
-		ckalloc((unsigned) sizeof(TkTextElideInfo));
+	infoPtr = ckalloc(sizeof(TkTextElideInfo));
     } else {
 	infoPtr = elideInfo;
     }
@@ -3500,10 +3492,8 @@ TkTextIsElided(
      */
 
     if (LOTSA_TAGS < infoPtr->numTags) {
-	infoPtr->tagCnts = (int *)
-		ckalloc((unsigned) sizeof(int) * infoPtr->numTags);
-	infoPtr->tagPtrs = (TkTextTag **)
-		ckalloc((unsigned) sizeof(TkTextTag *) * infoPtr->numTags);
+	infoPtr->tagCnts = ckalloc(sizeof(int) * infoPtr->numTags);
+	infoPtr->tagPtrs = ckalloc(sizeof(TkTextTag *) * infoPtr->numTags);
     }
 
     for (i=0; i<infoPtr->numTags; i++) {
@@ -3632,11 +3622,11 @@ TkTextIsElided(
 
     if (elideInfo == NULL) {
 	if (LOTSA_TAGS < infoPtr->numTags) {
-	    ckfree((char *) infoPtr->tagCnts);
-	    ckfree((char *) infoPtr->tagPtrs);
+	    ckfree(infoPtr->tagCnts);
+	    ckfree(infoPtr->tagPtrs);
 	}
 
-	ckfree((char *) infoPtr);
+	ckfree(infoPtr);
     }
 
     return elide;
@@ -3665,8 +3655,8 @@ TkTextFreeElideInfo(
 				 * structure. */
 {
     if (LOTSA_TAGS < elideInfo->numTags) {
-	ckfree((char *) elideInfo->tagCnts);
-	ckfree((char *) elideInfo->tagPtrs);
+	ckfree(elideInfo->tagCnts);
+	ckfree(elideInfo->tagPtrs);
     }
 }
 
@@ -3717,16 +3707,15 @@ IncCount(
 	int *newCounts, newSize;
 
 	newSize = 2 * tagInfoPtr->arraySize;
-	newTags = (TkTextTag **)
-		ckalloc((unsigned) newSize * sizeof(TkTextTag *));
+	newTags = ckalloc(newSize * sizeof(TkTextTag *));
 	memcpy(newTags, tagInfoPtr->tagPtrs,
 		tagInfoPtr->arraySize * sizeof(TkTextTag *));
-	ckfree((char *) tagInfoPtr->tagPtrs);
+	ckfree(tagInfoPtr->tagPtrs);
 	tagInfoPtr->tagPtrs = newTags;
-	newCounts = (int *) ckalloc((unsigned) newSize * sizeof(int));
+	newCounts = ckalloc(newSize * sizeof(int));
 	memcpy(newCounts, tagInfoPtr->counts,
 		tagInfoPtr->arraySize * sizeof(int));
-	ckfree((char *) tagInfoPtr->counts);
+	ckfree(tagInfoPtr->counts);
 	tagInfoPtr->counts = newCounts;
 	tagInfoPtr->arraySize = newSize;
     }
@@ -3926,7 +3915,7 @@ CheckNodeConsistency(
     numChildren = 0;
     numLines = 0;
     if (references > PIXEL_CLIENTS) {
-	numPixels = (int *) ckalloc(sizeof(int) * references);
+	numPixels = ckalloc(sizeof(int) * references);
     } else {
 	numPixels = pixels;
     }
@@ -4015,7 +4004,7 @@ CheckNodeConsistency(
 	}
     }
     if (references > PIXEL_CLIENTS) {
-	ckfree((char *) numPixels);
+	ckfree(numPixels);
     }
 
     for (summaryPtr = nodePtr->summaryPtr; summaryPtr != NULL;
@@ -4114,7 +4103,7 @@ Rebalance(
 		 */
 
 		if (nodePtr->parentPtr == NULL) {
-		    newPtr = (Node *) ckalloc(sizeof(Node));
+		    newPtr = ckalloc(sizeof(Node));
 		    newPtr->parentPtr = NULL;
 		    newPtr->nextPtr = NULL;
 		    newPtr->summaryPtr = NULL;
@@ -4122,7 +4111,7 @@ Rebalance(
 		    newPtr->children.nodePtr = nodePtr;
 		    newPtr->numChildren = 1;
 		    newPtr->numLines = nodePtr->numLines;
-		    newPtr->numPixels = (int *)
+		    newPtr->numPixels =
 			    ckalloc(sizeof(int) * treePtr->pixelReferences);
 		    for (i=0; i<treePtr->pixelReferences; i++) {
 			newPtr->numPixels[i] = nodePtr->numPixels[i];
@@ -4130,8 +4119,8 @@ Rebalance(
 		    RecomputeNodeCounts(treePtr, newPtr);
 		    treePtr->rootPtr = newPtr;
 		}
-		newPtr = (Node *) ckalloc(sizeof(Node));
-		newPtr->numPixels = (int *)
+		newPtr = ckalloc(sizeof(Node));
+		newPtr->numPixels =
 			ckalloc(sizeof(int) * treePtr->pixelReferences);
 		for (i=0; i<treePtr->pixelReferences; i++) {
 		    newPtr->numPixels[i] = 0;
@@ -4188,7 +4177,7 @@ Rebalance(
 		    treePtr->rootPtr = nodePtr->children.nodePtr;
 		    treePtr->rootPtr->parentPtr = NULL;
 		    DeleteSummaries(nodePtr->summaryPtr);
-		    ckfree((char *) nodePtr);
+		    ckfree(nodePtr);
 		}
 		return;
 	    }
@@ -4277,7 +4266,7 @@ Rebalance(
 		nodePtr->nextPtr = otherPtr->nextPtr;
 		nodePtr->parentPtr->numChildren--;
 		DeleteSummaries(otherPtr->summaryPtr);
-		ckfree((char *) otherPtr);
+		ckfree(otherPtr);
 		continue;
 	    }
 
@@ -4375,7 +4364,7 @@ RecomputeNodeCounts(
 		for (summaryPtr = nodePtr->summaryPtr; ;
 			summaryPtr = summaryPtr->nextPtr) {
 		    if (summaryPtr == NULL) {
-			summaryPtr = (Summary *) ckalloc(sizeof(Summary));
+			summaryPtr = ckalloc(sizeof(Summary));
 			summaryPtr->tagPtr = tagPtr;
 			summaryPtr->toggleCount = 1;
 			summaryPtr->nextPtr = nodePtr->summaryPtr;
@@ -4403,7 +4392,7 @@ RecomputeNodeCounts(
 		for (summaryPtr = nodePtr->summaryPtr; ;
 			summaryPtr = summaryPtr->nextPtr) {
 		    if (summaryPtr == NULL) {
-			summaryPtr = (Summary *) ckalloc(sizeof(Summary));
+			summaryPtr = ckalloc(sizeof(Summary));
 			summaryPtr->tagPtr = summaryPtr2->tagPtr;
 			summaryPtr->toggleCount = summaryPtr2->toggleCount;
 			summaryPtr->nextPtr = nodePtr->summaryPtr;
@@ -4452,11 +4441,11 @@ RecomputeNodeCounts(
 	}
 	if (summaryPtr2 != NULL) {
 	    summaryPtr2->nextPtr = summaryPtr->nextPtr;
-	    ckfree((char *) summaryPtr);
+	    ckfree(summaryPtr);
 	    summaryPtr = summaryPtr2->nextPtr;
 	} else {
 	    nodePtr->summaryPtr = summaryPtr->nextPtr;
-	    ckfree((char *) summaryPtr);
+	    ckfree(summaryPtr);
 	    summaryPtr = nodePtr->summaryPtr;
 	}
     }
@@ -4556,9 +4545,8 @@ CharSplitProc(
 {
     TkTextSegment *newPtr1, *newPtr2;
 
-    newPtr1 = (TkTextSegment *) ckalloc(CSEG_SIZE(index));
-    newPtr2 = (TkTextSegment *) ckalloc(
-	    CSEG_SIZE(segPtr->size - index));
+    newPtr1 = ckalloc(CSEG_SIZE(index));
+    newPtr2 = ckalloc(CSEG_SIZE(segPtr->size - index));
     newPtr1->typePtr = &tkTextCharType;
     newPtr1->nextPtr = newPtr2;
     newPtr1->size = index;
@@ -4568,7 +4556,7 @@ CharSplitProc(
     newPtr2->nextPtr = segPtr->nextPtr;
     newPtr2->size = segPtr->size - index;
     strcpy(newPtr2->body.chars, segPtr->body.chars + index);
-    ckfree((char *) segPtr);
+    ckfree(segPtr);
     return newPtr1;
 }
 
@@ -4603,15 +4591,14 @@ CharCleanupProc(
     if ((segPtr2 == NULL) || (segPtr2->typePtr != &tkTextCharType)) {
 	return segPtr;
     }
-    newPtr = (TkTextSegment *) ckalloc(CSEG_SIZE(
-	    segPtr->size + segPtr2->size));
+    newPtr = ckalloc(CSEG_SIZE(segPtr->size + segPtr2->size));
     newPtr->typePtr = &tkTextCharType;
     newPtr->nextPtr = segPtr2->nextPtr;
     newPtr->size = segPtr->size + segPtr2->size;
     strcpy(newPtr->body.chars, segPtr->body.chars);
     strcpy(newPtr->body.chars + segPtr->size, segPtr2->body.chars);
-    ckfree((char *) segPtr);
-    ckfree((char *) segPtr2);
+    ckfree(segPtr);
+    ckfree(segPtr2);
     return newPtr;
 }
 
@@ -4640,7 +4627,7 @@ CharDeleteProc(
 				 * deleted, so everything must get cleaned
 				 * up. */
 {
-    ckfree((char *) segPtr);
+    ckfree(segPtr);
     return 0;
 }
 
@@ -4716,7 +4703,7 @@ ToggleDeleteProc(
 				 * up. */
 {
     if (treeGone) {
-	ckfree((char *) segPtr);
+	ckfree(segPtr);
 	return 0;
     }
 
@@ -4790,9 +4777,9 @@ ToggleCleanupProc(
 			segPtr->body.toggle.tagPtr, -counts);
 	    }
 	    prevPtr->nextPtr = segPtr2->nextPtr;
-	    ckfree((char *) segPtr2);
+	    ckfree(segPtr2);
 	    segPtr2 = segPtr->nextPtr;
-	    ckfree((char *) segPtr);
+	    ckfree(segPtr);
 	    return segPtr2;
 	}
     }