*** empty log message ***

11 files changed, 249 insertions, 251 deletions

diff --git a/src/bltGrAxis.C b/src/bltGrAxis.C
index bea19b7..f7a5a2e 100644
--- a/src/bltGrAxis.C
+++ b/src/bltGrAxis.C
@@ -1870,8 +1870,8 @@ void
 Blt_ResetAxes(Graph *graphPtr)
 {
     Blt_ChainLink link;
-    Blt_HashEntry *hPtr;
-    Blt_HashSearch cursor;
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch cursor;
 
     /* FIXME: This should be called whenever the display list of
      *	      elements change. Maybe yet another flag INIT_STACKS to
@@ -1886,11 +1886,11 @@ Blt_ResetAxes(Graph *graphPtr)
      * Step 1:  Reset all axes. Initialize the data limits of the axis to
      *		impossible values.
      */
-    for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor);
-	hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
+    for (hPtr = Tcl_FirstHashEntry(&graphPtr->axes.table, &cursor);
+	hPtr != NULL; hPtr = Tcl_NextHashEntry(&cursor)) {
 	Axis *axisPtr;
 
-	axisPtr = Blt_GetHashValue(hPtr);
+	axisPtr = Tcl_GetHashValue(hPtr);
 	axisPtr->min = axisPtr->valueRange.min = DBL_MAX;
 	axisPtr->max = axisPtr->valueRange.max = -DBL_MAX;
     }
@@ -1918,12 +1918,12 @@ Blt_ResetAxes(Graph *graphPtr)
      * Step 3:  Now that we know the range of data values for each axis,
      *		set axis limits and compute a sweep to generate tick values.
      */
-    for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor);
-	 hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
+    for (hPtr = Tcl_FirstHashEntry(&graphPtr->axes.table, &cursor);
+	 hPtr != NULL; hPtr = Tcl_NextHashEntry(&cursor)) {
 	Axis *axisPtr;
 	double min, max;
 
-	axisPtr = Blt_GetHashValue(hPtr);
+	axisPtr = Tcl_GetHashValue(hPtr);
 	FixAxisRange(axisPtr);
 
 	/* Calculate min/max tick (major/minor) layouts */
@@ -2071,7 +2071,7 @@ DestroyAxis(Axis *axisPtr)
       free((void*)(axisPtr->obj.name));
     }
     if (axisPtr->hashPtr != NULL) {
-	Blt_DeleteHashEntry(&graphPtr->axes.table, axisPtr->hashPtr);
+	Tcl_DeleteHashEntry(axisPtr->hashPtr);
     }
     Blt_Ts_FreeStyle(graphPtr->display, &axisPtr->limitsTextStyle);
 
@@ -3829,7 +3829,7 @@ static Axis *
 NewAxis(Graph *graphPtr, const char *name, int margin)
 {
     Axis *axisPtr;
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     int isNew;
 
     if (name[0] == '-') {
@@ -3837,9 +3837,9 @@ NewAxis(Graph *graphPtr, const char *name, int margin)
 			 "\" can't start with a '-'", (char *)NULL);
 	return NULL;
     }
-    hPtr = Blt_CreateHashEntry(&graphPtr->axes.table, name, &isNew);
+    hPtr = Tcl_CreateHashEntry(&graphPtr->axes.table, name, &isNew);
     if (!isNew) {
-	axisPtr = Blt_GetHashValue(hPtr);
+	axisPtr = Tcl_GetHashValue(hPtr);
 	if ((axisPtr->flags & DELETE_PENDING) == 0) {
 	    Tcl_AppendResult(graphPtr->interp, "axis \"", name,
 		"\" already exists in \"", Tk_PathName(graphPtr->tkwin), "\"",
@@ -3882,7 +3882,7 @@ NewAxis(Graph *graphPtr, const char *name, int margin)
 	Blt_Ts_InitStyle(axisPtr->limitsTextStyle);
 	axisPtr->tickLabels = Blt_Chain_Create();
 	axisPtr->lineWidth = 1;
-	Blt_SetHashValue(hPtr, axisPtr);
+	Tcl_SetHashValue(hPtr, axisPtr);
     }
     return axisPtr;
 }
@@ -3891,16 +3891,16 @@ static int
 GetAxisFromObj(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr, 
 	       Axis **axisPtrPtr)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     const char *name;
 
     *axisPtrPtr = NULL;
     name = Tcl_GetString(objPtr);
-    hPtr = Blt_FindHashEntry(&graphPtr->axes.table, name);
+    hPtr = Tcl_FindHashEntry(&graphPtr->axes.table, name);
     if (hPtr != NULL) {
 	Axis *axisPtr;
 
-	axisPtr = Blt_GetHashValue(hPtr);
+	axisPtr = Tcl_GetHashValue(hPtr);
 	if ((axisPtr->flags & DELETE_PENDING) == 0) {
 	    *axisPtrPtr = axisPtr;
 	    return TCL_OK;
@@ -3945,19 +3945,19 @@ void
 Blt_DestroyAxes(Graph *graphPtr)
 {
     {
-	Blt_HashEntry *hPtr;
-	Blt_HashSearch cursor;
+	Tcl_HashEntry *hPtr;
+	Tcl_HashSearch cursor;
 
-	for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor);
-	     hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
+	for (hPtr = Tcl_FirstHashEntry(&graphPtr->axes.table, &cursor);
+	     hPtr != NULL; hPtr = Tcl_NextHashEntry(&cursor)) {
 	    Axis *axisPtr;
 	    
-	    axisPtr = Blt_GetHashValue(hPtr);
+	    axisPtr = Tcl_GetHashValue(hPtr);
 	    axisPtr->hashPtr = NULL;
 	    DestroyAxis(axisPtr);
 	}
     }
-    Blt_DeleteHashTable(&graphPtr->axes.table);
+    Tcl_DeleteHashTable(&graphPtr->axes.table);
     {
 	int i;
 	
@@ -3965,21 +3965,21 @@ Blt_DestroyAxes(Graph *graphPtr)
 	    Blt_Chain_Destroy(graphPtr->axisChain[i]);
 	}
     }
-    Blt_DeleteHashTable(&graphPtr->axes.tagTable);
+    Tcl_DeleteHashTable(&graphPtr->axes.tagTable);
     Blt_Chain_Destroy(graphPtr->axes.displayList);
 }
 
 void
 Blt_ConfigureAxes(Graph *graphPtr)
 {
-    Blt_HashEntry *hPtr;
-    Blt_HashSearch cursor;
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch cursor;
     
-    for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor);
-	 hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
+    for (hPtr = Tcl_FirstHashEntry(&graphPtr->axes.table, &cursor);
+	 hPtr != NULL; hPtr = Tcl_NextHashEntry(&cursor)) {
 	Axis *axisPtr;
 	
-	axisPtr = Blt_GetHashValue(hPtr);
+	axisPtr = Tcl_GetHashValue(hPtr);
 	ConfigureAxis(axisPtr);
     }
 }
@@ -4589,17 +4589,17 @@ AxisBindOp(Tcl_Interp *interp, Graph *graphPtr, int objc,
 	      Tcl_Obj *const *objv)
 {
     if (objc == 3) {
-	Blt_HashEntry *hPtr;
-	Blt_HashSearch cursor;
+	Tcl_HashEntry *hPtr;
+	Tcl_HashSearch cursor;
 	Tcl_Obj *listObjPtr;
 
 	listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
-	for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.tagTable, &cursor);
-	     hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
+	for (hPtr = Tcl_FirstHashEntry(&graphPtr->axes.tagTable, &cursor);
+	     hPtr != NULL; hPtr = Tcl_NextHashEntry(&cursor)) {
 	    const char *tagName;
 	    Tcl_Obj *objPtr;
 
-	    tagName = Blt_GetHashKey(&graphPtr->axes.tagTable, hPtr);
+	    tagName = Tcl_GetHashKey(&graphPtr->axes.tagTable, hPtr);
 	    objPtr = Tcl_NewStringObj(tagName, -1);
 	    Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
 	}
@@ -4916,14 +4916,14 @@ AxisNamesOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv)
 
     listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
     if (objc == 3) {
-	Blt_HashEntry *hPtr;
-	Blt_HashSearch cursor;
+	Tcl_HashEntry *hPtr;
+	Tcl_HashSearch cursor;
 
-	for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor);
-	     hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
+	for (hPtr = Tcl_FirstHashEntry(&graphPtr->axes.table, &cursor);
+	     hPtr != NULL; hPtr = Tcl_NextHashEntry(&cursor)) {
 	    Axis *axisPtr;
 
-	    axisPtr = Blt_GetHashValue(hPtr);
+	    axisPtr = Tcl_GetHashValue(hPtr);
 	    if (axisPtr->flags & DELETE_PENDING) {
 		continue;
 	    }
@@ -4931,15 +4931,15 @@ AxisNamesOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv)
 		     Tcl_NewStringObj(axisPtr->obj.name, -1));
 	}
     } else {
-	Blt_HashEntry *hPtr;
-	Blt_HashSearch cursor;
+	Tcl_HashEntry *hPtr;
+	Tcl_HashSearch cursor;
 
-	for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor);
-	     hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
+	for (hPtr = Tcl_FirstHashEntry(&graphPtr->axes.table, &cursor);
+	     hPtr != NULL; hPtr = Tcl_NextHashEntry(&cursor)) {
 	    Axis *axisPtr;
 	    int i;
 
-	    axisPtr = Blt_GetHashValue(hPtr);
+	    axisPtr = Tcl_GetHashValue(hPtr);
 	    for (i = 3; i < objc; i++) {
 		const char *pattern;
 
@@ -5297,8 +5297,8 @@ Blt_AxesToPostScript(Graph *graphPtr, Blt_Ps ps)
 void
 Blt_DrawAxisLimits(Graph *graphPtr, Drawable drawable)
 {
-    Blt_HashEntry *hPtr;
-    Blt_HashSearch cursor;
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch cursor;
     char minString[200], maxString[200];
     int vMin, hMin, vMax, hMax;
 
@@ -5306,15 +5306,15 @@ Blt_DrawAxisLimits(Graph *graphPtr, Drawable drawable)
     vMin = vMax = graphPtr->left + graphPtr->xPad + 2;
     hMin = hMax = graphPtr->bottom - graphPtr->yPad - 2;	/* Offsets */
 
-    for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor);
-	hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
+    for (hPtr = Tcl_FirstHashEntry(&graphPtr->axes.table, &cursor);
+	hPtr != NULL; hPtr = Tcl_NextHashEntry(&cursor)) {
 	Axis *axisPtr;
 	Dim2D textDim;
 	const char *minFmt, *maxFmt;
 	char *minPtr, *maxPtr;
 	int isHoriz;
 
-	axisPtr = Blt_GetHashValue(hPtr);
+	axisPtr = Tcl_GetHashValue(hPtr);
 	if (axisPtr->flags & DELETE_PENDING) {
 	    continue;
 	} 
@@ -5375,21 +5375,21 @@ Blt_DrawAxisLimits(Graph *graphPtr, Drawable drawable)
 void
 Blt_AxisLimitsToPostScript(Graph *graphPtr, Blt_Ps ps)
 {
-    Blt_HashEntry *hPtr;
-    Blt_HashSearch cursor;
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch cursor;
     double vMin, hMin, vMax, hMax;
     char string[200];
 
 #define SPACING 8
     vMin = vMax = graphPtr->left + graphPtr->xPad + 2;
     hMin = hMax = graphPtr->bottom - graphPtr->yPad - 2;	/* Offsets */
-    for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor);
-	 hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
+    for (hPtr = Tcl_FirstHashEntry(&graphPtr->axes.table, &cursor);
+	 hPtr != NULL; hPtr = Tcl_NextHashEntry(&cursor)) {
 	Axis *axisPtr;
 	const char *minFmt, *maxFmt;
 	unsigned int textWidth, textHeight;
 
-	axisPtr = Blt_GetHashValue(hPtr);
+	axisPtr = Tcl_GetHashValue(hPtr);
 	if (axisPtr->flags & DELETE_PENDING) {
 	    continue;
 	} 
@@ -5457,14 +5457,14 @@ Blt_GetFirstAxis(Blt_Chain chain)
 Axis *
 Blt_NearestAxis(Graph *graphPtr, int x, int y)
 {
-    Blt_HashEntry *hPtr;
-    Blt_HashSearch cursor;
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch cursor;
     
-    for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor); 
-	 hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) {
+    for (hPtr = Tcl_FirstHashEntry(&graphPtr->axes.table, &cursor); 
+	 hPtr != NULL; hPtr = Tcl_NextHashEntry(&cursor)) {
 	Axis *axisPtr;
 
-	axisPtr = Blt_GetHashValue(hPtr);
+	axisPtr = Tcl_GetHashValue(hPtr);
 	if ((axisPtr->flags & (DELETE_PENDING|HIDE|AXIS_USE)) != AXIS_USE) {
 	    continue;
 	}
@@ -5528,11 +5528,11 @@ Blt_NearestAxis(Graph *graphPtr, int x, int y)
 ClientData
 Blt_MakeAxisTag(Graph *graphPtr, const char *tagName)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     int isNew;
 
-    hPtr = Blt_CreateHashEntry(&graphPtr->axes.tagTable, tagName, &isNew);
-    return Blt_GetHashKey(&graphPtr->axes.tagTable, hPtr);
+    hPtr = Tcl_CreateHashEntry(&graphPtr->axes.tagTable, tagName, &isNew);
+    return Tcl_GetHashKey(&graphPtr->axes.tagTable, hPtr);
 }
 
 
diff --git a/src/bltGrAxis.h b/src/bltGrAxis.h
index 59182af..21bb44d 100644
--- a/src/bltGrAxis.h
+++ b/src/bltGrAxis.h
@@ -136,7 +136,7 @@ typedef struct {
 
     unsigned int flags;		
 
-    Blt_HashEntry *hashPtr;
+    Tcl_HashEntry *hashPtr;
 
     /* Fields specific to axes. */
 
diff --git a/src/bltGrElemBar.C b/src/bltGrElemBar.C
index 3776286..462c1dc 100644
--- a/src/bltGrElemBar.C
+++ b/src/bltGrElemBar.C
@@ -56,7 +56,7 @@ typedef struct {
 					 * active or normal */
     int refCount;			/* Reference count for elements using
 					 * this pen. */
-    Blt_HashEntry *hashPtr;
+    Tcl_HashEntry *hashPtr;
     Blt_ConfigSpec *configSpecs;	/* Configuration specifications */
     PenConfigureProc *configProc;
     PenDestroyProc *destroyProc;
@@ -114,7 +114,7 @@ typedef struct {
 typedef struct {
     GraphObj obj;			/* Must be first field in element. */
     unsigned int flags;		
-    Blt_HashEntry *hashPtr;
+    Tcl_HashEntry *hashPtr;
 
     /* Fields specific to elements. */
     const char *label;			/* Label displayed in legend */
@@ -1478,26 +1478,26 @@ MapBarProc(Graph *graphPtr, Element *basePtr)
 
 	if ((graphPtr->nBarGroups > 0) && (graphPtr->mode != BARS_INFRONT) && 
 	    (!graphPtr->stackAxes)) {
-	    Blt_HashEntry *hPtr;
+	    Tcl_HashEntry *hPtr;
 	    BarSetKey key;
 
 	    key.value = (float)x[i];
 	    key.axes = elemPtr->axes;
 	    key.axes.y = NULL;
-	    hPtr = Blt_FindHashEntry(&graphPtr->setTable, (char *)&key);
+	    hPtr = Tcl_FindHashEntry(&graphPtr->setTable, (char *)&key);
 	    if (hPtr != NULL) {
-		Blt_HashTable *tablePtr;
+		Tcl_HashTable *tablePtr;
 		const char *name;
 
-		tablePtr = Blt_GetHashValue(hPtr);
+		tablePtr = Tcl_GetHashValue(hPtr);
 		name = (elemPtr->groupName != NULL) ? elemPtr->groupName : 
 		    elemPtr->axes.y->obj.name;
- 		hPtr = Blt_FindHashEntry(tablePtr, name);
+ 		hPtr = Tcl_FindHashEntry(tablePtr, name);
 		if (hPtr != NULL) {
 		    BarGroup *groupPtr;
 		    double slice, width, offset;
 		    
-		    groupPtr = Blt_GetHashValue(hPtr);
+		    groupPtr = Tcl_GetHashValue(hPtr);
 		    slice = barWidth / (double)graphPtr->maxBarSetSize;
 		    offset = (slice * groupPtr->index);
 		    if (graphPtr->maxBarSetSize > 1) {
@@ -2307,10 +2307,10 @@ Blt_InitBarSetTable(Graph *graphPtr)
 {
     Blt_ChainLink link;
     int nStacks, nSegs;
-    Blt_HashTable setTable;
+    Tcl_HashTable setTable;
     int sum, max;
-    Blt_HashEntry *hPtr;
-    Blt_HashSearch iter;
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch iter;
 
     /*
      * Free resources associated with a previous frequency table. This includes
@@ -2321,14 +2321,14 @@ Blt_InitBarSetTable(Graph *graphPtr)
 	return;				/* No set table is needed for
 					 * "infront" mode */
     }
-    Blt_InitHashTable(&graphPtr->setTable, sizeof(BarSetKey) / sizeof(int));
+    Tcl_InitHashTable(&graphPtr->setTable, sizeof(BarSetKey) / sizeof(int));
 
     /*
      * Initialize a hash table and fill it with unique abscissas.  Keep track
      * of the frequency of each x-coordinate and how many abscissas have
      * duplicate mappings.
      */
-    Blt_InitHashTable(&setTable, sizeof(BarSetKey) / sizeof(int));
+    Tcl_InitHashTable(&setTable, sizeof(BarSetKey) / sizeof(int));
     nSegs = nStacks = 0;
     for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList);
 	link != NULL; link = Blt_Chain_NextLink(link)) {
@@ -2343,8 +2343,8 @@ Blt_InitBarSetTable(Graph *graphPtr)
 	nSegs++;
 	nPoints = NUMBEROFPOINTS(elemPtr);
 	for (x = elemPtr->x.values, xend = x + nPoints; x < xend; x++) {
-	    Blt_HashEntry *hPtr;
-	    Blt_HashTable *tablePtr;
+	    Tcl_HashEntry *hPtr;
+	    Tcl_HashTable *tablePtr;
 	    BarSetKey key;
 	    int isNew;
 	    size_t count;
@@ -2353,73 +2353,73 @@ Blt_InitBarSetTable(Graph *graphPtr)
 	    key.value = *x;
 	    key.axes = elemPtr->axes;
 	    key.axes.y = NULL;
-	    hPtr = Blt_CreateHashEntry(&setTable, (char *)&key, &isNew);
+	    hPtr = Tcl_CreateHashEntry(&setTable, (char *)&key, &isNew);
 	    if (isNew) {
-		tablePtr = malloc(sizeof(Blt_HashTable));
-		Blt_InitHashTable(tablePtr, BLT_STRING_KEYS);
-		Blt_SetHashValue(hPtr, tablePtr);
+		tablePtr = malloc(sizeof(Tcl_HashTable));
+		Tcl_InitHashTable(tablePtr, TCL_STRING_KEYS);
+		Tcl_SetHashValue(hPtr, tablePtr);
 	    } else {
-		tablePtr = Blt_GetHashValue(hPtr);
+		tablePtr = Tcl_GetHashValue(hPtr);
 	    }
 	    name = (elemPtr->groupName != NULL) ? elemPtr->groupName : 
 		elemPtr->axes.y->obj.name;
-	    hPtr = Blt_CreateHashEntry(tablePtr, name, &isNew);
+	    hPtr = Tcl_CreateHashEntry(tablePtr, name, &isNew);
 	    if (isNew) {
 		count = 1;
 	    } else {
-		count = (size_t)Blt_GetHashValue(hPtr);
+		count = (size_t)Tcl_GetHashValue(hPtr);
  		count++;
 	    }		
-	    Blt_SetHashValue(hPtr, (ClientData)count);
+	    Tcl_SetHashValue(hPtr, (ClientData)count);
 	}
     }
     if (setTable.numEntries == 0) {
 	return;				/* No bar elements to be displayed */
     }
     sum = max = 0;
-    for (hPtr = Blt_FirstHashEntry(&setTable, &iter); hPtr != NULL;
-	 hPtr = Blt_NextHashEntry(&iter)) {
-	Blt_HashTable *tablePtr;
-	Blt_HashEntry *hPtr2;
+    for (hPtr = Tcl_FirstHashEntry(&setTable, &iter); hPtr != NULL;
+	 hPtr = Tcl_NextHashEntry(&iter)) {
+	Tcl_HashTable *tablePtr;
+	Tcl_HashEntry *hPtr2;
 	BarSetKey *keyPtr;
 	int isNew;
 
-	keyPtr = (BarSetKey *)Blt_GetHashKey(&setTable, hPtr);
-	hPtr2 = Blt_CreateHashEntry(&graphPtr->setTable, (char *)keyPtr,&isNew);
-	tablePtr = Blt_GetHashValue(hPtr);
-	Blt_SetHashValue(hPtr2, tablePtr);
+	keyPtr = (BarSetKey *)Tcl_GetHashKey(&setTable, hPtr);
+	hPtr2 = Tcl_CreateHashEntry(&graphPtr->setTable, (char *)keyPtr,&isNew);
+	tablePtr = Tcl_GetHashValue(hPtr);
+	Tcl_SetHashValue(hPtr2, tablePtr);
 	if (max < tablePtr->numEntries) {
 	    max = tablePtr->numEntries;	/* # of stacks in group. */
 	}
 	sum += tablePtr->numEntries;
     }
-    Blt_DeleteHashTable(&setTable);
+    Tcl_DeleteHashTable(&setTable);
     if (sum > 0) {
 	BarGroup *groupPtr;
-	Blt_HashEntry *hPtr;
-	Blt_HashSearch iter;
+	Tcl_HashEntry *hPtr;
+	Tcl_HashSearch iter;
 
 	graphPtr->barGroups = calloc(sum, sizeof(BarGroup));
 	groupPtr = graphPtr->barGroups;
-	for (hPtr = Blt_FirstHashEntry(&graphPtr->setTable, &iter); 
-	     hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
+	for (hPtr = Tcl_FirstHashEntry(&graphPtr->setTable, &iter); 
+	     hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
 	    BarSetKey *keyPtr;
-	    Blt_HashTable *tablePtr;
-	    Blt_HashEntry *hPtr2;
-	    Blt_HashSearch iter2;
+	    Tcl_HashTable *tablePtr;
+	    Tcl_HashEntry *hPtr2;
+	    Tcl_HashSearch iter2;
 	    size_t xcount;
 
-	    tablePtr = Blt_GetHashValue(hPtr);
-	    keyPtr = (BarSetKey *)Blt_GetHashKey(&setTable, hPtr);
+	    tablePtr = Tcl_GetHashValue(hPtr);
+	    keyPtr = (BarSetKey *)Tcl_GetHashKey(&setTable, hPtr);
 	    xcount = 0;
-	    for (hPtr2 = Blt_FirstHashEntry(tablePtr, &iter2); hPtr2!=NULL;
-		 hPtr2 = Blt_NextHashEntry(&iter2)) {
+	    for (hPtr2 = Tcl_FirstHashEntry(tablePtr, &iter2); hPtr2!=NULL;
+		 hPtr2 = Tcl_NextHashEntry(&iter2)) {
 		size_t count;
 
 		count = (size_t)Blt_GetHashValue(hPtr2);
 		groupPtr->nSegments = count;
 		groupPtr->axes = keyPtr->axes;
-		Blt_SetHashValue(hPtr2, groupPtr);
+		Tcl_SetHashValue(hPtr2, groupPtr);
 		groupPtr->index = xcount++;
 		groupPtr++;
 	    }
@@ -2486,25 +2486,25 @@ Blt_ComputeBarStacks(Graph *graphPtr)
 		 xend = x + NUMBEROFPOINTS(elemPtr); x < xend; x++, y++) {
 	    BarSetKey key;
 	    BarGroup *groupPtr;
-	    Blt_HashEntry *hPtr;
-	    Blt_HashTable *tablePtr;
+	    Tcl_HashEntry *hPtr;
+	    Tcl_HashTable *tablePtr;
 	    const char *name;
 
 	    key.value = *x;
 	    key.axes = elemPtr->axes;
 	    key.axes.y = NULL;
-	    hPtr = Blt_FindHashEntry(&graphPtr->setTable, (char *)&key);
+	    hPtr = Tcl_FindHashEntry(&graphPtr->setTable, (char *)&key);
 	    if (hPtr == NULL) {
 		continue;
 	    }
-	    tablePtr = Blt_GetHashValue(hPtr);
+	    tablePtr = Tcl_GetHashValue(hPtr);
 	    name = (elemPtr->groupName != NULL) ? elemPtr->groupName : 
 		elemPtr->axes.y->obj.name;
-	    hPtr = Blt_FindHashEntry(tablePtr, name);
+	    hPtr = Tcl_FindHashEntry(tablePtr, name);
 	    if (hPtr == NULL) {
 		continue;
 	    }
-	    groupPtr = Blt_GetHashValue(hPtr);
+	    groupPtr = Tcl_GetHashValue(hPtr);
 	    groupPtr->sum += *y;
 	}
     }
@@ -2525,22 +2525,22 @@ Blt_ResetBarGroups(Graph *graphPtr)
 void
 Blt_DestroyBarSets(Graph *graphPtr)
 {
-    Blt_HashSearch iter;
-    Blt_HashEntry *hPtr;
+    Tcl_HashSearch iter;
+    Tcl_HashEntry *hPtr;
 
     if (graphPtr->barGroups != NULL) {
 	free(graphPtr->barGroups);
 	graphPtr->barGroups = NULL;
     }
     graphPtr->nBarGroups = 0;
-    for (hPtr = Blt_FirstHashEntry(&graphPtr->setTable, &iter); 
-	 hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
-	Blt_HashTable *tablePtr;
+    for (hPtr = Tcl_FirstHashEntry(&graphPtr->setTable, &iter); 
+	 hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
+	Tcl_HashTable *tablePtr;
 	
-	tablePtr = Blt_GetHashValue(hPtr);
-	Blt_DeleteHashTable(tablePtr);
+	tablePtr = Tcl_GetHashValue(hPtr);
+	Tcl_DeleteHashTable(tablePtr);
 	free(tablePtr);
     }
-    Blt_DeleteHashTable(&graphPtr->setTable);
-    Blt_InitHashTable(&graphPtr->setTable, sizeof(BarSetKey) / sizeof(int));
+    Tcl_DeleteHashTable(&graphPtr->setTable);
+    Tcl_InitHashTable(&graphPtr->setTable, sizeof(BarSetKey) / sizeof(int));
 }
diff --git a/src/bltGrElemLine.C b/src/bltGrElemLine.C
index c353595..56387d9 100644
--- a/src/bltGrElemLine.C
+++ b/src/bltGrElemLine.C
@@ -182,7 +182,7 @@ typedef struct {
 					 * active or normal */
     int refCount;			/* Reference count for elements using
 					 * this pen. */
-    Blt_HashEntry *hashPtr;
+    Tcl_HashEntry *hashPtr;
 
     Blt_ConfigSpec *configSpecs;	/* Configuration specifications */
 
@@ -248,7 +248,7 @@ typedef struct {
 typedef struct {
     GraphObj obj;			/* Must be first field in element. */
     unsigned int flags;		
-    Blt_HashEntry *hashPtr;
+    Tcl_HashEntry *hashPtr;
 
     /* Fields specific to elements. */
     const char *label;			/* Label displayed in legend */
diff --git a/src/bltGrElemOp.C b/src/bltGrElemOp.C
index 83710a7..68b2104 100644
--- a/src/bltGrElemOp.C
+++ b/src/bltGrElemOp.C
@@ -979,7 +979,7 @@ int
 Blt_GetElement(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr, 
 	       Element **elemPtrPtr)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     char *name;
 
     name = Tcl_GetString(objPtr);
@@ -1032,7 +1032,7 @@ DestroyElement(Element *elemPtr)
     }
     /* Remove the element for the graph's hash table of elements */
     if (elemPtr->hashPtr != NULL) {
-	Blt_DeleteHashEntry(&graphPtr->elements.table, elemPtr->hashPtr);
+	Tcl_DeleteHashEntry(elemPtr->hashPtr);
     }
     if (elemPtr->obj.name != NULL) {
       free((void*)(elemPtr->obj.name));
@@ -1066,7 +1066,7 @@ CreateElement(Graph *graphPtr, Tcl_Interp *interp, int objc,
 	      Tcl_Obj *const *objv, ClassId classId)
 {
     Element *elemPtr;
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     int isNew;
     char *string;
 
@@ -1128,18 +1128,18 @@ CreateElement(Graph *graphPtr, Tcl_Interp *interp, int objc,
 void
 Blt_DestroyElements(Graph *graphPtr)
 {
-    Blt_HashEntry *hPtr;
-    Blt_HashSearch iter;
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch iter;
     Element *elemPtr;
 
-    for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.table, &iter);
-	 hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
-	elemPtr = Blt_GetHashValue(hPtr);
+    for (hPtr = Tcl_FirstHashEntry(&graphPtr->elements.table, &iter);
+	 hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
+	elemPtr = Tcl_GetHashValue(hPtr);
 	elemPtr->hashPtr = NULL;
 	DestroyElement(elemPtr);
     }
-    Blt_DeleteHashTable(&graphPtr->elements.table);
-    Blt_DeleteHashTable(&graphPtr->elements.tagTable);
+    Tcl_DeleteHashTable(&graphPtr->elements.table);
+    Tcl_DeleteHashTable(&graphPtr->elements.tagTable);
     Blt_Chain_Destroy(graphPtr->elements.displayList);
 }
 
@@ -1326,15 +1326,15 @@ ActivateOp(
     int nIndices;
 
     if (objc == 3) {
-	Blt_HashEntry *hPtr;
-	Blt_HashSearch iter;
+	Tcl_HashEntry *hPtr;
+	Tcl_HashSearch iter;
 	Tcl_Obj *listObjPtr;
 
 	listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
 	/* List all the currently active elements */
-	for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.table, &iter);
-	     hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
-	    elemPtr = Blt_GetHashValue(hPtr);
+	for (hPtr = Tcl_FirstHashEntry(&graphPtr->elements.table, &iter);
+	     hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
+	    elemPtr = Tcl_GetHashValue(hPtr);
 	    if (elemPtr->flags & ACTIVE) {
 		Tcl_ListObjAppendElement(interp, listObjPtr, 
 			Tcl_NewStringObj(elemPtr->obj.name, -1));
@@ -1374,11 +1374,11 @@ ActivateOp(
 ClientData
 Blt_MakeElementTag(Graph *graphPtr, const char *tagName)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     int isNew;
 
-    hPtr = Blt_CreateHashEntry(&graphPtr->elements.tagTable, tagName, &isNew);
-    return Blt_GetHashKey(&graphPtr->elements.tagTable, hPtr);
+    hPtr = Tcl_CreateHashEntry(&graphPtr->elements.tagTable, tagName, &isNew);
+    return Tcl_GetHashKey(&graphPtr->elements.tagTable, hPtr);
 }
 
 /*
@@ -1399,15 +1399,15 @@ BindOp(
     Tcl_Obj *const *objv)
 {
     if (objc == 3) {
-	Blt_HashEntry *hPtr;
-	Blt_HashSearch iter;
+	Tcl_HashEntry *hPtr;
+	Tcl_HashSearch iter;
 	char *tagName;
 	Tcl_Obj *listObjPtr;
 
 	listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
-	for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.tagTable, &iter);
-	     hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
-	    tagName = Blt_GetHashKey(&graphPtr->elements.tagTable, hPtr);
+	for (hPtr = Tcl_FirstHashEntry(&graphPtr->elements.tagTable, &iter);
+	     hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
+	    tagName = Tcl_GetHashKey(&graphPtr->elements.tagTable, hPtr);
 	    Tcl_ListObjAppendElement(interp, listObjPtr, 
 				     Tcl_NewStringObj(tagName, -1));
 	}
@@ -1824,7 +1824,7 @@ ExistsOp(
     int objc,			/* Not used. */
     Tcl_Obj *const *objv)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
 
     hPtr = Blt_FindHashEntry(&graphPtr->elements.table, Tcl_GetString(objv[3]));
     Tcl_SetBooleanObj(Tcl_GetObjResult(interp), (hPtr != NULL));
@@ -1963,28 +1963,28 @@ NamesOp(
 
     listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
     if (objc == 3) {
-	Blt_HashEntry *hPtr;
-	Blt_HashSearch iter;
+	Tcl_HashEntry *hPtr;
+	Tcl_HashSearch iter;
 
-	for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.table, &iter);
-	     hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
+	for (hPtr = Tcl_FirstHashEntry(&graphPtr->elements.table, &iter);
+	     hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
 	    Element *elemPtr;
 	    Tcl_Obj *objPtr;
 
-	    elemPtr = Blt_GetHashValue(hPtr);
+	    elemPtr = Tcl_GetHashValue(hPtr);
 	    objPtr = Tcl_NewStringObj(elemPtr->obj.name, -1);
 	    Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
 	}
     } else {
-	Blt_HashEntry *hPtr;
-	Blt_HashSearch iter;
+	Tcl_HashEntry *hPtr;
+	Tcl_HashSearch iter;
 
-	for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.table, &iter);
-	     hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
+	for (hPtr = Tcl_FirstHashEntry(&graphPtr->elements.table, &iter);
+	     hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
 	    Element *elemPtr;
 	    int i;
 
-	    elemPtr = Blt_GetHashValue(hPtr);
+	    elemPtr = Tcl_GetHashValue(hPtr);
 	    for (i = 3; i < objc; i++) {
 		if (Tcl_StringMatch(elemPtr->obj.name,Tcl_GetString(objv[i]))) {
 		    Tcl_Obj *objPtr;
diff --git a/src/bltGrElemOp.h b/src/bltGrElemOp.h
index 0ad90b9..d898847 100644
--- a/src/bltGrElemOp.h
+++ b/src/bltGrElemOp.h
@@ -200,7 +200,7 @@ typedef struct {
 struct _Element {
     GraphObj obj;			/* Must be first field in element. */
     unsigned int flags;		
-    Blt_HashEntry *hashPtr;
+    Tcl_HashEntry *hashPtr;
 
     /* Fields specific to elements. */
     const char *label;			/* Label displayed in legend */
diff --git a/src/bltGrLegd.C b/src/bltGrLegd.C
index c1cd4b3..03ccf15 100644
--- a/src/bltGrLegd.C
+++ b/src/bltGrLegd.C
@@ -184,7 +184,7 @@ struct _Legend {
 					 * the selection changes. */
     int selectMode;			/* Mode of selection: single or
 					 * multiple. */
-    Blt_HashTable selectTable;		/* Table of selected elements. Used to
+    Tcl_HashTable selectTable;		/* Table of selected elements. Used to
 					 * quickly determine whether an element
 					 * is selected. */
     Blt_Chain selected;			/* List of selected elements. */
@@ -467,8 +467,8 @@ EventuallyInvokeSelectCmd(Legend *legendPtr)
 static void
 ClearSelection(Legend *legendPtr)
 {
-    Blt_DeleteHashTable(&legendPtr->selectTable);
-    Blt_InitHashTable(&legendPtr->selectTable, BLT_ONE_WORD_KEYS);
+    Tcl_DeleteHashTable(&legendPtr->selectTable);
+    Tcl_InitHashTable(&legendPtr->selectTable, TCL_ONE_WORD_KEYS);
     Blt_Chain_Reset(legendPtr->selected);
     Blt_Legend_EventuallyRedraw(legendPtr->graphPtr);
     if (legendPtr->selectCmd != NULL) {
@@ -964,9 +964,9 @@ SetLegendOrigin(Legend *legendPtr)
 static int
 EntryIsSelected(Legend *legendPtr, Element *elemPtr)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
 
-    hPtr = Blt_FindHashEntry(&legendPtr->selectTable, (char *)elemPtr);
+    hPtr = Tcl_FindHashEntry(&legendPtr->selectTable, (char *)elemPtr);
     return (hPtr != NULL);
 }
 
@@ -974,9 +974,9 @@ static void
 SelectElement(Legend *legendPtr, Element *elemPtr)
 {
     int isNew;
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
 
-    hPtr = Blt_CreateHashEntry(&legendPtr->selectTable, (char *)elemPtr,&isNew);
+    hPtr = Tcl_CreateHashEntry(&legendPtr->selectTable, (char *)elemPtr,&isNew);
     if (isNew) {
 	Blt_ChainLink link;
 
@@ -988,22 +988,22 @@ SelectElement(Legend *legendPtr, Element *elemPtr)
 static void
 DeselectElement(Legend *legendPtr, Element *elemPtr)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
 
-    hPtr = Blt_FindHashEntry(&legendPtr->selectTable, (char *)elemPtr);
+    hPtr = Tcl_FindHashEntry(&legendPtr->selectTable, (char *)elemPtr);
     if (hPtr != NULL) {
 	Blt_ChainLink link;
 
 	link = Blt_GetHashValue(hPtr);
 	Blt_Chain_DeleteLink(legendPtr->selected, link);
-	Blt_DeleteHashEntry(&legendPtr->selectTable, hPtr);
+	Tcl_DeleteHashEntry(hPtr);
     }
 }
 
 static void
 SelectEntry(Legend *legendPtr, Element *elemPtr)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
 
     switch (legendPtr->flags & SELECT_BLTMASK) {
     case SELECT_CLEAR:
@@ -1015,7 +1015,7 @@ SelectEntry(Legend *legendPtr, Element *elemPtr)
 	break;
 
     case SELECT_TOGGLE:
-	hPtr = Blt_FindHashEntry(&legendPtr->selectTable, (char *)elemPtr);
+	hPtr = Tcl_FindHashEntry(&legendPtr->selectTable, (char *)elemPtr);
 	if (hPtr != NULL) {
 	    DeselectElement(legendPtr, elemPtr);
 	} else {
@@ -1764,7 +1764,7 @@ Blt_CreateLegend(Graph *graphPtr)
     legendPtr->bindTable = Blt_CreateBindingTable(graphPtr->interp,
 	graphPtr->tkwin, graphPtr, PickEntryProc, Blt_GraphTags);
 
-    Blt_InitHashTable(&legendPtr->selectTable, BLT_ONE_WORD_KEYS);
+    Tcl_InitHashTable(&legendPtr->selectTable, TCL_ONE_WORD_KEYS);
     legendPtr->selected = Blt_Chain_Create();
     Tk_CreateSelHandler(legendPtr->tkwin, XA_PRIMARY, XA_STRING, 
 	SelectionProc, legendPtr, XA_STRING);
@@ -2144,17 +2144,17 @@ static int
 BindOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 {
     if (objc == 3) {
-	Blt_HashEntry *hPtr;
-	Blt_HashSearch iter;
+	Tcl_HashEntry *hPtr;
+	Tcl_HashSearch iter;
 	Tcl_Obj *listObjPtr;
 
 	listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
-	for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.tagTable, &iter);
-	    hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
+	for (hPtr = Tcl_FirstHashEntry(&graphPtr->elements.tagTable, &iter);
+	    hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
 	    const char *tagName;
 	    Tcl_Obj *objPtr;
 
-	    tagName = Blt_GetHashKey(&graphPtr->elements.tagTable, hPtr);
+	    tagName = Tcl_GetHashKey(&graphPtr->elements.tagTable, hPtr);
 	    objPtr = Tcl_NewStringObj(tagName, -1);
 	    Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
 	}
diff --git a/src/bltGrMarker.C b/src/bltGrMarker.C
index d4d1625..d81becb 100644
--- a/src/bltGrMarker.C
+++ b/src/bltGrMarker.C
@@ -159,7 +159,7 @@ struct _Marker {
 
     MarkerClass *classPtr;
 
-    Blt_HashEntry *hashPtr;
+    Tcl_HashEntry *hashPtr;
 
     Blt_ChainLink link;
 
@@ -199,7 +199,7 @@ typedef struct {
 
     MarkerClass *classPtr;
 
-    Blt_HashEntry *hashPtr;
+    Tcl_HashEntry *hashPtr;
 
     Blt_ChainLink link;
 
@@ -340,7 +340,7 @@ typedef struct {
 
     MarkerClass *classPtr;
 
-    Blt_HashEntry *hashPtr;
+    Tcl_HashEntry *hashPtr;
 
     Blt_ChainLink link;
 
@@ -477,7 +477,7 @@ typedef struct {
 
     MarkerClass *classPtr;
 
-    Blt_HashEntry *hashPtr;
+    Tcl_HashEntry *hashPtr;
 
     Blt_ChainLink link;
 
@@ -637,7 +637,7 @@ static MarkerClass polygonMarkerClass = {
 typedef struct {
     GraphObj obj;			/* Must be first field in marker. */
     MarkerClass *classPtr;
-    Blt_HashEntry *hashPtr;
+    Tcl_HashEntry *hashPtr;
     Blt_ChainLink link;
     const char *elemName;		/* Element associated with marker. Let's
 					 * you link a marker to an element. The
@@ -766,7 +766,7 @@ typedef struct {
 
     MarkerClass *classPtr;
 
-    Blt_HashEntry *hashPtr;
+    Tcl_HashEntry *hashPtr;
 
     Blt_ChainLink link;
 
@@ -1371,7 +1371,7 @@ ColorPairToObjProc(
 static INLINE int
 IsElementHidden(Marker *markerPtr)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     Graph *graphPtr = markerPtr->obj.graphPtr;
 
     /* Look up the named element and see if it's hidden */
@@ -1560,8 +1560,7 @@ DestroyMarker(Marker *markerPtr)
 	graphPtr->display, 0);
 
     if (markerPtr->hashPtr != NULL) {
-	Blt_DeleteHashEntry(&graphPtr->markers.table, 
-			    markerPtr->hashPtr);
+	Tcl_DeleteHashEntry(markerPtr->hashPtr);
     }
     if (markerPtr->link != NULL) {
 	Blt_Chain_DeleteLink(graphPtr->markers.displayList, markerPtr->link);
@@ -3532,7 +3531,7 @@ static int
 GetMarkerFromObj(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr,
 		 Marker **markerPtrPtr)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     const char *string;
 
     string = Tcl_GetString(objPtr);
@@ -3554,7 +3553,7 @@ RenameMarker(Graph *graphPtr, Marker *markerPtr, const char *oldName,
 	     const char *newName)
 {
     int isNew;
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
 
     /* Rename the marker only if no marker already exists by that name */
     hPtr = Blt_CreateHashEntry(&graphPtr->markers.table, newName, &isNew);
@@ -3569,7 +3568,7 @@ RenameMarker(Graph *graphPtr, Marker *markerPtr, const char *oldName,
 
     /* Delete the old hash entry */
     hPtr = Blt_FindHashEntry(&graphPtr->markers.table, oldName);
-    Blt_DeleteHashEntry(&graphPtr->markers.table, hPtr);
+    Tcl_DeleteHashEntry(hPtr);
     if (oldName != NULL) {
       free((void*)oldName);
     }
@@ -3644,17 +3643,17 @@ static int
 BindOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 {
     if (objc == 3) {
-	Blt_HashEntry *hp;
-	Blt_HashSearch iter;
+	Tcl_HashEntry *hp;
+	Tcl_HashSearch iter;
 	Tcl_Obj *listObjPtr;
 
 	listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
-	for (hp = Blt_FirstHashEntry(&graphPtr->markers.tagTable, &iter);
-	    hp != NULL; hp = Blt_NextHashEntry(&iter)) {
+	for (hp = Tcl_FirstHashEntry(&graphPtr->markers.tagTable, &iter);
+	    hp != NULL; hp = Tcl_NextHashEntry(&iter)) {
 	    const char *tag;
 	    Tcl_Obj *objPtr;
 
-	    tag = Blt_GetHashKey(&graphPtr->markers.tagTable, hp);
+	    tag = Tcl_GetHashKey(&graphPtr->markers.tagTable, hp);
 	    objPtr = Tcl_NewStringObj(tag, -1);
 	    Tcl_ListObjAppendElement(interp, listObjPtr, objPtr);
 	}
@@ -3790,7 +3789,7 @@ static int
 CreateOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 {
     Marker *markerPtr;
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     int isNew;
     ClassId classId;
     int i;
@@ -4102,7 +4101,7 @@ FindOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 static int
 ExistsOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
 
     hPtr = Blt_FindHashEntry(&graphPtr->markers.table, Tcl_GetString(objv[3]));
     Tcl_SetBooleanObj(Tcl_GetObjResult(interp), (hPtr != NULL));
@@ -4330,11 +4329,11 @@ Blt_MapMarkers(Graph *graphPtr)
 void
 Blt_DestroyMarkers(Graph *graphPtr)
 {
-    Blt_HashEntry *hPtr;
-    Blt_HashSearch iter;
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch iter;
 
-    for (hPtr = Blt_FirstHashEntry(&graphPtr->markers.table, &iter); 
-	 hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
+    for (hPtr = Tcl_FirstHashEntry(&graphPtr->markers.table, &iter); 
+	 hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
 	Marker *markerPtr;
 
 	markerPtr = Blt_GetHashValue(hPtr);
@@ -4345,8 +4344,8 @@ Blt_DestroyMarkers(Graph *graphPtr)
 	markerPtr->hashPtr = NULL;
 	DestroyMarker(markerPtr);
     }
-    Blt_DeleteHashTable(&graphPtr->markers.table);
-    Blt_DeleteHashTable(&graphPtr->markers.tagTable);
+    Tcl_DeleteHashTable(&graphPtr->markers.table);
+    Tcl_DeleteHashTable(&graphPtr->markers.tagTable);
     Blt_Chain_Destroy(graphPtr->markers.displayList);
 }
 
@@ -4392,12 +4391,12 @@ Blt_NearestMarker(
 ClientData
 Blt_MakeMarkerTag(Graph *graphPtr, const char *tagName)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     int isNew;
 
     assert(tagName != NULL);
-    hPtr = Blt_CreateHashEntry(&graphPtr->markers.tagTable, tagName, &isNew);
-    return Blt_GetHashKey(&graphPtr->markers.tagTable, hPtr);
+    hPtr = Tcl_CreateHashEntry(&graphPtr->markers.tagTable, tagName, &isNew);
+    return Tcl_GetHashKey(&graphPtr->markers.tagTable, hPtr);
 }
 
 
diff --git a/src/bltGrPenOp.C b/src/bltGrPenOp.C
index 93675b9..a2ab730 100644
--- a/src/bltGrPenOp.C
+++ b/src/bltGrPenOp.C
@@ -281,13 +281,13 @@ static int
 GetPenFromObj(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr, 
 	      Pen **penPtrPtr)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     Pen *penPtr;
     const char *name;
 
     penPtr = NULL;
     name = Tcl_GetString(objPtr);
-    hPtr = Blt_FindHashEntry(&graphPtr->penTable, name);
+    hPtr = Tcl_FindHashEntry(&graphPtr->penTable, name);
     if (hPtr != NULL) {
 	penPtr = Blt_GetHashValue(hPtr);
 	if (penPtr->flags & DELETE_PENDING) {
@@ -316,7 +316,7 @@ DestroyPen(Pen *penPtr)
       free((void*)(penPtr->name));
     }
     if (penPtr->hashPtr != NULL) {
-	Blt_DeleteHashEntry(&graphPtr->penTable, penPtr->hashPtr);
+	Tcl_DeleteHashEntry(penPtr->hashPtr);
     }
     free(penPtr);
 }
@@ -337,7 +337,7 @@ Blt_CreatePen(Graph *graphPtr, const char *penName, ClassId classId,
 	      int objc, Tcl_Obj *const *objv)
 {
     Pen *penPtr;
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     unsigned int configFlags;
     int isNew;
     int i;
@@ -368,7 +368,7 @@ Blt_CreatePen(Graph *graphPtr, const char *penName, ClassId classId,
 	}
     }
     classId = CID_ELEM_LINE;
-    hPtr = Blt_CreateHashEntry(&graphPtr->penTable, penName, &isNew);
+    hPtr = Tcl_CreateHashEntry(&graphPtr->penTable, penName, &isNew);
     if (!isNew) {
 	penPtr = Blt_GetHashValue(hPtr);
 	if ((penPtr->flags & DELETE_PENDING) == 0) {
@@ -413,13 +413,13 @@ int
 Blt_GetPenFromObj(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr,
 		  ClassId classId, Pen **penPtrPtr)
 {
-    Blt_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     Pen *penPtr;
     const char *name;
     
     penPtr = NULL;
     name = Tcl_GetString(objPtr);
-    hPtr = Blt_FindHashEntry(&graphPtr->penTable, name);
+    hPtr = Tcl_FindHashEntry(&graphPtr->penTable, name);
     if (hPtr != NULL) {
 	penPtr = Blt_GetHashValue(hPtr);
 	if (penPtr->flags & DELETE_PENDING) {
@@ -467,18 +467,18 @@ Blt_GetPenFromObj(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr,
 void
 Blt_DestroyPens(Graph *graphPtr)
 {
-    Blt_HashEntry *hPtr;
-    Blt_HashSearch iter;
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch iter;
 
-    for (hPtr = Blt_FirstHashEntry(&graphPtr->penTable, &iter);
-	hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
+    for (hPtr = Tcl_FirstHashEntry(&graphPtr->penTable, &iter);
+	hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
 	Pen *penPtr;
 
-	penPtr = Blt_GetHashValue(hPtr);
+	penPtr = Tcl_GetHashValue(hPtr);
 	penPtr->hashPtr = NULL;
 	DestroyPen(penPtr);
     }
-    Blt_DeleteHashTable(&graphPtr->penTable);
+    Tcl_DeleteHashTable(&graphPtr->penTable);
 }
 
 /*
@@ -673,25 +673,25 @@ NamesOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv)
 
     listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL);
     if (objc == 3) {
-	Blt_HashEntry *hPtr;
-	Blt_HashSearch iter;
+	Tcl_HashEntry *hPtr;
+	Tcl_HashSearch iter;
 
-	for (hPtr = Blt_FirstHashEntry(&graphPtr->penTable, &iter);
-	     hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
+	for (hPtr = Tcl_FirstHashEntry(&graphPtr->penTable, &iter);
+	     hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
 	    Pen *penPtr;
 
-	    penPtr = Blt_GetHashValue(hPtr);
+	    penPtr = Tcl_GetHashValue(hPtr);
 	    if ((penPtr->flags & DELETE_PENDING) == 0) {
 		Tcl_ListObjAppendElement(interp, listObjPtr, 
 			Tcl_NewStringObj(penPtr->name, -1));
 	    }
 	}
     } else {
-	Blt_HashEntry *hPtr;
-	Blt_HashSearch iter;
+	Tcl_HashEntry *hPtr;
+	Tcl_HashSearch iter;
 
-	for (hPtr = Blt_FirstHashEntry(&graphPtr->penTable, &iter);
-	     hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) {
+	for (hPtr = Tcl_FirstHashEntry(&graphPtr->penTable, &iter);
+	     hPtr != NULL; hPtr = Tcl_NextHashEntry(&iter)) {
 	    Pen *penPtr;
 
 	    penPtr = Blt_GetHashValue(hPtr);
diff --git a/src/bltGraph.C b/src/bltGraph.C
index d0ed323..d1e7d7b 100644
--- a/src/bltGraph.C
+++ b/src/bltGraph.C
@@ -445,7 +445,7 @@ AdjustAxisPointers(Graph *graphPtr)
 static int
 InitPens(Graph *graphPtr)
 {
-    Blt_InitHashTable(&graphPtr->penTable, BLT_STRING_KEYS);
+    Tcl_InitHashTable(&graphPtr->penTable, TCL_STRING_KEYS);
     if (Blt_CreatePen(graphPtr, "activeLine", CID_ELEM_LINE, 0, NULL) == NULL) {
   	return TCL_ERROR;
     }
@@ -848,13 +848,13 @@ CreateGraph(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv, ClassId classId)
     Blt_Ts_InitStyle(graphPtr->titleTextStyle);
     Blt_Ts_SetAnchor(graphPtr->titleTextStyle, TK_ANCHOR_N);
 
-    Blt_InitHashTable(&graphPtr->axes.table, BLT_STRING_KEYS);
-    Blt_InitHashTable(&graphPtr->axes.tagTable, BLT_STRING_KEYS);
-    Blt_InitHashTable(&graphPtr->elements.table, BLT_STRING_KEYS);
-    Blt_InitHashTable(&graphPtr->elements.tagTable, BLT_STRING_KEYS);
-    Blt_InitHashTable(&graphPtr->markers.table, BLT_STRING_KEYS);
-    Blt_InitHashTable(&graphPtr->markers.tagTable, BLT_STRING_KEYS);
-    Blt_InitHashTable(&graphPtr->dataTables, BLT_STRING_KEYS);
+    Tcl_InitHashTable(&graphPtr->axes.table, BLT_STRING_KEYS);
+    Tcl_InitHashTable(&graphPtr->axes.tagTable, BLT_STRING_KEYS);
+    Tcl_InitHashTable(&graphPtr->elements.table, BLT_STRING_KEYS);
+    Tcl_InitHashTable(&graphPtr->elements.tagTable, BLT_STRING_KEYS);
+    Tcl_InitHashTable(&graphPtr->markers.table, BLT_STRING_KEYS);
+    Tcl_InitHashTable(&graphPtr->markers.tagTable, BLT_STRING_KEYS);
+    Tcl_InitHashTable(&graphPtr->dataTables, BLT_STRING_KEYS);
     graphPtr->elements.displayList = Blt_Chain_Create();
     graphPtr->markers.displayList = Blt_Chain_Create();
     graphPtr->axes.displayList = Blt_Chain_Create();
diff --git a/src/bltGraph.h b/src/bltGraph.h
index 894d360..8a74ce3 100644
--- a/src/bltGraph.h
+++ b/src/bltGraph.h
@@ -204,23 +204,22 @@ typedef int (PenConfigureProc)(Graph *graphPtr, Pen *penPtr);
 typedef void (PenDestroyProc)(Graph *graphPtr, Pen *penPtr);
 
 struct _Pen {
-    const char *name;			/* Pen style identifier.  If NULL pen
+  const char *name;			/* Pen style identifier.  If NULL pen
 					 * was statically allocated. */
-    ClassId classId;			/* Type element using this pen. */
-    const char *typeId;			/* String token identifying the type of
+  ClassId classId;			/* Type element using this pen. */
+  const char *typeId;			/* String token identifying the type of
 					 * pen. */
-    unsigned int flags;			/* Indicates if the pen element is
+  unsigned int flags;			/* Indicates if the pen element is
 					 * active or normal. */
-    int refCount;			/* Reference count for elements using
-					 * this pen. */
-    Blt_HashEntry *hashPtr;
+  int refCount;			/* Reference count for elements using
+				 * this pen. */
+  Tcl_HashEntry *hashPtr;
 
-    Blt_ConfigSpec *configSpecs;	/* Configuration specifications */
+  Blt_ConfigSpec *configSpecs;	/* Configuration specifications */
 
-    PenConfigureProc *configProc;
-    PenDestroyProc *destroyProc;
-    Graph *graphPtr;			/* Graph that the pen is associated
-					 * with. */
+  PenConfigureProc *configProc;
+  PenDestroyProc *destroyProc;
+  Graph *graphPtr;			/* Graph that the pen is associated*/
 };
 
 /*
@@ -325,14 +324,14 @@ struct _Graph {
 					 * left in the window. */
     int width, height;			/* Actual size (in pixels) of graph
 					 * window or PostScript page. */
-    Blt_HashTable penTable;		/* Table of pens */
+    Tcl_HashTable penTable;		/* Table of pens */
     struct Component {
-	Blt_HashTable table;		/* Hash table of ids. */
+	Tcl_HashTable table;		/* Hash table of ids. */
 	Blt_Chain displayList;		/* Display list. */
-	Blt_HashTable tagTable;		/* Table of bind tags. */
+	Tcl_HashTable tagTable;		/* Table of bind tags. */
     } elements, markers, axes;
 
-    Blt_HashTable dataTables;		/* Hash table of datatable clients. */
+    Tcl_HashTable dataTables;		/* Hash table of datatable clients. */
     ClassId classId;			/* Default element type */
     Blt_BindTable bindTable;
     int nextMarkerId;			/* Tracks next marker identifier
@@ -416,7 +415,7 @@ struct _Graph {
 					 * zero, indicates nothing special
 					 * needs to be * done for "stack" or
 					 * "align" modes */
-    Blt_HashTable setTable;		/* Table managing sets of bars with
+    Tcl_HashTable setTable;		/* Table managing sets of bars with
 					 * the same abscissas. The bars in a
 					 * set may be displayed is various
 					 * ways: aligned, overlap, infront, or