Simplify command compilation by moving numerous common stanzas into macros so that things say what they do instead of relying on the code-writer knowing all the basic ropes.

Also cleaned up the whitespace/style of the code

1 files changed, 887 insertions, 863 deletions

diff --git a/generic/tclCompCmds.c b/generic/tclCompCmds.c
index 9598d84..a00106a 100644
--- a/generic/tclCompCmds.c
+++ b/generic/tclCompCmds.c
@@ -1,33 +1,33 @@
-/* 
+/*
  * tclCompCmds.c --
  *
  *	This file contains compilation procedures that compile various
- *	Tcl commands into a sequence of instructions ("bytecodes"). 
+ *	Tcl commands into a sequence of instructions ("bytecodes").
  *
  * Copyright (c) 1997-1998 Sun Microsystems, Inc.
  * Copyright (c) 2001 by Kevin B. Kenny.  All rights reserved.
  * Copyright (c) 2002 ActiveState Corporation.
+ * Copyright (c) 2004 Donal K. Fellows.
  *
  * 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.70 2005/06/01 11:00:35 dkf Exp $
+ * RCS: @(#) $Id: tclCompCmds.c,v 1.71 2005/06/12 22:13:27 dkf Exp $
  */
 
 #include "tclInt.h"
 #include "tclCompile.h"
 
 /*
- * Macro that encapsulates an efficiency trick that avoids a function
- * call for the simplest of compiles.  The ANSI C "prototype" for this
- * macro is:
+ * Macro that encapsulates an efficiency trick that avoids a function call for
+ * the simplest of compiles.  The ANSI C "prototype" for this macro is:
  *
- * static void		CompileWord _ANSI_ARGS((CompileEnv *envPtr,
- * 			    Tcl_Token *tokenPtr, Tcl_Inter *interp));
+ * static void		CompileWord(CompileEnv *envPtr, Tcl_Token *tokenPtr,
+ *			    Tcl_Interp *interp);
  */
 
 #define CompileWord(envPtr, tokenPtr, interp) \
