merge updates from HEAD

13 files changed, 3420 insertions, 1957 deletions

diff --git a/ChangeLog b/ChangeLog
index 57cc772..0eb8617 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,58 @@
+2007-11-24  Donal K. Fellows  <dkf@users.sf.net>
+
+	* generic/tclCompCmds.c (TclCompileDictAppendCmd): Fix bug in [dict
+	append] compiler which caused strange stack corruption. [Bug 1837392]
+
+2007-11-23  Andreas Kupries  <andreask@activestate.com>
+
+	* generic/tclIORChan.c: Fixed a problem with reflected channels. 'chan
+	postevent' is defined to work only from within the interpreter
+	containing the handler command. Sensible, we want only handler
+	commands to use it. It identifies the channel by handle. The channel
+	moves to a different interpreter or thread. The interpreter containing
+	the handler command doesn't know the channel any longer. 'chan
+	postevent' fails, not finding the channel any longer. Uhm.
+
+	Fixed by creating a second per-interpreter channel table, just for
+	reflected channels, where each interpreter remembers for which
+	reflected channels it has the handler command. This info does not move
+	with the channel itself. The table is updated by 'chan create', and
+	used by 'chan postevent'.
+
+	* tests/ioCmd.test: Updated the testsuite.
+
+2007-11-23  Jeff Hobbs  <jeffh@ActiveState.com>
+
+	* generic/tclVar.c (Tcl_ArrayObjCmd): handle the right data for
+	* tests/var.test (var-14.2):          [array names $var -glob $ptn]
+
+2007-11-23  Donal K. Fellows  <donal.k.fellows@manchester.ac.uk>
+
+	* generic/tclCmdMZ.c (String*Cmd, TclInitStringCmd): Rebuilt [string]
+	* generic/tclCompCmds.c (TclCompileString*Cmd): as an ensemble.
+
+2007-11-22  Donal K. Fellows  <dkf@users.sf.net>
+
+	* generic/tclDictObj.c (Dict*Cmd,TclInitDictCmd): Rebuilt the [dict]
+	* generic/tclCompCmds.c (TclCompileDict*Cmd): command as an ensemble.
+
+2007-11-22  Donal K. Fellows  <donal.k.fellows@manchester.ac.uk>
+
+	* generic/tclCmdMZ.c (Tcl_StringObjCmd): Rewrote the [string] and
+	* generic/tclDictObj.c (Tcl_DictObjCmd): [dict] implementations to be
+	ready for conversion to ensembles.
+
+	* tests/string.test (string-12.22): Flag shimmering bug found in
+	[string range].
+
+2007-11-21  Donal K. Fellows  <dkf@users.sf.net>
+
+	* generic/tclCompCmds.c (TclCompileEnsemble): Rewrote the ensemble
+	compiler to remove many of the limitations. Can now compile scripts
+	that use unique prefixes of subcommands, and which have mappings of a
+	command to multiple words (provided the first is a compilable command
+	of course).
+
 2007-11-21  Donal K. Fellows  <donal.k.fellows@manchester.ac.uk>
 
 	* generic/tclNamesp.c (TclMakeEnsemble): Factor out the code to set up
diff --git a/generic/tclBasic.c b/generic/tclBasic.c
index 82df237..8b9e8b4 100644
--- a/generic/tclBasic.c
+++ b/generic/tclBasic.c
@@ -14,7 +14,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclBasic.c,v 1.244.2.15 2007/11/13 13:07:41 dgp Exp $
+ * RCS: @(#) $Id: tclBasic.c,v 1.244.2.16 2007/11/25 06:45:43 dgp Exp $
  */
 
 #include "tclInt.h"
@@ -140,7 +140,6 @@ static const CmdInfo builtInCmds[] = {
     {"catch",		Tcl_CatchObjCmd,	TclCompileCatchCmd,	1},
     {"concat",		Tcl_ConcatObjCmd,	NULL,			1},
     {"continue",	Tcl_ContinueObjCmd,	TclCompileContinueCmd,	1},
-    {"dict",		Tcl_DictObjCmd,		TclCompileDictCmd,	1},
     {"encoding",	Tcl_EncodingObjCmd,	NULL,			0},
     {"error",		Tcl_ErrorObjCmd,	NULL,			1},
     {"eval",		Tcl_EvalObjCmd,		NULL,			1},
@@ -177,7 +176,6 @@ static const CmdInfo builtInCmds[] = {
     {"scan",		Tcl_ScanObjCmd,		NULL,			1},
     {"set",		Tcl_SetObjCmd,		TclCompileSetCmd,	1},
     {"split",		Tcl_SplitObjCmd,	NULL,			1},
-    {"string",		Tcl_StringObjCmd,	TclCompileStringCmd,	1},
     {"subst",		Tcl_SubstObjCmd,	NULL,			1},
     {"switch",		Tcl_SwitchObjCmd,	TclCompileSwitchCmd,	1},
     {"trace",		Tcl_TraceObjCmd,	NULL,			1},
@@ -656,7 +654,15 @@ Tcl_CreateInterp(void)
     }
 
     /*
-     * Register "clock", "chan" and "info" subcommands. These *do* go through
+     * Create the "dict", "info" and "string" ensembles.
+     */
+
+    TclInitDictCmd(interp);
+    TclInitInfoCmd(interp);
+    TclInitStringCmd(interp);
+
+    /*
+     * Register "clock" and "chan" subcommands. These *do* go through
      * Tcl_CreateObjCommand, since they aren't in the global namespace and
      * involve ensembles.
      */
@@ -670,8 +676,6 @@ Tcl_CreateInterp(void)
 		NULL, NULL);
     }
 
-    TclInitInfoCmd(interp);
-
     /* TIP #208 */
     Tcl_CreateObjCommand(interp, "::tcl::chan::Truncate",
 	    TclChanTruncateObjCmd, NULL, NULL);
diff --git a/generic/tclCmdMZ.c b/generic/tclCmdMZ.c
index cce50ff..56ac530 100644
--- a/generic/tclCmdMZ.c
+++ b/generic/tclCmdMZ.c
@@ -15,7 +15,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclCmdMZ.c,v 1.150.2.8 2007/11/21 06:30:48 dgp Exp $
+ * RCS: @(#) $Id: tclCmdMZ.c,v 1.150.2.9 2007/11/25 06:45:44 dgp Exp $
  */
 
 #include "tclInt.h"
@@ -1093,16 +1093,11 @@ Tcl_SplitObjCmd(
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_StringObjCmd --
+ * StringFirstCmd --
  *
- *	This procedure is invoked to process the "string" Tcl command. See the
- *	user documentation for details on what it does. Note that this command
- *	only functions correctly on properly formed Tcl UTF strings.
- *
- *	Note that the primary methods here (equal, compare, match, ...) have
- *	bytecode equivalents. You will find the code for those in
- *	tclExecute.c. The code here will only be used in the non-bc case (like
- *	in an 'eval').
+ *	This procedure is invoked to process the "string first" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
  *
  * Results:
  *	A standard Tcl result.
@@ -1113,1336 +1108,2227 @@ Tcl_SplitObjCmd(
  *----------------------------------------------------------------------
  */
 
-int
-Tcl_StringObjCmd(
+static int
+StringFirstCmd(
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
-    Tcl_Obj *CONST objv[])	/* Argument objects. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    int index, left, right;
-    char *string1, *string2;
-    int length1, length2;
-    static CONST char *options[] = {
-	"bytelength",	"compare",	"equal",	"first",
-	"index",	"is",		"last",		"length",
-	"map",		"match",	"range",	"repeat",
-	"replace",	"reverse",	"tolower",	"toupper",
-	"totitle",	"trim",		"trimleft",	"trimright",
-	"wordend",	"wordstart",	NULL
-    };
-    enum options {
-	STR_BYTELENGTH,	STR_COMPARE,	STR_EQUAL,	STR_FIRST,
-	STR_INDEX,	STR_IS,		STR_LAST,	STR_LENGTH,
-	STR_MAP,	STR_MATCH,	STR_RANGE,	STR_REPEAT,
-	STR_REPLACE,	STR_REVERSE,	STR_TOLOWER,	STR_TOUPPER,
-	STR_TOTITLE,	STR_TRIM,	STR_TRIMLEFT,	STR_TRIMRIGHT,
-	STR_WORDEND,	STR_WORDSTART
-    };
+    Tcl_UniChar *ustring1, *ustring2;
+    int match, start, length1, length2;
 
-    if (objc < 2) {
-	Tcl_WrongNumArgs(interp, 1, objv, "option arg ?arg ...?");
+    if (objc < 3 || objc > 4) {
+	Tcl_WrongNumArgs(interp, 1, objv,
+		"needleString haystackString ?startIndex?");
 	return TCL_ERROR;
     }
 
-    if (Tcl_GetIndexFromObj(interp, objv[1], options, "option", 0,
-	    &index) != TCL_OK) {
-	return TCL_ERROR;
-    }
+    /*
+     * We are searching string2 for the sequence string1.
+     */
+
+    match = -1;
+    start = 0;
+    length2 = -1;
+
+    ustring1 = Tcl_GetUnicodeFromObj(objv[1], &length1);
+    ustring2 = Tcl_GetUnicodeFromObj(objv[2], &length2);
 
-    switch ((enum options) index) {
-    case STR_EQUAL:
-    case STR_COMPARE: {
+    if (objc == 4) {
 	/*
-	 * Remember to keep code here in some sync with the byte-compiled
-	 * versions in tclExecute.c (INST_STR_EQ, INST_STR_NEQ and
-	 * INST_STR_CMP as well as the expr string comparison in
-	 * INST_EQ/INST_NEQ/INST_LT/...).
+	 * If a startIndex is specified, we will need to fast forward to that
+	 * point in the string before we think about a match.
 	 */
 
-	int i, match, length, nocase = 0, reqlength = -1;
-	typedef int (*strCmpFn_t)(const char *, const char *, unsigned int);
-	strCmpFn_t strCmpFn;
-
-	if (objc < 4 || objc > 7) {
-	str_cmp_args:
-	    Tcl_WrongNumArgs(interp, 2, objv,
-		    "?-nocase? ?-length int? string1 string2");
+	if (TclGetIntForIndexM(interp, objv[3], length2-1, &start) != TCL_OK){
 	    return TCL_ERROR;
 	}
 
-	for (i = 2; i < objc-2; i++) {
-	    string2 = TclGetStringFromObj(objv[i], &length2);
-	    if ((length2 > 1)
-		    && strncmp(string2, "-nocase", (size_t)length2) == 0) {
-		nocase = 1;
-	    } else if ((length2 > 1)
-		    && strncmp(string2, "-length", (size_t)length2) == 0) {
-		if (i+1 >= objc-2) {
-		    goto str_cmp_args;
-		}
-		++i;
-		if (TclGetIntFromObj(interp, objv[i],
-			&reqlength) != TCL_OK) {
-		    return TCL_ERROR;
-		}
-	    } else {
-		Tcl_AppendResult(interp, "bad option \"", string2,
-			"\": must be -nocase or -length", NULL);
-		return TCL_ERROR;
-	    }
-	}
-
 	/*
-	 * From now on, we only access the two objects at the end of the
-	 * argument array.
+	 * Reread to prevent shimmering problems.
 	 */
 
-	objv += objc-2;
+	ustring1 = Tcl_GetUnicodeFromObj(objv[1], &length1);
+	ustring2 = Tcl_GetUnicodeFromObj(objv[2], &length2);
 
-	if ((reqlength == 0) || (objv[0] == objv[1])) {
+	if (start >= length2) {
+	    goto str_first_done;
+	} else if (start > 0) {
+	    ustring2 += start;
+	    length2 -= start;
+	} else if (start < 0) {
 	    /*
-	     * Always match at 0 chars of if it is the same obj.
+	     * Invalid start index mapped to string start; Bug #423581
 	     */
 
-	    Tcl_SetObjResult(interp,
-		    Tcl_NewBooleanObj((enum options) index == STR_EQUAL));
-	    break;
-	} else if (!nocase && objv[0]->typePtr == &tclByteArrayType &&
-		objv[1]->typePtr == &tclByteArrayType) {
-	    /*
-	     * Use binary versions of comparisons since that won't cause undue
-	     * type conversions and it is much faster. Only do this if we're
-	     * case-sensitive (which is all that really makes sense with byte
-	     * arrays anyway, and we have no memcasecmp() for some
-	     * reason... :^)
-	     */
+	    start = 0;
+	}
+    }
 
-	    string1 = (char *) Tcl_GetByteArrayFromObj(objv[0], &length1);
-	    string2 = (char *) Tcl_GetByteArrayFromObj(objv[1], &length2);
-	    strCmpFn = (strCmpFn_t) memcmp;
-	} else if ((objv[0]->typePtr == &tclStringType)
-		&& (objv[1]->typePtr == &tclStringType)) {
-	    /*
-	     * Do a unicode-specific comparison if both of the args are of
-	     * String type. In benchmark testing this proved the most
-	     * efficient check between the unicode and string comparison
-	     * operations.
-	     */
+    if (length1 > 0) {
+	register Tcl_UniChar *p, *end;
 
-	    string1 = (char *) Tcl_GetUnicodeFromObj(objv[0], &length1);
-	    string2 = (char *) Tcl_GetUnicodeFromObj(objv[1], &length2);
-	    strCmpFn = (strCmpFn_t)
-		    (nocase ? Tcl_UniCharNcasecmp : Tcl_UniCharNcmp);
-	} else {
+	end = ustring2 + length2 - length1 + 1;
+	for (p = ustring2;  p < end;  p++) {
 	    /*
-	     * As a catch-all we will work with UTF-8. We cannot use memcmp()
-	     * as that is unsafe with any string containing NULL (\xC0\x80 in
-	     * Tcl's utf rep). We can use the more efficient TclpUtfNcmp2 if
-	     * we are case-sensitive and no specific length was requested.
+	     * Scan forward to find the first character.
 	     */
 
-	    string1 = (char *) TclGetStringFromObj(objv[0], &length1);
-	    string2 = (char *) TclGetStringFromObj(objv[1], &length2);
-	    if ((reqlength < 0) && !nocase) {
-		strCmpFn = (strCmpFn_t) TclpUtfNcmp2;
-	    } else {
-		length1 = Tcl_NumUtfChars(string1, length1);
-		length2 = Tcl_NumUtfChars(string2, length2);
-		strCmpFn = (strCmpFn_t)
-			(nocase ? Tcl_UtfNcasecmp : Tcl_UtfNcmp);
+	    if ((*p == *ustring1) && (TclUniCharNcmp(ustring1, p,
+		    (unsigned long) length1) == 0)) {
+		match = p - ustring2;
+		break;
 	    }
 	}
+    }
 
-	if (((enum options) index == STR_EQUAL)
-		&& (reqlength < 0) && (length1 != length2)) {
-	    match = 1;		/* This will be reversed below. */
-	} else {
-	    length = (length1 < length2) ? length1 : length2;
-	    if (reqlength > 0 && reqlength < length) {
-		length = reqlength;
-	    } else if (reqlength < 0) {
-		/*
-		 * The requested length is negative, so we ignore it by
-		 * setting it to length + 1 so we correct the match var.
-		 */
+    /*
+     * Compute the character index of the matching string by counting the
+     * number of characters before the match.
+     */
 
-		reqlength = length + 1;
-	    }
+    if ((match != -1) && (objc == 4)) {
+	match += start;
+    }
 
-	    match = strCmpFn(string1, string2, (unsigned) length);
-	    if ((match == 0) && (reqlength > length)) {
-		match = length1 - length2;
-	    }
-	}
+  str_first_done:
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(match));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringLastCmd --
+ *
+ *	This procedure is invoked to process the "string last" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
 
-	if ((enum options) index == STR_EQUAL) {
-	    Tcl_SetObjResult(interp, Tcl_NewBooleanObj(match ? 0 : 1));
-	} else {
-	    Tcl_SetObjResult(interp, Tcl_NewIntObj(
-		    (match > 0) ? 1 : (match < 0) ? -1 : 0));
-	}
-	break;
+static int
+StringLastCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    Tcl_UniChar *ustring1, *ustring2, *p;
+    int match, start, length1, length2;
+
+    if (objc < 3 || objc > 4) {
+	Tcl_WrongNumArgs(interp, 1, objv,
+		"needleString haystackString ?startIndex?");
+	return TCL_ERROR;
     }
-    case STR_FIRST: {
-	Tcl_UniChar *ustring1, *ustring2;
-	int match, start;
 
-	if (objc < 4 || objc > 5) {
-	    Tcl_WrongNumArgs(interp, 2, objv,
-		    "needleString haystackString ?startIndex?");
+    /*
+     * We are searching string2 for the sequence string1.
+     */
+
+    match = -1;
+    start = 0;
+    length2 = -1;
+
+    ustring1 = Tcl_GetUnicodeFromObj(objv[1], &length1);
+    ustring2 = Tcl_GetUnicodeFromObj(objv[2], &length2);
+
+    if (objc == 4) {
+	/*
+	 * If a startIndex is specified, we will need to restrict the string
+	 * range to that char index in the string
+	 */
+
+	if (TclGetIntForIndexM(interp, objv[3], length2-1, &start) != TCL_OK){
 	    return TCL_ERROR;
 	}
 
 	/*
-	 * We are searching string2 for the sequence string1.
+	 * Reread to prevent shimmering problems.
 	 */
 
-	match = -1;
-	start = 0;
-	length2 = -1;
+	ustring1 = Tcl_GetUnicodeFromObj(objv[1], &length1);
+	ustring2 = Tcl_GetUnicodeFromObj(objv[2], &length2);
 
-	ustring1 = Tcl_GetUnicodeFromObj(objv[2], &length1);
-	ustring2 = Tcl_GetUnicodeFromObj(objv[3], &length2);
+	if (start < 0) {
+	    goto str_last_done;
+	} else if (start < length2) {
+	    p = ustring2 + start + 1 - length1;
+	} else {
+	    p = ustring2 + length2 - length1;
+	}
+    } else {
+	p = ustring2 + length2 - length1;
+    }
 
-	if (objc == 5) {
+    if (length1 > 0) {
+	for (; p >= ustring2; p--) {
 	    /*
-	     * If a startIndex is specified, we will need to fast forward to
-	     * that point in the string before we think about a match.
+	     * Scan backwards to find the first character.
 	     */
 
-	    if (TclGetIntForIndexM(interp, objv[4], length2 - 1,
-		    &start) != TCL_OK) {
-		return TCL_ERROR;
-	    }
-	    if (start >= length2) {
-		goto str_first_done;
-	    } else if (start > 0) {
-		ustring2 += start;
-		length2 -= start;
-	    } else if (start < 0) {
-		/*
-		 * Invalid start index mapped to string start; Bug #423581
-		 */
-
-		start = 0;
+	    if ((*p == *ustring1) && !memcmp(ustring1, p,
+		    sizeof(Tcl_UniChar) * (size_t)length1)) {
+		match = p - ustring2;
+		break;
 	    }
 	}
+    }
+
+  str_last_done:
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(match));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringIndexCmd --
+ *
+ *	This procedure is invoked to process the "string index" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
 
-	if (length1 > 0) {
-	    register Tcl_UniChar *p, *end;
+static int
+StringIndexCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    int length, index;
 
-	    end = ustring2 + length2 - length1 + 1;
-	    for (p = ustring2;  p < end;  p++) {
-		/*
-		 * Scan forward to find the first character.
-		 */
-		if ((*p == *ustring1) && (TclUniCharNcmp(ustring1, p,
-			(unsigned long) length1) == 0)) {
-		    match = p - ustring2;
-		    break;
-		}
-	    }
-	}
+    if (objc != 3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "string charIndex");
+	return TCL_ERROR;
+    }
 
-	/*
-	 * Compute the character index of the matching string by counting the
-	 * number of characters before the match.
-	 */
+    /*
+     * If we have a ByteArray object, avoid indexing in the Utf string since
+     * the byte array contains one byte per character. Otherwise, use the
+     * Unicode string rep to get the index'th char.
+     */
 
-	if ((match != -1) && (objc == 5)) {
-	    match += start;
-	}
+    if (objv[1]->typePtr == &tclByteArrayType) {
+	const unsigned char *string =
+		Tcl_GetByteArrayFromObj(objv[1], &length);
 
-    str_first_done:
-	Tcl_SetObjResult(interp, Tcl_NewIntObj(match));
-	break;
-    }
-    case STR_INDEX: {
-	if (objc != 4) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "string charIndex");
+	if (TclGetIntForIndexM(interp, objv[2], length-1, &index) != TCL_OK){
 	    return TCL_ERROR;
 	}
-
+	string = Tcl_GetByteArrayFromObj(objv[1], &length);
+	if ((index >= 0) && (index < length)) {
+	    Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(string + index, 1));
+	}
+    } else {
 	/*
-	 * If we have a ByteArray object, avoid indexing in the Utf string
-	 * since the byte array contains one byte per character. Otherwise,
-	 * use the Unicode string rep to get the index'th char.
+	 * Get Unicode char length to calulate what 'end' means.
 	 */
 
-	if (objv[2]->typePtr == &tclByteArrayType) {
-	    string1 = (char *) Tcl_GetByteArrayFromObj(objv[2], &length1);
+	length = Tcl_GetCharLength(objv[1]);
 
-	    if (TclGetIntForIndexM(interp, objv[3], length1 - 1,
-		    &index) != TCL_OK) {
-		return TCL_ERROR;
-	    }
-	    if ((index >= 0) && (index < length1)) {
-		Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(
-			(unsigned char *)(&string1[index]), 1));
-	    }
-	} else {
-	    /*
-	     * Get Unicode char length to calulate what 'end' means.
-	     */
-
-	    length1 = Tcl_GetCharLength(objv[2]);
-
-	    if (TclGetIntForIndexM(interp, objv[3], length1 - 1,
-		    &index) != TCL_OK) {
-		return TCL_ERROR;
-	    }
-	    if ((index >= 0) && (index < length1)) {
-		char buf[TCL_UTF_MAX];
-		Tcl_UniChar ch;
+	if (TclGetIntForIndexM(interp, objv[2], length-1, &index) != TCL_OK){
+	    return TCL_ERROR;
+	}
+	if ((index >= 0) && (index < length)) {
+	    char buf[TCL_UTF_MAX];
+	    Tcl_UniChar ch;
 
-		ch = Tcl_GetUniChar(objv[2], index);
-		length1 = Tcl_UniCharToUtf(ch, buf);
-		Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, length1));
-	    }
+	    ch = Tcl_GetUniChar(objv[1], index);
+	    length = Tcl_UniCharToUtf(ch, buf);
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, length));
 	}
-	break;
     }
-    case STR_IS: {
-	char *end, *stop;
-	Tcl_UniChar ch;
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringIsCmd --
+ *
+ *	This procedure is invoked to process the "string is" Tcl command. See
+ *	the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
 
-	/*
-	 * The UniChar comparison function
-	 */
+static int
+StringIsCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    const char *string1, *string2, *end, *stop;
+    Tcl_UniChar ch;
+    int (*chcomp)(int) = NULL;	/* The UniChar comparison function. */
+    int i, failat = 0, result = 1, strict = 0, index, length1, length2;
+    Tcl_Obj *objPtr, *failVarObj = NULL;
+    Tcl_WideInt w;
+
+    static const char *isOptions[] = {
+	"alnum",	"alpha",	"ascii",	"control",
+	"boolean",	"digit",	"double",	"false",
+	"graph",	"integer",	"list",		"lower",
+	"print",	"punct",	"space",	"true",
+	"upper",	"wideinteger",	"wordchar",	"xdigit",
+	NULL
+    };
+    enum isOptions {
+	STR_IS_ALNUM, STR_IS_ALPHA,	STR_IS_ASCII,  STR_IS_CONTROL,
+	STR_IS_BOOL,  STR_IS_DIGIT,	STR_IS_DOUBLE, STR_IS_FALSE,
+	STR_IS_GRAPH, STR_IS_INT,	STR_IS_LIST,   STR_IS_LOWER,
+	STR_IS_PRINT, STR_IS_PUNCT, STR_IS_SPACE,  STR_IS_TRUE,
+	STR_IS_UPPER, STR_IS_WIDE,	STR_IS_WORD,   STR_IS_XDIGIT
+    };
 
-	int (*chcomp)(int) = NULL;
-	int i, failat = 0, result = 1, strict = 0;
-	Tcl_Obj *objPtr, *failVarObj = NULL;
-	Tcl_WideInt w;
-
-	static CONST char *isOptions[] = {
-	    "alnum",	"alpha",	"ascii",	"control",
-	    "boolean",	"digit",	"double",	"false",
-	    "graph",	"integer",	"list",		"lower",
-	    "print",	"punct",	"space",	"true",
-	    "upper",	"wideinteger",	"wordchar",	"xdigit",
-	    NULL
-	};
-	enum isOptions {
-	    STR_IS_ALNUM, STR_IS_ALPHA,	STR_IS_ASCII,  STR_IS_CONTROL,
-	    STR_IS_BOOL,  STR_IS_DIGIT,	STR_IS_DOUBLE, STR_IS_FALSE,
-	    STR_IS_GRAPH, STR_IS_INT,	STR_IS_LIST,   STR_IS_LOWER,
-	    STR_IS_PRINT, STR_IS_PUNCT, STR_IS_SPACE,  STR_IS_TRUE,
-	    STR_IS_UPPER, STR_IS_WIDE,	STR_IS_WORD,   STR_IS_XDIGIT
-	};
+    if (objc < 3 || objc > 6) {
+	Tcl_WrongNumArgs(interp, 1, objv,
+		"class ?-strict? ?-failindex var? str");
+	return TCL_ERROR;
+    }
+    if (Tcl_GetIndexFromObj(interp, objv[1], isOptions, "class", 0,
+	    &index) != TCL_OK) {
+	return TCL_ERROR;
+    }
 
-	if (objc < 4 || objc > 7) {
-	    Tcl_WrongNumArgs(interp, 2, objv,
-		    "class ?-strict? ?-failindex var? str");
-	    return TCL_ERROR;
-	}
-	if (Tcl_GetIndexFromObj(interp, objv[2], isOptions, "class", 0,
-		&index) != TCL_OK) {
-	    return TCL_ERROR;
-	}
-	if (objc != 4) {
-	    for (i = 3; i < objc-1; i++) {
-		string2 = TclGetStringFromObj(objv[i], &length2);
-		if ((length2 > 1) &&
-			strncmp(string2, "-strict", (size_t) length2) == 0) {
-		    strict = 1;
-		} else if ((length2 > 1) &&
-			strncmp(string2, "-failindex", (size_t)length2) == 0){
-		    if (i+1 >= objc-1) {
-			Tcl_WrongNumArgs(interp, 3, objv,
-				"?-strict? ?-failindex var? str");
-			return TCL_ERROR;
-		    }
-		    failVarObj = objv[++i];
-		} else {
-		    Tcl_AppendResult(interp, "bad option \"", string2,
-			    "\": must be -strict or -failindex", NULL);
+    if (objc != 3) {
+	for (i = 2; i < objc-1; i++) {
+	    string2 = TclGetStringFromObj(objv[i], &length2);
+	    if ((length2 > 1) &&
+		    strncmp(string2, "-strict", (size_t) length2) == 0) {
+		strict = 1;
+	    } else if ((length2 > 1) &&
+		    strncmp(string2, "-failindex", (size_t)length2) == 0){
+		if (i+1 >= objc-1) {
+		    Tcl_WrongNumArgs(interp, 2, objv,
+			    "?-strict? ?-failindex var? str");
 		    return TCL_ERROR;
 		}
+		failVarObj = objv[++i];
+	    } else {
+		Tcl_AppendResult(interp, "bad option \"", string2,
+			"\": must be -strict or -failindex", NULL);
+		return TCL_ERROR;
 	    }
 	}
+    }
 
-	/*
-	 * We get the objPtr so that we can short-cut for some classes by
-	 * checking the object type (int and double), but we need the string
-	 * otherwise, because we don't want any conversion of type occuring
-	 * (as, for example, Tcl_Get*FromObj would do
-	 */
+    /*
+     * We get the objPtr so that we can short-cut for some classes by checking
+     * the object type (int and double), but we need the string otherwise,
+     * because we don't want any conversion of type occuring (as, for example,
+     * Tcl_Get*FromObj would do).
+     */
 
-	objPtr = objv[objc-1];
-	string1 = TclGetStringFromObj(objPtr, &length1);
-	if (length1 == 0 && index != STR_IS_LIST) {
-	    if (strict) {
-		result = 0;
-	    }
-	    goto str_is_done;
+    objPtr = objv[objc-1];
+    string1 = TclGetStringFromObj(objPtr, &length1);
+    if (length1 == 0 && index != STR_IS_LIST) {
+	if (strict) {
+	    result = 0;
 	}
-	end = string1 + length1;
+	goto str_is_done;
+    }
+    end = string1 + length1;
 
-	/*
-	 * When entering here, result == 1 and failat == 0
-	 */
+    /*
+     * When entering here, result == 1 and failat == 0.
+     */
 
-	switch ((enum isOptions) index) {
-	case STR_IS_ALNUM:
-	    chcomp = Tcl_UniCharIsAlnum;
-	    break;
-	case STR_IS_ALPHA:
-	    chcomp = Tcl_UniCharIsAlpha;
-	    break;
-	case STR_IS_ASCII:
-	    chcomp = UniCharIsAscii;
-	    break;
-	case STR_IS_BOOL:
-	case STR_IS_TRUE:
-	case STR_IS_FALSE:
-	    if (TCL_OK != Tcl_ConvertToType(NULL, objPtr, &tclBooleanType)) {
-		result = 0;
-	    } else if ((((enum isOptions) index == STR_IS_TRUE) &&
-		    objPtr->internalRep.longValue == 0) ||
-		    (((enum isOptions) index == STR_IS_FALSE) &&
-		    objPtr->internalRep.longValue != 0)) {
-		result = 0;
-	    }
-	    break;
-	case STR_IS_CONTROL:
-	    chcomp = Tcl_UniCharIsControl;
-	    break;
-	case STR_IS_DIGIT:
-	    chcomp = Tcl_UniCharIsDigit;
-	    break;
-	case STR_IS_DOUBLE: {
-	    /* TODO */
-	    if ((objPtr->typePtr == &tclDoubleType) ||
-		    (objPtr->typePtr == &tclIntType) ||
+    switch ((enum isOptions) index) {
+    case STR_IS_ALNUM:
+	chcomp = Tcl_UniCharIsAlnum;
+	break;
+    case STR_IS_ALPHA:
+	chcomp = Tcl_UniCharIsAlpha;
+	break;
+    case STR_IS_ASCII:
+	chcomp = UniCharIsAscii;
+	break;
+    case STR_IS_BOOL:
+    case STR_IS_TRUE:
+    case STR_IS_FALSE:
+	if (TCL_OK != Tcl_ConvertToType(NULL, objPtr, &tclBooleanType)) {
+	    result = 0;
+	} else if (((index == STR_IS_TRUE) &&
+		objPtr->internalRep.longValue == 0)
+	    || ((index == STR_IS_FALSE) &&
+		objPtr->internalRep.longValue != 0)) {
+	    result = 0;
+	}
+	break;
+    case STR_IS_CONTROL:
+	chcomp = Tcl_UniCharIsControl;
+	break;
+    case STR_IS_DIGIT:
+	chcomp = Tcl_UniCharIsDigit;
+	break;
+    case STR_IS_DOUBLE: {
+	/* TODO */
+	if ((objPtr->typePtr == &tclDoubleType) ||
+		(objPtr->typePtr == &tclIntType) ||
 #ifndef NO_WIDE_TYPE
-		    (objPtr->typePtr == &tclWideIntType) ||
+		(objPtr->typePtr == &tclWideIntType) ||
 #endif
-		    (objPtr->typePtr == &tclBignumType)) {
-		break;
-	    }
-	    if (TclParseNumber(NULL, objPtr, NULL, NULL, -1,
-		    (const char **) &stop, 0) != TCL_OK) {
+		(objPtr->typePtr == &tclBignumType)) {
+	    break;
+	}
+	if (TclParseNumber(NULL, objPtr, NULL, NULL, -1,
+		(const char **) &stop, 0) != TCL_OK) {
+	    result = 0;
+	    failat = 0;
+	} else {
+	    failat = stop - string1;
+	    if (stop < end) {
 		result = 0;
-		failat = 0;
-	    } else {
-		failat = stop - string1;
-		if (stop < end) {
-		    result = 0;
-		    TclFreeIntRep(objPtr);
-		    objPtr->typePtr = NULL;
-		}
+		TclFreeIntRep(objPtr);
+		objPtr->typePtr = NULL;
 	    }
+	}
+	break;
+    }
+    case STR_IS_GRAPH:
+	chcomp = Tcl_UniCharIsGraph;
+	break;
+    case STR_IS_INT:
+	if (TCL_OK == TclGetIntFromObj(NULL, objPtr, &i)) {
 	    break;
 	}
-	case STR_IS_GRAPH:
-	    chcomp = Tcl_UniCharIsGraph;
+	goto failedIntParse;
+    case STR_IS_WIDE:
+	if (TCL_OK == Tcl_GetWideIntFromObj(NULL, objPtr, &w)) {
 	    break;
-	case STR_IS_INT:
-	case STR_IS_WIDE:
-	    if ((((enum isOptions) index) == STR_IS_INT)
-		    && (TCL_OK == TclGetIntFromObj(NULL, objPtr, &i))) {
-		break;
-	    }
-	    if ((((enum isOptions) index) == STR_IS_WIDE)
-		    && (TCL_OK == Tcl_GetWideIntFromObj(NULL, objPtr, &w))) {
-		break;
-	    }
+	}
 
-	    result = 0;
+    failedIntParse:
+	result = 0;
 
-	    if (failVarObj == NULL) {
+	if (failVarObj == NULL) {
+	    /*
+	     * Don't bother computing the failure point if we're not going to
+	     * return it.
+	     */
+
+	    break;
+	}
+	if (TclParseNumber(NULL, objPtr, NULL, NULL, -1,
+		(const char **) &stop, TCL_PARSE_INTEGER_ONLY) == TCL_OK) {
+	    if (stop == end) {
 		/*
-		 * Don't bother computing the failure point if we're not
-		 * going to return it.
+		 * Entire string parses as an integer, but rejected by
+		 * Tcl_Get(Wide)IntFromObj() so we must have overflowed the
+		 * target type, and our convention is to return failure at
+		 * index -1 in that situation.
 		 */
-		break;
-	    }
-	    if (TclParseNumber(NULL, objPtr, NULL, NULL, -1,
-		    (const char **) &stop, TCL_PARSE_INTEGER_ONLY) == TCL_OK) {
-		if (stop == end) {
-		    /*
-		     * Entire string parses as an integer, but rejected by
-		     * Tcl_Get(Wide)IntFromObj() so we must have overflowed
-		     * the target type, and our convention is to return
-		     * failure at index -1 in that situation.
-		     */
-		    failat = -1;
-		} else {
-		    /*
-		     * Some prefix parsed as an integer, but not the whole
-		     * string, so return failure index as the point where
-		     * parsing stopped.  Clear out the internal rep, since
-		     * keeping it would leave *objPtr in an inconsistent
-		     * state.
-		     */
-		    failat = stop - string1;
-		    TclFreeIntRep(objPtr);
-		    objPtr->typePtr = NULL;
-		}
+
+		failat = -1;
 	    } else {
-		/* No prefix is a valid integer.  Fail at beginning. */
-		failat = 0;
+		/*
+		 * Some prefix parsed as an integer, but not the whole string,
+		 * so return failure index as the point where parsing stopped.
+		 * Clear out the internal rep, since keeping it would leave
+		 * *objPtr in an inconsistent state.
+		 */
+
+		failat = stop - string1;
+		TclFreeIntRep(objPtr);
+		objPtr->typePtr = NULL;
 	    }
-	    break;
-	case STR_IS_LIST:
+	} else {
 	    /*
-	     * We ignore the strictness here, since empty strings are always
-	     * well-formed lists.
+	     * No prefix is a valid integer. Fail at beginning.
 	     */
 
-	    if (TCL_OK == TclListObjLength(NULL, objPtr, &length2)) {
-		break;
-	    }
+	    failat = 0;
+	}
+	break;
+    case STR_IS_LIST:
+	/*
+	 * We ignore the strictness here, since empty strings are always
+	 * well-formed lists.
+	 */
 
-	    if (failVarObj != NULL) {
-		/*
-		 * Need to figure out where the list parsing failed, which is
-		 * fairly expensive. This is adapted from the core of
-		 * SetListFromAny().
-		 */
+	if (TCL_OK == TclListObjLength(NULL, objPtr, &length2)) {
+	    break;
+	}
 
-		const char *elemStart, *nextElem, *limit;
-		int lenRemain, elemSize, hasBrace;
-		register const char *p;
+	if (failVarObj != NULL) {
+	    /*
+	     * Need to figure out where the list parsing failed, which is
+	     * fairly expensive. This is adapted from the core of
+	     * SetListFromAny().
+	     */
 
-		limit = string1 + length1;
-		failat = -1;
-		for (p=string1, lenRemain=length1; lenRemain > 0;
-			p = nextElem, lenRemain = (limit-nextElem)) {
-		    if (TCL_ERROR == TclFindElement(NULL, p, lenRemain,
-			    &elemStart, &nextElem, &elemSize, &hasBrace)) {
-			/*
-			 * This is the simplest way of getting the number of
-			 * characters parsed. Note that this is not the same
-			 * as the number of bytes when parsing strings with
-			 * non-ASCII characters in them.
-			 */
+	    const char *elemStart, *nextElem, *limit;
+	    int lenRemain, elemSize, hasBrace;
+	    register const char *p;
 
-			Tcl_Obj *tmpStr;
+	    limit = string1 + length1;
+	    failat = -1;
+	    for (p=string1, lenRemain=length1; lenRemain > 0;
+		    p=nextElem, lenRemain=limit-nextElem) {
+		if (TCL_ERROR == TclFindElement(NULL, p, lenRemain,
+			&elemStart, &nextElem, &elemSize, &hasBrace)) {
+		    Tcl_Obj *tmpStr;
 
-			/*
-			 * Skip leading spaces first. This is only really an
-			 * issue if it is the first "element" that has the
-			 * failure.
-			 */
+		    /*
+		     * This is the simplest way of getting the number of
+		     * characters parsed. Note that this is not the same as
+		     * the number of bytes when parsing strings with non-ASCII
+		     * characters in them.
+		     *
+		     * Skip leading spaces first. This is only really an issue
+		     * if it is the first "element" that has the failure.
+		     */
 
-			while (isspace(UCHAR(*p))) {		/* INTL: ? */
-			    p++;
-			}
-			tmpStr = Tcl_NewStringObj(string1, p-string1);
-			failat = Tcl_GetCharLength(tmpStr);
-			TclDecrRefCount(tmpStr);
-			break;
+		    while (isspace(UCHAR(*p))) {		/* INTL: ? */
+			p++;
 		    }
-		}
-	    }
-	    result = 0;
-	    break;
-	case STR_IS_LOWER:
-	    chcomp = Tcl_UniCharIsLower;
-	    break;
-	case STR_IS_PRINT:
-	    chcomp = Tcl_UniCharIsPrint;
-	    break;
-	case STR_IS_PUNCT:
-	    chcomp = Tcl_UniCharIsPunct;
-	    break;
-	case STR_IS_SPACE:
-	    chcomp = Tcl_UniCharIsSpace;
-	    break;
-	case STR_IS_UPPER:
-	    chcomp = Tcl_UniCharIsUpper;
-	    break;
-	case STR_IS_WORD:
-	    chcomp = Tcl_UniCharIsWordChar;
-	    break;
-	case STR_IS_XDIGIT:
-	    for (; string1 < end; string1++, failat++) {
-		/* INTL: We assume unicode is bad for this class. */
-		if ((*((unsigned char *)string1) >= 0xC0) ||
-			!isxdigit(*(unsigned char *)string1)) {
-		    result = 0;
+		    TclNewStringObj(tmpStr, string1, p-string1);
+		    failat = Tcl_GetCharLength(tmpStr);
+		    TclDecrRefCount(tmpStr);
 		    break;
 		}
 	    }
-	    break;
 	}
-	if (chcomp != NULL) {
-	    for (; string1 < end; string1 += length2, failat++) {
-		length2 = TclUtfToUniChar(string1, &ch);
-		if (!chcomp(ch)) {
-		    result = 0;
-		    break;
-		}
+	result = 0;
+	break;
+    case STR_IS_LOWER:
+	chcomp = Tcl_UniCharIsLower;
+	break;
+    case STR_IS_PRINT:
+	chcomp = Tcl_UniCharIsPrint;
+	break;
+    case STR_IS_PUNCT:
+	chcomp = Tcl_UniCharIsPunct;
+	break;
+    case STR_IS_SPACE:
+	chcomp = Tcl_UniCharIsSpace;
+	break;
+    case STR_IS_UPPER:
+	chcomp = Tcl_UniCharIsUpper;
+	break;
+    case STR_IS_WORD:
+	chcomp = Tcl_UniCharIsWordChar;
+	break;
+    case STR_IS_XDIGIT:
+	for (; string1 < end; string1++, failat++) {
+	    /* INTL: We assume unicode is bad for this class. */
+	    if ((*((unsigned char *)string1) >= 0xC0) ||
+		    !isxdigit(*(unsigned char *)string1)) {
+		result = 0;
+		break;
+	    }
+	}
+	break;
+    }
+    if (chcomp != NULL) {
+	for (; string1 < end; string1 += length2, failat++) {
+	    length2 = TclUtfToUniChar(string1, &ch);
+	    if (!chcomp(ch)) {
+		result = 0;
+		break;
 	    }
 	}
+    }
 
-	/*
-	 * Only set the failVarObj when we will return 0 and we have indicated
-	 * a valid fail index (>= 0).
-	 */
+    /*
+     * Only set the failVarObj when we will return 0 and we have indicated a
+     * valid fail index (>= 0).
+     */
 
-    str_is_done:
-	if ((result == 0) && (failVarObj != NULL) &&
-	    Tcl_ObjSetVar2(interp, failVarObj, NULL, Tcl_NewIntObj(failat),
-		    TCL_LEAVE_ERR_MSG) == NULL) {
-	    return TCL_ERROR;
-	}
-	Tcl_SetObjResult(interp, Tcl_NewBooleanObj(result));
-	break;
+ str_is_done:
+    if ((result == 0) && (failVarObj != NULL) &&
+	Tcl_ObjSetVar2(interp, failVarObj, NULL, Tcl_NewIntObj(failat),
+		TCL_LEAVE_ERR_MSG) == NULL) {
+	return TCL_ERROR;
     }
-    case STR_LAST: {
-	Tcl_UniChar *ustring1, *ustring2, *p;
-	int match, start;
+    Tcl_SetObjResult(interp, Tcl_NewBooleanObj(result));
+    return TCL_OK;
+}
 
-	if (objc < 4 || objc > 5) {
-	    Tcl_WrongNumArgs(interp, 2, objv,
-		    "needleString haystackString ?startIndex?");
+static int
+UniCharIsAscii(
+    int character)
+{
+    return (character >= 0) && (character < 0x80);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringMapCmd --
+ *
+ *	This procedure is invoked to process the "string map" Tcl command. See
+ *	the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+StringMapCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    int length1, length2, mapElemc, index;
+    int nocase = 0, mapWithDict = 0, copySource = 0;
+    Tcl_Obj **mapElemv, *sourceObj, *resultPtr;
+    Tcl_UniChar *ustring1, *ustring2, *p, *end;
+    int (*strCmpFn)(const Tcl_UniChar*, const Tcl_UniChar*, unsigned long);
+
+    if (objc < 3 || objc > 4) {
+	Tcl_WrongNumArgs(interp, 1, objv, "?-nocase? charMap string");
+	return TCL_ERROR;
+    }
+
+    if (objc == 4) {
+	const char *string = TclGetStringFromObj(objv[1], &length2);
+
+	if ((length2 > 1) &&
+		strncmp(string, "-nocase", (size_t) length2) == 0) {
+	    nocase = 1;
+	} else {
+	    Tcl_AppendResult(interp, "bad option \"", string,
+		    "\": must be -nocase", NULL);
 	    return TCL_ERROR;
 	}
+    }
 
-	/*
-	 * We are searching string2 for the sequence string1.
-	 */
+    /*
+     * This test is tricky, but has to be that way or you get other strange
+     * inconsistencies (see test string-10.20 for illustration why!)
+     */
 
-	match = -1;
-	start = 0;
-	length2 = -1;
+    if (objv[objc-2]->typePtr == &tclDictType && objv[objc-2]->bytes == NULL){
+	int i, done;
+	Tcl_DictSearch search;
 
-	ustring1 = Tcl_GetUnicodeFromObj(objv[2], &length1);
-	ustring2 = Tcl_GetUnicodeFromObj(objv[3], &length2);
+	/*
+	 * We know the type exactly, so all dict operations will succeed for
+	 * sure. This shortens this code quite a bit.
+	 */
 
-	if (objc == 5) {
+	Tcl_DictObjSize(interp, objv[objc-2], &mapElemc);
+	if (mapElemc == 0) {
 	    /*
-	     * If a startIndex is specified, we will need to restrict the
-	     * string range to that char index in the string
+	     * Empty charMap, just return whatever string was given.
 	     */
 
-	    if (TclGetIntForIndexM(interp, objv[4], length2 - 1,
-		    &start) != TCL_OK) {
-		return TCL_ERROR;
-	    }
-	    if (start < 0) {
-		goto str_last_done;
-	    } else if (start < length2) {
-		p = ustring2 + start + 1 - length1;
-	    } else {
-		p = ustring2 + length2 - length1;
-	    }
-	} else {
-	    p = ustring2 + length2 - length1;
+	    Tcl_SetObjResult(interp, objv[objc-1]);
+	    return TCL_OK;
 	}
 
-	if (length1 > 0) {
-	    for (; p >= ustring2; p--) {
-		/*
-		 * Scan backwards to find the first character.
-		 */
+	mapElemc *= 2;
+	mapWithDict = 1;
 
-		if ((*p == *ustring1) && !memcmp(ustring1, p,
-			sizeof(Tcl_UniChar) * (size_t)length1)) {
-		    match = p - ustring2;
-		    break;
-		}
-	    }
-	}
+	/*
+	 * Copy the dictionary out into an array; that's the easiest way to
+	 * adapt this code...
+	 */
 
-    str_last_done:
-	Tcl_SetObjResult(interp, Tcl_NewIntObj(match));
-	break;
-    }
-    case STR_BYTELENGTH:
-    case STR_LENGTH:
-	if (objc != 3) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "string");
+	mapElemv = (Tcl_Obj **)
+		TclStackAlloc(interp, sizeof(Tcl_Obj *) * mapElemc);
+	Tcl_DictObjFirst(interp, objv[objc-2], &search, mapElemv+0,
+		mapElemv+1, &done);
+	for (i=2 ; i<mapElemc ; i+=2) {
+	    Tcl_DictObjNext(&search, mapElemv+i, mapElemv+i+1, &done);
+	}
+	Tcl_DictObjDone(&search);
+    } else {
+	if (TclListObjGetElements(interp, objv[objc-2], &mapElemc,
+		&mapElemv) != TCL_OK) {
 	    return TCL_ERROR;
 	}
+	if (mapElemc == 0) {
+	    /*
+	     * empty charMap, just return whatever string was given.
+	     */
 
-	if ((enum options) index == STR_BYTELENGTH) {
-	    (void) TclGetStringFromObj(objv[2], &length1);
-	} else {
+	    Tcl_SetObjResult(interp, objv[objc-1]);
+	    return TCL_OK;
+	} else if (mapElemc & 1) {
 	    /*
-	     * If we have a ByteArray object, avoid recomputing the string
-	     * since the byte array contains one byte per character.
-	     * Otherwise, use the Unicode string rep to calculate the length.
+	     * The charMap must be an even number of key/value items.
 	     */
 
-	    if (objv[2]->typePtr == &tclByteArrayType) {
-		(void) Tcl_GetByteArrayFromObj(objv[2], &length1);
-	    } else {
-		length1 = Tcl_GetCharLength(objv[2]);
-	    }
-	}
-	Tcl_SetObjResult(interp, Tcl_NewIntObj(length1));
-	break;
-    case STR_MAP: {
-	int mapElemc, nocase = 0, mapWithDict = 0, copySource = 0;
-	Tcl_Obj **mapElemv, *sourceObj, *resultPtr;
-	Tcl_UniChar *ustring1, *ustring2, *p, *end;
-	int (*strCmpFn)(CONST Tcl_UniChar*, CONST Tcl_UniChar*, unsigned long);
-
-	if (objc < 4 || objc > 5) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "?-nocase? charMap string");
+	    Tcl_SetObjResult(interp,
+		    Tcl_NewStringObj("char map list unbalanced", -1));
 	    return TCL_ERROR;
 	}
+    }
 
-	if (objc == 5) {
-	    string2 = TclGetStringFromObj(objv[2], &length2);
-	    if ((length2 > 1) &&
-		    strncmp(string2, "-nocase", (size_t) length2) == 0) {
-		nocase = 1;
-	    } else {
-		Tcl_AppendResult(interp, "bad option \"", string2,
-			"\": must be -nocase", NULL);
-		return TCL_ERROR;
-	    }
-	}
+    /*
+     * Take a copy of the source string object if it is the same as the map
+     * string to cut out nasty sharing crashes. [Bug 1018562]
+     */
 
+    if (objv[objc-2] == objv[objc-1]) {
+	sourceObj = Tcl_DuplicateObj(objv[objc-1]);
+	copySource = 1;
+    } else {
+	sourceObj = objv[objc-1];
+    }
+    ustring1 = Tcl_GetUnicodeFromObj(sourceObj, &length1);
+    if (length1 == 0) {
 	/*
-	 * This test is tricky, but has to be that way or you get other
-	 * strange inconsistencies (see test string-10.20 for illustration
-	 * why!)
+	 * Empty input string, just stop now.
 	 */
 
-	if (objv[objc-2]->typePtr == &tclDictType &&
-		objv[objc-2]->bytes == NULL) {
-	    int i, done;
-	    Tcl_DictSearch search;
+	goto done;
+    }
+    end = ustring1 + length1;
 
-	    /*
-	     * We know the type exactly, so all dict operations will succeed
-	     * for sure. This shortens this code quite a bit.
-	     */
+    strCmpFn = (nocase ? Tcl_UniCharNcasecmp : Tcl_UniCharNcmp);
 
-	    Tcl_DictObjSize(interp, objv[objc-2], &mapElemc);
-	    if (mapElemc == 0) {
-		/*
-		 * Empty charMap, just return whatever string was given.
-		 */
+    /*
+     * Force result to be Unicode
+     */
 
-		Tcl_SetObjResult(interp, objv[objc-1]);
-		return TCL_OK;
-	    }
+    resultPtr = Tcl_NewUnicodeObj(ustring1, 0);
 
-	    mapElemc *= 2;
-	    mapWithDict = 1;
+    if (mapElemc == 2) {
+	/*
+	 * Special case for one map pair which avoids the extra for loop and
+	 * extra calls to get Unicode data. The algorithm is otherwise
+	 * identical to the multi-pair case. This will be >30% faster on
+	 * larger strings.
+	 */
+
+	int mapLen;
+	Tcl_UniChar *mapString, u2lc;
 
+	ustring2 = Tcl_GetUnicodeFromObj(mapElemv[0], &length2);
+	p = ustring1;
+	if ((length2 > length1) || (length2 == 0)) {
 	    /*
-	     * Copy the dictionary out into an array; that's the easiest way
-	     * to adapt this code...
+	     * Match string is either longer than input or empty.
 	     */
 
-	    mapElemv = (Tcl_Obj **)
-		    TclStackAlloc(interp, sizeof(Tcl_Obj *) * mapElemc);
-	    Tcl_DictObjFirst(interp, objv[objc-2], &search, mapElemv+0,
-		    mapElemv+1, &done);
-	    for (i=2 ; i<mapElemc ; i+=2) {
-		Tcl_DictObjNext(&search, mapElemv+i, mapElemv+i+1, &done);
-	    }
-	    Tcl_DictObjDone(&search);
+	    ustring1 = end;
 	} else {
-	    if (TclListObjGetElements(interp, objv[objc-2],
-		    &mapElemc, &mapElemv) != TCL_OK) {
-		return TCL_ERROR;
+	    mapString = Tcl_GetUnicodeFromObj(mapElemv[1], &mapLen);
+	    u2lc = (nocase ? Tcl_UniCharToLower(*ustring2) : 0);
+	    for (; ustring1 < end; ustring1++) {
+		if (((*ustring1 == *ustring2) ||
+			(nocase&&Tcl_UniCharToLower(*ustring1)==u2lc)) &&
+			(length2==1 || strCmpFn(ustring1, ustring2,
+				(unsigned long) length2) == 0)) {
+		    if (p != ustring1) {
+			Tcl_AppendUnicodeToObj(resultPtr, p, ustring1-p);
+			p = ustring1 + length2;
+		    } else {
+			p += length2;
+		    }
+		    ustring1 = p - 1;
+
+		    Tcl_AppendUnicodeToObj(resultPtr, mapString, mapLen);
+		}
 	    }
-	    if (mapElemc == 0) {
-		/*
-		 * empty charMap, just return whatever string was given.
-		 */
+	}
+    } else {
+	Tcl_UniChar **mapStrings, *u2lc = NULL;
+	int *mapLens;
 
-		Tcl_SetObjResult(interp, objv[objc-1]);
-		return TCL_OK;
-	    } else if (mapElemc & 1) {
+	/*
+	 * Precompute pointers to the unicode string and length. This saves us
+	 * repeated function calls later, significantly speeding up the
+	 * algorithm. We only need the lowercase first char in the nocase
+	 * case.
+	 */
+
+	mapStrings = (Tcl_UniChar **) TclStackAlloc(interp,
+		mapElemc * 2 * sizeof(Tcl_UniChar *));
+	mapLens = (int *) TclStackAlloc(interp, mapElemc * 2 * sizeof(int));
+	if (nocase) {
+	    u2lc = (Tcl_UniChar *) TclStackAlloc(interp,
+		    mapElemc * sizeof(Tcl_UniChar));
+	}
+	for (index = 0; index < mapElemc; index++) {
+	    mapStrings[index] = Tcl_GetUnicodeFromObj(mapElemv[index],
+		    mapLens+index);
+	    if (nocase && ((index % 2) == 0)) {
+		u2lc[index/2] = Tcl_UniCharToLower(*mapStrings[index]);
+	    }
+	}
+	for (p = ustring1; ustring1 < end; ustring1++) {
+	    for (index = 0; index < mapElemc; index += 2) {
 		/*
-		 * The charMap must be an even number of key/value items.
+		 * Get the key string to match on.
 		 */
 
-		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"char map list unbalanced", -1));
-		return TCL_ERROR;
+		ustring2 = mapStrings[index];
+		length2 = mapLens[index];
+		if ((length2 > 0) && ((*ustring1 == *ustring2) || (nocase &&
+			(Tcl_UniCharToLower(*ustring1) == u2lc[index/2]))) &&
+			/* Restrict max compare length. */
+			(end-ustring1 >= length2) && ((length2 == 1) ||
+			!strCmpFn(ustring2, ustring1, (unsigned) length2))) {
+		    if (p != ustring1) {
+			/*
+			 * Put the skipped chars onto the result first.
+			 */
+
+			Tcl_AppendUnicodeToObj(resultPtr, p, ustring1-p);
+			p = ustring1 + length2;
+		    } else {
+			p += length2;
+		    }
+
+		    /*
+		     * Adjust len to be full length of matched string.
+		     */
+
+		    ustring1 = p - 1;
+
+		    /*
+		     * Append the map value to the unicode string.
+		     */
+
+		    Tcl_AppendUnicodeToObj(resultPtr,
+			    mapStrings[index+1], mapLens[index+1]);
+		    break;
+		}
 	    }
 	}
-
+	if (nocase) {
+	    TclStackFree(interp, u2lc);
+	}
+	TclStackFree(interp, mapLens);
+	TclStackFree(interp, mapStrings);
+    }
+    if (p != ustring1) {
 	/*
-	 * Take a copy of the source string object if it is the same as the
-	 * map string to cut out nasty sharing crashes. [Bug 1018562]
+	 * Put the rest of the unmapped chars onto result.
 	 */
 
-	if (objv[objc-2] == objv[objc-1]) {
-	    sourceObj = Tcl_DuplicateObj(objv[objc-1]);
-	    copySource = 1;
+	Tcl_AppendUnicodeToObj(resultPtr, p, ustring1 - p);
+    }
+    Tcl_SetObjResult(interp, resultPtr);
+  done:
+    if (mapWithDict) {
+	TclStackFree(interp, mapElemv);
+    }
+    if (copySource) {
+	Tcl_DecrRefCount(sourceObj);
+    }
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringMatchCmd --
+ *
+ *	This procedure is invoked to process the "string match" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+StringMatchCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    Tcl_UniChar *ustring1, *ustring2;
+    int length1, length2, nocase = 0;
+
+    if (objc < 3 || objc > 4) {
+	Tcl_WrongNumArgs(interp, 1, objv, "?-nocase? pattern string");
+	return TCL_ERROR;
+    }
+
+    if (objc == 4) {
+	const char *string = TclGetStringFromObj(objv[1], &length2);
+
+	if ((length2 > 1) &&
+	    strncmp(string, "-nocase", (size_t) length2) == 0) {
+	    nocase = 1;
 	} else {
-	    sourceObj = objv[objc-1];
+	    Tcl_AppendResult(interp, "bad option \"", string,
+		    "\": must be -nocase", NULL);
+	    return TCL_ERROR;
 	}
-	ustring1 = Tcl_GetUnicodeFromObj(sourceObj, &length1);
-	if (length1 == 0) {
+    }
+    ustring1 = Tcl_GetUnicodeFromObj(objv[objc-1], &length1);
+    ustring2 = Tcl_GetUnicodeFromObj(objv[objc-2], &length2);
+    Tcl_SetObjResult(interp, Tcl_NewBooleanObj(
+	    TclUniCharMatch(ustring1, length1, ustring2, length2, nocase)));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringRangeCmd --
+ *
+ *	This procedure is invoked to process the "string range" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+StringRangeCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    const unsigned char *string;
+    int length, first, last;
+
+    if (objc != 4) {
+	Tcl_WrongNumArgs(interp, 1, objv, "string first last");
+	return TCL_ERROR;
+    }
+
+    /*
+     * If we have a ByteArray object, avoid indexing in the Utf string since
+     * the byte array contains one byte per character. Otherwise, use the
+     * Unicode string rep to get the range.
+     */
+
+    if (objv[1]->typePtr == &tclByteArrayType) {
+	string = Tcl_GetByteArrayFromObj(objv[1], &length);
+	length--;
+    } else {
+	/*
+	 * Get the length in actual characters.
+	 */
+
+	string = NULL;
+	length = Tcl_GetCharLength(objv[1]) - 1;
+    }
+
+    if (TclGetIntForIndexM(interp, objv[2], length, &first) != TCL_OK ||
+	    TclGetIntForIndexM(interp, objv[3], length, &last) != TCL_OK) {
+	return TCL_ERROR;
+    }
+
+    if (first < 0) {
+	first = 0;
+    }
+    if (last >= length) {
+	last = length;
+    }
+    if (last >= first) {
+	if (string != NULL) {
 	    /*
-	     * Empty input string, just stop now.
+	     * Reread the string to prevent shimmering nasties.
 	     */
 
-	    if (mapWithDict) {
-		TclStackFree(interp, mapElemv);
-	    }
-	    if (copySource) {
-		Tcl_DecrRefCount(sourceObj);
-	    }
-	    break;
+	    string = Tcl_GetByteArrayFromObj(objv[1], &length);
+	    Tcl_SetObjResult(interp,
+		    Tcl_NewByteArrayObj(string+first, last - first + 1));
+	} else {
+	    Tcl_SetObjResult(interp, Tcl_GetRange(objv[1], first, last));
 	}
-	end = ustring1 + length1;
+    }
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringReptCmd --
+ *
+ *	This procedure is invoked to process the "string repeat" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
 
-	strCmpFn = (nocase ? Tcl_UniCharNcasecmp : Tcl_UniCharNcmp);
+static int
+StringReptCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    const char *string1;
+    char *string2;
+    int count, index, length1, length2;
+    Tcl_Obj *resultPtr;
+
+    if (objc != 3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "string count");
+	return TCL_ERROR;
+    }
 
+    if (TclGetIntFromObj(interp, objv[2], &count) != TCL_OK) {
+	return TCL_ERROR;
+    }
+
+    /*
+     * Check for cases that allow us to skip copying stuff.
+     */
+
+    if (count == 1) {
+	Tcl_SetObjResult(interp, objv[1]);
+	goto done;
+    } else if (count < 1) {
+	goto done;
+    }
+    string1 = TclGetStringFromObj(objv[1], &length1);
+    if (length1 <= 0) {
+	goto done;
+    }
+
+    /*
+     * Only build up a string that has data. Instead of building it up with
+     * repeated appends, we just allocate the necessary space once and copy
+     * the string value in. Check for overflow with back-division. [Bug
+     * #714106]
+     */
+
+    length2 = length1 * count + 1;
+    if ((length2-1) / count != length1) {
+	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+		"string size overflow, must be less than %d", INT_MAX));
+	return TCL_ERROR;
+    }
+
+    /*
+     * Include space for the NUL.
+     */
+
+    string2 = attemptckalloc((size_t) length2);
+    if (string2 == NULL) {
 	/*
-	 * Force result to be Unicode
+	 * Alloc failed. Note that in this case we try to do an error message
+	 * since this is a case that's most likely when the alloc is large and
+	 * that's easy to do with this API. Note that if we fail allocating a
+	 * short string, this will likely keel over too (and fatally).
 	 */
-	resultPtr = Tcl_NewUnicodeObj(ustring1, 0);
 
-	if (mapElemc == 2) {
-	    /*
-	     * Special case for one map pair which avoids the extra for loop
-	     * and extra calls to get Unicode data. The algorithm is otherwise
-	     * identical to the multi-pair case. This will be >30% faster on
-	     * larger strings.
-	     */
+	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+		"string size overflow, out of memory allocating %d bytes",
+		length2));
+	return TCL_ERROR;
+    }
+    for (index = 0; index < count; index++) {
+	memcpy(string2 + (length1 * index), string1, (size_t) length1);
+    }
+    string2[length2-1] = '\0';
 
-	    int mapLen;
-	    Tcl_UniChar *mapString, u2lc;
+    /*
+     * We have to directly assign this instead of using Tcl_SetStringObj (and
+     * indirectly TclInitStringRep) because that makes another copy of the
+     * data.
+     */
 
-	    ustring2 = Tcl_GetUnicodeFromObj(mapElemv[0], &length2);
-	    p = ustring1;
-	    if ((length2 > length1) || (length2 == 0)) {
-		/*
-		 * Match string is either longer than input or empty.
-		 */
+    TclNewObj(resultPtr);
+    resultPtr->bytes = string2;
+    resultPtr->length = length2-1;
+    Tcl_SetObjResult(interp, resultPtr);
 
-		ustring1 = end;
-	    } else {
-		mapString = Tcl_GetUnicodeFromObj(mapElemv[1], &mapLen);
-		u2lc = (nocase ? Tcl_UniCharToLower(*ustring2) : 0);
-		for (; ustring1 < end; ustring1++) {
-		    if (((*ustring1 == *ustring2) ||
-			    (nocase&&Tcl_UniCharToLower(*ustring1)==u2lc)) &&
-			    (length2==1 || strCmpFn(ustring1, ustring2,
-				    (unsigned long) length2) == 0)) {
-			if (p != ustring1) {
-			    Tcl_AppendUnicodeToObj(resultPtr, p, ustring1-p);
-			    p = ustring1 + length2;
-			} else {
-			    p += length2;
-			}
-			ustring1 = p - 1;
-
-			Tcl_AppendUnicodeToObj(resultPtr, mapString, mapLen);
-		    }
-		}
-	    }
-	} else {
-	    Tcl_UniChar **mapStrings, *u2lc = NULL;
-	    int *mapLens;
+  done:
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringRplcCmd --
+ *
+ *	This procedure is invoked to process the "string replace" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
 
-	    /*
-	     * Precompute pointers to the unicode string and length. This
-	     * saves us repeated function calls later, significantly speeding
-	     * up the algorithm. We only need the lowercase first char in the
-	     * nocase case.
-	     */
+static int
+StringRplcCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    Tcl_UniChar *ustring;
+    int first, last, length;
 
-	    mapStrings = (Tcl_UniChar **) TclStackAlloc(interp,
-		    (mapElemc * 2) * sizeof(Tcl_UniChar *));
-	    mapLens = (int *) TclStackAlloc(interp,
-		    (mapElemc * 2) * sizeof(int));
-	    if (nocase) {
-		u2lc = (Tcl_UniChar *) TclStackAlloc(interp,
-			(mapElemc) * sizeof(Tcl_UniChar));
-	    }
-	    for (index = 0; index < mapElemc; index++) {
-		mapStrings[index] = Tcl_GetUnicodeFromObj(mapElemv[index],
-			&(mapLens[index]));
-		if (nocase && ((index % 2) == 0)) {
-		    u2lc[index/2] = Tcl_UniCharToLower(*mapStrings[index]);
-		}
-	    }
-	    for (p = ustring1; ustring1 < end; ustring1++) {
-		for (index = 0; index < mapElemc; index += 2) {
-		    /*
-		     * Get the key string to match on.
-		     */
+    if (objc < 4 || objc > 5) {
+	Tcl_WrongNumArgs(interp, 1, objv, "string first last ?string?");
+	return TCL_ERROR;
+    }
 
-		    ustring2 = mapStrings[index];
-		    length2 = mapLens[index];
-		    if ((length2 > 0) && ((*ustring1 == *ustring2) ||
-			    (nocase && (Tcl_UniCharToLower(*ustring1) ==
-				    u2lc[index/2]))) &&
-			    /* Restrict max compare length. */
-			    ((end - ustring1) >= length2) &&
-			    ((length2 == 1) || strCmpFn(ustring2, ustring1,
-				    (unsigned long) length2) == 0)) {
-			if (p != ustring1) {
-			    /*
-			     * Put the skipped chars onto the result first.
-			     */
-
-			    Tcl_AppendUnicodeToObj(resultPtr, p, ustring1-p);
-			    p = ustring1 + length2;
-			} else {
-			    p += length2;
-			}
+    ustring = Tcl_GetUnicodeFromObj(objv[1], &length);
+    length--;
 
-			/*
-			 * Adjust len to be full length of matched string.
-			 */
+    if (TclGetIntForIndexM(interp, objv[2], length, &first) != TCL_OK ||
+	    TclGetIntForIndexM(interp, objv[3], length, &last) != TCL_OK){
+	return TCL_ERROR;
+    }
 
-			ustring1 = p - 1;
+    if ((last < first) || (last < 0) || (first > length)) {
+	Tcl_SetObjResult(interp, objv[1]);
+    } else {
+	Tcl_Obj *resultPtr;
 
-			/*
-			 * Append the map value to the unicode string.
-			 */
+	ustring = Tcl_GetUnicodeFromObj(objv[1], &length);
+	length--;
 
-			Tcl_AppendUnicodeToObj(resultPtr,
-				mapStrings[index+1], mapLens[index+1]);
-			break;
-		    }
-		}
-	    }
-	    if (nocase) {
-		TclStackFree(interp, u2lc);
-	    }
-	    TclStackFree(interp, mapLens);
-	    TclStackFree(interp, mapStrings);
+	if (first < 0) {
+	    first = 0;
 	}
-	if (p != ustring1) {
-	    /*
-	     * Put the rest of the unmapped chars onto result.
-	     */
 
-	    Tcl_AppendUnicodeToObj(resultPtr, p, ustring1 - p);
-	}
-	if (mapWithDict) {
-	    TclStackFree(interp, mapElemv);
+	resultPtr = Tcl_NewUnicodeObj(ustring, first);
+	if (objc == 5) {
+	    Tcl_AppendObjToObj(resultPtr, objv[4]);
 	}
-	if (copySource) {
-	    Tcl_DecrRefCount(sourceObj);
+	if (last < length) {
+	    Tcl_AppendUnicodeToObj(resultPtr, ustring + last + 1,
+		    length - last);
 	}
 	Tcl_SetObjResult(interp, resultPtr);
-	break;
     }
-    case STR_MATCH: {
-	Tcl_UniChar *ustring1, *ustring2;
-	int nocase = 0;
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringRevCmd --
+ *
+ *	This procedure is invoked to process the "string reverse" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
 
-	if (objc < 4 || objc > 5) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "?-nocase? pattern string");
-	    return TCL_ERROR;
+static int
+StringRevCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    if (objc != 2) {
+	Tcl_WrongNumArgs(interp, 1, objv, "string");
+	return TCL_ERROR;
+    }
+
+    Tcl_SetObjResult(interp, TclStringObjReverse(objv[1]));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringStartCmd --
+ *
+ *	This procedure is invoked to process the "string wordstart" Tcl
+ *	command. See the user documentation for details on what it does. Note
+ *	that this command only functions correctly on properly formed Tcl UTF
+ *	strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+StringStartCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    Tcl_UniChar ch;
+    const char *p, *string;
+    int cur, index, length, numChars;
+
+    if (objc != 3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "string index");
+	return TCL_ERROR;
+    }
+
+    string = TclGetStringFromObj(objv[1], &length);
+    numChars = Tcl_NumUtfChars(string, length);
+    if (TclGetIntForIndexM(interp, objv[2], numChars-1, &index) != TCL_OK) {
+	return TCL_ERROR;
+    }
+    string = TclGetStringFromObj(objv[1], &length);
+    if (index >= numChars) {
+	index = numChars - 1;
+    }
+    cur = 0;
+    if (index > 0) {
+	p = Tcl_UtfAtIndex(string, index);
+	for (cur = index; cur >= 0; cur--) {
+	    TclUtfToUniChar(p, &ch);
+	    if (!Tcl_UniCharIsWordChar(ch)) {
+		break;
+	    }
+	    p = Tcl_UtfPrev(p, string);
 	}
+	if (cur != index) {
+	    cur += 1;
+	}
+    }
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(cur));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringEndCmd --
+ *
+ *	This procedure is invoked to process the "string wordend" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
 
-	if (objc == 5) {
-	    string2 = TclGetStringFromObj(objv[2], &length2);
-	    if ((length2 > 1) &&
-		strncmp(string2, "-nocase", (size_t) length2) == 0) {
-		nocase = 1;
-	    } else {
-		Tcl_AppendResult(interp, "bad option \"", string2,
-			"\": must be -nocase", NULL);
-		return TCL_ERROR;
+static int
+StringEndCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    Tcl_UniChar ch;
+    const char *p, *end, *string;
+    int cur, index, length, numChars;
+
+    if (objc != 3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "string index");
+	return TCL_ERROR;
+    }
+
+    string = TclGetStringFromObj(objv[1], &length);
+    numChars = Tcl_NumUtfChars(string, length);
+    if (TclGetIntForIndexM(interp, objv[2], numChars-1, &index) != TCL_OK) {
+	return TCL_ERROR;
+    }
+    string = TclGetStringFromObj(objv[1], &length);
+    if (index < 0) {
+	index = 0;
+    }
+    if (index < numChars) {
+	p = Tcl_UtfAtIndex(string, index);
+	end = string+length;
+	for (cur = index; p < end; cur++) {
+	    p += TclUtfToUniChar(p, &ch);
+	    if (!Tcl_UniCharIsWordChar(ch)) {
+		break;
 	    }
 	}
-	ustring1 = Tcl_GetUnicodeFromObj(objv[objc-1], &length1);
-	ustring2 = Tcl_GetUnicodeFromObj(objv[objc-2], &length2);
-	Tcl_SetObjResult(interp, Tcl_NewBooleanObj(TclUniCharMatch(
-		ustring1, length1, ustring2, length2, nocase)));
-	break;
+	if (cur == index) {
+	    cur++;
+	}
+    } else {
+	cur = numChars;
     }
-    case STR_RANGE: {
-	int first, last;
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(cur));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringEqualCmd --
+ *
+ *	This procedure is invoked to process the "string equal" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+StringEqualCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    /*
+     * Remember to keep code here in some sync with the byte-compiled versions
+     * in tclExecute.c (INST_STR_EQ, INST_STR_NEQ and INST_STR_CMP as well as
+     * the expr string comparison in INST_EQ/INST_NEQ/INST_LT/...).
+     */
 
-	if (objc != 5) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "string first last");
+    char *string1, *string2;
+    int length1, length2, i, match, length, nocase = 0, reqlength = -1;
+    typedef int (*strCmpFn_t)(const char *, const char *, unsigned int);
+    strCmpFn_t strCmpFn;
+
+    if (objc < 3 || objc > 6) {
+    str_cmp_args:
+	Tcl_WrongNumArgs(interp, 1, objv,
+		"?-nocase? ?-length int? string1 string2");
+	return TCL_ERROR;
+    }
+
+    for (i = 1; i < objc-2; i++) {
+	string2 = TclGetStringFromObj(objv[i], &length2);
+	if ((length2 > 1) && !strncmp(string2, "-nocase", (size_t)length2)) {
+	    nocase = 1;
+	} else if ((length2 > 1)
+		&& !strncmp(string2, "-length", (size_t)length2)) {
+	    if (i+1 >= objc-2) {
+		goto str_cmp_args;
+	    }
+	    ++i;
+	    if (TclGetIntFromObj(interp, objv[i], &reqlength) != TCL_OK) {
+		return TCL_ERROR;
+	    }
+	} else {
+	    Tcl_AppendResult(interp, "bad option \"", string2,
+		    "\": must be -nocase or -length", NULL);
 	    return TCL_ERROR;
 	}
+    }
+
+    /*
+     * From now on, we only access the two objects at the end of the argument
+     * array.
+     */
+
+    objv += objc-2;
+
+    if ((reqlength == 0) || (objv[0] == objv[1])) {
+	/*
+	 * Always match at 0 chars of if it is the same obj.
+	 */
+
+	Tcl_SetObjResult(interp, Tcl_NewBooleanObj(1));
+	return TCL_OK;
+    }
+
+    if (!nocase && objv[0]->typePtr == &tclByteArrayType &&
+	    objv[1]->typePtr == &tclByteArrayType) {
+	/*
+	 * Use binary versions of comparisons since that won't cause undue
+	 * type conversions and it is much faster. Only do this if we're
+	 * case-sensitive (which is all that really makes sense with byte
+	 * arrays anyway, and we have no memcasecmp() for some reason... :^)
+	 */
 
+	string1 = (char *) Tcl_GetByteArrayFromObj(objv[0], &length1);
+	string2 = (char *) Tcl_GetByteArrayFromObj(objv[1], &length2);
+	strCmpFn = (strCmpFn_t) memcmp;
+    } else if ((objv[0]->typePtr == &tclStringType)
+	    && (objv[1]->typePtr == &tclStringType)) {
 	/*
-	 * If we have a ByteArray object, avoid indexing in the Utf string
-	 * since the byte array contains one byte per character. Otherwise,
-	 * use the Unicode string rep to get the range.
+	 * Do a unicode-specific comparison if both of the args are of String
+	 * type. In benchmark testing this proved the most efficient check
+	 * between the unicode and string comparison operations.
 	 */
 
-	if (objv[2]->typePtr == &tclByteArrayType) {
-	    string1 = (char *) Tcl_GetByteArrayFromObj(objv[2], &length1);
-	    length1--;
+	string1 = (char *) Tcl_GetUnicodeFromObj(objv[0], &length1);
+	string2 = (char *) Tcl_GetUnicodeFromObj(objv[1], &length2);
+	strCmpFn = (strCmpFn_t)
+		(nocase ? Tcl_UniCharNcasecmp : Tcl_UniCharNcmp);
+    } else {
+	/*
+	 * As a catch-all we will work with UTF-8. We cannot use memcmp() as
+	 * that is unsafe with any string containing NUL (\xC0\x80 in Tcl's
+	 * utf rep). We can use the more efficient TclpUtfNcmp2 if we are
+	 * case-sensitive and no specific length was requested.
+	 */
+
+	string1 = (char *) TclGetStringFromObj(objv[0], &length1);
+	string2 = (char *) TclGetStringFromObj(objv[1], &length2);
+	if ((reqlength < 0) && !nocase) {
+	    strCmpFn = (strCmpFn_t) TclpUtfNcmp2;
 	} else {
+	    length1 = Tcl_NumUtfChars(string1, length1);
+	    length2 = Tcl_NumUtfChars(string2, length2);
+	    strCmpFn = (strCmpFn_t) (nocase ? Tcl_UtfNcasecmp : Tcl_UtfNcmp);
+	}
+    }
+
+    if ((reqlength < 0) && (length1 != length2)) {
+	match = 1;		/* This will be reversed below. */
+    } else {
+	length = (length1 < length2) ? length1 : length2;
+	if (reqlength > 0 && reqlength < length) {
+	    length = reqlength;
+	} else if (reqlength < 0) {
 	    /*
-	     * Get the length in actual characters.
+	     * The requested length is negative, so we ignore it by setting it
+	     * to length + 1 so we correct the match var.
 	     */
 
-	    string1 = NULL;
-	    length1 = Tcl_GetCharLength(objv[2]) - 1;
+	    reqlength = length + 1;
+	}
+
+	match = strCmpFn(string1, string2, (unsigned) length);
+	if ((match == 0) && (reqlength > length)) {
+	    match = length1 - length2;
 	}
+    }
+
+    Tcl_SetObjResult(interp, Tcl_NewBooleanObj(match ? 0 : 1));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringCmpCmd --
+ *
+ *	This procedure is invoked to process the "string compare" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+StringCmpCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    /*
+     * Remember to keep code here in some sync with the byte-compiled versions
+     * in tclExecute.c (INST_STR_EQ, INST_STR_NEQ and INST_STR_CMP as well as
+     * the expr string comparison in INST_EQ/INST_NEQ/INST_LT/...).
+     */
+
+    char *string1, *string2;
+    int length1, length2, i, match, length, nocase = 0, reqlength = -1;
+    typedef int (*strCmpFn_t)(const char *, const char *, unsigned int);
+    strCmpFn_t strCmpFn;
+
+    if (objc < 3 || objc > 6) {
+    str_cmp_args:
+	Tcl_WrongNumArgs(interp, 1, objv,
+		"?-nocase? ?-length int? string1 string2");
+	return TCL_ERROR;
+    }
 
-	if (TclGetIntForIndexM(interp, objv[3], length1, &first) != TCL_OK ||
-		TclGetIntForIndexM(interp, objv[4], length1, &last) != TCL_OK) {
+    for (i = 1; i < objc-2; i++) {
+	string2 = TclGetStringFromObj(objv[i], &length2);
+	if ((length2 > 1) && !strncmp(string2, "-nocase", (size_t)length2)) {
+	    nocase = 1;
+	} else if ((length2 > 1)
+		&& !strncmp(string2, "-length", (size_t)length2)) {
+	    if (i+1 >= objc-2) {
+		goto str_cmp_args;
+	    }
+	    ++i;
+	    if (TclGetIntFromObj(interp, objv[i], &reqlength) != TCL_OK) {
+		return TCL_ERROR;
+	    }
+	} else {
+	    Tcl_AppendResult(interp, "bad option \"", string2,
+		    "\": must be -nocase or -length", NULL);
 	    return TCL_ERROR;
 	}
+    }
+
+    /*
+     * From now on, we only access the two objects at the end of the argument
+     * array.
+     */
+
+    objv += objc-2;
+
+    if ((reqlength == 0) || (objv[0] == objv[1])) {
+	/*
+	 * Always match at 0 chars of if it is the same obj.
+	 */
+
+	Tcl_SetObjResult(interp, Tcl_NewBooleanObj(0));
+	return TCL_OK;
+    }
+
+    if (!nocase && objv[0]->typePtr == &tclByteArrayType &&
+	    objv[1]->typePtr == &tclByteArrayType) {
+	/*
+	 * Use binary versions of comparisons since that won't cause undue
+	 * type conversions and it is much faster. Only do this if we're
+	 * case-sensitive (which is all that really makes sense with byte
+	 * arrays anyway, and we have no memcasecmp() for some reason... :^)
+	 */
+
+	string1 = (char *) Tcl_GetByteArrayFromObj(objv[0], &length1);
+	string2 = (char *) Tcl_GetByteArrayFromObj(objv[1], &length2);
+	strCmpFn = (strCmpFn_t) memcmp;
+    } else if ((objv[0]->typePtr == &tclStringType)
+	    && (objv[1]->typePtr == &tclStringType)) {
+	/*
+	 * Do a unicode-specific comparison if both of the args are of String
+	 * type. In benchmark testing this proved the most efficient check
+	 * between the unicode and string comparison operations.
+	 */
+
+	string1 = (char *) Tcl_GetUnicodeFromObj(objv[0], &length1);
+	string2 = (char *) Tcl_GetUnicodeFromObj(objv[1], &length2);
+	strCmpFn = (strCmpFn_t)
+		(nocase ? Tcl_UniCharNcasecmp : Tcl_UniCharNcmp);
+    } else {
+	/*
+	 * As a catch-all we will work with UTF-8. We cannot use memcmp() as
+	 * that is unsafe with any string containing NUL (\xC0\x80 in Tcl's
+	 * utf rep). We can use the more efficient TclpUtfNcmp2 if we are
+	 * case-sensitive and no specific length was requested.
+	 */
+
+	string1 = (char *) TclGetStringFromObj(objv[0], &length1);
+	string2 = (char *) TclGetStringFromObj(objv[1], &length2);
+	if ((reqlength < 0) && !nocase) {
+	    strCmpFn = (strCmpFn_t) TclpUtfNcmp2;
+	} else {
+	    length1 = Tcl_NumUtfChars(string1, length1);
+	    length2 = Tcl_NumUtfChars(string2, length2);
+	    strCmpFn = (strCmpFn_t) (nocase ? Tcl_UtfNcasecmp : Tcl_UtfNcmp);
+	}
+    }
+
+    length = (length1 < length2) ? length1 : length2;
+    if (reqlength > 0 && reqlength < length) {
+	length = reqlength;
+    } else if (reqlength < 0) {
+	/*
+	 * The requested length is negative, so we ignore it by setting it to
+	 * length + 1 so we correct the match var.
+	 */
+
+	reqlength = length + 1;
+    }
+
+    match = strCmpFn(string1, string2, (unsigned) length);
+    if ((match == 0) && (reqlength > length)) {
+	match = length1 - length2;
+    }
+
+    Tcl_SetObjResult(interp,
+	    Tcl_NewIntObj((match > 0) ? 1 : (match < 0) ? -1 : 0));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringBytesCmd --
+ *
+ *	This procedure is invoked to process the "string bytelength" Tcl
+ *	command. See the user documentation for details on what it does. Note
+ *	that this command only functions correctly on properly formed Tcl UTF
+ *	strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+StringBytesCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    int length;
+
+    if (objc != 2) {
+	Tcl_WrongNumArgs(interp, 1, objv, "string");
+	return TCL_ERROR;
+    }
+
+    (void) TclGetStringFromObj(objv[1], &length);
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(length));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringLenCmd --
+ *
+ *	This procedure is invoked to process the "string length" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+StringLenCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    int length;
+
+    if (objc != 2) {
+	Tcl_WrongNumArgs(interp, 1, objv, "string");
+	return TCL_ERROR;
+    }
+
+    /*
+     * If we have a ByteArray object, avoid recomputing the string since the
+     * byte array contains one byte per character. Otherwise, use the Unicode
+     * string rep to calculate the length.
+     */
+
+    if (objv[1]->typePtr == &tclByteArrayType) {
+	(void) Tcl_GetByteArrayFromObj(objv[1], &length);
+    } else {
+	length = Tcl_GetCharLength(objv[1]);
+    }
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(length));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringLowerCmd --
+ *
+ *	This procedure is invoked to process the "string tolower" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+StringLowerCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    int length1, length2;
+    char *string1, *string2;
+
+    if (objc < 2 || objc > 4) {
+	Tcl_WrongNumArgs(interp, 1, objv, "string ?first? ?last?");
+	return TCL_ERROR;
+    }
+
+    string1 = TclGetStringFromObj(objv[1], &length1);
+
+    if (objc == 2) {
+	Tcl_Obj *resultPtr = Tcl_NewStringObj(string1, length1);
 
+	length1 = Tcl_UtfToLower(TclGetString(resultPtr));
+	Tcl_SetObjLength(resultPtr, length1);
+	Tcl_SetObjResult(interp, resultPtr);
+    } else {
+	int first, last;
+	const char *start, *end;
+	Tcl_Obj *resultPtr;
+
+	length1 = Tcl_NumUtfChars(string1, length1) - 1;
+	if (TclGetIntForIndexM(interp,objv[2],length1, &first) != TCL_OK) {
+	    return TCL_ERROR;
+	}
 	if (first < 0) {
 	    first = 0;
 	}
+	last = first;
+
+	if ((objc == 4) && (TclGetIntForIndexM(interp, objv[3], length1,
+		&last) != TCL_OK)) {
+	    return TCL_ERROR;
+	}
+
 	if (last >= length1) {
 	    last = length1;
 	}
-	if (last >= first) {
-	    if (string1 != NULL) {
-		int numBytes = last - first + 1;
-		Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(
-			(unsigned char *) &string1[first], numBytes));
-	    } else {
-		Tcl_SetObjResult(interp,
-			Tcl_GetRange(objv[2], first, last));
-	    }
+	if (last < first) {
+	    Tcl_SetObjResult(interp, objv[1]);
+	    return TCL_OK;
 	}
-	break;
+
+	string1 = TclGetStringFromObj(objv[1], &length1);
+	start = Tcl_UtfAtIndex(string1, first);
+	end = Tcl_UtfAtIndex(start, last - first + 1);
+	resultPtr = Tcl_NewStringObj(string1, end - string1);
+	string2 = TclGetString(resultPtr) + (start - string1);
+
+	length2 = Tcl_UtfToLower(string2);
+	Tcl_SetObjLength(resultPtr, length2 + (start - string1));
+
+	Tcl_AppendToObj(resultPtr, end, -1);
+	Tcl_SetObjResult(interp, resultPtr);
     }
-    case STR_REPEAT: {
-	int count;
 
-	if (objc != 4) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "string count");
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringUpperCmd --
+ *
+ *	This procedure is invoked to process the "string toupper" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+StringUpperCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    int length1, length2;
+    char *string1, *string2;
+
+    if (objc < 2 || objc > 4) {
+	Tcl_WrongNumArgs(interp, 1, objv, "string ?first? ?last?");
+	return TCL_ERROR;
+    }
+
+    string1 = TclGetStringFromObj(objv[1], &length1);
+
+    if (objc == 2) {
+	Tcl_Obj *resultPtr = Tcl_NewStringObj(string1, length1);
+
+	length1 = Tcl_UtfToUpper(TclGetString(resultPtr));
+	Tcl_SetObjLength(resultPtr, length1);
+	Tcl_SetObjResult(interp, resultPtr);
+    } else {
+	int first, last;
+	const char *start, *end;
+	Tcl_Obj *resultPtr;
+
+	length1 = Tcl_NumUtfChars(string1, length1) - 1;
+	if (TclGetIntForIndexM(interp,objv[2],length1, &first) != TCL_OK) {
 	    return TCL_ERROR;
 	}
+	if (first < 0) {
+	    first = 0;
+	}
+	last = first;
 
-	if (TclGetIntFromObj(interp, objv[3], &count) != TCL_OK) {
+	if ((objc == 4) && (TclGetIntForIndexM(interp, objv[3], length1,
+		&last) != TCL_OK)) {
 	    return TCL_ERROR;
 	}
 
-	if (count == 1) {
-	    Tcl_SetObjResult(interp, objv[2]);
-	} else if (count > 1) {
-	    string1 = TclGetStringFromObj(objv[2], &length1);
-	    if (length1 > 0) {
-		/*
-		 * Only build up a string that has data. Instead of building
-		 * it up with repeated appends, we just allocate the necessary
-		 * space once and copy the string value in. Check for overflow
-		 * with back-division. [Bug #714106]
-		 */
+	if (last >= length1) {
+	    last = length1;
+	}
+	if (last < first) {
+	    Tcl_SetObjResult(interp, objv[1]);
+	    return TCL_OK;
+	}
 
-		Tcl_Obj *resultPtr;
+	string1 = TclGetStringFromObj(objv[1], &length1);
+	start = Tcl_UtfAtIndex(string1, first);
+	end = Tcl_UtfAtIndex(start, last - first + 1);
+	resultPtr = Tcl_NewStringObj(string1, end - string1);
+	string2 = TclGetString(resultPtr) + (start - string1);
 
-		length2 = length1 * count;
-		if ((length2 / count) != length1) {
-		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-			    "string size overflow, must be less than %d",
-			    INT_MAX));
-		    return TCL_ERROR;
-		}
+	length2 = Tcl_UtfToUpper(string2);
+	Tcl_SetObjLength(resultPtr, length2 + (start - string1));
 
-		/*
-		 * Include space for the NULL.
-		 */
+	Tcl_AppendToObj(resultPtr, end, -1);
+	Tcl_SetObjResult(interp, resultPtr);
+    }
 
-		string2 = (char *) ckalloc((size_t) length2+1);
-		for (index = 0; index < count; index++) {
-		    memcpy(string2 + (length1 * index), string1,
-			    (size_t) length1);
-		}
-		string2[length2] = '\0';
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringTitleCmd --
+ *
+ *	This procedure is invoked to process the "string totitle" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
 
-		/*
-		 * We have to directly assign this instead of using
-		 * Tcl_SetStringObj (and indirectly TclInitStringRep) because
-		 * that makes another copy of the data.
-		 */
+static int
+StringTitleCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    int length1, length2;
+    char *string1, *string2;
 
-		TclNewObj(resultPtr);
-		resultPtr->bytes = string2;
-		resultPtr->length = length2;
-		Tcl_SetObjResult(interp, resultPtr);
-	    }
-	}
-	break;
+    if (objc < 2 || objc > 4) {
+	Tcl_WrongNumArgs(interp, 1, objv, "string ?first? ?last?");
+	return TCL_ERROR;
     }
-    case STR_REPLACE: {
-	Tcl_UniChar *ustring1;
+
+    string1 = TclGetStringFromObj(objv[1], &length1);
+
+    if (objc == 2) {
+	Tcl_Obj *resultPtr = Tcl_NewStringObj(string1, length1);
+
+	length1 = Tcl_UtfToTitle(TclGetString(resultPtr));
+	Tcl_SetObjLength(resultPtr, length1);
+	Tcl_SetObjResult(interp, resultPtr);
+    } else {
 	int first, last;
+	const char *start, *end;
+	Tcl_Obj *resultPtr;
 
-	if (objc < 5 || objc > 6) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "string first last ?string?");
+	length1 = Tcl_NumUtfChars(string1, length1) - 1;
+	if (TclGetIntForIndexM(interp,objv[2],length1, &first) != TCL_OK) {
 	    return TCL_ERROR;
 	}
+	if (first < 0) {
+	    first = 0;
+	}
+	last = first;
 
-	ustring1 = Tcl_GetUnicodeFromObj(objv[2], &length1);
-	length1--;
-
-	if (TclGetIntForIndexM(interp, objv[3], length1, &first) != TCL_OK ||
-		TclGetIntForIndexM(interp, objv[4], length1, &last) != TCL_OK){
+	if ((objc == 4) && (TclGetIntForIndexM(interp, objv[3], length1,
+		&last) != TCL_OK)) {
 	    return TCL_ERROR;
 	}
 
-	if ((last < first) || (last < 0) || (first > length1)) {
-	    Tcl_SetObjResult(interp, objv[2]);
-	} else {
-	    Tcl_Obj *resultPtr;
-	    if (first < 0) {
-		first = 0;
-	    }
-
-	    resultPtr = Tcl_NewUnicodeObj(ustring1, first);
-	    if (objc == 6) {
-		Tcl_AppendObjToObj(resultPtr, objv[5]);
-	    }
-	    if (last < length1) {
-		Tcl_AppendUnicodeToObj(resultPtr, ustring1 + last + 1,
-			length1 - last);
-	    }
-	    Tcl_SetObjResult(interp, resultPtr);
+	if (last >= length1) {
+	    last = length1;
 	}
-	break;
-    }
-    case STR_REVERSE: {
-	if (objc != 3) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "string");
-	    return TCL_ERROR;
+	if (last < first) {
+	    Tcl_SetObjResult(interp, objv[1]);
+	    return TCL_OK;
 	}
 
-	Tcl_SetObjResult(interp, TclStringObjReverse(objv[2]));
-	break;
+	string1 = TclGetStringFromObj(objv[1], &length1);
+	start = Tcl_UtfAtIndex(string1, first);
+	end = Tcl_UtfAtIndex(start, last - first + 1);
+	resultPtr = Tcl_NewStringObj(string1, end - string1);
+	string2 = TclGetString(resultPtr) + (start - string1);
+
+	length2 = Tcl_UtfToTitle(string2);
+	Tcl_SetObjLength(resultPtr, length2 + (start - string1));
+
+	Tcl_AppendToObj(resultPtr, end, -1);
+	Tcl_SetObjResult(interp, resultPtr);
     }
-    case STR_TOLOWER:
-    case STR_TOUPPER:
-    case STR_TOTITLE:
-	if (objc < 3 || objc > 5) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "string ?first? ?last?");
-	    return TCL_ERROR;
-	}
 
-	string1 = TclGetStringFromObj(objv[2], &length1);
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringTrimCmd --
+ *
+ *	This procedure is invoked to process the "string trim" Tcl command.
+ *	See the user documentation for details on what it does. Note that this
+ *	command only functions correctly on properly formed Tcl UTF strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
 
-	if (objc == 3) {
-	    Tcl_Obj *resultPtr = Tcl_NewStringObj(string1, length1);
-	    if ((enum options) index == STR_TOLOWER) {
-		length1 = Tcl_UtfToLower(TclGetString(resultPtr));
-	    } else if ((enum options) index == STR_TOUPPER) {
-		length1 = Tcl_UtfToUpper(TclGetString(resultPtr));
-	    } else {
-		length1 = Tcl_UtfToTitle(TclGetString(resultPtr));
-	    }
-	    Tcl_SetObjLength(resultPtr, length1);
-	    Tcl_SetObjResult(interp, resultPtr);
-	} else {
-	    int first, last;
-	    CONST char *start, *end;
-	    Tcl_Obj *resultPtr;
+static int
+StringTrimCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    Tcl_UniChar ch, trim;
+    register const char *p, *end;
+    const char *check, *checkEnd, *string1, *string2;
+    int offset, length1, length2;
+
+    if (objc == 3) {
+	string2 = TclGetStringFromObj(objv[2], &length2);
+    } else if (objc == 2) {
+	string2 = " \t\n\r";
+	length2 = strlen(string2);
+    } else {
+	Tcl_WrongNumArgs(interp, 1, objv, "string ?chars?");
+	return TCL_ERROR;
+    }
+    string1 = TclGetStringFromObj(objv[1], &length1);
+    checkEnd = string2 + length2;
 
-	    length1 = Tcl_NumUtfChars(string1, length1) - 1;
-	    if (TclGetIntForIndexM(interp,objv[3],length1, &first) != TCL_OK) {
-		return TCL_ERROR;
-	    }
-	    if (first < 0) {
-		first = 0;
-	    }
-	    last = first;
+    /*
+     * The outer loop iterates over the string. The inner loop iterates over
+     * the trim characters. The loops terminate as soon as a non-trim
+     * character is discovered and string1 is left pointing at the first
+     * non-trim character.
+     */
 
-	    if ((objc == 5) && (TclGetIntForIndexM(interp, objv[4], length1,
-		    &last) != TCL_OK)) {
-		return TCL_ERROR;
-	    }
+    end = string1 + length1;
+    for (p = string1; p < end; p += offset) {
+	offset = TclUtfToUniChar(p, &ch);
 
-	    if (last >= length1) {
-		last = length1;
+	for (check = string2; ; ) {
+	    if (check >= checkEnd) {
+		p = end;
+		break;
 	    }
-	    if (last < first) {
-		Tcl_SetObjResult(interp, objv[2]);
+	    check += TclUtfToUniChar(check, &trim);
+	    if (ch == trim) {
+		length1 -= offset;
+		string1 += offset;
 		break;
 	    }
+	}
+    }
 
-	    start = Tcl_UtfAtIndex(string1, first);
-	    end = Tcl_UtfAtIndex(start, last - first + 1);
-	    resultPtr = Tcl_NewStringObj(string1, end - string1);
-	    string2 = TclGetString(resultPtr) + (start - string1);
+    /*
+     * The outer loop iterates over the string. The inner loop iterates over
+     * the trim characters. The loops terminate as soon as a non-trim
+     * character is discovered and length1 marks the last non-trim character.
+     */
 
-	    if ((enum options) index == STR_TOLOWER) {
-		length2 = Tcl_UtfToLower(string2);
-	    } else if ((enum options) index == STR_TOUPPER) {
-		length2 = Tcl_UtfToUpper(string2);
-	    } else {
-		length2 = Tcl_UtfToTitle(string2);
+    end = string1;
+    for (p = string1 + length1; p > end; ) {
+	p = Tcl_UtfPrev(p, string1);
+	offset = TclUtfToUniChar(p, &ch);
+	check = string2;
+	while (1) {
+	    if (check >= checkEnd) {
+		p = end;
+		break;
+	    }
+	    check += TclUtfToUniChar(check, &trim);
+	    if (ch == trim) {
+		length1 -= offset;
+		break;
 	    }
-	    Tcl_SetObjLength(resultPtr, length2 + (start - string1));
-
-	    Tcl_AppendToObj(resultPtr, end, -1);
-	    Tcl_SetObjResult(interp, resultPtr);
-	}
-	break;
-
-    case STR_TRIMLEFT:
-	left = 1;
-	right = 0;
-	goto dotrim;
-    case STR_TRIMRIGHT:
-	left = 0;
-	right = 1;
-	goto dotrim;
-    case STR_TRIM: {
-	Tcl_UniChar ch, trim;
-	register CONST char *p, *end;
-	char *check, *checkEnd;
-	int offset;
-
-	left = 1;
-	right = 1;
-
-    dotrim:
-	if (objc == 4) {
-	    string2 = TclGetStringFromObj(objv[3], &length2);
-	} else if (objc == 3) {
-	    string2 = " \t\n\r";
-	    length2 = strlen(string2);
-	} else {
-	    Tcl_WrongNumArgs(interp, 2, objv, "string ?chars?");
-	    return TCL_ERROR;
 	}
-	string1 = TclGetStringFromObj(objv[2], &length1);
-	checkEnd = string2 + length2;
+    }
 
-	if (left) {
-	    end = string1 + length1;
-	    /*
-	     * The outer loop iterates over the string. The inner loop
-	     * iterates over the trim characters. The loops terminate as soon
-	     * as a non-trim character is discovered and string1 is left
-	     * pointing at the first non-trim character.
-	     */
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(string1, length1));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringTrimLCmd --
+ *
+ *	This procedure is invoked to process the "string trimleft" Tcl
+ *	command. See the user documentation for details on what it does. Note
+ *	that this command only functions correctly on properly formed Tcl UTF
+ *	strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
 
-	    for (p = string1; p < end; p += offset) {
-		offset = TclUtfToUniChar(p, &ch);
+static int
+StringTrimLCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    Tcl_UniChar ch, trim;
+    register const char *p, *end;
+    const char *check, *checkEnd, *string1, *string2;
+    int offset, length1, length2;
+
+    if (objc == 3) {
+	string2 = TclGetStringFromObj(objv[2], &length2);
+    } else if (objc == 2) {
+	string2 = " \t\n\r";
+	length2 = strlen(string2);
+    } else {
+	Tcl_WrongNumArgs(interp, 1, objv, "string ?chars?");
+	return TCL_ERROR;
+    }
+    string1 = TclGetStringFromObj(objv[1], &length1);
+    checkEnd = string2 + length2;
 
-		for (check = string2; ; ) {
-		    if (check >= checkEnd) {
-			p = end;
-			break;
-		    }
-		    check += TclUtfToUniChar(check, &trim);
-		    if (ch == trim) {
-			length1 -= offset;
-			string1 += offset;
-			break;
-		    }
-		}
-	    }
-	}
-	if (right) {
-	    end = string1;
+    /*
+     * The outer loop iterates over the string. The inner loop iterates over
+     * the trim characters. The loops terminate as soon as a non-trim
+     * character is discovered and string1 is left pointing at the first
+     * non-trim character.
+     */
 
-	    /*
-	     * The outer loop iterates over the string. The inner loop
-	     * iterates over the trim characters. The loops terminate as soon
-	     * as a non-trim character is discovered and length1 marks the
-	     * last non-trim character.
-	     */
+    end = string1 + length1;
+    for (p = string1; p < end; p += offset) {
+	offset = TclUtfToUniChar(p, &ch);
 
-	    for (p = string1 + length1; p > end; ) {
-		p = Tcl_UtfPrev(p, string1);
-		offset = TclUtfToUniChar(p, &ch);
-		check = string2;
-		while (1) {
-		    if (check >= checkEnd) {
-			p = end;
-			break;
-		    }
-		    check += TclUtfToUniChar(check, &trim);
-		    if (ch == trim) {
-			length1 -= offset;
-			break;
-		    }
-		}
+	for (check = string2; ; ) {
+	    if (check >= checkEnd) {
+		p = end;
+		break;
+	    }
+	    check += TclUtfToUniChar(check, &trim);
+	    if (ch == trim) {
+		length1 -= offset;
+		string1 += offset;
+		break;
 	    }
 	}
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(string1, length1));
-	break;
     }
-    case STR_WORDEND: {
-	int cur;
-	Tcl_UniChar ch;
-	CONST char *p, *end;
-	int numChars;
 
-	if (objc != 4) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "string index");
-	    return TCL_ERROR;
-	}
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(string1, length1));
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * StringTrimRCmd --
+ *
+ *	This procedure is invoked to process the "string trimright" Tcl
+ *	command. See the user documentation for details on what it does. Note
+ *	that this command only functions correctly on properly formed Tcl UTF
+ *	strings.
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
 
-	string1 = TclGetStringFromObj(objv[2], &length1);
-	numChars = Tcl_NumUtfChars(string1, length1);
-	if (TclGetIntForIndexM(interp, objv[3], numChars-1, &index) != TCL_OK){
-	    return TCL_ERROR;
-	}
-	if (index < 0) {
-	    index = 0;
-	}
-	if (index < numChars) {
-	    p = Tcl_UtfAtIndex(string1, index);
-	    end = string1+length1;
-	    for (cur = index; p < end; cur++) {
-		p += TclUtfToUniChar(p, &ch);
-		if (!Tcl_UniCharIsWordChar(ch)) {
-		    break;
-		}
-	    }
-	    if (cur == index) {
-		cur++;
-	    }
-	} else {
-	    cur = numChars;
-	}
-	Tcl_SetObjResult(interp, Tcl_NewIntObj(cur));
-	break;
+static int
+StringTrimRCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    Tcl_UniChar ch, trim;
+    register const char *p, *end;
+    const char *check, *checkEnd, *string1, *string2;
+    int offset, length1, length2;
+
+    if (objc == 3) {
+	string2 = TclGetStringFromObj(objv[2], &length2);
+    } else if (objc == 2) {
+	string2 = " \t\n\r";
+	length2 = strlen(string2);
+    } else {
+	Tcl_WrongNumArgs(interp, 1, objv, "string ?chars?");
+	return TCL_ERROR;
     }
-    case STR_WORDSTART: {
-	int cur;
-	Tcl_UniChar ch;
-	CONST char *p;
-	int numChars;
+    string1 = TclGetStringFromObj(objv[1], &length1);
+    checkEnd = string2 + length2;
 
-	if (objc != 4) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "string index");
-	    return TCL_ERROR;
-	}
+    /*
+     * The outer loop iterates over the string. The inner loop iterates over
+     * the trim characters. The loops terminate as soon as a non-trim
+     * character is discovered and length1 marks the last non-trim character.
+     */
 
-	string1 = TclGetStringFromObj(objv[2], &length1);
-	numChars = Tcl_NumUtfChars(string1, length1);
-	if (TclGetIntForIndexM(interp, objv[3], numChars-1, &index) != TCL_OK){
-	    return TCL_ERROR;
-	}
-	if (index >= numChars) {
-	    index = numChars - 1;
-	}
-	cur = 0;
-	if (index > 0) {
-	    p = Tcl_UtfAtIndex(string1, index);
-	    for (cur = index; cur >= 0; cur--) {
-		TclUtfToUniChar(p, &ch);
-		if (!Tcl_UniCharIsWordChar(ch)) {
-		    break;
-		}
-		p = Tcl_UtfPrev(p, string1);
+    end = string1;
+    for (p = string1 + length1; p > end; ) {
+	p = Tcl_UtfPrev(p, string1);
+	offset = TclUtfToUniChar(p, &ch);
+	check = string2;
+	while (1) {
+	    if (check >= checkEnd) {
+		p = end;
+		break;
 	    }
-	    if (cur != index) {
-		cur += 1;
+	    check += TclUtfToUniChar(check, &trim);
+	    if (ch == trim) {
+		length1 -= offset;
+		break;
 	    }
 	}
-	Tcl_SetObjResult(interp, Tcl_NewIntObj(cur));
-	break;
-    }
     }
+
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(string1, length1));
     return TCL_OK;
 }
 
-static int
-UniCharIsAscii(
-    int character)
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclInitStringCmd --
+ *
+ *	This procedure creates the "string" Tcl command. See the user
+ *	documentation for details on what it does. Note that this command only
+ *	functions correctly on properly formed Tcl UTF strings.
+ *
+ *	Also note that the primary methods here (equal, compare, match, ...)
+ *	have bytecode equivalents. You will find the code for those in
+ *	tclExecute.c. The code here will only be used in the non-bc case (like
+ *	in an 'eval').
+ *
+ * Results:
+ *	A standard Tcl result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_Command
+TclInitStringCmd(
+    Tcl_Interp *interp)		/* Current interpreter. */
 {
-    return (character >= 0) && (character < 0x80);
+    static const EnsembleImplMap stringImplMap[] = {
+	{"bytelength",	StringBytesCmd,	NULL},
+	{"compare",	StringCmpCmd,	TclCompileStringCmpCmd},
+	{"equal",	StringEqualCmd,	TclCompileStringEqualCmd},
+	{"first",	StringFirstCmd,	NULL},
+	{"index",	StringIndexCmd,	TclCompileStringIndexCmd},
+	{"is",		StringIsCmd,	NULL},
+	{"last",	StringLastCmd,	NULL},
+	{"length",	StringLenCmd,	TclCompileStringLenCmd},
+	{"map",		StringMapCmd,	NULL},
+	{"match",	StringMatchCmd,	TclCompileStringMatchCmd},
+	{"range",	StringRangeCmd,	NULL},
+	{"repeat",	StringReptCmd,	NULL},
+	{"replace",	StringRplcCmd,	NULL},
+	{"reverse",	StringRevCmd,	NULL},
+	{"tolower",	StringLowerCmd,	NULL},
+	{"toupper",	StringUpperCmd,	NULL},
+	{"totitle",	StringTitleCmd,	NULL},
+	{"trim",	StringTrimCmd,	NULL},
+	{"trimleft",	StringTrimLCmd,	NULL},
+	{"trimright",	StringTrimRCmd,	NULL},
+	{"wordend",	StringEndCmd,	NULL},
+	{"wordstart",	StringStartCmd,	NULL},
+	{NULL}
+    };
+
+    return TclMakeEnsemble(interp, "string", stringImplMap);
 }
 
 /*
@@ -2477,7 +3363,7 @@ Tcl_SubstObjCmd(
 	SUBST_NOBACKSLASHES, SUBST_NOCOMMANDS, SUBST_NOVARS
     };
     Tcl_Obj *resultPtr;
-    int optionIndex, flags, i;
+    int flags, i;
 
     /*
      * Parse command-line options.
@@ -2485,6 +3371,8 @@ Tcl_SubstObjCmd(
 
     flags = TCL_SUBST_ALL;
     for (i = 1; i < (objc-1); i++) {
+	int optionIndex;
+
 	if (Tcl_GetIndexFromObj(interp, objv[i], substOptions, "switch", 0,
 		&optionIndex) != TCL_OK) {
 	    return TCL_ERROR;
@@ -2503,7 +3391,7 @@ Tcl_SubstObjCmd(
 	    Tcl_Panic("Tcl_SubstObjCmd: bad option index to SubstOptions");
 	}
     }
-    if (i != (objc-1)) {
+    if (i != objc-1) {
 	Tcl_WrongNumArgs(interp, 1, objv,
 		"?-nobackslashes? ?-nocommands? ?-novariables? string");
 	return TCL_ERROR;
diff --git a/generic/tclCompCmds.c b/generic/tclCompCmds.c
index d9314f8..4d01c44 100644
--- a/generic/tclCompCmds.c
+++ b/generic/tclCompCmds.c
@@ -12,7 +12,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclCompCmds.c,v 1.109.2.12 2007/11/21 06:30:49 dgp Exp $
+ * RCS: @(#) $Id: tclCompCmds.c,v 1.109.2.13 2007/11/25 06:45:44 dgp Exp $
  */
 
 #include "tclInt.h"
@@ -588,24 +588,43 @@ TclCompileContinueCmd(
 /*
  *----------------------------------------------------------------------
  *
- * TclCompileDictCmd --
+ * TclCompileDict*Cmd --
  *
- *	Procedure called to compile the "dict" command.
+ *	Functions called to compile "dict" sucommands.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
+ * 	All return TCL_OK for a successful compile, and TCL_ERROR to defer
  * 	evaluation to runtime.
  *
  * Side effects:
- *	Instructions are added to envPtr to execute the "dict" command at
+ *	Instructions are added to envPtr to execute the "dict" subcommand at
  *	runtime.
  *
+ * Notes:
+ *	The following commands are in fairly common use and are possibly worth
+ *	bytecoding:
+ *		dict append
+ *		dict create	[*]
+ *		dict exists	[*]
+ *		dict for
+ *		dict get	[*]
+ *		dict incr
+ *		dict keys	[*]
+ *		dict lappend
+ *		dict set
+ *		dict unset
+ *
+ *	In practice, those that are pure-value operators (marked with [*]) can
+ *	probably be left alone (except perhaps [dict get] which is very very
+ *	common) and [dict update] should be considered instead (really big
+ *	win!)
+ *
  *----------------------------------------------------------------------
  */
 
 int
-TclCompileDictCmd(
-    Tcl_Interp *interp,		/* Used for error reporting. */
+TclCompileDictSetCmd(
+    Tcl_Interp *interp,		/* Used for looking up stuff. */
     Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
 				 * created by Tcl_ParseCommand. */
     Command *cmdPtr,		/* Points to defintion of command being
@@ -613,496 +632,638 @@ TclCompileDictCmd(
     CompileEnv *envPtr)		/* Holds resulting instructions. */
 {
     Tcl_Token *tokenPtr;
-    int numWords, size, i;
-    const char *cmd;
+    int numWords, i;
     Proc *procPtr = envPtr->procPtr;
     DefineLineInformation;	/* TIP #280 */
+    Tcl_Token *varTokenPtr;
+    int dictVarIndex, nameChars;
+    const char *name;
 
     /*
      * There must be at least one argument after the command.
      */
 
-    if (parsePtr->numWords < 2) {
+    if (parsePtr->numWords < 4 || procPtr == NULL) {
 	return TCL_ERROR;
     }
 
-    tokenPtr = TokenAfter(parsePtr->tokenPtr);
-    numWords = parsePtr->numWords-2;
-    if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+    /*
+     * The dictionary variable must be a local scalar that is knowable at
+     * compile time; anything else exceeds the complexity of the opcode. So
+     * discover what the index is.
+     */
+
+    varTokenPtr = TokenAfter(parsePtr->tokenPtr);
+    if (varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
 	return TCL_ERROR;
     }
+    name = varTokenPtr[1].start;
+    nameChars = varTokenPtr[1].size;
+    if (!TclIsLocalScalar(name, nameChars)) {
+	return TCL_ERROR;
+    }
+    dictVarIndex = TclFindCompiledLocal(name, nameChars, 1, procPtr);
 
     /*
-     * The following commands are in fairly common use and are possibly worth
-     * bytecoding:
-     *     dict append
-     *     dict create	[*]
-     *     dict exists	[*]
-     *     dict for
-     *     dict get	[*]
-     *     dict incr
-     *     dict keys	[*]
-     *     dict lappend
-     *     dict set
-     *     dict unset
-     * In practice, those that are pure-value operators (marked with [*]) can
-     * probably be left alone (except perhaps [dict get] which is very very
-     * common) and [dict update] should be considered instead (really big
-     * win!)
-     */
-
-    size = tokenPtr[1].size;
-    cmd = tokenPtr[1].start;
-    if (size==3 && strncmp(cmd, "set", 3)==0) {
-	Tcl_Token *varTokenPtr;
-	int dictVarIndex, nameChars;
-	const char *name;
-
-	if (numWords < 3 || procPtr == NULL) {
-	    return TCL_ERROR;
-	}
-	varTokenPtr = TokenAfter(tokenPtr);
-	tokenPtr = TokenAfter(varTokenPtr);
-	if (varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
-	    return TCL_ERROR;
-	}
-	name = varTokenPtr[1].start;
-	nameChars = varTokenPtr[1].size;
-	if (!TclIsLocalScalar(name, nameChars)) {
-	    return TCL_ERROR;
-	}
-	dictVarIndex = TclFindCompiledLocal(name, nameChars, 1, procPtr);
-	for (i=1 ; i<numWords ; i++) {
-	    CompileWord(envPtr, tokenPtr, interp, i);
-	    tokenPtr = TokenAfter(tokenPtr);
-	}
-	TclEmitInstInt4( INST_DICT_SET, numWords-2,		envPtr);
-	TclEmitInt4(	 dictVarIndex,				envPtr);
-	return TCL_OK;
-    } else if (size==4 && strncmp(cmd, "incr", 4)==0) {
-	Tcl_Token *varTokenPtr, *keyTokenPtr, *incrTokenPtr = NULL;
-	int dictVarIndex, nameChars, incrAmount = 1;
-	const char *name;
+     * Remaining words (key path and value to set) can be handled normally.
+     */
 
-	if (numWords < 2 || numWords > 3 || procPtr == NULL) {
-	    return TCL_ERROR;
-	}
-	varTokenPtr = TokenAfter(tokenPtr);
-	keyTokenPtr = TokenAfter(varTokenPtr);
-	if (numWords == 3) {
-	    const char *word;
-	    int numBytes, code;
-	    Tcl_Obj *intObj;
-
-	    incrTokenPtr = TokenAfter(keyTokenPtr);
-	    if (incrTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
-		return TCL_ERROR;
-	    }
-	    word = incrTokenPtr[1].start;
-	    numBytes = incrTokenPtr[1].size;
+    tokenPtr = TokenAfter(varTokenPtr);
+    numWords = parsePtr->numWords-1;
+    for (i=1 ; i<numWords ; i++) {
+	CompileWord(envPtr, tokenPtr, interp, i);
+	tokenPtr = TokenAfter(tokenPtr);
+    }
 
-	    intObj = Tcl_NewStringObj(word, numBytes);
-	    Tcl_IncrRefCount(intObj);
-	    code = TclGetIntFromObj(NULL, intObj, &incrAmount);
-	    TclDecrRefCount(intObj);
-	    if (code != TCL_OK) {
-		return TCL_ERROR;
-	    }
-	}
-	if (varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
-	    return TCL_ERROR;
-	}
-	name = varTokenPtr[1].start;
-	nameChars = varTokenPtr[1].size;
-	if (!TclIsLocalScalar(name, nameChars)) {
-	    return TCL_ERROR;
-	}
-	dictVarIndex = TclFindCompiledLocal(name, nameChars, 1, procPtr);
-	CompileWord(envPtr, keyTokenPtr, interp, 3);
-	TclEmitInstInt4( INST_DICT_INCR_IMM, incrAmount,	envPtr);
-	TclEmitInt4(	 dictVarIndex,				envPtr);
-	return TCL_OK;
-    } else if (size==3 && strncmp(cmd, "get", 3)==0) {
-	/*
-	 * Only compile this because we need INST_DICT_GET anyway.
-	 */
+    /*
+     * Now emit the instruction to do the dict manipulation.
+     */
 
-	if (numWords < 2) {
-	    return TCL_ERROR;
-	}
-	for (i=0 ; i<numWords ; i++) {
-	    tokenPtr = TokenAfter(tokenPtr);
-	    CompileWord(envPtr, tokenPtr, interp, i);
-	}
-	TclEmitInstInt4(INST_DICT_GET, numWords-1, envPtr);
-	return TCL_OK;
-    } else if (size==3 && strncmp(cmd, "for", 3)==0) {
-	Tcl_Token *varsTokenPtr, *dictTokenPtr, *bodyTokenPtr;
-	int keyVarIndex, valueVarIndex, nameChars, loopRange, catchRange;
-	int infoIndex, jumpDisplacement, bodyTargetOffset, emptyTargetOffset;
-	int endTargetOffset;
-	const char **argv;
-	Tcl_DString buffer;
-	int savedStackDepth = envPtr->currStackDepth;
-	DefineLineInformation;	/* TIP #280 */
+    TclEmitInstInt4( INST_DICT_SET, numWords-2,		envPtr);
+    TclEmitInt4(     dictVarIndex,			envPtr);
+    return TCL_OK;
+}
+
+int
+TclCompileDictIncrCmd(
+    Tcl_Interp *interp,		/* Used for looking up stuff. */
+    Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
+    Command *cmdPtr,		/* Points to defintion of command being
+				 * compiled. */
+    CompileEnv *envPtr)		/* Holds resulting instructions. */
+{
+    Proc *procPtr = envPtr->procPtr;
+    DefineLineInformation;	/* TIP #280 */
+    Tcl_Token *varTokenPtr, *keyTokenPtr;
+    int dictVarIndex, nameChars, incrAmount;
+    const char *name;
+
+    /*
+     * There must be at least two arguments after the command.
+     */
+
+    if (parsePtr->numWords < 3 || parsePtr->numWords > 4 || procPtr == NULL) {
+	return TCL_ERROR;
+    }
+    varTokenPtr = TokenAfter(parsePtr->tokenPtr);
+    keyTokenPtr = TokenAfter(varTokenPtr);
 
-	if (numWords != 3 || procPtr == NULL) {
+    /*
+     * Parse the increment amount, if present.
+     */
+
+    if (parsePtr->numWords == 4) {
+	const char *word;
+	int numBytes, code;
+	Tcl_Token *incrTokenPtr;
+	Tcl_Obj *intObj;
+
+	incrTokenPtr = TokenAfter(keyTokenPtr);
+	if (incrTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
 	    return TCL_ERROR;
 	}
+	word = incrTokenPtr[1].start;
+	numBytes = incrTokenPtr[1].size;
 
-	varsTokenPtr = TokenAfter(tokenPtr);
-	dictTokenPtr = TokenAfter(varsTokenPtr);
-	bodyTokenPtr = TokenAfter(dictTokenPtr);
-	if (varsTokenPtr->type != TCL_TOKEN_SIMPLE_WORD ||
-		bodyTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	intObj = Tcl_NewStringObj(word, numBytes);
+	Tcl_IncrRefCount(intObj);
+	code = TclGetIntFromObj(NULL, intObj, &incrAmount);
+	TclDecrRefCount(intObj);
+	if (code != TCL_OK) {
 	    return TCL_ERROR;
 	}
+    } else {
+	incrAmount = 1;
+    }
 
-	/*
-	 * Check we've got a pair of variables and that they are local
-	 * variables. Then extract their indices in the LVT.
-	 */
+    /*
+     * The dictionary variable must be a local scalar that is knowable at
+     * compile time; anything else exceeds the complexity of the opcode. So
+     * discover what the index is.
+     */
 
-	Tcl_DStringInit(&buffer);
-	Tcl_DStringAppend(&buffer, varsTokenPtr[1].start,
-		varsTokenPtr[1].size);
-	if (Tcl_SplitList(NULL, Tcl_DStringValue(&buffer), &numWords,
-		&argv) != TCL_OK) {
-	    Tcl_DStringFree(&buffer);
-	    return TCL_ERROR;
-	}
+    if (varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	return TCL_ERROR;
+    }
+    name = varTokenPtr[1].start;
+    nameChars = varTokenPtr[1].size;
+    if (!TclIsLocalScalar(name, nameChars)) {
+	return TCL_ERROR;
+    }
+    dictVarIndex = TclFindCompiledLocal(name, nameChars, 1, procPtr);
+
+    /*
+     * Emit the key and the code to actually do the increment.
+     */
+
+    CompileWord(envPtr, keyTokenPtr, interp, 3);
+    TclEmitInstInt4( INST_DICT_INCR_IMM, incrAmount,	envPtr);
+    TclEmitInt4(     dictVarIndex,			envPtr);
+    return TCL_OK;
+}
+
+int
+TclCompileDictGetCmd(
+    Tcl_Interp *interp,		/* Used for looking up stuff. */
+    Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
+    Command *cmdPtr,		/* Points to defintion of command being
+				 * compiled. */
+    CompileEnv *envPtr)		/* Holds resulting instructions. */
+{
+    Tcl_Token *tokenPtr;
+    int numWords, i;
+    DefineLineInformation;	/* TIP #280 */
+
+    /*
+     * There must be at least two arguments after the command (the single-arg
+     * case is legal, but too special and magic for us to deal with here).
+     */
+
+    if (parsePtr->numWords < 3) {
+	return TCL_ERROR;
+    }
+    tokenPtr = TokenAfter(parsePtr->tokenPtr);
+    numWords = parsePtr->numWords-1;
+
+    /*
+     * Only compile this because we need INST_DICT_GET anyway.
+     */
+
+    for (i=0 ; i<numWords ; i++) {
+	CompileWord(envPtr, tokenPtr, interp, i);
+	tokenPtr = TokenAfter(tokenPtr);
+    }
+    TclEmitInstInt4(INST_DICT_GET, numWords-1, envPtr);
+    return TCL_OK;
+}
+
+int
+TclCompileDictForCmd(
+    Tcl_Interp *interp,		/* Used for looking up stuff. */
+    Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
+    Command *cmdPtr,		/* Points to defintion of command being
+				 * compiled. */
+    CompileEnv *envPtr)		/* Holds resulting instructions. */
+{
+    Proc *procPtr = envPtr->procPtr;
+    DefineLineInformation;	/* TIP #280 */
+    Tcl_Token *varsTokenPtr, *dictTokenPtr, *bodyTokenPtr;
+    int keyVarIndex, valueVarIndex, nameChars, loopRange, catchRange;
+    int infoIndex, jumpDisplacement, bodyTargetOffset, emptyTargetOffset;
+    int numVars, endTargetOffset;
+    int savedStackDepth = envPtr->currStackDepth; /* is this necessary? */
+    const char **argv;
+    Tcl_DString buffer;
+
+    /*
+     * There must be at least three argument after the command.
+     */
+
+    if (parsePtr->numWords != 4 || procPtr == NULL) {
+	return TCL_ERROR;
+    }
+
+    varsTokenPtr = TokenAfter(parsePtr->tokenPtr);
+    dictTokenPtr = TokenAfter(varsTokenPtr);
+    bodyTokenPtr = TokenAfter(dictTokenPtr);
+    if (varsTokenPtr->type != TCL_TOKEN_SIMPLE_WORD ||
+	    bodyTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	return TCL_ERROR;
+    }
+
+    /*
+     * Check we've got a pair of variables and that they are local variables.
+     * Then extract their indices in the LVT.
+     */
+
+    Tcl_DStringInit(&buffer);
+    Tcl_DStringAppend(&buffer, varsTokenPtr[1].start, varsTokenPtr[1].size);
+    if (Tcl_SplitList(NULL, Tcl_DStringValue(&buffer), &numVars,
+	    &argv) != TCL_OK) {
 	Tcl_DStringFree(&buffer);
-	if (numWords != 2) {
-	    ckfree((char *) argv);
-	    return TCL_ERROR;
-	}
-	nameChars = strlen(argv[0]);
-	if (!TclIsLocalScalar(argv[0], nameChars)) {
-	    ckfree((char *) argv);
-	    return TCL_ERROR;
-	}
-	keyVarIndex = TclFindCompiledLocal(argv[0], nameChars, 1, procPtr);
-	nameChars = strlen(argv[1]);
-	if (!TclIsLocalScalar(argv[1], nameChars)) {
-	    ckfree((char *) argv);
-	    return TCL_ERROR;
-	}
-	valueVarIndex = TclFindCompiledLocal(argv[1], nameChars, 1, procPtr);
+	return TCL_ERROR;
+    }
+    Tcl_DStringFree(&buffer);
+    if (numVars != 2) {
 	ckfree((char *) argv);
+	return TCL_ERROR;
+    }
 
-	/*
-	 * Allocate a temporary variable to store the iterator reference. The
-	 * variable will contain a Tcl_DictSearch reference which will be
-	 * allocated by INST_DICT_FIRST and disposed when the variable is
-	 * unset (at which point it should also have been finished with).
-	 */
+    nameChars = strlen(argv[0]);
+    if (!TclIsLocalScalar(argv[0], nameChars)) {
+	ckfree((char *) argv);
+	return TCL_ERROR;
+    }
+    keyVarIndex = TclFindCompiledLocal(argv[0], nameChars, 1, procPtr);
 
-	infoIndex = TclFindCompiledLocal(NULL, 0, 1, procPtr);
+    nameChars = strlen(argv[1]);
+    if (!TclIsLocalScalar(argv[1], nameChars)) {
+	ckfree((char *) argv);
+	return TCL_ERROR;
+    }
+    valueVarIndex = TclFindCompiledLocal(argv[1], nameChars, 1, procPtr);
+    ckfree((char *) argv);
 
-	/*
-	 * Preparation complete; issue instructions. Note that this code
-	 * issues fixed-sized jumps. That simplifies things a lot!
-	 *
-	 * First up, get the dictionary and start the iteration. No catching
-	 * of errors at this point.
-	 */
+    /*
+     * Allocate a temporary variable to store the iterator reference. The
+     * variable will contain a Tcl_DictSearch reference which will be
+     * allocated by INST_DICT_FIRST and disposed when the variable is unset
+     * (at which point it should also have been finished with).
+     */
 
-	CompileWord(envPtr, dictTokenPtr, interp, 3);
-	TclEmitInstInt4( INST_DICT_FIRST, infoIndex,		envPtr);
-	emptyTargetOffset = CurrentOffset(envPtr);
-	TclEmitInstInt4( INST_JUMP_TRUE4, 0,			envPtr);
+    infoIndex = TclFindCompiledLocal(NULL, 0, 1, procPtr);
 
-	/*
-	 * Now we catch errors from here on so that we can finalize the search
-	 * started by Tcl_DictObjFirst above.
-	 */
+    /*
+     * Preparation complete; issue instructions. Note that this code issues
+     * fixed-sized jumps. That simplifies things a lot!
+     *
+     * First up, get the dictionary and start the iteration. No catching of
+     * errors at this point.
+     */
 
-	catchRange = DeclareExceptionRange(envPtr, CATCH_EXCEPTION_RANGE);
-	TclEmitInstInt4( INST_BEGIN_CATCH4, catchRange,		envPtr);
-	ExceptionRangeStarts(envPtr, catchRange);
+    CompileWord(envPtr, dictTokenPtr, interp, 3);
+    TclEmitInstInt4( INST_DICT_FIRST, infoIndex,		envPtr);
+    emptyTargetOffset = CurrentOffset(envPtr);
+    TclEmitInstInt4( INST_JUMP_TRUE4, 0,			envPtr);
 
-	/*
-	 * Inside the iteration, write the loop variables.
-	 */
+    /*
+     * Now we catch errors from here on so that we can finalize the search
+     * started by Tcl_DictObjFirst above.
+     */
 
-	bodyTargetOffset = CurrentOffset(envPtr);
-	TclEmitInstInt4( INST_STORE_SCALAR4, keyVarIndex,	envPtr);
-	TclEmitOpcode(   INST_POP,				envPtr);
-	TclEmitInstInt4( INST_STORE_SCALAR4, valueVarIndex,	envPtr);
-	TclEmitOpcode(   INST_POP,				envPtr);
+    catchRange = DeclareExceptionRange(envPtr, CATCH_EXCEPTION_RANGE);
+    TclEmitInstInt4( INST_BEGIN_CATCH4, catchRange,		envPtr);
+    ExceptionRangeStarts(envPtr, catchRange);
 
-	/*
-	 * Set up the loop exception targets.
-	 */
+    /*
+     * Inside the iteration, write the loop variables.
+     */
 
-	loopRange = DeclareExceptionRange(envPtr, LOOP_EXCEPTION_RANGE);
-	ExceptionRangeStarts(envPtr, loopRange);
+    bodyTargetOffset = CurrentOffset(envPtr);
+    TclEmitInstInt4( INST_STORE_SCALAR4, keyVarIndex,		envPtr);
+    TclEmitOpcode(   INST_POP,					envPtr);
+    TclEmitInstInt4( INST_STORE_SCALAR4, valueVarIndex,		envPtr);
+    TclEmitOpcode(   INST_POP,					envPtr);
 
-	/*
-	 * Compile the loop body itself. It should be stack-neutral.
-	 */
+    /*
+     * Set up the loop exception targets.
+     */
 
-	envPtr->line = mapPtr->loc[eclIndex].line[4];
-	CompileBody(envPtr, bodyTokenPtr, interp);
-	envPtr->currStackDepth = savedStackDepth + 1;
-	TclEmitOpcode(   INST_POP,				envPtr);
-	envPtr->currStackDepth = savedStackDepth;
+    loopRange = DeclareExceptionRange(envPtr, LOOP_EXCEPTION_RANGE);
+    ExceptionRangeStarts(envPtr, loopRange);
 
-	/*
-	 * Both exception target ranges (error and loop) end here.
-	 */
+    /*
+     * Compile the loop body itself. It should be stack-neutral.
+     */
 
-	ExceptionRangeEnds(envPtr, loopRange);
-	ExceptionRangeEnds(envPtr, catchRange);
+    envPtr->line = mapPtr->loc[eclIndex].line[4];
+    CompileBody(envPtr, bodyTokenPtr, interp);
+    envPtr->currStackDepth = savedStackDepth + 1;
+    TclEmitOpcode(   INST_POP,					envPtr);
+    envPtr->currStackDepth = savedStackDepth;
 
-	/*
-	 * Continue (or just normally process) by getting the next pair of
-	 * items from the dictionary and jumping back to the code to write
-	 * them into variables if there is another pair.
-	 */
+    /*
+     * Both exception target ranges (error and loop) end here.
+     */
 
-	ExceptionRangeTarget(envPtr, loopRange, continueOffset);
-	TclEmitInstInt4( INST_DICT_NEXT, infoIndex,		envPtr);
-	jumpDisplacement = bodyTargetOffset - CurrentOffset(envPtr);
-	TclEmitInstInt4( INST_JUMP_FALSE4, jumpDisplacement,	envPtr);
-	TclEmitOpcode(   INST_POP,				envPtr);
-	TclEmitOpcode(   INST_POP,				envPtr);
+    ExceptionRangeEnds(envPtr, loopRange);
+    ExceptionRangeEnds(envPtr, catchRange);
 
-	/*
-	 * Now do the final cleanup for the no-error case (this is where we
-	 * break out of the loop to) by force-terminating the iteration (if
-	 * not already terminated), ditching the exception info and jumping to
-	 * the last instruction for this command. In theory, this could be
-	 * done using the "finally" clause (next generated) but this is
-	 * faster.
-	 */
+    /*
+     * Continue (or just normally process) by getting the next pair of items
+     * from the dictionary and jumping back to the code to write them into
+     * variables if there is another pair.
+     */
 
-	ExceptionRangeTarget(envPtr, loopRange, breakOffset);
-	TclEmitInstInt4( INST_DICT_DONE, infoIndex,		envPtr);
-	TclEmitOpcode(	 INST_END_CATCH,			envPtr);
-	endTargetOffset = CurrentOffset(envPtr);
-	TclEmitInstInt4( INST_JUMP4, 0,				envPtr);
+    ExceptionRangeTarget(envPtr, loopRange, continueOffset);
+    TclEmitInstInt4( INST_DICT_NEXT, infoIndex,			envPtr);
+    jumpDisplacement = bodyTargetOffset - CurrentOffset(envPtr);
+    TclEmitInstInt4( INST_JUMP_FALSE4, jumpDisplacement,	envPtr);
+    TclEmitOpcode(   INST_POP,					envPtr);
+    TclEmitOpcode(   INST_POP,					envPtr);
 
-	/*
-	 * Error handler "finally" clause, which force-terminates the
-	 * iteration and rethrows the error.
-	 */
+    /*
+     * Now do the final cleanup for the no-error case (this is where we break
+     * out of the loop to) by force-terminating the iteration (if not already
+     * terminated), ditching the exception info and jumping to the last
+     * instruction for this command. In theory, this could be done using the
+     * "finally" clause (next generated) but this is faster.
+     */
 
-	ExceptionRangeTarget(envPtr, catchRange, catchOffset);
-	TclEmitOpcode(   INST_PUSH_RETURN_OPTIONS,		envPtr);
-	TclEmitOpcode(   INST_PUSH_RESULT,			envPtr);
-	TclEmitInstInt4( INST_DICT_DONE, infoIndex,		envPtr);
-	TclEmitOpcode(   INST_END_CATCH,			envPtr);
-	TclEmitOpcode(   INST_RETURN_STK,			envPtr);
+    ExceptionRangeTarget(envPtr, loopRange, breakOffset);
+    TclEmitInstInt4( INST_DICT_DONE, infoIndex,			envPtr);
+    TclEmitOpcode(   INST_END_CATCH,				envPtr);
+    endTargetOffset = CurrentOffset(envPtr);
+    TclEmitInstInt4( INST_JUMP4, 0,				envPtr);
 
-	/*
-	 * Otherwise we're done (the jump after the DICT_FIRST points here)
-	 * and we need to pop the bogus key/value pair (pushed to keep stack
-	 * calculations easy!) Note that we skip the END_CATCH. [Bug 1382528]
-	 */
+    /*
+     * Error handler "finally" clause, which force-terminates the iteration
+     * and rethrows the error.
+     */
+
+    ExceptionRangeTarget(envPtr, catchRange, catchOffset);
+    TclEmitOpcode(   INST_PUSH_RETURN_OPTIONS,			envPtr);
+    TclEmitOpcode(   INST_PUSH_RESULT,				envPtr);
+    TclEmitInstInt4( INST_DICT_DONE, infoIndex,			envPtr);
+    TclEmitOpcode(   INST_END_CATCH,				envPtr);
+    TclEmitOpcode(   INST_RETURN_STK,				envPtr);
+
+    /*
+     * Otherwise we're done (the jump after the DICT_FIRST points here) and we
+     * need to pop the bogus key/value pair (pushed to keep stack calculations
+     * easy!) Note that we skip the END_CATCH. [Bug 1382528]
+     */
+
+    jumpDisplacement = CurrentOffset(envPtr) - emptyTargetOffset;
+    TclUpdateInstInt4AtPc(INST_JUMP_TRUE4, jumpDisplacement,
+	    envPtr->codeStart + emptyTargetOffset);
+    TclEmitOpcode(   INST_POP,					envPtr);
+    TclEmitOpcode(   INST_POP,					envPtr);
+    TclEmitInstInt4( INST_DICT_DONE, infoIndex,			envPtr);
+
+    /*
+     * Final stage of the command (normal case) is that we push an empty
+     * object. This is done last to promote peephole optimization when it's
+     * dropped immediately.
+     */
+
+    jumpDisplacement = CurrentOffset(envPtr) - endTargetOffset;
+    TclUpdateInstInt4AtPc(INST_JUMP4, jumpDisplacement,
+	    envPtr->codeStart + endTargetOffset);
+    PushLiteral(envPtr, "", 0);
+    return TCL_OK;
+}
+
+int
+TclCompileDictUpdateCmd(
+    Tcl_Interp *interp,		/* Used for looking up stuff. */
+    Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
+    Command *cmdPtr,		/* Points to defintion of command being
+				 * compiled. */
+    CompileEnv *envPtr)		/* Holds resulting instructions. */
+{
+    Proc *procPtr = envPtr->procPtr;
+    DefineLineInformation;	/* TIP #280 */
+    const char *name;
+    int i, nameChars, dictIndex, numVars, range, infoIndex;
+    Tcl_Token **keyTokenPtrs, *dictVarTokenPtr, *bodyTokenPtr, *tokenPtr;
+    DictUpdateInfo *duiPtr;
+    JumpFixup jumpFixup;
+
+    /*
+     * There must be at least one argument after the command.
+     */
+
+    if (parsePtr->numWords < 5 || procPtr == NULL) {
+	return TCL_ERROR;
+    }
 
-	jumpDisplacement = CurrentOffset(envPtr) - emptyTargetOffset;
-	TclUpdateInstInt4AtPc(INST_JUMP_TRUE4, jumpDisplacement,
-		envPtr->codeStart + emptyTargetOffset);
-	TclEmitOpcode(   INST_POP,				envPtr);
-	TclEmitOpcode(   INST_POP,				envPtr);
-	TclEmitInstInt4( INST_DICT_DONE, infoIndex,		envPtr);
+    /*
+     * Parse the command. Expect the following:
+     *   dict update <lit(eral)> <any> <lit> ?<any> <lit> ...? <lit>
+     */
 
+    if ((parsePtr->numWords - 1) & 1) {
+	return TCL_ERROR;
+    }
+    numVars = (parsePtr->numWords - 3) / 2;
+
+    /*
+     * The dictionary variable must be a local scalar that is knowable at
+     * compile time; anything else exceeds the complexity of the opcode. So
+     * discover what the index is.
+     */
+
+    dictVarTokenPtr = TokenAfter(parsePtr->tokenPtr);
+    if (dictVarTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	return TCL_ERROR;
+    }
+    name = dictVarTokenPtr[1].start;
+    nameChars = dictVarTokenPtr[1].size;
+    if (!TclIsLocalScalar(name, nameChars)) {
+	return TCL_ERROR;
+    }
+    dictIndex = TclFindCompiledLocal(name, nameChars, 1, procPtr);
+
+    /*
+     * Assemble the instruction metadata. This is complex enough that it is
+     * represented as auxData; it holds an ordered list of variable indices
+     * that are to be used.
+     */
+
+    duiPtr = (DictUpdateInfo *)
+	    ckalloc(sizeof(DictUpdateInfo) + sizeof(int) * (numVars - 1));
+    duiPtr->length = numVars;
+    keyTokenPtrs = (Tcl_Token **) TclStackAlloc(interp,
+	    sizeof(Tcl_Token *) * numVars);
+    tokenPtr = TokenAfter(dictVarTokenPtr);
+
+    for (i=0 ; i<numVars ; i++) {
 	/*
-	 * Final stage of the command (normal case) is that we push an empty
-	 * object. This is done last to promote peephole optimization when
-	 * it's dropped immediately.
+	 * Put keys to one side for later compilation to bytecode.
 	 */
 
-	jumpDisplacement = CurrentOffset(envPtr) - endTargetOffset;
-	TclUpdateInstInt4AtPc(INST_JUMP4, jumpDisplacement,
-		envPtr->codeStart + endTargetOffset);
-	PushLiteral(envPtr, "", 0);
-	return TCL_OK;
-    } else if (size==6 && strncmp(cmd, "update", 6)==0) {
-	const char *name;
-	int nameChars, dictIndex, numVars, range, infoIndex;
-	Tcl_Token **keyTokenPtrs, *dictVarTokenPtr, *bodyTokenPtr;
-	DictUpdateInfo *duiPtr;
-	JumpFixup jumpFixup;
+	keyTokenPtrs[i] = tokenPtr;
 
 	/*
-	 * Parse the command. Expect the following:
-	 *   dict update <lit(eral)> <any> <lit> ?<any> <lit> ...? <lit>
+	 * Variables first need to be checked for sanity.
 	 */
 
-	if (numWords < 4 || numWords & 1 || procPtr == NULL) {
-	    return TCL_ERROR;
-	}
-	numVars = numWords/2 - 1;
-	dictVarTokenPtr = TokenAfter(tokenPtr);
-	if (dictVarTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	tokenPtr = TokenAfter(tokenPtr);
+	if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	    ckfree((char *) duiPtr);
+	    TclStackFree(interp, keyTokenPtrs);
 	    return TCL_ERROR;
 	}
-	name = dictVarTokenPtr[1].start;
-	nameChars = dictVarTokenPtr[1].size;
+	name = tokenPtr[1].start;
+	nameChars = tokenPtr[1].size;
 	if (!TclIsLocalScalar(name, nameChars)) {
-	    return TCL_ERROR;
-	}
-	dictIndex = TclFindCompiledLocal(name, nameChars, 1, procPtr);
-
-	duiPtr = (DictUpdateInfo *)
-		ckalloc(sizeof(DictUpdateInfo) + sizeof(int) * (numVars - 1));
-	duiPtr->length = numVars;
-	keyTokenPtrs = (Tcl_Token **) TclStackAlloc(interp,
-		sizeof(Tcl_Token *) * numVars);
-	tokenPtr = TokenAfter(dictVarTokenPtr);
-	for (i=0 ; i<numVars ; i++) {
-	    keyTokenPtrs[i] = tokenPtr;
-	    tokenPtr = TokenAfter(tokenPtr);
-	    if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
-		ckfree((char *) duiPtr);
-		TclStackFree(interp, keyTokenPtrs);
-		return TCL_ERROR;
-	    }
-	    name = tokenPtr[1].start;
-	    nameChars = tokenPtr[1].size;
-	    if (!TclIsLocalScalar(name, nameChars)) {
-		ckfree((char *) duiPtr);
-		TclStackFree(interp, keyTokenPtrs);
-		return TCL_ERROR;
-	    }
-	    duiPtr->varIndices[i] =
-		TclFindCompiledLocal(name, nameChars, 1, procPtr);
-	    tokenPtr = TokenAfter(tokenPtr);
-	}
-	if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
 	    ckfree((char *) duiPtr);
 	    TclStackFree(interp, keyTokenPtrs);
 	    return TCL_ERROR;
 	}
-	bodyTokenPtr = tokenPtr;
 
 	/*
-	 * The list of variables to bind is stored in auxiliary data so that
-	 * it can't be snagged by literal sharing and forced to shimmer
-	 * dangerously.
+	 * Stash the index in the auxiliary data.
 	 */
 
-	infoIndex = TclCreateAuxData(duiPtr, &tclDictUpdateInfoType, envPtr);
+	duiPtr->varIndices[i] =
+		TclFindCompiledLocal(name, nameChars, 1, procPtr);
+	tokenPtr = TokenAfter(tokenPtr);
+    }
+    if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	ckfree((char *) duiPtr);
+	TclStackFree(interp, keyTokenPtrs);
+	return TCL_ERROR;
+    }
+    bodyTokenPtr = tokenPtr;
 
-	for (i=0 ; i<numVars ; i++) {
-	    CompileWord(envPtr, keyTokenPtrs[i], interp, i);
-	}
-	TclEmitInstInt4( INST_LIST, numVars,			envPtr);
-	TclEmitInstInt4( INST_DICT_UPDATE_START, dictIndex,	envPtr);
-	TclEmitInt4(				 infoIndex,	envPtr);
+    /*
+     * The list of variables to bind is stored in auxiliary data so that it
+     * can't be snagged by literal sharing and forced to shimmer dangerously.
+     */
 
-	range = DeclareExceptionRange(envPtr, CATCH_EXCEPTION_RANGE);
-	TclEmitInstInt4( INST_BEGIN_CATCH4, range,		envPtr);
+    infoIndex = TclCreateAuxData(duiPtr, &tclDictUpdateInfoType, envPtr);
 
-	ExceptionRangeStarts(envPtr, range);
-	CompileBody(envPtr, bodyTokenPtr, interp);
-	ExceptionRangeEnds(envPtr, range);
+    for (i=0 ; i<numVars ; i++) {
+	CompileWord(envPtr, keyTokenPtrs[i], interp, i);
+    }
+    TclEmitInstInt4( INST_LIST, numVars,			envPtr);
+    TclEmitInstInt4( INST_DICT_UPDATE_START, dictIndex,		envPtr);
+    TclEmitInt4(     infoIndex,					envPtr);
 
-	/*
-	 * Normal termination code: the stack has the key list below the
-	 * result of the body evaluation: swap them and finish the update
-	 * code.
-	 */
+    range = DeclareExceptionRange(envPtr, CATCH_EXCEPTION_RANGE);
+    TclEmitInstInt4( INST_BEGIN_CATCH4, range,			envPtr);
 
-	TclEmitOpcode(   INST_END_CATCH,			envPtr);
-	TclEmitInstInt4( INST_REVERSE,                2,	envPtr);
-	TclEmitInstInt4( INST_DICT_UPDATE_END, dictIndex,	envPtr);
-	TclEmitInt4(			       infoIndex,	envPtr);
+    ExceptionRangeStarts(envPtr, range);
+    CompileBody(envPtr, bodyTokenPtr, interp);
+    ExceptionRangeEnds(envPtr, range);
 
-	/*
-	 * Jump around the exceptional termination code
-	 */
+    /*
+     * Normal termination code: the stack has the key list below the result of
+     * the body evaluation: swap them and finish the update code.
+     */
 
-	TclEmitForwardJump(envPtr, TCL_UNCONDITIONAL_JUMP, &jumpFixup);
+    TclEmitOpcode(   INST_END_CATCH,				envPtr);
+    TclEmitInstInt4( INST_REVERSE, 2,				envPtr);
+    TclEmitInstInt4( INST_DICT_UPDATE_END, dictIndex,		envPtr);
+    TclEmitInt4(     infoIndex,					envPtr);
 
-	/*
-	 * Termination code for non-ok returns: stash the result and return
-	 * options in the stack, bring up the key list, finish the update
-	 * code, and finally return with the catched return data
-	 */
+    /*
+     * Jump around the exceptional termination code.
+     */
 
-	ExceptionRangeTarget(envPtr, range, catchOffset);
-	TclEmitOpcode(   INST_PUSH_RESULT,			envPtr);
-	TclEmitOpcode(   INST_PUSH_RETURN_OPTIONS,		envPtr);
-	TclEmitOpcode(   INST_END_CATCH,			envPtr);
-	TclEmitInstInt4( INST_REVERSE,                3,	envPtr);
+    TclEmitForwardJump(envPtr, TCL_UNCONDITIONAL_JUMP, &jumpFixup);
 
-	TclEmitInstInt4( INST_DICT_UPDATE_END, dictIndex,	envPtr);
-	TclEmitInt4(			       infoIndex,	envPtr);
-	TclEmitOpcode(   INST_RETURN_STK,			envPtr);
+    /*
+     * Termination code for non-ok returns: stash the result and return
+     * options in the stack, bring up the key list, finish the update code,
+     * and finally return with the catched return data
+     */
 
-	if (TclFixupForwardJumpToHere(envPtr, &jumpFixup, 127)) {
-	    Tcl_Panic("TclCompileDictCmd(update): bad jump distance %d",
-		    CurrentOffset(envPtr) - jumpFixup.codeOffset);
-	}
-	TclStackFree(interp, keyTokenPtrs);
-	return TCL_OK;
-    } else if (size==6 && strncmp(cmd, "append", 6) == 0) {
-	Tcl_Token *varTokenPtr;
-	int dictVarIndex, nameChars;
-	const char *name;
+    ExceptionRangeTarget(envPtr, range, catchOffset);
+    TclEmitOpcode(   INST_PUSH_RESULT,				envPtr);
+    TclEmitOpcode(   INST_PUSH_RETURN_OPTIONS,			envPtr);
+    TclEmitOpcode(   INST_END_CATCH,				envPtr);
+    TclEmitInstInt4( INST_REVERSE, 3,				envPtr);
 
-	/*
-	 * Arbirary safe limit; anyone exceeding it should stop worrying about
-	 * speed quite so much. ;-)
-	 */
+    TclEmitInstInt4( INST_DICT_UPDATE_END, dictIndex,		envPtr);
+    TclEmitInt4(     infoIndex,					envPtr);
+    TclEmitOpcode(   INST_RETURN_STK,				envPtr);
 
-	if (numWords < 3 || numWords > 100 || procPtr == NULL) {
-	    return TCL_ERROR;
-	}
-	varTokenPtr = TokenAfter(tokenPtr);
-	tokenPtr = TokenAfter(varTokenPtr);
-	if (varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
-	    return TCL_ERROR;
-	}
-	name = varTokenPtr[1].start;
-	nameChars = varTokenPtr[1].size;
-	if (!TclIsLocalScalar(name, nameChars)) {
-	    return TCL_ERROR;
-	}
-	dictVarIndex = TclFindCompiledLocal(name, nameChars, 1, procPtr);
-	for (i=1 ; i<numWords ; i++) {
-	    CompileWord(envPtr, tokenPtr, interp, i);
-	    tokenPtr = TokenAfter(tokenPtr);
-	}
-	if (numWords > 3) {
-	    TclEmitInstInt1( INST_CONCAT1, numWords-2,		envPtr);
-	}
-	TclEmitInstInt4( INST_DICT_APPEND, dictVarIndex,	envPtr);
-	return TCL_OK;
-    } else if (size==7 && strncmp(cmd, "lappend", 7) == 0) {
-	Tcl_Token *varTokenPtr, *keyTokenPtr, *valueTokenPtr;
-	int dictVarIndex, nameChars;
-	const char *name;
+    if (TclFixupForwardJumpToHere(envPtr, &jumpFixup, 127)) {
+	Tcl_Panic("TclCompileDictCmd(update): bad jump distance %d",
+		CurrentOffset(envPtr) - jumpFixup.codeOffset);
+    }
+    TclStackFree(interp, keyTokenPtrs);
+    return TCL_OK;
+}
+
+int
+TclCompileDictAppendCmd(
+    Tcl_Interp *interp,		/* Used for looking up stuff. */
+    Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
+    Command *cmdPtr,		/* Points to defintion of command being
+				 * compiled. */
+    CompileEnv *envPtr)		/* Holds resulting instructions. */
+{
+    Proc *procPtr = envPtr->procPtr;
+    DefineLineInformation;	/* TIP #280 */
+    Tcl_Token *tokenPtr;
+    int i, dictVarIndex;
+
+    /*
+     * There must be at least two argument after the command. And we impose an
+     * (arbirary) safe limit; anyone exceeding it should stop worrying about
+     * speed quite so much. ;-)
+     */
+
+    if (parsePtr->numWords<4 || parsePtr->numWords>100 || procPtr==NULL) {
+	return TCL_ERROR;
+    }
+
+    /*
+     * Get the index of the local variable that we will be working with.
+     */
+
+    tokenPtr = TokenAfter(parsePtr->tokenPtr);
+    if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	return TCL_ERROR;
+    } else {
+	register const char *name = tokenPtr[1].start;
+	register int nameChars = tokenPtr[1].size;
 
-	if (numWords != 3 || procPtr == NULL) {
-	    return TCL_ERROR;
-	}
-	varTokenPtr = TokenAfter(tokenPtr);
-	keyTokenPtr = TokenAfter(varTokenPtr);
-	valueTokenPtr = TokenAfter(keyTokenPtr);
-	if (varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
-	    return TCL_ERROR;
-	}
-	name = varTokenPtr[1].start;
-	nameChars = varTokenPtr[1].size;
 	if (!TclIsLocalScalar(name, nameChars)) {
 	    return TCL_ERROR;
 	}
 	dictVarIndex = TclFindCompiledLocal(name, nameChars, 1, procPtr);
-	CompileWord(envPtr, keyTokenPtr, interp, 3);
-	CompileWord(envPtr, valueTokenPtr, interp, 4);
-	TclEmitInstInt4( INST_DICT_LAPPEND, dictVarIndex,	envPtr);
-	return TCL_OK;
     }
 
     /*
-     * Something we do not know how to compile.
+     * Produce the string to concatenate onto the dictionary entry.
+     */
+
+    tokenPtr = TokenAfter(tokenPtr);
+    for (i=2 ; i<parsePtr->numWords ; i++) {
+	CompileWord(envPtr, tokenPtr, interp, i);
+	tokenPtr = TokenAfter(tokenPtr);
+    }
+    if (parsePtr->numWords > 4) {
+	TclEmitInstInt1(INST_CONCAT1, parsePtr->numWords-2, envPtr);
+    }
+
+    /*
+     * Do the concatenation.
      */
 
-    return TCL_ERROR;
+    TclEmitInstInt4(INST_DICT_APPEND, dictVarIndex, envPtr);
+    return TCL_OK;
+}
+
+int
+TclCompileDictLappendCmd(
+    Tcl_Interp *interp,		/* Used for looking up stuff. */
+    Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
+    Command *cmdPtr,		/* Points to defintion of command being
+				 * compiled. */
+    CompileEnv *envPtr)		/* Holds resulting instructions. */
+{
+    Proc *procPtr = envPtr->procPtr;
+    DefineLineInformation;	/* TIP #280 */
+    Tcl_Token *varTokenPtr, *keyTokenPtr, *valueTokenPtr;
+    int dictVarIndex, nameChars;
+    const char *name;
+
+    /*
+     * There must be three arguments after the command.
+     */
+
+    if (parsePtr->numWords != 4 || procPtr == NULL) {
+	return TCL_ERROR;
+    }
+
+    varTokenPtr = TokenAfter(parsePtr->tokenPtr);
+    keyTokenPtr = TokenAfter(varTokenPtr);
+    valueTokenPtr = TokenAfter(keyTokenPtr);
+    if (varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	return TCL_ERROR;
+    }
+    name = varTokenPtr[1].start;
+    nameChars = varTokenPtr[1].size;
+    if (!TclIsLocalScalar(name, nameChars)) {
+	return TCL_ERROR;
+    }
+    dictVarIndex = TclFindCompiledLocal(name, nameChars, 1, procPtr);
+    CompileWord(envPtr, keyTokenPtr, interp, 3);
+    CompileWord(envPtr, valueTokenPtr, interp, 4);
+    TclEmitInstInt4( INST_DICT_LAPPEND, dictVarIndex, envPtr);
+    return TCL_OK;
 }
 
 /*
@@ -3330,26 +3491,24 @@ TclCompileSetCmd(
 /*
  *----------------------------------------------------------------------
  *
- * TclCompileStringCmd --
+ * TclCompileStringCmpCmd --
  *
- *	Procedure called to compile the "string" command. Generally speaking,
- *	these are mostly various kinds of peephole optimizations; most string
- *	operations are handled by executing the interpreted version of the
- *	command.
+ *	Procedure called to compile the simplest and most common form of the
+ *	"string compare" command.
  *
  * Results:
  * 	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
  * 	evaluation to runtime.
  *
  * Side effects:
- *	Instructions are added to envPtr to execute the "string" command at
- *	runtime.
+ *	Instructions are added to envPtr to execute the "string compare"
+ *	command at runtime.
  *
  *----------------------------------------------------------------------
  */
 
 int
-TclCompileStringCmd(
+TclCompileStringCmpCmd(
     Tcl_Interp *interp,		/* Used for error reporting. */
     Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
 				 * created by Tcl_ParseCommand. */
@@ -3358,191 +3517,278 @@ TclCompileStringCmd(
     CompileEnv *envPtr)		/* Holds resulting instructions. */
 {
     DefineLineInformation;	/* TIP #280 */
-    Tcl_Token *opTokenPtr, *varTokenPtr;
-    Tcl_Obj *opObj;
-    int i, index;
-
-    static const char *options[] = {
-	"bytelength",	"compare",	"equal",	"first",
-	"index",	"is",		"last",		"length",
-	"map",		"match",	"range",	"repeat",
-	"replace",	"tolower",	"toupper",	"totitle",
-	"trim",		"trimleft",	"trimright",
-	"wordend",	"wordstart",	NULL
-    };
-    enum options {
-	STR_BYTELENGTH,	STR_COMPARE,	STR_EQUAL,	STR_FIRST,
-	STR_INDEX,	STR_IS,		STR_LAST,	STR_LENGTH,
-	STR_MAP,	STR_MATCH,	STR_RANGE,	STR_REPEAT,
-	STR_REPLACE,	STR_TOLOWER,	STR_TOUPPER,	STR_TOTITLE,
-	STR_TRIM,	STR_TRIMLEFT,	STR_TRIMRIGHT,
-	STR_WORDEND,	STR_WORDSTART
-    };
+    Tcl_Token *tokenPtr;
 
-    if (parsePtr->numWords < 2) {
-	/*
-	 * Fail at run time, not in compilation.
-	 */
+    /*
+     * We don't support any flags; the bytecode isn't that sophisticated.
+     */
 
+    if (parsePtr->numWords != 3) {
 	return TCL_ERROR;
     }
-    opTokenPtr = TokenAfter(parsePtr->tokenPtr);
 
-    opObj = Tcl_NewStringObj(opTokenPtr->start, opTokenPtr->size);
-    if (Tcl_GetIndexFromObj(interp, opObj, options, "option", 0,
-	    &index) != TCL_OK) {
-	Tcl_DecrRefCount(opObj);
-	Tcl_ResetResult(interp);
+    /*
+     * Push the two operands onto the stack and then the test.
+     */
+
+    tokenPtr = TokenAfter(parsePtr->tokenPtr);
+    CompileWord(envPtr, tokenPtr, interp, 1);
+    tokenPtr = TokenAfter(tokenPtr);
+    CompileWord(envPtr, tokenPtr, interp, 2);
+    TclEmitOpcode(INST_STR_CMP, envPtr);
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclCompileStringEqualCmd --
+ *
+ *	Procedure called to compile the simplest and most common form of the
+ *	"string equal" command.
+ *
+ * Results:
+ * 	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
+ * 	evaluation to runtime.
+ *
+ * Side effects:
+ *	Instructions are added to envPtr to execute the "string equal" command
+ *	at runtime.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+TclCompileStringEqualCmd(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
+    Command *cmdPtr,		/* Points to defintion of command being
+				 * compiled. */
+    CompileEnv *envPtr)		/* Holds resulting instructions. */
+{
+    DefineLineInformation;	/* TIP #280 */
+    Tcl_Token *tokenPtr;
+
+    /*
+     * We don't support any flags; the bytecode isn't that sophisticated.
+     */
+
+    if (parsePtr->numWords != 3) {
 	return TCL_ERROR;
     }
-    Tcl_DecrRefCount(opObj);
 
-    varTokenPtr = TokenAfter(opTokenPtr);
+    /*
+     * Push the two operands onto the stack and then the test.
+     */
 
-    switch ((enum options) index) {
-    case STR_COMPARE:
-    case STR_EQUAL:
-	/*
-	 * If there are any flags to the command, we can't byte compile it
-	 * because the INST_STR_EQ bytecode doesn't support flags.
-	 */
+    tokenPtr = TokenAfter(parsePtr->tokenPtr);
+    CompileWord(envPtr, tokenPtr, interp, 1);
+    tokenPtr = TokenAfter(tokenPtr);
+    CompileWord(envPtr, tokenPtr, interp, 2);
+    TclEmitOpcode(INST_STR_EQ, envPtr);
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclCompileStringIndexCmd --
+ *
+ *	Procedure called to compile the simplest and most common form of the
+ *	"string index" command.
+ *
+ * Results:
+ * 	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
+ * 	evaluation to runtime.
+ *
+ * Side effects:
+ *	Instructions are added to envPtr to execute the "string index" command
+ *	at runtime.
+ *
+ *----------------------------------------------------------------------
+ */
 
-	if (parsePtr->numWords != 4) {
-	    return TCL_ERROR;
-	}
+int
+TclCompileStringIndexCmd(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
+    Command *cmdPtr,		/* Points to defintion of command being
+				 * compiled. */
+    CompileEnv *envPtr)		/* Holds resulting instructions. */
+{
+    DefineLineInformation;	/* TIP #280 */
+    Tcl_Token *tokenPtr;
 
-	/*
-	 * Push the two operands onto the stack.
-	 */
+    if (parsePtr->numWords != 3) {
+	return TCL_ERROR;
+    }
 
-	for (i = 0; i < 2; i++) {
-	    CompileWord(envPtr, varTokenPtr, interp, i);
-	    varTokenPtr = TokenAfter(varTokenPtr);
-	}
+    /*
+     * Push the two operands onto the stack and then the index operation.
+     */
 
-	TclEmitOpcode(((((enum options) index) == STR_COMPARE) ?
-		INST_STR_CMP : INST_STR_EQ), envPtr);
-	return TCL_OK;
+    tokenPtr = TokenAfter(parsePtr->tokenPtr);
+    CompileWord(envPtr, tokenPtr, interp, 1);
+    tokenPtr = TokenAfter(tokenPtr);
+    CompileWord(envPtr, tokenPtr, interp, 2);
+    TclEmitOpcode(INST_STR_INDEX, envPtr);
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclCompileStringMatchCmd --
+ *
+ *	Procedure called to compile the simplest and most common form of the
+ *	"string match" command.
+ *
+ * Results:
+ * 	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
+ * 	evaluation to runtime.
+ *
+ * Side effects:
+ *	Instructions are added to envPtr to execute the "string match" command
+ *	at runtime.
+ *
+ *----------------------------------------------------------------------
+ */
 
-    case STR_INDEX:
-	if (parsePtr->numWords != 4) {
-	    /*
-	     * Fail at run time, not in compilation.
-	     */
+int
+TclCompileStringMatchCmd(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
+    Command *cmdPtr,		/* Points to defintion of command being
+				 * compiled. */
+    CompileEnv *envPtr)		/* Holds resulting instructions. */
+{
+    DefineLineInformation;	/* TIP #280 */
+    Tcl_Token *tokenPtr;
+    int i, length, exactMatch = 0, nocase = 0;
+    const char *str;
 
-	    return TCL_ERROR;
-	}
+    if (parsePtr->numWords < 3 || parsePtr->numWords > 4) {
+	return TCL_ERROR;
+    }
+    tokenPtr = TokenAfter(parsePtr->tokenPtr);
 
-	/*
-	 * Push the two operands onto the stack.
-	 */
+    /*
+     * Check if we have a -nocase flag.
+     */
 
-	for (i = 0; i < 2; i++) {
-	    CompileWord(envPtr, varTokenPtr, interp, i);
-	    varTokenPtr = TokenAfter(varTokenPtr);
+    if (parsePtr->numWords == 4) {
+	if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	    return TCL_ERROR;
 	}
-
-	TclEmitOpcode(INST_STR_INDEX, envPtr);
-	return TCL_OK;
-    case STR_MATCH: {
-	int length, exactMatch = 0, nocase = 0;
-	const char *str;
-
-	if (parsePtr->numWords < 4 || parsePtr->numWords > 5) {
+	str = tokenPtr[1].start;
+	length = tokenPtr[1].size;
+	if ((length <= 1) || strncmp(str, "-nocase", (size_t) length)) {
 	    /*
 	     * Fail at run time, not in compilation.
 	     */
 
 	    return TCL_ERROR;
 	}
+	nocase = 1;
+	tokenPtr = TokenAfter(tokenPtr);
+    }
 
-	if (parsePtr->numWords == 5) {
-	    if (varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
-		return TCL_ERROR;
-	    }
-	    str = varTokenPtr[1].start;
-	    length = varTokenPtr[1].size;
-	    if ((length > 1) &&
-		    strncmp(str, "-nocase", (size_t) length) == 0) {
-		nocase = 1;
-	    } else {
+    /*
+     * Push the strings to match against each other.
+     */
+
+    for (i = 0; i < 2; i++) {
+	if (tokenPtr->type == TCL_TOKEN_SIMPLE_WORD) {
+	    str = tokenPtr[1].start;
+	    length = tokenPtr[1].size;
+	    if (!nocase && (i == 0)) {
 		/*
-		 * Fail at run time, not in compilation.
+		 * Trivial matches can be done by 'string equal'. If -nocase
+		 * was specified, we can't do this because INST_STR_EQ has no
+		 * support for nocase.
 		 */
 
-		return TCL_ERROR;
-	    }
-	    varTokenPtr = TokenAfter(varTokenPtr);
-	}
+		Tcl_Obj *copy = Tcl_NewStringObj(str, length);
 
-	for (i = 0; i < 2; i++) {
-	    if (varTokenPtr->type == TCL_TOKEN_SIMPLE_WORD) {
-		str = varTokenPtr[1].start;
-		length = varTokenPtr[1].size;
-		if (!nocase && (i == 0)) {
-		    /*
-		     * Trivial matches can be done by 'string equal'. If
-		     * -nocase was specified, we can't do this because
-		     * INST_STR_EQ has no support for nocase.
-		     */
-
-		    Tcl_Obj *copy = Tcl_NewStringObj(str, length);
-		    Tcl_IncrRefCount(copy);
-		    exactMatch = TclMatchIsTrivial(TclGetString(copy));
-		    TclDecrRefCount(copy);
-		}
-		PushLiteral(envPtr, str, length);
-	    } else {
-		envPtr->line = mapPtr->loc[eclIndex].line[i];
-		CompileTokens(envPtr, varTokenPtr, interp);
+		Tcl_IncrRefCount(copy);
+		exactMatch = TclMatchIsTrivial(TclGetString(copy));
+		TclDecrRefCount(copy);
 	    }
-	    varTokenPtr = TokenAfter(varTokenPtr);
-	}
-
-	if (exactMatch) {
-	    TclEmitOpcode(INST_STR_EQ, envPtr);
+	    PushLiteral(envPtr, str, length);
 	} else {
-	    TclEmitInstInt1(INST_STR_MATCH, nocase, envPtr);
+	    envPtr->line = mapPtr->loc[eclIndex].line[i+1+nocase];
+	    CompileTokens(envPtr, tokenPtr, interp);
 	}
-	return TCL_OK;
+	tokenPtr = TokenAfter(tokenPtr);
     }
-    case STR_LENGTH:
-	if (parsePtr->numWords != 3) {
-	    /*
-	     * Fail at run time, not in compilation.
-	     */
 
-	    return TCL_ERROR;
-	}
+    /*
+     * Push the matcher.
+     */
 
-	if (varTokenPtr->type == TCL_TOKEN_SIMPLE_WORD) {
-	    /*
-	     * Here someone is asking for the length of a static string. Just
-	     * push the actual character (not byte) length.
-	     */
+    if (exactMatch) {
+	TclEmitOpcode(INST_STR_EQ, envPtr);
+    } else {
+	TclEmitInstInt1(INST_STR_MATCH, nocase, envPtr);
+    }
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclCompileStringLenCmd --
+ *
+ *	Procedure called to compile the simplest and most common form of the
+ *	"string length" command.
+ *
+ * Results:
+ * 	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
+ * 	evaluation to runtime.
+ *
+ * Side effects:
+ *	Instructions are added to envPtr to execute the "string length"
+ *	command at runtime.
+ *
+ *----------------------------------------------------------------------
+ */
 
-	    char buf[TCL_INTEGER_SPACE];
-	    int len = Tcl_NumUtfChars(varTokenPtr[1].start,
-		    varTokenPtr[1].size);
+int
+TclCompileStringLenCmd(
+    Tcl_Interp *interp,		/* Used for error reporting. */
+    Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
+    Command *cmdPtr,		/* Points to defintion of command being
+				 * compiled. */
+    CompileEnv *envPtr)		/* Holds resulting instructions. */
+{
+    DefineLineInformation;	/* TIP #280 */
+    Tcl_Token *tokenPtr;
 
-	    len = sprintf(buf, "%d", len);
-	    PushLiteral(envPtr, buf, len);
-	    return TCL_OK;
-	} else {
-	    envPtr->line = mapPtr->loc[eclIndex].line[2];
-	    CompileTokens(envPtr, varTokenPtr, interp);
-	}
-	TclEmitOpcode(INST_STR_LEN, envPtr);
-	return TCL_OK;
+    if (parsePtr->numWords != 2) {
+	return TCL_ERROR;
+    }
 
-    default:
+    tokenPtr = TokenAfter(parsePtr->tokenPtr);
+    if (tokenPtr->type == TCL_TOKEN_SIMPLE_WORD) {
 	/*
-	 * All other cases: compile out of line.
+	 * Here someone is asking for the length of a static string. Just push
+	 * the actual character (not byte) length.
 	 */
 
-	return TCL_ERROR;
-    }
+	char buf[TCL_INTEGER_SPACE];
+	int len = Tcl_NumUtfChars(tokenPtr[1].start, tokenPtr[1].size);
 
+	len = sprintf(buf, "%d", len);
+	PushLiteral(envPtr, buf, len);
+    } else {
+	envPtr->line = mapPtr->loc[eclIndex].line[1];
+	CompileTokens(envPtr, tokenPtr, interp);
+	TclEmitOpcode(INST_STR_LEN, envPtr);
+    }
     return TCL_OK;
 }
 
@@ -5863,7 +6109,7 @@ TclCompileEnsemble(
     Tcl_Obj *mapObj, *subcmdObj, *targetCmdObj, *listObj, **elems;
     Tcl_Command ensemble = (Tcl_Command) cmdPtr;
     Tcl_Parse synthetic;
-    int len, numBytes, result;
+    int len, numBytes, result, flags = 0, i;
     const char *word;
 
     if (parsePtr->numWords < 2) {
@@ -5898,30 +6144,11 @@ TclCompileEnsemble(
 	return TCL_ERROR;
     }
 
-    TclNewStringObj(subcmdObj, word, numBytes);
-    if (Tcl_DictObjGet(NULL, mapObj, subcmdObj, &targetCmdObj) != TCL_OK
-	    || targetCmdObj == NULL) {
-	/*
-	 * We've not got a valid subcommand.
-	 */
-
-	TclDecrRefCount(subcmdObj);
-	return TCL_ERROR;
-    }
-    TclDecrRefCount(subcmdObj);
-
     /*
-     * The command we map to is the first word out of the map element. Note
-     * that we reject dealing with lists that are multiple elements long here;
-     * our rewriting-fu is not yet strong enough.
+     * Next, get the flags. We need them on several code paths.
      */
 
-    if (Tcl_ListObjGetElements(NULL, targetCmdObj, &len, &elems) != TCL_OK
-	    || len != 1) {
-	return TCL_ERROR;
-    }
-    targetCmdObj = elems[0];
-    Tcl_IncrRefCount(targetCmdObj);
+    (void) Tcl_GetEnsembleFlags(NULL, ensemble, &flags);
 
     /*
      * Check to see if there's also a subcommand list; must check to see if
@@ -5931,29 +6158,134 @@ TclCompileEnsemble(
 
     (void) Tcl_GetEnsembleSubcommandList(NULL, ensemble, &listObj);
     if (listObj != NULL) {
-	int i, sclen;
-	char *str;
+	int sclen;
+	const char *str;
+	Tcl_Obj *matchObj = NULL;
 
-	if (Tcl_ListObjGetElements(NULL, listObj, &len,&elems) != TCL_OK){
-	    TclDecrRefCount(targetCmdObj);
+	if (Tcl_ListObjGetElements(NULL, listObj, &len, &elems) != TCL_OK) {
 	    return TCL_ERROR;
 	}
 	for (i=0 ; i<len ; i++) {
 	    str = Tcl_GetStringFromObj(elems[i], &sclen);
-	    if (sclen == numBytes &&
-		    memcmp(word, str, (unsigned) numBytes) == 0) {
-		goto doneSubcmdListSearch;
+	    if (sclen==numBytes && !memcmp(word, str, (unsigned) numBytes)) {
+		/*
+		 * Exact match! Excellent!
+		 */
+
+		result = Tcl_DictObjGet(NULL, mapObj,elems[i], &targetCmdObj);
+		if (result != TCL_OK || targetCmdObj == NULL) {
+		    return TCL_ERROR;
+		}
+		goto doneMapLookup;
+	    }
+
+	    /*
+	     * Check to see if we've got a prefix match. A single prefix match
+	     * is fine, and allows us to refine our dictionary lookup, but
+	     * multiple prefix matches is a Bad Thing and will prevent us from
+	     * making progress. Note that we cannot do the lookup immediately
+	     * in the prefix case; might be another entry later in the list
+	     * that causes things to fail.
+	     */
+
+	    if ((flags & TCL_ENSEMBLE_PREFIX)
+		    && strncmp(word, str, (unsigned) numBytes) == 0) {
+		if (matchObj != NULL) {
+		    return TCL_ERROR;
+		}
+		matchObj = elems[i];
 	    }
 	}
-	TclDecrRefCount(targetCmdObj);
+	if (matchObj != NULL) {
+	    result = Tcl_DictObjGet(NULL, mapObj, matchObj, &targetCmdObj);
+	    if (result != TCL_OK || targetCmdObj == NULL) {
+		return TCL_ERROR;
+	    }
+	    goto doneMapLookup;
+	}
 	return TCL_ERROR;
+    } else {
+	/*
+	 * No map, so check the dictionary directly.
+	 */
+
+	TclNewStringObj(subcmdObj, word, numBytes);
+	result = Tcl_DictObjGet(NULL, mapObj, subcmdObj, &targetCmdObj);
+	TclDecrRefCount(subcmdObj);
+	if (result == TCL_OK && targetCmdObj != NULL) {
+	    /*
+	     * Got it. Skip the fiddling around with prefixes.
+	     */
+
+	    goto doneMapLookup;
+	}
+
+	/*
+	 * We've not literally got a valid subcommand. But maybe we have a
+	 * prefix. Check if prefix matches are allowed.
+	 */
+
+	if (flags & TCL_ENSEMBLE_PREFIX) {
+	    Tcl_DictSearch s;
+	    int done, matched;
+	    Tcl_Obj *tmpObj;
+
+	    /*
+	     * Iterate over the keys in the dictionary, checking to see if
+	     * we're a prefix.
+	     */
+
+	    Tcl_DictObjFirst(NULL,mapObj,&s,&subcmdObj,&tmpObj,&done);
+	    matched = 0;
+	    while (!done) {
+		if (strncmp(TclGetString(subcmdObj), word,
+			(unsigned) numBytes) == 0) {
+		    if (matched++) {
+			/*
+			 * Must have matched twice! Not unique, so no point
+			 * looking further.
+			 */
+
+			break;
+		    }
+		    targetCmdObj = tmpObj;
+		}
+		Tcl_DictObjNext(&s, &subcmdObj, &tmpObj, &done);
+	    }
+	    Tcl_DictObjDone(&s);
+
+	    /*
+	     * If we have anything other than a single match, we've failed the
+	     * unique prefix check.
+	     */
+
+	    if (matched != 1) {
+		return TCL_ERROR;
+	    }
+	} else {
+	    return TCL_ERROR;
+	}
     }
 
     /*
      * OK, we definitely map to something. But what?
+     *
+     * The command we map to is the first word out of the map element. Note
+     * that we also reject dealing with multi-element rewrites if we are in a
+     * safe interpreter, as there is otherwise a (highly gnarly!) way to make
+     * Tcl crash open to exploit.
      */
 
-  doneSubcmdListSearch:
+  doneMapLookup:
+    if (Tcl_ListObjGetElements(NULL, targetCmdObj, &len, &elems) != TCL_OK) {
+	return TCL_ERROR;
+    }
+    if (len > 1 && Tcl_IsSafe(interp)) {
+	return TCL_ERROR;
+    }
+    targetCmdObj = elems[0];
+
+    Tcl_IncrRefCount(targetCmdObj);
     cmdPtr = (Command *) Tcl_GetCommandFromObj(interp, targetCmdObj);
     TclDecrRefCount(targetCmdObj);
     if (cmdPtr == NULL || cmdPtr->compileProc == NULL) {
@@ -5966,20 +6298,15 @@ TclCompileEnsemble(
     }
 
     /*
-     * Should check if we mapped to another ensemble here, and go round the
-     * peek-inside scheme above if so. [TO-DO]
-     */
-
-    /*
      * Now we've done the mapping process, can now actually try to compile.
      * We do this by handing off to the subcommand's actual compiler. But to
-     * do that, we have to perform some trickery to rewrite the arguments. 
+     * do that, we have to perform some trickery to rewrite the arguments.
      */
 
     argTokensPtr = TokenAfter(tokenPtr);
     memcpy(&synthetic, parsePtr, sizeof(Tcl_Parse));
-    synthetic.numWords--;
-    synthetic.numTokens -= (argTokensPtr - parsePtr->tokenPtr) - 2;
+    synthetic.numWords -= 2 - len;
+    synthetic.numTokens -= (argTokensPtr - parsePtr->tokenPtr) - 2*len;
     if (synthetic.numTokens <= NUM_STATIC_TOKENS) {
 	synthetic.tokenPtr = synthetic.staticTokens;
 	synthetic.tokensAvailable = NUM_STATIC_TOKENS;
@@ -5990,19 +6317,26 @@ TclCompileEnsemble(
     }
 
     /*
-     * Now we have the space to work in, install something rewritten.
+     * Now we have the space to work in, install something rewritten. Note
+     * that we are here praying for all our might that none of these words are
+     * a script; the error detection code will crash if that happens and there
+     * is nothing we can do to avoid it!
      */
 
-    synthetic.tokenPtr[0].type = TCL_TOKEN_SIMPLE_WORD;
-    synthetic.tokenPtr[0].start = parsePtr->tokenPtr[0].start;
-    synthetic.tokenPtr[0].size = (tokenPtr->start + tokenPtr->size)
-	    - parsePtr->tokenPtr[0].start;
-    synthetic.tokenPtr[0].numComponents = 1;
+    for (i=0 ; i<len ; i++) {
+	int sclen;
+	const char *str = Tcl_GetStringFromObj(elems[i], &sclen);
 
-    synthetic.tokenPtr[1].type = TCL_TOKEN_TEXT;
-    synthetic.tokenPtr[1].start = synthetic.tokenPtr[0].start;
-    synthetic.tokenPtr[1].size = synthetic.tokenPtr[0].size;
-    synthetic.tokenPtr[1].numComponents = 0;
+	synthetic.tokenPtr[2*i].type = TCL_TOKEN_SIMPLE_WORD;
+	synthetic.tokenPtr[2*i].start = str;
+	synthetic.tokenPtr[2*i].size = sclen;
+	synthetic.tokenPtr[2*i].numComponents = 1;
+
+	synthetic.tokenPtr[2*i+1].type = TCL_TOKEN_TEXT;
+	synthetic.tokenPtr[2*i+1].start = str;
+	synthetic.tokenPtr[2*i+1].size = sclen;
+	synthetic.tokenPtr[2*i+1].numComponents = 0;
+    }
 
     /*
      * Copy over the real argument tokens.
diff --git a/generic/tclDictObj.c b/generic/tclDictObj.c
index 00abbe0..10ff299 100644
--- a/generic/tclDictObj.c
+++ b/generic/tclDictObj.c
@@ -9,7 +9,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclDictObj.c,v 1.49.2.4 2007/11/21 06:44:32 dgp Exp $
+ * RCS: @(#) $Id: tclDictObj.c,v 1.49.2.5 2007/11/25 06:45:44 dgp Exp $
  */
 
 #include "tclInt.h"
@@ -25,43 +25,43 @@ struct Dict;
  */
 
 static void		DeleteDict(struct Dict *dict);
-static int		DictAppendCmd(Tcl_Interp *interp,
+static int		DictAppendCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictCreateCmd(Tcl_Interp *interp,
+static int		DictCreateCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictExistsCmd(Tcl_Interp *interp,
+static int		DictExistsCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictFilterCmd(Tcl_Interp *interp,
+static int		DictFilterCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictForCmd(Tcl_Interp *interp,
+static int		DictForCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictGetCmd(Tcl_Interp *interp,
+static int		DictGetCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictIncrCmd(Tcl_Interp *interp,
+static int		DictIncrCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictInfoCmd(Tcl_Interp *interp,
+static int		DictInfoCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictKeysCmd(Tcl_Interp *interp,
+static int		DictKeysCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictLappendCmd(Tcl_Interp *interp,
+static int		DictLappendCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictMergeCmd(Tcl_Interp *interp,
+static int		DictMergeCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictRemoveCmd(Tcl_Interp *interp,
+static int		DictRemoveCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictReplaceCmd(Tcl_Interp *interp,
+static int		DictReplaceCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictSetCmd(Tcl_Interp *interp,
+static int		DictSetCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictSizeCmd(Tcl_Interp *interp,
+static int		DictSizeCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictUnsetCmd(Tcl_Interp *interp,
+static int		DictUnsetCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictValuesCmd(Tcl_Interp *interp,
+static int		DictUpdateCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictUpdateCmd(Tcl_Interp *interp,
+static int		DictValuesCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
-static int		DictWithCmd(Tcl_Interp *interp,
+static int		DictWithCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const *objv);
 static void		DupDictInternalRep(Tcl_Obj *srcPtr, Tcl_Obj *copyPtr);
 static void		FreeDictInternalRep(Tcl_Obj *dictPtr);
@@ -76,6 +76,33 @@ static inline Tcl_HashEntry *CreateChainEntry(struct Dict *dict,
 static inline int	DeleteChainEntry(struct Dict *dict, Tcl_Obj *keyPtr);
 
 /*
+ * Table of dict subcommand names and implementations.
+ */
+
+static const EnsembleImplMap implementationMap[] = {
+    {"append",	DictAppendCmd,	TclCompileDictAppendCmd },
+    {"create",	DictCreateCmd,	NULL },
+    {"exists",	DictExistsCmd,	NULL },
+    {"filter",	DictFilterCmd,	NULL },
+    {"for",	DictForCmd,	TclCompileDictForCmd },
+    {"get",	DictGetCmd,	TclCompileDictGetCmd },
+    {"incr",	DictIncrCmd,	TclCompileDictIncrCmd },
+    {"info",	DictInfoCmd,	NULL },
+    {"keys",	DictKeysCmd,	NULL },
+    {"lappend",	DictLappendCmd,	TclCompileDictLappendCmd },
+    {"merge",	DictMergeCmd,	NULL },
+    {"remove",	DictRemoveCmd,	NULL },
+    {"replace",	DictReplaceCmd,	NULL },
+    {"set",	DictSetCmd,	TclCompileDictSetCmd },
+    {"size",	DictSizeCmd,	NULL },
+    {"unset",	DictUnsetCmd,	NULL },
+    {"update",	DictUpdateCmd,	TclCompileDictUpdateCmd },
+    {"values",	DictValuesCmd,	NULL },
+    {"with",	DictWithCmd,	NULL },
+    {NULL}
+};
+
+/*
  * Internal representation of the entries in the hash table that backs a
  * dictionary.
  */
@@ -136,6 +163,9 @@ Tcl_ObjType tclDictType = {
  * table defined in the tclObj.c code. This version differs in that it
  * allocates a bit more space in each hash entry in order to hold the pointers
  * used to keep the hash entries in a linked list.
+ *
+ * Note that this type of hash table is *only* suitable for direct use in
+ * *this* file. Everything else should use the dict iterator API.
  */
 
 static Tcl_HashKeyType chainHashType = {
@@ -1459,6 +1489,7 @@ Tcl_DbNewDictObj(
 
 static int
 DictCreateCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -1472,13 +1503,13 @@ DictCreateCmd(
      * easier.)
      */
 
-    if (objc & 1) {
-	Tcl_WrongNumArgs(interp, 2, objv, "?key value ...?");
+    if ((objc & 1) == 0) {
+	Tcl_WrongNumArgs(interp, 1, objv, "?key value ...?");
 	return TCL_ERROR;
     }
 
     dictObj = Tcl_NewDictObj();
-    for (i=2 ; i<objc ; i+=2) {
+    for (i=1 ; i<objc ; i+=2) {
 	/*
 	 * The next command is assumed to never fail...
 	 */
@@ -1508,6 +1539,7 @@ DictCreateCmd(
 
 static int
 DictGetCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -1515,8 +1547,8 @@ DictGetCmd(
     Tcl_Obj *dictPtr, *valuePtr = NULL;
     int result;
 
-    if (objc < 3) {
-	Tcl_WrongNumArgs(interp, 2, objv, "dictionary ?key key ...?");
+    if (objc < 2) {
+	Tcl_WrongNumArgs(interp, 1, objv, "dictionary ?key key ...?");
 	return TCL_ERROR;
     }
 
@@ -1526,12 +1558,12 @@ DictGetCmd(
      * list handling more efficient.
      */
 
-    if (objc == 3) {
+    if (objc == 2) {
 	Tcl_Obj *keyPtr, *listPtr;
 	Tcl_DictSearch search;
 	int done;
 
-	result = Tcl_DictObjFirst(interp, objv[2], &search,
+	result = Tcl_DictObjFirst(interp, objv[1], &search,
 		&keyPtr, &valuePtr, &done);
 	if (result != TCL_OK) {
 	    return result;
@@ -1560,7 +1592,7 @@ DictGetCmd(
      * Note that this loop always executes at least once.
      */
 
-    dictPtr = TclTraceDictPath(interp, objv[2], objc-4,objv+3, DICT_PATH_READ);
+    dictPtr = TclTraceDictPath(interp, objv[1], objc-3,objv+2, DICT_PATH_READ);
     if (dictPtr == NULL) {
 	return TCL_ERROR;
     }
@@ -1598,6 +1630,7 @@ DictGetCmd(
 
 static int
 DictReplaceCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -1606,17 +1639,17 @@ DictReplaceCmd(
     int i, result;
     int allocatedDict = 0;
 
-    if ((objc < 3) || !(objc & 1)) {
-	Tcl_WrongNumArgs(interp, 2, objv, "dictionary ?key value ...?");
+    if ((objc < 2) || (objc & 1)) {
+	Tcl_WrongNumArgs(interp, 1, objv, "dictionary ?key value ...?");
 	return TCL_ERROR;
     }
 
-    dictPtr = objv[2];
+    dictPtr = objv[1];
     if (Tcl_IsShared(dictPtr)) {
 	dictPtr = Tcl_DuplicateObj(dictPtr);
 	allocatedDict = 1;
     }
-    for (i=3 ; i<objc ; i+=2) {
+    for (i=2 ; i<objc ; i+=2) {
 	result = Tcl_DictObjPut(interp, dictPtr, objv[i], objv[i+1]);
 	if (result != TCL_OK) {
 	    if (allocatedDict) {
@@ -1649,6 +1682,7 @@ DictReplaceCmd(
 
 static int
 DictRemoveCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -1657,17 +1691,17 @@ DictRemoveCmd(
     int i, result;
     int allocatedDict = 0;
 
-    if (objc < 3) {
-	Tcl_WrongNumArgs(interp, 2, objv, "dictionary ?key ...?");
+    if (objc < 2) {
+	Tcl_WrongNumArgs(interp, 1, objv, "dictionary ?key ...?");
 	return TCL_ERROR;
     }
 
-    dictPtr = objv[2];
+    dictPtr = objv[1];
     if (Tcl_IsShared(dictPtr)) {
 	dictPtr = Tcl_DuplicateObj(dictPtr);
 	allocatedDict = 1;
     }
-    for (i=3 ; i<objc ; i++) {
+    for (i=2 ; i<objc ; i++) {
 	result = Tcl_DictObjRemove(interp, dictPtr, objv[i]);
 	if (result != TCL_OK) {
 	    if (allocatedDict) {
@@ -1700,6 +1734,7 @@ DictRemoveCmd(
 
 static int
 DictMergeCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -1709,7 +1744,7 @@ DictMergeCmd(
     int i, done;
     Tcl_DictSearch search;
 
-    if (objc == 2) {
+    if (objc == 1) {
 	/*
 	 * No dictionary arguments; return default (empty value).
 	 */
@@ -1717,18 +1752,23 @@ DictMergeCmd(
 	return TCL_OK;
     }
 
-    if (objc == 3) {
+    /*
+     * Make sure first argument is a dictionary.
+     */
+
+    targetObj = objv[1];
+    if (targetObj->typePtr != &tclDictType) {
+	if (SetDictFromAny(interp, targetObj) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+    }
+
+    if (objc == 2) {
 	/*
-	 * Single argument, make sure it is a dictionary, but otherwise return
-	 * it.
+	 * Single argument, return it.
 	 */
 
-	if (objv[2]->typePtr != &tclDictType) {
-	    if (SetDictFromAny(interp, objv[2]) != TCL_OK) {
-		return TCL_ERROR;
-	    }
-	}
-	Tcl_SetObjResult(interp, objv[2]);
+	Tcl_SetObjResult(interp, objv[1]);
 	return TCL_OK;
     }
 
@@ -1736,12 +1776,11 @@ DictMergeCmd(
      * Normal behaviour: combining two (or more) dictionaries.
      */
 
-    targetObj = objv[2];
     if (Tcl_IsShared(targetObj)) {
 	targetObj = Tcl_DuplicateObj(targetObj);
 	allocatedDict = 1;
     }
-    for (i=3 ; i<objc ; i++) {
+    for (i=2 ; i<objc ; i++) {
 	if (Tcl_DictObjFirst(interp, objv[i], &search, &keyObj, &valueObj,
 		&done) != TCL_OK) {
 	    if (allocatedDict) {
@@ -1750,16 +1789,15 @@ DictMergeCmd(
 	    return TCL_ERROR;
 	}
 	while (!done) {
-	    if (Tcl_DictObjPut(interp, targetObj,
-		    keyObj, valueObj) != TCL_OK) {
-		Tcl_DictObjDone(&search);
-		if (allocatedDict) {
-		    TclDecrRefCount(targetObj);
-		}
-		return TCL_ERROR;
-	    }
+	    /*
+	     * Next line can't fail; already know we have a dictionary in
+	     * targetObj.
+	     */
+
+	    Tcl_DictObjPut(NULL, targetObj, keyObj, valueObj);
 	    Tcl_DictObjNext(&search, &keyObj, &valueObj, &done);
 	}
+	Tcl_DictObjDone(&search);
     }
     Tcl_SetObjResult(interp, targetObj);
     return TCL_OK;
@@ -1785,6 +1823,7 @@ DictMergeCmd(
 
 static int
 DictKeysCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -1792,8 +1831,8 @@ DictKeysCmd(
     Tcl_Obj *listPtr;
     char *pattern = NULL;
 
-    if (objc!=3 && objc!=4) {
-	Tcl_WrongNumArgs(interp, 2, objv, "dictionary ?pattern?");
+    if (objc!=2 && objc!=3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "dictionary ?pattern?");
 	return TCL_ERROR;
     }
 
@@ -1803,24 +1842,24 @@ DictKeysCmd(
      * need. [Bug 1705778, leak K04]
      */
 
-    if (objv[2]->typePtr != &tclDictType) {
-	int result = SetDictFromAny(interp, objv[2]);
+    if (objv[1]->typePtr != &tclDictType) {
+	int result = SetDictFromAny(interp, objv[1]);
 
 	if (result != TCL_OK) {
 	    return result;
 	}
     }
 
-    if (objc == 4) {
-	pattern = TclGetString(objv[3]);
+    if (objc == 3) {
+	pattern = TclGetString(objv[2]);
     }
     listPtr = Tcl_NewListObj(0, NULL);
     if ((pattern != NULL) && TclMatchIsTrivial(pattern)) {
 	Tcl_Obj *valuePtr = NULL;
 
-	Tcl_DictObjGet(interp, objv[2], objv[3], &valuePtr);
+	Tcl_DictObjGet(interp, objv[1], objv[2], &valuePtr);
 	if (valuePtr != NULL) {
-	    Tcl_ListObjAppendElement(NULL, listPtr, objv[3]);
+	    Tcl_ListObjAppendElement(NULL, listPtr, objv[2]);
 	}
     } else {
 	Tcl_DictSearch search;
@@ -1834,12 +1873,13 @@ DictKeysCmd(
 	 * can start the iteration process without checking for failures.
 	 */
 
-	Tcl_DictObjFirst(NULL, objv[2], &search, &keyPtr, NULL, &done);
+	Tcl_DictObjFirst(NULL, objv[1], &search, &keyPtr, NULL, &done);
 	for (; !done ; Tcl_DictObjNext(&search, &keyPtr, NULL, &done)) {
 	    if (!pattern || Tcl_StringMatch(TclGetString(keyPtr), pattern)) {
 		Tcl_ListObjAppendElement(NULL, listPtr, keyPtr);
 	    }
 	}
+	Tcl_DictObjDone(&search);
     }
 
     Tcl_SetObjResult(interp, listPtr);
@@ -1866,26 +1906,29 @@ DictKeysCmd(
 
 static int
 DictValuesCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
 {
     Tcl_Obj *valuePtr, *listPtr;
     Tcl_DictSearch search;
-    int result, done;
-    char *pattern = NULL;
+    int done;
+    char *pattern;
 
-    if (objc!=3 && objc!=4) {
-	Tcl_WrongNumArgs(interp, 2, objv, "dictionary ?pattern?");
+    if (objc!=2 && objc!=3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "dictionary ?pattern?");
 	return TCL_ERROR;
     }
 
-    result= Tcl_DictObjFirst(interp, objv[2], &search, NULL, &valuePtr, &done);
-    if (result != TCL_OK) {
+    if (Tcl_DictObjFirst(interp, objv[1], &search, NULL, &valuePtr,
+	    &done) != TCL_OK) {
 	return TCL_ERROR;
     }
-    if (objc == 4) {
-	pattern = TclGetString(objv[3]);
+    if (objc == 3) {
+	pattern = TclGetString(objv[2]);
+    } else {
+	pattern = NULL;
     }
     listPtr = Tcl_NewListObj(0, NULL);
     for (; !done ; Tcl_DictObjNext(&search, NULL, &valuePtr, &done)) {
@@ -1897,6 +1940,7 @@ DictValuesCmd(
 	    Tcl_ListObjAppendElement(interp, listPtr, valuePtr);
 	}
     }
+    Tcl_DictObjDone(&search);
 
     Tcl_SetObjResult(interp, listPtr);
     return TCL_OK;
@@ -1922,17 +1966,18 @@ DictValuesCmd(
 
 static int
 DictSizeCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
 {
     int result, size;
 
-    if (objc != 3) {
-	Tcl_WrongNumArgs(interp, 2, objv, "dictionary");
+    if (objc != 2) {
+	Tcl_WrongNumArgs(interp, 1, objv, "dictionary");
 	return TCL_ERROR;
     }
-    result = Tcl_DictObjSize(interp, objv[2], &size);
+    result = Tcl_DictObjSize(interp, objv[1], &size);
     if (result == TCL_OK) {
 	Tcl_SetObjResult(interp, Tcl_NewIntObj(size));
     }
@@ -1959,6 +2004,7 @@ DictSizeCmd(
 
 static int
 DictExistsCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -1966,12 +2012,12 @@ DictExistsCmd(
     Tcl_Obj *dictPtr, *valuePtr;
     int result;
 
-    if (objc < 4) {
-	Tcl_WrongNumArgs(interp, 2, objv, "dictionary key ?key ...?");
+    if (objc < 3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "dictionary key ?key ...?");
 	return TCL_ERROR;
     }
 
-    dictPtr = TclTraceDictPath(interp, objv[2], objc-4, objv+3,
+    dictPtr = TclTraceDictPath(interp, objv[1], objc-3, objv+2,
 	    DICT_PATH_EXISTS);
     if (dictPtr == NULL) {
 	return TCL_ERROR;
@@ -2008,6 +2054,7 @@ DictExistsCmd(
 
 static int
 DictInfoCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2015,12 +2062,12 @@ DictInfoCmd(
     Tcl_Obj *dictPtr;
     Dict *dict;
 
-    if (objc != 3) {
-	Tcl_WrongNumArgs(interp, 2, objv, "dictionary");
+    if (objc != 2) {
+	Tcl_WrongNumArgs(interp, 1, objv, "dictionary");
 	return TCL_ERROR;
     }
 
-    dictPtr = objv[2];
+    dictPtr = objv[1];
     if (dictPtr->typePtr != &tclDictType) {
 	int result = SetDictFromAny(interp, dictPtr);
 	if (result != TCL_OK) {
@@ -2057,6 +2104,7 @@ DictInfoCmd(
 
 static int
 DictIncrCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2064,19 +2112,19 @@ DictIncrCmd(
     int code = TCL_OK;
     Tcl_Obj *dictPtr, *valuePtr = NULL;
 
-    if (objc < 4 || objc > 5) {
-	Tcl_WrongNumArgs(interp, 2, objv, "varName key ?increment?");
+    if (objc < 3 || objc > 4) {
+	Tcl_WrongNumArgs(interp, 1, objv, "varName key ?increment?");
 	return TCL_ERROR;
     }
 
-    dictPtr = Tcl_ObjGetVar2(interp, objv[2], NULL, 0);
+    dictPtr = Tcl_ObjGetVar2(interp, objv[1], NULL, 0);
     if (dictPtr == NULL) {
 	/*
 	 * Variable didn't yet exist. Create new dictionary value.
 	 */
 
 	dictPtr = Tcl_NewDictObj();
-    } else if (Tcl_DictObjGet(interp, dictPtr, objv[3], &valuePtr) != TCL_OK) {
+    } else if (Tcl_DictObjGet(interp, dictPtr, objv[2], &valuePtr) != TCL_OK) {
 	/*
 	 * Variable contents are not a dict, report error.
 	 */
@@ -2100,21 +2148,21 @@ DictIncrCmd(
 	 * Key not in dictionary. Create new key with increment as value.
 	 */
 
-	if (objc == 5) {
+	if (objc == 4) {
 	    /*
 	     * Verify increment is an integer.
 	     */
 
 	    mp_int increment;
 
-	    code = Tcl_GetBignumFromObj(interp, objv[4], &increment);
+	    code = Tcl_GetBignumFromObj(interp, objv[3], &increment);
 	    if (code != TCL_OK) {
 		Tcl_AddErrorInfo(interp, "\n    (reading increment)");
 	    } else {
-		Tcl_DictObjPut(interp, dictPtr, objv[3], objv[4]);
+		Tcl_DictObjPut(interp, dictPtr, objv[2], objv[3]);
 	    }
 	} else {
-	    Tcl_DictObjPut(interp, dictPtr, objv[3], Tcl_NewIntObj(1));
+	    Tcl_DictObjPut(interp, dictPtr, objv[2], Tcl_NewIntObj(1));
 	}
     } else {
 	/*
@@ -2123,12 +2171,13 @@ DictIncrCmd(
 
 	if (Tcl_IsShared(valuePtr)) {
 	    valuePtr = Tcl_DuplicateObj(valuePtr);
-	    Tcl_DictObjPut(interp, dictPtr, objv[3], valuePtr);
+	    Tcl_DictObjPut(interp, dictPtr, objv[2], valuePtr);
 	}
-	if (objc == 5) {
-	    code = TclIncrObj(interp, valuePtr, objv[4]);
+	if (objc == 4) {
+	    code = TclIncrObj(interp, valuePtr, objv[3]);
 	} else {
 	    Tcl_Obj *incrPtr = Tcl_NewIntObj(1);
+
 	    Tcl_IncrRefCount(incrPtr);
 	    code = TclIncrObj(interp, valuePtr, incrPtr);
 	    Tcl_DecrRefCount(incrPtr);
@@ -2136,7 +2185,7 @@ DictIncrCmd(
     }
     if (code == TCL_OK) {
 	Tcl_InvalidateStringRep(dictPtr);
-	valuePtr = Tcl_ObjSetVar2(interp, objv[2], NULL,
+	valuePtr = Tcl_ObjSetVar2(interp, objv[1], NULL,
 		dictPtr, TCL_LEAVE_ERR_MSG);
 	if (valuePtr == NULL) {
 	    code = TCL_ERROR;
@@ -2169,6 +2218,7 @@ DictIncrCmd(
 
 static int
 DictLappendCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2176,12 +2226,12 @@ DictLappendCmd(
     Tcl_Obj *dictPtr, *valuePtr, *resultPtr;
     int i, allocatedDict = 0, allocatedValue = 0;
 
-    if (objc < 4) {
-	Tcl_WrongNumArgs(interp, 2, objv, "varName key ?value ...?");
+    if (objc < 3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "varName key ?value ...?");
 	return TCL_ERROR;
     }
 
-    dictPtr = Tcl_ObjGetVar2(interp, objv[2], NULL, 0);
+    dictPtr = Tcl_ObjGetVar2(interp, objv[1], NULL, 0);
     if (dictPtr == NULL) {
 	allocatedDict = 1;
 	dictPtr = Tcl_NewDictObj();
@@ -2190,7 +2240,7 @@ DictLappendCmd(
 	dictPtr = Tcl_DuplicateObj(dictPtr);
     }
 
-    if (Tcl_DictObjGet(interp, dictPtr, objv[3], &valuePtr) != TCL_OK) {
+    if (Tcl_DictObjGet(interp, dictPtr, objv[2], &valuePtr) != TCL_OK) {
 	if (allocatedDict) {
 	    TclDecrRefCount(dictPtr);
 	}
@@ -2198,7 +2248,7 @@ DictLappendCmd(
     }
 
     if (valuePtr == NULL) {
-	valuePtr = Tcl_NewListObj(objc-4, objv+4);
+	valuePtr = Tcl_NewListObj(objc-3, objv+3);
 	allocatedValue = 1;
     } else {
 	if (Tcl_IsShared(valuePtr)) {
@@ -2206,7 +2256,7 @@ DictLappendCmd(
 	    valuePtr = Tcl_DuplicateObj(valuePtr);
 	}
 
-	for (i=4 ; i<objc ; i++) {
+	for (i=3 ; i<objc ; i++) {
 	    if (Tcl_ListObjAppendElement(interp, valuePtr,
 		    objv[i]) != TCL_OK) {
 		if (allocatedValue) {
@@ -2221,12 +2271,12 @@ DictLappendCmd(
     }
 
     if (allocatedValue) {
-	Tcl_DictObjPut(interp, dictPtr, objv[3], valuePtr);
+	Tcl_DictObjPut(interp, dictPtr, objv[2], valuePtr);
     } else if (dictPtr->bytes != NULL) {
 	Tcl_InvalidateStringRep(dictPtr);
     }
 
-    resultPtr = Tcl_ObjSetVar2(interp, objv[2], NULL, dictPtr,
+    resultPtr = Tcl_ObjSetVar2(interp, objv[1], NULL, dictPtr,
 	    TCL_LEAVE_ERR_MSG);
     if (resultPtr == NULL) {
 	return TCL_ERROR;
@@ -2255,6 +2305,7 @@ DictLappendCmd(
 
 static int
 DictAppendCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2262,12 +2313,12 @@ DictAppendCmd(
     Tcl_Obj *dictPtr, *valuePtr, *resultPtr;
     int i, allocatedDict = 0;
 
-    if (objc < 4) {
-	Tcl_WrongNumArgs(interp, 2, objv, "varName key ?value ...?");
+    if (objc < 3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "varName key ?value ...?");
 	return TCL_ERROR;
     }
 
-    dictPtr = Tcl_ObjGetVar2(interp, objv[2], NULL, 0);
+    dictPtr = Tcl_ObjGetVar2(interp, objv[1], NULL, 0);
     if (dictPtr == NULL) {
 	allocatedDict = 1;
 	dictPtr = Tcl_NewDictObj();
@@ -2276,7 +2327,7 @@ DictAppendCmd(
 	dictPtr = Tcl_DuplicateObj(dictPtr);
     }
 
-    if (Tcl_DictObjGet(interp, dictPtr, objv[3], &valuePtr) != TCL_OK) {
+    if (Tcl_DictObjGet(interp, dictPtr, objv[2], &valuePtr) != TCL_OK) {
 	if (allocatedDict) {
 	    TclDecrRefCount(dictPtr);
 	}
@@ -2291,13 +2342,13 @@ DictAppendCmd(
 	}
     }
 
-    for (i=4 ; i<objc ; i++) {
+    for (i=3 ; i<objc ; i++) {
 	Tcl_AppendObjToObj(valuePtr, objv[i]);
     }
 
-    Tcl_DictObjPut(interp, dictPtr, objv[3], valuePtr);
+    Tcl_DictObjPut(interp, dictPtr, objv[2], valuePtr);
 
-    resultPtr = Tcl_ObjSetVar2(interp, objv[2], NULL, dictPtr,
+    resultPtr = Tcl_ObjSetVar2(interp, objv[1], NULL, dictPtr,
 	    TCL_LEAVE_ERR_MSG);
     if (resultPtr == NULL) {
 	return TCL_ERROR;
@@ -2326,23 +2377,24 @@ DictAppendCmd(
 
 static int
 DictForCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
 {
-    Interp* iPtr = (Interp*) interp;
+    Interp *iPtr = (Interp *) interp;
     Tcl_Obj *scriptObj, *keyVarObj, *valueVarObj;
     Tcl_Obj **varv, *keyObj, *valueObj;
     Tcl_DictSearch search;
     int varc, done, result;
 
-    if (objc != 5) {
-	Tcl_WrongNumArgs(interp, 2, objv,
+    if (objc != 4) {
+	Tcl_WrongNumArgs(interp, 1, objv,
 		"{keyVar valueVar} dictionary script");
 	return TCL_ERROR;
     }
 
-    if (TclListObjGetElements(interp, objv[2], &varc, &varv) != TCL_OK) {
+    if (TclListObjGetElements(interp, objv[1], &varc, &varv) != TCL_OK) {
 	return TCL_ERROR;
     }
     if (varc != 2) {
@@ -2350,11 +2402,11 @@ DictForCmd(
 		TCL_STATIC);
 	return TCL_ERROR;
     }
-    keyVarObj    = varv[0];
-    valueVarObj  = varv[1];
-    scriptObj   = objv[4];
+    keyVarObj = varv[0];
+    valueVarObj = varv[1];
+    scriptObj = objv[3];
 
-    if (Tcl_DictObjFirst(interp, objv[3], &search, &keyObj, &valueObj,
+    if (Tcl_DictObjFirst(interp, objv[2], &search, &keyObj, &valueObj,
 	    &done) != TCL_OK) {
 	return TCL_ERROR;
     }
@@ -2398,7 +2450,7 @@ DictForCmd(
 	 * TIP #280. Make invoking context available to loop body.
 	 */
 
-	result = TclEvalObjEx(interp, scriptObj, 0, iPtr->cmdFramePtr, 4);
+	result = TclEvalObjEx(interp, scriptObj, 0, iPtr->cmdFramePtr, 3);
 	if (result == TCL_CONTINUE) {
 	    result = TCL_OK;
 	} else if (result != TCL_OK) {
@@ -2450,6 +2502,7 @@ DictForCmd(
 
 static int
 DictSetCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2457,12 +2510,12 @@ DictSetCmd(
     Tcl_Obj *dictPtr, *resultPtr;
     int result, allocatedDict = 0;
 
-    if (objc < 5) {
-	Tcl_WrongNumArgs(interp, 2, objv, "varName key ?key ...? value");
+    if (objc < 4) {
+	Tcl_WrongNumArgs(interp, 1, objv, "varName key ?key ...? value");
 	return TCL_ERROR;
     }
 
-    dictPtr = Tcl_ObjGetVar2(interp, objv[2], NULL, 0);
+    dictPtr = Tcl_ObjGetVar2(interp, objv[1], NULL, 0);
     if (dictPtr == NULL) {
 	allocatedDict = 1;
 	dictPtr = Tcl_NewDictObj();
@@ -2471,7 +2524,7 @@ DictSetCmd(
 	dictPtr = Tcl_DuplicateObj(dictPtr);
     }
 
-    result = Tcl_DictObjPutKeyList(interp, dictPtr, objc-4, objv+3,
+    result = Tcl_DictObjPutKeyList(interp, dictPtr, objc-3, objv+2,
 	    objv[objc-1]);
     if (result != TCL_OK) {
 	if (allocatedDict) {
@@ -2480,7 +2533,7 @@ DictSetCmd(
 	return TCL_ERROR;
     }
 
-    resultPtr = Tcl_ObjSetVar2(interp, objv[2], NULL, dictPtr,
+    resultPtr = Tcl_ObjSetVar2(interp, objv[1], NULL, dictPtr,
 	    TCL_LEAVE_ERR_MSG);
     if (resultPtr == NULL) {
 	return TCL_ERROR;
@@ -2509,6 +2562,7 @@ DictSetCmd(
 
 static int
 DictUnsetCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2516,12 +2570,12 @@ DictUnsetCmd(
     Tcl_Obj *dictPtr, *resultPtr;
     int result, allocatedDict = 0;
 
-    if (objc < 4) {
-	Tcl_WrongNumArgs(interp, 2, objv, "varName key ?key ...?");
+    if (objc < 3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "varName key ?key ...?");
 	return TCL_ERROR;
     }
 
-    dictPtr = Tcl_ObjGetVar2(interp, objv[2], NULL, 0);
+    dictPtr = Tcl_ObjGetVar2(interp, objv[1], NULL, 0);
     if (dictPtr == NULL) {
 	allocatedDict = 1;
 	dictPtr = Tcl_NewDictObj();
@@ -2530,7 +2584,7 @@ DictUnsetCmd(
 	dictPtr = Tcl_DuplicateObj(dictPtr);
     }
 
-    result = Tcl_DictObjRemoveKeyList(interp, dictPtr, objc-3, objv+3);
+    result = Tcl_DictObjRemoveKeyList(interp, dictPtr, objc-2, objv+2);
     if (result != TCL_OK) {
 	if (allocatedDict) {
 	    TclDecrRefCount(dictPtr);
@@ -2538,7 +2592,7 @@ DictUnsetCmd(
 	return TCL_ERROR;
     }
 
-    resultPtr = Tcl_ObjSetVar2(interp, objv[2], NULL, dictPtr,
+    resultPtr = Tcl_ObjSetVar2(interp, objv[1], NULL, dictPtr,
 	    TCL_LEAVE_ERR_MSG);
     if (resultPtr == NULL) {
 	return TCL_ERROR;
@@ -2567,11 +2621,12 @@ DictUnsetCmd(
 
 static int
 DictFilterCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
 {
-    Interp* iPtr = (Interp*) interp;
+    Interp *iPtr = (Interp *) interp;
     static const char *filters[] = {
 	"key", "script", "value", NULL
     };
@@ -2584,19 +2639,19 @@ DictFilterCmd(
     int index, varc, done, result, satisfied;
     char *pattern;
 
-    if (objc < 4) {
-	Tcl_WrongNumArgs(interp, 2, objv, "dictionary filterType ...");
+    if (objc < 3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "dictionary filterType ...");
 	return TCL_ERROR;
     }
-    if (Tcl_GetIndexFromObj(interp, objv[3], filters, "filterType",
+    if (Tcl_GetIndexFromObj(interp, objv[2], filters, "filterType",
 	     0, &index) != TCL_OK) {
 	return TCL_ERROR;
     }
 
     switch ((enum FilterTypes) index) {
     case FILTER_KEYS:
-	if (objc != 5) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "dictionary key globPattern");
+	if (objc != 4) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "dictionary key globPattern");
 	    return TCL_ERROR;
 	}
 
@@ -2604,11 +2659,11 @@ DictFilterCmd(
 	 * Create a dictionary whose keys all match a certain pattern.
 	 */
 
-	if (Tcl_DictObjFirst(interp, objv[2], &search,
+	if (Tcl_DictObjFirst(interp, objv[1], &search,
 		&keyObj, &valueObj, &done) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	pattern = TclGetString(objv[4]);
+	pattern = TclGetString(objv[3]);
 	resultObj = Tcl_NewDictObj();
 	if (TclMatchIsTrivial(pattern)) {
 	    /*
@@ -2617,9 +2672,9 @@ DictFilterCmd(
 	     */
 
 	    Tcl_DictObjDone(&search);
-	    Tcl_DictObjGet(interp, objv[2], objv[4], &valueObj);
+	    Tcl_DictObjGet(interp, objv[1], objv[3], &valueObj);
 	    if (valueObj != NULL) {
-		Tcl_DictObjPut(interp, resultObj, objv[4], valueObj);
+		Tcl_DictObjPut(interp, resultObj, objv[3], valueObj);
 	    }
 	} else {
 	    while (!done) {
@@ -2633,8 +2688,8 @@ DictFilterCmd(
 	return TCL_OK;
 
     case FILTER_VALUES:
-	if (objc != 5) {
-	    Tcl_WrongNumArgs(interp, 2, objv, "dictionary value globPattern");
+	if (objc != 4) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "dictionary value globPattern");
 	    return TCL_ERROR;
 	}
 
@@ -2642,11 +2697,11 @@ DictFilterCmd(
 	 * Create a dictionary whose values all match a certain pattern.
 	 */
 
-	if (Tcl_DictObjFirst(interp, objv[2], &search,
+	if (Tcl_DictObjFirst(interp, objv[1], &search,
 		&keyObj, &valueObj, &done) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	pattern = TclGetString(objv[4]);
+	pattern = TclGetString(objv[3]);
 	resultObj = Tcl_NewDictObj();
 	while (!done) {
 	    if (Tcl_StringMatch(TclGetString(valueObj), pattern)) {
@@ -2658,8 +2713,8 @@ DictFilterCmd(
 	return TCL_OK;
 
     case FILTER_SCRIPT:
-	if (objc != 6) {
-	    Tcl_WrongNumArgs(interp, 2, objv,
+	if (objc != 5) {
+	    Tcl_WrongNumArgs(interp, 1, objv,
 		    "dictionary script {keyVar valueVar} filterScript");
 	    return TCL_ERROR;
 	}
@@ -2670,7 +2725,7 @@ DictFilterCmd(
 	 * copying from the "dict for" implementation has occurred!
 	 */
 
-	if (TclListObjGetElements(interp, objv[4], &varc, &varv) != TCL_OK) {
+	if (TclListObjGetElements(interp, objv[3], &varc, &varv) != TCL_OK) {
 	    return TCL_ERROR;
 	}
 	if (varc != 2) {
@@ -2680,7 +2735,7 @@ DictFilterCmd(
 	}
 	keyVarObj = varv[0];
 	valueVarObj = varv[1];
-	scriptObj = objv[5];
+	scriptObj = objv[4];
 
 	/*
 	 * Make sure that these objects (which we need throughout the body of
@@ -2693,7 +2748,7 @@ DictFilterCmd(
 	Tcl_IncrRefCount(valueVarObj);
 	Tcl_IncrRefCount(scriptObj);
 
-	result = Tcl_DictObjFirst(interp, objv[2],
+	result = Tcl_DictObjFirst(interp, objv[1],
 		&search, &keyObj, &valueObj, &done);
 	if (result != TCL_OK) {
 	    TclDecrRefCount(keyVarObj);
@@ -2732,7 +2787,7 @@ DictFilterCmd(
 	     * TIP #280. Make invoking context available to loop body.
 	     */
 
-	    result = TclEvalObjEx(interp, scriptObj, 0, iPtr->cmdFramePtr, 5);
+	    result = TclEvalObjEx(interp, scriptObj, 0, iPtr->cmdFramePtr, 4);
 	    switch (result) {
 	    case TCL_OK:
 		boolObj = Tcl_GetObjResult(interp);
@@ -2826,21 +2881,23 @@ DictFilterCmd(
 
 static int
 DictUpdateCmd(
+    ClientData clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
 {
+    Interp *iPtr = (Interp *) interp;
     Tcl_Obj *dictPtr, *objPtr;
     int i, result, dummy;
     Tcl_InterpState state;
 
-    if (objc < 6 || objc & 1) {
-	Tcl_WrongNumArgs(interp, 2, objv,
+    if (objc < 5 || !(objc & 1)) {
+	Tcl_WrongNumArgs(interp, 1, objv,
 		"varName key varName ?key varName ...? script");
 	return TCL_ERROR;
     }
 
-    dictPtr = Tcl_ObjGetVar2(interp, objv[2], NULL, TCL_LEAVE_ERR_MSG);
+    dictPtr = Tcl_ObjGetVar2(interp, objv[1], NULL, TCL_LEAVE_ERR_MSG);
     if (dictPtr == NULL) {
 	return TCL_ERROR;
     }
@@ -2848,7 +2905,7 @@ DictUpdateCmd(
 	return TCL_ERROR;
     }
     Tcl_IncrRefCount(dictPtr);
-    for (i=3 ; i+2<objc ; i+=2) {
+    for (i=2 ; i+2<objc ; i+=2) {
 	if (Tcl_DictObjGet(interp, dictPtr, objv[i], &objPtr) != TCL_OK) {
 	    TclDecrRefCount(dictPtr);
 	    return TCL_ERROR;
@@ -2868,7 +2925,7 @@ DictUpdateCmd(
      * Execute the body.
      */
 
-    result = Tcl_EvalObj(interp, objv[objc-1]);
+    result = TclEvalObjEx(interp, objv[objc-1], 0, iPtr->cmdFramePtr, objc-1);
     if (result == TCL_ERROR) {
 	Tcl_AddErrorInfo(interp, "\n    (body of \"dict update\")");
     }
@@ -2877,7 +2934,7 @@ DictUpdateCmd(
      * If the dictionary variable doesn't exist, drop everything silently.
      */
 
-    dictPtr = Tcl_ObjGetVar2(interp, objv[2], NULL, 0);
+    dictPtr = Tcl_ObjGetVar2(interp, objv[1], NULL, 0);
     if (dictPtr == NULL) {
 	return result;
     }
@@ -2901,7 +2958,7 @@ DictUpdateCmd(
      * an instruction to remove the key.
      */
 
-    for (i=3 ; i+2<objc ; i+=2) {
+    for (i=2 ; i+2<objc ; i+=2) {
 	objPtr = Tcl_ObjGetVar2(interp, objv[i+1], NULL, 0);
 	if (objPtr == NULL) {
 	    Tcl_DictObjRemove(interp, dictPtr, objv[i]);
@@ -2923,7 +2980,7 @@ DictUpdateCmd(
      * Write the dictionary back to its variable.
      */
 
-    if (Tcl_ObjSetVar2(interp, objv[2], NULL, dictPtr,
+    if (Tcl_ObjSetVar2(interp, objv[1], NULL, dictPtr,
 	    TCL_LEAVE_ERR_MSG) == NULL) {
 	Tcl_DiscardInterpState(state);
 	return TCL_ERROR;
@@ -2952,18 +3009,19 @@ DictUpdateCmd(
 
 static int
 DictWithCmd(
+    ClientData dummy,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
 {
-    Interp* iPtr = (Interp*) interp;
+    Interp *iPtr = (Interp *) interp;
     Tcl_Obj *dictPtr, *keysPtr, *keyPtr, *valPtr, **keyv, *leafPtr;
     Tcl_DictSearch s;
     Tcl_InterpState state;
-    int done, result, keyc, i, allocdict=0;
+    int done, result, keyc, i, allocdict = 0;
 
-    if (objc < 4) {
-	Tcl_WrongNumArgs(interp, 2, objv, "dictVar ?key ...? script");
+    if (objc < 3) {
+	Tcl_WrongNumArgs(interp, 1, objv, "dictVar ?key ...? script");
 	return TCL_ERROR;
     }
 
@@ -2971,12 +3029,12 @@ DictWithCmd(
      * Get the dictionary to open out.
      */
 
-    dictPtr = Tcl_ObjGetVar2(interp, objv[2], NULL, TCL_LEAVE_ERR_MSG);
+    dictPtr = Tcl_ObjGetVar2(interp, objv[1], NULL, TCL_LEAVE_ERR_MSG);
     if (dictPtr == NULL) {
 	return TCL_ERROR;
     }
-    if (objc > 4) {
-	dictPtr = TclTraceDictPath(interp, dictPtr, objc-4, objv+3,
+    if (objc > 3) {
+	dictPtr = TclTraceDictPath(interp, dictPtr, objc-3, objv+2,
 		DICT_PATH_READ);
 	if (dictPtr == NULL) {
 	    return TCL_ERROR;
@@ -3022,7 +3080,7 @@ DictWithCmd(
      * If the dictionary variable doesn't exist, drop everything silently.
      */
 
-    dictPtr = Tcl_ObjGetVar2(interp, objv[2], NULL, 0);
+    dictPtr = Tcl_ObjGetVar2(interp, objv[1], NULL, 0);
     if (dictPtr == NULL) {
 	TclDecrRefCount(keysPtr);
 	return result;
@@ -3044,7 +3102,7 @@ DictWithCmd(
 	allocdict = 1;
     }
 
-    if (objc > 4) {
+    if (objc > 3) {
 	/*
 	 * Want to get to the dictionary which we will update; need to do
 	 * prepare-for-update de-sharing along the path *but* avoid generating
@@ -3054,7 +3112,7 @@ DictWithCmd(
 	 * perfectly efficient (but no memory should be leaked).
 	 */
 
-	leafPtr = TclTraceDictPath(interp, dictPtr, objc-4, objv+3,
+	leafPtr = TclTraceDictPath(interp, dictPtr, objc-3, objv+2,
 		DICT_PATH_EXISTS | DICT_PATH_UPDATE);
 	if (leafPtr == NULL) {
 	    TclDecrRefCount(keysPtr);
@@ -3102,7 +3160,7 @@ DictWithCmd(
      * rep.
      */
 
-    if (objc > 4) {
+    if (objc > 3) {
 	InvalidateDictChain(leafPtr);
     }
 
@@ -3110,7 +3168,7 @@ DictWithCmd(
      * Write back the outermost dictionary to the variable.
      */
 
-    if (Tcl_ObjSetVar2(interp, objv[2], NULL, dictPtr,
+    if (Tcl_ObjSetVar2(interp, objv[1], NULL, dictPtr,
 	    TCL_LEAVE_ERR_MSG) == NULL) {
 	Tcl_DiscardInterpState(state);
 	return TCL_ERROR;
@@ -3121,78 +3179,26 @@ DictWithCmd(
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_DictObjCmd --
+ * TclInitDictCmd --
  *
- *	This function is invoked to process the "dict" Tcl command. See the
- *	user documentation for details on what it does, and TIP#111 for the
- *	formal specification.
+ *	This function is create the "dict" Tcl command. See the user
+ *	documentation for details on what it does, and TIP#111 for the formal
+ *	specification.
  *
  * Results:
- *	A standard Tcl result.
+ *	A Tcl command handle.
  *
  * Side effects:
- *	See the user documentation.
+ *	May advance compilation epoch.
  *
  *----------------------------------------------------------------------
  */
 
-int
-Tcl_DictObjCmd(
-    /*ignored*/ ClientData clientData,
-    Tcl_Interp *interp,
-    int objc,
-    Tcl_Obj *const *objv)
+Tcl_Command
+TclInitDictCmd(
+    Tcl_Interp *interp)
 {
-    static const char *subcommands[] = {
-	"append", "create", "exists", "filter", "for",
-	"get", "incr", "info", "keys", "lappend", "merge",
-	"remove", "replace", "set", "size", "unset",
-	"update", "values", "with", NULL
-    };
-    enum DictSubcommands {
-	DICT_APPEND, DICT_CREATE, DICT_EXISTS, DICT_FILTER, DICT_FOR,
-	DICT_GET, DICT_INCR, DICT_INFO, DICT_KEYS, DICT_LAPPEND, DICT_MERGE,
-	DICT_REMOVE, DICT_REPLACE, DICT_SET, DICT_SIZE, DICT_UNSET,
-	DICT_UPDATE, DICT_VALUES, DICT_WITH
-    };
-    int index;
-
-    if (objc < 2) {
-	Tcl_WrongNumArgs(interp, 1, objv, "subcommand ?arg ...?");
-	return TCL_ERROR;
-    }
-    if (Tcl_GetIndexFromObj(interp, objv[1], subcommands, "subcommand",
-	    0, &index) != TCL_OK) {
-	return TCL_ERROR;
-    }
-    switch ((enum DictSubcommands) index) {
-    case DICT_APPEND:	return DictAppendCmd(interp, objc, objv);
-    case DICT_CREATE:	return DictCreateCmd(interp, objc, objv);
-    case DICT_EXISTS:	return DictExistsCmd(interp, objc, objv);
-    case DICT_FILTER:	return DictFilterCmd(interp, objc, objv);
-    case DICT_FOR:	return DictForCmd(interp, objc, objv);
-    case DICT_GET:	return DictGetCmd(interp, objc, objv);
-    case DICT_INCR:	return DictIncrCmd(interp, objc, objv);
-    case DICT_INFO:	return DictInfoCmd(interp, objc, objv);
-    case DICT_KEYS:	return DictKeysCmd(interp, objc, objv);
-    case DICT_LAPPEND:	return DictLappendCmd(interp, objc, objv);
-    case DICT_MERGE:	return DictMergeCmd(interp, objc, objv);
-    case DICT_REMOVE:	return DictRemoveCmd(interp, objc, objv);
-    case DICT_REPLACE:	return DictReplaceCmd(interp, objc, objv);
-    case DICT_SET:	return DictSetCmd(interp, objc, objv);
-    case DICT_SIZE:	return DictSizeCmd(interp, objc, objv);
-    case DICT_UNSET:	return DictUnsetCmd(interp, objc, objv);
-    case DICT_UPDATE:	return DictUpdateCmd(interp, objc, objv);
-    case DICT_VALUES:	return DictValuesCmd(interp, objc, objv);
-    case DICT_WITH:	return DictWithCmd(interp, objc, objv);
-    }
-    Tcl_Panic("unexpected fallthrough");
-
-    /*
-     * Next line is NOT REACHED - stops compliler complaint though...
-     */
-
-    return TCL_ERROR;
+    return TclMakeEnsemble(interp, "dict", implementationMap);
 }
 
 /*
diff --git a/generic/tclIORChan.c b/generic/tclIORChan.c
index 1a65770..c15bb10 100644
--- a/generic/tclIORChan.c
+++ b/generic/tclIORChan.c
@@ -15,7 +15,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclIORChan.c,v 1.24.2.1 2007/11/21 06:30:52 dgp Exp $
+ * RCS: @(#) $Id: tclIORChan.c,v 1.24.2.2 2007/11/25 06:45:44 dgp Exp $
  */
 
 #include <tclInt.h>
@@ -137,6 +137,23 @@ typedef struct {
 } ReflectedChannel;
 
 /*
+ * Structure of the table maping from channel handles to reflected
+ * channels. Each interpreter which has the handler command for one or more
+ * reflected channels records them in such a table, so that 'chan postevent'
+ * is able to find them even if the actual channel was moved to a different
+ * interpreter and/or thread.
+ *
+ * The table is reachable via the standard interpreter AssocData, the key is
+ * defined below.
+ */
+
+typedef struct {
+    Tcl_HashTable map;
+} ReflectedChannelMap;
+
+#define RCMKEY "ReflectedChannelMap"
+
+/*
  * Event literals. ==================================================
  */
 
@@ -402,6 +419,10 @@ static int		InvokeTclMethod(ReflectedChannel *rcPtr,
 			    const char *method, Tcl_Obj *argOneObj,
 			    Tcl_Obj *argTwoObj, Tcl_Obj **resultObjPtr);
 
+static ReflectedChannelMap *	GetReflectedChannelMap(Tcl_Interp *interp);
+static void		DeleteReflectedChannelMap(ClientData clientData,
+			    Tcl_Interp *interp);
+
 /*
  * Global constant strings (messages). ==================
  * These string are used directly as bypass errors, thus they have to be valid
@@ -464,6 +485,9 @@ TclChanCreateObjCmd(
     int methods;		/* Bitmask for supported methods. */
     Channel *chanPtr;		/* 'chan' resolved to internal struct. */
     Tcl_Obj *err;		/* Error message */
+    ReflectedChannelMap* rcmPtr; /* Map of reflected channels with handlers in this interp */
+    Tcl_HashEntry* hPtr;         /* Entry in the above map */
+    int isNew;                   /* Placeholder. */
 
     /*
      * Syntax:   chan create MODE CMDPREFIX
@@ -655,8 +679,23 @@ TclChanCreateObjCmd(
 	chanPtr->typePtr = clonePtr;
     }
 
+    /*
+     * Register the channel in the I/O system, and in our our map for 'chan
+     * postevent'.
+     */
+
     Tcl_RegisterChannel(interp, chan);
 
+    rcmPtr = GetReflectedChannelMap (interp);
+    hPtr   = Tcl_CreateHashEntry(&rcmPtr->map,
+				 chanPtr->state->channelName, &isNew);
+    if (!isNew) {
+	if (chanPtr != Tcl_GetHashValue(hPtr)) {
+	    Tcl_Panic("TclChanCreateObjCmd: duplicate channel names");
+	}
+    }
+    Tcl_SetHashValue(hPtr, chan);
+
     /*
      * Return handle as result of command.
      */
@@ -720,8 +759,9 @@ TclChanPostEventObjCmd(
     const Tcl_ChannelType *chanTypePtr;
 				/* Its associated driver structure */
     ReflectedChannel *rcPtr;	/* Associated instance data */
-    int mode;			/* Dummy, r|w mode of the channel */
     int events;			/* Mask of events to post */
+    ReflectedChannelMap* rcmPtr; /* Map of reflected channels with handlers in this interp */
+    Tcl_HashEntry* hPtr;         /* Entry in the above map */
 
     /*
      * Number of arguments...
@@ -738,12 +778,34 @@ TclChanPostEventObjCmd(
      */
 
     chanId = TclGetString(objv[CHAN]);
-    chan = Tcl_GetChannel(interp, chanId, &mode);
 
-    if (chan == NULL) {
+    rcmPtr = GetReflectedChannelMap (interp);
+    hPtr = Tcl_FindHashEntry (&rcmPtr->map, chanId);
+
+    if (hPtr == NULL) {
+	Tcl_AppendResult(interp, "can not find reflected channel named \"", chanId,
+		"\"", NULL);
+	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "CHANNEL", chanId, NULL);
 	return TCL_ERROR;
     }
 
+    /*
+     * Note that the search above subsumes several of the older checks, namely:
+     *
+     * (1) Does the channel handle refer to a reflected channel ?
+     * (2) Is the post event issued from the interpreter holding the handler
+     *     of the reflected channel ?
+     *
+     * A successful search answers yes to both. Because the map holds only
+     * handles of reflected channels, and only of such whose handler is
+     * defined in this interpreter.
+     *
+     * We keep the old checks for both, for paranioa, but abort now instead of
+     * throwing errors, as failure now means that our internal datastructures
+     * have gone seriously haywire.
+     */
+
+    chan        = Tcl_GetHashValue(hPtr);
     chanTypePtr = Tcl_GetChannelType(chan);
 
     /*
@@ -756,17 +818,13 @@ TclChanPostEventObjCmd(
      */
 
     if (chanTypePtr->watchProc != &ReflectWatch) {
-	Tcl_AppendResult(interp, "channel \"", chanId,
-		"\" is not a reflected channel", NULL);
-	return TCL_ERROR;
+	Tcl_Panic ("TclChanPostEventObjCmd: channel is not a reflected channel");
     }
 
     rcPtr = (ReflectedChannel *) Tcl_GetChannelInstanceData(chan);
 
     if (rcPtr->interp != interp) {
-	Tcl_AppendResult(interp, "postevent for channel \"", chanId,
-		"\" called from outside interpreter", NULL);
-	return TCL_ERROR;
+	Tcl_Panic ("TclChanPostEventObjCmd: postevent accepted for call from outside interpreter");
     }
 
     /*
@@ -2099,6 +2157,84 @@ InvokeTclMethod(
     return result;
 }
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * GetReflectedChannelMap --
+ *
+ *	Gets and potentially initializes the reflected channel map for an
+ *	interpreter.
+ *
+ * Results:
+ *	A pointer to the map created, for use by the caller.
+ *
+ * Side effects:
+ *	Initializes the reflected channel map for an interpreter.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static ReflectedChannelMap *
+GetReflectedChannelMap(
+    Tcl_Interp *interp)
+{
+    ReflectedChannelMap* rcmPtr = Tcl_GetAssocData(interp, RCMKEY, NULL);
+
+    if (rcmPtr == NULL) {
+	rcmPtr = (ReflectedChannelMap *) ckalloc(sizeof(ReflectedChannelMap));
+	Tcl_InitHashTable(&rcmPtr->map, TCL_STRING_KEYS);
+	Tcl_SetAssocData(interp, RCMKEY,
+		(Tcl_InterpDeleteProc *) DeleteReflectedChannelMap, rcmPtr);
+    }
+    return rcmPtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * DeleteReflectedChannelMap --
+ *
+ *	Deletes the channel table for an interpreter, closing any open
+ *	channels whose refcount reaches zero. This procedure is invoked when
+ *	an interpreter is deleted, via the AssocData cleanup mechanism.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Deletes the hash table of channels. May close channels. May flush
+ *	output on closed channels. Removes any channeEvent handlers that were
+ *	registered in this interpreter.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+DeleteReflectedChannelMap(
+    ClientData clientData,	/* The per-interpreter data structure. */
+    Tcl_Interp *interp)		/* The interpreter being deleted. */
+{
+    ReflectedChannelMap* rcmPtr; /* The map */
+    Tcl_HashSearch hSearch;	 /* Search variable. */
+    Tcl_HashEntry *hPtr;	 /* Search variable. */
+
+    /*
+     * Delete all entries. The channels may have been closed alreay, or will
+     * be closed later, by the standard IO finalization of an interpreter
+     * under destruction.
+     */
+
+    rcmPtr = clientData;
+    for (hPtr = Tcl_FirstHashEntry(&rcmPtr->map, &hSearch);
+	 hPtr != NULL;
+	 hPtr = Tcl_FirstHashEntry(&rcmPtr->map, &hSearch)) {
+
+	Tcl_DeleteHashEntry(hPtr);
+    }
+    Tcl_DeleteHashTable(&rcmPtr->map);
+    ckfree((char *) &rcmPtr->map);
+}
+
 #ifdef TCL_THREADS
 static void
 ForwardOpToOwnerThread(
diff --git a/generic/tclInt.h b/generic/tclInt.h
index e09e6ef..d05a9b6 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -13,7 +13,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclInt.h,v 1.310.2.18 2007/11/21 16:26:59 dgp Exp $
+ * RCS: @(#) $Id: tclInt.h,v 1.310.2.19 2007/11/25 06:45:44 dgp Exp $
  */
 
 #ifndef _TCLINT
@@ -2704,7 +2704,7 @@ MODULE_SCOPE int	TclChanPendingObjCmd(
 MODULE_SCOPE int	TclChanTruncateObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
-MODULE_SCOPE void	TclClockInit(Tcl_Interp*);
+MODULE_SCOPE void	TclClockInit(Tcl_Interp *interp);
 MODULE_SCOPE int	TclClockOldscanObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
@@ -2723,9 +2723,7 @@ MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler(
 MODULE_SCOPE int	TclDefaultBgErrorHandlerObjCmd(
 			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_DictObjCmd(ClientData clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
+MODULE_SCOPE Tcl_Command TclInitDictCmd(Tcl_Interp *interp);
 MODULE_SCOPE int	Tcl_DisassembleObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
@@ -2892,9 +2890,7 @@ MODULE_SCOPE int	Tcl_SocketObjCmd(ClientData clientData,
 MODULE_SCOPE int	Tcl_SourceObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_StringObjCmd(ClientData clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
+MODULE_SCOPE Tcl_Command TclInitStringCmd(Tcl_Interp *interp);
 MODULE_SCOPE int	Tcl_SubstObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
@@ -2953,7 +2949,25 @@ MODULE_SCOPE int	TclCompileCatchCmd(Tcl_Interp *interp,
 MODULE_SCOPE int	TclCompileContinueCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclCompileDictCmd(Tcl_Interp *interp,
+MODULE_SCOPE int	TclCompileDictAppendCmd(Tcl_Interp *interp,
+			    Tcl_Parse *parsePtr, Command *cmdPtr,
+			    struct CompileEnv *envPtr);
+MODULE_SCOPE int	TclCompileDictForCmd(Tcl_Interp *interp,
+			    Tcl_Parse *parsePtr, Command *cmdPtr,
+			    struct CompileEnv *envPtr);
+MODULE_SCOPE int	TclCompileDictGetCmd(Tcl_Interp *interp,
+			    Tcl_Parse *parsePtr, Command *cmdPtr,
+			    struct CompileEnv *envPtr);
+MODULE_SCOPE int	TclCompileDictIncrCmd(Tcl_Interp *interp,
+			    Tcl_Parse *parsePtr, Command *cmdPtr,
+			    struct CompileEnv *envPtr);
+MODULE_SCOPE int	TclCompileDictLappendCmd(Tcl_Interp *interp,
+			    Tcl_Parse *parsePtr, Command *cmdPtr,
+			    struct CompileEnv *envPtr);
+MODULE_SCOPE int	TclCompileDictSetCmd(Tcl_Interp *interp,
+			    Tcl_Parse *parsePtr, Command *cmdPtr,
+			    struct CompileEnv *envPtr);
+MODULE_SCOPE int	TclCompileDictUpdateCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
 MODULE_SCOPE int	TclCompileEnsemble(Tcl_Interp *interp,
@@ -3013,7 +3027,19 @@ MODULE_SCOPE int	TclCompileReturnCmd(Tcl_Interp *interp,
 MODULE_SCOPE int	TclCompileSetCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclCompileStringCmd(Tcl_Interp *interp,
+MODULE_SCOPE int	TclCompileStringCmpCmd(Tcl_Interp *interp,
+			    Tcl_Parse *parsePtr, Command *cmdPtr,
+			    struct CompileEnv *envPtr);
+MODULE_SCOPE int	TclCompileStringEqualCmd(Tcl_Interp *interp,
+			    Tcl_Parse *parsePtr, Command *cmdPtr,
+			    struct CompileEnv *envPtr);
+MODULE_SCOPE int	TclCompileStringIndexCmd(Tcl_Interp *interp,
+			    Tcl_Parse *parsePtr, Command *cmdPtr,
+			    struct CompileEnv *envPtr);
+MODULE_SCOPE int	TclCompileStringLenCmd(Tcl_Interp *interp,
+			    Tcl_Parse *parsePtr, Command *cmdPtr,
+			    struct CompileEnv *envPtr);
+MODULE_SCOPE int	TclCompileStringMatchCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
 MODULE_SCOPE int	TclCompileSwitchCmd(Tcl_Interp *interp,
diff --git a/generic/tclVar.c b/generic/tclVar.c
index 35254b6..14b37a6 100644
--- a/generic/tclVar.c
+++ b/generic/tclVar.c
@@ -16,7 +16,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclVar.c,v 1.135.2.12 2007/11/21 06:30:55 dgp Exp $
+ * RCS: @(#) $Id: tclVar.c,v 1.135.2.13 2007/11/25 06:45:44 dgp Exp $
  */
 
 #include "tclInt.h"
@@ -3048,9 +3048,9 @@ Tcl_ArrayObjCmd(
     case ARRAY_NAMES: {
 	Tcl_HashSearch search;
 	Var *varPtr2;
-	char *pattern = NULL;
+	char *pattern;
 	char *name;
-	Tcl_Obj *namePtr, *resultPtr;
+	Tcl_Obj *namePtr, *resultPtr, *patternPtr;
 	int mode, matched = 0;
 	static const char *options[] = {
 	    "-exact", "-glob", "-regexp", NULL
@@ -3067,18 +3067,23 @@ Tcl_ArrayObjCmd(
 	    return TCL_OK;
 	}
 	if (objc == 4) {
-	    pattern = TclGetString(objv[3]);
+	    patternPtr = objv[3];
+	    pattern = TclGetString(patternPtr);
 	} else if (objc == 5) {
-	    pattern = TclGetString(objv[4]);
+	    patternPtr = objv[4];
+	    pattern = TclGetString(patternPtr);
 	    if (Tcl_GetIndexFromObj(interp, objv[3], options, "option", 0,
 		    &mode) != TCL_OK) {
 		return TCL_ERROR;
 	    }
+	} else {
+	    patternPtr = NULL;
+	    pattern = NULL;
 	}
 	TclNewObj(resultPtr);
 	if (((enum options) mode)==OPT_GLOB && pattern!=NULL &&
 		TclMatchIsTrivial(pattern)) {
-	    varPtr2 = VarHashFindVar(varPtr->value.tablePtr, objv[3]);
+	    varPtr2 = VarHashFindVar(varPtr->value.tablePtr, patternPtr);
 	    if ((varPtr2 != NULL) && !TclIsVarUndefined(varPtr2)) {
 		result = Tcl_ListObjAppendElement(interp, resultPtr,
 			VarHashGetKey(varPtr2));
diff --git a/tests/dict.test b/tests/dict.test
index e45c954..96c14fa 100644
--- a/tests/dict.test
+++ b/tests/dict.test
@@ -9,7 +9,7 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: dict.test,v 1.20.2.1 2007/09/09 04:14:29 dgp Exp $
+# RCS: @(#) $Id: dict.test,v 1.20.2.2 2007/11/25 06:45:45 dgp Exp $
 
 if {[lsearch [namespace children] ::tcltest] == -1} {
     package require tcltest 2
@@ -35,10 +35,10 @@ proc getOrder {dictVal args} {
 
 test dict-1.1 {dict command basic syntax} {
     list [catch {dict} msg] $msg
-} {1 {wrong # args: should be "dict subcommand ?arg ...?"}}
+} {1 {wrong # args: should be "dict subcommand ?argument ...?"}}
 test dict-1.2 {dict command basic syntax} {
     list [catch {dict ?} msg] $msg
-} {1 {bad subcommand "?": must be append, create, exists, filter, for, get, incr, info, keys, lappend, merge, remove, replace, set, size, unset, update, values, or with}}
+} {1 {unknown or ambiguous subcommand "?": must be append, create, exists, filter, for, get, incr, info, keys, lappend, merge, remove, replace, set, size, unset, update, values, or with}}
 
 test dict-2.1 {dict create command} {
     dict create
diff --git a/tests/ioCmd.test b/tests/ioCmd.test
index 9eda3f7..6bb72af 100644
--- a/tests/ioCmd.test
+++ b/tests/ioCmd.test
@@ -13,7 +13,7 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: ioCmd.test,v 1.31.2.2 2007/11/21 06:44:32 dgp Exp $
+# RCS: @(#) $Id: ioCmd.test,v 1.31.2.3 2007/11/25 06:45:45 dgp Exp $
 
 if {[lsearch [namespace children] ::tcltest] == -1} {
     package require tcltest 2
@@ -1732,7 +1732,7 @@ test iocmd-31.1 {chan postevent, restricted to reflected channels} -match glob -
     close $c
     removeFile goo
     set msg
-} -result {channel "file*" is not a reflected channel}
+} -result {can not find reflected channel named "file*"}
 test iocmd-31.2 {chan postevent, unwanted events} -match glob -body {
     set res {}
     proc foo {args} {oninit; onfinal; track; return}
@@ -3182,7 +3182,7 @@ test iocmd.tf-31.8 {chan postevent, bad input} -match glob -body {
     rename foo {}
     set res
 } -constraints {testchannel testthread} \
-    -result {{postevent for channel "rc*" called from outside interpreter}}
+    -result {{can not find reflected channel named "rc*"}}
 
 # ### ### ### ######### ######### #########
 
diff --git a/tests/string.test b/tests/string.test
index 134e2cb..29dafcf 100644
--- a/tests/string.test
+++ b/tests/string.test
@@ -12,7 +12,7 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: string.test,v 1.62.2.5 2007/11/21 06:44:32 dgp Exp $
+# RCS: @(#) $Id: string.test,v 1.62.2.6 2007/11/25 06:45:45 dgp Exp $
 
 if {[lsearch [namespace children] ::tcltest] == -1} {
     package require tcltest
@@ -26,10 +26,10 @@ testConstraint testindexobj [expr {[info commands testindexobj] != {}}]
 
 test string-1.1 {error conditions} {
     list [catch {string gorp a b} msg] $msg
-} {1 {bad option "gorp": must be bytelength, compare, equal, first, index, is, last, length, map, match, range, repeat, replace, reverse, tolower, toupper, totitle, trim, trimleft, trimright, wordend, or wordstart}}
+} {1 {unknown or ambiguous subcommand "gorp": must be bytelength, compare, equal, first, index, is, last, length, map, match, range, repeat, replace, reverse, tolower, totitle, toupper, trim, trimleft, trimright, wordend, or wordstart}}
 test string-1.2 {error conditions} {
     list [catch {string} msg] $msg
-} {1 {wrong # args: should be "string option arg ?arg ...?"}}
+} {1 {wrong # args: should be "string subcommand ?argument ...?"}}
 
 test string-2.1 {string compare, too few args} {
     list [catch {string compare a} msg] $msg
@@ -1131,6 +1131,11 @@ test string-12.21 {string range, regenerates correct reps, bug 1410553} {
     binary scan $rxCRC "H*" rxCRC_hex
     list $input_hex $rxBuffer_hex $rxCRC_hex
 } {000341 000341 0341}
+test string-12.22 {string range, shimmering binary/index} {
+    set s 0000000001
+    binary scan $s a* x
+    string range $s $s end
+} 000000001
 
 test string-13.1 {string repeat} {
     list [catch {string repeat} msg] $msg
@@ -1357,7 +1362,7 @@ test string-20.1 {string trimright errors} {
 } {1 {wrong # args: should be "string trimright string ?chars?"}}
 test string-20.2 {string trimright errors} {
     list [catch {string trimg a} msg] $msg
-} {1 {bad option "trimg": must be bytelength, compare, equal, first, index, is, last, length, map, match, range, repeat, replace, reverse, tolower, toupper, totitle, trim, trimleft, trimright, wordend, or wordstart}}
+} {1 {unknown or ambiguous subcommand "trimg": must be bytelength, compare, equal, first, index, is, last, length, map, match, range, repeat, replace, reverse, tolower, totitle, toupper, trim, trimleft, trimright, wordend, or wordstart}}
 test string-20.3 {string trimright} {
     string trimright "    XYZ      "
 } {    XYZ}
@@ -1413,7 +1418,7 @@ test string-21.14 {string wordend, unicode} {
 
 test string-22.1 {string wordstart} {
     list [catch {string word a} msg] $msg
-} {1 {ambiguous option "word": must be bytelength, compare, equal, first, index, is, last, length, map, match, range, repeat, replace, reverse, tolower, toupper, totitle, trim, trimleft, trimright, wordend, or wordstart}}
+} {1 {unknown or ambiguous subcommand "word": must be bytelength, compare, equal, first, index, is, last, length, map, match, range, repeat, replace, reverse, tolower, totitle, toupper, trim, trimleft, trimright, wordend, or wordstart}}
 test string-22.2 {string wordstart} {
     list [catch {string wordstart a} msg] $msg
 } {1 {wrong # args: should be "string wordstart string index"}}
diff --git a/tests/stringComp.test b/tests/stringComp.test
index 3ccfc75..dfbe57f 100644
--- a/tests/stringComp.test
+++ b/tests/stringComp.test
@@ -15,7 +15,7 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: stringComp.test,v 1.11.2.2 2007/10/16 03:50:33 dgp Exp $
+# RCS: @(#) $Id: stringComp.test,v 1.11.2.3 2007/11/25 06:45:45 dgp Exp $
 
 if {[lsearch [namespace children] ::tcltest] == -1} {
     package require tcltest
@@ -29,11 +29,11 @@ testConstraint testobj [expr {[info commands testobj] != {}}]
 test stringComp-1.1 {error conditions} {
     proc foo {} {string gorp a b}
     list [catch {foo} msg] $msg
-} {1 {bad option "gorp": must be bytelength, compare, equal, first, index, is, last, length, map, match, range, repeat, replace, reverse, tolower, toupper, totitle, trim, trimleft, trimright, wordend, or wordstart}}
+} {1 {unknown or ambiguous subcommand "gorp": must be bytelength, compare, equal, first, index, is, last, length, map, match, range, repeat, replace, reverse, tolower, totitle, toupper, trim, trimleft, trimright, wordend, or wordstart}}
 test stringComp-1.2 {error conditions} {
     proc foo {} {string}
     list [catch {foo} msg] $msg
-} {1 {wrong # args: should be "string option arg ?arg ...?"}}
+} {1 {wrong # args: should be "string subcommand ?argument ...?"}}
 test stringComp-1.3 {error condition - undefined method during compile} {
     # We don't want this to complain about 'never' because it may never
     # be called, or string may get redefined.  This must compile OK.
diff --git a/tests/var.test b/tests/var.test
index 57c6fe4..42a1024 100644
--- a/tests/var.test
+++ b/tests/var.test
@@ -14,7 +14,7 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: var.test,v 1.28 2007/03/12 18:06:14 dgp Exp $
+# RCS: @(#) $Id: var.test,v 1.28.2.1 2007/11/25 06:45:45 dgp Exp $
 #
 
 if {[lsearch [namespace children] ::tcltest] == -1} {
@@ -680,6 +680,10 @@ test var-14.1 {array names syntax} -body {
     array names foo bar baz snafu
 } -returnCodes 1 -match glob -result *
 
+test var-14.2 {array names -glob} -body {
+    array names tcl_platform -glob os
+} -returnCodes 0 -match exact -result os
+
 test var-15.1 {segfault in [unset], [Bug 735335]} {
     proc A { name } {
 	upvar $name var