Merge updates from core 8.5 branch.

43 files changed, 467 insertions, 412 deletions

diff --git a/generic/tk.decls b/generic/tk.decls
index 50b2837..2825111 100644
--- a/generic/tk.decls
+++ b/generic/tk.decls
@@ -1067,6 +1067,9 @@ declare 272 {
 declare 273 {
     void Tk_CreateOldPhotoImageFormat(Tk_PhotoImageFormat *formatPtr)
 }
+declare 275 {
+    void TkUnusedStubEntry(void)
+}
 
 # Define the platform specific public Tk interface.  These functions are
 # only available on the designated platform.
diff --git a/generic/tk.h b/generic/tk.h
index 8c13df2..186732b 100644
--- a/generic/tk.h
+++ b/generic/tk.h
@@ -17,10 +17,18 @@
 #define _TK
 
 #include <tcl.h>
-#if (TCL_MAJOR_VERSION != 8) || (TCL_MINOR_VERSION != 5)
-#	error Tk 8.5 must be compiled with tcl.h from Tcl 8.5
+#if (TCL_MAJOR_VERSION != 8) || (TCL_MINOR_VERSION < 5)
+#	error Tk 8.5 must be compiled with tcl.h from Tcl 8.5 or better
 #endif
 
+#ifndef _ANSI_ARGS_
+#   ifndef NO_PROTOTYPES
+#	define _ANSI_ARGS_(x)	x
+#   else
+#	define _ANSI_ARGS_(x)	()
+#   endif
+#endif
+
 /*
  * For C++ compilers, use extern "C"
  */
@@ -33,7 +41,7 @@ extern "C" {
  * When version numbers change here, you must also go into the following files
  * and update the version numbers:
  *
- * library/tk.tcl	(2 LOC patch)
+ * library/tk.tcl	(1 LOC patch)
  * unix/configure.in	(2 LOC Major, 2 LOC minor, 1 LOC patch)
  * win/configure.in	(as above)
  * README		(sections 0 and 1)
@@ -51,10 +59,10 @@ extern "C" {
 #define TK_MAJOR_VERSION	8
 #define TK_MINOR_VERSION	5
 #define TK_RELEASE_LEVEL	TCL_FINAL_RELEASE
-#define TK_RELEASE_SERIAL	13
+#define TK_RELEASE_SERIAL	17
 
 #define TK_VERSION		"8.5"
-#define TK_PATCH_LEVEL		"8.5.13"
+#define TK_PATCH_LEVEL		"8.5.17"
 
 /*
  * A special definition used to allow this header file to be included from
@@ -69,11 +77,9 @@ extern "C" {
 #ifndef RC_INVOKED
 
 #ifndef _XLIB_H
-#   if defined(MAC_OSX_TK)
-#	include <X11/Xlib.h>
+#   include <X11/Xlib.h>
+#   ifdef MAC_OSX_TK
 #	include <X11/X.h>
-#   else
-#	include <X11/Xlib.h>
 #   endif
 #endif
 #ifdef __STDC__
@@ -81,18 +87,20 @@ extern "C" {
 #endif
 
 #ifdef BUILD_tk
-# undef TCL_STORAGE_CLASS
-# define TCL_STORAGE_CLASS DLLEXPORT
+#undef TCL_STORAGE_CLASS
+#define TCL_STORAGE_CLASS	DLLEXPORT
 #endif
-
+
 /*
+ *----------------------------------------------------------------------
+ *
  * Decide whether or not to use input methods.
  */
 
 #ifdef XNQueryInputStyle
 #define TK_USE_INPUT_METHODS
 #endif
-
+
 /*
  * Dummy types that are used by clients:
  */
@@ -118,8 +126,10 @@ typedef struct Tk_StyledElement_ *Tk_StyledElement;
  */
 
 typedef const char *Tk_Uid;
-
+
 /*
+ *----------------------------------------------------------------------
+ *
  * The enum below defines the valid types for Tk configuration options as
  * implemented by Tk_InitOptions, Tk_SetOptions, etc.
  */
@@ -217,7 +227,7 @@ typedef void (Tk_CustomOptionFreeProc) _ANSI_ARGS_((ClientData clientData,
 	Tk_Window tkwin, char *internalPtr));
 
 typedef struct Tk_ObjCustomOption {
-    const char *name; /* Name of the custom option. */
+    const char *name;		/* Name of the custom option. */
     Tk_CustomOptionSetProc *setProc;
 				/* Function to use to set a record's option
 				 * value from a Tcl_Obj */
@@ -293,7 +303,7 @@ typedef struct Tk_SavedOptions {
 				 * old values in a single structure. NULL
 				 * means no more structures. */
 } Tk_SavedOptions;
-
+
 /*
  * Structure used to describe application-specific configuration options:
  * indicates procedures to call to parse an option and to return a text string
@@ -392,7 +402,7 @@ typedef enum {
 #define TK_CONFIG_OPTION_SPECIFIED      (1 << 4)
 #define TK_CONFIG_USER_BIT		0x100
 #endif /* __NO_OLD_CONFIG */
-
+
 /*
  * Structure used to specify how to handle argv options.
  */
@@ -436,7 +446,7 @@ typedef struct {
 #define TK_ARGV_NO_LEFTOVERS		0x2
 #define TK_ARGV_NO_ABBREV		0x4
 #define TK_ARGV_DONT_SKIP_FIRST_ARG	0x8
-
+
 /*
  * Enumerated type for describing actions to be taken in response to a
  * restrictProc established by Tk_RestrictEvents.
@@ -494,7 +504,7 @@ typedef enum {
     TK_ANCHOR_S, TK_ANCHOR_SW, TK_ANCHOR_W, TK_ANCHOR_NW,
     TK_ANCHOR_CENTER
 } Tk_Anchor;
-
+
 /*
  * Enumerated type for describing a style of justification:
  */
@@ -538,7 +548,7 @@ typedef struct Tk_FontMetrics {
 
 #define TK_IGNORE_TABS		8
 #define TK_IGNORE_NEWLINES	16
-
+
 /*
  * Widget class procedures used to implement platform specific widget
  * behavior.
@@ -582,7 +592,7 @@ typedef struct Tk_ClassProcs {
 #define Tk_GetClassProc(procs, which) \
     (((procs) == NULL) ? NULL : \
     (((procs)->size <= Tk_Offset(Tk_ClassProcs, which)) ? NULL:(procs)->which))
-
+
 /*
  * Each geometry manager (the packer, the placer, etc.) is represented by a
  * structure of the following form, which indicates procedures to invoke in
@@ -616,13 +626,13 @@ typedef struct Tk_GeomMgr {
 #define TK_SCROLL_PAGES		2
 #define TK_SCROLL_UNITS		3
 #define TK_SCROLL_ERROR		4
-
+
 /*
- *---------------------------------------------------------------------------
+ *----------------------------------------------------------------------
  *
  * Extensions to the X event set
  *
- *---------------------------------------------------------------------------
+ *----------------------------------------------------------------------
  */
 
 #define VirtualEvent	    (MappingNotify + 1)
@@ -681,12 +691,12 @@ typedef XActivateDeactivateEvent XActivateEvent;
 typedef XActivateDeactivateEvent XDeactivateEvent;
 
 /*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  *
  * Macros for querying Tk_Window structures. See the manual entries for
  * documentation.
  *
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  */
 
 #define Tk_Display(tkwin)	(((Tk_FakeWin *) (tkwin))->display)
@@ -883,11 +893,11 @@ typedef struct Tk_FakeWin {
 #define TK_WM_MANAGEABLE	0x80000
 
 /*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  *
  * Procedure prototypes and structures used for defining new canvas items:
  *
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  */
 
 typedef enum {
@@ -1124,7 +1134,7 @@ typedef struct Tk_CanvasTextInfo {
 				 * should be displayed in focusItemPtr.
 				 * Read-only to items.*/
 } Tk_CanvasTextInfo;
-
+
 /*
  * Structures used for Dashing and Outline.
  */
@@ -1180,11 +1190,11 @@ typedef struct Tk_Outline {
 } Tk_Outline;
 
 /*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  *
  * Procedure prototypes and structures used for managing images:
  *
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  */
 
 typedef struct Tk_ImageType Tk_ImageType;
@@ -1247,13 +1257,13 @@ struct Tk_ImageType {
 				 * manager. */
     char *reserved;		/* reserved for future expansion */
 };
-
+
 /*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  *
  * Additional definitions used to manage images of type "photo".
  *
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  */
 
 /*
@@ -1363,18 +1373,13 @@ struct Tk_PhotoImageFormat {
 				 * currently known. Filled in by Tk, not by
 				 * image format handler. */
 };
-
-#ifdef USE_OLD_IMAGE
-#define Tk_CreateImageType Tk_CreateOldImageType
-#define Tk_CreatePhotoImageFormat Tk_CreateOldPhotoImageFormat
-#endif
 
 /*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  *
  * Procedure prototypes and structures used for managing styles:
  *
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  */
 
 /*
@@ -1438,13 +1443,13 @@ typedef struct Tk_ElementSpec {
 #define TK_ELEMENT_STATE_PRESSED        1<<3
 
 /*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  *
  * The definitions below provide backward compatibility for functions and
  * types related to event handling that used to be in Tk but have moved to
  * Tcl.
  *
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  */
 
 #define TK_READABLE		TCL_READABLE
@@ -1491,21 +1496,18 @@ EXTERN const char *	Tk_PkgInitStubsCheck _ANSI_ARGS_((Tcl_Interp *interp,
 			    const char *version, int exact));
 
 #ifndef USE_TK_STUBS
-
 #define Tk_InitStubs(interp, version, exact) \
     Tk_PkgInitStubsCheck(interp, version, exact)
-
-#endif
+#endif /* USE_TK_STUBS */
 
 #define Tk_InitImageArgs(interp, argc, argv) /**/
-
 
 /*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  *
  * Additional procedure types defined by Tk.
  *
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  */
 
 typedef int (Tk_ErrorProc) _ANSI_ARGS_((ClientData clientData,
@@ -1523,18 +1525,27 @@ typedef Tk_RestrictAction (Tk_RestrictProc) _ANSI_ARGS_((
 	ClientData clientData, XEvent *eventPtr));
 typedef int (Tk_SelectionProc) _ANSI_ARGS_((ClientData clientData,
 	int offset, char *buffer, int maxBytes));
-
+
 /*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  *
- * Platform independant exported procedures and variables.
+ * Platform independent exported procedures and variables.
  *
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  */
 
 #include "tkDecls.h"
+
+#ifdef USE_OLD_IMAGE
+#undef Tk_CreateImageType
+#define Tk_CreateImageType		Tk_CreateOldImageType
+#undef Tk_CreatePhotoImageFormat
+#define Tk_CreatePhotoImageFormat	Tk_CreateOldPhotoImageFormat
+#endif /* USE_OLD_IMAGE */
 
 /*
+ *----------------------------------------------------------------------
+ *
  * Allow users to say that they don't want to alter their source to add extra
  * arguments to Tk_PhotoPutBlock() et al; DO NOT DEFINE THIS WHEN BUILDING TK.
  *
@@ -1574,11 +1585,7 @@ typedef int (Tk_SelectionProc) _ANSI_ARGS_((ClientData clientData,
 #   endif
 #   define Tk_PhotoSetSize		Tk_PhotoSetSize_Panic
 #endif /* USE_PANIC_ON_PHOTO_ALLOC_FAILURE */
-
-/*
- * Tcl commands exported by Tk:
- */
-
+
 #undef TCL_STORAGE_CLASS
 #define TCL_STORAGE_CLASS DLLIMPORT
 
diff --git a/generic/tkBind.c b/generic/tkBind.c
index dbbaaf4..d7c8c04 100644
--- a/generic/tkBind.c
+++ b/generic/tkBind.c
@@ -4603,7 +4603,7 @@ TkKeysymToString(
  *
  * TkCopyAndGlobalEval --
  *
- *	This function makes a copy of a script then calls Tcl_GlobalEval to
+ *	This function makes a copy of a script then calls Tcl_EvalEx to
  *	evaluate it. It's used in situations where the execution of a command
  *	may cause the original command string to be reallocated.
  *
diff --git a/generic/tkCanvUtil.c b/generic/tkCanvUtil.c
index eca3789..b4d0c3b 100644
--- a/generic/tkCanvUtil.c
+++ b/generic/tkCanvUtil.c
@@ -1660,8 +1660,10 @@ TkCanvTranslatePath(
     double *a, *b, *t;		/* Pointers to parts of the temporary
 				 * storage */
     int i, j;			/* Loop counters */
+#ifndef NDEBUG
     int maxOutput;		/* Maximum number of outputs that we will
 				 * allow */
+#endif
     double limit[4];		/* Boundries at which clipping occurs */
     double staticSpace[480];	/* Temp space from the stack */
 
@@ -1756,7 +1758,9 @@ TkCanvTranslatePath(
      * This is the loop that makes the four passes through the data.
      */
 
+#ifndef NDEBUG
     maxOutput = numVertex*3;
+#endif
     for (j=0; j<4; j++){
 	double xClip = limit[j];
 	int inside = a[0]<xClip;
diff --git a/generic/tkCmds.c b/generic/tkCmds.c
index a86ef84..2010b6e 100644
--- a/generic/tkCmds.c
+++ b/generic/tkCmds.c
@@ -232,7 +232,7 @@ TkBindEventProc(
     ClientData objects[MAX_OBJS], *objPtr;
     TkWindow *topLevPtr;
     int i, count;
-    char *p;
+    const char *p;
     Tcl_HashEntry *hPtr;
 
     if ((winPtr->mainPtr == NULL) || (winPtr->mainPtr->bindingTable == NULL)) {
@@ -251,7 +251,7 @@ TkBindEventProc(
 		    (winPtr->numTags * sizeof(ClientData)));
 	}
 	for (i = 0; i < winPtr->numTags; i++) {
-	    p = (char *) winPtr->tagPtr[i];
+	    p = winPtr->tagPtr[i];
 	    if (*p == '.') {
 		hPtr = Tcl_FindHashEntry(&winPtr->mainPtr->nameTable, p);
 		if (hPtr != NULL) {
@@ -327,7 +327,6 @@ Tk_BindtagsObjCmd(
     }
     if (objc == 2) {
 	listPtr = Tcl_NewObj();
-	Tcl_IncrRefCount(listPtr);
 	if (winPtr->numTags == 0) {
 	    Tcl_ListObjAppendElement(interp, listPtr,
 		    Tcl_NewStringObj(winPtr->pathName, -1));
@@ -350,7 +349,6 @@ Tk_BindtagsObjCmd(
 	    }
 	}
 	Tcl_SetObjResult(interp, listPtr);
-	Tcl_DecrRefCount(listPtr);
 	return TCL_OK;
     }
     if (winPtr->tagPtr != NULL) {
@@ -411,17 +409,17 @@ TkFreeBindingTags(
     TkWindow *winPtr)		/* Window whose tags are to be released. */
 {
     int i;
-    char *p;
+    const char *p;
 
     for (i = 0; i < winPtr->numTags; i++) {
-	p = (char *) (winPtr->tagPtr[i]);
+	p = winPtr->tagPtr[i];
 	if (*p == '.') {
 	    /*
 	     * Names starting with "." are malloced rather than Uids, so they
 	     * have to be freed.
 	     */
 
-	    ckfree(p);
+	    ckfree((char *)p);
 	}
     }
     ckfree((char *) winPtr->tagPtr);
@@ -1503,9 +1501,7 @@ Tk_WinfoObjCmd(
 	    Tcl_SetStringObj(resultPtr, Tk_PathName(tkwin), -1);
 	}
 	break;
-    case WIN_INTERPS: {
-	int result;
-
+    case WIN_INTERPS:
 	skip = TkGetDisplayOf(interp, objc - 2, objv + 2, &tkwin);
 	if (skip < 0) {
 	    return TCL_ERROR;
@@ -1514,9 +1510,7 @@ Tk_WinfoObjCmd(
 	    Tcl_WrongNumArgs(interp, 2, objv, "?-displayof window?");
 	    return TCL_ERROR;
 	}
-	result = TkGetInterpNames(interp, tkwin);
-	return result;
-    }
+	return TkGetInterpNames(interp, tkwin);
     case WIN_PATHNAME: {
 	Window id;
 
diff --git a/generic/tkConsole.c b/generic/tkConsole.c
index b10aaaf..2cd2632 100644
--- a/generic/tkConsole.c
+++ b/generic/tkConsole.c
@@ -220,11 +220,10 @@ Tk_InitConsoleChannels(
     Tcl_Channel consoleChannel;
 
     /*
-     * Ensure that we are getting the matching version of Tcl. This is really
-     * only an issue when Tk is loaded dynamically.
+     * Ensure that we are getting a compatible version of Tcl.
      */
 
-    if (Tcl_InitStubs(interp, TCL_VERSION, 0) == NULL) {
+    if (Tcl_InitStubs(interp, "8.5.0", 0) == NULL) {
         return;
     }
 
@@ -436,7 +435,8 @@ Tk_CreateConsoleWindow(
     }
 
     Tcl_Preserve((ClientData) consoleInterp);
-    result = Tcl_GlobalEval(consoleInterp, "source $tk_library/console.tcl");
+    result = Tcl_EvalEx(consoleInterp, "source $tk_library/console.tcl",
+	    -1, TCL_EVAL_GLOBAL);
     if (result == TCL_ERROR) {
 	Tcl_SetReturnOptions(interp,
 		Tcl_GetReturnOptions(consoleInterp, result));
@@ -528,7 +528,7 @@ ConsoleOutput(
 
 	    Tcl_DStringFree(&ds);
 	    Tcl_IncrRefCount(cmd);
-	    Tcl_GlobalEvalObj(consoleInterp, cmd);
+	    Tcl_EvalObjEx(consoleInterp, cmd, TCL_EVAL_GLOBAL);
 	    Tcl_DecrRefCount(cmd);
 	}
     }
@@ -732,7 +732,7 @@ ConsoleObjCmd(
     Tcl_IncrRefCount(cmd);
     if (consoleInterp && !Tcl_InterpDeleted(consoleInterp)) {
 	Tcl_Preserve((ClientData) consoleInterp);
-	result = Tcl_GlobalEvalObj(consoleInterp, cmd);
+	result = Tcl_EvalObjEx(consoleInterp, cmd, TCL_EVAL_GLOBAL);
 	Tcl_SetReturnOptions(interp,
 		Tcl_GetReturnOptions(consoleInterp, result));
 	Tcl_SetObjResult(interp, Tcl_GetObjResult(consoleInterp));
@@ -794,7 +794,7 @@ InterpreterObjCmd(
     Tcl_Preserve((ClientData) otherInterp);
     switch ((enum option) index) {
     case OTHER_EVAL:
-   	result = Tcl_GlobalEvalObj(otherInterp, objv[2]);
+   	result = Tcl_EvalObjEx(otherInterp, objv[2], TCL_EVAL_GLOBAL);
 	/*
 	 * TODO: Should exceptions be filtered here?
 	 */
@@ -929,7 +929,7 @@ ConsoleEventProc(
 	Tcl_Interp *consoleInterp = info->consoleInterp;
 
 	if (consoleInterp && !Tcl_InterpDeleted(consoleInterp)) {
-	    Tcl_GlobalEval(consoleInterp, "tk::ConsoleExit");
+	    Tcl_EvalEx(consoleInterp, "tk::ConsoleExit", -1, TCL_EVAL_GLOBAL);
 	}
 
 	if (--info->refCount <= 0) {
diff --git a/generic/tkDecls.h b/generic/tkDecls.h
index d06df4b..00a3dde 100644
--- a/generic/tkDecls.h
+++ b/generic/tkDecls.h
@@ -25,6 +25,10 @@
 
 /* !BEGIN!: Do not edit below this line. */
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
  * Exported function declarations:
  */
@@ -1674,6 +1678,12 @@ EXTERN void		Tk_CreateOldImageType(Tk_ImageType *typePtr);
 EXTERN void		Tk_CreateOldPhotoImageFormat(
 				Tk_PhotoImageFormat *formatPtr);
 #endif
+/* Slot 274 is reserved */
+#ifndef TkUnusedStubEntry_TCL_DECLARED
+#define TkUnusedStubEntry_TCL_DECLARED
+/* 275 */
+EXTERN void		TkUnusedStubEntry(void);
+#endif
 
 typedef struct TkStubHooks {
     struct TkPlatStubs *tkPlatStubs;
@@ -1960,12 +1970,12 @@ typedef struct TkStubs {
     Tcl_Interp * (*tk_Interp) (Tk_Window tkwin); /* 271 */
     void (*tk_CreateOldImageType) (Tk_ImageType *typePtr); /* 272 */
     void (*tk_CreateOldPhotoImageFormat) (Tk_PhotoImageFormat *formatPtr); /* 273 */
+    VOID *reserved274;
+    void (*tkUnusedStubEntry) (void); /* 275 */
 } TkStubs;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
 extern TkStubs *tkStubsPtr;
+
 #ifdef __cplusplus
 }
 #endif
@@ -3066,6 +3076,11 @@ extern TkStubs *tkStubsPtr;
 #define Tk_CreateOldPhotoImageFormat \
 	(tkStubsPtr->tk_CreateOldPhotoImageFormat) /* 273 */
 #endif
+/* Slot 274 is reserved */
+#ifndef TkUnusedStubEntry
+#define TkUnusedStubEntry \
+	(tkStubsPtr->tkUnusedStubEntry) /* 275 */
+#endif
 
 #endif /* defined(USE_TK_STUBS) && !defined(USE_TK_STUB_PROCS) */
 
@@ -3074,5 +3089,7 @@ extern TkStubs *tkStubsPtr;
 #undef TCL_STORAGE_CLASS
 #define TCL_STORAGE_CLASS DLLIMPORT
 
+#undef TkUnusedStubEntry
+
 #endif /* _TKDECLS */
 
diff --git a/generic/tkEntry.c b/generic/tkEntry.c
index 26311a3..816b7fa 100644
--- a/generic/tkEntry.c
+++ b/generic/tkEntry.c
@@ -2519,12 +2519,6 @@ GetEntryIndex(
 	} else {
 	badIndex:
 
-	    /*
-	     * Some of the paths here leave messages in the interp's result,
-	     * so we have to clear it out before storing our own message.
-	     */
-
-	    Tcl_SetResult(interp, NULL, TCL_STATIC);
 	    Tcl_AppendResult(interp, "bad ",
 		    (entryPtr->type == TK_ENTRY) ? "entry" : "spinbox",
 		    " index \"", string, "\"", NULL);
@@ -2544,7 +2538,6 @@ GetEntryIndex(
 	}
     } else if (string[0] == 's') {
 	if (entryPtr->selectFirst < 0) {
-	    Tcl_SetResult(interp, NULL, TCL_STATIC);
 	    Tcl_AppendResult(interp, "selection isn't in widget ",
 		    Tk_PathName(entryPtr->tkwin), NULL);
 	    return TCL_ERROR;
@@ -2562,7 +2555,7 @@ GetEntryIndex(
     } else if (string[0] == '@') {
 	int x, roundUp, maxWidth;
 
-	if (Tcl_GetInt(interp, string + 1, &x) != TCL_OK) {
+	if (Tcl_GetInt(NULL, string + 1, &x) != TCL_OK) {
 	    goto badIndex;
 	}
 	if (x < entryPtr->inset) {
@@ -2589,7 +2582,7 @@ GetEntryIndex(
 	    *indexPtr += 1;
 	}
     } else {
-	if (Tcl_GetInt(interp, string, indexPtr) != TCL_OK) {
+	if (Tcl_GetInt(NULL, string, indexPtr) != TCL_OK) {
 	    goto badIndex;
 	}
 	if (*indexPtr < 0){
diff --git a/generic/tkFont.c b/generic/tkFont.c
index 1a6474f..9eaaf94 100644
--- a/generic/tkFont.c
+++ b/generic/tkFont.c
@@ -1522,8 +1522,8 @@ FreeFontObjProc(
 	fontPtr->objRefCount--;
 	if ((fontPtr->resourceRefCount == 0) && (fontPtr->objRefCount == 0)) {
 	    ckfree((char *) fontPtr);
-	    objPtr->internalRep.twoPtrValue.ptr1 = NULL;
 	}
+	objPtr->internalRep.twoPtrValue.ptr1 = NULL;
     }
 }
 
diff --git a/generic/tkImgPPM.c b/generic/tkImgPPM.c
index 8a46fde..ddd16b2 100644
--- a/generic/tkImgPPM.c
+++ b/generic/tkImgPPM.c
@@ -140,7 +140,7 @@ FileReadPPM(
 				 * image being read. */
 {
     int fileWidth, fileHeight, maxIntensity;
-    int nLines, nBytes, h, type, count;
+    int nLines, nBytes, h, type, count, bytesPerChannel = 1;
     unsigned char *pixelPtr;
     Tk_PhotoImageBlock block;
 
@@ -155,13 +155,15 @@ FileReadPPM(
 		"\" has dimension(s) <= 0", NULL);
 	return TCL_ERROR;
     }
-    if ((maxIntensity <= 0) || (maxIntensity >= 256)) {
+    if ((maxIntensity <= 0) || (maxIntensity > 0xffff)) {
 	char buffer[TCL_INTEGER_SPACE];
 
 	sprintf(buffer, "%d", maxIntensity);
 	Tcl_AppendResult(interp, "PPM image file \"", fileName,
 		"\" has bad maximum intensity value ", buffer, NULL);
 	return TCL_ERROR;
+    } else if (maxIntensity > 0x00ff) {
+	bytesPerChannel = 2;
     }
 
     if ((srcX + width) > fileWidth) {
@@ -171,20 +173,20 @@ FileReadPPM(
 	height = fileHeight - srcY;
     }
     if ((width <= 0) || (height <= 0)
-	|| (srcX >= fileWidth) || (srcY >= fileHeight)) {
+	    || (srcX >= fileWidth) || (srcY >= fileHeight)) {
 	return TCL_OK;
     }
 
     if (type == PGM) {
-	block.pixelSize = 1;
+	block.pixelSize = 1 * bytesPerChannel;
 	block.offset[0] = 0;
 	block.offset[1] = 0;
 	block.offset[2] = 0;
     } else {
-	block.pixelSize = 3;
+	block.pixelSize = 3 * bytesPerChannel;
 	block.offset[0] = 0;
-	block.offset[1] = 1;
-	block.offset[2] = 2;
+	block.offset[1] = 1 * bytesPerChannel;
+	block.offset[2] = 2 * bytesPerChannel;
     }
     block.offset[3] = 0;
     block.width = width;
@@ -224,12 +226,21 @@ FileReadPPM(
 	    ckfree((char *) pixelPtr);
 	    return TCL_ERROR;
 	}
-	if (maxIntensity != 255) {
+	if (maxIntensity < 0x00ff) {
 	    unsigned char *p;
 
 	    for (p = pixelPtr; count > 0; count--, p++) {
 		*p = (((int) *p) * 255)/maxIntensity;
 	    }
+	} else if (maxIntensity > 0x00ff) {
+	    unsigned char *p;
+	    unsigned int value;
+
+	    for (p = pixelPtr; count > 0; count--, p += 2) {
+		value = ((unsigned int) p[0]) * 256 + ((unsigned int) p[1]);
+		value = value * 255 / maxIntensity;
+		p[0] = p[1] = (unsigned char) value;
+	    }
 	}
 	block.height = nLines;
 	if (Tk_PhotoPutBlock(interp, imageHandle, &block, destX, destY,
@@ -474,7 +485,7 @@ StringReadPPM(
 				 * image being read. */
 {
     int fileWidth, fileHeight, maxIntensity;
-    int nLines, nBytes, h, type, count, dataSize;
+    int nLines, nBytes, h, type, count, dataSize, bytesPerChannel = 1;
     unsigned char *pixelPtr, *dataBuffer;
     Tk_PhotoImageBlock block;
 
@@ -490,7 +501,7 @@ StringReadPPM(
 		NULL);
 	return TCL_ERROR;
     }
-    if ((maxIntensity <= 0) || (maxIntensity >= 256)) {
+    if ((maxIntensity <= 0) || (maxIntensity > 0xffff)) {
 	char buffer[TCL_INTEGER_SPACE];
 
 	sprintf(buffer, "%d", maxIntensity);
@@ -498,6 +509,8 @@ StringReadPPM(
 		"PPM image data has bad maximum intensity value ", buffer,
 		NULL);
 	return TCL_ERROR;
+    } else if (maxIntensity > 0x00ff) {
+	bytesPerChannel = 2;
     }
 
     if ((srcX + width) > fileWidth) {
@@ -512,15 +525,15 @@ StringReadPPM(
     }
 
     if (type == PGM) {
-	block.pixelSize = 1;
+	block.pixelSize = 1 * bytesPerChannel;
 	block.offset[0] = 0;
 	block.offset[1] = 0;
 	block.offset[2] = 0;
     } else {
-	block.pixelSize = 3;
+	block.pixelSize = 3 * bytesPerChannel;
 	block.offset[0] = 0;
-	block.offset[1] = 1;
-	block.offset[2] = 2;
+	block.offset[1] = 1 * bytesPerChannel;
+	block.offset[2] = 2 * bytesPerChannel;
     }
     block.offset[3] = 0;
     block.width = width;
@@ -531,7 +544,7 @@ StringReadPPM(
 	dataSize -= srcY * block.pitch;
     }
 
-    if (maxIntensity == 255) {
+    if (maxIntensity == 0x00ff) {
 	/*
 	 * We have all the data in memory, so write everything in one go.
 	 */
@@ -574,8 +587,19 @@ StringReadPPM(
 	    Tcl_AppendResult(interp, "truncated PPM data", NULL);
 	    return TCL_ERROR;
 	}
-	for (p=pixelPtr,count=nBytes ; count>0 ; count--,p++,dataBuffer++) {
-	    *p = (((int) *dataBuffer) * 255)/maxIntensity;
+	if (maxIntensity < 0x00ff) {
+	    for (p=pixelPtr,count=nBytes ; count>0 ; count--,p++,dataBuffer++) {
+		*p = (((int) *dataBuffer) * 255)/maxIntensity;
+	    }
+	} else {
+	    unsigned char *p;
+	    unsigned int value;
+
+	    for (p = pixelPtr,count=nBytes; count > 1; count-=2, p += 2) {
+		value = ((unsigned int) p[0]) * 256 + ((unsigned int) p[1]);
+		value = value * 255 / maxIntensity;
+		p[0] = p[1] = (unsigned char) value;
+	    }
 	}
 	dataSize -= nBytes;
 	block.height = nLines;
diff --git a/generic/tkImgPhoto.c b/generic/tkImgPhoto.c
index 85c7de5..58c4484 100644
--- a/generic/tkImgPhoto.c
+++ b/generic/tkImgPhoto.c
@@ -5648,12 +5648,6 @@ ImgGetPhoto(
 	    break;
 	}
     }
-    if (!alphaOffset) {
-	blockPtr->pixelPtr--;
-	blockPtr->offset[0]++;
-	blockPtr->offset[1]++;
-	blockPtr->offset[2]++;
-    }
     greenOffset = blockPtr->offset[1] - blockPtr->offset[0];
     blueOffset = blockPtr->offset[2] - blockPtr->offset[0];
     if (((optPtr->options & OPT_BACKGROUND) && alphaOffset) ||
@@ -5766,9 +5760,14 @@ ImgGetPhoto(
 	if (newPixelSize>2) {
 	    blockPtr->offset[1]= 1;
 	    blockPtr->offset[2]= 2;
+	    blockPtr->offset[3]= 3;
 	} else {
 	    blockPtr->offset[1]= 0;
 	    blockPtr->offset[2]= 0;
+	    blockPtr->offset[3]= 1;
+	}
+	if (!alphaOffset) {
+	  blockPtr->offset[3]= -1;
 	}
 	return data;
     }
diff --git a/generic/tkInt.decls b/generic/tkInt.decls
index 6794edb..17f39ba 100644
--- a/generic/tkInt.decls
+++ b/generic/tkInt.decls
@@ -568,6 +568,9 @@ declare 180 {
     char *TkSmoothPrintProc(ClientData clientData, Tk_Window tkwin,
 	    char *widgRec, int offset, Tcl_FreeProc **freeProcPtr)
 }
+declare 184 {
+    void TkUnusedStubEntry(void)
+}
 
 ##############################################################################
 
diff --git a/generic/tkInt.h b/generic/tkInt.h
index 9a36e1e..15a01c5 100644
--- a/generic/tkInt.h
+++ b/generic/tkInt.h
@@ -570,6 +570,7 @@ typedef struct TkDisplay {
 #define TK_DISPLAY_USE_IM			(1 << 1)
 #define TK_DISPLAY_WM_TRACING			(1 << 3)
 #define TK_DISPLAY_IN_WARP			(1 << 4)
+#define TK_DISPLAY_USE_XKB			(1 << 5)
 
 /*
  * One of the following structures exists for each error handler created by a
@@ -975,11 +976,6 @@ MODULE_SCOPE CONST char *const tkWebColors[20];
 
 #include "tkIntDecls.h"
 
-#ifdef BUILD_tk
-#undef TCL_STORAGE_CLASS
-#define TCL_STORAGE_CLASS DLLEXPORT
-#endif
-
 /*
  * Themed widget set init function:
  */
@@ -1200,9 +1196,6 @@ MODULE_SCOPE int	TkUnsupported1ObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 
-#undef TCL_STORAGE_CLASS
-#define TCL_STORAGE_CLASS DLLIMPORT
-
 #endif /* _TKINT */
 
 /*
diff --git a/generic/tkIntDecls.h b/generic/tkIntDecls.h
index 5fcce30..9dea8d4 100644
--- a/generic/tkIntDecls.h
+++ b/generic/tkIntDecls.h
@@ -28,6 +28,10 @@
 
 /* !BEGIN!: Do not edit below this line. */
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
  * Exported function declarations:
  */
@@ -962,6 +966,14 @@ EXTERN char *		TkSmoothPrintProc(ClientData clientData,
 				Tk_Window tkwin, char *widgRec, int offset,
 				Tcl_FreeProc **freeProcPtr);
 #endif
+/* Slot 181 is reserved */
+/* Slot 182 is reserved */
+/* Slot 183 is reserved */
+#ifndef TkUnusedStubEntry_TCL_DECLARED
+#define TkUnusedStubEntry_TCL_DECLARED
+/* 184 */
+EXTERN void		TkUnusedStubEntry(void);
+#endif
 
 typedef struct TkIntStubs {
     int magic;
@@ -1175,12 +1187,14 @@ typedef struct TkIntStubs {
     char * (*tkOrientPrintProc) (ClientData clientData, Tk_Window tkwin, char *widgRec, int offset, Tcl_FreeProc **freeProcPtr); /* 178 */
     int (*tkSmoothParseProc) (ClientData clientData, Tcl_Interp *interp, Tk_Window tkwin, CONST char *value, char *widgRec, int offset); /* 179 */
     char * (*tkSmoothPrintProc) (ClientData clientData, Tk_Window tkwin, char *widgRec, int offset, Tcl_FreeProc **freeProcPtr); /* 180 */
+    VOID *reserved181;
+    VOID *reserved182;
+    VOID *reserved183;
+    void (*tkUnusedStubEntry) (void); /* 184 */
 } TkIntStubs;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
 extern TkIntStubs *tkIntStubsPtr;
+
 #ifdef __cplusplus
 }
 #endif
@@ -1846,6 +1860,13 @@ extern TkIntStubs *tkIntStubsPtr;
 #define TkSmoothPrintProc \
 	(tkIntStubsPtr->tkSmoothPrintProc) /* 180 */
 #endif
+/* Slot 181 is reserved */
+/* Slot 182 is reserved */
+/* Slot 183 is reserved */
+#ifndef TkUnusedStubEntry
+#define TkUnusedStubEntry \
+	(tkIntStubsPtr->tkUnusedStubEntry) /* 184 */
+#endif
 
 #endif /* defined(USE_TK_STUBS) && !defined(USE_TK_STUB_PROCS) */
 
@@ -1881,6 +1902,7 @@ extern TkIntStubs *tkIntStubsPtr;
 (Region) (src), (Region) (ret))
 #endif /* !__CYGWIN__*/
 
+#undef TkUnusedStubEntry
 #if defined(__CYGWIN__) && defined(USE_TK_STUBS) && !defined(USE_TK_STUB_PROCS)
 #   undef TkBindDeadWindow
 #   define TkBindDeadWindow(winPtr) /* Removed from Cygwins stub table, just do nothing */
diff --git a/generic/tkIntPlatDecls.h b/generic/tkIntPlatDecls.h
index a181073..9b800f3 100644
--- a/generic/tkIntPlatDecls.h
+++ b/generic/tkIntPlatDecls.h
@@ -26,6 +26,10 @@
 
 /* !BEGIN!: Do not edit below this line. */
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
  * Exported function declarations:
  */
@@ -731,10 +735,8 @@ typedef struct TkIntPlatStubs {
 #endif /* X11 */
 } TkIntPlatStubs;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
 extern TkIntPlatStubs *tkIntPlatStubsPtr;
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/generic/tkIntXlibDecls.h b/generic/tkIntXlibDecls.h
index 1357ceb..b978561 100644
--- a/generic/tkIntXlibDecls.h
+++ b/generic/tkIntXlibDecls.h
@@ -36,6 +36,10 @@ typedef int (*XAfterFunction) (	    /* WARNING, this type not in Xlib spec */
 
 /* !BEGIN!: Do not edit below this line. */
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
  * Exported function declarations:
  */
@@ -1453,10 +1457,8 @@ typedef struct TkIntXlibStubs {
 #endif /* AQUA */
 } TkIntXlibStubs;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
 extern TkIntXlibStubs *tkIntXlibStubsPtr;
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/generic/tkListbox.c b/generic/tkListbox.c
index d803d7b..248dd7b 100644
--- a/generic/tkListbox.c
+++ b/generic/tkListbox.c
@@ -1630,9 +1630,6 @@ ConfigureListbox(
 		if (Tcl_SetVar2Ex(interp, listPtr->listVarName, NULL,
 			listVarObj, TCL_GLOBAL_ONLY|TCL_LEAVE_ERR_MSG)
 			== NULL) {
-		    if (oldListObj == NULL) {
-			Tcl_DecrRefCount(listVarObj);
-		    }
 		    continue;
 		}
 	    }
diff --git a/generic/tkMain.c b/generic/tkMain.c
index 3be7189..00ac165 100644
--- a/generic/tkMain.c
+++ b/generic/tkMain.c
@@ -132,15 +132,18 @@ Tk_MainEx(
     Tcl_DString appName;
 
     /*
-     * Ensure that we are getting the matching version of Tcl. This is really
-     * only an issue when Tk is loaded dynamically.
+     * Ensure that we are getting a compatible version of Tcl.
      */
 
-    if (Tcl_InitStubs(interp, TCL_VERSION, 0) == NULL) {
-	abort();
+    if (Tcl_InitStubs(interp, "8.5.0", 0) == NULL) {
+	if (Tcl_InitStubs(interp, "8.1", 0) == NULL) {
+	    abort();
+	} else {
+	    Tcl_Panic("%s", Tcl_GetStringResult(interp));
+	}
     }
 
-#if defined(__WIN32__) && !defined(__WIN64__) && !defined(STATIC_BUILD)
+#if defined(__WIN32__) && !defined(STATIC_BUILD)
 
     if (tclStubsPtr->reserved9) {
 	/* We are running win32 Tk under Cygwin, so let's check
diff --git a/generic/tkMenu.c b/generic/tkMenu.c
index 064eaca..49b5935 100644
--- a/generic/tkMenu.c
+++ b/generic/tkMenu.c
@@ -1461,13 +1461,14 @@ DestroyMenuEntry(
 		}
 	    }
 	    UnhookCascadeEntry(mePtr);
+	    menuRefPtr = mePtr->childMenuRefPtr;
 	    if (menuRefPtr != NULL) {
 		if (menuRefPtr->menuPtr == destroyThis) {
 		    menuRefPtr->menuPtr = NULL;
 		}
-		if (destroyThis != NULL) {
-		    TkDestroyMenu(destroyThis);
-		}
+	    }
+	    if (destroyThis != NULL) {
+		TkDestroyMenu(destroyThis);
 	    }
 	} else {
 	    UnhookCascadeEntry(mePtr);
diff --git a/generic/tkObj.c b/generic/tkObj.c
index 7672240..f30742b 100644
--- a/generic/tkObj.c
+++ b/generic/tkObj.c
@@ -189,7 +189,7 @@ GetPixelsFromObjEx(
     int *intPtr,
     double *dblPtr)		/* Places to store resulting pixels. */
 {
-    int result,fresh;
+    int result, fresh;
     double d;
     PixelRep *pixelPtr;
     static double bias[] = {
@@ -204,16 +204,16 @@ GetPixelsFromObjEx(
      */
 
     if (objPtr->typePtr != &pixelObjType) {
-	ThreadSpecificData *tsdPtr = GetTypeCache();
+	ThreadSpecificData *typeCache = GetTypeCache();
 
-	if (objPtr->typePtr == tsdPtr->doubleTypePtr) {
+	if (objPtr->typePtr == typeCache->doubleTypePtr) {
 	    (void) Tcl_GetDoubleFromObj(interp, objPtr, &d);
 	    if (dblPtr != NULL) {
 		*dblPtr = d;
 	    }
 	    *intPtr = (int) (d<0 ? d-0.5 : d+0.5);
 	    return TCL_OK;
-	} else if (objPtr->typePtr == tsdPtr->intTypePtr) {
+	} else if (objPtr->typePtr == typeCache->intTypePtr) {
 	    (void) Tcl_GetIntFromObj(interp, objPtr, intPtr);
 	    if (dblPtr) {
 		*dblPtr = (double) (*intPtr);
@@ -223,14 +223,12 @@ GetPixelsFromObjEx(
     }
 
  retry:
-    if (objPtr->typePtr != &pixelObjType) {
+    fresh = (objPtr->typePtr != &pixelObjType);
+    if (fresh) {
 	result = SetPixelFromAny(interp, objPtr);
 	if (result != TCL_OK) {
 	    return result;
 	}
-	fresh = 1;
-    } else {
-	fresh = 0;
     }
 
     if (SIMPLE_PIXELREP(objPtr)) {
@@ -242,14 +240,14 @@ GetPixelsFromObjEx(
 	pixelPtr = GET_COMPLEXPIXEL(objPtr);
 	if ((!fresh) && (pixelPtr->tkwin != tkwin)) {
 	    /*
-	     * In case of exo-screen conversions of non-pixels we force a
+	     * In the case of exo-screen conversions of non-pixels, we force a
 	     * recomputation from the string.
 	     */
 
 	    FreePixelInternalRep(objPtr);
 	    goto retry;
 	}
-	if ((pixelPtr->tkwin != tkwin)||dblPtr) {
+	if ((pixelPtr->tkwin != tkwin) || dblPtr) {
 	    d = pixelPtr->value;
 	    if (pixelPtr->units >= 0) {
 		d *= bias[pixelPtr->units] * WidthOfScreen(Tk_Screen(tkwin));
@@ -294,7 +292,7 @@ Tk_GetPixelsFromObj(
     Tcl_Obj *objPtr,		/* The object from which to get pixels. */
     int *intPtr)		/* Place to store resulting pixels. */
 {
-    return GetPixelsFromObjEx(interp,tkwin,objPtr,intPtr,NULL);
+    return GetPixelsFromObjEx(interp, tkwin, objPtr, intPtr, NULL);
 }
 
 /*
@@ -326,7 +324,7 @@ Tk_GetDoublePixelsFromObj(
     double *doublePtr)		/* Place to store resulting pixels. */
 {
     double d;
-    int result,val;
+    int result, val;
 
     result = GetPixelsFromObjEx(interp, tkwin, objPtr, &val, &d);
     if (result != TCL_OK) {
@@ -448,7 +446,7 @@ SetPixelFromAny(
     double d;
     int i, units;
 
-    string = Tcl_GetStringFromObj(objPtr, NULL);
+    string = Tcl_GetString(objPtr);
 
     d = strtod(string, &rest);
     if (rest == string) {
@@ -561,7 +559,7 @@ Tk_GetMMFromObj(
 	}
     }
 
-    mmPtr = (MMRep *) objPtr->internalRep.otherValuePtr;
+    mmPtr = (MMRep *) objPtr->internalRep.twoPtrValue.ptr1;
     if (mmPtr->tkwin != tkwin) {
 	d = mmPtr->value;
 	if (mmPtr->units == -1) {
@@ -600,8 +598,8 @@ static void
 FreeMMInternalRep(
     Tcl_Obj *objPtr)		/* MM object with internal rep to free. */
 {
-    ckfree((char *) objPtr->internalRep.otherValuePtr);
-    objPtr->internalRep.otherValuePtr = NULL;
+    ckfree((char *) objPtr->internalRep.twoPtrValue.ptr1);
+    objPtr->internalRep.twoPtrValue.ptr1 = NULL;
     objPtr->typePtr = NULL;
 }
 
@@ -631,13 +629,13 @@ DupMMInternalRep(
     MMRep *oldPtr, *newPtr;
 
     copyPtr->typePtr = srcPtr->typePtr;
-    oldPtr = (MMRep *) srcPtr->internalRep.otherValuePtr;
+    oldPtr = (MMRep *) srcPtr->internalRep.twoPtrValue.ptr1;
     newPtr = (MMRep *) ckalloc(sizeof(MMRep));
     newPtr->value = oldPtr->value;
     newPtr->units = oldPtr->units;
     newPtr->tkwin = oldPtr->tkwin;
     newPtr->returnValue = oldPtr->returnValue;
-    copyPtr->internalRep.otherValuePtr = (VOID *) newPtr;
+    copyPtr->internalRep.twoPtrValue.ptr1 = (VOID *) newPtr;
 }
 
 /*
@@ -667,7 +665,7 @@ UpdateStringOfMM(
     char buffer[TCL_DOUBLE_SPACE];
     register int len;
 
-    mmPtr = (MMRep *) objPtr->internalRep.otherValuePtr;
+    mmPtr = (MMRep *) objPtr->internalRep.twoPtrValue.ptr1;
     /* assert( mmPtr->units == -1 && objPtr->bytes == NULL ); */
     if ((mmPtr->units != -1) || (objPtr->bytes != NULL)) {
 	Tcl_Panic("UpdateStringOfMM: false precondition");
@@ -705,17 +703,17 @@ SetMMFromAny(
     Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
     Tcl_Obj *objPtr)		/* The object to convert. */
 {
-    ThreadSpecificData *tsdPtr = GetTypeCache();
+    ThreadSpecificData *typeCache = GetTypeCache();
     const Tcl_ObjType *typePtr;
     char *string, *rest;
     double d;
     int units;
     MMRep *mmPtr;
 
-    if (objPtr->typePtr == tsdPtr->doubleTypePtr) {
+    if (objPtr->typePtr == typeCache->doubleTypePtr) {
 	Tcl_GetDoubleFromObj(interp, objPtr, &d);
 	units = -1;
-    } else if (objPtr->typePtr == tsdPtr->intTypePtr) {
+    } else if (objPtr->typePtr == typeCache->intTypePtr) {
 	Tcl_GetIntFromObj(interp, objPtr, &units);
 	d = (double) units;
 	units = -1;
@@ -726,13 +724,13 @@ SetMMFromAny(
 	 * ints again from mm obj types.
 	 */
 
-	(void) Tcl_GetStringFromObj(objPtr, NULL);
+	(void) Tcl_GetString(objPtr);
     } else {
 	/*
 	 * It wasn't a known int or double, so parse it.
 	 */
 
-	string = Tcl_GetStringFromObj(objPtr, NULL);
+	string = Tcl_GetString(objPtr);
 
 	d = strtod(string, &rest);
 	if (rest == string) {
@@ -780,15 +778,15 @@ SetMMFromAny(
 	(*typePtr->freeIntRepProc)(objPtr);
     }
 
-    objPtr->typePtr	= &mmObjType;
+    objPtr->typePtr = &mmObjType;
 
-    mmPtr		= (MMRep *) ckalloc(sizeof(MMRep));
-    mmPtr->value	= d;
-    mmPtr->units	= units;
-    mmPtr->tkwin	= NULL;
+    mmPtr = (MMRep *) ckalloc(sizeof(MMRep));
+    mmPtr->value = d;
+    mmPtr->units = units;
+    mmPtr->tkwin = NULL;
     mmPtr->returnValue	= d;
 
-    objPtr->internalRep.otherValuePtr = (VOID *) mmPtr;
+    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) mmPtr;
 
     return TCL_OK;
 }
@@ -821,7 +819,7 @@ TkGetWindowFromObj(
     Tcl_Obj *objPtr,		/* The object from which to get window. */
     Tk_Window *windowPtr)	/* Place to store resulting window. */
 {
-    TkMainInfo *mainPtr = ((TkWindow *)tkwin)->mainPtr;
+    TkMainInfo *mainPtr = ((TkWindow *) tkwin)->mainPtr;
     register WindowRep *winPtr;
     int result;
 
@@ -830,28 +828,28 @@ TkGetWindowFromObj(
 	return result;
     }
 
-    winPtr = (WindowRep *) objPtr->internalRep.otherValuePtr;
-    if (    winPtr->tkwin == NULL
-	 || winPtr->mainPtr == NULL
-	 || winPtr->mainPtr != mainPtr
-	 || winPtr->epoch != mainPtr->deletionEpoch)
+    winPtr = (WindowRep *) objPtr->internalRep.twoPtrValue.ptr1;
+    if (winPtr->tkwin == NULL
+	    || winPtr->mainPtr == NULL
+	    || winPtr->mainPtr != mainPtr
+	    || winPtr->epoch != mainPtr->deletionEpoch)
     {
 	/*
 	 * Cache is invalid.
 	 */
 
 	winPtr->tkwin = Tk_NameToWindow(interp,
-		Tcl_GetStringFromObj(objPtr, NULL), tkwin);
+		Tcl_GetString(objPtr), tkwin);
+	if (winPtr->tkwin == NULL) {
+	    /* ASSERT: Tk_NameToWindow has left error message in interp */
+	    return TCL_ERROR;
+	}
+
 	winPtr->mainPtr = mainPtr;
 	winPtr->epoch = mainPtr ? mainPtr->deletionEpoch : 0;
     }
 
     *windowPtr = winPtr->tkwin;
-
-    if (winPtr->tkwin == NULL) {
-	/* ASSERT: Tk_NameToWindow has left error message in interp */
-	return TCL_ERROR;
-    }
     return TCL_OK;
 }
 
@@ -887,7 +885,7 @@ SetWindowFromAny(
      * Free the old internalRep before setting the new one.
      */
 
-    Tcl_GetStringFromObj(objPtr, NULL);
+    (void)Tcl_GetString(objPtr);
     typePtr = objPtr->typePtr;
     if ((typePtr != NULL) && (typePtr->freeIntRepProc != NULL)) {
 	(*typePtr->freeIntRepProc)(objPtr);
@@ -898,7 +896,7 @@ SetWindowFromAny(
     winPtr->mainPtr = NULL;
     winPtr->epoch = 0;
 
-    objPtr->internalRep.otherValuePtr = (VOID*)winPtr;
+    objPtr->internalRep.twoPtrValue.ptr1 = (VOID*)winPtr;
     objPtr->typePtr = &windowObjType;
 
     return TCL_OK;
@@ -929,12 +927,12 @@ DupWindowInternalRep(
 {
     register WindowRep *oldPtr, *newPtr;
 
-    oldPtr = srcPtr->internalRep.otherValuePtr;
+    oldPtr = srcPtr->internalRep.twoPtrValue.ptr1;
     newPtr = (WindowRep *) ckalloc(sizeof(WindowRep));
     newPtr->tkwin = oldPtr->tkwin;
     newPtr->mainPtr = oldPtr->mainPtr;
     newPtr->epoch = oldPtr->epoch;
-    copyPtr->internalRep.otherValuePtr = (VOID *)newPtr;
+    copyPtr->internalRep.twoPtrValue.ptr1 = (VOID *)newPtr;
     copyPtr->typePtr = srcPtr->typePtr;
 }
 
@@ -960,13 +958,13 @@ static void
 FreeWindowInternalRep(
     Tcl_Obj *objPtr)		/* Window object with internal rep to free. */
 {
-    ckfree((char *) objPtr->internalRep.otherValuePtr);
-    objPtr->internalRep.otherValuePtr = NULL;
+    ckfree((char *) objPtr->internalRep.twoPtrValue.ptr1);
+    objPtr->internalRep.twoPtrValue.ptr1 = NULL;
     objPtr->typePtr = NULL;
 }
 
 /*
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  *
  * TkParsePadAmount --
  *
@@ -984,7 +982,7 @@ FreeWindowInternalRep(
  *	An error message is written to the interpreter if something is not
  *	right.
  *
- *--------------------------------------------------------------
+ *----------------------------------------------------------------------
  */
 
 int
diff --git a/generic/tkOption.c b/generic/tkOption.c
index de92627..91a6cc0 100644
--- a/generic/tkOption.c
+++ b/generic/tkOption.c
@@ -1019,14 +1019,25 @@ AddFromString(
 		Tcl_SetResult(interp, buf, TCL_VOLATILE);
 		return TCL_ERROR;
 	    }
-	    if ((src[0] == '\\') && (src[1] == '\n')) {
-		src += 2;
-		lineNum++;
-	    } else {
-		*dst = *src;
-		dst++;
-		src++;
+	    if (*src == '\\'){
+		if (src[1] == '\n') {
+		    src += 2;
+		    lineNum++;
+		    continue;
+		} else if (src[1] == 'n') {
+		    src += 2;
+		    *dst++ = '\n';
+		    continue;
+		} else if (src[1] == '\t' || src[1] == ' ' || src[1] == '\\') {
+		    ++src;
+		} else if (src[1] >= '0' && src[1] <= '3' && src[2] >= '0' &&
+			src[2] <= '9' && src[3] >= '0' && src[3] <= '9') {
+		    *dst++ = ((src[1]&7)<<6) | ((src[2]&7)<<3) | (src[3]&7);
+		    src += 4;
+		    continue;
+		}
 	    }
+	    *dst++ = *src++;
 	}
 	*dst = 0;
 
diff --git a/generic/tkPlatDecls.h b/generic/tkPlatDecls.h
index 549ae30..eb3d74d 100644
--- a/generic/tkPlatDecls.h
+++ b/generic/tkPlatDecls.h
@@ -25,6 +25,10 @@
 
 /* !BEGIN!: Do not edit below this line. */
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
  * Exported function declarations:
  */
@@ -154,10 +158,8 @@ typedef struct TkPlatStubs {
 #endif /* AQUA */
 } TkPlatStubs;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
 extern TkPlatStubs *tkPlatStubsPtr;
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/generic/tkScale.c b/generic/tkScale.c
index 28e5b16..69a7d91 100644
--- a/generic/tkScale.c
+++ b/generic/tkScale.c
@@ -808,6 +808,9 @@ ComputeFormat(
      */
 
     numDigits = scalePtr->digits;
+    if (numDigits > TCL_MAX_PREC) {
+	numDigits = 0;
+    }
     if (numDigits <= 0) {
 	if (scalePtr->resolution > 0) {
 	    /*
@@ -888,7 +891,7 @@ static void
 ComputeScaleGeometry(
     register TkScale *scalePtr)	/* Information about widget. */
 {
-    char valueString[PRINT_CHARS];
+    char valueString[TCL_DOUBLE_SPACE];
     int tmp, valuePixels, x, y, extraSpace;
     Tk_FontMetrics fm;
 
@@ -1304,7 +1307,7 @@ ScaleSetVariable(
     register TkScale *scalePtr)	/* Info about widget. */
 {
     if (scalePtr->varNamePtr != NULL) {
-	char string[PRINT_CHARS];
+	char string[TCL_DOUBLE_SPACE];
 
 	sprintf(string, scalePtr->format, scalePtr->value);
 	scalePtr->flags |= SETTING_VAR;
diff --git a/generic/tkScale.h b/generic/tkScale.h
index f406bf6..a2c5f2b 100644
--- a/generic/tkScale.h
+++ b/generic/tkScale.h
@@ -220,12 +220,6 @@ typedef struct TkScale {
 #define SPACING 2
 
 /*
- * How many characters of space to provide when formatting the scale's value:
- */
-
-#define PRINT_CHARS 150
-
-/*
  * Declaration of procedures used in the implementation of the scale widget.
  */
 
diff --git a/generic/tkStubInit.c b/generic/tkStubInit.c
index c2ef290..79edc4d 100644
--- a/generic/tkStubInit.c
+++ b/generic/tkStubInit.c
@@ -30,6 +30,8 @@
 #include "tkPlatDecls.h"
 #include "tkIntXlibDecls.h"
 
+#define TkUnusedStubEntry NULL
+
 #ifdef __WIN32__
 
 static int
@@ -476,6 +478,10 @@ TkIntStubs tkIntStubs = {
     TkOrientPrintProc, /* 178 */
     TkSmoothParseProc, /* 179 */
     TkSmoothPrintProc, /* 180 */
+    NULL, /* 181 */
+    NULL, /* 182 */
+    NULL, /* 183 */
+    TkUnusedStubEntry, /* 184 */
 };
 
 TkIntPlatStubs tkIntPlatStubs = {
@@ -1130,6 +1136,8 @@ TkStubs tkStubs = {
     Tk_Interp, /* 271 */
     Tk_CreateOldImageType, /* 272 */
     Tk_CreateOldPhotoImageFormat, /* 273 */
+    NULL, /* 274 */
+    TkUnusedStubEntry, /* 275 */
 };
 
 /* !END!: Do not edit above this line. */
diff --git a/generic/tkStubLib.c b/generic/tkStubLib.c
index 5349a0b..f605b5d 100644
--- a/generic/tkStubLib.c
+++ b/generic/tkStubLib.c
@@ -1,33 +1,16 @@
 /*
  * tkStubLib.c --
  *
- *	Stub object that will be statically linked into extensions that wish
+ *	Stub object that will be statically linked into extensions that want
  *	to access Tk.
  *
- * Copyright (c) 1998 Paul Duffin.
  * Copyright (c) 1998-1999 by Scriptics Corporation.
+ * Copyright (c) 1998 Paul Duffin.
  *
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  */
 
-/*
- * We need to ensure that we use the stub macros so that this file contains no
- * references to any of the stub functions. This will make it possible to
- * build an extension that references Tk_InitStubs but doesn't end up
- * including the rest of the stub functions.
- */
-
-#ifndef USE_TCL_STUBS
-#define USE_TCL_STUBS
-#endif
-#undef USE_TCL_STUB_PROCS
-
-#ifndef USE_TK_STUBS
-#define USE_TK_STUBS
-#endif
-#undef USE_TK_STUB_PROCS
-
 #include "tkInt.h"
 
 #ifdef __WIN32__
@@ -56,7 +39,8 @@ TkIntXlibStubs *tkIntXlibStubsPtr = NULL;
  * Use our own isdigit to avoid linking to libc on windows
  */
 
-static int isDigit(const int c)
+static int
+isDigit(const int c)
 {
     return (c >= '0' && c <= '9');
 }
@@ -78,66 +62,73 @@ static int isDigit(const int c)
  *
  *----------------------------------------------------------------------
  */
-
-#ifdef Tk_InitStubs
 #undef Tk_InitStubs
-#endif
-
 CONST char *
 Tk_InitStubs(
     Tcl_Interp *interp,
     CONST char *version,
     int exact)
 {
-    CONST char *actualVersion;
-    TkStubs **stubsPtrPtr = &tkStubsPtr;	/* squelch warning */
-
-    actualVersion = Tcl_PkgRequireEx(interp, "Tk", version, 0,
-	    (ClientData *) stubsPtrPtr);
-    if (!actualVersion) {
+    const char *packageName = "Tk";
+    const char *errMsg = NULL;
+    ClientData clientData = NULL;
+    CONST char *actualVersion = tclStubsPtr->tcl_PkgRequireEx(interp,
+	    packageName, version, 0, &clientData);
+    TkStubs *stubsPtr = (TkStubs *)clientData;
+
+    if (actualVersion == NULL) {
 	return NULL;
     }
+
     if (exact) {
-        CONST char *p = version;
-        int count = 0;
+	CONST char *p = version;
+	int count = 0;
 
-        while (*p) {
-            count += !isDigit(*p++);
-        }
-        if (count == 1) {
+	while (*p) {
+	    count += !isDigit(*p++);
+	}
+	if (count == 1) {
 	    CONST char *q = actualVersion;
 
 	    p = version;
 	    while (*p && (*p == *q)) {
 		p++; q++;
 	    }
-            if (*p) {
+	    if (*p || isDigit(*q)) {
 		/* Construct error message */
-		Tcl_PkgRequireEx(interp, "Tk", version, 1, NULL);
-                return NULL;
-
-            }
-        } else {
-            actualVersion = Tcl_PkgRequireEx(interp, "Tk", version, 1, NULL);
-            if (actualVersion == NULL) {
-                return NULL;
-            }
-        }
+		tclStubsPtr->tcl_PkgRequireEx(interp, "Tk", version, 1, NULL);
+		return NULL;
+	    }
+	} else {
+	    actualVersion = tclStubsPtr->tcl_PkgRequireEx(interp, "Tk",
+		    version, 1, NULL);
+	    if (actualVersion == NULL) {
+		return NULL;
+	    }
+	}
     }
-
-    if (!tkStubsPtr) {
-	Tcl_SetResult(interp,
-		"This implementation of Tk does not support stubs",
-		TCL_STATIC);
-	return NULL;
+    if (stubsPtr == NULL) {
+	errMsg = "missing stub table pointer";
+    } else {
+	tkStubsPtr = stubsPtr;
+	if (stubsPtr->hooks) {
+	    tkPlatStubsPtr = stubsPtr->hooks->tkPlatStubs;
+	    tkIntStubsPtr = stubsPtr->hooks->tkIntStubs;
+	    tkIntPlatStubsPtr = stubsPtr->hooks->tkIntPlatStubs;
+	    tkIntXlibStubsPtr = stubsPtr->hooks->tkIntXlibStubs;
+	} else {
+	    tkPlatStubsPtr = NULL;
+	    tkIntStubsPtr = NULL;
+	    tkIntPlatStubsPtr = NULL;
+	    tkIntXlibStubsPtr = NULL;
+	}
+	return actualVersion;
     }
-
-    tkPlatStubsPtr = tkStubsPtr->hooks->tkPlatStubs;
-    tkIntStubsPtr = tkStubsPtr->hooks->tkIntStubs;
-    tkIntPlatStubsPtr = tkStubsPtr->hooks->tkIntPlatStubs;
-    tkIntXlibStubsPtr = tkStubsPtr->hooks->tkIntXlibStubs;
-
-    return actualVersion;
+    tclStubsPtr->tcl_ResetResult(interp);
+    tclStubsPtr->tcl_AppendResult(interp, "Error loading ", packageName,
+	    " (requested version ", version, ", actual version ",
+	    actualVersion, "): ", errMsg, NULL);
+    return NULL;
 }
 
 /*
diff --git a/generic/tkStyle.c b/generic/tkStyle.c
index dd3b2e8..c2eed8f 100644
--- a/generic/tkStyle.c
+++ b/generic/tkStyle.c
@@ -62,7 +62,7 @@ typedef struct StyleEngine {
     StyledElement *elements;	/* Table of widget element descriptors. Each
 				 * element is indexed by a unique system-wide
 				 * ID. Table grows dynamically as new elements
-				 * are registered. Malloc'd*/
+				 * are registered. Malloc'd. */
     struct StyleEngine *parentPtr;
 				/* Parent engine. Engines may be layered to
 				 * form a fallback chain, terminated by the
@@ -146,7 +146,7 @@ static int		SetStyleFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr);
 
 /*
  * The following structure defines the implementation of the "style" Tcl
- * object, used for drawing. The internalRep.otherValuePtr field of each style
+ * object, used for drawing. The internalRep.twoPtrValue.ptr1 field of each style
  * object points to the Style structure for the stylefont, or NULL.
  */
 
@@ -375,14 +375,12 @@ InitStyleEngine(
 	 */
 
 	enginePtr->parentPtr = NULL;
-
     } else if (parentPtr == NULL) {
 	/*
 	 * The default style engine is the parent.
 	 */
 
 	enginePtr->parentPtr = tsdPtr->defaultEnginePtr;
-
     } else {
 	enginePtr->parentPtr = parentPtr;
     }
@@ -602,17 +600,16 @@ FreeStyledElement(
 
 static int
 CreateElement(
-    const char *name,	/* Name of the element. */
-    int create)		/* Boolean, whether the element is being created
-			 * explicitly (being registered) or implicitly (by a
-			 * derived element). */
+    const char *name,		/* Name of the element. */
+    int create)			/* Boolean, whether the element is being
+				 * created explicitly (being registered) or
+				 * implicitly (by a derived element). */
 {
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *)
 	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
     Tcl_HashEntry *entryPtr, *engineEntryPtr;
     Tcl_HashSearch search;
-    int newEntry;
-    int elementId, genericId = -1;
+    int newEntry, elementId, genericId = -1;
     char *dot;
     StyleEngine *enginePtr;
 
@@ -1261,8 +1258,7 @@ Tk_CreateStyle(
 
     stylePtr = (Style *) ckalloc(sizeof(Style));
     InitStyle(stylePtr, Tcl_GetHashKey(&tsdPtr->styleTable, entryPtr),
-	    (engine != NULL ? (StyleEngine *) engine :
-		    tsdPtr->defaultEnginePtr),
+	    (engine!=NULL ? (StyleEngine *) engine : tsdPtr->defaultEnginePtr),
 	    clientData);
     Tcl_SetHashValue(entryPtr, (ClientData) stylePtr);
 
@@ -1415,10 +1411,8 @@ Tk_AllocStyleFromObj(
 
     if (objPtr->typePtr != &styleObjType) {
 	SetStyleFromAny(interp, objPtr);
-	stylePtr = (Style *) objPtr->internalRep.otherValuePtr;
-    } else {
-	stylePtr = (Style *) objPtr->internalRep.otherValuePtr;
     }
+    stylePtr = (Style *) objPtr->internalRep.twoPtrValue.ptr1;
 
     return (Tk_Style) stylePtr;
 }
@@ -1450,7 +1444,7 @@ Tk_GetStyleFromObj(
 	SetStyleFromAny(NULL, objPtr);
     }
 
-    return (Tk_Style) objPtr->internalRep.otherValuePtr;
+    return (Tk_Style) objPtr->internalRep.twoPtrValue.ptr1;
 }
 
 /*
@@ -1505,7 +1499,7 @@ SetStyleFromAny(
     }
 
     objPtr->typePtr = &styleObjType;
-    objPtr->internalRep.otherValuePtr = (VOID *) Tk_GetStyle(interp, name);
+    objPtr->internalRep.twoPtrValue.ptr1 = (VOID *) Tk_GetStyle(interp, name);
 
     return TCL_OK;
 }
@@ -1528,7 +1522,7 @@ static void
 FreeStyleObjProc(
     Tcl_Obj *objPtr)		/* The object we are releasing. */
 {
-    objPtr->internalRep.otherValuePtr = NULL;
+    objPtr->internalRep.twoPtrValue.ptr1 = NULL;
     objPtr->typePtr = NULL;
 }
 
@@ -1549,7 +1543,8 @@ DupStyleObjProc(
     Tcl_Obj *dupObjPtr)		/* The object we are copying to. */
 {
     dupObjPtr->typePtr = srcObjPtr->typePtr;
-    dupObjPtr->internalRep.otherValuePtr=srcObjPtr->internalRep.otherValuePtr;
+    dupObjPtr->internalRep.twoPtrValue.ptr1 =
+	    srcObjPtr->internalRep.twoPtrValue.ptr1;
 }
 
 /*
diff --git a/generic/tkTest.c b/generic/tkTest.c
index 307ca34..d06769d 100644
--- a/generic/tkTest.c
+++ b/generic/tkTest.c
@@ -164,7 +164,7 @@ static int		TestfontObjCmd(ClientData dummy,
 			    Tcl_Obj *const objv[]);
 static int		TestmakeexistCmd(ClientData dummy,
 			    Tcl_Interp *interp, int argc, const char **argv);
-#if !(defined(__WIN32__) || defined(MAC_OSX_TK))
+#if !(defined(__WIN32__) || defined(MAC_OSX_TK) || defined(__CYGWIN__))
 static int		TestmenubarCmd(ClientData dummy,
 			    Tcl_Interp *interp, int argc, const char **argv);
 #endif
@@ -190,7 +190,7 @@ static void		CustomOptionFree(ClientData clientData,
 			    Tk_Window tkwin, char *internalPtr);
 static int		TestpropCmd(ClientData dummy,
 			    Tcl_Interp *interp, int argc, const char **argv);
-#if !(defined(__WIN32__) || defined(MAC_OSX_TK))
+#if !(defined(__WIN32__) || defined(MAC_OSX_TK) || defined(__CYGWIN__))
 static int		TestwrapperCmd(ClientData dummy,
 			    Tcl_Interp *interp, int argc, const char **argv);
 #endif
@@ -277,7 +277,7 @@ Tktest_Init(
 #if defined(__WIN32__) || defined(MAC_OSX_TK)
     Tcl_CreateCommand(interp, "testmetrics", TestmetricsCmd,
 	    (ClientData) Tk_MainWindow(interp), NULL);
-#else
+#elif !defined(__CYGWIN__)
     Tcl_CreateCommand(interp, "testmenubar", TestmenubarCmd,
 	    (ClientData) Tk_MainWindow(interp), NULL);
     Tcl_CreateCommand(interp, "testsend", TkpTestsendCmd,
@@ -400,7 +400,7 @@ CBindingEvalProc(
 
     cbindPtr = (CBinding *) clientData;
 
-    return Tcl_GlobalEval(interp, cbindPtr->command);
+    return Tcl_EvalEx(interp, cbindPtr->command, -1, TCL_EVAL_GLOBAL);
 }
 
 static void
@@ -410,7 +410,7 @@ CBindingFreeProc(
     CBinding *cbindPtr = (CBinding *) clientData;
 
     if (cbindPtr->delete != NULL) {
-	Tcl_GlobalEval(cbindPtr->interp, cbindPtr->delete);
+	Tcl_EvalEx(cbindPtr->interp, cbindPtr->delete, -1, TCL_EVAL_GLOBAL);
 	ckfree((char *) cbindPtr->delete);
     }
     ckfree((char *) cbindPtr->command);
@@ -1813,7 +1813,7 @@ TestmakeexistCmd(
  */
 
 	/* ARGSUSED */
-#if !(defined(__WIN32__) || defined(MAC_OSX_TK))
+#if !(defined(__WIN32__) || defined(MAC_OSX_TK) || defined(__CYGWIN__))
 static int
 TestmenubarCmd(
     ClientData clientData,	/* Main window for application. */
@@ -2016,7 +2016,7 @@ TestpropCmd(
     return TCL_OK;
 }
 
-#if !(defined(__WIN32__) || defined(MAC_OSX_TK))
+#if !(defined(__WIN32__) || defined(MAC_OSX_TK) || defined(__CYGWIN__))
 /*
  *----------------------------------------------------------------------
  *
diff --git a/generic/tkTextDisp.c b/generic/tkTextDisp.c
index 2516e1c..cd232bf 100644
--- a/generic/tkTextDisp.c
+++ b/generic/tkTextDisp.c
@@ -3968,6 +3968,16 @@ DisplayText(
     UpdateDisplayInfo(textPtr);
     dInfoPtr->dLinesInvalidated = 0;
 
+#ifdef MAC_OSX_TK
+    /*
+     * Make sure that unmapped subwindows really have been unmapped.
+     * If the unmap request is pending as an idle request, the window
+     * can get redrawn on top of the widget.
+     */
+     while (Tcl_DoOneEvent(TCL_IDLE_EVENTS|TCL_DONT_WAIT)) {}
+#endif
+
+
     /*
      * See if it's possible to bring some parts of the screen up-to-date by
      * scrolling (copying from other parts of the screen). We have to be
diff --git a/generic/tkTextImage.c b/generic/tkTextImage.c
index 771347d..bc2b7c4 100644
--- a/generic/tkTextImage.c
+++ b/generic/tkTextImage.c
@@ -779,6 +779,10 @@ TkTextImageIndex(
     Tcl_HashEntry *hPtr;
     TkTextSegment *eiPtr;
 
+    if (textPtr == NULL) {
+	return 0;
+    }
+
     hPtr = Tcl_FindHashEntry(&textPtr->sharedTextPtr->imageTable, name);
     if (hPtr == NULL) {
 	return 0;
diff --git a/generic/tkTextIndex.c b/generic/tkTextIndex.c
index a9b0bed..70c94db 100644
--- a/generic/tkTextIndex.c
+++ b/generic/tkTextIndex.c
@@ -758,9 +758,11 @@ GetIndex(
 
     /*
      *---------------------------------------------------------------------
-     * Stage 1: check to see if the index consists of nothing but a mark name.
-     * We do this check now even though it's also done later, in order to
-     * allow mark names that include funny characters such as spaces or "+1c".
+     * Stage 1: check to see if the index consists of nothing but a mark
+     * name, an embedded window or an embedded image.  We do this check
+     * now even though it's also done later, in order to allow mark names,
+     * embedded window names or image names that include funny characters
+     * such as spaces or "+1c".
      *---------------------------------------------------------------------
      */
 
@@ -768,6 +770,14 @@ GetIndex(
 	goto done;
     }
 
+    if (TkTextWindowIndex(textPtr, string, indexPtr) != 0) {
+	return TCL_OK;
+    }
+
+    if (TkTextImageIndex(textPtr, string, indexPtr) != 0) {
+	return TCL_OK;
+    }
+
     /*
      *------------------------------------------------
      * Stage 2: start again by parsing the base index.
diff --git a/generic/tkTextTag.c b/generic/tkTextTag.c
index 5162e16..dad03bf 100644
--- a/generic/tkTextTag.c
+++ b/generic/tkTextTag.c
@@ -169,6 +169,14 @@ TkTextTagCmd(
 	    return TCL_ERROR;
 	}
 	tagPtr = TkTextCreateTag(textPtr, Tcl_GetString(objv[3]), NULL);
+	if (tagPtr->elide) {
+		/*
+		* Indices are potentially obsolete after adding or removing
+		* elided character ranges, especially indices having "display"
+		* or "any" submodifier, therefore increase the epoch.
+		*/
+		textPtr->sharedTextPtr->stateEpoch++;
+	}
 	for (i = 4; i < objc; i += 2) {
 	    if (TkTextGetObjIndex(interp, textPtr, objv[i],
 		    &index1) != TCL_OK) {
diff --git a/generic/tkTextWind.c b/generic/tkTextWind.c
index ecafd4e..8d1f850 100644
--- a/generic/tkTextWind.c
+++ b/generic/tkTextWind.c
@@ -902,10 +902,10 @@ EmbWinLayoutProc(
 
 	if (dsPtr != NULL) {
 	    Tcl_DStringAppend(dsPtr, before, (int) (string-before));
-	    code = Tcl_GlobalEval(textPtr->interp, Tcl_DStringValue(dsPtr));
+	    code = Tcl_EvalEx(textPtr->interp, Tcl_DStringValue(dsPtr), -1, TCL_EVAL_GLOBAL);
 	    Tcl_DStringFree(dsPtr);
 	} else {
-	    code = Tcl_GlobalEval(textPtr->interp, ewPtr->body.ew.create);
+	    code = Tcl_EvalEx(textPtr->interp, ewPtr->body.ew.create, -1, TCL_EVAL_GLOBAL);
 	}
 	if (code != TCL_OK) {
 	createError:
@@ -1329,6 +1329,10 @@ TkTextWindowIndex(
     Tcl_HashEntry *hPtr;
     TkTextSegment *ewPtr;
 
+    if (textPtr == NULL) {
+	return 0;
+    }
+
     hPtr = Tcl_FindHashEntry(&textPtr->sharedTextPtr->windowTable, name);
     if (hPtr == NULL) {
 	return 0;
diff --git a/generic/tkUtil.c b/generic/tkUtil.c
index 2a8240b..bfa5d5c 100644
--- a/generic/tkUtil.c
+++ b/generic/tkUtil.c
@@ -976,89 +976,6 @@ TkFindStateNumObj(
 }
 
 /*
- * ----------------------------------------------------------------------
- *
- * TkBackgroundEvalObjv --
- *
- *	Evaluate a command while ensuring that we do not affect the
- *	interpreters state. This is important when evaluating script
- *	during background tasks.
- *
- * Results:
- *	A standard Tcl result code.
- *
- * Side Effects:
- *	The interpreters variables and code may be modified by the script
- *	but the result will not be modified.
- *
- * ----------------------------------------------------------------------
- */
-
-int
-TkBackgroundEvalObjv(
-    Tcl_Interp *interp,
-    int objc,
-    Tcl_Obj *const *objv,
-    int flags)
-{
-    Tcl_DString errorInfo, errorCode;
-    Tcl_SavedResult state;
-    int n, r = TCL_OK;
-
-    Tcl_DStringInit(&errorInfo);
-    Tcl_DStringInit(&errorCode);
-
-    Tcl_Preserve(interp);
-
-    /*
-     * Record the state of the interpreter
-     */
-
-    Tcl_SaveResult(interp, &state);
-    Tcl_DStringAppend(&errorInfo,
-	Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY), -1);
-    Tcl_DStringAppend(&errorCode,
-	Tcl_GetVar(interp, "errorCode", TCL_GLOBAL_ONLY), -1);
-
-    /*
-     * Evaluate the command and handle any error.
-     */
-
-    for (n = 0; n < objc; ++n) {
-	Tcl_IncrRefCount(objv[n]);
-    }
-    r = Tcl_EvalObjv(interp, objc, objv, flags);
-    for (n = 0; n < objc; ++n) {
-	Tcl_DecrRefCount(objv[n]);
-    }
-    if (r == TCL_ERROR) {
-        Tcl_AddErrorInfo(interp, "\n    (background event handler)");
-        Tcl_BackgroundError(interp);
-    }
-
-    Tcl_Release(interp);
-
-    /*
-     * Restore the state of the interpreter
-     */
-
-    Tcl_SetVar(interp, "errorInfo",
-	Tcl_DStringValue(&errorInfo), TCL_GLOBAL_ONLY);
-    Tcl_SetVar(interp, "errorCode",
-	Tcl_DStringValue(&errorCode), TCL_GLOBAL_ONLY);
-    Tcl_RestoreResult(interp, &state);
-
-    /*
-     * Clean up references.
-     */
-
-    Tcl_DStringFree(&errorInfo);
-    Tcl_DStringFree(&errorCode);
-
-    return r;
-}
-
-/*
  * Local Variables:
  * mode: c
  * c-basic-offset: 4
diff --git a/generic/tkWindow.c b/generic/tkWindow.c
index 995f71f..f2e98e8 100644
--- a/generic/tkWindow.c
+++ b/generic/tkWindow.c
@@ -2831,7 +2831,7 @@ DeleteWindowsExitProc(
     tsdPtr->initialized = 0;
 }
 
-#if defined(__WIN32__) && !defined(__WIN64__)
+#if defined(__WIN32__)
 
 static HMODULE tkcygwindll = NULL;
 
@@ -2903,7 +2903,7 @@ int
 Tk_Init(
     Tcl_Interp *interp)		/* Interpreter to initialize. */
 {
-#if defined(__WIN32__) && !defined(__WIN64__)
+#if defined(__WIN32__)
     if (tkcygwindll) {
 	int (*sym)(Tcl_Interp *);
 
@@ -2976,7 +2976,7 @@ Tk_SafeInit(
      * checked at several places to differentiate the two initialisations.
      */
 
-#if defined(__WIN32__) && !defined(__WIN64__)
+#if defined(__WIN32__)
     if (tkcygwindll) {
 	int (*sym)(Tcl_Interp *);
 
@@ -3021,11 +3021,10 @@ Initialize(
     ThreadSpecificData *tsdPtr;
 
     /*
-     * Ensure that we are getting the matching version of Tcl. This is really
-     * only an issue when Tk is loaded dynamically.
+     * Ensure that we are getting a compatible version of Tcl.
      */
 
-    if (Tcl_InitStubs(interp, TCL_VERSION, 0) == NULL) {
+    if (Tcl_InitStubs(interp, "8.5.0", 0) == NULL) {
 	return TCL_ERROR;
     }
 
@@ -3257,11 +3256,6 @@ Initialize(
 	geometry = NULL;
     }
 
-    if (Tcl_PkgRequire(interp, "Tcl", TCL_VERSION, 0) == NULL) {
-	code = TCL_ERROR;
-	goto done;
-    }
-
     /*
      * Provide Tk and its stub table.
      */
@@ -3281,9 +3275,11 @@ Initialize(
 
     Tcl_SetMainLoop(Tk_MainLoop);
 
-#undef Tk_InitStubs
-
+#ifndef _WIN32
+    /* On Windows, this has no added value. */
+#   undef Tk_InitStubs
     Tk_InitStubs(interp, TK_VERSION, 1);
+#endif
 
     /*
      * Initialized the themed widget set
diff --git a/generic/ttk/ttkDecls.h b/generic/ttk/ttkDecls.h
index ee679b7..8473d36 100644
--- a/generic/ttk/ttkDecls.h
+++ b/generic/ttk/ttkDecls.h
@@ -23,6 +23,10 @@ extern const char *TtkInitializeStubs(
 #define TTK_STUBS_EPOCH 0
 #define TTK_STUBS_REVISION 31
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
  * Exported function declarations:
  */
@@ -178,10 +182,8 @@ typedef struct TtkStubs {
     int (*ttk_GetOrientFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int *orient); /* 40 */
 } TtkStubs;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
 extern const TtkStubs *ttkStubsPtr;
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/generic/ttk/ttkEntry.c b/generic/ttk/ttkEntry.c
index 5c280e4..ae43ae6 100644
--- a/generic/ttk/ttkEntry.c
+++ b/generic/ttk/ttkEntry.c
@@ -1642,6 +1642,14 @@ static int EntryXViewCommand(
     void *recordPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 {
     Entry *entryPtr = recordPtr;
+    if (objc == 3) {
+	int newFirst;
+	if (EntryIndex(interp, entryPtr, objv[2], &newFirst) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	TtkScrollTo(entryPtr->entry.xscrollHandle, newFirst);
+	return TCL_OK;
+    }
     return TtkScrollviewCommand(interp, objc, objv, entryPtr->entry.xscrollHandle);
 }
 
diff --git a/generic/ttk/ttkGenStubs.tcl b/generic/ttk/ttkGenStubs.tcl
index 90dea25..3c8eb19 100644
--- a/generic/ttk/ttkGenStubs.tcl
+++ b/generic/ttk/ttkGenStubs.tcl
@@ -187,7 +187,6 @@ proc genStubs::declare {args} {
     variable revision
 
     incr revision
-
     if {[llength $args] == 2} {
 	lassign $args index decl
 	set status current
@@ -214,7 +213,25 @@ proc genStubs::declare {args} {
     if {$index > $stubs($curName,lastNum)} {
 	set stubs($curName,lastNum) $index
     }
+    return
+}
+
+# genStubs::export --
+#
+#	This function is used in the declarations file to declare a symbol
+#	that is exported from the library but is not in the stubs table.
+#
+# Arguments:
+#	decl		The C function declaration, or {} for an undefined
+#			entry.
+#
+# Results:
+#	None.
 
+proc genStubs::export {args} {
+    if {[llength $args] != 1} {
+	puts stderr "wrong # args: export $args"
+    }
     return
 }
 
@@ -410,7 +427,6 @@ proc genStubs::parseArg {arg} {
 
 proc genStubs::makeDecl {name decl index} {
     variable scspec
-
     lassign $decl rtype fname args
 
     append text "/* $index */\n"
@@ -731,6 +747,8 @@ proc genStubs::emitHeader {name} {
     append text "#define ${CAPName}_STUBS_EPOCH $epoch\n"
     append text "#define ${CAPName}_STUBS_REVISION $revision\n"
 
+    append text "\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n"
+
     emitDeclarations $name text
 
     if {[info exists hooks($name)]} {
@@ -752,8 +770,7 @@ proc genStubs::emitHeader {name} {
 
     append text "} ${capName}Stubs;\n\n"
 
-    append text "#ifdef __cplusplus\nextern \"C\" {\n#endif\n"
-    append text "extern const ${capName}Stubs *${name}StubsPtr;\n"
+    append text "extern const ${capName}Stubs *${name}StubsPtr;\n\n"
     append text "#ifdef __cplusplus\n}\n#endif\n"
 
     emitMacros $name text
@@ -778,10 +795,9 @@ proc genStubs::emitInit {name textVar} {
     variable interfaces
     variable epoch
     variable revision
-
     upvar $textVar text
-    set root 1
 
+    set root 1
     set capName [string toupper [string index $name 0]]
     append capName [string range $name 1 end]
     set CAPName [string toupper $name]
diff --git a/generic/ttk/ttkLabel.c b/generic/ttk/ttkLabel.c
index 597682f..d51388b 100644
--- a/generic/ttk/ttkLabel.c
+++ b/generic/ttk/ttkLabel.c
@@ -347,6 +347,8 @@ static void ImageDraw(
      * Do not stipple at all under Aqua, just draw the image: it shows up 
      * as a white rectangle otherwise.
      */
+
+    
     if (state & TTK_STATE_DISABLED) {
 	if (TtkSelectImage(image->imageSpec, 0ul) == image->tkimg) {
 #ifndef MAC_OSX_TK
@@ -484,6 +486,7 @@ static Ttk_ElementOptionSpec LabelElementOptions[] = {
  * 	Calculate the text, image, and total width and height.
  */
 
+#undef  MAX
 #define MAX(a,b) ((a) > (b) ? a : b);
 static void LabelSetup(
     LabelElement *c, Tk_Window tkwin, Ttk_State state)
diff --git a/generic/ttk/ttkManager.c b/generic/ttk/ttkManager.c
index ba9e5c0..2fcb190 100644
--- a/generic/ttk/ttkManager.c
+++ b/generic/ttk/ttkManager.c
@@ -237,7 +237,7 @@ void Ttk_DeleteManager(Ttk_Manager *mgr)
 	ckfree((ClientData)mgr->slaves);
     }
 
-    Tk_CancelIdleCall(ManagerIdleProc, mgr);
+    Tcl_CancelIdleCall(ManagerIdleProc, mgr);
 
     ckfree((ClientData)mgr);
 }
diff --git a/generic/ttk/ttkScroll.c b/generic/ttk/ttkScroll.c
index defe05a..fc305e9 100644
--- a/generic/ttk/ttkScroll.c
+++ b/generic/ttk/ttkScroll.c
@@ -34,7 +34,7 @@
  * TtkScrollbarUpdateRequired, which will invoke step (5) (@@@ Fix this)
  */
 
-#include <tk.h>
+#include <tkInt.h>
 #include "ttkTheme.h"
 #include "ttkWidget.h"
 
@@ -78,6 +78,7 @@ static int UpdateScrollbar(Tcl_Interp *interp, ScrollHandle h)
     char arg1[TCL_DOUBLE_SPACE + 2];
     char arg2[TCL_DOUBLE_SPACE + 2];
     int code;
+    Tcl_DString buf;
 
     h->flags &= ~SCROLL_UPDATE_REQUIRED;
 
@@ -88,9 +89,14 @@ static int UpdateScrollbar(Tcl_Interp *interp, ScrollHandle h)
     arg1[0] = arg2[0] = ' ';
     Tcl_PrintDouble(interp, (double)s->first / s->total, arg1+1);
     Tcl_PrintDouble(interp, (double)s->last / s->total, arg2+1);
+    Tcl_DStringInit(&buf);
+    Tcl_DStringAppend(&buf, s->scrollCmd, -1);
+    Tcl_DStringAppend(&buf, arg1, -1);
+    Tcl_DStringAppend(&buf, arg2, -1);
 
     Tcl_Preserve(corePtr);
-    code = Tcl_VarEval(interp, s->scrollCmd, arg1, arg2, NULL);
+    code = Tcl_EvalEx(interp, Tcl_DStringValue(&buf), -1, TCL_EVAL_GLOBAL);
+    Tcl_DStringFree(&buf);
     if (WidgetDestroyed(corePtr)) {
 	Tcl_Release(corePtr);
 	return TCL_ERROR;
diff --git a/generic/ttk/ttkTheme.c b/generic/ttk/ttkTheme.c
index 5095487..a2c51c0 100644
--- a/generic/ttk/ttkTheme.c
+++ b/generic/ttk/ttkTheme.c
@@ -509,7 +509,7 @@ static void ThemeChangedProc(ClientData clientData)
     static char ThemeChangedScript[] = "ttk::ThemeChanged";
     StylePackageData *pkgPtr = clientData;
 
-    if (Tcl_GlobalEval(pkgPtr->interp, ThemeChangedScript) != TCL_OK) {
+    if (Tcl_EvalEx(pkgPtr->interp, ThemeChangedScript, -1, TCL_EVAL_GLOBAL) != TCL_OK) {
 	Tcl_BackgroundError(pkgPtr->interp);
     }
     pkgPtr->themeChangePending = 0;
diff --git a/generic/ttk/ttkTreeview.c b/generic/ttk/ttkTreeview.c
index 862c7f6..f0a3003 100644
--- a/generic/ttk/ttkTreeview.c
+++ b/generic/ttk/ttkTreeview.c
@@ -3169,6 +3169,8 @@ static int TreeviewTagAddCommand(
 	AddTag(items[i], tag);
     }
 
+    TtkRedisplayWidget(&tv->core);
+
     return TCL_OK;
 }
 
@@ -3213,6 +3215,9 @@ static int TreeviewTagRemoveCommand(
 	    item=NextPreorder(item);
 	}
     }
+
+    TtkRedisplayWidget(&tv->core);
+
     return TCL_OK;
 }