-   if ((tokenPtr)->type == TCL_TOKEN_SIMPLE_WORD) { \
+    if ((tokenPtr)->type == TCL_TOKEN_SIMPLE_WORD) { \
 	TclEmitPush(TclRegisterNewLiteral((envPtr), (tokenPtr)[1].start, \
 		(tokenPtr)[1].size), (envPtr)); \
     } else { \
@@ -36,6 +36,49 @@
     }
 
 /*
+ * Convenience macro for use when compiling bodies of commands. The ANSI C
+ * "prototype" for this macro is:
+ *
+ * static void		CompileBody(CompileEnv *envPtr, Tcl_Token *tokenPtr,
+ *			    Tcl_Interp *interp);
+ */
+
+#define CompileBody(envPtr, tokenPtr, interp) \
+    TclCompileCmdWord((interp), (tokenPtr)+1, (tokenPtr)->numComponents, \
+	    (envPtr))
+
+/*
+ * Convenience macro for use when pushing literals. The ANSI C "prototype" for
+ * this macro is:
+ *
+ * static void		PushLiteral(CompileEnv *envPtr,
+ *			    const char *string, int length);
+ */
+
+#define PushLiteral(envPtr, string, length) \
+    TclEmitPush(TclRegisterNewLiteral((envPtr), (string), (length)), (envPtr))
+
+/*
+ * Macro to advance to the next token; it is more mnemonic than the address
+ * arithmetic that it replaces. The ANSI C "prototype" for this macro is:
+ *
+ * static Tcl_Token *	TokenAfter(Tcl_Token *tokenPtr);
+ */
+
+#define TokenAfter(tokenPtr) \
+    ((tokenPtr) + ((tokenPtr)->numComponents + 1))
+
+/*
+ * Macro to get the offset to the next instruction to be issued. The ANSI C
+ * "prototype" for this macro is:
+ *
+ * static int	TokenAfter(CompileEnv *envPtr);
+ */
+
+#define CurrentOffset(envPtr) \
+    ((envPtr)->codeNext - (envPtr)->codeStart)
+
+/*
  * Prototypes for procedures defined later in this file:
  */
 
@@ -57,9 +100,9 @@ static int		PushVarName _ANSI_ARGS_((Tcl_Interp *interp,
  */
 
 AuxDataType tclForeachInfoType = {
-    "ForeachInfo",				/* name */
-    DupForeachInfo,				/* dupProc */
-    FreeForeachInfo				/* freeProc */
+    "ForeachInfo",		/* name */
+    DupForeachInfo,		/* dupProc */
+    FreeForeachInfo		/* freeProc */
 };
 
 /*
@@ -70,12 +113,12 @@ AuxDataType tclForeachInfoType = {
  *	Procedure called to compile the "append" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "append" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "append" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -83,8 +126,8 @@ AuxDataType tclForeachInfoType = {
 int
 TclCompileAppendCmd(interp, parsePtr, envPtr)
     Tcl_Interp *interp;		/* Used for error reporting. */
-    Tcl_Parse *parsePtr;	/* Points to a parse structure for the
-				 * command created by Tcl_ParseCommand. */
+    Tcl_Parse *parsePtr;	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
 {
     Tcl_Token *varTokenPtr, *valueTokenPtr;
@@ -92,41 +135,40 @@ TclCompileAppendCmd(interp, parsePtr, envPtr)
 
     numWords = parsePtr->numWords;
     if (numWords == 1) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     } else if (numWords == 2) {
 	/*
 	 * append varName == set varName
 	 */
-        return TclCompileSetCmd(interp, parsePtr, envPtr);
+	return TclCompileSetCmd(interp, parsePtr, envPtr);
     } else if (numWords > 3) {
 	/*
 	 * APPEND instructions currently only handle one value
 	 */
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
 
     /*
-     * Decide if we can use a frame slot for the var/array name or if we
-     * need to emit code to compute and push the name at runtime. We use a
-     * frame slot (entry in the array of local vars) if we are compiling a
-     * procedure body and if the name is simple text that does not include
-     * namespace qualifiers. 
+     * Decide if we can use a frame slot for the var/array name or if we need
+     * to emit code to compute and push the name at runtime. We use a frame
+     * slot (entry in the array of local vars) if we are compiling a procedure
+     * body and if the name is simple text that does not include namespace
+     * qualifiers.
      */
 
-    varTokenPtr = parsePtr->tokenPtr
-	    + (parsePtr->tokenPtr->numComponents + 1);
+    varTokenPtr = TokenAfter(parsePtr->tokenPtr);
 
     PushVarName(interp, varTokenPtr, envPtr, TCL_CREATE_VAR,
 	    &localIndex, &simpleVarName, &isScalar);
 
     /*
-     * We are doing an assignment, otherwise TclCompileSetCmd was called,
-     * so push the new value.  This will need to be extended to push a
-     * value for each argument.
+     * We are doing an assignment, otherwise TclCompileSetCmd was called, so
+     * push the new value.  This will need to be extended to push a value for
+     * each argument.
      */
 
     if (numWords > 2) {
-	valueTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
+	valueTokenPtr = TokenAfter(varTokenPtr);
 	CompileWord(envPtr, valueTokenPtr, interp);
     }
 
@@ -136,24 +178,20 @@ TclCompileAppendCmd(interp, parsePtr, envPtr)
 
     if (simpleVarName) {
 	if (isScalar) {
-	    if (localIndex >= 0) {
-		if (localIndex <= 255) {
-		    TclEmitInstInt1(INST_APPEND_SCALAR1, localIndex, envPtr);
-		} else {
-		    TclEmitInstInt4(INST_APPEND_SCALAR4, localIndex, envPtr);
-		}
-	    } else {
+	    if (localIndex < 0) {
 		TclEmitOpcode(INST_APPEND_STK, envPtr);
+	    } else if (localIndex <= 255) {
+		TclEmitInstInt1(INST_APPEND_SCALAR1, localIndex, envPtr);
+	    } else {
+		TclEmitInstInt4(INST_APPEND_SCALAR4, localIndex, envPtr);
 	    }
 	} else {
-	    if (localIndex >= 0) {
-		if (localIndex <= 255) {
-		    TclEmitInstInt1(INST_APPEND_ARRAY1, localIndex, envPtr);
-		} else {
-		    TclEmitInstInt4(INST_APPEND_ARRAY4, localIndex, envPtr);
-		}
-	    } else {
+	    if (localIndex < 0) {
 		TclEmitOpcode(INST_APPEND_ARRAY_STK, envPtr);
+	    } else if (localIndex <= 255) {
+		TclEmitInstInt1(INST_APPEND_ARRAY1, localIndex, envPtr);
+	    } else {
+		TclEmitInstInt4(INST_APPEND_ARRAY4, localIndex, envPtr);
 	    }
 	}
     } else {
@@ -171,12 +209,12 @@ TclCompileAppendCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "break" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "break" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "break" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -184,8 +222,8 @@ TclCompileAppendCmd(interp, parsePtr, envPtr)
 int
 TclCompileBreakCmd(interp, parsePtr, envPtr)
     Tcl_Interp *interp;		/* Used for error reporting. */
-    Tcl_Parse *parsePtr;	/* Points to a parse structure for the
-				 * command created by Tcl_ParseCommand. */
+    Tcl_Parse *parsePtr;	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
 {
     if (parsePtr->numWords != 1) {
@@ -208,12 +246,12 @@ TclCompileBreakCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "catch" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "catch" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "catch" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -232,8 +270,8 @@ TclCompileCatchCmd(interp, parsePtr, envPtr)
     int savedStackDepth = envPtr->currStackDepth;
 
     /*
-     * If syntax does not match what we expect for [catch], do not
-     * compile.  Let runtime checks determine if syntax has changed.
+     * If syntax does not match what we expect for [catch], do not compile.
+     * Let runtime checks determine if syntax has changed.
      */
     if ((parsePtr->numWords != 2) && (parsePtr->numWords != 3)) {
 	return TCL_ERROR;
@@ -241,8 +279,7 @@ TclCompileCatchCmd(interp, parsePtr, envPtr)
 
     /*
      * If a variable was specified and the catch command is at global level
-     * (not in a procedure), don't compile it inline: the payoff is
-     * too small.
+     * (not in a procedure), don't compile it inline: the payoff is too small.
      */
 
     if ((parsePtr->numWords == 3) && (envPtr->procPtr == NULL)) {
@@ -255,10 +292,9 @@ TclCompileCatchCmd(interp, parsePtr, envPtr)
      */
 
     localIndex = -1;
-    cmdTokenPtr = parsePtr->tokenPtr
-	    + (parsePtr->tokenPtr->numComponents + 1);
+    cmdTokenPtr = TokenAfter(parsePtr->tokenPtr);
     if (parsePtr->numWords == 3) {
-	nameTokenPtr = cmdTokenPtr + (cmdTokenPtr->numComponents + 1);
+	nameTokenPtr = TokenAfter(cmdTokenPtr);
 	/* DGP */
 	if (nameTokenPtr->type == TCL_TOKEN_SIMPLE_WORD) {
 	    name = nameTokenPtr[1].start;
@@ -267,51 +303,50 @@ TclCompileCatchCmd(interp, parsePtr, envPtr)
 		return TCL_ERROR;
 	    }
 	    localIndex = TclFindCompiledLocal(nameTokenPtr[1].start,
-		    nameTokenPtr[1].size, /*create*/ 1, 
-		    /*flags*/ VAR_SCALAR, envPtr->procPtr);
+		    nameTokenPtr[1].size, /*create*/ 1, VAR_SCALAR,
+		    envPtr->procPtr);
 	} else {
 	   return TCL_ERROR;
 	}
     }
 
     /*
-     * We will compile the catch command. Emit a beginCatch instruction at
-     * the start of the catch body: the subcommand it controls.
+     * We will compile the catch command. Emit a beginCatch instruction at the
+     * start of the catch body: the subcommand it controls.
      */
 
     envPtr->exceptDepth++;
     envPtr->maxExceptDepth =
-	TclMax(envPtr->exceptDepth, envPtr->maxExceptDepth);
+	    TclMax(envPtr->exceptDepth, envPtr->maxExceptDepth);
     range = TclCreateExceptRange(CATCH_EXCEPTION_RANGE, envPtr);
     TclEmitInstInt4(INST_BEGIN_CATCH4, range, envPtr);
 
     /*
-     * If the body is a simple word, compile the instructions to
-     * eval it. Otherwise, compile instructions to substitute its
-     * text without catching, a catch instruction that resets the 
-     * stack to what it was before substituting the body, and then 
-     * an instruction to eval the body. Care has to be taken to 
-     * register the correct startOffset for the catch range so that
-     * errors in the substitution are not catched [Bug 219184]
+     * If the body is a simple word, compile the instructions to eval it.
+     * Otherwise, compile instructions to substitute its text without
+     * catching, a catch instruction that resets the stack to what it was
+     * before substituting the body, and then an instruction to eval the body.
+     * Care has to be taken to register the correct startOffset for the catch
+     * range so that errors in the substitution are not catched [Bug 219184]
      */
 
     if (cmdTokenPtr->type == TCL_TOKEN_SIMPLE_WORD) {
-	startOffset = (envPtr->codeNext - envPtr->codeStart);
-	TclCompileCmdWord(interp, cmdTokenPtr+1, 1, envPtr);
+	startOffset = CurrentOffset(envPtr);
+	CompileBody(envPtr, cmdTokenPtr, envPtr);
     } else {
 	TclCompileTokens(interp, cmdTokenPtr+1,
-	        cmdTokenPtr->numComponents, envPtr);
-	startOffset = (envPtr->codeNext - envPtr->codeStart);
+		cmdTokenPtr->numComponents, envPtr);
+	startOffset = CurrentOffset(envPtr);
 	TclEmitOpcode(INST_EVAL_STK, envPtr);
     }
     envPtr->exceptArrayPtr[range].codeOffset = startOffset;
     envPtr->exceptArrayPtr[range].numCodeBytes =
-	    (envPtr->codeNext - envPtr->codeStart) - startOffset;
+	    CurrentOffset(envPtr) - startOffset;
 
     /*
      * The "no errors" epilogue code: store the body's result into the
-     * variable (if any), push "0" (TCL_OK) as the catch's "no error"
-     * result, and jump around the "error case" code.
+     * variable (if any), push "0" (TCL_OK) as the catch's "no error" result,
+     * and jump around the "error case" code.
      */
 
     if (localIndex != -1) {
@@ -322,7 +357,7 @@ TclCompileCatchCmd(interp, parsePtr, envPtr)
 	}
     }
     TclEmitOpcode(INST_POP, envPtr);
-    TclEmitPush(TclRegisterNewLiteral(envPtr, "0", 1), envPtr);
+    PushLiteral(envPtr, "0", 1);
     TclEmitForwardJump(envPtr, TCL_UNCONDITIONAL_JUMP, &jumpFixup);
 
     /*
@@ -332,8 +367,7 @@ TclCompileCatchCmd(interp, parsePtr, envPtr)
      */
 
     envPtr->currStackDepth = savedStackDepth;
-    envPtr->exceptArrayPtr[range].catchOffset =
-	    (envPtr->codeNext - envPtr->codeStart);
+    envPtr->exceptArrayPtr[range].catchOffset = CurrentOffset(envPtr);
     if (localIndex != -1) {
 	TclEmitOpcode(INST_PUSH_RESULT, envPtr);
 	if (localIndex <= 255) {
@@ -347,13 +381,13 @@ TclCompileCatchCmd(interp, parsePtr, envPtr)
 
 
     /*
-     * Update the target of the jump after the "no errors" code, then emit
-     * an endCatch instruction at the end of the catch command.
+     * Update the target of the jump after the "no errors" code, then emit an
+     * endCatch instruction at the end of the catch command.
      */
 
     if (TclFixupForwardJumpToHere(envPtr, &jumpFixup, 127)) {
 	Tcl_Panic("TclCompileCatchCmd: bad jump distance %d\n",
-		(envPtr->codeNext - envPtr->codeStart) - jumpFixup.codeOffset);
+		CurrentOffset(envPtr) - jumpFixup.codeOffset);
     }
     TclEmitOpcode(INST_END_CATCH, envPtr);
 
@@ -370,12 +404,12 @@ TclCompileCatchCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "continue" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "continue" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "continue" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -411,12 +445,12 @@ TclCompileContinueCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "expr" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "expr" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "expr" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -434,9 +468,8 @@ TclCompileExprCmd(interp, parsePtr, envPtr)
 	return TCL_ERROR;
     }
 
-    firstWordPtr = parsePtr->tokenPtr
-	    + (parsePtr->tokenPtr->numComponents + 1);
-    TclCompileExprWords(interp, firstWordPtr, (parsePtr->numWords-1), envPtr);
+    firstWordPtr = TokenAfter(parsePtr->tokenPtr);
+    TclCompileExprWords(interp, firstWordPtr, parsePtr->numWords-1, envPtr);
     return TCL_OK;
 }
 
@@ -448,12 +481,12 @@ TclCompileExprCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "for" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "for" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "for" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -480,9 +513,8 @@ TclCompileForCmd(interp, parsePtr, envPtr)
      * execute or execute forever, as in "for {} "$x > 5" {incr x} {}".
      */
 
-    startTokenPtr = parsePtr->tokenPtr
-	    + (parsePtr->tokenPtr->numComponents + 1);
-    testTokenPtr = startTokenPtr + (startTokenPtr->numComponents + 1);
+    startTokenPtr = TokenAfter(parsePtr->tokenPtr);
+    testTokenPtr = TokenAfter(startTokenPtr);
     if (testTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
 	return TCL_ERROR;
     }
@@ -492,17 +524,17 @@ TclCompileForCmd(interp, parsePtr, envPtr)
      * in order to insure correct behaviour [Bug 219166]
      */
 
-    nextTokenPtr = testTokenPtr + (testTokenPtr->numComponents + 1);
-    bodyTokenPtr = nextTokenPtr + (nextTokenPtr->numComponents + 1);
-    if ((nextTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) 
+    nextTokenPtr = TokenAfter(testTokenPtr);
+    bodyTokenPtr = TokenAfter(nextTokenPtr);
+    if ((nextTokenPtr->type != TCL_TOKEN_SIMPLE_WORD)
 	    || (bodyTokenPtr->type != TCL_TOKEN_SIMPLE_WORD)) {
 	return TCL_ERROR;
     }
 
     /*
-     * Create ExceptionRange records for the body and the "next" command.
-     * The "next" command's ExceptionRange supports break but not continue
-     * (and has a -1 continueOffset).
+     * Create ExceptionRange records for the body and the "next" command. The
+     * "next" command's ExceptionRange supports break but not continue (and
+     * has a -1 continueOffset).
      */
 
     envPtr->exceptDepth++;
@@ -515,8 +547,7 @@ TclCompileForCmd(interp, parsePtr, envPtr)
      * Inline compile the initial command.
      */
 
-    TclCompileCmdWord(interp, startTokenPtr+1,
-	    startTokenPtr->numComponents, envPtr);
+    CompileBody(envPtr, startTokenPtr, interp);
     TclEmitOpcode(INST_POP, envPtr);
 
     /*
@@ -537,13 +568,12 @@ TclCompileForCmd(interp, parsePtr, envPtr)
      * Compile the loop body.
      */
 
-    bodyCodeOffset = (envPtr->codeNext - envPtr->codeStart);
+    bodyCodeOffset = CurrentOffset(envPtr);
 
-    TclCompileCmdWord(interp, bodyTokenPtr+1,
-	    bodyTokenPtr->numComponents, envPtr);
+    CompileBody(envPtr, bodyTokenPtr, interp);
     envPtr->currStackDepth = savedStackDepth + 1;
     envPtr->exceptArrayPtr[bodyRange].numCodeBytes =
-	    (envPtr->codeNext - envPtr->codeStart) - bodyCodeOffset;
+	    CurrentOffset(envPtr) - bodyCodeOffset;
     TclEmitOpcode(INST_POP, envPtr);
 
 
@@ -551,15 +581,13 @@ TclCompileForCmd(interp, parsePtr, envPtr)
      * Compile the "next" subcommand.
      */
 
-    nextCodeOffset = (envPtr->codeNext - envPtr->codeStart);
+    nextCodeOffset = CurrentOffset(envPtr);
 
     envPtr->currStackDepth = savedStackDepth;
-    TclCompileCmdWord(interp, nextTokenPtr+1,
-	    nextTokenPtr->numComponents, envPtr);
+    CompileBody(envPtr, nextTokenPtr, interp);
     envPtr->currStackDepth = savedStackDepth + 1;
     envPtr->exceptArrayPtr[nextRange].numCodeBytes =
-	    (envPtr->codeNext - envPtr->codeStart)
-	    - nextCodeOffset;
+	    CurrentOffset(envPtr) - nextCodeOffset;
     TclEmitOpcode(INST_POP, envPtr);
     envPtr->currStackDepth = savedStackDepth;
 
@@ -568,7 +596,7 @@ TclCompileForCmd(interp, parsePtr, envPtr)
      * terminates the for.
      */
 
-    testCodeOffset = (envPtr->codeNext - envPtr->codeStart);
+    testCodeOffset = CurrentOffset(envPtr);
 
     jumpDist = testCodeOffset - jumpEvalCondFixup.codeOffset;
     if (TclFixupForwardJump(envPtr, &jumpEvalCondFixup, jumpDist, 127)) {
@@ -581,7 +609,7 @@ TclCompileForCmd(interp, parsePtr, envPtr)
     TclCompileExprWords(interp, testTokenPtr, 1, envPtr);
     envPtr->currStackDepth = savedStackDepth + 1;
 
-    jumpDist = (envPtr->codeNext - envPtr->codeStart) - bodyCodeOffset;
+    jumpDist = CurrentOffset(envPtr) - bodyCodeOffset;
     if (jumpDist > 127) {
 	TclEmitInstInt4(INST_JUMP_TRUE4, -jumpDist, envPtr);
     } else {
@@ -598,15 +626,15 @@ TclCompileForCmd(interp, parsePtr, envPtr)
     envPtr->exceptArrayPtr[nextRange].codeOffset = nextCodeOffset;
 
     envPtr->exceptArrayPtr[bodyRange].breakOffset =
-            envPtr->exceptArrayPtr[nextRange].breakOffset =
-	    (envPtr->codeNext - envPtr->codeStart);
+	    envPtr->exceptArrayPtr[nextRange].breakOffset =
+	    CurrentOffset(envPtr);
 
     /*
      * The for command's result is an empty string.
      */
 
     envPtr->currStackDepth = savedStackDepth;
-    TclEmitPush(TclRegisterNewLiteral(envPtr, "", 0), envPtr);
+    PushLiteral(envPtr, "", 0);
 
     envPtr->exceptDepth--;
     return TCL_OK;
@@ -620,12 +648,12 @@ TclCompileForCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "foreach" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "foreach" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "foreach" command at
+ *	runtime.
  *
 n*----------------------------------------------------------------------
  */
@@ -679,12 +707,11 @@ TclCompileForeachCmd(interp, parsePtr, envPtr)
     }
 
     /*
-     * Bail out if the body requires substitutions
-     * in order to insure correct behaviour [Bug 219166]
+     * Bail out if the body requires substitutions in order to insure correct
+     * behaviour [Bug 219166]
      */
-    for (i = 0, tokenPtr = parsePtr->tokenPtr;
-	    i < numWords-1;
-	    i++, tokenPtr += (tokenPtr->numComponents + 1)) {
+    for (i = 0, tokenPtr = parsePtr->tokenPtr; i < numWords-1; i++) {
+	tokenPtr = TokenAfter(tokenPtr);
     }
     bodyTokenPtr = tokenPtr;
     if (bodyTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
@@ -697,70 +724,73 @@ TclCompileForeachCmd(interp, parsePtr, envPtr)
 
     numLists = (numWords - 2)/2;
     if (numLists > STATIC_VAR_LIST_SIZE) {
-        varcList = (int *) ckalloc(numLists * sizeof(int));
-        varvList = (CONST char ***) ckalloc(numLists * sizeof(CONST char **));
+	varcList = (int *) ckalloc(numLists * sizeof(int));
+	varvList = (CONST char ***) ckalloc(numLists * sizeof(CONST char **));
     }
     for (loopIndex = 0;  loopIndex < numLists;  loopIndex++) {
-        varcList[loopIndex] = 0;
-        varvList[loopIndex] = NULL;
+	varcList[loopIndex] = 0;
+	varvList[loopIndex] = NULL;
     }
 
     /*
      * Set the exception stack depth.
-     */ 
+     */
 
     envPtr->exceptDepth++;
     envPtr->maxExceptDepth =
 	    TclMax(envPtr->exceptDepth, envPtr->maxExceptDepth);
 
     /*
-     * Break up each var list and set the varcList and varvList arrays.
-     * Don't compile the foreach inline if any var name needs substitutions
-     * or isn't a scalar, or if any var list needs substitutions.
+     * Break up each var list and set the varcList and varvList arrays. Don't
+     * compile the foreach inline if any var name needs substitutions or isn't
+     * a scalar, or if any var list needs substitutions.
      */
 
     loopIndex = 0;
     for (i = 0, tokenPtr = parsePtr->tokenPtr;
 	    i < numWords-1;
-	    i++, tokenPtr += (tokenPtr->numComponents + 1)) {
-	if (i%2 == 1) {
-	    if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	    i++, tokenPtr = TokenAfter(tokenPtr)) {
+	Tcl_DString varList;
+
+	if (i%2 != 1) {
+	    continue;
+	}
+	if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	    code = TCL_ERROR;
+	    goto done;
+	}
+
+	/*
+	 * Lots of copying going on here.  Need a ListObj wizard to show a
+	 * better way.
+	 */
+
+	Tcl_DStringInit(&varList);
+	Tcl_DStringAppend(&varList, tokenPtr[1].start, tokenPtr[1].size);
+	code = Tcl_SplitList(interp, Tcl_DStringValue(&varList),
+		&varcList[loopIndex], &varvList[loopIndex]);
+	Tcl_DStringFree(&varList);
+	if (code != TCL_OK) {
+	    code = TCL_ERROR;
+	    goto done;
+	}
+	numVars = varcList[loopIndex];
+	for (j = 0;  j < numVars;  j++) {
+	    CONST char *varName = varvList[loopIndex][j];
+	    if (!TclIsLocalScalar(varName, (int) strlen(varName))) {
 		code = TCL_ERROR;
 		goto done;
-	    } else {
-		/* Lots of copying going on here.  Need a ListObj wizard
-		 * to show a better way. */
-
-		Tcl_DString varList;
-
-		Tcl_DStringInit(&varList);
-		Tcl_DStringAppend(&varList, tokenPtr[1].start,
-			tokenPtr[1].size);
-		code = Tcl_SplitList(interp, Tcl_DStringValue(&varList),
-			&varcList[loopIndex], &varvList[loopIndex]);
-		Tcl_DStringFree(&varList);
-		if (code != TCL_OK) {
-		    code = TCL_ERROR;
-		    goto done;
-		}
-		numVars = varcList[loopIndex];
-		for (j = 0;  j < numVars;  j++) {
-		    CONST char *varName = varvList[loopIndex][j];
-		    if (!TclIsLocalScalar(varName, (int) strlen(varName))) {
-			code = TCL_ERROR;
-			goto done;
-		    }
-		}
 	    }
-	    loopIndex++;
 	}
+	loopIndex++;
     }
 
     /*
-     * We will compile the foreach command.
-     * Reserve (numLists + 1) temporary variables:
+     * We will compile the foreach command.  Reserve (numLists + 1) temporary
+     * variables:
      *    - numLists temps to hold each value list
      *    - 1 temp for the loop counter (index of next element in each list)
+     *
      * At this time we don't try to reuse temporaries; if there are two
      * nonoverlapping foreach loops, they don't share any temps.
      */
@@ -769,13 +799,13 @@ TclCompileForeachCmd(interp, parsePtr, envPtr)
     firstValueTemp = -1;
     for (loopIndex = 0;  loopIndex < numLists;  loopIndex++) {
 	tempVar = TclFindCompiledLocal(NULL, /*nameChars*/ 0,
-		/*create*/ 1, /*flags*/ VAR_SCALAR, procPtr);
+		/*create*/ 1, VAR_SCALAR, procPtr);
 	if (loopIndex == 0) {
 	    firstValueTemp = tempVar;
 	}
     }
     loopCtTemp = TclFindCompiledLocal(NULL, /*nameChars*/ 0,
-	    /*create*/ 1, /*flags*/ VAR_SCALAR, procPtr);
+	    /*create*/ 1, VAR_SCALAR, procPtr);
 
     /*
      * Create and initialize the ForeachInfo and ForeachVarList data
@@ -784,7 +814,7 @@ TclCompileForeachCmd(interp, parsePtr, envPtr)
      */
 
     infoPtr = (ForeachInfo *) ckalloc((unsigned)
-	    (sizeof(ForeachInfo) + (numLists * sizeof(ForeachVarList *))));
+	    sizeof(ForeachInfo) + numLists*sizeof(ForeachVarList *));
     infoPtr->numLists = numLists;
     infoPtr->firstValueTemp = firstValueTemp;
     infoPtr->loopCtTemp = loopCtTemp;
@@ -792,13 +822,13 @@ TclCompileForeachCmd(interp, parsePtr, envPtr)
 	ForeachVarList *varListPtr;
 	numVars = varcList[loopIndex];
 	varListPtr = (ForeachVarList *) ckalloc((unsigned)
-	        sizeof(ForeachVarList) + (numVars * sizeof(int)));
+		sizeof(ForeachVarList) + numVars*sizeof(int));
 	varListPtr->numVars = numVars;
 	for (j = 0;  j < numVars;  j++) {
 	    CONST char *varName = varvList[loopIndex][j];
 	    int nameChars = strlen(varName);
 	    varListPtr->varIndexes[j] = TclFindCompiledLocal(varName,
-		    nameChars, /*create*/ 1, /*flags*/ VAR_SCALAR, procPtr);
+		    nameChars, /*create*/ 1, VAR_SCALAR, procPtr);
 	}
 	infoPtr->varLists[loopIndex] = varListPtr;
     }
@@ -813,7 +843,7 @@ TclCompileForeachCmd(interp, parsePtr, envPtr)
     loopIndex = 0;
     for (i = 0, tokenPtr = parsePtr->tokenPtr;
 	    i < numWords-1;
-	    i++, tokenPtr += (tokenPtr->numComponents + 1)) {
+	    i++, tokenPtr = TokenAfter(tokenPtr)) {
 	if ((i%2 == 0) && (i > 0)) {
 	    TclCompileTokens(interp, tokenPtr+1,
 		    tokenPtr->numComponents, envPtr);
@@ -840,8 +870,7 @@ TclCompileForeachCmd(interp, parsePtr, envPtr)
      * to terminate the loop.
      */
 
-    envPtr->exceptArrayPtr[range].continueOffset =
-	    (envPtr->codeNext - envPtr->codeStart);
+    envPtr->exceptArrayPtr[range].continueOffset = CurrentOffset(envPtr);
     TclEmitInstInt4(INST_FOREACH_STEP4, infoIndex, envPtr);
     TclEmitForwardJump(envPtr, TCL_FALSE_JUMP, &jumpFalseFixup);
 
@@ -849,26 +878,22 @@ TclCompileForeachCmd(interp, parsePtr, envPtr)
      * Inline compile the loop body.
      */
 
-    envPtr->exceptArrayPtr[range].codeOffset =
-	    (envPtr->codeNext - envPtr->codeStart);
-    TclCompileCmdWord(interp, bodyTokenPtr+1,
-	    bodyTokenPtr->numComponents, envPtr);
+    envPtr->exceptArrayPtr[range].codeOffset = CurrentOffset(envPtr);
+    CompileBody(envPtr, bodyTokenPtr, interp);
     envPtr->currStackDepth = savedStackDepth + 1;
     envPtr->exceptArrayPtr[range].numCodeBytes =
-	    (envPtr->codeNext - envPtr->codeStart)
-	    - envPtr->exceptArrayPtr[range].codeOffset;
+	    CurrentOffset(envPtr) - envPtr->exceptArrayPtr[range].codeOffset;
     TclEmitOpcode(INST_POP, envPtr);
 
     /*
-     * Jump back to the test at the top of the loop. Generate a 4 byte jump
-     * if the distance to the test is > 120 bytes. This is conservative and
+     * Jump back to the test at the top of the loop. Generate a 4 byte jump if
+     * the distance to the test is > 120 bytes. This is conservative and
      * ensures that we won't have to replace this jump if we later need to
      * replace the ifFalse jump with a 4 byte jump.
      */
 
-    jumpBackOffset = (envPtr->codeNext - envPtr->codeStart);
-    jumpBackDist =
-	(jumpBackOffset - envPtr->exceptArrayPtr[range].continueOffset);
+    jumpBackOffset = CurrentOffset(envPtr);
+    jumpBackDist = jumpBackOffset-envPtr->exceptArrayPtr[range].continueOffset;
     if (jumpBackDist > 120) {
 	TclEmitInstInt4(INST_JUMP4, -jumpBackDist, envPtr);
     } else {
@@ -905,18 +930,17 @@ TclCompileForeachCmd(interp, parsePtr, envPtr)
      * Set the loop's break target.
      */
 
-    envPtr->exceptArrayPtr[range].breakOffset =
-	    (envPtr->codeNext - envPtr->codeStart);
+    envPtr->exceptArrayPtr[range].breakOffset = CurrentOffset(envPtr);
 
     /*
      * The foreach command's result is an empty string.
      */
 
     envPtr->currStackDepth = savedStackDepth;
-    TclEmitPush(TclRegisterNewLiteral(envPtr, "", 0), envPtr);
+    PushLiteral(envPtr, "", 0);
     envPtr->currStackDepth = savedStackDepth + 1;
 
-    done:
+  done:
     for (loopIndex = 0;  loopIndex < numLists;  loopIndex++) {
 	if (varvList[loopIndex] != (CONST char **) NULL) {
 	    ckfree((char *) varvList[loopIndex]);
@@ -924,7 +948,7 @@ TclCompileForeachCmd(interp, parsePtr, envPtr)
     }
     if (varcList != varcListStaticSpace) {
 	ckfree((char *) varcList);
-        ckfree((char *) varvList);
+	ckfree((char *) varvList);
     }
     envPtr->exceptDepth--;
     return code;
@@ -935,8 +959,8 @@ TclCompileForeachCmd(interp, parsePtr, envPtr)
  *
  * DupForeachInfo --
  *
- *	This procedure duplicates a ForeachInfo structure created as
- *	auxiliary data during the compilation of a foreach command.
+ *	This procedure duplicates a ForeachInfo structure created as auxiliary
+ *	data during the compilation of a foreach command.
  *
  * Results:
  *	A pointer to a newly allocated copy of the existing ForeachInfo
@@ -944,9 +968,9 @@ TclCompileForeachCmd(interp, parsePtr, envPtr)
  *
  * Side effects:
  *	Storage for the copied ForeachInfo record is allocated. If the
- *	original ForeachInfo structure pointed to any ForeachVarList
- *	records, these structures are also copied and pointers to them
- *	are stored in the new ForeachInfo record.
+ *	original ForeachInfo structure pointed to any ForeachVarList records,
+ *	these structures are also copied and pointers to them are stored in
+ *	the new ForeachInfo record.
  *
  *----------------------------------------------------------------------
  */
@@ -963,7 +987,7 @@ DupForeachInfo(clientData)
     int numVars, i, j;
 
     dupPtr = (ForeachInfo *) ckalloc((unsigned)
-	    (sizeof(ForeachInfo) + (numLists * sizeof(ForeachVarList *))));
+	    sizeof(ForeachInfo) + numLists*sizeof(ForeachVarList *));
     dupPtr->numLists = numLists;
     dupPtr->firstValueTemp = srcPtr->firstValueTemp;
     dupPtr->loopCtTemp = srcPtr->loopCtTemp;
@@ -972,7 +996,7 @@ DupForeachInfo(clientData)
 	srcListPtr = srcPtr->varLists[i];
 	numVars = srcListPtr->numVars;
 	dupListPtr = (ForeachVarList *) ckalloc((unsigned)
-	        sizeof(ForeachVarList) + numVars*sizeof(int));
+		sizeof(ForeachVarList) + numVars*sizeof(int));
 	dupListPtr->numVars = numVars;
 	for (j = 0;  j < numVars;  j++) {
 	    dupListPtr->varIndexes[j] =	srcListPtr->varIndexes[j];
@@ -1026,45 +1050,45 @@ FreeForeachInfo(clientData)
  *	Procedure called to compile the "if" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "if" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "if" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
 int
 TclCompileIfCmd(interp, parsePtr, envPtr)
     Tcl_Interp *interp;		/* Used for error reporting. */
-    Tcl_Parse *parsePtr;	/* Points to a parse structure for the
-				 * command created by Tcl_ParseCommand. */
+    Tcl_Parse *parsePtr;	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
 {
     JumpFixupArray jumpFalseFixupArray;
     				/* Used to fix the ifFalse jump after each
 				 * test when its target PC is determined. */
     JumpFixupArray jumpEndFixupArray;
-				/* Used to fix the jump after each "then"
-				 * body to the end of the "if" when that PC
-				 * is determined. */
+				/* Used to fix the jump after each "then" body
+				 * to the end of the "if" when that PC is
+				 * determined. */
     Tcl_Token *tokenPtr, *testTokenPtr;
     int jumpFalseDist;
-    int jumpIndex = 0;          /* avoid compiler warning. */
+    int jumpIndex = 0;		/* avoid compiler warning. */
     int numWords, wordIdx, numBytes, j, code;
     CONST char *word;
     int savedStackDepth = envPtr->currStackDepth;
-                                /* Saved stack depth at the start of the first
+				/* Saved stack depth at the start of the first
 				 * test; the envPtr current depth is restored
 				 * to this value at the start of each test. */
-    int realCond = 1;           /* set to 0 for static conditions: "if 0 {..}" */
-    int boolVal;                /* value of static condition */
-    int compileScripts = 1;            
+    int realCond = 1;		/* set to 0 for static conditions: "if 0 {..}" */
+    int boolVal;		/* value of static condition */
+    int compileScripts = 1;
 
     /*
-     * Only compile the "if" command if all arguments are simple
-     * words, in order to insure correct substitution [Bug 219166]
+     * Only compile the "if" command if all arguments are simple words, in
+     * order to insure correct substitution [Bug 219166]
      */
 
     tokenPtr = parsePtr->tokenPtr;
@@ -1084,8 +1108,8 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
     code = TCL_OK;
 
     /*
-     * Each iteration of this loop compiles one "if expr ?then? body"
-     * or "elseif expr ?then? body" clause. 
+     * Each iteration of this loop compiles one "if expr ?then? body" or
+     * "elseif expr ?then? body" clause.
      */
 
     tokenPtr = parsePtr->tokenPtr;
@@ -1098,8 +1122,8 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 	word = tokenPtr[1].start;
 	numBytes = tokenPtr[1].size;
 	if ((tokenPtr == parsePtr->tokenPtr)
-	        || ((numBytes == 6) && (strncmp(word, "elseif", 6) == 0))) {
-	    tokenPtr += (tokenPtr->numComponents + 1);
+		|| ((numBytes == 6) && (strncmp(word, "elseif", 6) == 0))) {
+	    tokenPtr = TokenAfter(tokenPtr);
 	    wordIdx++;
 	} else {
 	    break;
@@ -1110,8 +1134,8 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 	}
 
 	/*
-	 * Compile the test expression then emit the conditional jump
-	 * around the "then" part. 
+	 * Compile the test expression then emit the conditional jump around
+	 * the "then" part.
 	 */
 
 	envPtr->currStackDepth = savedStackDepth;
@@ -1120,7 +1144,7 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 
 	if (realCond) {
 	    /*
-	     * Find out if the condition is a constant. 
+	     * Find out if the condition is a constant.
 	     */
 
 	    Tcl_Obj *boolObj = Tcl_NewStringObj(testTokenPtr[1].start,
@@ -1145,7 +1169,7 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 		jumpIndex = jumpFalseFixupArray.next;
 		jumpFalseFixupArray.next++;
 		TclEmitForwardJump(envPtr, TCL_FALSE_JUMP,
-			       &(jumpFalseFixupArray.fixup[jumpIndex]));	    
+			jumpFalseFixupArray.fixup+jumpIndex);
 	    }
 	    code = TCL_OK;
 	}
@@ -1155,7 +1179,7 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 	 * Skip over the optional "then" before the then clause.
 	 */
 
-	tokenPtr = testTokenPtr + (testTokenPtr->numComponents + 1);
+	tokenPtr = TokenAfter(testTokenPtr);
 	wordIdx++;
 	if (wordIdx >= numWords) {
 	    code = TCL_ERROR;
@@ -1165,7 +1189,7 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 	    word = tokenPtr[1].start;
 	    numBytes = tokenPtr[1].size;
 	    if ((numBytes == 4) && (strncmp(word, "then", 4) == 0)) {
-		tokenPtr += (tokenPtr->numComponents + 1);
+		tokenPtr = TokenAfter(tokenPtr);
 		wordIdx++;
 		if (wordIdx >= numWords) {
 		    code = TCL_ERROR;
@@ -1180,14 +1204,13 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 
 	if (compileScripts) {
 	    envPtr->currStackDepth = savedStackDepth;
-	    TclCompileCmdWord(interp, tokenPtr+1,
-	            tokenPtr->numComponents, envPtr);
+	    CompileBody(envPtr, tokenPtr, interp);
 	}
 
 	if (realCond) {
 	    /*
-	     * Jump to the end of the "if" command. Both jumpFalseFixupArray and
-	     * jumpEndFixupArray are indexed by "jumpIndex".
+	     * Jump to the end of the "if" command. Both jumpFalseFixupArray
+	     * and jumpEndFixupArray are indexed by "jumpIndex".
 	     */
 
 	    if (jumpEndFixupArray.next >= jumpEndFixupArray.end) {
@@ -1195,18 +1218,18 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 	    }
 	    jumpEndFixupArray.next++;
 	    TclEmitForwardJump(envPtr, TCL_UNCONDITIONAL_JUMP,
-	            &(jumpEndFixupArray.fixup[jumpIndex]));
+		    jumpEndFixupArray.fixup+jumpIndex);
 
 	    /*
-	     * Fix the target of the jumpFalse after the test. Generate a 4 byte
-	     * jump if the distance is > 120 bytes. This is conservative, and
-	     * ensures that we won't have to replace this jump if we later also
-	     * need to replace the proceeding jump to the end of the "if" with a
-	     * 4 byte jump.
+	     * Fix the target of the jumpFalse after the test. Generate a 4
+	     * byte jump if the distance is > 120 bytes. This is conservative,
+	     * and ensures that we won't have to replace this jump if we later
+	     * also need to replace the proceeding jump to the end of the "if"
+	     * with a 4 byte jump.
 	     */
 
 	    if (TclFixupForwardJumpToHere(envPtr,
-	            &(jumpFalseFixupArray.fixup[jumpIndex]), 120)) {
+		    jumpFalseFixupArray.fixup+jumpIndex, 120)) {
 		/*
 		 * Adjust the code offset for the proceeding jump to the end
 		 * of the "if" command.
@@ -1215,40 +1238,38 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 		jumpEndFixupArray.fixup[jumpIndex].codeOffset += 3;
 	    }
 	} else if (boolVal) {
-	    /* 
-	     *We were processing an "if 1 {...}"; stop compiling
-	     * scripts
+	    /*
+	     * We were processing an "if 1 {...}"; stop compiling scripts.
 	     */
 
 	    compileScripts = 0;
 	} else {
-	    /* 
-	     *We were processing an "if 0 {...}"; reset so that
-	     * the rest (elseif, else) is compiled correctly
+	    /*
+	     * We were processing an "if 0 {...}"; reset so that the rest
+	     * (elseif, else) is compiled correctly.
 	     */
 
 	    realCond = 1;
 	    compileScripts = 1;
-	} 
+	}
 
-	tokenPtr += (tokenPtr->numComponents + 1);
+	tokenPtr = TokenAfter(tokenPtr);
 	wordIdx++;
     }
 
     /*
-     * Restore the current stack depth in the environment; the 
-     * "else" clause (or its default) will add 1 to this.
+     * Restore the current stack depth in the environment; the "else" clause
+     * (or its default) will add 1 to this.
      */
 
     envPtr->currStackDepth = savedStackDepth;
 
     /*
-     * Check for the optional else clause. Do not compile
-     * anything if this was an "if 1 {...}" case.
+     * Check for the optional else clause. Do not compile anything if this was
+     * an "if 1 {...}" case.
      */
 
-    if ((wordIdx < numWords)
-	    && (tokenPtr->type == TCL_TOKEN_SIMPLE_WORD)) {
+    if ((wordIdx < numWords) && (tokenPtr->type == TCL_TOKEN_SIMPLE_WORD)) {
 	/*
 	 * There is an else clause. Skip over the optional "else" word.
 	 */
@@ -1256,7 +1277,7 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 	word = tokenPtr[1].start;
 	numBytes = tokenPtr[1].size;
 	if ((numBytes == 4) && (strncmp(word, "else", 4) == 0)) {
-	    tokenPtr += (tokenPtr->numComponents + 1);
+	    tokenPtr = TokenAfter(tokenPtr);
 	    wordIdx++;
 	    if (wordIdx >= numWords) {
 		code = TCL_ERROR;
@@ -1269,8 +1290,7 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 	     * Compile the else command body.
 	     */
 
-	    TclCompileCmdWord(interp, tokenPtr+1,
-		    tokenPtr->numComponents, envPtr);
+	    CompileBody(envPtr, tokenPtr, interp);
 	}
 
 	/*
@@ -1288,7 +1308,7 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 	 */
 
 	if (compileScripts) {
-	    TclEmitPush(TclRegisterNewLiteral(envPtr, "", 0), envPtr);
+	    PushLiteral(envPtr, "", 0);
 	}
     }
 
@@ -1299,14 +1319,14 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
     for (j = jumpEndFixupArray.next;  j > 0;  j--) {
 	jumpIndex = (j - 1);	/* i.e. process the closest jump first */
 	if (TclFixupForwardJumpToHere(envPtr,
-	        &(jumpEndFixupArray.fixup[jumpIndex]), 127)) {
+		jumpEndFixupArray.fixup+jumpIndex, 127)) {
 	    /*
-	     * Adjust the immediately preceeding "ifFalse" jump. We moved
-	     * it's target (just after this jump) down three bytes.
+	     * Adjust the immediately preceeding "ifFalse" jump. We moved it's
+	     * target (just after this jump) down three bytes.
 	     */
 
 	    unsigned char *ifFalsePc = envPtr->codeStart
-	            + jumpFalseFixupArray.fixup[jumpIndex].codeOffset;
+		    + jumpFalseFixupArray.fixup[jumpIndex].codeOffset;
 	    unsigned char opCode = *ifFalsePc;
 	    if (opCode == INST_JUMP_FALSE1) {
 		jumpFalseDist = TclGetInt1AtPtr(ifFalsePc + 1);
@@ -1317,7 +1337,7 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
 		jumpFalseDist += 3;
 		TclStoreInt4AtPtr(jumpFalseDist, (ifFalsePc + 1));
 	    } else {
-		Tcl_Panic("TclCompileIfCmd: unexpected opcode updating ifFalse jump");
+		Tcl_Panic("TclCompileIfCmd: unexpected opcode \"%d\" updating ifFalse jump", (int) opCode);
 	    }
 	}
     }
@@ -1326,7 +1346,7 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
      * Free the jumpFixupArray array if malloc'ed storage was used.
      */
 
-    done:
+  done:
     envPtr->currStackDepth = savedStackDepth + 1;
     TclFreeJumpFixupArray(&jumpFalseFixupArray);
     TclFreeJumpFixupArray(&jumpEndFixupArray);
@@ -1341,12 +1361,12 @@ TclCompileIfCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "incr" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "incr" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "incr" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -1365,11 +1385,9 @@ TclCompileIncrCmd(interp, parsePtr, envPtr)
 	return TCL_ERROR;
     }
 
-    varTokenPtr = parsePtr->tokenPtr
-	    + (parsePtr->tokenPtr->numComponents + 1);
+    varTokenPtr = TokenAfter(parsePtr->tokenPtr);
 
-    PushVarName(interp, varTokenPtr, envPtr, 
-	    (TCL_NO_LARGE_INDEX | TCL_CREATE_VAR),
+    PushVarName(interp, varTokenPtr, envPtr, TCL_NO_LARGE_INDEX|TCL_CREATE_VAR,
 	    &localIndex, &simpleVarName, &isScalar);
 
     /*
@@ -1380,7 +1398,7 @@ TclCompileIncrCmd(interp, parsePtr, envPtr)
     haveImmValue = 0;
     immValue = 1;
     if (parsePtr->numWords == 3) {
-	incrTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
+	incrTokenPtr = TokenAfter(varTokenPtr);
 	if (incrTokenPtr->type == TCL_TOKEN_SIMPLE_WORD) {
 	    CONST char *word = incrTokenPtr[1].start;
 	    int numBytes = incrTokenPtr[1].size;
@@ -1403,12 +1421,11 @@ TclCompileIncrCmd(interp, parsePtr, envPtr)
 		}
 	    }
 	    if (!haveImmValue) {
-		TclEmitPush(
-			TclRegisterNewLiteral(envPtr, word, numBytes), envPtr);
+		PushLiteral(envPtr, word, numBytes);
 	    }
 	} else {
-	    TclCompileTokens(interp, incrTokenPtr+1, 
-	            incrTokenPtr->numComponents, envPtr);
+	    TclCompileTokens(interp, incrTokenPtr+1,
+		    incrTokenPtr->numComponents, envPtr);
 	}
     } else {			/* no incr amount given so use 1 */
 	haveImmValue = 1;
@@ -1469,12 +1486,12 @@ TclCompileIncrCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "lappend" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "lappend" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "lappend" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -1486,7 +1503,7 @@ TclCompileLappendCmd(interp, parsePtr, envPtr)
 				 * command created by Tcl_ParseCommand. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
 {
-    Tcl_Token *varTokenPtr, *valueTokenPtr;
+    Tcl_Token *varTokenPtr;
     int simpleVarName, isScalar, localIndex, numWords;
 
     /*
@@ -1504,7 +1521,7 @@ TclCompileLappendCmd(interp, parsePtr, envPtr)
 	/*
 	 * LAPPEND instructions currently only handle one value appends
 	 */
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
 
     /*
@@ -1512,22 +1529,21 @@ TclCompileLappendCmd(interp, parsePtr, envPtr)
      * need to emit code to compute and push the name at runtime. We use a
      * frame slot (entry in the array of local vars) if we are compiling a
      * procedure body and if the name is simple text that does not include
-     * namespace qualifiers. 
+     * namespace qualifiers.
      */
 
-    varTokenPtr = parsePtr->tokenPtr
-	    + (parsePtr->tokenPtr->numComponents + 1);
+    varTokenPtr = TokenAfter(parsePtr->tokenPtr);
 
     PushVarName(interp, varTokenPtr, envPtr, TCL_CREATE_VAR,
 	    &localIndex, &simpleVarName, &isScalar);
 
     /*
-     * If we are doing an assignment, push the new value.
-     * In the no values case, create an empty object.
+     * If we are doing an assignment, push the new value.  In the no values
+     * case, create an empty object.
      */
 
     if (numWords > 2) {
-	valueTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
+	Tcl_Token *valueTokenPtr = TokenAfter(varTokenPtr);
 	CompileWord(envPtr, valueTokenPtr, interp);
     }
 
@@ -1541,24 +1557,20 @@ TclCompileLappendCmd(interp, parsePtr, envPtr)
      */
     if (simpleVarName) {
 	if (isScalar) {
-	    if (localIndex >= 0) {
-		if (localIndex <= 255) {
-		    TclEmitInstInt1(INST_LAPPEND_SCALAR1, localIndex, envPtr);
-		} else {
-		    TclEmitInstInt4(INST_LAPPEND_SCALAR4, localIndex, envPtr);
-		}
-	    } else {
+	    if (localIndex < 0) {
 		TclEmitOpcode(INST_LAPPEND_STK, envPtr);
+	    } else if (localIndex <= 255) {
+		TclEmitInstInt1(INST_LAPPEND_SCALAR1, localIndex, envPtr);
+	    } else {
+		TclEmitInstInt4(INST_LAPPEND_SCALAR4, localIndex, envPtr);
 	    }
 	} else {
-	    if (localIndex >= 0) {
-		if (localIndex <= 255) {
-		    TclEmitInstInt1(INST_LAPPEND_ARRAY1, localIndex, envPtr);
-		} else {
-		    TclEmitInstInt4(INST_LAPPEND_ARRAY4, localIndex, envPtr);
-		}
-	    } else {
+	    if (localIndex < 0) {
 		TclEmitOpcode(INST_LAPPEND_ARRAY_STK, envPtr);
+	    } else if (localIndex <= 255) {
+		TclEmitInstInt1(INST_LAPPEND_ARRAY1, localIndex, envPtr);
+	    } else {
+		TclEmitInstInt4(INST_LAPPEND_ARRAY4, localIndex, envPtr);
 	    }
 	}
     } else {
@@ -1576,12 +1588,12 @@ TclCompileLappendCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "lassign" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "lassign" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "lassign" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -1607,14 +1619,14 @@ TclCompileLassignCmd(interp, parsePtr, envPtr)
     /*
      * Generate code to push list being taken apart by [lassign].
      */
-    tokenPtr = parsePtr->tokenPtr + (parsePtr->tokenPtr->numComponents + 1);
+    tokenPtr = TokenAfter(parsePtr->tokenPtr);
     CompileWord(envPtr, tokenPtr, interp);
 
     /*
      * Generate code to assign values from the list to variables
      */
     for (idx=0 ; idx<numWords-2 ; idx++) {
-	tokenPtr += tokenPtr->numComponents + 1;
+	tokenPtr = TokenAfter(tokenPtr);
 
 	/*
 	 * Generate the next variable name
@@ -1623,8 +1635,8 @@ TclCompileLassignCmd(interp, parsePtr, envPtr)
 		&localIndex, &simpleVarName, &isScalar);
 
 	/*
-	 * Emit instructions to get the idx'th item out of the list
-	 * value on the stack and assign it to the variable.
+	 * Emit instructions to get the idx'th item out of the list value on
+	 * the stack and assign it to the variable.
 	 */
 	if (simpleVarName) {
 	    if (isScalar) {
@@ -1681,12 +1693,12 @@ TclCompileLassignCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "lindex" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "lindex" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "lindex" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -1694,13 +1706,12 @@ TclCompileLassignCmd(interp, parsePtr, envPtr)
 int
 TclCompileLindexCmd(interp, parsePtr, envPtr)
     Tcl_Interp *interp;		/* Used for error reporting. */
-    Tcl_Parse *parsePtr;	/* Points to a parse structure for the
-				 * command created by Tcl_ParseCommand. */
+    Tcl_Parse *parsePtr;	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
 {
     Tcl_Token *varTokenPtr;
-    int i, numWords;
-    numWords = parsePtr->numWords;
+    int i, numWords = parsePtr->numWords;
 
     /*
      * Quit if too few args
@@ -1710,36 +1721,36 @@ TclCompileLindexCmd(interp, parsePtr, envPtr)
 	return TCL_ERROR;
     }
 
-    varTokenPtr = parsePtr->tokenPtr
-	    + (parsePtr->tokenPtr->numComponents + 1);
+    varTokenPtr = TokenAfter(parsePtr->tokenPtr);
 
     if ((numWords == 3) && (varTokenPtr->type == TCL_TOKEN_SIMPLE_WORD) &&
 	    TclLooksLikeInt(varTokenPtr[1].start, varTokenPtr[1].size)) {
 	Tcl_Obj *tmpObj;
-	int idx;
+	int idx, result;
 
 	tmpObj = Tcl_NewStringObj(varTokenPtr[1].start, varTokenPtr[1].size);
-	if (Tcl_GetIntFromObj(NULL, tmpObj, &idx) == TCL_OK && idx >= 0) {
-	    TclDecrRefCount(tmpObj);
-	    varTokenPtr += varTokenPtr->numComponents + 1;
+	result = Tcl_GetIntFromObj(NULL, tmpObj, &idx);
+	TclDecrRefCount(tmpObj);
+
+	if (result == TCL_OK && idx >= 0) {
 	    /*
-	     * All checks have been completed, and we have exactly
-	     * this construct:
+	     * All checks have been completed, and we have exactly this
+	     * construct:
 	     *	 lindex <posInt> <arbitraryValue>
-	     * This is best compiled as a push of the arbitrary value
-	     * followed by an "immediate lindex" which is the most
-	     * efficient variety.
+	     * This is best compiled as a push of the arbitrary value followed
+	     * by an "immediate lindex" which is the most efficient variety.
 	     */
+
+	    varTokenPtr = TokenAfter(varTokenPtr);
 	    CompileWord(envPtr, varTokenPtr, interp);
 	    TclEmitInstInt4(INST_LIST_INDEX_IMM, idx, envPtr);
 	    return TCL_OK;
-	} else {
-	    /*
-	     * If the conversion failed or the value was negative, we
-	     * just keep on going with the more complex compilation.
-	     */
-	    TclDecrRefCount(tmpObj);
 	}
+
+	/*
+	 * If the conversion failed or the value was negative, we just keep on
+	 * going with the more complex compilation.
+	 */
     }
 
     /*
@@ -1748,12 +1759,12 @@ TclCompileLindexCmd(interp, parsePtr, envPtr)
 
     for (i=1 ; i<numWords ; i++) {
 	CompileWord(envPtr, varTokenPtr, interp);
-	varTokenPtr += varTokenPtr->numComponents + 1;
+	varTokenPtr = TokenAfter(varTokenPtr);
     }
 
     /*
-     * Emit INST_LIST_INDEX if objc==3, or INST_LIST_INDEX_MULTI
-     * if there are multiple index args.
+     * Emit INST_LIST_INDEX if objc==3, or INST_LIST_INDEX_MULTI if there are
+     * multiple index args.
      */
 
     if (numWords == 3) {
@@ -1773,12 +1784,12 @@ TclCompileLindexCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "list" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "list" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "list" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -1786,8 +1797,8 @@ TclCompileLindexCmd(interp, parsePtr, envPtr)
 int
 TclCompileListCmd(interp, parsePtr, envPtr)
     Tcl_Interp *interp;		/* Used for error reporting. */
-    Tcl_Parse *parsePtr;	/* Points to a parse structure for the
-				 * command created by Tcl_ParseCommand. */
+    Tcl_Parse *parsePtr;	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
 {
     /*
@@ -1799,10 +1810,10 @@ TclCompileListCmd(interp, parsePtr, envPtr)
 
     if (parsePtr->numWords == 1) {
 	/*
-	 * Empty args case
+	 * [list] without arguments just pushes an empty object.
 	 */
 
-	TclEmitPush(TclRegisterNewLiteral(envPtr, "", 0), envPtr);
+	PushLiteral(envPtr, "", 0);
     } else {
 	/*
 	 * Push the all values onto the stack.
@@ -1812,11 +1823,10 @@ TclCompileListCmd(interp, parsePtr, envPtr)
 
 	numWords = parsePtr->numWords;
 
-	valueTokenPtr = parsePtr->tokenPtr
-	    + (parsePtr->tokenPtr->numComponents + 1);
+	valueTokenPtr = TokenAfter(parsePtr->tokenPtr);
 	for (i = 1; i < numWords; i++) {
 	    CompileWord(envPtr, valueTokenPtr, interp);
-	    valueTokenPtr = valueTokenPtr + (valueTokenPtr->numComponents + 1);
+	    valueTokenPtr = TokenAfter(valueTokenPtr);
 	}
 	TclEmitInstInt4(INST_LIST, numWords - 1, envPtr);
     }
@@ -1832,12 +1842,12 @@ TclCompileListCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "llength" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "llength" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "llength" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -1845,8 +1855,8 @@ TclCompileListCmd(interp, parsePtr, envPtr)
 int
 TclCompileLlengthCmd(interp, parsePtr, envPtr)
     Tcl_Interp *interp;		/* Used for error reporting. */
-    Tcl_Parse *parsePtr;	/* Points to a parse structure for the
-				 * command created by Tcl_ParseCommand. */
+    Tcl_Parse *parsePtr;	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
 {
     Tcl_Token *varTokenPtr;
@@ -1854,8 +1864,7 @@ TclCompileLlengthCmd(interp, parsePtr, envPtr)
     if (parsePtr->numWords != 2) {
 	return TCL_ERROR;
     }
-    varTokenPtr = parsePtr->tokenPtr
-	+ (parsePtr->tokenPtr->numComponents + 1);
+    varTokenPtr = TokenAfter(parsePtr->tokenPtr);
 
     CompileWord(envPtr, varTokenPtr, interp);
     TclEmitOpcode(INST_LIST_LENGTH, envPtr);
@@ -1870,34 +1879,34 @@ TclCompileLlengthCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "lset" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "lset" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "lset" command at
+ *	runtime.
  *
  * The general template for execution of the "lset" command is:
- *	(1) Instructions to push the variable name, unless the
- *	    variable is local to the stack frame.
- *	(2) If the variable is an array element, instructions
- *	    to push the array element name.
- *	(3) Instructions to push each of zero or more "index" arguments
- *	    to the stack, followed with the "newValue" element.
- *	(4) Instructions to duplicate the variable name and/or array
- *	    element name onto the top of the stack, if either was
- *	    pushed at steps (1) and (2).
- *	(5) The appropriate INST_LOAD_* instruction to place the
- *	    original value of the list variable at top of stack.
+ *	(1) Instructions to push the variable name, unless the variable is
+ *	    local to the stack frame.
+ *	(2) If the variable is an array element, instructions to push the
+ *	    array element name.
+ *	(3) Instructions to push each of zero or more "index" arguments to the
+ *	    stack, followed with the "newValue" element.
+ *	(4) Instructions to duplicate the variable name and/or array element
+ *	    name onto the top of the stack, if either was pushed at steps (1)
+ *	    and (2).
+ *	(5) The appropriate INST_LOAD_* instruction to place the original
+ *	    value of the list variable at top of stack.
  *	(6) At this point, the stack contains:
- *	     varName? arrayElementName? index1 index2 ... newValue oldList
+ *		varName? arrayElementName? index1 index2 ... newValue oldList
  *	    The compiler emits one of INST_LSET_FLAT or INST_LSET_LIST
- *	    according as whether there is exactly one index element (LIST)
- *	    or either zero or else two or more (FLAT).  This instruction
- *	    removes everything from the stack except for the two names
- *	    and pushes the new value of the variable.
- *	(7) Finally, INST_STORE_* stores the new value in the variable
- *	    and cleans up the stack.
+ *	    according as whether there is exactly one index element (LIST) or
+ *	    either zero or else two or more (FLAT).  This instruction removes
+ *	    everything from the stack except for the two names and pushes the
+ *	    new value of the variable.
+ *	(7) Finally, INST_STORE_* stores the new value in the variable and
+ *	    cleans up the stack.
  *
  *----------------------------------------------------------------------
  */
@@ -1905,14 +1914,14 @@ TclCompileLlengthCmd(interp, parsePtr, envPtr)
 int
 TclCompileLsetCmd(interp, parsePtr, envPtr)
     Tcl_Interp* interp;		/* Tcl interpreter for error reporting */
-    Tcl_Parse* parsePtr;	/* Points to a parse structure for
-				 * the command */
+    Tcl_Parse* parsePtr;	/* Points to a parse structure for the
+				 * command */
     CompileEnv* envPtr;		/* Holds the resulting instructions */
 {
-    int tempDepth;		/* Depth used for emitting one part
-				 * of the code burst. */
-    Tcl_Token* varTokenPtr;	/* Pointer to the Tcl_Token representing
-				 * the parse of the variable name */
+    int tempDepth;		/* Depth used for emitting one part of the
+				 * code burst. */
+    Tcl_Token* varTokenPtr;	/* Pointer to the Tcl_Token representing the
+				 * parse of the variable name */
     int localIndex;		/* Index of var in local var table */
     int simpleVarName;		/* Flag == 1 if var name is simple */
     int isScalar;		/* Flag == 1 if scalar, 0 if array */
@@ -1926,32 +1935,28 @@ TclCompileLsetCmd(interp, parsePtr, envPtr)
     }
 
     /*
-     * Decide if we can use a frame slot for the var/array name or if we
-     * need to emit code to compute and push the name at runtime. We use a
-     * frame slot (entry in the array of local vars) if we are compiling a
-     * procedure body and if the name is simple text that does not include
-     * namespace qualifiers. 
+     * Decide if we can use a frame slot for the var/array name or if we need
+     * to emit code to compute and push the name at runtime. We use a frame
+     * slot (entry in the array of local vars) if we are compiling a procedure
+     * body and if the name is simple text that does not include namespace
+     * qualifiers.
      */
 
-    varTokenPtr = parsePtr->tokenPtr
-	    + (parsePtr->tokenPtr->numComponents + 1);
+    varTokenPtr = TokenAfter(parsePtr->tokenPtr);
     PushVarName(interp, varTokenPtr, envPtr, TCL_CREATE_VAR,
 	    &localIndex, &simpleVarName, &isScalar);
 
-    /* Push the "index" args and the new element value. */
+    /*
+     * Push the "index" args and the new element value.
+     */
 
     for (i=2 ; i<parsePtr->numWords ; ++i) {
-	/* Advance to next arg */
-
-	varTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
-
-	/* Push an arg */
-
+	varTokenPtr = TokenAfter(varTokenPtr);
 	CompileWord(envPtr, varTokenPtr, interp);
     }
 
     /*
-     * Duplicate the variable name if it's been pushed.  
+     * Duplicate the variable name if it's been pushed.
      */
 
     if (!simpleVarName || localIndex < 0) {
@@ -2007,7 +2012,7 @@ TclCompileLsetCmd(interp, parsePtr, envPtr)
     if (parsePtr->numWords == 4) {
 	TclEmitOpcode(INST_LSET_LIST, envPtr);
     } else {
-	TclEmitInstInt4(INST_LSET_FLAT, (parsePtr->numWords - 1), envPtr);
+	TclEmitInstInt4(INST_LSET_FLAT, parsePtr->numWords-1, envPtr);
     }
 
     /*
@@ -2045,12 +2050,12 @@ TclCompileLsetCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "regexp" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "regexp" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "regexp" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -2058,18 +2063,18 @@ TclCompileLsetCmd(interp, parsePtr, envPtr)
 int
 TclCompileRegexpCmd(interp, parsePtr, envPtr)
     Tcl_Interp* interp;		/* Tcl interpreter for error reporting */
-    Tcl_Parse* parsePtr;	/* Points to a parse structure for
-				 * the command */
+    Tcl_Parse* parsePtr;	/* Points to a parse structure for the
+				 * command */
     CompileEnv* envPtr;		/* Holds the resulting instructions */
 {
-    Tcl_Token *varTokenPtr;	/* Pointer to the Tcl_Token representing
-				 * the parse of the RE or string */
+    Tcl_Token *varTokenPtr;	/* Pointer to the Tcl_Token representing the
+				 * parse of the RE or string */
     int i, len, nocase, anchorLeft, anchorRight, start;
     char *str;
 
     /*
-     * We are only interested in compiling simple regexp cases.
-     * Currently supported compile cases are:
+     * We are only interested in compiling simple regexp cases.  Currently
+     * supported compile cases are:
      *   regexp ?-nocase? ?--? staticString $var
      *   regexp ?-nocase? ?--? {^staticString$} $var
      */
@@ -2081,12 +2086,12 @@ TclCompileRegexpCmd(interp, parsePtr, envPtr)
     varTokenPtr = parsePtr->tokenPtr;
 
     /*
-     * We only look for -nocase and -- as options.  Everything else
-     * gets pushed to runtime execution.  This is different than regexp's
-     * runtime option handling, but satisfies our stricter needs.
+     * We only look for -nocase and -- as options.  Everything else gets
+     * pushed to runtime execution.  This is different than regexp's runtime
+     * option handling, but satisfies our stricter needs.
      */
     for (i = 1; i < parsePtr->numWords - 2; i++) {
-	varTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
+	varTokenPtr = TokenAfter(varTokenPtr);
 	if (varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
 	    /* Not a simple string - punt to runtime. */
 	    return TCL_ERROR;
@@ -2096,8 +2101,7 @@ TclCompileRegexpCmd(interp, parsePtr, envPtr)
 	if ((len == 2) && (str[0] == '-') && (str[1] == '-')) {
 	    i++;
 	    break;
-	} else if ((len > 1)
-		&& (strncmp(str, "-nocase", (unsigned) len) == 0)) {
+	} else if ((len > 1) && (strncmp(str,"-nocase",(unsigned)len) == 0)) {
 	    nocase = 1;
 	} else {
 	    /* Not an option we recognize. */
@@ -2114,7 +2118,7 @@ TclCompileRegexpCmd(interp, parsePtr, envPtr)
      * Get the regexp string.  If it is not a simple string, punt to runtime.
      * If it has a '-', it could be an incorrectly formed regexp command.
      */
-    varTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
+    varTokenPtr = TokenAfter(varTokenPtr);
     str = (char *) varTokenPtr[1].start;
     len = varTokenPtr[1].size;
     if ((varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) || (*str == '-')) {
@@ -2125,7 +2129,7 @@ TclCompileRegexpCmd(interp, parsePtr, envPtr)
 	/*
 	 * The semantics of regexp are always match on re == "".
 	 */
-	TclEmitPush(TclRegisterNewLiteral(envPtr, "1", 1), envPtr);
+	PushLiteral(envPtr, "1", 1);
 	return TCL_OK;
     }
 
@@ -2159,11 +2163,11 @@ TclCompileRegexpCmd(interp, parsePtr, envPtr)
      * On the first (pattern) arg, check to see if any RE special characters
      * are in the word.  If not, this is the same as 'string equal'.
      */
-    if ((len > (1+start)) && (str[start] == '.') && (str[start+1] == '*')) {
+    if ((len > 1+start) && (str[start] == '.') && (str[start+1] == '*')) {
 	start += 2;
 	anchorLeft = 0;
     }
-    if ((len > (2+start)) && (str[len-3] != '\\')
+    if ((len > 2+start) && (str[len-3] != '\\')
 	    && (str[len-2] == '.') && (str[len-1] == '*')) {
 	len -= 2;
 	str[len] = '\0';
@@ -2171,9 +2175,9 @@ TclCompileRegexpCmd(interp, parsePtr, envPtr)
     }
 
     /*
-     * Don't do anything with REs with other special chars.  Also check if
-     * this is a bad RE (do this at the end because it can be expensive).
-     * If so, let it complain at runtime.
+     * Don't do anything with REs with other special chars. Also check if this
+     * is a bad RE (do this at the end because it can be expensive). If so,
+     * let it complain at runtime.
      */
     if ((strpbrk(str + start, "*+?{}()[].\\|^$") != NULL)
 	    || (Tcl_RegExpCompile(NULL, str) == NULL)) {
@@ -2182,14 +2186,14 @@ TclCompileRegexpCmd(interp, parsePtr, envPtr)
     }
 
     if (anchorLeft && anchorRight) {
-	TclEmitPush(TclRegisterNewLiteral(envPtr, str+start, len-start),
-		envPtr);
+	PushLiteral(envPtr, str+start, len-start);
     } else {
 	/*
-	 * This needs to find the substring anywhere in the string, so
-	 * use string match and *foo*, with appropriate anchoring.
+	 * This needs to find the substring anywhere in the string, so use
+	 * [string match] and *foo*, with appropriate anchoring.
 	 */
-	char *newStr  = ckalloc((unsigned) len + 3);
+	char *newStr = ckalloc((unsigned) len + 3);
+
 	len -= start;
 	if (anchorLeft) {
 	    strncpy(newStr, str + start, (size_t) len);
@@ -2201,7 +2205,7 @@ TclCompileRegexpCmd(interp, parsePtr, envPtr)
 	    newStr[len++] = '*';
 	}
 	newStr[len] = '\0';
-	TclEmitPush(TclRegisterNewLiteral(envPtr, newStr, len), envPtr);
+	PushLiteral(envPtr, newStr, len);
 	ckfree((char *) newStr);
     }
     ckfree((char *) str);
@@ -2209,7 +2213,8 @@ TclCompileRegexpCmd(interp, parsePtr, envPtr)
     /*
      * Push the string arg
      */
-    varTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
+
+    varTokenPtr = TokenAfter(varTokenPtr);
     CompileWord(envPtr, varTokenPtr, interp);
 
     if (anchorLeft && anchorRight && !nocase) {
@@ -2229,12 +2234,12 @@ TclCompileRegexpCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "return" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "return" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "return" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -2255,8 +2260,7 @@ TclCompileReturnCmd(interp, parsePtr, envPtr)
     int explicitResult = (0 == (numWords % 2));
     int numOptionWords = numWords - 1 - explicitResult;
     Tcl_Obj *returnOpts;
-    Tcl_Token *wordTokenPtr = parsePtr->tokenPtr
-		+ (parsePtr->tokenPtr->numComponents + 1);
+    Tcl_Token *wordTokenPtr = TokenAfter(parsePtr->tokenPtr);
 #define NUM_STATIC_OBJS 20
     int objc;
     Tcl_Obj *staticObjArray[NUM_STATIC_OBJS], **objv;
@@ -2267,10 +2271,10 @@ TclCompileReturnCmd(interp, parsePtr, envPtr)
 	objv = staticObjArray;
     }
 
-    /* 
-     * Scan through the return options.  If any are unknown at compile
-     * time, there is no value in bytecompiling.  Save the option values
-     * known in an objv array for merging into a return options dictionary.
+    /*
+     * Scan through the return options.  If any are unknown at compile time,
+     * there is no value in bytecompiling.  Save the option values known in an
+     * objv array for merging into a return options dictionary.
      */
 
     for (objc = 0; objc < numOptionWords; objc++) {
@@ -2281,11 +2285,11 @@ TclCompileReturnCmd(interp, parsePtr, envPtr)
 	    status = TCL_ERROR;
 	    goto cleanup;
 	}
-	wordTokenPtr += wordTokenPtr->numComponents + 1;
+	wordTokenPtr = TokenAfter(wordTokenPtr);
     }
     status = TclMergeReturnOptions(interp, objc, objv,
 	    &returnOpts, &code, &level);
-cleanup:
+  cleanup:
     while (--objc >= 0) {
 	Tcl_DecrRefCount(objv[objc]);
     }
@@ -2294,9 +2298,9 @@ cleanup:
     }
     if (TCL_ERROR == status) {
 	/*
-	 * Something was bogus in the return options.  Clear the
-	 * error message, and report back to the compiler that this
-	 * must be interpreted at runtime.
+	 * Something was bogus in the return options. Clear the error message,
+	 * and report back to the compiler that this must be interpreted at
+	 * runtime.
 	 */
 	Tcl_ResetResult(interp);
 	return TCL_ERROR;
@@ -2310,43 +2314,47 @@ cleanup:
     if (explicitResult) {
 	CompileWord(envPtr, wordTokenPtr, interp);
     } else {
-	/* No explict result argument, so default result is empty string */
-	TclEmitPush(TclRegisterNewLiteral(envPtr, "", 0), envPtr);
-    }
-
-   /* 
-    * Check for optimization:  When [return] is in a proc, and there's
-    * no enclosing [catch], and there are no return options, then the
-    * INST_DONE instruction is equivalent, and may be more efficient.
-    */
-    if (numOptionWords == 0) {
-	/* We have default return options... */
-	if (envPtr->procPtr != NULL) {
-	    /* ... and we're in a proc ... */
-	    int index = envPtr->exceptArrayNext - 1;
-	    int enclosingCatch = 0;
-	    while (index >= 0) {
-		ExceptionRange range = envPtr->exceptArrayPtr[index];
-		if ((range.type == CATCH_EXCEPTION_RANGE)
-			&& (range.catchOffset == -1)) {
-		    enclosingCatch = 1;
-		    break;
-		}
-		index--;
-	    }
-	    if (!enclosingCatch) {
-		/* ... and there is no enclosing catch. */
-		Tcl_DecrRefCount(returnOpts);
-		TclEmitOpcode(INST_DONE, envPtr);
-		return TCL_OK;
+	/*
+	 * No explict result argument, so default result is empty string.
+	 */
+	PushLiteral(envPtr, "", 0);
+    }
+
+    /*
+     * Check for optimization: When [return] is in a proc, and there's no
+     * enclosing [catch], and there are no return options, then the INST_DONE
+     * instruction is equivalent, and may be more efficient.
+     */
+
+    if (numOptionWords == 0 && envPtr->procPtr != NULL) {
+	/*
+	 * We have default return options and we're in a proc ...
+	 */
+	int index = envPtr->exceptArrayNext - 1;
+	int enclosingCatch = 0;
+	while (index >= 0) {
+	    ExceptionRange range = envPtr->exceptArrayPtr[index];
+	    if ((range.type == CATCH_EXCEPTION_RANGE)
+		    && (range.catchOffset == -1)) {
+		enclosingCatch = 1;
+		break;
 	    }
+	    index--;
+	}
+	if (!enclosingCatch) {
+	    /*
+	     * ... and there is no enclosing catch. Issue the maximally
+	     * efficient exit instruction.
+	     */
+	    Tcl_DecrRefCount(returnOpts);
+	    TclEmitOpcode(INST_DONE, envPtr);
+	    return TCL_OK;
 	}
     }
 
     /*
-     * Could not use the optimization, so we push the return options
-     * dictionary, and emit the INST_RETURN instruction with code
-     * and level as operands.
+     * Could not use the optimization, so we push the return options dict, and
+     * emit the INST_RETURN instruction with code and level as operands.
      */
 
     TclEmitPush(TclAddLiteralObj(envPtr, returnOpts, NULL), envPtr);
@@ -2363,12 +2371,12 @@ cleanup:
  *	Procedure called to compile the "set" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "set" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "set" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -2376,8 +2384,8 @@ cleanup:
 int
 TclCompileSetCmd(interp, parsePtr, envPtr)
     Tcl_Interp *interp;		/* Used for error reporting. */
-    Tcl_Parse *parsePtr;	/* Points to a parse structure for the
-				 * command created by Tcl_ParseCommand. */
+    Tcl_Parse *parsePtr;	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
 {
     Tcl_Token *varTokenPtr, *valueTokenPtr;
@@ -2390,16 +2398,14 @@ TclCompileSetCmd(interp, parsePtr, envPtr)
     isAssignment = (numWords == 3);
 
     /*
-     * Decide if we can use a frame slot for the var/array name or if we
-     * need to emit code to compute and push the name at runtime. We use a
-     * frame slot (entry in the array of local vars) if we are compiling a
-     * procedure body and if the name is simple text that does not include
-     * namespace qualifiers. 
+     * Decide if we can use a frame slot for the var/array name or if we need
+     * to emit code to compute and push the name at runtime. We use a frame
+     * slot (entry in the array of local vars) if we are compiling a procedure
+     * body and if the name is simple text that does not include namespace
+     * qualifiers.
      */
 
-    varTokenPtr = parsePtr->tokenPtr
-	    + (parsePtr->tokenPtr->numComponents + 1);
-
+    varTokenPtr = TokenAfter(parsePtr->tokenPtr);
     PushVarName(interp, varTokenPtr, envPtr, TCL_CREATE_VAR,
 	    &localIndex, &simpleVarName, &isScalar);
 
@@ -2408,7 +2414,7 @@ TclCompileSetCmd(interp, parsePtr, envPtr)
      */
 
     if (isAssignment) {
-	valueTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
+	valueTokenPtr = TokenAfter(varTokenPtr);
 	CompileWord(envPtr, valueTokenPtr, interp);
     }
 
@@ -2418,34 +2424,30 @@ TclCompileSetCmd(interp, parsePtr, envPtr)
 
     if (simpleVarName) {
 	if (isScalar) {
-	    if (localIndex >= 0) {
-		if (localIndex <= 255) {
-		    TclEmitInstInt1((isAssignment?
-		            INST_STORE_SCALAR1 : INST_LOAD_SCALAR1),
-			    localIndex, envPtr);
-		} else {
-		    TclEmitInstInt4((isAssignment?
-			    INST_STORE_SCALAR4 : INST_LOAD_SCALAR4),
-			    localIndex, envPtr);
-		}
-	    } else {
+	    if (localIndex < 0) {
 		TclEmitOpcode((isAssignment?
 		        INST_STORE_SCALAR_STK : INST_LOAD_SCALAR_STK), envPtr);
+	    } else if (localIndex <= 255) {
+		TclEmitInstInt1((isAssignment?
+			INST_STORE_SCALAR1 : INST_LOAD_SCALAR1),
+			localIndex, envPtr);
+	    } else {
+		TclEmitInstInt4((isAssignment?
+			INST_STORE_SCALAR4 : INST_LOAD_SCALAR4),
+			localIndex, envPtr);
 	    }
 	} else {
-	    if (localIndex >= 0) {
-		if (localIndex <= 255) {
-		    TclEmitInstInt1((isAssignment?
-		            INST_STORE_ARRAY1 : INST_LOAD_ARRAY1),
-			    localIndex, envPtr);
-		} else {
-		    TclEmitInstInt4((isAssignment?
-			    INST_STORE_ARRAY4 : INST_LOAD_ARRAY4),
-			    localIndex, envPtr);
-		}
-	    } else {
+	    if (localIndex < 0) {
 		TclEmitOpcode((isAssignment?
-		        INST_STORE_ARRAY_STK : INST_LOAD_ARRAY_STK), envPtr);
+			INST_STORE_ARRAY_STK : INST_LOAD_ARRAY_STK), envPtr);
+	    } else if (localIndex <= 255) {
+		TclEmitInstInt1((isAssignment?
+			INST_STORE_ARRAY1 : INST_LOAD_ARRAY1),
+			localIndex, envPtr);
+	    } else {
+		TclEmitInstInt4((isAssignment?
+			INST_STORE_ARRAY4 : INST_LOAD_ARRAY4),
+			localIndex, envPtr);
 	    }
 	}
     } else {
@@ -2460,15 +2462,18 @@ TclCompileSetCmd(interp, parsePtr, envPtr)
  *
  * TclCompileStringCmd --
  *
- *	Procedure called to compile the "string" command.
+ *	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.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -2476,13 +2481,13 @@ TclCompileSetCmd(interp, parsePtr, envPtr)
 int
 TclCompileStringCmd(interp, parsePtr, envPtr)
     Tcl_Interp *interp;		/* Used for error reporting. */
-    Tcl_Parse *parsePtr;	/* Points to a parse structure for the
-				 * command created by Tcl_ParseCommand. */
+    Tcl_Parse *parsePtr;	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
 {
     Tcl_Token *opTokenPtr, *varTokenPtr;
     Tcl_Obj *opObj;
-    int index;
+    int i, index;
 
     static CONST char *options[] = {
 	"bytelength",	"compare",	"equal",	"first",
@@ -2499,14 +2504,13 @@ TclCompileStringCmd(interp, parsePtr, envPtr)
 	STR_REPLACE,	STR_TOLOWER,	STR_TOUPPER,	STR_TOTITLE,
 	STR_TRIM,	STR_TRIMLEFT,	STR_TRIMRIGHT,
 	STR_WORDEND,	STR_WORDSTART
-    };	  
+    };
 
     if (parsePtr->numWords < 2) {
 	/* Fail at run time, not in compilation */
 	return TCL_ERROR;
     }
-    opTokenPtr = parsePtr->tokenPtr
-	+ (parsePtr->tokenPtr->numComponents + 1);
+    opTokenPtr = TokenAfter(parsePtr->tokenPtr);
 
     opObj = Tcl_NewStringObj(opTokenPtr->start, opTokenPtr->size);
     if (Tcl_GetIndexFromObj(interp, opObj, options, "option", 0,
@@ -2517,155 +2521,134 @@ TclCompileStringCmd(interp, parsePtr, envPtr)
     }
     Tcl_DecrRefCount(opObj);
 
-    varTokenPtr = opTokenPtr + (opTokenPtr->numComponents + 1);
+    varTokenPtr = TokenAfter(opTokenPtr);
 
     switch ((enum options) index) {
-	case STR_BYTELENGTH:
-	case STR_FIRST:
-	case STR_IS:
-	case STR_LAST:
-	case STR_MAP:
-	case STR_RANGE:
-	case STR_REPEAT:
-	case STR_REPLACE:
-	case STR_TOLOWER:
-	case STR_TOUPPER:
-	case STR_TOTITLE:
-	case STR_TRIM:
-	case STR_TRIMLEFT:
-	case STR_TRIMRIGHT:
-	case STR_WORDEND:
-	case STR_WORDSTART:
-	    /*
-	     * All other cases: compile out of line.
-	     */
-	    return TCL_ERROR;
+    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.
+	 */
 
-	case STR_COMPARE: 
-	case STR_EQUAL: {
-	    int i;
-	    /*
-	     * If there are any flags to the command, we can't byte compile it
-	     * because the INST_STR_EQ bytecode doesn't support flags.
-	     */
+	if (parsePtr->numWords != 4) {
+	    return TCL_ERROR;
+	}
 
-	    if (parsePtr->numWords != 4) {
-		return TCL_ERROR;
-	    }
+	/*
+	 * Push the two operands onto the stack.
+	 */
 
-	    /*
-	     * Push the two operands onto the stack.
-	     */
+	for (i = 0; i < 2; i++) {
+	    CompileWord(envPtr, varTokenPtr, interp);
+	    varTokenPtr = TokenAfter(varTokenPtr);
+	}
 
-	    for (i = 0; i < 2; i++) {
-		CompileWord(envPtr, varTokenPtr, interp);
-		varTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
-	    }
+	TclEmitOpcode(((((enum options) index) == STR_COMPARE) ?
+		INST_STR_CMP : INST_STR_EQ), envPtr);
+	return TCL_OK;
 
-	    TclEmitOpcode(((((enum options) index) == STR_COMPARE) ?
-		    INST_STR_CMP : INST_STR_EQ), envPtr);
-	    return TCL_OK;
+    case STR_INDEX:
+	if (parsePtr->numWords != 4) {
+	    /* Fail at run time, not in compilation */
+	    return TCL_ERROR;
 	}
-	case STR_INDEX: {
-	    int i;
 
-	    if (parsePtr->numWords != 4) {
-		/* Fail at run time, not in compilation */
-		return TCL_ERROR;
-	    }
+	/*
+	 * Push the two operands onto the stack.
+	 */
 
-	    /*
-	     * Push the two operands onto the stack.
-	     */
+	for (i = 0; i < 2; i++) {
+	    CompileWord(envPtr, varTokenPtr, interp);
+	    varTokenPtr = TokenAfter(varTokenPtr);
+	}
 
-	    for (i = 0; i < 2; i++) {
-		CompileWord(envPtr, varTokenPtr, interp);
-		varTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
-	    }
+	TclEmitOpcode(INST_STR_INDEX, envPtr);
+	return TCL_OK;
+    case STR_MATCH: {
+	int length, exactMatch = 0, nocase = 0;
+	CONST char *str;
 
-	    TclEmitOpcode(INST_STR_INDEX, envPtr);
-	    return TCL_OK;
+	if (parsePtr->numWords < 4 || parsePtr->numWords > 5) {
+	    /* Fail at run time, not in compilation */
+	    return TCL_ERROR;
 	}
-	case STR_LENGTH: {
-	    if (parsePtr->numWords != 3) {
-		/* Fail at run time, not in compilation */
+
+	if (parsePtr->numWords == 5) {
+	    if (varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
 		return TCL_ERROR;
 	    }
-
-	    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.
-		 */
-		char buf[TCL_INTEGER_SPACE];
-		int len = Tcl_NumUtfChars(varTokenPtr[1].start,
-			varTokenPtr[1].size);
-		len = sprintf(buf, "%d", len);
-		TclEmitPush(TclRegisterNewLiteral(envPtr, buf, len), envPtr);
-		return TCL_OK;
+	    str = varTokenPtr[1].start;
+	    length = varTokenPtr[1].size;
+	    if ((length > 1) &&
+		    strncmp(str, "-nocase", (size_t) length) == 0) {
+		nocase = 1;
 	    } else {
-		TclCompileTokens(interp, varTokenPtr+1,
-			varTokenPtr->numComponents, envPtr);
-	    }
-	    TclEmitOpcode(INST_STR_LEN, envPtr);
-	    return TCL_OK;
-	}
-	case STR_MATCH: {
-	    int i, length, exactMatch = 0, nocase = 0;
-	    CONST char *str;
-
-	    if (parsePtr->numWords < 4 || parsePtr->numWords > 5) {
 		/* Fail at run time, not in compilation */
 		return TCL_ERROR;
 	    }
+	    varTokenPtr = TokenAfter(varTokenPtr);
+	}
 
-	    if (parsePtr->numWords == 5) {
-		if (varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
-		    return TCL_ERROR;
-		}
-		str    = varTokenPtr[1].start;
+	for (i = 0; i < 2; i++) {
+	    if (varTokenPtr->type == TCL_TOKEN_SIMPLE_WORD) {
+		str = varTokenPtr[1].start;
 		length = varTokenPtr[1].size;
-		if ((length > 1) &&
-			strncmp(str, "-nocase", (size_t) length) == 0) {
-		    nocase = 1;
-		} else {
-		    /* Fail at run time, not in compilation */
-		    return TCL_ERROR;
+		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(Tcl_GetString(copy));
+		    Tcl_DecrRefCount(copy);
 		}
-		varTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
+		PushLiteral(envPtr, str, length);
+	    } else {
+		TclCompileTokens(interp, varTokenPtr+1,
+			varTokenPtr->numComponents, envPtr);
 	    }
+	    varTokenPtr = TokenAfter(varTokenPtr);
+	}
 
-	    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(Tcl_GetString(copy));
-			Tcl_DecrRefCount(copy);
-		    }
-		    TclEmitPush(
-			    TclRegisterNewLiteral(envPtr, str, length), envPtr);
-		} else {
-		    TclCompileTokens(interp, varTokenPtr+1,
-			    varTokenPtr->numComponents, envPtr);
-		}
-		varTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
-	    }
+	if (exactMatch) {
+	    TclEmitOpcode(INST_STR_EQ, envPtr);
+	} else {
+	    TclEmitInstInt1(INST_STR_MATCH, nocase, envPtr);
+	}
+	return TCL_OK;
+    }
+    case STR_LENGTH:
+	if (parsePtr->numWords != 3) {
+	    /* Fail at run time, not in compilation */
+	    return TCL_ERROR;
+	}
 
-	    if (exactMatch) {
-		TclEmitOpcode(INST_STR_EQ, envPtr);
-	    } else {
-		TclEmitInstInt1(INST_STR_MATCH, nocase, envPtr);
-	    }
+	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.
+	     */
+	    char buf[TCL_INTEGER_SPACE];
+	    int len = Tcl_NumUtfChars(varTokenPtr[1].start,
+		    varTokenPtr[1].size);
+	    len = sprintf(buf, "%d", len);
+	    PushLiteral(envPtr, buf, len);
 	    return TCL_OK;
+	} else {
+	    TclCompileTokens(interp, varTokenPtr+1,
+		    varTokenPtr->numComponents, envPtr);
 	}
+	TclEmitOpcode(INST_STR_LEN, envPtr);
+	return TCL_OK;
+
+    default:
+	/*
+	 * All other cases: compile out of line.
+	 */
+	return TCL_ERROR;
     }
 
     return TCL_OK;
@@ -2679,14 +2662,14 @@ TclCompileStringCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "switch" command.
  *
  * Results:
- * 	Returns TCL_OK for successful compile, or TCL_ERROR
- * 	to defer evaluation to runtime (either when it is too complex
- * 	to get the semantics right, or when we know for sure that it
- * 	is an error but need the error to happen at the right time).
+ * 	Returns TCL_OK for successful compile, or TCL_ERROR to defer
+ * 	evaluation to runtime (either when it is too complex to get the
+ * 	semantics right, or when we know for sure that it is an error but need
+ * 	the error to happen at the right time).
  *
  * Side effects:
- *	Instructions are added to envPtr to execute the "switch" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "switch" command at
+ *	runtime.
  *
  * FIXME:
  *	Stack depths are probably not calculated correctly.
@@ -2697,8 +2680,8 @@ TclCompileStringCmd(interp, parsePtr, envPtr)
 int
 TclCompileSwitchCmd(interp, parsePtr, envPtr)
     Tcl_Interp *interp;		/* Used for error reporting. */
-    Tcl_Parse *parsePtr;	/* Points to a parse structure for the
-				 * command created by Tcl_ParseCommand. */
+    Tcl_Parse *parsePtr;	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
 {
     Tcl_Token *tokenPtr;	/* Pointer to tokens in command */
@@ -2710,17 +2693,17 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
 
     Tcl_Token *bodyTokenArray;	/* Array of real pattern list items. */
     Tcl_Token **bodyToken;	/* Array of pointers to pattern list items. */
-    int foundDefault;		/* Flag to indicate whether a "default"
-				 * clause is present. */
+    int foundDefault;		/* Flag to indicate whether a "default" clause
+				 * is present. */
 
     JumpFixup *fixupArray;	/* Array of forward-jump fixup records. */
     int *fixupTargetArray;	/* Array of places for fixups to point at. */
     int fixupCount;		/* Number of places to fix up. */
-    int contFixIndex;		/* Where the first of the jumps due to a
-				 * group of continuation bodies starts,
-				 * or -1 if there aren't any. */
-    int contFixCount;		/* Number of continuation bodies pointing
-				 * to the current (or next) real body. */
+    int contFixIndex;		/* Where the first of the jumps due to a group
+				 * of continuation bodies starts, or -1 if
+				 * there aren't any. */
+    int contFixCount;		/* Number of continuation bodies pointing to
+				 * the current (or next) real body. */
 
     int savedStackDepth = envPtr->currStackDepth;
     int noCase;
@@ -2729,31 +2712,31 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
     /*
      * Only handle the following versions:
      *   switch        -- word {pattern body ...}
-     *   switch -exact -- word {pattern body ...} 
+     *   switch -exact -- word {pattern body ...}
      *   switch -glob  -- word {pattern body ...}
      *   switch        -- word simpleWordPattern simpleWordBody ...
      *   switch -exact -- word simpleWordPattern simpleWordBody ...
      *   switch -glob  -- word simpleWordPattern simpleWordBody ...
+     * When the mode is -glob, can also handle a -nocase flag.
      */
 
     tokenPtr = parsePtr->tokenPtr;
     numWords = parsePtr->numWords;
 
     /*
-     * We don't care how the command's word was generated; we're
-     * compiling it anyway!
+     * We don't care how the command's word was generated; we're compiling it
+     * anyway!
      */
 
-    tokenPtr += tokenPtr->numComponents + 1;
+    tokenPtr = TokenAfter(tokenPtr);
     numWords--;
 
     /*
-     * Check for options. There must be at least one, --, because
-     * without that there is no way to statically avoid the problems
-     * you get from strings-to-match that start with a - (the
-     * interpreted code falls apart if it encounters them, so we punt
-     * if we *might* encounter them as that is the easiest way of
-     * emulating the behaviour).
+     * Check for options. There must be at least one, --, because without that
+     * there is no way to statically avoid the problems you get from strings-
+     * -to-be-matched that start with a - (the interpreted code falls apart if
+     * it encounters them, so we punt if we *might* encounter them as that is
+     * the easiest way of emulating the behaviour).
      */
 
     noCase = 0;
@@ -2763,9 +2746,9 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
 	register CONST char *chrs = tokenPtr[1].start;
 
 	/*
-	 * We only process literal options, and we assume that -e, -g
-	 * and -n are unique prefixes of -exact, -glob and -nocase
-	 * respectively (true at time of writing).
+	 * We only process literal options, and we assume that -e, -g and -n
+	 * are unique prefixes of -exact, -glob and -nocase respectively (true
+	 * at time of writing).
 	 */
 	if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD || size < 2) {
 	    return TCL_ERROR;
@@ -2785,11 +2768,12 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
 	}
 
 	/*
-	 * The switch command has many flags we cannot compile at all
-	 * (e.g. all the RE-related ones) which we must have
-	 * encountered. Either that or we have run off the end. The
-	 * action here is the same: punt to interpreted version.
+	 * The switch command has many flags we cannot compile at all (e.g.
+	 * all the RE-related ones) which we must have encountered.  Either
+	 * that or we have run off the end. The action here is the same: punt
+	 * to interpreted version.
 	 */
+
 	return TCL_ERROR;
     }
     if (numWords < 3) {
@@ -2799,28 +2783,27 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
     numWords--;
     if (noCase && (mode == Switch_Exact)) {
 	/*
-	 * Can't compile this case!
+	 * Can't compile this case; no opcode for case-insensitive equality!
 	 */
 	return TCL_ERROR;
     }
 
     /*
-     * The value to test against is going to always get pushed on the
-     * stack.  But not yet; we need to verify that the rest of the
-     * command is compilable too.
+     * The value to test against is going to always get pushed on the stack.
+     * But not yet; we need to verify that the rest of the command is
+     * compilable too.
      */
 
     valueTokenPtr = tokenPtr;
-    tokenPtr += tokenPtr->numComponents + 1;
+    tokenPtr = TokenAfter(tokenPtr);
     numWords--;
 
     /*
-     * Build an array of tokens for the matcher terms and script
-     * bodies. Note that in the case of the quoted bodies, this is
-     * tricky as we cannot use copies of the string from the input
-     * token for the generated tokens (it causes a crash during
-     * exception handling). When multiple tokens are available at this
-     * point, this is pretty easy.
+     * Build an array of tokens for the matcher terms and script bodies. Note
+     * that in the case of the quoted bodies, this is tricky as we cannot use
+     * copies of the string from the input token for the generated tokens (it
+     * causes a crash during exception handling). When multiple tokens are
+     * available at this point, this is pretty easy.
      */
 
     if (numWords == 1) {
@@ -2830,9 +2813,9 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
 	CONST char *tokenStartPtr;
 
 	/*
-	 * Test that we've got a suitable body list as a simple (i.e.
-	 * braced) word, and that the elements of the body are simple
-	 * words too.  This is really rather nasty indeed.
+	 * Test that we've got a suitable body list as a simple (i.e. braced)
+	 * word, and that the elements of the body are simple words too. This
+	 * is really rather nasty indeed.
 	 */
 
 	if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
@@ -2846,12 +2829,25 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
 	    return TCL_ERROR;
 	}
 	Tcl_DStringFree(&bodyList);
+
+	/*
+	 * Now we know what the switch arms are, we've got to see whether we
+	 * can synthesize tokens for the arms. First check whether we've got a
+	 * valid number of arms since we can do that now.
+	 */
+
 	if (numWords == 0 || numWords % 2) {
 	    ckfree((char *) argv);
 	    return TCL_ERROR;
 	}
+
 	bodyTokenArray = (Tcl_Token *) ckalloc(sizeof(Tcl_Token) * numWords);
 	bodyToken = (Tcl_Token **) ckalloc(sizeof(Tcl_Token *) * numWords);
+
+	/*
+	 * Locate the start of the arms within the overall word.
+	 */
+
 	tokenStartPtr = tokenPtr[1].start;
 	while (isspace(UCHAR(*tokenStartPtr))) {
 	    tokenStartPtr++;
@@ -2869,12 +2865,14 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
 	    bodyTokenArray[i].numComponents = 0;
 	    bodyToken[i] = bodyTokenArray+i;
 	    tokenStartPtr += bodyTokenArray[i].size;
+
 	    /*
-	     * Test to see if we have guessed the end of the word
-	     * correctly; if not, we can't feed the real string to the
-	     * sub-compilation engine, and we're then stuck and so
-	     * have to punt out to doing everything at runtime.
+	     * Test to see if we have guessed the end of the word correctly;
+	     * if not, we can't feed the real string to the sub-compilation
+	     * engine, and we're then stuck and so have to punt out to doing
+	     * everything at runtime.
 	     */
+
 	    if ((isTokenBraced && *(tokenStartPtr++) != '}') ||
 		    (tokenStartPtr < tokenPtr[1].start+tokenPtr[1].size
 		    && !isspace(UCHAR(*tokenStartPtr)))) {
@@ -2897,35 +2895,40 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
 	    }
 	}
 	ckfree((char *)argv);
+
 	/*
-	 * Check that we've parsed everything we thought we were going
-	 * to parse. If not, something odd is going on and we should
-	 * bail out.
+	 * Check that we've parsed everything we thought we were going to
+	 * parse. If not, something odd is going on (I believe it is possible
+	 * to defeat the code above) and we should bail out.
 	 */
+
 	if (tokenStartPtr != tokenPtr[1].start+tokenPtr[1].size) {
 	    ckfree((char *) bodyToken);
 	    ckfree((char *) bodyTokenArray);
 	    return TCL_ERROR;
 	}
+
     } else if (numWords % 2 || numWords == 0) {
 	/*
-	 * Odd number of words (>1) available, or no words at all
-	 * available. Both are error cases, so punt and let the
-	 * interpreted-version generate the error message. Note that
-	 * the second case probably should get caught earlier, but
-	 * it's easy to check here again anyway because it'd cause a
-	 * nasty crash otherwise.
+	 * Odd number of words (>1) available, or no words at all available.
+	 * Both are error cases, so punt and let the interpreted-version
+	 * generate the error message. Note that the second case probably
+	 * should get caught earlier, but it's easy to check here again anyway
+	 * because it'd cause a nasty crash otherwise.
 	 */
+
 	return TCL_ERROR;
+
     } else {
 	bodyToken = (Tcl_Token **) ckalloc(sizeof(Tcl_Token *) * numWords);
 	bodyTokenArray = NULL;
 	for (i=0 ; i<numWords ; i++) {
 	    /*
-	     * We only handle the very simplest case. Anything more
-	     * complex is a good reason to go to the interpreted case
-	     * anyway due to traces, etc.
+	     * We only handle the very simplest case. Anything more complex is
+	     * a good reason to go to the interpreted case anyway due to
+	     * traces, etc.
 	     */
+
 	    if (tokenPtr->type != TCL_TOKEN_SIMPLE_WORD ||
 		    tokenPtr->numComponents != 1) {
 		ckfree((char *) bodyToken);
@@ -2937,9 +2940,8 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
     }
 
     /*
-     * Fall back to interpreted if the last body is a continuation
-     * (it's illegal, but this makes the error happen at the right
-     * time).
+     * Fall back to interpreted if the last body is a continuation (it's
+     * illegal, but this makes the error happen at the right time).
      */
 
     if (bodyToken[numWords-1]->size == 1 &&
@@ -2952,9 +2954,7 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
     }
 
     /*
-     * Now we commit to generating code; the parsing stage per se is
-     * done.
-     *
+     * Now we commit to generating code; the parsing stage per se is done.
      * First, we push the value we're matching against on the stack.
      */
 
@@ -2992,59 +2992,63 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
 		TclEmitInstInt1(INST_STR_MATCH, noCase, envPtr);
 		break;
 	    default:
-		Tcl_Panic("unknown switch mode: %d",mode);
+		Tcl_Panic("unknown switch mode: %d", mode);
 	    }
+
 	    /*
-	     * Process fall-through clauses here...
+	     * In a fall-through case, we will jump on _true_ to the place
+	     * where the body starts (generated later, with guarantee of this
+	     * ensured earlier; the final body is never a fall-through).
 	     */
+
 	    if (bodyToken[i+1]->size==1 && bodyToken[i+1]->start[0]=='-') {
 		if (contFixIndex == -1) {
 		    contFixIndex = fixupCount;
 		    contFixCount = 0;
 		}
 		TclEmitForwardJump(envPtr, TCL_TRUE_JUMP,
-			&fixupArray[contFixIndex+contFixCount]);
+			fixupArray+contFixIndex+contFixCount);
 		fixupCount++;
 		contFixCount++;
 		continue;
 	    }
-	    TclEmitForwardJump(envPtr, TCL_FALSE_JUMP,
-		    &fixupArray[fixupCount]);
+
+	    TclEmitForwardJump(envPtr, TCL_FALSE_JUMP, fixupArray+fixupCount);
 	    nextArmFixupIndex = fixupCount;
 	    fixupCount++;
 	} else {
 	    /*
-	     * Got a default clause; set a flag to inhibit the
-	     * generation of the jump after the body and the cleanup
-	     * of the intermediate value that we are switching
-	     * against.
+	     * Got a default clause; set a flag to inhibit the generation of
+	     * the jump after the body and the cleanup of the intermediate
+	     * value that we are switching against.
 	     *
-	     * Note that default clauses (which are always last
-	     * clauses) cannot be fall-through clauses as well, since
-	     * the last clause is never a fall-through clause (which
-	     * we have already verified).
+	     * Note that default clauses (which are always terminal clauses)
+	     * cannot be fall-through clauses as well, since the last clause
+	     * is never a fall-through clause (which we have already
+	     * verified).
 	     */
 
 	    foundDefault = 1;
 	}
 
 	/*
-	 * Generate the body for the arm.  This is guaranteed not to
-	 * be a fall-through case, but it might have preceding
-	 * fall-through cases, so we must process those first.
+	 * Generate the body for the arm.  This is guaranteed not to be a
+	 * fall-through case, but it might have preceding fall-through cases,
+	 * so we must process those first.
 	 */
 
 	if (contFixIndex != -1) {
 	    int j;
 	    for (j=0 ; j<contFixCount ; j++) {
-		fixupTargetArray[contFixIndex+j] =
-			envPtr->codeNext-envPtr->codeStart;
+		fixupTargetArray[contFixIndex+j] = CurrentOffset(envPtr);
 	    }
 	    contFixIndex = -1;
 	}
 
 	/*
-	 * Now do the actual compilation.
+	 * Now do the actual compilation. Note that we do not use CompileBody
+	 * because we may have synthesized the tokens in a non-standard
+	 * pattern.
 	 */
 
 	TclEmitOpcode(INST_POP, envPtr);
@@ -3053,10 +3057,9 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
 
 	if (!foundDefault) {
 	    TclEmitForwardJump(envPtr, TCL_UNCONDITIONAL_JUMP,
-		    &fixupArray[fixupCount]);
+		    fixupArray+fixupCount);
 	    fixupCount++;
-	    fixupTargetArray[nextArmFixupIndex] =
-		    envPtr->codeNext-envPtr->codeStart;
+	    fixupTargetArray[nextArmFixupIndex] = CurrentOffset(envPtr);
 	}
     }
     ckfree((char *) bodyToken);
@@ -3065,20 +3068,22 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
     }
 
     /*
-     * Discard the value we are matching against unless we've had a
-     * default clause (in which case it will already be gone) and make
-     * the result of the command an empty string.
+     * Discard the value we are matching against unless we've had a default
+     * clause (in which case it will already be gone due to the code at the
+     * start of processing an arm, guaranteed) and make the result of the
+     * command an empty string.
      */
 
     if (!foundDefault) {
 	TclEmitOpcode(INST_POP, envPtr);
-	TclEmitPush(TclRegisterNewLiteral(envPtr, "", 0), envPtr);
+	PushLiteral(envPtr, "", 0);
     }
 
     /*
-     * Do jump fixups for arms that were executed.  First, fill in the
-     * jumps of all jumps that don't point elsewhere to point to here.
+     * Do jump fixups for arms that were executed.  First, fill in the jumps
+     * of all jumps that don't point elsewhere to point to here.
      */
+
     for (i=0 ; i<fixupCount ; i++) {
 	if (fixupTargetArray[i] == 0) {
 	    fixupTargetArray[i] = envPtr->codeNext-envPtr->codeStart;
@@ -3086,15 +3091,16 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
     }
 
     /*
-     * Now scan backwards over all the jumps (all of which are forward
-     * jumps) doing each one.  When we do one and there is a size
-     * changes, we must scan back over all the previous ones and see
-     * if they need adjusting before proceeding with further jump
-     * fixups.
+     * Now scan backwards over all the jumps (all of which are forward jumps)
+     * doing each one.  When we do one and there is a size changes, we must
+     * scan back over all the previous ones and see if they need adjusting
+     * before proceeding with further jump fixups (the interleaved nature of
+     * all the jumps makes this impossible to do without nested loops).
      */
+
     for (i=fixupCount-1 ; i>=0 ; i--) {
 	if (TclFixupForwardJump(envPtr, &fixupArray[i],
-		fixupTargetArray[i]-fixupArray[i].codeOffset, 127)) {
+		fixupTargetArray[i] - fixupArray[i].codeOffset, 127)) {
 	    int j;
 	    for (j=i-1 ; j>=0 ; j--) {
 		if (fixupTargetArray[j] > fixupArray[i].codeOffset) {
@@ -3115,8 +3121,8 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
  *
  * TclCompileVariableCmd --
  *
- *	Procedure called to reserve the local variables for the 
- *      "variable" command. The command itself is *not* compiled.
+ *	Procedure called to reserve the local variables for the "variable"
+ *	command. The command itself is *not* compiled.
  *
  * Results:
  *      Always returns TCL_ERROR.
@@ -3126,11 +3132,12 @@ TclCompileSwitchCmd(interp, parsePtr, envPtr)
  *
  *----------------------------------------------------------------------
  */
+
 int
 TclCompileVariableCmd(interp, parsePtr, envPtr)
     Tcl_Interp *interp;		/* Used for error reporting. */
-    Tcl_Parse *parsePtr;	/* Points to a parse structure for the
-				 * command created by Tcl_ParseCommand. */
+    Tcl_Parse *parsePtr;	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
 {
     Tcl_Token *varTokenPtr;
@@ -3143,23 +3150,34 @@ TclCompileVariableCmd(interp, parsePtr, envPtr)
 
     numWords = parsePtr->numWords;
 
-    varTokenPtr = parsePtr->tokenPtr
-	+ (parsePtr->tokenPtr->numComponents + 1);
+    varTokenPtr = TokenAfter(parsePtr->tokenPtr);
     for (i = 1; i < numWords; i += 2) {
-	if (varTokenPtr->type == TCL_TOKEN_SIMPLE_WORD) {
-	    varName = varTokenPtr[1].start;
-	    tail = varName + varTokenPtr[1].size - 1;
-	    if ((*tail == ')') || (tail < varName)) continue;
-	    while ((tail > varName) && ((*tail != ':') || (*(tail-1) != ':'))) {
-		tail--;
-	    }
-	    if ((*tail == ':') && (tail > varName)) {
-		tail++;
-	    }
-	    (void) TclFindCompiledLocal(tail, (tail-varName+1),
-		    /*create*/ 1, /*flags*/ 0, envPtr->procPtr);
-	    varTokenPtr = varTokenPtr + (varTokenPtr->numComponents + 1);
+	/*
+	 * Skip non-literals.
+	 */
+	if (varTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
+	    continue;
 	}
+
+	varName = varTokenPtr[1].start;
+	tail = varName + varTokenPtr[1].size - 1;
+
+	/*
+	 * Skip if it looks like it might be an array or an empty string.
+	 */
+	if ((*tail == ')') || (tail < varName)) {
+	    continue;
+	}
+
+	while ((tail > varName) && ((*tail != ':') || (*(tail-1) != ':'))) {
+	    tail--;
+	}
+	if ((*tail == ':') && (tail > varName)) {
+	    tail++;
+	}
+	(void) TclFindCompiledLocal(tail, tail-varName+1,
+		/*create*/ 1, /*flags*/ 0, envPtr->procPtr);
+	varTokenPtr = TokenAfter(varTokenPtr);
     }
     return TCL_ERROR;
 }
@@ -3172,12 +3190,12 @@ TclCompileVariableCmd(interp, parsePtr, envPtr)
  *	Procedure called to compile the "while" command.
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "while" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "while" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -3185,8 +3203,8 @@ TclCompileVariableCmd(interp, parsePtr, envPtr)
 int
 TclCompileWhileCmd(interp, parsePtr, envPtr)
     Tcl_Interp *interp;		/* Used for error reporting. */
-    Tcl_Parse *parsePtr;	/* Points to a parse structure for the
-				 * command created by Tcl_ParseCommand. */
+    Tcl_Parse *parsePtr;	/* Points to a parse structure for the command
+				 * created by Tcl_ParseCommand. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
 {
     Tcl_Token *testTokenPtr, *bodyTokenPtr;
@@ -3194,8 +3212,8 @@ TclCompileWhileCmd(interp, parsePtr, envPtr)
     int testCodeOffset, bodyCodeOffset, jumpDist;
     int range, code;
     int savedStackDepth = envPtr->currStackDepth;
-    int loopMayEnd = 1;         /* This is set to 0 if it is recognized as
-				 * an infinite loop. */
+    int loopMayEnd = 1;		/* This is set to 0 if it is recognized as an
+				 * infinite loop. */
     Tcl_Obj *boolObj;
     int boolVal;
 
@@ -3204,24 +3222,24 @@ TclCompileWhileCmd(interp, parsePtr, envPtr)
     }
 
     /*
-     * If the test expression requires substitutions, don't compile the
-     * while command inline. E.g., the expression might cause the loop to
-     * never execute or execute forever, as in "while "$x < 5" {}".
+     * If the test expression requires substitutions, don't compile the while
+     * command inline. E.g., the expression might cause the loop to never
+     * execute or execute forever, as in "while "$x < 5" {}".
      *
-     * Bail out also if the body expression requires substitutions
-     * in order to insure correct behaviour [Bug 219166]
+     * Bail out also if the body expression requires substitutions in order to
+     * insure correct behaviour [Bug 219166]
      */
 
-    testTokenPtr = parsePtr->tokenPtr
-	    + (parsePtr->tokenPtr->numComponents + 1);
-    bodyTokenPtr = testTokenPtr + (testTokenPtr->numComponents + 1);
+    testTokenPtr = TokenAfter(parsePtr->tokenPtr);
+    bodyTokenPtr = TokenAfter(testTokenPtr);
+
     if ((testTokenPtr->type != TCL_TOKEN_SIMPLE_WORD)
 	    || (bodyTokenPtr->type != TCL_TOKEN_SIMPLE_WORD)) {
 	return TCL_ERROR;
     }
 
     /*
-     * Find out if the condition is a constant. 
+     * Find out if the condition is a constant.
      */
 
     boolObj = Tcl_NewStringObj(testTokenPtr[1].start, testTokenPtr[1].size);
@@ -3231,28 +3249,29 @@ TclCompileWhileCmd(interp, parsePtr, envPtr)
     if (code == TCL_OK) {
 	if (boolVal) {
 	    /*
-	     * it is an infinite loop 
+	     * It is an infinite loop; flag it so that we generate a more
+	     * efficient body.
 	     */
 
-	    loopMayEnd = 0;  
+	    loopMayEnd = 0;
 	} else {
 	    /*
-	     * This is an empty loop: "while 0 {...}" or such.
-	     * Compile no bytecodes.
+	     * This is an empty loop: "while 0 {...}" or such.  Compile no
+	     * bytecodes.
 	     */
 
 	    goto pushResult;
 	}
     }
 
-    /* 
+    /*
      * Create a ExceptionRange record for the loop body. This is used to
      * implement break and continue.
      */
 
     envPtr->exceptDepth++;
     envPtr->maxExceptDepth =
-	TclMax(envPtr->exceptDepth, envPtr->maxExceptDepth);
+	    TclMax(envPtr->exceptDepth, envPtr->maxExceptDepth);
     range = TclCreateExceptRange(LOOP_EXCEPTION_RANGE, envPtr);
 
     /*
@@ -3273,19 +3292,18 @@ TclCompileWhileCmd(interp, parsePtr, envPtr)
 	TclEmitForwardJump(envPtr, TCL_UNCONDITIONAL_JUMP, &jumpEvalCondFixup);
 	testCodeOffset = 0; /* avoid compiler warning */
     } else {
-	testCodeOffset = (envPtr->codeNext - envPtr->codeStart);
+	testCodeOffset = CurrentOffset(envPtr);
     }
 
     /*
      * Compile the loop body.
      */
 
-    bodyCodeOffset = (envPtr->codeNext - envPtr->codeStart);
-    TclCompileCmdWord(interp, bodyTokenPtr+1,
-	    bodyTokenPtr->numComponents, envPtr);
+    bodyCodeOffset = CurrentOffset(envPtr);
+    CompileBody(envPtr, bodyTokenPtr, interp);
     envPtr->currStackDepth = savedStackDepth + 1;
     envPtr->exceptArrayPtr[range].numCodeBytes =
-	    (envPtr->codeNext - envPtr->codeStart) - bodyCodeOffset;
+	    CurrentOffset(envPtr) - bodyCodeOffset;
     TclEmitOpcode(INST_POP, envPtr);
 
     /*
@@ -3294,7 +3312,7 @@ TclCompileWhileCmd(interp, parsePtr, envPtr)
      */
 
     if (loopMayEnd) {
-	testCodeOffset = (envPtr->codeNext - envPtr->codeStart);
+	testCodeOffset = CurrentOffset(envPtr);
 	jumpDist = testCodeOffset - jumpEvalCondFixup.codeOffset;
 	if (TclFixupForwardJump(envPtr, &jumpEvalCondFixup, jumpDist, 127)) {
 	    bodyCodeOffset += 3;
@@ -3304,19 +3322,19 @@ TclCompileWhileCmd(interp, parsePtr, envPtr)
 	TclCompileExprWords(interp, testTokenPtr, 1, envPtr);
 	envPtr->currStackDepth = savedStackDepth + 1;
 
-	jumpDist = (envPtr->codeNext - envPtr->codeStart) - bodyCodeOffset;
+	jumpDist = CurrentOffset(envPtr) - bodyCodeOffset;
 	if (jumpDist > 127) {
 	    TclEmitInstInt4(INST_JUMP_TRUE4, -jumpDist, envPtr);
 	} else {
 	    TclEmitInstInt1(INST_JUMP_TRUE1, -jumpDist, envPtr);
 	}
     } else {
-	jumpDist = (envPtr->codeNext - envPtr->codeStart) - bodyCodeOffset;
+	jumpDist = CurrentOffset(envPtr) - bodyCodeOffset;
 	if (jumpDist > 127) {
 	    TclEmitInstInt4(INST_JUMP4, -jumpDist, envPtr);
 	} else {
 	    TclEmitInstInt1(INST_JUMP1, -jumpDist, envPtr);
-	}	
+	}
     }
 
 
@@ -3326,16 +3344,15 @@ TclCompileWhileCmd(interp, parsePtr, envPtr)
 
     envPtr->exceptArrayPtr[range].continueOffset = testCodeOffset;
     envPtr->exceptArrayPtr[range].codeOffset = bodyCodeOffset;
-    envPtr->exceptArrayPtr[range].breakOffset =
-	    (envPtr->codeNext - envPtr->codeStart);
+    envPtr->exceptArrayPtr[range].breakOffset = CurrentOffset(envPtr);
 
     /*
      * The while command's result is an empty string.
      */
 
-    pushResult:
+  pushResult:
     envPtr->currStackDepth = savedStackDepth;
-    TclEmitPush(TclRegisterNewLiteral(envPtr, "", 0), envPtr);
+    PushLiteral(envPtr, "", 0);
     envPtr->exceptDepth--;
     return TCL_OK;
 }
@@ -3345,16 +3362,16 @@ TclCompileWhileCmd(interp, parsePtr, envPtr)
  *
  * PushVarName --
  *
- *	Procedure used in the compiling where pushing a variable name
- *	is necessary (append, lappend, set).
+ *	Procedure used in the compiling where pushing a variable name is
+ *	necessary (append, lappend, set).
  *
  * Results:
- * 	Returns TCL_OK for a successful compile.
- * 	Returns TCL_ERROR to defer evaluation to runtime.
+ * 	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 "set" command
- *	at runtime.
+ *	Instructions are added to envPtr to execute the "set" command at
+ *	runtime.
  *
  *----------------------------------------------------------------------
  */
@@ -3365,8 +3382,7 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
     Tcl_Interp *interp;		/* Used for error reporting. */
     Tcl_Token *varTokenPtr;	/* Points to a variable token. */
     CompileEnv *envPtr;		/* Holds resulting instructions. */
-    int flags;			/* takes TCL_CREATE_VAR or
-				 * TCL_NO_LARGE_INDEX */
+    int flags;			/* TCL_CREATE_VAR or TCL_NO_LARGE_INDEX */
     int *localIndexPtr;		/* must not be NULL */
     int *simpleVarNamePtr;	/* must not be NULL */
     int *isScalarPtr;		/* must not be NULL */
@@ -3382,11 +3398,11 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
     int removedParen = 0;
 
     /*
-     * Decide if we can use a frame slot for the var/array name or if we
-     * need to emit code to compute and push the name at runtime. We use a
-     * frame slot (entry in the array of local vars) if we are compiling a
-     * procedure body and if the name is simple text that does not include
-     * namespace qualifiers. 
+     * Decide if we can use a frame slot for the var/array name or if we need
+     * to emit code to compute and push the name at runtime. We use a frame
+     * slot (entry in the array of local vars) if we are compiling a procedure
+     * body and if the name is simple text that does not include namespace
+     * qualifiers.
      */
 
     simpleVarName = 0;
@@ -3396,8 +3412,8 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
 
     /*
      * Check not only that the type is TCL_TOKEN_SIMPLE_WORD, but whether
-     * curly braces surround the variable name.
-     * This really matters for array elements to handle things like
+     * curly braces surround the variable name. This really matters for array
+     * elements to handle things like
      *    set {x($foo)} 5
      * which raises an undefined var error if we are not careful here.
      */
@@ -3413,7 +3429,7 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
 	name = varTokenPtr[1].start;
 	nameChars = varTokenPtr[1].size;
 	if (name[nameChars-1] == ')') {
-	    /* 
+	    /*
 	     * last char is ')' => potential array reference.
 	     */
 
@@ -3428,8 +3444,8 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
 
 	    if ((elName != NULL) && elNameChars) {
 		/*
-		 * An array element, the element name is a simple
-		 * string: assemble the corresponding token.
+		 * An array element, the element name is a simple string:
+		 * assemble the corresponding token.
 		 */
 
 		elemTokenPtr = (Tcl_Token *) ckalloc(sizeof(Tcl_Token));
@@ -3443,28 +3459,28 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
 	}
     } else if (((n = varTokenPtr->numComponents) > 1)
 	    && (varTokenPtr[1].type == TCL_TOKEN_TEXT)
-            && (varTokenPtr[n].type == TCL_TOKEN_TEXT)
-            && (varTokenPtr[n].start[varTokenPtr[n].size - 1] == ')')) {
+	    && (varTokenPtr[n].type == TCL_TOKEN_TEXT)
+	    && (varTokenPtr[n].start[varTokenPtr[n].size - 1] == ')')) {
 
-        /*
+	/*
 	 * Check for parentheses inside first token
 	 */
 
-        simpleVarName = 0;
-        for (i = 0, p = varTokenPtr[1].start; 
-	     i < varTokenPtr[1].size; i++, p++) {
-            if (*p == '(') {
-                simpleVarName = 1;
-                break;
-            }
-        }
-        if (simpleVarName) {
+	simpleVarName = 0;
+	for (i = 0, p = varTokenPtr[1].start;
+		i < varTokenPtr[1].size; i++, p++) {
+	    if (*p == '(') {
+		simpleVarName = 1;
+		break;
+	    }
+	}
+	if (simpleVarName) {
 	    int remainingChars;
 
 	    /*
-	     * Check the last token: if it is just ')', do not count
-	     * it. Otherwise, remove the ')' and flag so that it is
-	     * restored at the end.
+	     * Check the last token: if it is just ')', do not count it.
+	     * Otherwise, remove the ')' and flag so that it is restored at
+	     * the end.
 	     */
 
 	    if (varTokenPtr[n].size == 1) {
@@ -3474,15 +3490,15 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
 		removedParen = n;
 	    }
 
-            name = varTokenPtr[1].start;
-            nameChars = p - varTokenPtr[1].start;
-            elName = p + 1;
-            remainingChars = (varTokenPtr[2].start - p) - 1;
-            elNameChars = (varTokenPtr[n].start - p) + varTokenPtr[n].size - 2;
+	    name = varTokenPtr[1].start;
+	    nameChars = p - varTokenPtr[1].start;
+	    elName = p + 1;
+	    remainingChars = (varTokenPtr[2].start - p) - 1;
+	    elNameChars = (varTokenPtr[n].start - p) + varTokenPtr[n].size - 2;
 
 	    if (remainingChars) {
 		/*
-		 * Make a first token with the extra characters in the first 
+		 * Make a first token with the extra characters in the first
 		 * token.
 		 */
 
@@ -3499,14 +3515,14 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
 		 */
 
 		memcpy((void *) (elemTokenPtr+1), (void *) (&varTokenPtr[2]),
-			((n-1) * sizeof(Tcl_Token)));
+			(n-1) * sizeof(Tcl_Token));
 	    } else {
 		/*
 		 * Use the already available tokens.
 		 */
 
 		elemTokenPtr = &varTokenPtr[2];
-		elemTokenCount = n - 1;	    
+		elemTokenCount = n - 1;
 	    }
 	}
     }
@@ -3525,15 +3541,15 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
 	}
 
 	/*
-	 * Look up the var name's index in the array of local vars in the
-	 * proc frame. If retrieving the var's value and it doesn't already
-	 * exist, push its name and look it up at runtime.
+	 * Look up the var name's index in the array of local vars in the proc
+	 * frame. If retrieving the var's value and it doesn't already exist,
+	 * push its name and look it up at runtime.
 	 */
 
 	if ((envPtr->procPtr != NULL) && !hasNsQualifiers) {
 	    localIndex = TclFindCompiledLocal(name, nameChars,
-		    /*create*/ (flags & TCL_CREATE_VAR),
-                    /*flags*/ ((elName==NULL)? VAR_SCALAR : VAR_ARRAY),
+		    /*create*/ flags & TCL_CREATE_VAR,
+		    /*flags*/ ((elName==NULL)? VAR_SCALAR : VAR_ARRAY),
 		    envPtr->procPtr);
 	    if ((flags & TCL_NO_LARGE_INDEX) && (localIndex > 255)) {
 		/* we'll push the name */
@@ -3541,7 +3557,7 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
 	    }
 	}
 	if (localIndex < 0) {
-	    TclEmitPush(TclRegisterNewLiteral(envPtr, name, nameChars), envPtr);
+	    PushLiteral(envPtr, name, nameChars);
 	}
 
 	/*
@@ -3552,7 +3568,7 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
 	    if (elNameChars) {
 		TclCompileTokens(interp, elemTokenPtr, elemTokenCount, envPtr);
 	    } else {
-		TclEmitPush(TclRegisterNewLiteral(envPtr, "", 0), envPtr);
+		PushLiteral(envPtr, "", 0);
 	    }
 	}
     } else {
@@ -3560,8 +3576,8 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
 	 * The var name isn't simple: compile and push it.
 	 */
 
-	TclCompileTokens(interp, varTokenPtr+1,
-		varTokenPtr->numComponents, envPtr);
+	TclCompileTokens(interp, varTokenPtr+1, varTokenPtr->numComponents,
+		envPtr);
     }
 
     if (removedParen) {
@@ -3570,8 +3586,16 @@ PushVarName(interp, varTokenPtr, envPtr, flags, localIndexPtr,
     if (allocedTokens) {
         ckfree((char *) elemTokenPtr);
     }
-    *localIndexPtr	= localIndex;
-    *simpleVarNamePtr	= simpleVarName;
-    *isScalarPtr	= (elName == NULL);
+    *localIndexPtr = localIndex;
+    *simpleVarNamePtr = simpleVarName;
+    *isScalarPtr = (elName == NULL);
     return TCL_OK;
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */