*** empty log message ***

23 files changed, 388 insertions, 380 deletions

diff --git a/src/bltChain.C b/src/bltChain.C
index b6051b8..54797e1 100644
--- a/src/bltChain.C
+++ b/src/bltChain.C
@@ -55,7 +55,7 @@ Blt_Chain_Create(void)
 {
     Chain *chainPtr;
 
-    chainPtr = Blt_Malloc(sizeof(Chain));
+    chainPtr = malloc(sizeof(Chain));
     if (chainPtr != NULL) {
 	Blt_Chain_Init(chainPtr);
     }
@@ -82,7 +82,7 @@ Blt_Chain_AllocLink(size_t extraSize)
     size_t linkSize;
 
     linkSize = ALIGN(sizeof(ChainLink));
-    linkPtr = Blt_AssertCalloc(1, linkSize + extraSize);
+    linkPtr = calloc(1, linkSize + extraSize);
     if (extraSize > 0) {
 	/* Point clientData at the memory beyond the normal structure. */
 	linkPtr->clientData = (ClientData)((char *)linkPtr + linkSize);
@@ -127,7 +127,7 @@ Blt_Chain_NewLink(void)
 {
     ChainLink *linkPtr;
 
-    linkPtr = Blt_AssertMalloc(sizeof(ChainLink));
+    linkPtr = malloc(sizeof(ChainLink));
     linkPtr->clientData = NULL;
     linkPtr->next = linkPtr->prev = NULL;
     return linkPtr;
@@ -157,7 +157,7 @@ Blt_Chain_Reset(Chain *chainPtr) /* Chain to clear */
 	while (linkPtr != NULL) {
 	    oldPtr = linkPtr;
 	    linkPtr = linkPtr->next;
-	    Blt_Free(oldPtr);
+	    free(oldPtr);
 	}
 	Blt_Chain_Init(chainPtr);
     }
@@ -182,7 +182,8 @@ Blt_Chain_Destroy(Chain *chainPtr)
 {
     if (chainPtr != NULL) {
 	Blt_Chain_Reset(chainPtr);
-	Blt_Free(chainPtr);
+	free(chainPtr);
+	chainPtr = NULL;
     }
 }
 
@@ -343,7 +344,8 @@ void
 Blt_Chain_DeleteLink(Blt_Chain chain, Blt_ChainLink link)
 {
     Blt_Chain_UnlinkLink(chain, link);
-    Blt_Free(link);
+    free(link);
+    link = NULL;
 }
 
 /*
@@ -465,7 +467,7 @@ Blt_Chain_Sort(Chain *chainPtr, Blt_ChainCompareProc *proc)
     if (chainPtr->nLinks < 2) {
 	return;
     }
-    linkArr = Blt_Malloc(sizeof(Blt_ChainLink) * (chainPtr->nLinks + 1));
+    linkArr = malloc(sizeof(Blt_ChainLink) * (chainPtr->nLinks + 1));
     if (linkArr == NULL) {
 	return;			/* Out of memory. */
     }
@@ -488,7 +490,7 @@ Blt_Chain_Sort(Chain *chainPtr, Blt_ChainCompareProc *proc)
     }
     chainPtr->tail = linkPtr;
     linkPtr->next = NULL;
-    Blt_Free(linkArr);
+    free(linkArr);
 }
 
 
diff --git a/src/bltConfig.C b/src/bltConfig.C
index cf67a23..863cb0d 100644
--- a/src/bltConfig.C
+++ b/src/bltConfig.C
@@ -1216,9 +1216,10 @@ DoConfig(
 		char *value;
 		
 		value = (objIsEmpty) ? NULL : 
-		    Blt_AssertStrdup(Tcl_GetString(objPtr));
+		    Blt_Strdup(Tcl_GetString(objPtr));
 		if (*(char **)ptr != NULL) {
-		    Blt_Free(*(char **)ptr);
+		    free(*(char **)ptr);
+		    *((char **) ptr) = NULL;
 		}
 		*(char **)ptr = value;
 	    }
@@ -1357,7 +1358,8 @@ DoConfig(
 		    return TCL_ERROR;
 		}
 		if (*(char ***)ptr != NULL) {
-		    Blt_Free(*(char ***)ptr);
+		    free(*(char ***)ptr);
+		    *((char **) ptr) = NULL;
 		}
 		*(const char ***)ptr = argv;
 	    }
@@ -2261,7 +2263,7 @@ Blt_FreeOptions(
 	switch (sp->type) {
 	case BLT_CONFIG_STRING:
 	    if (*((char **) ptr) != NULL) {
-		Blt_Free(*((char **) ptr));
+		free(*((char **) ptr));
 		*((char **) ptr) = NULL;
 	    }
 	    break;
@@ -2318,7 +2320,7 @@ Blt_FreeOptions(
 
 	case BLT_CONFIG_LIST:
 	    if (*((char ***) ptr) != NULL) {
-		Blt_Free(*((char ***) ptr));
+		free(*((char ***) ptr));
 		*((char ***) ptr) = NULL;
 	    }
 	    break;
@@ -2430,7 +2432,7 @@ Blt_ConfigureComponentFromObj(
     char *tmpName;
     int isTemporary = FALSE;
 
-    tmpName = Blt_AssertStrdup(name);
+    tmpName = Blt_Strdup(name);
 
     /* Window name can't start with an upper case letter */
     tmpName[0] = tolower(name[0]);
@@ -2450,7 +2452,7 @@ Blt_ConfigureComponentFromObj(
 	return TCL_ERROR;
     }
     assert(Tk_Depth(tkwin) == Tk_Depth(parent));
-    Blt_Free(tmpName);
+    free(tmpName);
 
     Tk_SetClass(tkwin, className);
     result = Blt_ConfigureWidgetFromObj(interp, tkwin, sp, objc, objv, widgRec,
diff --git a/src/bltGrAxis.C b/src/bltGrAxis.C
index f6f54e9..9238e67 100644
--- a/src/bltGrAxis.C
+++ b/src/bltGrAxis.C
@@ -543,7 +543,7 @@ FreeFormatProc(
     Axis *axisPtr = (Axis *)(widgRec);
 
     if (axisPtr->limitsFormats != NULL) {
-	Blt_Free(axisPtr->limitsFormats);
+	free(axisPtr->limitsFormats);
 	axisPtr->limitsFormats = NULL;
     }
     axisPtr->nFormats = 0;
@@ -584,11 +584,11 @@ ObjToFormatProc(
     if (argc > 2) {
 	Tcl_AppendResult(interp, "too many elements in limits format list \"",
 		Tcl_GetString(objPtr), "\"", (char *)NULL);
-	Blt_Free(argv);
+	free(argv);
 	return TCL_ERROR;
     }
     if (axisPtr->limitsFormats != NULL) {
-	Blt_Free(axisPtr->limitsFormats);
+	free(axisPtr->limitsFormats);
     }
     axisPtr->limitsFormats = argv;
     axisPtr->nFormats = argc;
@@ -623,11 +623,11 @@ FormatToObjProc(
     if (axisPtr->nFormats == 0) {
 	objPtr = Tcl_NewStringObj("", -1);
     } else {
-	const char *string;
+	char *string;
 
 	string = Tcl_Merge(axisPtr->nFormats, axisPtr->limitsFormats); 
 	objPtr = Tcl_NewStringObj(string, -1);
-	Blt_Free(string);
+	free(string);
     }
     return objPtr;
 }
@@ -833,7 +833,7 @@ FreeTicksProc(
 
     axisPtr->flags |= mask;
     if (*ticksPtrPtr != NULL) {
-	Blt_Free(*ticksPtrPtr);
+	free(*ticksPtrPtr);
     }
     *ticksPtrPtr = NULL;
 }
@@ -875,12 +875,12 @@ ObjToTicksProc(
     if (objc > 0) {
 	int i;
 
-	ticksPtr = Blt_AssertMalloc(sizeof(Ticks) + (objc*sizeof(double)));
+	ticksPtr = malloc(sizeof(Ticks) + (objc*sizeof(double)));
 	for (i = 0; i < objc; i++) {
 	    double value;
 
 	    if (Blt_ExprDoubleFromObj(interp, objv[i], &value) != TCL_OK) {
-		Blt_Free(ticksPtr);
+		free(ticksPtr);
 		return TCL_ERROR;
 	    }
 	    ticksPtr->values[i] = value;
@@ -1057,7 +1057,7 @@ FreeTickLabels(Blt_Chain chain)
 	TickLabel *labelPtr;
 
 	labelPtr = Blt_Chain_GetValue(link);
-	Blt_Free(labelPtr);
+	free(labelPtr);
     }
     Blt_Chain_Reset(chain);
 }
@@ -1121,7 +1121,7 @@ MakeLabel(Axis *axisPtr, double value)
 	    Tcl_ResetResult(interp); /* Clear the interpreter's result. */
 	}
     }
-    labelPtr = Blt_AssertMalloc(sizeof(TickLabel) + strlen(string));
+    labelPtr = malloc(sizeof(TickLabel) + strlen(string));
     strcpy(labelPtr->string, string);
     labelPtr->anchorPos.x = labelPtr->anchorPos.y = DBL_MAX;
     return labelPtr;
@@ -1476,7 +1476,7 @@ GenerateTicks(TickSweep *sweepPtr)
 {
     Ticks *ticksPtr;
 
-    ticksPtr = Blt_AssertMalloc(sizeof(Ticks) + 
+    ticksPtr = malloc(sizeof(Ticks) + 
 	(sweepPtr->nSteps * sizeof(double)));
     ticksPtr->nTicks = 0;
 
@@ -1798,13 +1798,13 @@ SweepTicks(Axis *axisPtr)
 {
     if (axisPtr->flags & AXIS_AUTO_MAJOR) {
 	if (axisPtr->t1Ptr != NULL) {
-	    Blt_Free(axisPtr->t1Ptr);
+	    free(axisPtr->t1Ptr);
 	}
 	axisPtr->t1Ptr = GenerateTicks(&axisPtr->majorSweep);
     }
     if (axisPtr->flags & AXIS_AUTO_MINOR) {
 	if (axisPtr->t2Ptr != NULL) {
-	    Blt_Free(axisPtr->t2Ptr);
+	    free(axisPtr->t2Ptr);
 	}
 	axisPtr->t2Ptr = GenerateTicks(&axisPtr->minorSweep);
     }
@@ -2022,7 +2022,7 @@ DestroyAxis(Axis *axisPtr)
 	Blt_Chain_DeleteLink(axisPtr->chain, axisPtr->link);
     }
     if (axisPtr->obj.name != NULL) {
-	Blt_Free(axisPtr->obj.name);
+	free(axisPtr->obj.name);
     }
     if (axisPtr->hashPtr != NULL) {
 	Blt_DeleteHashEntry(&graphPtr->axes.table, axisPtr->hashPtr);
@@ -2044,9 +2044,10 @@ DestroyAxis(Axis *axisPtr)
     FreeTickLabels(axisPtr->tickLabels);
     Blt_Chain_Destroy(axisPtr->tickLabels);
     if (axisPtr->segments != NULL) {
-	Blt_Free(axisPtr->segments);
+	free(axisPtr->segments);
     }
-    Blt_Free(axisPtr);
+    free(axisPtr);
+    axisPtr = NULL;
 }
 
 static void
@@ -2433,7 +2434,8 @@ MakeSegments(Axis *axisPtr, AxisInfo *infoPtr)
     Segment2d *sp;
 
     if (axisPtr->segments != NULL) {
-	Blt_Free(axisPtr->segments);
+	free(axisPtr->segments);
+	axisPtr->segments = NULL;	
     }
     nMajorTicks = nMinorTicks = 0;
     if (axisPtr->t1Ptr != NULL) {
@@ -2443,7 +2445,7 @@ MakeSegments(Axis *axisPtr, AxisInfo *infoPtr)
 	nMinorTicks = axisPtr->t2Ptr->nTicks;
     }
     arraySize = 1 + (nMajorTicks * (nMinorTicks + 1));
-    segments = Blt_AssertMalloc(arraySize * sizeof(Segment2d));
+    segments = malloc(arraySize * sizeof(Segment2d));
     sp = segments;
     if (axisPtr->lineWidth > 0) {
 	/* Axis baseline */
@@ -3015,17 +3017,19 @@ MapGridlines(Axis *axisPtr)
     needed = t1Ptr->nTicks;
     if (needed != axisPtr->major.nAllocated) {
 	if (axisPtr->major.segments != NULL) {
-	    Blt_Free(axisPtr->major.segments);
+	  free(axisPtr->major.segments);
+	  axisPtr->major.segments = NULL;
 	}
-	axisPtr->major.segments = Blt_AssertMalloc(sizeof(Segment2d) * needed);
+	axisPtr->major.segments = malloc(sizeof(Segment2d) * needed);
 	axisPtr->major.nAllocated = needed;
     }
     needed = (t1Ptr->nTicks * t2Ptr->nTicks);
     if (needed != axisPtr->minor.nAllocated) {
 	if (axisPtr->minor.segments != NULL) {
-	    Blt_Free(axisPtr->minor.segments);
+	  free(axisPtr->minor.segments);
+	  axisPtr->minor.segments = NULL;
 	}
-	axisPtr->minor.segments = Blt_AssertMalloc(sizeof(Segment2d) * needed);
+	axisPtr->minor.segments = malloc(sizeof(Segment2d) * needed);
 	axisPtr->minor.nAllocated = needed;
     }
     s1 = axisPtr->major.segments, s2 = axisPtr->minor.segments;
@@ -3053,10 +3057,10 @@ MapGridlines(Axis *axisPtr)
 	}
     }
     if (t1Ptr != axisPtr->t1Ptr) {
-	Blt_Free(t1Ptr);		/* Free generated ticks. */
+	free(t1Ptr);		/* Free generated ticks. */
     }
     if (t2Ptr != axisPtr->t2Ptr) {
-	Blt_Free(t2Ptr);		/* Free generated ticks. */
+	free(t2Ptr);		/* Free generated ticks. */
     }
     axisPtr->major.nUsed = s1 - axisPtr->major.segments;
     axisPtr->minor.nUsed = s2 - axisPtr->minor.segments;
@@ -3805,13 +3809,13 @@ NewAxis(Graph *graphPtr, const char *name, int margin)
 	}
 	axisPtr->flags &= ~DELETE_PENDING;
     } else {
-	axisPtr = Blt_Calloc(1, sizeof(Axis));
+	axisPtr = calloc(1, sizeof(Axis));
 	if (axisPtr == NULL) {
 	    Tcl_AppendResult(graphPtr->interp, 
 		"can't allocate memory for axis \"", name, "\"", (char *)NULL);
 	    return NULL;
 	}
-	axisPtr->obj.name = Blt_AssertStrdup(name);
+	axisPtr->obj.name = Blt_Strdup(name);
 	axisPtr->hashPtr = hPtr;
 	Blt_GraphSetObjectClass(&axisPtr->obj, CID_NONE);
 	axisPtr->obj.graphPtr = graphPtr;
@@ -5702,7 +5706,7 @@ TimeGenerateTicks(TickSweep *sweepPtr)
 {
     Ticks *ticksPtr;
 
-    ticksPtr = Blt_AssertMalloc(sizeof(Ticks) + 
+    ticksPtr = malloc(sizeof(Ticks) + 
 	(sweepPtr->nSteps * sizeof(double)));
     ticksPtr->nTicks = 0;
 
diff --git a/src/bltGrBind.C b/src/bltGrBind.C
index 7b288f7..d4d189c 100644
--- a/src/bltGrBind.C
+++ b/src/bltGrBind.C
@@ -133,7 +133,7 @@ DoEvent(
 	tagArray = staticTags;
 	nTags = Blt_List_GetLength(tagList);
 	if (nTags >= MAX_STATIC_TAGS) {
-	    tagArray = Blt_AssertMalloc(sizeof(ClientData) * nTags);
+	    tagArray = malloc(sizeof(ClientData) * nTags);
 	    
 	} 
 	nTags = 0;
@@ -144,7 +144,7 @@ DoEvent(
 	Tk_BindEvent(bindPtr->bindingTable, eventPtr, bindPtr->tkwin, nTags, 
 		tagArray);
 	if (tagArray != staticTags) {
-	    Blt_Free(tagArray);
+	    free(tagArray);
 	}
     }
     Blt_List_Destroy(tagList);
@@ -607,7 +607,7 @@ Blt_CreateBindingTable(
     unsigned int mask;
     BindTable *bindPtr;
 
-    bindPtr = Blt_AssertCalloc(1, sizeof(BindTable));
+    bindPtr = calloc(1, sizeof(BindTable));
     bindPtr->bindingTable = Tk_CreateBindingTable(interp);
     bindPtr->clientData = clientData;
     bindPtr->tkwin = tkwin;
@@ -630,7 +630,8 @@ Blt_DestroyBindingTable(BindTable *bindPtr)
 	ButtonReleaseMask | EnterWindowMask | LeaveWindowMask |
 	PointerMotionMask);
     Tk_DeleteEventHandler(bindPtr->tkwin, mask, BindProc, bindPtr);
-    Blt_Free(bindPtr);
+    free(bindPtr);
+    bindPtr = NULL;
 }
 
 void
diff --git a/src/bltGrElemBar.C b/src/bltGrElemBar.C
index 328275a..4e472fd 100644
--- a/src/bltGrElemBar.C
+++ b/src/bltGrElemBar.C
@@ -681,9 +681,9 @@ Blt_BarPen(const char *penName)
 {
     BarPen *penPtr;
 
-    penPtr = Blt_AssertCalloc(1, sizeof(BarPen));
+    penPtr = calloc(1, sizeof(BarPen));
     InitializeBarPen(penPtr);
-    penPtr->name = Blt_AssertStrdup(penName);
+    penPtr->name = Blt_Strdup(penName);
     if (strcmp(penName, "activeBar") == 0) {
 	penPtr->flags = ACTIVE_PEN;
     }
@@ -1052,8 +1052,8 @@ MergePens(BarElement *elemPtr, BarStyle **dataToStyle)
 	XRectangle *bars, *bp;
 	int *ip, *barToData;
 
-	bars = Blt_AssertMalloc(elemPtr->nBars * sizeof(XRectangle));
-	barToData = Blt_AssertMalloc(elemPtr->nBars * sizeof(int));
+	bars = malloc(elemPtr->nBars * sizeof(XRectangle));
+	barToData = malloc(elemPtr->nBars * sizeof(int));
 	bp = bars, ip = barToData;
 	for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL; 
 	     link = Blt_Chain_NextLink(link)) {
@@ -1074,8 +1074,8 @@ MergePens(BarElement *elemPtr, BarStyle **dataToStyle)
 	    }
 	    stylePtr->nBars = bp - stylePtr->bars;
 	}
-	Blt_Free(elemPtr->bars);
-	Blt_Free(elemPtr->barToData);
+	free(elemPtr->bars);
+	free(elemPtr->barToData);
 	elemPtr->bars = bars;
 	elemPtr->barToData = barToData;
     }
@@ -1085,8 +1085,8 @@ MergePens(BarElement *elemPtr, BarStyle **dataToStyle)
 	Segment2d *bars, *sp;
 	int *map, *ip;
 
-	bars = Blt_AssertMalloc(elemPtr->xeb.length * sizeof(Segment2d));
-	map = Blt_AssertMalloc(elemPtr->xeb.length * sizeof(int));
+	bars = malloc(elemPtr->xeb.length * sizeof(Segment2d));
+	map = malloc(elemPtr->xeb.length * sizeof(int));
 	sp = bars, ip = map;
 	for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); 
 	     link != NULL; link = Blt_Chain_NextLink(link)) {
@@ -1106,9 +1106,9 @@ MergePens(BarElement *elemPtr, BarStyle **dataToStyle)
 	    }
 	    stylePtr->xeb.length = sp - stylePtr->xeb.segments;
 	}
-	Blt_Free(elemPtr->xeb.segments);
+	free(elemPtr->xeb.segments);
 	elemPtr->xeb.segments = bars;
-	Blt_Free(elemPtr->xeb.map);
+	free(elemPtr->xeb.map);
 	elemPtr->xeb.map = map;
     }
     if (elemPtr->yeb.length > 0) {
@@ -1116,8 +1116,8 @@ MergePens(BarElement *elemPtr, BarStyle **dataToStyle)
 	Segment2d *bars, *sp;
 	int *map, *ip;
 
-	bars = Blt_AssertMalloc(elemPtr->yeb.length * sizeof(Segment2d));
-	map = Blt_AssertMalloc(elemPtr->yeb.length * sizeof(int));
+	bars = malloc(elemPtr->yeb.length * sizeof(Segment2d));
+	map = malloc(elemPtr->yeb.length * sizeof(int));
 	sp = bars, ip = map;
 	for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL; 
 	     link = Blt_Chain_NextLink(link)) {
@@ -1137,9 +1137,9 @@ MergePens(BarElement *elemPtr, BarStyle **dataToStyle)
 	    }
 	    stylePtr->yeb.length = sp - stylePtr->yeb.segments;
 	}
-	Blt_Free(elemPtr->yeb.segments);
+	free(elemPtr->yeb.segments);
 	elemPtr->yeb.segments = bars;
-	Blt_Free(elemPtr->yeb.map);
+	free(elemPtr->yeb.map);
 	elemPtr->yeb.map = map;
     }
 }
@@ -1163,11 +1163,11 @@ static void
 MapActiveBars(BarElement *elemPtr)
 {
     if (elemPtr->activeRects != NULL) {
-	Blt_Free(elemPtr->activeRects);
+	free(elemPtr->activeRects);
 	elemPtr->activeRects = NULL;
     }
     if (elemPtr->activeToData != NULL) {
-	Blt_Free(elemPtr->activeToData);
+	free(elemPtr->activeToData);
 	elemPtr->activeToData = NULL;
     }
     elemPtr->nActive = 0;
@@ -1178,9 +1178,9 @@ MapActiveBars(BarElement *elemPtr)
 	int i;
 	int count;
 
-	activeRects = Blt_AssertMalloc(sizeof(XRectangle) * 
+	activeRects = malloc(sizeof(XRectangle) * 
 				       elemPtr->nActiveIndices);
-	activeToData = Blt_AssertMalloc(sizeof(int) * 
+	activeToData = malloc(sizeof(int) * 
 					elemPtr->nActiveIndices);
 	count = 0;
 	for (i = 0; i < elemPtr->nBars; i++) {
@@ -1208,28 +1208,28 @@ ResetBar(BarElement *elemPtr)
     /* Release any storage associated with the display of the bar */
     ResetStylePalette(elemPtr->stylePalette);
     if (elemPtr->activeRects != NULL) {
-	Blt_Free(elemPtr->activeRects);
+	free(elemPtr->activeRects);
     }
     if (elemPtr->activeToData != NULL) {
-	Blt_Free(elemPtr->activeToData);
+	free(elemPtr->activeToData);
     }
     if (elemPtr->xeb.segments != NULL) {
-	Blt_Free(elemPtr->xeb.segments);
+	free(elemPtr->xeb.segments);
     }
     if (elemPtr->xeb.map != NULL) {
-	Blt_Free(elemPtr->xeb.map);
+	free(elemPtr->xeb.map);
     }
     if (elemPtr->yeb.segments != NULL) {
-	Blt_Free(elemPtr->yeb.segments);
+	free(elemPtr->yeb.segments);
     }
     if (elemPtr->yeb.map != NULL) {
-	Blt_Free(elemPtr->yeb.map);
+	free(elemPtr->yeb.map);
     }
     if (elemPtr->bars != NULL) {
-	Blt_Free(elemPtr->bars);
+	free(elemPtr->bars);
     }
     if (elemPtr->barToData != NULL) {
-	Blt_Free(elemPtr->barToData);
+	free(elemPtr->barToData);
     }
     elemPtr->activeToData = elemPtr->xeb.map = elemPtr->yeb.map = 
 	elemPtr->barToData = NULL;
@@ -1275,8 +1275,8 @@ MapErrorBars(Graph *graphPtr, BarElement *elemPtr, BarStyle **dataToStyle)
 	int *indexPtr;
 	int i;
 		
-	segPtr = bars = Blt_AssertMalloc(n * 3 * sizeof(Segment2d));
-	indexPtr = map = Blt_AssertMalloc(n * 3 * sizeof(int));
+	segPtr = bars = malloc(n * 3 * sizeof(Segment2d));
+	indexPtr = map = malloc(n * 3 * sizeof(int));
 	for (i = 0; i < n; i++) {
 	    double x, y;
 	    double high, low;
@@ -1339,8 +1339,8 @@ MapErrorBars(Graph *graphPtr, BarElement *elemPtr, BarStyle **dataToStyle)
 	int *indexPtr;
 	int i;
 		
-	segPtr = bars = Blt_AssertMalloc(n * 3 * sizeof(Segment2d));
-	indexPtr = map = Blt_AssertMalloc(n * 3 * sizeof(int));
+	segPtr = bars = malloc(n * 3 * sizeof(Segment2d));
+	indexPtr = map = malloc(n * 3 * sizeof(int));
 	for (i = 0; i < n; i++) {
 	    double x, y;
 	    double high, low;
@@ -1446,8 +1446,8 @@ MapBarProc(Graph *graphPtr, Element *basePtr)
      * Create an array of bars representing the screen coordinates of all the
      * segments in the bar.
      */
-    bars = Blt_AssertCalloc(nPoints, sizeof(XRectangle));
-    barToData = Blt_AssertCalloc(nPoints, sizeof(int));
+    bars = calloc(nPoints, sizeof(XRectangle));
+    barToData = calloc(nPoints, sizeof(int));
 
     x = elemPtr->x.values, y = elemPtr->y.values;
     count = 0;
@@ -1647,7 +1647,7 @@ MapBarProc(Graph *graphPtr, Element *basePtr)
 	MapErrorBars(graphPtr, elemPtr, dataToStyle);
     }
     MergePens(elemPtr, dataToStyle);
-    Blt_Free(dataToStyle);
+    free(dataToStyle);
 }
 
 /*
@@ -2225,7 +2225,7 @@ DestroyBarProc(Graph *graphPtr, Element *basePtr)
 	Blt_Chain_Destroy(elemPtr->stylePalette);
     }
     if (elemPtr->activeIndices != NULL) {
-	Blt_Free(elemPtr->activeIndices);
+	free(elemPtr->activeIndices);
     }
 }
 
@@ -2265,15 +2265,15 @@ Blt_BarElement(Graph *graphPtr, const char *name, ClassId classId)
 {
     BarElement *elemPtr;
 
-    elemPtr = Blt_AssertCalloc(1, sizeof(BarElement));
+    elemPtr = calloc(1, sizeof(BarElement));
     elemPtr->procsPtr = &barProcs;
     elemPtr->configSpecs = barElemConfigSpecs;
     elemPtr->legendRelief = TK_RELIEF_FLAT;
     Blt_GraphSetObjectClass(&elemPtr->obj, classId);
-    elemPtr->obj.name = Blt_AssertStrdup(name);
+    elemPtr->obj.name = Blt_Strdup(name);
     elemPtr->obj.graphPtr = graphPtr;
     /* By default, an element's name and label are the same. */
-    elemPtr->label = Blt_AssertStrdup(name);
+    elemPtr->label = Blt_Strdup(name);
     elemPtr->builtinPenPtr = &elemPtr->builtinPen;
     InitializeBarPen(elemPtr->builtinPenPtr);
     elemPtr->stylePalette = Blt_Chain_Create();
@@ -2352,7 +2352,7 @@ Blt_InitBarSetTable(Graph *graphPtr)
 	    key.axes.y = NULL;
 	    hPtr = Blt_CreateHashEntry(&setTable, (char *)&key, &isNew);
 	    if (isNew) {
-		tablePtr = Blt_AssertMalloc(sizeof(Blt_HashTable));
+		tablePtr = malloc(sizeof(Blt_HashTable));
 		Blt_InitHashTable(tablePtr, BLT_STRING_KEYS);
 		Blt_SetHashValue(hPtr, tablePtr);
 	    } else {
@@ -2396,7 +2396,7 @@ Blt_InitBarSetTable(Graph *graphPtr)
 	Blt_HashEntry *hPtr;
 	Blt_HashSearch iter;
 
-	graphPtr->barGroups = Blt_AssertCalloc(sum, sizeof(BarGroup));
+	graphPtr->barGroups = calloc(sum, sizeof(BarGroup));
 	groupPtr = graphPtr->barGroups;
 	for (hPtr = Blt_FirstHashEntry(&graphPtr->setTable, &iter); 
 	     hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
@@ -2526,7 +2526,7 @@ Blt_DestroyBarSets(Graph *graphPtr)
     Blt_HashEntry *hPtr;
 
     if (graphPtr->barGroups != NULL) {
-	Blt_Free(graphPtr->barGroups);
+	free(graphPtr->barGroups);
 	graphPtr->barGroups = NULL;
     }
     graphPtr->nBarGroups = 0;
@@ -2536,7 +2536,7 @@ Blt_DestroyBarSets(Graph *graphPtr)
 	
 	tablePtr = Blt_GetHashValue(hPtr);
 	Blt_DeleteHashTable(tablePtr);
-	Blt_Free(tablePtr);
+	free(tablePtr);
     }
     Blt_DeleteHashTable(&graphPtr->setTable);
     Blt_InitHashTable(&graphPtr->setTable, sizeof(BarSetKey) / sizeof(int));
diff --git a/src/bltGrElemLine.C b/src/bltGrElemLine.C
index 82234da..4028e5b 100644
--- a/src/bltGrElemLine.C
+++ b/src/bltGrElemLine.C
@@ -1437,9 +1437,9 @@ Blt_LinePen(const char *penName)
 {
     LinePen *penPtr;
 
-    penPtr = Blt_AssertCalloc(1, sizeof(LinePen));
+    penPtr = calloc(1, sizeof(LinePen));
     InitLinePen(penPtr);
-    penPtr->name = Blt_AssertStrdup(penName);
+    penPtr->name = Blt_Strdup(penName);
     penPtr->classId = CID_ELEM_LINE;
     if (strcmp(penName, "activeLine") == 0) {
 	penPtr->flags = ACTIVE_PEN;
@@ -1552,8 +1552,8 @@ GetScreenPoints(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr)
     np = NUMBEROFPOINTS(elemPtr);
     x = elemPtr->x.values;
     y = elemPtr->y.values;
-    points = Blt_AssertMalloc(sizeof(Point2d) * np);
-    map = Blt_AssertMalloc(sizeof(int) * np);
+    points = malloc(sizeof(Point2d) * np);
+    map = malloc(sizeof(int) * np);
 
     count = 0;			      /* Count the valid screen coordinates */
     if (graphPtr->inverted) {
@@ -1603,9 +1603,9 @@ ReducePoints(MapInfo *mapPtr, double tolerance)
     Point2d *screenPts;
     int *map, *simple;
 
-    simple    = Blt_AssertMalloc(mapPtr->nScreenPts * sizeof(int));
-    map	      = Blt_AssertMalloc(mapPtr->nScreenPts * sizeof(int));
-    screenPts = Blt_AssertMalloc(mapPtr->nScreenPts * sizeof(Point2d));
+    simple    = malloc(mapPtr->nScreenPts * sizeof(int));
+    map	      = malloc(mapPtr->nScreenPts * sizeof(int));
+    screenPts = malloc(mapPtr->nScreenPts * sizeof(Point2d));
     np = Blt_SimplifyLine(mapPtr->screenPts, 0, mapPtr->nScreenPts - 1, 
 		 tolerance, simple);
     for (i = 0; i < np; i++) {
@@ -1620,9 +1620,9 @@ ReducePoints(MapInfo *mapPtr, double tolerance)
 	fprintf(stderr, "reduced from %d to %d\n", mapPtr->nScreenPts, np);
     }
 #endif
-    Blt_Free(mapPtr->screenPts);
-    Blt_Free(mapPtr->map);
-    Blt_Free(simple);
+    free(mapPtr->screenPts);
+    free(mapPtr->map);
+    free(simple);
     mapPtr->screenPts = screenPts;
     mapPtr->map = map;
     mapPtr->nScreenPts = np;
@@ -1654,8 +1654,8 @@ GenerateSteps(MapInfo *mapPtr)
     int *map;
 
     newSize = ((mapPtr->nScreenPts - 1) * 2) + 1;
-    screenPts = Blt_AssertMalloc(newSize * sizeof(Point2d));
-    map = Blt_AssertMalloc(sizeof(int) * newSize);
+    screenPts = malloc(newSize * sizeof(Point2d));
+    map = malloc(sizeof(int) * newSize);
     screenPts[0] = mapPtr->screenPts[0];
     map[0] = 0;
 
@@ -1671,8 +1671,8 @@ GenerateSteps(MapInfo *mapPtr)
 	map[count] = map[count + 1] = mapPtr->map[i];
 	count += 2;
     }
-    Blt_Free(mapPtr->screenPts);
-    Blt_Free(mapPtr->map);
+    free(mapPtr->screenPts);
+    free(mapPtr->map);
     mapPtr->map = map;
     mapPtr->screenPts = screenPts;
     mapPtr->nScreenPts = newSize;
@@ -1733,8 +1733,8 @@ GenerateSpline(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr)
 	return;
     }
     niPts = nOrigPts + extra + 1;
-    iPts = Blt_AssertMalloc(niPts * sizeof(Point2d));
-    map = Blt_AssertMalloc(sizeof(int) * niPts);
+    iPts = malloc(niPts * sizeof(Point2d));
+    map = malloc(sizeof(int) * niPts);
     /* Populate the x2 array with both the original X-coordinates and extra
      * X-coordinates for each horizontal pixel that the line segment
      * contains. */
@@ -1788,11 +1788,11 @@ GenerateSpline(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr)
 	/* The spline interpolation failed.  We'll fallback to the current
 	 * coordinates and do no smoothing (standard line segments).  */
 	elemPtr->smooth = PEN_SMOOTH_LINEAR;
-	Blt_Free(iPts);
-	Blt_Free(map);
+	free(iPts);
+	free(map);
     } else {
-	Blt_Free(mapPtr->screenPts);
-	Blt_Free(mapPtr->map);
+	free(mapPtr->screenPts);
+	free(mapPtr->map);
 	mapPtr->map = map;
 	mapPtr->screenPts = iPts;
 	mapPtr->nScreenPts = niPts;
@@ -1853,8 +1853,8 @@ GenerateParametricSpline(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr)
 	}
     }
     niPts = count;
-    iPts = Blt_AssertMalloc(niPts * sizeof(Point2d));
-    map = Blt_AssertMalloc(sizeof(int) * niPts);
+    iPts = malloc(niPts * sizeof(Point2d));
+    map = malloc(sizeof(int) * niPts);
 
     /* 
      * FIXME: This is just plain wrong.  The spline should be computed
@@ -1920,11 +1920,11 @@ GenerateParametricSpline(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr)
         /* The spline interpolation failed.  We will fall back to the current
          * coordinates and do no smoothing (standard line segments).  */
         elemPtr->smooth = PEN_SMOOTH_LINEAR;
-        Blt_Free(iPts);
-        Blt_Free(map);
+        free(iPts);
+        free(map);
     } else {
-        Blt_Free(mapPtr->screenPts);
-        Blt_Free(mapPtr->map);
+        free(mapPtr->screenPts);
+        free(mapPtr->map);
         mapPtr->map = map;
         mapPtr->screenPts = iPts;
         mapPtr->nScreenPts = niPts;
@@ -1956,8 +1956,8 @@ MapSymbols(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr)
     int *map;
     int i, count;
 
-    points = Blt_AssertMalloc(sizeof(Point2d) * mapPtr->nScreenPts);
-    map    = Blt_AssertMalloc(sizeof(int)     * mapPtr->nScreenPts);
+    points = malloc(sizeof(Point2d) * mapPtr->nScreenPts);
+    map    = malloc(sizeof(int)     * mapPtr->nScreenPts);
 
     Blt_GraphExtents(graphPtr, &exts);
     count = 0;			/* Count the number of visible points */
@@ -1999,16 +1999,16 @@ MapActiveSymbols(Graph *graphPtr, LineElement *elemPtr)
     int count, i, np;
 
     if (elemPtr->activePts.points != NULL) {
-	Blt_Free(elemPtr->activePts.points);
+	free(elemPtr->activePts.points);
 	elemPtr->activePts.points = NULL;
     }
     if (elemPtr->activePts.map != NULL) {
-	Blt_Free(elemPtr->activePts.map);
+	free(elemPtr->activePts.map);
 	elemPtr->activePts.map = NULL;
     }
     Blt_GraphExtents(graphPtr, &exts);
-    points = Blt_AssertMalloc(sizeof(Point2d) * elemPtr->nActiveIndices);
-    map    = Blt_AssertMalloc(sizeof(int)     * elemPtr->nActiveIndices);
+    points = malloc(sizeof(Point2d) * elemPtr->nActiveIndices);
+    map    = malloc(sizeof(int)     * elemPtr->nActiveIndices);
     np = NUMBEROFPOINTS(elemPtr);
     count = 0;				/* Count the visible active points */
     for (i = 0; i < elemPtr->nActiveIndices; i++) {
@@ -2032,8 +2032,8 @@ MapActiveSymbols(Graph *graphPtr, LineElement *elemPtr)
 	elemPtr->activePts.map = map;
     } else {
 	/* No active points were visible. */
-	Blt_Free(points);
-	Blt_Free(map);	
+	free(points);
+	free(map);	
     }
     elemPtr->activePts.length = count;
     elemPtr->flags &= ~ACTIVE_PENDING;
@@ -2064,13 +2064,13 @@ MapStrip(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr)
     Segment2d *sp;
     int count;
 
-    indices = Blt_AssertMalloc(sizeof(int) * mapPtr->nScreenPts);
+    indices = malloc(sizeof(int) * mapPtr->nScreenPts);
 
     /* 
      * Create array to hold points for line segments (not polyline
      * coordinates).  So allocate twice the number of points.
      */
-    sp = lines = Blt_AssertMalloc(mapPtr->nScreenPts * sizeof(Segment2d));
+    sp = lines = malloc(mapPtr->nScreenPts * sizeof(Segment2d));
     Blt_GraphExtents(graphPtr, &exts);
     count = 0;				/* Count the number of segments. */
     indexPtr = mapPtr->map;
@@ -2133,8 +2133,8 @@ MergePens(LineElement *elemPtr, LineStyle **styleMap)
 	int *ip;
 	int *map;
 
-	segments = Blt_AssertMalloc(elemPtr->lines.length * sizeof(Segment2d));
-	map = Blt_AssertMalloc(elemPtr->lines.length * sizeof(int));
+	segments = malloc(elemPtr->lines.length * sizeof(Segment2d));
+	map = malloc(elemPtr->lines.length * sizeof(int));
 	sp = segments, ip = map;
 	for (link = Blt_Chain_FirstLink(elemPtr->styles); 
 	     link != NULL; link = Blt_Chain_NextLink(link)) {
@@ -2154,9 +2154,9 @@ MergePens(LineElement *elemPtr, LineStyle **styleMap)
 	    }
 	    stylePtr->lines.length = sp - stylePtr->lines.segments;
 	}
-	Blt_Free(elemPtr->lines.segments);
+	free(elemPtr->lines.segments);
 	elemPtr->lines.segments = segments;
-	Blt_Free(elemPtr->lines.map);
+	free(elemPtr->lines.map);
 	elemPtr->lines.map = map;
     }
     if (elemPtr->symbolPts.length > 0) {
@@ -2165,8 +2165,8 @@ MergePens(LineElement *elemPtr, LineStyle **styleMap)
 	Point2d *points, *pp;
 	int *map;
 
-	points = Blt_AssertMalloc(elemPtr->symbolPts.length * sizeof(Point2d));
-	map = Blt_AssertMalloc(elemPtr->symbolPts.length * sizeof(int));
+	points = malloc(elemPtr->symbolPts.length * sizeof(Point2d));
+	map = malloc(elemPtr->symbolPts.length * sizeof(int));
 	pp = points, ip = map;
 	for (link = Blt_Chain_FirstLink(elemPtr->styles); 
 	     link != NULL; link = Blt_Chain_NextLink(link)) {
@@ -2186,8 +2186,8 @@ MergePens(LineElement *elemPtr, LineStyle **styleMap)
 	    }
 	    stylePtr->symbolPts.length = pp - stylePtr->symbolPts.points;
 	}
-	Blt_Free(elemPtr->symbolPts.points);
-	Blt_Free(elemPtr->symbolPts.map);
+	free(elemPtr->symbolPts.points);
+	free(elemPtr->symbolPts.map);
 	elemPtr->symbolPts.points = points;
 	elemPtr->symbolPts.map = map;
     }
@@ -2196,8 +2196,8 @@ MergePens(LineElement *elemPtr, LineStyle **styleMap)
 	int *map, *ip;
 	Blt_ChainLink link;
 
-	segments = Blt_AssertMalloc(elemPtr->xeb.length * sizeof(Segment2d));
-	map = Blt_AssertMalloc(elemPtr->xeb.length * sizeof(int));
+	segments = malloc(elemPtr->xeb.length * sizeof(Segment2d));
+	map = malloc(elemPtr->xeb.length * sizeof(int));
 	sp = segments, ip = map;
 	for (link = Blt_Chain_FirstLink(elemPtr->styles); 
 	     link != NULL; link = Blt_Chain_NextLink(link)) {
@@ -2217,8 +2217,8 @@ MergePens(LineElement *elemPtr, LineStyle **styleMap)
 	    }
 	    stylePtr->xeb.length = sp - stylePtr->xeb.segments;
 	}
-	Blt_Free(elemPtr->xeb.segments);
-	Blt_Free(elemPtr->xeb.map);
+	free(elemPtr->xeb.segments);
+	free(elemPtr->xeb.map);
 	elemPtr->xeb.segments = segments;
 	elemPtr->xeb.map = map;
     }
@@ -2227,8 +2227,8 @@ MergePens(LineElement *elemPtr, LineStyle **styleMap)
 	int *map, *ip;
 	Blt_ChainLink link;
 
-	segments = Blt_AssertMalloc(elemPtr->yeb.length * sizeof(Segment2d));
-	map = Blt_AssertMalloc(elemPtr->yeb.length * sizeof(int));
+	segments = malloc(elemPtr->yeb.length * sizeof(Segment2d));
+	map = malloc(elemPtr->yeb.length * sizeof(int));
 	sp = segments, ip = map;
 	for (link = Blt_Chain_FirstLink(elemPtr->styles); 
 	     link != NULL; link = Blt_Chain_NextLink(link)) {
@@ -2248,9 +2248,9 @@ MergePens(LineElement *elemPtr, LineStyle **styleMap)
 	    }
 	    stylePtr->yeb.length = sp - stylePtr->yeb.segments;
 	}
-	Blt_Free(elemPtr->yeb.segments);
+	free(elemPtr->yeb.segments);
 	elemPtr->yeb.segments = segments;
-	Blt_Free(elemPtr->yeb.map);
+	free(elemPtr->yeb.map);
 	elemPtr->yeb.map = map;
     }
 }
@@ -2353,9 +2353,9 @@ SaveTrace(
     int *map;
     int i, j;
 
-    tracePtr  = Blt_AssertMalloc(sizeof(Trace));
-    screenPts = Blt_AssertMalloc(sizeof(Point2d) * length);
-    map       = Blt_AssertMalloc(sizeof(int) * length);
+    tracePtr  = malloc(sizeof(Trace));
+    screenPts = malloc(sizeof(Point2d) * length);
+    map       = malloc(sizeof(int) * length);
 
     /* Copy the screen coordinates of the trace into the point array */
 
@@ -2404,9 +2404,9 @@ FreeTraces(LineElement *elemPtr)
 	Trace *tracePtr;
 
 	tracePtr = Blt_Chain_GetValue(link);
-	Blt_Free(tracePtr->screenPts.map);
-	Blt_Free(tracePtr->screenPts.points);
-	Blt_Free(tracePtr);
+	free(tracePtr->screenPts.map);
+	free(tracePtr->screenPts.points);
+	free(tracePtr);
     }
     Blt_Chain_Destroy(elemPtr->traces);
     elemPtr->traces = NULL;
@@ -2516,7 +2516,7 @@ MapFillArea(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr)
     int np;
 
     if (elemPtr->fillPts != NULL) {
-	Blt_Free(elemPtr->fillPts);
+	free(elemPtr->fillPts);
 	elemPtr->fillPts = NULL;
 	elemPtr->nFillPts = 0;
     }
@@ -2526,7 +2526,7 @@ MapFillArea(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr)
     np = mapPtr->nScreenPts + 3;
     Blt_GraphExtents(graphPtr, &exts);
 
-    origPts = Blt_AssertMalloc(sizeof(Point2d) * np);
+    origPts = malloc(sizeof(Point2d) * np);
     if (graphPtr->inverted) {
 	double minX;
 	int i;
@@ -2571,12 +2571,12 @@ MapFillArea(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr)
 	origPts[i] = origPts[0];
     }
 
-    clipPts = Blt_AssertMalloc(sizeof(Point2d) * np * 3);
+    clipPts = malloc(sizeof(Point2d) * np * 3);
     np = Blt_PolyRectClip(&exts, origPts, np - 1, clipPts);
 
-    Blt_Free(origPts);
+    free(origPts);
     if (np < 3) {
-	Blt_Free(clipPts);
+	free(clipPts);
     } else {
 	elemPtr->fillPts = clipPts;
 	elemPtr->nFillPts = np;
@@ -2589,34 +2589,34 @@ ResetLine(LineElement *elemPtr)
     FreeTraces(elemPtr);
     ResetStylePalette(elemPtr->styles);
     if (elemPtr->symbolPts.points != NULL) {
-	Blt_Free(elemPtr->symbolPts.points);
+	free(elemPtr->symbolPts.points);
     }
     if (elemPtr->symbolPts.map != NULL) {
-	Blt_Free(elemPtr->symbolPts.map);
+	free(elemPtr->symbolPts.map);
     }
     if (elemPtr->lines.segments != NULL) {
-	Blt_Free(elemPtr->lines.segments);
+	free(elemPtr->lines.segments);
     }
     if (elemPtr->lines.map != NULL) {
-	Blt_Free(elemPtr->lines.map);
+	free(elemPtr->lines.map);
     }
     if (elemPtr->activePts.points != NULL) {
-	Blt_Free(elemPtr->activePts.points);
+	free(elemPtr->activePts.points);
     }
     if (elemPtr->activePts.map != NULL) {
-	Blt_Free(elemPtr->activePts.map);
+	free(elemPtr->activePts.map);
     }
     if (elemPtr->xeb.segments != NULL) {
-	Blt_Free(elemPtr->xeb.segments);
+	free(elemPtr->xeb.segments);
     }
     if (elemPtr->xeb.map != NULL) {
-	Blt_Free(elemPtr->xeb.map);
+	free(elemPtr->xeb.map);
     }
     if (elemPtr->yeb.segments != NULL) {
-	Blt_Free(elemPtr->yeb.segments);
+	free(elemPtr->yeb.segments);
     }
     if (elemPtr->yeb.map != NULL) {
-	Blt_Free(elemPtr->yeb.map);
+	free(elemPtr->yeb.map);
     }
     elemPtr->xeb.segments = elemPtr->yeb.segments = elemPtr->lines.segments = NULL;
     elemPtr->symbolPts.points = elemPtr->activePts.points = NULL;
@@ -2662,8 +2662,8 @@ MapErrorBars(Graph *graphPtr, LineElement *elemPtr, LineStyle **styleMap)
 	int *indexPtr;
 	int i;
 		
-	segPtr = errorBars = Blt_AssertMalloc(n * 3 * sizeof(Segment2d));
-	indexPtr = errorToData = Blt_AssertMalloc(n * 3 * sizeof(int));
+	segPtr = errorBars = malloc(n * 3 * sizeof(Segment2d));
+	indexPtr = errorToData = malloc(n * 3 * sizeof(int));
 	for (i = 0; i < n; i++) {
 	    double x, y;
 	    double high, low;
@@ -2726,8 +2726,8 @@ MapErrorBars(Graph *graphPtr, LineElement *elemPtr, LineStyle **styleMap)
 	int *indexPtr;
 	int i;
 		
-	segPtr = errorBars = Blt_AssertMalloc(n * 3 * sizeof(Segment2d));
-	indexPtr = errorToData = Blt_AssertMalloc(n * 3 * sizeof(int));
+	segPtr = errorBars = malloc(n * 3 * sizeof(Segment2d));
+	indexPtr = errorToData = malloc(n * 3 * sizeof(int));
 	for (i = 0; i < n; i++) {
 	    double x, y;
 	    double high, low;
@@ -2865,8 +2865,8 @@ MapLineProc(Graph *graphPtr, Element *basePtr)
 	    MapTraces(graphPtr, elemPtr, &mi);
 	}
     }
-    Blt_Free(mi.screenPts);
-    Blt_Free(mi.map);
+    free(mi.screenPts);
+    free(mi.map);
 
     /* Set the symbol size of all the pen styles. */
     for (link = Blt_Chain_FirstLink(elemPtr->styles); link != NULL;
@@ -2889,7 +2889,7 @@ MapLineProc(Graph *graphPtr, Element *basePtr)
 	MapErrorBars(graphPtr, elemPtr, styleMap);
     }
     MergePens(elemPtr, styleMap);
-    Blt_Free(styleMap);
+    free(styleMap);
 }
 
 static double
@@ -3565,7 +3565,7 @@ DrawCircles(Display *display, Drawable drawable, LineElement *elemPtr,
     int count;
 
     s = radius + radius;
-    arcs = Blt_AssertMalloc(nSymbolPts * sizeof(XArc));
+    arcs = malloc(nSymbolPts * sizeof(XArc));
 
     if (elemPtr->symbolInterval > 0) {
 	Point2d *pp, *pend;
@@ -3611,7 +3611,7 @@ DrawCircles(Display *display, Drawable drawable, LineElement *elemPtr,
 	    XDrawArcs(display, drawable, penPtr->symbol.outlineGC, arcs + i, n);
 	}
     }
-    Blt_Free(arcs);
+    free(arcs);
 }
 
 #endif
@@ -3626,7 +3626,7 @@ DrawSquares(Display *display, Drawable drawable, LineElement *elemPtr,
     int s, count;
 
     s = r + r;
-    rectangles = Blt_AssertMalloc(nSymbolPts * sizeof(XRectangle));
+    rectangles = malloc(nSymbolPts * sizeof(XRectangle));
     if (elemPtr->symbolInterval > 0) {
 	Point2d *pp, *pend;
 	XRectangle *rp;
@@ -3670,7 +3670,7 @@ DrawSquares(Display *display, Drawable drawable, LineElement *elemPtr,
 	    XDrawRectangles(display, drawable, penPtr->symbol.outlineGC, rp, n);
 	}
     }
-    Blt_Free(rectangles);
+    free(rectangles);
 }
 
 /*
@@ -3711,7 +3711,7 @@ DrawSymbols(
 	    Point2d *pp, *endp;
 	    XPoint *points, *xpp;
 	    
-	    xpp = points = Blt_AssertMalloc(nSymbolPts * sizeof(XPoint));
+	    xpp = points = malloc(nSymbolPts * sizeof(XPoint));
 	    for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) {
 		xpp->x = Round(pp->x);
 		xpp->y = Round(pp->y);
@@ -3719,7 +3719,7 @@ DrawSymbols(
 	    }
 	    XDrawPoints(graphPtr->display, drawable, penPtr->symbol.fillGC, 
 			points, nSymbolPts, CoordModeOrigin);
-	    Blt_Free(points);
+	    free(points);
 	}
 	return;
     }
@@ -3757,7 +3757,7 @@ DrawSymbols(
 		pattern[0].x = pattern[2].y = -r2;
 		pattern[1].x = pattern[3].y = r2;
 	    }
-	    segments = Blt_AssertMalloc(nSymbolPts * 2 * sizeof(XSegment));
+	    segments = malloc(nSymbolPts * 2 * sizeof(XSegment));
 	    if (elemPtr->symbolInterval > 0) {
 		Point2d *pp, *endp;
 		XSegment *sp;
@@ -3813,7 +3813,7 @@ DrawSymbols(
 		XDrawSegments(graphPtr->display, drawable, 
 			penPtr->symbol.outlineGC, segments + i, chunk);
 	    }
-	    Blt_Free(segments);
+	    free(segments);
 	}
 	break;
 
@@ -3861,7 +3861,7 @@ DrawSymbols(
 		}
 		pattern[12] = pattern[0];
 	    }
-	    polygon = Blt_AssertMalloc(nSymbolPts * 13 * sizeof(XPoint));
+	    polygon = malloc(nSymbolPts * 13 * sizeof(XPoint));
 	    if (elemPtr->symbolInterval > 0) {
 		Point2d *pp, *endp;
 		XPoint *xpp;
@@ -3920,7 +3920,7 @@ DrawSymbols(
 			penPtr->symbol.outlineGC, xpp, 13, CoordModeOrigin);
 		}
 	    }
-	    Blt_Free(polygon);
+	    free(polygon);
 	}
 	break;
 
@@ -3943,7 +3943,7 @@ DrawSymbols(
 	    pattern[3].y = pattern[2].x = r1;
 	    pattern[4] = pattern[0];
 
-	    polygon = Blt_AssertMalloc(nSymbolPts * 5 * sizeof(XPoint));
+	    polygon = malloc(nSymbolPts * 5 * sizeof(XPoint));
 	    if (elemPtr->symbolInterval > 0) {
 		Point2d *pp, *endp;
 		XPoint *xpp;
@@ -4003,7 +4003,7 @@ DrawSymbols(
 		       penPtr->symbol.outlineGC, xpp, 5, CoordModeOrigin);
 		}
 	    }
-	    Blt_Free(polygon);
+	    free(polygon);
 	}
 	break;
 
@@ -4046,7 +4046,7 @@ DrawSymbols(
 		pattern[2].y = pattern[1].y = h2;
 		pattern[2].x = -b2;
 	    }
-	    polygon = Blt_AssertMalloc(nSymbolPts * 4 * sizeof(XPoint));
+	    polygon = malloc(nSymbolPts * 4 * sizeof(XPoint));
 	    if (elemPtr->symbolInterval > 0) {
 		Point2d *pp, *endp;
 		XPoint *xpp;
@@ -4107,7 +4107,7 @@ DrawSymbols(
 			penPtr->symbol.outlineGC, xpp, 4, CoordModeOrigin);
 		}
 	    }
-	    Blt_Free(polygon);
+	    free(polygon);
 	}
 	break;
 
@@ -4301,7 +4301,7 @@ DrawTraces(
     } else {
 	np = Blt_MaxRequestSize(graphPtr->display, sizeof(POINT)) - 1;
     }
-    points = Blt_AssertMalloc((np + 1) * sizeof(POINT));
+    points = malloc((np + 1) * sizeof(POINT));
 
     dc = TkWinGetDrawableDC(graphPtr->display, drawable, &state);
 
@@ -4368,7 +4368,7 @@ DrawTraces(
 	    Polyline(dc, points, remaining + 1);
 	}
     }
-    Blt_Free(points);
+    free(points);
     DeletePen(SelectPen(dc, oldPen));
     DeleteBrush(SelectBrush(dc, oldBrush));
     TkWinReleaseDrawableDC(drawable, dc, &state);
@@ -4385,7 +4385,7 @@ DrawTraces(Graph *graphPtr, Drawable drawable, LineElement *elemPtr,
     int np;
 
     np = Blt_MaxRequestSize(graphPtr->display, sizeof(XPoint)) - 1;
-    points = Blt_AssertMalloc((np + 1) * sizeof(XPoint));
+    points = malloc((np + 1) * sizeof(XPoint));
 	    
     for (link = Blt_Chain_FirstLink(elemPtr->traces); link != NULL;
 	link = Blt_Chain_NextLink(link)) {
@@ -4445,7 +4445,7 @@ DrawTraces(Graph *graphPtr, Drawable drawable, LineElement *elemPtr,
 		remaining + 1, CoordModeOrigin);
 	}
     }
-    Blt_Free(points);
+    free(points);
 }
 #endif /* WIN32 */
 
@@ -4587,7 +4587,7 @@ DrawNormalLineProc(Graph *graphPtr, Drawable drawable, Element *basePtr)
 	XPoint *points;
 	Point2d *endp, *pp;
 
-	points = Blt_AssertMalloc(sizeof(XPoint) * elemPtr->nFillPts);
+	points = malloc(sizeof(XPoint) * elemPtr->nFillPts);
 	count = 0;
 	for (pp = elemPtr->fillPts, endp = pp + elemPtr->nFillPts; 
 	     pp < endp; pp++) {
@@ -4600,7 +4600,7 @@ DrawNormalLineProc(Graph *graphPtr, Drawable drawable, Element *basePtr)
 	    Blt_FillBackgroundPolygon(graphPtr->tkwin, drawable, 
 		elemPtr->fillBg, points, elemPtr->nFillPts, 0, TK_RELIEF_FLAT);
 	}
-	Blt_Free(points);
+	free(points);
     }
 
     /* Lines: stripchart segments or graph traces. */
@@ -5159,10 +5159,10 @@ DestroyLineProc(Graph *graphPtr, Element *basePtr)
 	Blt_Chain_Destroy(elemPtr->styles);
     }
     if (elemPtr->activeIndices != NULL) {
-	Blt_Free(elemPtr->activeIndices);
+	free(elemPtr->activeIndices);
     }
     if (elemPtr->fillPts != NULL) {
-	Blt_Free(elemPtr->fillPts);
+	free(elemPtr->fillPts);
     }
     if (elemPtr->fillGC != NULL) {
 	Tk_FreeGC(graphPtr->display, elemPtr->fillGC);
@@ -5208,19 +5208,19 @@ Blt_LineElement(Graph *graphPtr, const char *name, ClassId classId)
 {
     LineElement *elemPtr;
 
-    elemPtr = Blt_AssertCalloc(1, sizeof(LineElement));
+    elemPtr = calloc(1, sizeof(LineElement));
     elemPtr->procsPtr = &lineProcs;
     if (classId == CID_ELEM_LINE) {
 	elemPtr->configSpecs = lineElemConfigSpecs;
     } else {
 	elemPtr->configSpecs = stripElemConfigSpecs;
     }
-    elemPtr->obj.name = Blt_AssertStrdup(name);
+    elemPtr->obj.name = Blt_Strdup(name);
     Blt_GraphSetObjectClass(&elemPtr->obj, classId);
     elemPtr->flags = SCALE_SYMBOL;
     elemPtr->obj.graphPtr = graphPtr;
     /* By default an element's name and label are the same. */
-    elemPtr->label = Blt_AssertStrdup(name);
+    elemPtr->label = Blt_Strdup(name);
     elemPtr->legendRelief = TK_RELIEF_FLAT;
     elemPtr->penDir = PEN_BOTH_DIRECTIONS;
     elemPtr->styles = Blt_Chain_Create();
@@ -5318,8 +5318,8 @@ MapLineProc(Graph *graphPtr, Element *basePtr)
 	    MapTraces(graphPtr, elemPtr, &mi);
 	}
     }
-    Blt_Free(mi.screenPts);
-    Blt_Free(mi.map);
+    free(mi.screenPts);
+    free(mi.map);
 
     /* Set the symbol size of all the pen styles. */
     for (link = Blt_Chain_FirstLink(elemPtr->styles); link != NULL;
@@ -5342,6 +5342,6 @@ MapLineProc(Graph *graphPtr, Element *basePtr)
 	MapErrorBars(graphPtr, elemPtr, styleMap);
     }
     MergePens(elemPtr, styleMap);
-    Blt_Free(styleMap);
+    free(styleMap);
 }
 #endif
diff --git a/src/bltGrElemLineSpline.C b/src/bltGrElemLineSpline.C
index 3f3b621..77fdb3c 100644
--- a/src/bltGrElemLineSpline.C
+++ b/src/bltGrElemLineSpline.C
@@ -750,12 +750,12 @@ Blt_QuadraticSpline(Point2d *origPts, int nOrigPts, Point2d *intpPts,
     double *work;
     int result;
 
-    work = Blt_AssertMalloc(nOrigPts * sizeof(double));
+    work = malloc(nOrigPts * sizeof(double));
     epsilon = 0.0;		/* TBA: adjust error via command-line option */
     /* allocate space for vectors used in calculation */
     QuadSlopes(origPts, work, nOrigPts);
     result = QuadEval(origPts, nOrigPts, intpPts, nIntpPts, work, epsilon);
-    Blt_Free(work);
+    free(work);
     if (result > 1) {
 	return FALSE;
     }
@@ -787,7 +787,7 @@ Blt_NaturalSpline(Point2d *origPts, int nOrigPts, Point2d *intpPts,
     int isKnot;
     int i, j, n;
 
-    dx = Blt_AssertMalloc(sizeof(double) * nOrigPts);
+    dx = malloc(sizeof(double) * nOrigPts);
     /* Calculate vector of differences */
     for (i = 0, j = 1; j < nOrigPts; i++, j++) {
 	dx[i] = origPts[j].x - origPts[i].x;
@@ -796,9 +796,9 @@ Blt_NaturalSpline(Point2d *origPts, int nOrigPts, Point2d *intpPts,
 	}
     }
     n = nOrigPts - 1;		/* Number of intervals. */
-    A = Blt_AssertMalloc(sizeof(TriDiagonalMatrix) * nOrigPts);
+    A = malloc(sizeof(TriDiagonalMatrix) * nOrigPts);
     if (A == NULL) {
-	Blt_Free(dx);
+	free(dx);
 	return 0;
     }
     /* Vectors to solve the tridiagonal matrix */
@@ -815,10 +815,10 @@ Blt_NaturalSpline(Point2d *origPts, int nOrigPts, Point2d *intpPts,
 	A[j][2] = (alpha - dx[i] * A[i][2]) / A[j][0];
     }
 
-    eq = Blt_Malloc(sizeof(Cubic2D) * nOrigPts);
+    eq = malloc(sizeof(Cubic2D) * nOrigPts);
     if (eq == NULL) {
-	Blt_Free(A);
-	Blt_Free(dx);
+	free(A);
+	free(dx);
 	return FALSE;
     }
     eq[0].c = eq[n].c = 0.0;
@@ -828,8 +828,8 @@ Blt_NaturalSpline(Point2d *origPts, int nOrigPts, Point2d *intpPts,
 	eq[i].b = (dy) / dx[i] - dx[i] * (eq[j].c + 2.0 * eq[i].c) / 3.0;
 	eq[i].d = (eq[j].c - eq[i].c) / (3.0 * dx[i]);
     }
-    Blt_Free(A);
-    Blt_Free(dx);
+    free(A);
+    free(dx);
 
     /* Now calculate the new values */
     for (ip = intpPts, iend = ip + nIntpPts; ip < iend; ip++) {
@@ -850,7 +850,7 @@ Blt_NaturalSpline(Point2d *origPts, int nOrigPts, Point2d *intpPts,
 	    ip->y = origPts[i].y + x * (eq[i].b + x * (eq[i].c + x * eq[i].d));
 	}
     }
-    Blt_Free(eq);
+    free(eq);
     return TRUE;
 }
 
@@ -931,17 +931,17 @@ SplineCmd(
 	    return TCL_ERROR;
 	}
     }
-    origPts = Blt_Malloc(sizeof(Point2d) * nOrigPts);
+    origPts = malloc(sizeof(Point2d) * nOrigPts);
     if (origPts == NULL) {
 	Tcl_AppendResult(interp, "can't allocate \"", Blt_Itoa(nOrigPts), 
 		"\" points", (char *)NULL);
 	return TCL_ERROR;
     }
-    intpPts = Blt_Malloc(sizeof(Point2d) * nIntpPts);
+    intpPts = malloc(sizeof(Point2d) * nIntpPts);
     if (intpPts == NULL) {
 	Tcl_AppendResult(interp, "can't allocate \"", Blt_Itoa(nIntpPts), 
 		"\" points", (char *)NULL);
-	Blt_Free(origPts);
+	free(origPts);
 	return TCL_ERROR;
     }
     xArr = Blt_VecData(x);
@@ -959,16 +959,16 @@ SplineCmd(
     if (!(*proc) (origPts, nOrigPts, intpPts, nIntpPts)) {
 	Tcl_AppendResult(interp, "error generating spline for \"", 
 		Blt_NameOfVector(splY), "\"", (char *)NULL);
-	Blt_Free(origPts);
-	Blt_Free(intpPts);
+	free(origPts);
+	free(intpPts);
 	return TCL_ERROR;
     }
     yArr = Blt_VecData(splY);
     for (i = 0; i < nIntpPts; i++) {
 	yArr[i] = intpPts[i].y;
     }
-    Blt_Free(origPts);
-    Blt_Free(intpPts);
+    free(origPts);
+    free(intpPts);
 
     /* Finally update the vector. The size of the vector hasn't
      * changed, just the data. Reset the vector using TCL_STATIC to
@@ -1123,13 +1123,13 @@ CubicSlopes(
     double norm, dx, dy;
     TriDiagonalMatrix *A;	/* The tri-diagonal matrix is saved here. */
     
-    spline = Blt_Malloc(sizeof(CubicSpline) * nPoints);
+    spline = malloc(sizeof(CubicSpline) * nPoints);
     if (spline == NULL) {
 	return NULL;
     }
-    A = Blt_Malloc(sizeof(TriDiagonalMatrix) * nPoints);
+    A = malloc(sizeof(TriDiagonalMatrix) * nPoints);
     if (A == NULL) {
-	Blt_Free(spline);
+	free(spline);
 	return NULL;
     }
     /*
@@ -1210,8 +1210,8 @@ CubicSlopes(
     if (SolveCubic1(A, n)) {	/* Cholesky decomposition */
 	SolveCubic2(A, spline, n); /* A * dxdt2 = b_x */
     } else {			/* Should not happen, but who knows ... */
-	Blt_Free(A);
-	Blt_Free(spline);
+	free(A);
+	free(spline);
 	return NULL;
     }
     /* Shift all second derivatives one place right and update the ends. */
@@ -1230,7 +1230,7 @@ CubicSlopes(
 	spline[n + 1].x = spline[n].x;
 	spline[n + 1].y = spline[n].y;
     }
-    Blt_Free( A);
+    free( A);
     return spline;
 }
 
@@ -1333,7 +1333,7 @@ Blt_NaturalParametricSpline(Point2d *origPts, int nOrigPts, Region2d *extsPtr,
 	return 0;
     }
     result= CubicEval(origPts, nOrigPts, intpPts, nIntpPts, spline);
-    Blt_Free(spline);
+    free(spline);
     return result;
 }
 
@@ -1380,7 +1380,7 @@ Blt_CatromParametricSpline(Point2d *points, int nPoints, Point2d *intpPts,
      * that we can select the abscissas of the interpolated points from each
      * pixel horizontally across the plotting area.
      */
-    origPts = Blt_AssertMalloc((nPoints + 4) * sizeof(Point2d));
+    origPts = malloc((nPoints + 4) * sizeof(Point2d));
     memcpy(origPts + 1, points, sizeof(Point2d) * nPoints);
 
     origPts[0] = origPts[1];
@@ -1394,6 +1394,6 @@ Blt_CatromParametricSpline(Point2d *points, int nPoints, Point2d *intpPts,
 	intpPts[i].x = (d.x + t * (c.x + t * (b.x + t * a.x))) / 2.0;
 	intpPts[i].y = (d.y + t * (c.y + t * (b.y + t * a.y))) / 2.0;
     }
-    Blt_Free(origPts);
+    free(origPts);
     return 1;
 }
diff --git a/src/bltGrElemOp.C b/src/bltGrElemOp.C
index 6f509ac..c6886ea 100644
--- a/src/bltGrElemOp.C
+++ b/src/bltGrElemOp.C
@@ -109,7 +109,7 @@ Blt_DestroyTableClients(Graph *graphPtr)
 	if (clientPtr->table != NULL) {
 	    Blt_Table_Close(clientPtr->table);
 	}
-	Blt_Free(clientPtr);
+	free(clientPtr);
     }
     Blt_DeleteHashTable(&graphPtr->dataTables);
 }
@@ -177,9 +177,9 @@ FetchVectorValues(Tcl_Interp *interp, ElemValues *valuesPtr, Blt_Vector *vector)
     double *array;
     
     if (valuesPtr->values == NULL) {
-	array = Blt_Malloc(Blt_VecLength(vector) * sizeof(double));
+	array = malloc(Blt_VecLength(vector) * sizeof(double));
     } else {
-	array = Blt_Realloc(valuesPtr->values, 
+	array = realloc(valuesPtr->values, 
 			    Blt_VecLength(vector) * sizeof(double));
     }
     if (array == NULL) {
@@ -271,7 +271,7 @@ FetchTableValues(Tcl_Interp *interp, ElemValues *valuesPtr, Blt_TableColumn col)
     Blt_Table table;
 
     table = valuesPtr->tableSource.table;
-    array = Blt_Malloc(sizeof(double) * Blt_Table_NumRows(table));
+    array = malloc(sizeof(double) * Blt_Table_NumRows(table));
     if (array == NULL) {
 	return TCL_ERROR;
     }
@@ -287,7 +287,7 @@ FetchTableValues(Tcl_Interp *interp, ElemValues *valuesPtr, Blt_TableColumn col)
 	}
     }
     if (valuesPtr->values != NULL) {
-	Blt_Free(valuesPtr->values);
+	free(valuesPtr->values);
     }
     valuesPtr->nValues = j;
     valuesPtr->values = array;
@@ -319,7 +319,7 @@ FreeTableSource(ElemValues *valuesPtr)
 	    if (srcPtr->table != NULL) {
 		Blt_Table_Close(srcPtr->table);
 	    }
-	    Blt_Free(clientPtr);
+	    free(clientPtr);
 	    Blt_DeleteHashEntry(&graphPtr->dataTables, srcPtr->hashPtr);
 	    srcPtr->hashPtr = NULL;
 	}
@@ -423,7 +423,7 @@ GetTableData(Tcl_Interp *interp, ElemValues *valuesPtr, const char *tableName,
 	if (Blt_Table_Open(interp, tableName, &srcPtr->table) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	clientPtr = Blt_AssertMalloc(sizeof(TableClient));
+	clientPtr = malloc(sizeof(TableClient));
 	clientPtr->table = srcPtr->table;
 	clientPtr->refCount = 1;
 	Blt_SetHashValue(srcPtr->hashPtr, clientPtr);
@@ -469,14 +469,14 @@ ParseValues(Tcl_Interp *interp, Tcl_Obj *objPtr, int *nValuesPtr,
 	double *p;
 	int i;
 
-	array = Blt_Malloc(sizeof(double) * objc);
+	array = malloc(sizeof(double) * objc);
 	if (array == NULL) {
 	    Tcl_AppendResult(interp, "can't allocate new vector", (char *)NULL);
 	    return TCL_ERROR;
 	}
 	for (p = array, i = 0; i < objc; i++, p++) {
 	    if (Blt_ExprDoubleFromObj(interp, objv[i], p) != TCL_OK) {
-		Blt_Free(array);
+		free(array);
 		return TCL_ERROR;
 	    }
 	}
@@ -498,7 +498,7 @@ FreeDataValues(ElemValues *valuesPtr)
 					break;
     }
     if (valuesPtr->values != NULL) {
-	Blt_Free(valuesPtr->values);
+	free(valuesPtr->values);
     }
     valuesPtr->values = NULL;
     valuesPtr->nValues = 0;
@@ -798,7 +798,7 @@ ObjToValuePairs(
     }
     if (nValues & 1) {
 	Tcl_AppendResult(interp, "odd number of data points", (char *)NULL);
-	Blt_Free(values);
+	free(values);
 	return TCL_ERROR;
     }
     nValues /= 2;
@@ -809,14 +809,14 @@ ObjToValuePairs(
 	double *p;
 	int i;
 
-	elemPtr->x.values = Blt_AssertMalloc(newSize);
-	elemPtr->y.values = Blt_AssertMalloc(newSize);
+	elemPtr->x.values = malloc(newSize);
+	elemPtr->y.values = malloc(newSize);
 	elemPtr->x.nValues = elemPtr->y.nValues = nValues;
 	for (p = values, i = 0; i < nValues; i++) {
 	    elemPtr->x.values[i] = *p++;
 	    elemPtr->y.values[i] = *p++;
 	}
-	Blt_Free(values);
+	free(values);
 	FindRange(&elemPtr->x);
 	FindRange(&elemPtr->y);
     }
@@ -1141,7 +1141,7 @@ Blt_StyleMap(Element *elemPtr)
      * Create a style mapping array (data point index to style), 
      * initialized to the default style.
      */
-    dataToStyle = Blt_AssertMalloc(nPoints * sizeof(PenStyle *));
+    dataToStyle = malloc(nPoints * sizeof(PenStyle *));
     for (i = 0; i < nPoints; i++) {
 	dataToStyle[i] = stylePtr;
     }
@@ -1267,12 +1267,12 @@ DestroyElement(Element *elemPtr)
 	Blt_DeleteHashEntry(&graphPtr->elements.table, elemPtr->hashPtr);
     }
     if (elemPtr->obj.name != NULL) {
-	Blt_Free(elemPtr->obj.name);
+	free(elemPtr->obj.name);
     }
     if (elemPtr->label != NULL) {
-	Blt_Free(elemPtr->label);
+	free(elemPtr->label);
     }
-    Blt_Free(elemPtr);
+    free(elemPtr);
 }
 
 static void
@@ -1587,7 +1587,7 @@ ActivateOp(
 	int *activePtr;
 
 	nIndices = objc - 4;
-	activePtr = indices = Blt_AssertMalloc(sizeof(int) * nIndices);
+	activePtr = indices = malloc(sizeof(int) * nIndices);
 	for (i = 4; i < objc; i++) {
 	    if (GetIndex(interp, elemPtr, objv[i], activePtr) != TCL_OK) {
 		return TCL_ERROR;
@@ -1596,7 +1596,7 @@ ActivateOp(
 	}
     }
     if (elemPtr->activeIndices != NULL) {
-	Blt_Free(elemPtr->activeIndices);
+	free(elemPtr->activeIndices);
     }
     elemPtr->nActiveIndices = nIndices;
     elemPtr->activeIndices = indices;
@@ -1986,7 +1986,7 @@ DeactivateOp(
 	}
 	elemPtr->flags &= ~(ACTIVE | ACTIVE_PENDING);
 	if (elemPtr->activeIndices != NULL) {
-	    Blt_Free(elemPtr->activeIndices);
+	    free(elemPtr->activeIndices);
 	    elemPtr->activeIndices = NULL;
 	}
 	elemPtr->nActiveIndices = 0;
diff --git a/src/bltGrHairs.C b/src/bltGrHairs.C
index 86ebb57..6cbd3c4 100644
--- a/src/bltGrHairs.C
+++ b/src/bltGrHairs.C
@@ -282,7 +282,7 @@ Blt_DestroyCrosshairs(Graph *graphPtr)
 	if (chPtr->gc != NULL) {
 	    Blt_FreePrivateGC(graphPtr->display, chPtr->gc);
 	}
-	Blt_Free(chPtr);
+	free(chPtr);
     }
 }
 
@@ -307,7 +307,7 @@ Blt_CreateCrosshairs(Graph *graphPtr)
 {
     Crosshairs *chPtr;
 
-    chPtr = Blt_AssertCalloc(1, sizeof(Crosshairs));
+    chPtr = calloc(1, sizeof(Crosshairs));
     chPtr->hidden = TRUE;
     chPtr->hotSpot.x = chPtr->hotSpot.y = -1;
     graphPtr->crosshairs = chPtr;
diff --git a/src/bltGrLegd.C b/src/bltGrLegd.C
index 9ed3169..88c6c8b 100644
--- a/src/bltGrLegd.C
+++ b/src/bltGrLegd.C
@@ -1752,7 +1752,7 @@ Blt_DestroyLegend(Graph *graphPtr)
 	    Tk_DestroyWindow(tkwin);
 	}
     }
-    Blt_Free(legendPtr);
+    free(legendPtr);
 }
 
 /*
@@ -1773,7 +1773,7 @@ Blt_CreateLegend(Graph *graphPtr)
 {
     Legend *legendPtr;
 
-    legendPtr = Blt_AssertCalloc(1, sizeof(Legend));
+    legendPtr = calloc(1, sizeof(Legend));
     graphPtr->legend = legendPtr;
     legendPtr->graphPtr = graphPtr;
     legendPtr->tkwin = graphPtr->tkwin;
diff --git a/src/bltGrMarker.C b/src/bltGrMarker.C
index c9546f6..7c8e212 100644
--- a/src/bltGrMarker.C
+++ b/src/bltGrMarker.C
@@ -1170,7 +1170,7 @@ ParseCoordinates(
 	return TCL_ERROR;
     }
     nWorldPts = objc / 2;
-    worldPts = Blt_Malloc(nWorldPts * sizeof(Point2d));
+    worldPts = malloc(nWorldPts * sizeof(Point2d));
     if (worldPts == NULL) {
 	Tcl_AppendResult(interp, "can't allocate new coordinate array",
 	    (char *)NULL);
@@ -1186,7 +1186,7 @@ ParseCoordinates(
 	    
 	    if ((GetCoordinate(interp, objv[i], &x) != TCL_OK) ||
 		(GetCoordinate(interp, objv[i + 1], &y) != TCL_OK)) {
-		Blt_Free(worldPts);
+		free(worldPts);
 		return TCL_ERROR;
 	    }
 	    pp->x = x, pp->y = y, pp++;
@@ -1195,7 +1195,7 @@ ParseCoordinates(
     /* Don't free the old coordinate array until we've parsed the new
      * coordinates without errors.  */
     if (markerPtr->worldPts != NULL) {
-	Blt_Free(markerPtr->worldPts);
+	free(markerPtr->worldPts);
     }
     markerPtr->worldPts = worldPts;
     markerPtr->nWorldPts = nWorldPts;
@@ -1215,7 +1215,7 @@ FreeCoordsProc(
     Point2d **pointsPtr = (Point2d **)(widgRec + offset);
 
     if (*pointsPtr != NULL) {
-	Blt_Free(*pointsPtr);
+	free(*pointsPtr);
 	*pointsPtr = NULL;
     }
     markerPtr->nWorldPts = 0;
@@ -1799,7 +1799,7 @@ CreateMarker(
     markerPtr->obj.graphPtr = graphPtr;
     markerPtr->drawUnder = FALSE;
     markerPtr->flags |= MAP_ITEM;
-    markerPtr->obj.name = Blt_AssertStrdup(name);
+    markerPtr->obj.name = Blt_Strdup(name);
     Blt_GraphSetObjectClass(&markerPtr->obj, classId);
     return markerPtr;
 }
@@ -1836,9 +1836,9 @@ DestroyMarker(Marker *markerPtr)
 	Blt_Chain_DeleteLink(graphPtr->markers.displayList, markerPtr->link);
     }
     if (markerPtr->obj.name != NULL) {
-	Blt_Free(markerPtr->obj.name);
+	free(markerPtr->obj.name);
     }
-    Blt_Free(markerPtr);
+    free(markerPtr);
 }
 
 static void
@@ -2359,7 +2359,7 @@ CreateBitmapProc(void)
 {
     BitmapMarker *bmPtr;
 
-    bmPtr = Blt_AssertCalloc(1, sizeof(BitmapMarker));
+    bmPtr = calloc(1, sizeof(BitmapMarker));
     bmPtr->classPtr = &bitmapMarkerClass;
     return (Marker *)bmPtr;
 }
@@ -2706,7 +2706,7 @@ CreateImageProc(void)
 {
     ImageMarker *imPtr;
 
-    imPtr = Blt_AssertCalloc(1, sizeof(ImageMarker));
+    imPtr = calloc(1, sizeof(ImageMarker));
     imPtr->classPtr = &imageMarkerClass;
     return (Marker *)imPtr;
 }
@@ -3026,7 +3026,7 @@ CreateTextProc(void)
 {
     TextMarker *tmPtr;
 
-    tmPtr = Blt_AssertCalloc(1, sizeof(TextMarker));
+    tmPtr = calloc(1, sizeof(TextMarker));
     tmPtr->classPtr = &textMarkerClass;
     Blt_Ts_InitStyle(tmPtr->style);
     tmPtr->style.anchor = TK_ANCHOR_NW;
@@ -3305,7 +3305,7 @@ CreateWindowProc(void)
 {
     WindowMarker *wmPtr;
 
-    wmPtr = Blt_AssertCalloc(1, sizeof(WindowMarker));
+    wmPtr = calloc(1, sizeof(WindowMarker));
     wmPtr->classPtr = &windowMarkerClass;
     return (Marker *)wmPtr;
 }
@@ -3430,7 +3430,7 @@ MapLineProc(Marker *markerPtr)
 
     lmPtr->nSegments = 0;
     if (lmPtr->segments != NULL) {
-	Blt_Free(lmPtr->segments);
+	free(lmPtr->segments);
     }
     if (markerPtr->nWorldPts < 2) {
 	return;				/* Too few points */
@@ -3443,7 +3443,7 @@ MapLineProc(Marker *markerPtr)
      * because clipping against the plot area may chop the line into several
      * disconnected segments.
      */
-    segments = Blt_AssertMalloc(markerPtr->nWorldPts * sizeof(Segment2d));
+    segments = malloc(markerPtr->nWorldPts * sizeof(Segment2d));
     srcPtr = markerPtr->worldPts;
     p = MapPoint(srcPtr, &markerPtr->axes);
     p.x += markerPtr->xOffset;
@@ -3707,7 +3707,7 @@ FreeLineProc(Marker *markerPtr)
 	Blt_FreePrivateGC(graphPtr->display, lmPtr->gc);
     }
     if (lmPtr->segments != NULL) {
-	Blt_Free(lmPtr->segments);
+	free(lmPtr->segments);
     }
 }
 
@@ -3732,7 +3732,7 @@ CreateLineProc(void)
 {
     LineMarker *lmPtr;
 
-    lmPtr = Blt_AssertCalloc(1, sizeof(LineMarker));
+    lmPtr = calloc(1, sizeof(LineMarker));
     lmPtr->classPtr = &lineMarkerClass;
     lmPtr->xor = FALSE;
     lmPtr->capStyle = CapButt;
@@ -3763,17 +3763,17 @@ MapPolygonProc(Marker *markerPtr)
     int nScreenPts;
 
     if (pmPtr->outlinePts != NULL) {
-	Blt_Free(pmPtr->outlinePts);
+	free(pmPtr->outlinePts);
 	pmPtr->outlinePts = NULL;
 	pmPtr->nOutlinePts = 0;
     }
     if (pmPtr->fillPts != NULL) {
-	Blt_Free(pmPtr->fillPts);
+	free(pmPtr->fillPts);
 	pmPtr->fillPts = NULL;
 	pmPtr->nFillPts = 0;
     }
     if (pmPtr->screenPts != NULL) {
-	Blt_Free(pmPtr->screenPts);
+	free(pmPtr->screenPts);
 	pmPtr->screenPts = NULL;
     }
     if (markerPtr->nWorldPts < 3) {
@@ -3785,7 +3785,7 @@ MapPolygonProc(Marker *markerPtr)
      * the polygon.
      */
     nScreenPts = markerPtr->nWorldPts + 1;
-    screenPts = Blt_AssertMalloc((nScreenPts + 1) * sizeof(Point2d));
+    screenPts = malloc((nScreenPts + 1) * sizeof(Point2d));
     {
 	Point2d *sp, *dp, *send;
 
@@ -3805,10 +3805,10 @@ MapPolygonProc(Marker *markerPtr)
 	Point2d *fillPts;
 	int n;
 
-	fillPts = Blt_AssertMalloc(sizeof(Point2d) * nScreenPts * 3);
+	fillPts = malloc(sizeof(Point2d) * nScreenPts * 3);
 	n = Blt_PolyRectClip(&extents, screenPts, markerPtr->nWorldPts,fillPts);
 	if (n < 3) { 
-	    Blt_Free(fillPts);
+	    free(fillPts);
 	} else {
 	    pmPtr->nFillPts = n;
 	    pmPtr->fillPts = fillPts;
@@ -3824,7 +3824,7 @@ MapPolygonProc(Marker *markerPtr)
 	 * Generate line segments representing the polygon outline.  The
 	 * resulting outline may or may not be closed from viewport clipping.
 	 */
-	outlinePts = Blt_Malloc(nScreenPts * sizeof(Segment2d));
+	outlinePts = malloc(nScreenPts * sizeof(Segment2d));
 	if (outlinePts == NULL) {
 	    return;			/* Can't allocate point array */
 	}
@@ -3891,7 +3891,7 @@ DrawPolygonProc(Marker *markerPtr, Drawable drawable)
 	XPoint *dp, *points;
 	Point2d *sp, *send;
 	
-	points = Blt_Malloc(pmPtr->nFillPts * sizeof(XPoint));
+	points = malloc(pmPtr->nFillPts * sizeof(XPoint));
 	if (points == NULL) {
 	    return;
 	}
@@ -3905,7 +3905,7 @@ DrawPolygonProc(Marker *markerPtr, Drawable drawable)
 
 	XFillPolygon(graphPtr->display, drawable, pmPtr->fillGC, points, 
 		pmPtr->nFillPts, Complex, CoordModeOrigin);
-	Blt_Free(points);
+	free(points);
     }
     /* and then the outline */
     if ((pmPtr->nOutlinePts > 0) && (pmPtr->lineWidth > 0) && 
@@ -4122,13 +4122,13 @@ FreePolygonProc(Marker *markerPtr)
 	Blt_FreePrivateGC(graphPtr->display, pmPtr->outlineGC);
     }
     if (pmPtr->fillPts != NULL) {
-	Blt_Free(pmPtr->fillPts);
+	free(pmPtr->fillPts);
     }
     if (pmPtr->outlinePts != NULL) {
-	Blt_Free(pmPtr->outlinePts);
+	free(pmPtr->outlinePts);
     }
     if (pmPtr->screenPts != NULL) {
-	Blt_Free(pmPtr->screenPts);
+	free(pmPtr->screenPts);
     }
 }
 
@@ -4152,7 +4152,7 @@ CreatePolygonProc(void)
 {
     PolygonMarker *pmPtr;
 
-    pmPtr = Blt_AssertCalloc(1, sizeof(PolygonMarker));
+    pmPtr = calloc(1, sizeof(PolygonMarker));
     pmPtr->classPtr = &polygonMarkerClass;
     pmPtr->capStyle = CapButt;
     pmPtr->joinStyle = JoinMiter;
@@ -4194,7 +4194,7 @@ RenameMarker(Graph *graphPtr, Marker *markerPtr, const char *oldName,
 	    "\" already exists", (char *)NULL);
 	return TCL_ERROR;
     }
-    markerPtr->obj.name = Blt_AssertStrdup(newName);
+    markerPtr->obj.name = Blt_Strdup(newName);
     markerPtr->hashPtr = hPtr;
     Blt_SetHashValue(hPtr, (char *)markerPtr);
 
@@ -4202,7 +4202,7 @@ RenameMarker(Graph *graphPtr, Marker *markerPtr, const char *oldName,
     hPtr = Blt_FindHashEntry(&graphPtr->markers.table, oldName);
     Blt_DeleteHashEntry(&graphPtr->markers.table, hPtr);
     if (oldName != NULL) {
-	Blt_Free(oldName);
+	free(oldName);
     }
     return TCL_OK;
 }
diff --git a/src/bltGrMisc.C b/src/bltGrMisc.C
index 101273e..b63df8c 100644
--- a/src/bltGrMisc.C
+++ b/src/bltGrMisc.C
@@ -1120,7 +1120,7 @@ Blt_Draw2DSegments(
     XSegment *dp, *xsegments;
     Segment2d *sp, *send;
 
-    xsegments = Blt_Malloc(nSegments * sizeof(XSegment));
+    xsegments = malloc(nSegments * sizeof(XSegment));
     if (xsegments == NULL) {
 	return;
     }
@@ -1133,7 +1133,7 @@ Blt_Draw2DSegments(
 	dp++;
     }
     XDrawSegments(display, drawable, gc, xsegments, nSegments);
-    Blt_Free(xsegments);
+    free(xsegments);
 }
 
 void
@@ -1534,7 +1534,7 @@ FreeBorder(display, borderPtr)
     if (borderPtr->bgGC != NULL) {
 	Blt_FreePrivateGC(tkwin, borderPtr->bgGC);
     }
-    Blt_Free(borderPtr);
+    free(borderPtr);
 }
 
 void
@@ -1604,7 +1604,7 @@ Blt_Get3DBorder(Tcl_Interp *interp, Tk_Window tkwin, const char *borderName)
     }
 
     /* Create a new border */
-    borderPtr = Blt_AssertCalloc(1, sizeof(Blt_3DBorder));
+    borderPtr = calloc(1, sizeof(Blt_3DBorder));
     borderPtr->screen = Tk_Screen(tkwin);
     borderPtr->visual = Tk_Visual(tkwin);
     borderPtr->depth = Tk_Depth(tkwin);
@@ -1642,13 +1642,13 @@ Blt_Get3DBorder(Tcl_Interp *interp, Tk_Window tkwin, const char *borderName)
     }
     Blt_SetHashValue(hPtr, borderPtr);
     if (argv != NULL) {
-	Blt_Free(argv);
+	free(argv);
     }
     return TCL_OK;
 
  error:
     if (argv != NULL) {
-	Blt_Free(argv);
+	free(argv);
     }
     if (bgColorPtr != NULL) {
 	Tk_FreeColor(bgColorPtr);
@@ -1768,7 +1768,7 @@ CreateArcBall (float w, float h)
 {
     ArcBall *arcPtr;
 
-    arcPtr = Blt_AssertCalloc(1, sizeof(ArcBall));
+    arcPtr = calloc(1, sizeof(ArcBall));
     SetArcBallBounds (arcPtr, w, h);
     return arcPtr;
 }
@@ -1777,7 +1777,7 @@ static void
 DestroyArcBall(ArcBall *arcPtr)
 {
     if (arcPtr != NULL) {
-        Blt_Free(arcPtr);
+        free(arcPtr);
     }
 }
 
diff --git a/src/bltGrPSOutput.C b/src/bltGrPSOutput.C
index 44cfdb8..030ffde 100644
--- a/src/bltGrPSOutput.C
+++ b/src/bltGrPSOutput.C
@@ -233,7 +233,7 @@ Blt_Ps_Create(Tcl_Interp *interp, PageSetup *setupPtr)
 {
     PostScript *psPtr;
 
-    psPtr = Blt_AssertMalloc(sizeof(PostScript));
+    psPtr = malloc(sizeof(PostScript));
     psPtr->setupPtr = setupPtr;
     psPtr->interp = interp;
     Tcl_DStringInit(&psPtr->dString);
@@ -256,7 +256,7 @@ void
 Blt_Ps_Free(PostScript *psPtr)
 {
     Tcl_DStringFree(&psPtr->dString);
-    Blt_Free(psPtr);
+    free(psPtr);
 }
 
 const char *
@@ -607,7 +607,7 @@ Blt_Ps_XSetBitmapData(
 	    byteCount++;
 	}
     }				/* y */
-    Blt_Free(srcBits);
+    free(srcBits);
     Blt_Ps_Append(psPtr, ">\n");
 }
 
@@ -1357,13 +1357,13 @@ Blt_Ps_XSetFont(PostScript *psPtr, Blt_Font font)
 	    fontName = argv[0];
 	    if ((argc != 2) || 
 		(Tcl_GetInt(interp, argv[1], &newSize) != TCL_OK)) {
-		Blt_Free(argv);
+		free(argv);
 		return;
 	    }
 	    pointSize = (double)newSize;
 	    Blt_Ps_Format(psPtr, "%g /%s SetFont\n", pointSize, 
 		fontName);
-	    Blt_Free(argv);
+	    free(argv);
 	    return;
 	}
 	/*FallThru*/
@@ -1518,7 +1518,7 @@ Blt_Ps_DrawText(
 
     Blt_Ps_XSetForeground(ps, tsPtr->color);
     TextLayoutToPostScript(ps, 0, 0, textPtr);
-    Blt_Free(textPtr);
+    free(textPtr);
     Blt_Ps_Append(ps, "EndText\n");
 }
 
diff --git a/src/bltGrPenOp.C b/src/bltGrPenOp.C
index 2e13b3a..b370f25 100644
--- a/src/bltGrPenOp.C
+++ b/src/bltGrPenOp.C
@@ -303,12 +303,12 @@ DestroyPen(Pen *penPtr)
     Blt_FreeOptions(penPtr->configSpecs, (char *)penPtr, graphPtr->display, 0);
     (*penPtr->destroyProc) (graphPtr, penPtr);
     if ((penPtr->name != NULL) && (penPtr->name[0] != '\0')) {
-	Blt_Free(penPtr->name);
+	free(penPtr->name);
     }
     if (penPtr->hashPtr != NULL) {
 	Blt_DeleteHashEntry(&graphPtr->penTable, penPtr->hashPtr);
     }
-    Blt_Free(penPtr);
+    free(penPtr);
 }
 
 void
diff --git a/src/bltGrText.C b/src/bltGrText.C
index d9cb33b..b91e2e5 100644
--- a/src/bltGrText.C
+++ b/src/bltGrText.C
@@ -577,7 +577,7 @@ Blt_Ts_CreateLayout(const char *text, int textLen, TextStyle *tsPtr)
     }
     size = sizeof(TextLayout) + (sizeof(TextFragment) * (nFrags - 1));
 
-    layoutPtr = Blt_AssertCalloc(1, size);
+    layoutPtr = calloc(1, size);
     layoutPtr->nFrags = nFrags;
 
     nFrags = count = 0;
@@ -1239,7 +1239,7 @@ Blt_Ts_DrawText(
 
     layoutPtr = Blt_Ts_CreateLayout(text, textLen, stylePtr);
     Blt_Ts_DrawLayout(tkwin, drawable, layoutPtr, stylePtr, x, y);
-    Blt_Free(layoutPtr);
+    free(layoutPtr);
 }
 
 void
@@ -1276,7 +1276,7 @@ Blt_DrawText2(
     }
     areaPtr->width = width;
     areaPtr->height = height;
-    Blt_Free(layoutPtr);
+    free(layoutPtr);
 }
 
 void
@@ -1294,7 +1294,7 @@ Blt_DrawText(
     }
     layoutPtr = Blt_Ts_CreateLayout(string, -1, stylePtr);
     Blt_Ts_DrawLayout(tkwin, drawable, layoutPtr, stylePtr, x, y);
-    Blt_Free(layoutPtr);
+    free(layoutPtr);
 }
 
 void
@@ -1402,7 +1402,7 @@ Blt_FreeTextLayout(Tk_TextLayout textLayout)
     TkTextLayout *layoutPtr = (TkTextLayout *) textLayout;
 
     if (layoutPtr != NULL) {
-	Blt_Free(layoutPtr);
+	free(layoutPtr);
     }
 }
 
@@ -1442,7 +1442,7 @@ NewChunk(TkTextLayout **layoutPtrPtr, int *maxPtr, const char *start,
     if (layoutPtr->numChunks == maxChunks) {
 	maxChunks *= 2;
 	s = sizeof(TkTextLayout) + ((maxChunks - 1) * sizeof(LayoutChunk));
-	layoutPtr = Blt_Realloc(layoutPtr, s);
+	layoutPtr = realloc(layoutPtr, s);
 	*layoutPtrPtr = layoutPtr;
 	*maxPtr = maxChunks;
     }
@@ -1543,7 +1543,7 @@ Blt_ComputeTextLayout(
 
     maxChunks = 1;
 
-    layoutPtr = Blt_AssertMalloc(sizeof(TkTextLayout) + (maxChunks - 1) * 
+    layoutPtr = malloc(sizeof(TkTextLayout) + (maxChunks - 1) * 
 				sizeof(LayoutChunk));
     layoutPtr->font	    = font;
     layoutPtr->string	    = string;
diff --git a/src/bltGraph.C b/src/bltGraph.C
index de768f1..8402dae 100644
--- a/src/bltGraph.C
+++ b/src/bltGraph.C
@@ -810,7 +810,7 @@ DestroyGraph(DestroyData dataPtr)
     if (graphPtr->cache != None) {
 	Tk_FreePixmap(graphPtr->display, graphPtr->cache);
     }
-    Blt_Free(graphPtr);
+    free(graphPtr);
 }
 
 /*
@@ -842,7 +842,7 @@ CreateGraph(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv, ClassId classId)
     if (tkwin == NULL) {
 	return NULL;
     }
-    graphPtr = Blt_AssertCalloc(1, sizeof(Graph));
+    graphPtr = calloc(1, sizeof(Graph));
 
     /* Initialize the graph data structure. */
 
diff --git a/src/bltInt.C b/src/bltInt.C
index ac4640c..da3ac95 100644
--- a/src/bltInt.C
+++ b/src/bltInt.C
@@ -308,7 +308,6 @@ Blt_core_Init(Tcl_Interp *interp) /* Interpreter to add extra commands */
 	return TCL_ERROR;
     };
 #endif
-    Blt_AllocInit(NULL, NULL, NULL);
 
     /*
      * Check that the versions of TCL that have been loaded are the same ones
diff --git a/src/bltNsUtil.C b/src/bltNsUtil.C
index 62f727d..c4340d6 100644
--- a/src/bltNsUtil.C
+++ b/src/bltNsUtil.C
@@ -98,10 +98,10 @@ Blt_EnterNamespace(Tcl_Interp *interp, Tcl_Namespace *nsPtr)
 {
     Tcl_CallFrame *framePtr;
 
-    framePtr = Blt_AssertMalloc(sizeof(Tcl_CallFrame));
+    framePtr = malloc(sizeof(Tcl_CallFrame));
     if (Tcl_PushCallFrame(interp, framePtr, (Tcl_Namespace *)nsPtr, 0)
 	!= TCL_OK) {
-	Blt_Free(framePtr);
+	free(framePtr);
 	return NULL;
     }
     return framePtr;
@@ -111,7 +111,7 @@ void
 Blt_LeaveNamespace(Tcl_Interp *interp, Tcl_CallFrame *framePtr)
 {
     Tcl_PopCallFrame(interp);
-    Blt_Free(framePtr);
+    free(framePtr);
 }
 
 int
diff --git a/src/bltParse.C b/src/bltParse.C
index 10703f3..fc051f3 100644
--- a/src/bltParse.C
+++ b/src/bltParse.C
@@ -404,7 +404,7 @@ Blt_ExpandParseValue(
     } else {
 	size += size;
     }
-    buffer = Blt_AssertMalloc((unsigned int)size);
+    buffer = malloc((unsigned int)size);
 
     /*
      * Copy from old buffer to new, free old buffer if needed, and
@@ -414,7 +414,7 @@ Blt_ExpandParseValue(
 	(size_t) (parsePtr->next - parsePtr->buffer));
     parsePtr->next = buffer + (parsePtr->next - parsePtr->buffer);
     if (parsePtr->clientData != 0) {
-	Blt_Free(parsePtr->buffer);
+	free(parsePtr->buffer);
     }
     parsePtr->buffer = buffer;
     parsePtr->end = buffer + size - 1;
diff --git a/src/bltSwitch.C b/src/bltSwitch.C
index 35228d1..6d1aa31 100644
--- a/src/bltSwitch.C
+++ b/src/bltSwitch.C
@@ -268,9 +268,9 @@ DoSwitch(
 		char *value;
 		
 		value = Tcl_GetString(objPtr);
-		value =  (*value == '\0') ?  NULL : Blt_AssertStrdup(value);
+		value =  (*value == '\0') ?  NULL : Blt_Strdup(value);
 		if (*(char **)ptr != NULL) {
-		    Blt_Free(*(char **)ptr);
+		    free(*(char **)ptr);
 		}
 		*(char **)ptr = value;
 	    }
@@ -282,10 +282,10 @@ DoSwitch(
 		string = Tcl_GetString(objPtr);
 		strPtr = (char **)ptr;
 		new = ((*string == '\0') && (sp->flags & BLT_SWITCH_NULL_OK))
-		    ? NULL : Blt_AssertStrdup(string);
+		    ? NULL : Blt_Strdup(string);
 		old = *strPtr;
 		if (old != NULL) {
-		    Blt_Free(old);
+		    free(old);
 		}
 		*strPtr = new;
 	    }
@@ -454,7 +454,7 @@ Blt_FreeSwitches(
 	    case BLT_SWITCH_STRING:
 	    case BLT_SWITCH_LIST:
 		if (*((char **) ptr) != NULL) {
-		    Blt_Free(*((char **) ptr));
+		    free(*((char **) ptr));
 		    *((char **) ptr) = NULL;
 		}
 		break;
diff --git a/src/bltVecCmd.C b/src/bltVecCmd.C
index c113347..ac2a8f2 100644
--- a/src/bltVecCmd.C
+++ b/src/bltVecCmd.C
@@ -402,7 +402,7 @@ DeleteOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
     }
 
     /* Allocate an "unset" bitmap the size of the vector. */
-    unsetArr = Blt_AssertCalloc(sizeof(unsigned char), (vPtr->length + 7) / 8);
+    unsetArr = calloc(sizeof(unsigned char), (vPtr->length + 7) / 8);
 #define SetBit(i) \
     unsetArr[(i) >> 3] |= (1 << ((i) & 0x07))
 #define GetBit(i) \
@@ -413,7 +413,7 @@ DeleteOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 	if (Blt_Vec_GetIndexRange(interp, vPtr, string, 
 		(INDEX_COLON | INDEX_CHECK), (Blt_VectorIndexProc **) NULL) 
 		!= TCL_OK) {
-	    Blt_Free(unsetArr);
+	    free(unsetArr);
 	    return TCL_ERROR;
 	}
 	for (j = vPtr->first; j <= vPtr->last; j++) {
@@ -430,7 +430,7 @@ DeleteOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 	}
 	count++;
     }
-    Blt_Free(unsetArr);
+    free(unsetArr);
     vPtr->length = count;
     if (vPtr->flush) {
 	Blt_Vec_FlushCache(vPtr);
@@ -764,7 +764,7 @@ MergeOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
     
     /* Allocate an array of vector pointers of each vector to be
      * merged in the current vector.  */
-    vecArr = Blt_AssertMalloc(sizeof(Vector *) * objc);
+    vecArr = malloc(sizeof(Vector *) * objc);
     vPtrPtr = vecArr;
 
     refSize = -1;
@@ -775,7 +775,7 @@ MergeOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 
 	if (Blt_Vec_LookupName(vPtr->dataPtr, Tcl_GetString(objv[i]), &v2Ptr)
 		!= TCL_OK) {
-	    Blt_Free(vecArr);
+	    free(vecArr);
 	    return TCL_ERROR;
 	}
 	/* Check that all the vectors are the same length */
@@ -786,7 +786,7 @@ MergeOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 	    Tcl_AppendResult(vPtr->interp, "vectors \"", vPtr->name,
 		"\" and \"", v2Ptr->name, "\" differ in length",
 		(char *)NULL);
-	    Blt_Free(vecArr);
+	    free(vecArr);
 	    return TCL_ERROR;
 	}
 	*vPtrPtr++ = v2Ptr;
@@ -794,7 +794,7 @@ MergeOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
     }
     *vPtrPtr = NULL;
 
-    valueArr = Blt_Malloc(sizeof(double) * nElem);
+    valueArr = malloc(sizeof(double) * nElem);
     if (valueArr == NULL) {
 	Tcl_AppendResult(vPtr->interp, "not enough memory to allocate ", 
 		 Blt_Itoa(nElem), " vector elements", (char *)NULL);
@@ -810,7 +810,7 @@ MergeOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 	    *valuePtr++ = (*vpp)->valueArr[i + (*vpp)->first];
 	}
     }
-    Blt_Free(vecArr);
+    free(vecArr);
     Blt_Vec_Reset(vPtr, valueArr, nElem, nElem, TCL_DYNAMIC);
     return TCL_OK;
 }
@@ -1469,7 +1469,7 @@ BinreadOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 	arraySize = count * size;
     }
 
-    byteArr = Blt_AssertMalloc(arraySize);
+    byteArr = malloc(arraySize);
     /* FIXME: restore old channel translation later? */
     if (Tcl_SetChannelOption(interp, channel, "-translation",
 	    "binary") != TCL_OK) {
@@ -1498,7 +1498,7 @@ BinreadOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 	    break;
 	}
     }
-    Blt_Free(byteArr);
+    free(byteArr);
 
     if (vPtr->flush) {
 	Blt_Vec_FlushCache(vPtr);
@@ -1783,14 +1783,14 @@ SimplifyOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 
     length = vPtr->length;
     nPoints = vPtr->length / 2;
-    simple  = Blt_AssertMalloc(nPoints * sizeof(int));
-    reduced = Blt_AssertMalloc(nPoints * sizeof(Point2d));
+    simple  = malloc(nPoints * sizeof(int));
+    reduced = malloc(nPoints * sizeof(Point2d));
     orig = (Point2d *)vPtr->valueArr;
     n = Blt_SimplifyLine(orig, 0, nPoints - 1, tolerance, simple);
     for (i = 0; i < n; i++) {
 	reduced[i] = orig[simple[i]];
     }
-    Blt_Free(simple);
+    free(simple);
     Blt_Vec_Reset(vPtr, (double *)reduced, n * 2, vPtr->length, TCL_DYNAMIC);
     /*
      * The vector has changed; so flush the array indices (they're wrong
@@ -1913,7 +1913,7 @@ Blt_Vec_SortMap(Vector **vectors, int nVectors)
     int length;
 
     length = vPtr->last - vPtr->first + 1;
-    map = Blt_AssertMalloc(sizeof(size_t) * length);
+    map = malloc(sizeof(size_t) * length);
     for (i = vPtr->first; i <= vPtr->last; i++) {
 	map[i] = i;
     }
@@ -1932,7 +1932,7 @@ SortVectors(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
     size_t *map;
     int i;
 
-    vectors = Blt_AssertMalloc(sizeof(Vector *) * (objc + 1));
+    vectors = malloc(sizeof(Vector *) * (objc + 1));
     vectors[0] = vPtr;
     map = NULL;
     for (i = 0; i < objc; i++) {
@@ -1950,7 +1950,7 @@ SortVectors(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
     }
     map = Blt_Vec_SortMap(vectors, objc + 1);
   error:
-    Blt_Free(vectors);
+    free(vectors);
     return map;
 }
 
@@ -2010,7 +2010,7 @@ SortOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
      * indices found in the index array.
      */
     nBytes = sizeof(double) * sortLength;
-    copy = Blt_AssertMalloc(nBytes);
+    copy = malloc(nBytes);
     memcpy((char *)copy, (char *)vPtr->valueArr, nBytes);
     if (switches.flags & SORT_UNIQUE) {
 	int count;
@@ -2061,8 +2061,8 @@ SortOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
     }
     result = TCL_OK;
   error:
-    Blt_Free(copy);
-    Blt_Free(map);
+    free(copy);
+    free(map);
     return result;
 }
 
@@ -2307,7 +2307,7 @@ Blt_Vec_VarTrace(ClientData clientData, Tcl_Interp *interp, const char *part1,
 
     if (part2 == NULL) {
 	if (flags & TCL_TRACE_UNSETS) {
-	    Blt_Free(vPtr->arrayName);
+	    free(vPtr->arrayName);
 	    vPtr->arrayName = NULL;
 	    if (vPtr->freeOnUnset) {
 		Blt_Vec_Free(vPtr);
diff --git a/src/bltVecMath.C b/src/bltVecMath.C
index a0bd4af..8481770 100644
--- a/src/bltVecMath.C
+++ b/src/bltVecMath.C
@@ -200,15 +200,15 @@ Sort(Vector *vPtr)
     int i;
 
     map = Blt_Vec_SortMap(&vPtr, 1);
-    values = Blt_AssertMalloc(sizeof(double) * vPtr->length);
+    values = malloc(sizeof(double) * vPtr->length);
     for(i = vPtr->first; i <= vPtr->last; i++) {
 	values[i] = vPtr->valueArr[map[i]];
     }
-    Blt_Free(map);
+    free(map);
     for (i = vPtr->first; i <= vPtr->last; i++) {
 	vPtr->valueArr[i] = values[i];
     }
-    Blt_Free(values);
+    free(values);
     return TCL_OK;
 }
 
@@ -445,7 +445,7 @@ Median(Blt_Vector *vectorPtr)
 	q2 = (vPtr->valueArr[map[mid]] + 
 	      vPtr->valueArr[map[mid + 1]]) * 0.5;
     }
-    Blt_Free(map);
+    free(map);
     return q2;
 }
 
@@ -481,7 +481,7 @@ Q1(Blt_Vector *vectorPtr)
 		  vPtr->valueArr[map[q + 1]]) * 0.5; 
 	}
     }
-    Blt_Free(map);
+    free(map);
     return q1;
 }
 
@@ -518,7 +518,7 @@ Q3(Blt_Vector *vectorPtr)
 		  vPtr->valueArr[map[q + 1]]) * 0.5; 
 	}
     }
-    Blt_Free(map);
+    free(map);
     return q3;
 }
 
@@ -1303,7 +1303,7 @@ NextValue(
 			double *hold;
 			int j;
 
-			hold = Blt_AssertMalloc(sizeof(double) * offset);
+			hold = malloc(sizeof(double) * offset);
 			for (i = 0; i < offset; i++) {
 			    hold[i] = opnd[i];
 			}
@@ -1314,7 +1314,7 @@ NextValue(
 			     j < vPtr->length; i++, j++) {
 			    opnd[j] = hold[i];
 			}
-			Blt_Free(hold);
+			free(hold);
 		    }
 		}
 		break;
@@ -1328,7 +1328,7 @@ NextValue(
 			double *hold;
 			int j;
 			
-			hold = Blt_AssertMalloc(sizeof(double) * offset);
+			hold = malloc(sizeof(double) * offset);
 			for (i = vPtr->length - offset, j = 0; 
 			     i < vPtr->length; i++, j++) {
 			    hold[j] = opnd[i];
@@ -1340,7 +1340,7 @@ NextValue(
 			for (i = 0; i < offset; i++) {
 			    opnd[i] = hold[i];
 			}
-			Blt_Free(hold);
+			free(hold);
 		    }
 		}
 		break;
@@ -1579,14 +1579,14 @@ NextValue(
     }
   done:
     if (value2.pv.buffer != value2.staticSpace) {
-	Blt_Free(value2.pv.buffer);
+	free(value2.pv.buffer);
     }
     Blt_Vec_Free(v2Ptr);
     return result;
 
   error:
     if (value2.pv.buffer != value2.staticSpace) {
-	Blt_Free(value2.pv.buffer);
+	free(value2.pv.buffer);
     }
     Blt_Vec_Free(v2Ptr);
     return TCL_ERROR;
@@ -1800,7 +1800,7 @@ Blt_Vec_UninstallMathFunctions(Blt_HashTable *tablePtr)
 
 	mathPtr = Blt_GetHashValue(hPtr);
 	if (mathPtr->name == NULL) {
-	    Blt_Free(mathPtr);
+	    free(mathPtr);
 	}
     }
 }
diff --git a/src/bltVector.C b/src/bltVector.C
index e332b9d..6134b9f 100644
--- a/src/bltVector.C
+++ b/src/bltVector.C
@@ -717,7 +717,7 @@ UnmapVariable(Vector *vPtr)
     Tcl_UnsetVar2(interp, vPtr->arrayName, (char *)NULL, vPtr->varFlags);
 
     if (vPtr->arrayName != NULL) {
-	Blt_Free(vPtr->arrayName);
+	free(vPtr->arrayName);
 	vPtr->arrayName = NULL;
     }
 }
@@ -802,7 +802,7 @@ Blt_Vec_MapVariable(
     /* Create a full-array trace on reads, writes, and unsets. */
     Tcl_TraceVar2(interp, newPath, (char *)NULL, TRACE_ALL, Blt_Vec_VarTrace,
 	vPtr);
-    vPtr->arrayName = Blt_AssertStrdup(newPath);
+    vPtr->arrayName = Blt_Strdup(newPath);
     Tcl_DStringFree(&dString);
     return TCL_OK;
 }
@@ -846,7 +846,7 @@ Blt_Vec_SetSize(
 	double *newArr;
 
 	/* Old memory was dynamically allocated, so use realloc. */
-	newArr = Blt_Realloc(vPtr->valueArr, newSize * sizeof(double));
+	newArr = realloc(vPtr->valueArr, newSize * sizeof(double));
 	if (newArr == NULL) {
 	    if (interp != NULL) {
 		Tcl_AppendResult(interp, "can't reallocate ", 
@@ -866,7 +866,7 @@ Blt_Vec_SetSize(
 	/* Old memory was created specially (static or special allocator).
 	 * Replace with dynamically allocated memory (malloc-ed). */
 
-	newArr = Blt_Calloc(newSize, sizeof(double));
+	newArr = calloc(newSize, sizeof(double));
 	if (newArr == NULL) {
 	    if (interp != NULL) {
 		Tcl_AppendResult(interp, "can't allocate ", 
@@ -901,7 +901,7 @@ Blt_Vec_SetSize(
 	 */
 	if (vPtr->freeProc != TCL_STATIC) {
 	    if (vPtr->freeProc == TCL_DYNAMIC) {
-		Blt_Free(vPtr->valueArr);
+		free(vPtr->valueArr);
 	    } else {
 		(*vPtr->freeProc) ((char *)vPtr->valueArr);
 	    }
@@ -1048,7 +1048,7 @@ Blt_Vec_Reset(
 					 * the current vector.  */
 	if ((valueArr == NULL) || (size == 0)) {
 	    /* Empty array. Set up default values */
-	    valueArr = Blt_Malloc(sizeof(double) * DEF_ARRAY_SIZE);
+	    valueArr = malloc(sizeof(double) * DEF_ARRAY_SIZE);
 	    size = DEF_ARRAY_SIZE;
 	    if (valueArr == NULL) {
 		Tcl_AppendResult(vPtr->interp, "can't allocate ", 
@@ -1061,7 +1061,7 @@ Blt_Vec_Reset(
 	} else if (freeProc == TCL_VOLATILE) {
 	    double *newArr;
 	    /* Data is volatile. Make a copy of the value array.  */
-	    newArr = Blt_Malloc(size * sizeof(double));
+	    newArr = malloc(size * sizeof(double));
 	    if (newArr == NULL) {
 		Tcl_AppendResult(vPtr->interp, "can't allocate ", 
 			Blt_Itoa(size), " elements for vector \"", 
@@ -1078,7 +1078,7 @@ Blt_Vec_Reset(
 	    /* Old data was dynamically allocated. Free it before attaching
 	     * new data.  */
 	    if (vPtr->freeProc == TCL_DYNAMIC) {
-		Blt_Free(vPtr->valueArr);
+		free(vPtr->valueArr);
 	    } else {
 		(*freeProc) ((char *)vPtr->valueArr);
 	    }
@@ -1101,10 +1101,10 @@ Blt_Vec_New(VectorInterpData *dataPtr) /* Interpreter-specific data. */
 {
     Vector *vPtr;
 
-    vPtr = Blt_AssertCalloc(1, sizeof(Vector));
-    vPtr->valueArr = Blt_Malloc(sizeof(double) * DEF_ARRAY_SIZE);
+    vPtr = calloc(1, sizeof(Vector));
+    vPtr->valueArr = malloc(sizeof(double) * DEF_ARRAY_SIZE);
     if (vPtr->valueArr == NULL) {
-	Blt_Free(vPtr);
+	free(vPtr);
 	return NULL;
     }
     vPtr->size = DEF_ARRAY_SIZE;
@@ -1169,12 +1169,12 @@ Blt_Vec_Free(Vector *vPtr)
 	VectorClient *clientPtr;
 
 	clientPtr = Blt_Chain_GetValue(link);
-	Blt_Free(clientPtr);
+	free(clientPtr);
     }
     Blt_Chain_Destroy(vPtr->chain);
     if ((vPtr->valueArr != NULL) && (vPtr->freeProc != TCL_STATIC)) {
 	if (vPtr->freeProc == TCL_DYNAMIC) {
-	    Blt_Free(vPtr->valueArr);
+	    free(vPtr->valueArr);
 	} else {
 	    (*vPtr->freeProc) ((char *)vPtr->valueArr);
 	}
@@ -1187,7 +1187,7 @@ Blt_Vec_Free(Vector *vPtr)
 	Blt_DestroyNsDeleteNotify(vPtr->interp, vPtr->nsPtr, vPtr);
     }
 #endif /* NAMESPACE_DELETE_NOTIFY */
-    Blt_Free(vPtr);
+    free(vPtr);
 }
 
 /*
@@ -1791,7 +1791,7 @@ VectorInterpDeleteProc(
 
     Blt_DeleteHashTable(&dataPtr->indexProcTable);
     Tcl_DeleteAssocData(interp, VECTOR_THREAD_KEY);
-    Blt_Free(dataPtr);
+    free(dataPtr);
 }
 
 VectorInterpData *
@@ -1803,7 +1803,7 @@ Blt_Vec_GetInterpData(Tcl_Interp *interp)
     dataPtr = (VectorInterpData *)
 	Tcl_GetAssocData(interp, VECTOR_THREAD_KEY, &proc);
     if (dataPtr == NULL) {
-	dataPtr = Blt_AssertMalloc(sizeof(VectorInterpData));
+	dataPtr = malloc(sizeof(VectorInterpData));
 	dataPtr->interp = interp;
 	dataPtr->nextId = 0;
 	Tcl_SetAssocData(interp, VECTOR_THREAD_KEY, VectorInterpDeleteProc,
@@ -1889,9 +1889,9 @@ Blt_CreateVector2(
     }
     dataPtr = Blt_Vec_GetInterpData(interp);
 
-    nameCopy = Blt_AssertStrdup(vecName);
+    nameCopy = Blt_Strdup(vecName);
     vPtr = Blt_Vec_Create(dataPtr, nameCopy, cmdName, varName, &isNew);
-    Blt_Free(nameCopy);
+    free(nameCopy);
 
     if (vPtr == NULL) {
 	return TCL_ERROR;
@@ -1980,10 +1980,10 @@ Blt_DeleteVectorByName(Tcl_Interp *interp, const char *name)
      * the string.  Therefore make a writable copy and free it when we're
      * done.
      */
-    nameCopy = Blt_AssertStrdup(name);
+    nameCopy = Blt_Strdup(name);
     dataPtr = Blt_Vec_GetInterpData(interp);
     result = Blt_Vec_LookupName(dataPtr, nameCopy, &vPtr);
-    Blt_Free(nameCopy);
+    free(nameCopy);
 
     if (result != TCL_OK) {
 	return TCL_ERROR;
@@ -2042,9 +2042,9 @@ Blt_VectorExists(Tcl_Interp *interp, const char *vecName)
      * the string.  Therefore make a writable copy and free it when we're
      * done.
      */
-    nameCopy = Blt_AssertStrdup(vecName);
+    nameCopy = Blt_Strdup(vecName);
     result = Blt_VectorExists2(interp, nameCopy);
-    Blt_Free(nameCopy);
+    free(nameCopy);
     return result;
 }
 
@@ -2077,9 +2077,9 @@ Blt_GetVector(Tcl_Interp *interp, const char *name, Blt_Vector **vecPtrPtr)
      * the string.  Therefore make a writable copy and free it when we're
      * done.
      */
-    nameCopy = Blt_AssertStrdup(name);
+    nameCopy = Blt_Strdup(name);
     result = Blt_Vec_LookupName(dataPtr, nameCopy, &vPtr);
-    Blt_Free(nameCopy);
+    free(nameCopy);
     if (result != TCL_OK) {
 	return TCL_ERROR;
     }
@@ -2232,15 +2232,15 @@ Blt_AllocVectorId(Tcl_Interp *interp, const char *name)
      * the string.  Therefore make a writable copy and free it when we're
      * done.
      */
-    nameCopy = Blt_AssertStrdup(name);
+    nameCopy = Blt_Strdup(name);
     result = Blt_Vec_LookupName(dataPtr, nameCopy, &vPtr);
-    Blt_Free(nameCopy);
+    free(nameCopy);
 
     if (result != TCL_OK) {
 	return (Blt_VectorId) 0;
     }
     /* Allocate a new client structure */
-    clientPtr = Blt_AssertCalloc(1, sizeof(VectorClient));
+    clientPtr = calloc(1, sizeof(VectorClient));
     clientPtr->magic = VECTOR_MAGIC;
 
     /* Add the new client to the server's list of clients */
@@ -2317,7 +2317,7 @@ Blt_FreeVectorId(Blt_VectorId clientId)
 	/* Remove the client from the server's list */
 	Blt_Chain_DeleteLink(clientPtr->serverPtr->chain, clientPtr->link);
     }
-    Blt_Free(clientPtr);
+    free(clientPtr);
 }
 
 /*
@@ -2562,7 +2562,7 @@ Blt_Vec_FFT(
     }
 
     /* Allocate memory zero-filled array. */
-    paddedData = Blt_Calloc(pow2len * 2, sizeof(double));
+    paddedData = calloc(pow2len * 2, sizeof(double));
     if (paddedData == NULL) {
 	Tcl_AppendResult(interp, "can't allocate memory for padded data",
 		 (char *)NULL);
@@ -2648,7 +2648,7 @@ Blt_Vec_FFT(
     }
     
     /* Memory is necessarily dynamic, because nobody touched it ! */
-    Blt_Free(paddedData);
+    free(paddedData);
     
     realPtr->offset = 0;
     return TCL_OK;
@@ -2689,7 +2689,7 @@ Blt_Vec_InverseFFT(Tcl_Interp *interp, Vector *srcImagPtr, Vector *destRealPtr,
 	return TCL_ERROR;
     }
 
-    paddedData = Blt_AssertMalloc( pow2len*2*sizeof(double) );
+    paddedData = malloc( pow2len*2*sizeof(double) );
     if( paddedData == NULL ){
 	if (interp != NULL) {
 	    Tcl_AppendResult(interp, "memory allocation failed", (char *)NULL);
@@ -2723,7 +2723,7 @@ for(i=0;i<pow2len;i++){
     }
 
 /* memory is necessarily dynamic, because nobody touched it ! */
-    Blt_Free( paddedData );
+    free( paddedData );
 
     return TCL_OK;
 }
@@ -2789,7 +2789,7 @@ Blt_SimplifyLine(Point2d *inputPts, int low, int high, double tolerance,
     int s = -1;			/* Points to top stack item. */
     int count;
 
-    stack = Blt_AssertMalloc(sizeof(int) * (high - low + 1));
+    stack = malloc(sizeof(int) * (high - low + 1));
     StackPush(high);
     count = 0;
     indices[count++] = 0;
@@ -2803,6 +2803,6 @@ Blt_SimplifyLine(Point2d *inputPts, int low, int high, double tolerance,
 	    StackPop(low);
 	}
     } 
-    Blt_Free(stack);
+    free(stack);
     return count;
 }