Improve error-message "cannot use xxxx as operand ....."

9 files changed, 229 insertions, 226 deletions

diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index a063aae..47cb5e6 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -167,7 +167,7 @@ static BuiltinFunc const tclBuiltinFuncTable[] = {
  * Minimal data required to fully reconstruct the execution state.
  */
 
-typedef struct TEBCdata {
+typedef struct {
     ByteCode *codePtr;		/* Constant until the BC returns */
 				/* -----------------------------------------*/
     Tcl_Obj **catchTop;		/* These fields are used on return TO this */
@@ -2446,8 +2446,8 @@ TEBCresume(
 	    if (traceInstructions) {
 		TRACE_APPEND(("YIELD...\n"));
 	    } else {
-		fprintf(stdout, "%d: (%u) yielding value \"%.30s\"\n",
-			iPtr->numLevels, (unsigned)(pc - codePtr->codeStart),
+		fprintf(stdout, "%d: (%" TCL_Z_MODIFIER "u) yielding value \"%.30s\"\n",
+			iPtr->numLevels, (size_t)(pc - codePtr->codeStart),
 			Tcl_GetString(OBJ_AT_TOS));
 	    }
 	    fflush(stdout);
@@ -2489,8 +2489,8 @@ TEBCresume(
 		TRACE(("[%.30s] => YIELD...\n", O2S(valuePtr)));
 	    } else {
 		/* FIXME: What is the right thing to trace? */
-		fprintf(stdout, "%d: (%u) yielding to [%.30s]\n",
-			iPtr->numLevels, (unsigned)(pc - codePtr->codeStart),
+		fprintf(stdout, "%d: (%" TCL_Z_MODIFIER "u) yielding to [%.30s]\n",
+			iPtr->numLevels, (size_t)(pc - codePtr->codeStart),
 			TclGetString(valuePtr));
 	    }
 	    fflush(stdout);
@@ -2851,8 +2851,8 @@ TEBCresume(
 		strncpy(cmdNameBuf, TclGetString(objv[0]), 20);
 		TRACE(("%u => call ", objc));
 	    } else {
-		fprintf(stdout, "%d: (%u) invoking ", iPtr->numLevels,
-			(unsigned)(pc - codePtr->codeStart));
+		fprintf(stdout, "%d: (%" TCL_Z_MODIFIER "u) invoking ", iPtr->numLevels,
+			(size_t)(pc - codePtr->codeStart));
 	    }
 	    for (i = 0;  i < objc;  i++) {
 		TclPrintObject(stdout, objv[i], 15);
@@ -2984,8 +2984,8 @@ TEBCresume(
 		TRACE(("%u => call (implementation %s) ", objc, O2S(objPtr)));
 	    } else {
 		fprintf(stdout,
-			"%d: (%u) invoking (using implementation %s) ",
-			iPtr->numLevels, (unsigned)(pc - codePtr->codeStart),
+			"%d: (%" TCL_Z_MODIFIER "u) invoking (using implementation %s) ",
+			iPtr->numLevels, (size_t)(pc - codePtr->codeStart),
 			O2S(objPtr));
 	    }
 	    for (i = 0;  i < objc;  i++) {
@@ -4308,15 +4308,15 @@ TEBCresume(
 
     case INST_JUMP1:
 	opnd = TclGetInt1AtPtr(pc+1);
-	TRACE(("%d => new pc %u\n", opnd,
-		(unsigned)(pc + opnd - codePtr->codeStart)));
+	TRACE(("%d => new pc %" TCL_Z_MODIFIER "u\n", opnd,
+		(size_t)(pc + opnd - codePtr->codeStart)));
 	NEXT_INST_F(opnd, 0, 0);
     break;
 
     case INST_JUMP4:
 	opnd = TclGetInt4AtPtr(pc+1);
-	TRACE(("%d => new pc %u\n", opnd,
-		(unsigned)(pc + opnd - codePtr->codeStart)));
+	TRACE(("%d => new pc %" TCL_Z_MODIFIER "u\n", opnd,
+		(size_t)(pc + opnd - codePtr->codeStart)));
 	NEXT_INST_F(opnd, 0, 0);
 
     {
@@ -4358,8 +4358,8 @@ TEBCresume(
 #ifdef TCL_COMPILE_DEBUG
 	if (b) {
 	    if ((*pc == INST_JUMP_TRUE1) || (*pc == INST_JUMP_TRUE4)) {
-		TRACE_APPEND(("%.20s true, new pc %u\n", O2S(valuePtr),
-			(unsigned)(pc + jmpOffset[1] - codePtr->codeStart)));
+		TRACE_APPEND(("%.20s true, new pc %" TCL_Z_MODIFIER "u\n", O2S(valuePtr),
+			(size_t)(pc + jmpOffset[1] - codePtr->codeStart)));
 	    } else {
 		TRACE_APPEND(("%.20s true\n", O2S(valuePtr)));
 	    }
@@ -4367,8 +4367,8 @@ TEBCresume(
 	    if ((*pc == INST_JUMP_TRUE1) || (*pc == INST_JUMP_TRUE4)) {
 		TRACE_APPEND(("%.20s false\n", O2S(valuePtr)));
 	    } else {
-		TRACE_APPEND(("%.20s false, new pc %u\n", O2S(valuePtr),
-			(unsigned)(pc + jmpOffset[0] - codePtr->codeStart)));
+		TRACE_APPEND(("%.20s false, new pc %" TCL_Z_MODIFIER "u\n", O2S(valuePtr),
+			(size_t)(pc + jmpOffset[0] - codePtr->codeStart)));
 	    }
 	}
 #endif
@@ -4392,8 +4392,8 @@ TEBCresume(
 	if (hPtr != NULL) {
 	    int jumpOffset = PTR2INT(Tcl_GetHashValue(hPtr));
 
-	    TRACE_APPEND(("found in table, new pc %u\n",
-		    (unsigned)(pc - codePtr->codeStart + jumpOffset)));
+	    TRACE_APPEND(("found in table, new pc %" TCL_Z_MODIFIER "u\n",
+		    (size_t)(pc - codePtr->codeStart + jumpOffset)));
 	    NEXT_INST_F(jumpOffset, 1, 0);
 	} else {
 	    TRACE_APPEND(("not found in table\n"));
@@ -4638,9 +4638,9 @@ TEBCresume(
 			if (traceInstructions) {
 			    strncpy(cmdNameBuf, TclGetString(objv[0]), 20);
 			} else {
-			    fprintf(stdout, "%d: (%u) invoking ",
+			    fprintf(stdout, "%d: (%" TCL_Z_MODIFIER "u) invoking ",
 				    iPtr->numLevels,
-				    (unsigned)(pc - codePtr->codeStart));
+				    (size_t)(pc - codePtr->codeStart));
 			}
 			for (i = 0;  i < opnd;  i++) {
 			    TclPrintObject(stdout, objv[i], 15);
@@ -4664,7 +4664,7 @@ TEBCresume(
 
 	    TRACE_APPEND(("ERROR: \"%.30s\" not on reachable chain\n",
 		    O2S(valuePtr)));
-	    for (i = contextPtr->index ; i >= 0 ; i--) {
+	    for (i = contextPtr->index ; i != TCL_INDEX_NONE ; i--) {
 		miPtr = contextPtr->callPtr->chain + i;
 		if (miPtr->isFilter
 			|| miPtr->mPtr->declaringClassPtr != classPtr) {
@@ -4740,8 +4740,8 @@ TEBCresume(
 	    if (traceInstructions) {
 		strncpy(cmdNameBuf, TclGetString(objv[0]), 20);
 	    } else {
-		fprintf(stdout, "%d: (%u) invoking ",
-			iPtr->numLevels, (unsigned)(pc - codePtr->codeStart));
+		fprintf(stdout, "%d: (%" TCL_Z_MODIFIER "u) invoking ",
+			iPtr->numLevels, (size_t)(pc - codePtr->codeStart));
 	    }
 	    for (i = 0;  i < opnd;  i++) {
 		TclPrintObject(stdout, objv[i], 15);
@@ -7585,7 +7585,7 @@ TEBCresume(
 	{			/* Read the wall clock */
 	    Tcl_WideInt wval;
 	    Tcl_Time now;
-	    switch(TclGetUInt1AtPtr(pc+1)) {
+	    switch (TclGetUInt1AtPtr(pc+1)) {
 	    case 0:		/* clicks */
 #ifdef TCL_WIDE_CLICKS
 		wval = TclpGetWideClicks();
@@ -7682,7 +7682,7 @@ TEBCresume(
 			rangePtr->codeOffset, rangePtr->breakOffset));
 		NEXT_INST_F(0, 0, 0);
 	    }
-	    if (rangePtr->continueOffset == -1) {
+	    if (rangePtr->continueOffset == TCL_INDEX_NONE) {
 		TRACE_APPEND(("%s, loop w/o continue, checking for catch\n",
 			StringForResultCode(result)));
 		goto checkForCatch;
@@ -9124,7 +9124,6 @@ PrintByteCodeInfo(
     fprintf(stdout, "\nExecuting ByteCode 0x%p, refCt %" TCL_Z_MODIFIER "u, epoch %u, interp 0x%p (epoch %u)\n",
 	    codePtr, (size_t)codePtr->refCount, codePtr->compileEpoch, iPtr,
 	    iPtr->compileEpoch);
-
     fprintf(stdout, "  Source: ");
     TclPrintSource(stdout, codePtr->source, 60);
 
@@ -9139,13 +9138,13 @@ PrintByteCodeInfo(
 	    0.0);
 
 #ifdef TCL_COMPILE_STATS
-    fprintf(stdout, "  Code %lu = header %lu+inst %d+litObj %lu+exc %lu+aux %lu+cmdMap %d\n",
+    fprintf(stdout, "  Code %lu = header %" TCL_Z_MODIFIER "u+inst %d+litObj %" TCL_Z_MODIFIER "u+exc %" TCL_Z_MODIFIER "u+aux %" TCL_Z_MODIFIER "u+cmdMap %d\n",
 	    (unsigned long) codePtr->structureSize,
-	    (unsigned long) offsetof(ByteCode, localCachePtr),
+	    offsetof(ByteCode, localCachePtr),
 	    codePtr->numCodeBytes,
-	    (unsigned long) (codePtr->numLitObjects * sizeof(Tcl_Obj *)),
-	    (unsigned long) (codePtr->numExceptRanges*sizeof(ExceptionRange)),
-	    (unsigned long) (codePtr->numAuxDataItems * sizeof(AuxData)),
+	    codePtr->numLitObjects * sizeof(Tcl_Obj *),
+	    codePtr->numExceptRanges*sizeof(ExceptionRange),
+	    codePtr->numAuxDataItems * sizeof(AuxData),
 	    codePtr->numCmdLocBytes);
 #endif /* TCL_COMPILE_STATS */
     if (procPtr != NULL) {
@@ -9289,7 +9288,8 @@ IllegalExprOperandType(
     }
 
     Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-	    "can't use %s as operand of \"%s\"", description, op));
+	    "can't use %s \"%s\" as operand of \"%s\"", description,
+	    TclGetString(opndPtr), op));
     Tcl_SetErrorCode(interp, "ARITH", "DOMAIN", description, NULL);
 }
 
@@ -9366,7 +9366,8 @@ TclGetSrcInfoForPc(
 
 	ExtCmdLoc *eclPtr;
 	ECL *locPtr = NULL;
-	int srcOffset, i;
+	int srcOffset;
+	int i;
 	Interp *iPtr = (Interp *) *codePtr->interpHandle;
 	Tcl_HashEntry *hePtr =
 		Tcl_FindHashEntry(iPtr->lineBCPtr, codePtr);
@@ -9601,7 +9602,7 @@ GetExceptRangeForPc(
 	    if (searchMode == TCL_BREAK) {
 		return rangePtr;
 	    }
-	    if (searchMode == TCL_CONTINUE && rangePtr->continueOffset != -1){
+	    if (searchMode == TCL_CONTINUE && rangePtr->continueOffset != TCL_INDEX_NONE){
 		return rangePtr;
 	    }
 	}
@@ -9799,8 +9800,8 @@ EvalStatsCmd(
 
     Tcl_AppendPrintfToObj(objPtr, "\n----------------------------------------------------------------\n");
     Tcl_AppendPrintfToObj(objPtr,
-	    "Compilation and execution statistics for interpreter %#" TCL_Z_MODIFIER "x\n",
-	    (size_t)iPtr);
+	    "Compilation and execution statistics for interpreter %p\n",
+	    iPtr);
 
     Tcl_AppendPrintfToObj(objPtr, "\nNumber ByteCodes executed\t%" TCL_Z_MODIFIER "u\n",
 	    statsPtr->numExecutions);
@@ -9847,11 +9848,11 @@ EvalStatsCmd(
 	    statsPtr->currentByteCodeBytes);
     Tcl_AppendPrintfToObj(objPtr, "    Literal bytes\t\t%.6g\n",
 	    currentLiteralBytes);
-    Tcl_AppendPrintfToObj(objPtr, "      table %lu + bkts %lu + entries %lu + objects %lu + strings %.6g\n",
-	    (unsigned long) sizeof(LiteralTable),
-	    (unsigned long) (iPtr->literalTable.numBuckets * sizeof(LiteralEntry *)),
-	    (unsigned long) (iPtr->literalTable.numEntries * sizeof(LiteralEntry)),
-	    (unsigned long) (iPtr->literalTable.numEntries * sizeof(Tcl_Obj)),
+    Tcl_AppendPrintfToObj(objPtr, "      table %" TCL_Z_MODIFIER "u + bkts %" TCL_Z_MODIFIER "u + entries %" TCL_Z_MODIFIER "u + objects %" TCL_Z_MODIFIER "u + strings %.6g\n",
+	    sizeof(LiteralTable),
+	    iPtr->literalTable.numBuckets * sizeof(LiteralEntry *),
+	    iPtr->literalTable.numEntries * sizeof(LiteralEntry),
+	    iPtr->literalTable.numEntries * sizeof(Tcl_Obj),
 	    statsPtr->currentLitStringBytes);
     Tcl_AppendPrintfToObj(objPtr, "  Mean code/source\t\t%.1f\n",
 	    currentCodeBytes / statsPtr->currentSrcBytes);
diff --git a/tests/assemble.test b/tests/assemble.test
index 55124d0..b656894 100644
--- a/tests/assemble.test
+++ b/tests/assemble.test
@@ -781,7 +781,7 @@ test assemble-7.43 {uplus} {
 	}
     }
     -returnCodes error
-    -result {can't use non-numeric floating-point value as operand of "+"}
+    -result {can't use non-numeric floating-point value "NaN" as operand of "+"}
 }
 test assemble-7.43.1 {tryCvtToNumeric} {
     -body {
diff --git a/tests/compExpr-old.test b/tests/compExpr-old.test
index b70e65c..40dea76 100644
--- a/tests/compExpr-old.test
+++ b/tests/compExpr-old.test
@@ -280,10 +280,10 @@ test compExpr-old-6.8 {CompileBitXorExpr: error compiling bitxor arm} -body {
 } -returnCodes error -match glob -result *
 test compExpr-old-6.9 {CompileBitXorExpr: runtime error in bitxor arm} {
     list [catch {expr {24.0^3}} msg] $msg
-} {1 {can't use floating-point value as operand of "^"}}
+} {1 {can't use floating-point value "24.0" as operand of "^"}}
 test compExpr-old-6.10 {CompileBitXorExpr: runtime error in bitxor arm} {
     list [catch {expr {"a"^"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "^"}}
+} {1 {can't use non-numeric string "a" as operand of "^"}}
 
 test compExpr-old-7.1 {CompileBitAndExpr: just equality expr} {expr 3==2} 0
 test compExpr-old-7.2 {CompileBitAndExpr: just equality expr} {expr 2.0==2} 1
@@ -304,10 +304,10 @@ test compExpr-old-7.11 {CompileBitAndExpr: error compiling bitand arm} -body {
 } -returnCodes error -match glob -result *
 test compExpr-old-7.12 {CompileBitAndExpr: runtime error in bitand arm} {
     list [catch {expr {24.0&3}} msg] $msg
-} {1 {can't use floating-point value as operand of "&"}}
+} {1 {can't use floating-point value "24.0" as operand of "&"}}
 test compExpr-old-7.13 {CompileBitAndExpr: runtime error in bitand arm} {
     list [catch {expr {"a"&"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "&"}}
+} {1 {can't use non-numeric string "a" as operand of "&"}}
 
 test compExpr-old-8.1 {CompileEqualityExpr: just relational expr} {expr 3>=2} 1
 test compExpr-old-8.2 {CompileEqualityExpr: just relational expr} {expr 2<=2.1} 1
@@ -365,10 +365,10 @@ test compExpr-old-10.9 {CompileShiftExpr: error compiling shift arm} -body {
 } -returnCodes error -match glob -result *
 test compExpr-old-10.10 {CompileShiftExpr: runtime error} {
     list [catch {expr {24.0>>43}} msg] $msg
-} {1 {can't use floating-point value as operand of ">>"}}
+} {1 {can't use floating-point value "24.0" as operand of ">>"}}
 test compExpr-old-10.11 {CompileShiftExpr: runtime error} {
     list [catch {expr {"a"<<"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "<<"}}
+} {1 {can't use non-numeric string "a" as operand of "<<"}}
 
 test compExpr-old-11.1 {CompileAddExpr: just multiply expr} {expr 4*-2} -8
 test compExpr-old-11.2 {CompileAddExpr: just multiply expr} {expr 0xff%2} 1
@@ -387,10 +387,10 @@ test compExpr-old-11.9 {CompileAddExpr: error compiling add arm} -body {
 } -returnCodes error -match glob -result *
 test compExpr-old-11.10 {CompileAddExpr: runtime error} {
     list [catch {expr {24.0+"xx"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string "xx" as operand of "+"}}
 test compExpr-old-11.11 {CompileAddExpr: runtime error} {
     list [catch {expr {"a"-"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "-"}}
+} {1 {can't use non-numeric string "a" as operand of "-"}}
 test compExpr-old-11.12 {CompileAddExpr: runtime error} {
     list [catch {expr {3/0}} msg] $msg
 } {1 {divide by zero}}
@@ -418,10 +418,10 @@ test compExpr-old-12.9 {CompileMultiplyExpr: error compiling multiply arm} -body
 } -returnCodes error -match glob -result *
 test compExpr-old-12.10 {CompileMultiplyExpr: runtime error} {
     list [catch {expr {24.0*"xx"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "*"}}
+} {1 {can't use non-numeric string "xx" as operand of "*"}}
 test compExpr-old-12.11 {CompileMultiplyExpr: runtime error} {
     list [catch {expr {"a"/"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "/"}}
+} {1 {can't use non-numeric string "a" as operand of "/"}}
 
 test compExpr-old-13.1 {CompileUnaryExpr: unary exprs} {expr -0xff} -255
 test compExpr-old-13.2 {CompileUnaryExpr: unary exprs} {expr +0o00123} 83
@@ -439,10 +439,10 @@ test compExpr-old-13.9 {CompileUnaryExpr: error compiling unary expr} -body {
 } -returnCodes error -match glob -result *
 test compExpr-old-13.10 {CompileUnaryExpr: runtime error} {
     list [catch {expr {~"xx"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "~"}}
+} {1 {can't use non-numeric string "xx" as operand of "~"}}
 test compExpr-old-13.11 {CompileUnaryExpr: runtime error} {
     list [catch {expr ~4.0} msg] $msg
-} {1 {can't use floating-point value as operand of "~"}}
+} {1 {can't use floating-point value "4.0" as operand of "~"}}
 test compExpr-old-13.12 {CompileUnaryExpr: just primary expr} {expr 0x123} 291
 test compExpr-old-13.13 {CompileUnaryExpr: just primary expr} {
     set a 27
@@ -590,6 +590,7 @@ test compExpr-old-15.5 {CompileMathFuncCall: not enough arguments} -body {
 test compExpr-old-15.6 {CompileMathFuncCall: missing ')'} -body {
     expr sin(1
 } -returnCodes error -match glob -result *
+
 test compExpr-old-16.1 {GetToken: checks whether integer token starting with "0x" (e.g., "0x$") is invalid} {
     catch {unset a}
     set a(VALUE) ff15
diff --git a/tests/execute.test b/tests/execute.test
index d86ad0e..8702de6 100644
--- a/tests/execute.test
+++ b/tests/execute.test
@@ -179,7 +179,7 @@ test execute-3.5 {TclExecuteByteCode, INST_ADD, op1 is string double} {testobj}
 test execute-3.6 {TclExecuteByteCode, INST_ADD, op1 is non-numeric} {testobj} {
     set x [teststringobj set 0 foo]
     list [catch {expr {$x + 1}} msg] $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string "foo" as operand of "+"}}
 test execute-3.7 {TclExecuteByteCode, INST_ADD, op2 is int} {testobj} {
     set x [testintobj set 0 1]
     expr {1 + $x}
@@ -204,7 +204,7 @@ test execute-3.11 {TclExecuteByteCode, INST_ADD, op2 is string double} {testobj}
 test execute-3.12 {TclExecuteByteCode, INST_ADD, op2 is non-numeric} {testobj} {
     set x [teststringobj set 0 foo]
     list [catch {expr {1 + $x}} msg] $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string "foo" as operand of "+"}}
 
 # INST_SUB is partially tested:
 test execute-3.13 {TclExecuteByteCode, INST_SUB, op1 is int} {testobj} {
@@ -231,7 +231,7 @@ test execute-3.17 {TclExecuteByteCode, INST_SUB, op1 is string double} {testobj}
 test execute-3.18 {TclExecuteByteCode, INST_SUB, op1 is non-numeric} {testobj} {
     set x [teststringobj set 0 foo]
     list [catch {expr {$x - 1}} msg] $msg
-} {1 {can't use non-numeric string as operand of "-"}}
+} {1 {can't use non-numeric string "foo" as operand of "-"}}
 test execute-3.19 {TclExecuteByteCode, INST_SUB, op2 is int} {testobj} {
     set x [testintobj set 0 1]
     expr {1 - $x}
@@ -256,7 +256,7 @@ test execute-3.23 {TclExecuteByteCode, INST_SUB, op2 is string double} {testobj}
 test execute-3.24 {TclExecuteByteCode, INST_SUB, op2 is non-numeric} {testobj} {
     set x [teststringobj set 0 foo]
     list [catch {expr {1 - $x}} msg] $msg
-} {1 {can't use non-numeric string as operand of "-"}}
+} {1 {can't use non-numeric string "foo" as operand of "-"}}
 
 # INST_MULT is partially tested:
 test execute-3.25 {TclExecuteByteCode, INST_MULT, op1 is int} {testobj} {
@@ -283,7 +283,7 @@ test execute-3.29 {TclExecuteByteCode, INST_MULT, op1 is string double} {testobj
 test execute-3.30 {TclExecuteByteCode, INST_MULT, op1 is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {$x * 1}} msg] $msg
-} {1 {can't use non-numeric string as operand of "*"}}
+} {1 {can't use non-numeric string "foo" as operand of "*"}}
 test execute-3.31 {TclExecuteByteCode, INST_MULT, op2 is int} {testobj} {
     set x [testintobj set 1 1]
     expr {1 * $x}
@@ -308,7 +308,7 @@ test execute-3.35 {TclExecuteByteCode, INST_MULT, op2 is string double} {testobj
 test execute-3.36 {TclExecuteByteCode, INST_MULT, op2 is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {1 * $x}} msg] $msg
-} {1 {can't use non-numeric string as operand of "*"}}
+} {1 {can't use non-numeric string "foo" as operand of "*"}}
 
 # INST_DIV is partially tested:
 test execute-3.37 {TclExecuteByteCode, INST_DIV, op1 is int} {testobj} {
@@ -335,7 +335,7 @@ test execute-3.41 {TclExecuteByteCode, INST_DIV, op1 is string double} {testobj}
 test execute-3.42 {TclExecuteByteCode, INST_DIV, op1 is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {$x / 1}} msg] $msg
-} {1 {can't use non-numeric string as operand of "/"}}
+} {1 {can't use non-numeric string "foo" as operand of "/"}}
 test execute-3.43 {TclExecuteByteCode, INST_DIV, op2 is int} {testobj} {
     set x [testintobj set 1 1]
     expr {2 / $x}
@@ -360,7 +360,7 @@ test execute-3.47 {TclExecuteByteCode, INST_DIV, op2 is string double} {testobj}
 test execute-3.48 {TclExecuteByteCode, INST_DIV, op2 is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {1 / $x}} msg] $msg
-} {1 {can't use non-numeric string as operand of "/"}}
+} {1 {can't use non-numeric string "foo" as operand of "/"}}
 
 # INST_UPLUS is partially tested:
 test execute-3.49 {TclExecuteByteCode, INST_UPLUS, op is int} {testobj} {
@@ -387,7 +387,7 @@ test execute-3.53 {TclExecuteByteCode, INST_UPLUS, op is string double} {testobj
 test execute-3.54 {TclExecuteByteCode, INST_UPLUS, op is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {+ $x}} msg] $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string "foo" as operand of "+"}}
 
 # INST_UMINUS is partially tested:
 test execute-3.55 {TclExecuteByteCode, INST_UMINUS, op is int} {testobj} {
@@ -414,7 +414,7 @@ test execute-3.59 {TclExecuteByteCode, INST_UMINUS, op is string double} {testob
 test execute-3.60 {TclExecuteByteCode, INST_UMINUS, op is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {- $x}} msg] $msg
-} {1 {can't use non-numeric string as operand of "-"}}
+} {1 {can't use non-numeric string "foo" as operand of "-"}}
 
 # INST_LNOT is partially tested:
 test execute-3.61 {TclExecuteByteCode, INST_LNOT, op is int} {testobj} {
@@ -462,7 +462,7 @@ test execute-3.70 {TclExecuteByteCode, INST_LNOT, op is string double} {testobj}
 test execute-3.71 {TclExecuteByteCode, INST_LNOT, op is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {! $x}} msg] $msg
-} {1 {can't use non-numeric string as operand of "!"}}
+} {1 {can't use non-numeric string "foo" as operand of "!"}}
 
 # INST_BITNOT not tested
 # INST_CALL_BUILTIN_FUNC1 not tested
diff --git a/tests/expr-old.test b/tests/expr-old.test
index 676443a..2401bd4 100644
--- a/tests/expr-old.test
+++ b/tests/expr-old.test
@@ -194,34 +194,34 @@ test expr-old-2.38 {floating-point operators} {
 
 test expr-old-3.1 {illegal floating-point operations} {
     list [catch {expr ~4.0} msg] $msg
-} {1 {can't use floating-point value as operand of "~"}}
+} {1 {can't use floating-point value "4.0" as operand of "~"}}
 test expr-old-3.2 {illegal floating-point operations} {
     list [catch {expr 27%4.0} msg] $msg
-} {1 {can't use floating-point value as operand of "%"}}
+} {1 {can't use floating-point value "4.0" as operand of "%"}}
 test expr-old-3.3 {illegal floating-point operations} {
     list [catch {expr 27.0%4} msg] $msg
-} {1 {can't use floating-point value as operand of "%"}}
+} {1 {can't use floating-point value "27.0" as operand of "%"}}
 test expr-old-3.4 {illegal floating-point operations} {
     list [catch {expr 1.0<<3} msg] $msg
-} {1 {can't use floating-point value as operand of "<<"}}
+} {1 {can't use floating-point value "1.0" as operand of "<<"}}
 test expr-old-3.5 {illegal floating-point operations} {
     list [catch {expr 3<<1.0} msg] $msg
-} {1 {can't use floating-point value as operand of "<<"}}
+} {1 {can't use floating-point value "1.0" as operand of "<<"}}
 test expr-old-3.6 {illegal floating-point operations} {
     list [catch {expr 24.0>>3} msg] $msg
-} {1 {can't use floating-point value as operand of ">>"}}
+} {1 {can't use floating-point value "24.0" as operand of ">>"}}
 test expr-old-3.7 {illegal floating-point operations} {
     list [catch {expr 24>>3.0} msg] $msg
-} {1 {can't use floating-point value as operand of ">>"}}
+} {1 {can't use floating-point value "3.0" as operand of ">>"}}
 test expr-old-3.8 {illegal floating-point operations} {
     list [catch {expr 24&3.0} msg] $msg
-} {1 {can't use floating-point value as operand of "&"}}
+} {1 {can't use floating-point value "3.0" as operand of "&"}}
 test expr-old-3.9 {illegal floating-point operations} {
     list [catch {expr 24.0|3} msg] $msg
-} {1 {can't use floating-point value as operand of "|"}}
+} {1 {can't use floating-point value "24.0" as operand of "|"}}
 test expr-old-3.10 {illegal floating-point operations} {
     list [catch {expr 24.0^3} msg] $msg
-} {1 {can't use floating-point value as operand of "^"}}
+} {1 {can't use floating-point value "24.0" as operand of "^"}}
 
 # Check the string operators individually.
 
@@ -262,46 +262,46 @@ test expr-old-4.32 {string operators} {expr {0?"foo":"bar"}} bar
 
 test expr-old-5.1 {illegal string operations} {
     list [catch {expr {-"a"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "-"}}
+} {1 {can't use non-numeric string "a" as operand of "-"}}
 test expr-old-5.2 {illegal string operations} {
     list [catch {expr {+"a"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string "a" as operand of "+"}}
 test expr-old-5.3 {illegal string operations} {
     list [catch {expr {~"a"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "~"}}
+} {1 {can't use non-numeric string "a" as operand of "~"}}
 test expr-old-5.4 {illegal string operations} {
     list [catch {expr {!"a"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "!"}}
+} {1 {can't use non-numeric string "a" as operand of "!"}}
 test expr-old-5.5 {illegal string operations} {
     list [catch {expr {"a"*"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "*"}}
+} {1 {can't use non-numeric string "a" as operand of "*"}}
 test expr-old-5.6 {illegal string operations} {
     list [catch {expr {"a"/"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "/"}}
+} {1 {can't use non-numeric string "a" as operand of "/"}}
 test expr-old-5.7 {illegal string operations} {
     list [catch {expr {"a"%"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "%"}}
+} {1 {can't use non-numeric string "a" as operand of "%"}}
 test expr-old-5.8 {illegal string operations} {
     list [catch {expr {"a"+"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string "a" as operand of "+"}}
 test expr-old-5.9 {illegal string operations} {
     list [catch {expr {"a"-"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "-"}}
+} {1 {can't use non-numeric string "a" as operand of "-"}}
 test expr-old-5.10 {illegal string operations} {
     list [catch {expr {"a"<<"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "<<"}}
+} {1 {can't use non-numeric string "a" as operand of "<<"}}
 test expr-old-5.11 {illegal string operations} {
     list [catch {expr {"a">>"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of ">>"}}
+} {1 {can't use non-numeric string "a" as operand of ">>"}}
 test expr-old-5.12 {illegal string operations} {
     list [catch {expr {"a"&"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "&"}}
+} {1 {can't use non-numeric string "a" as operand of "&"}}
 test expr-old-5.13 {illegal string operations} {
     list [catch {expr {"a"^"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "^"}}
+} {1 {can't use non-numeric string "a" as operand of "^"}}
 test expr-old-5.14 {illegal string operations} {
     list [catch {expr {"a"|"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "|"}}
+} {1 {can't use non-numeric string "a" as operand of "|"}}
 test expr-old-5.15 {illegal string operations} {
     list [catch {expr {"a"&&"b"}} msg] $msg
 } {1 {expected boolean value but got "a"}}
@@ -490,7 +490,7 @@ test expr-old-25.20 {type conversions} {expr 10.0} 10.0
 
 test expr-old-26.1 {error conditions} {
     list [catch {expr 2+"a"} msg] $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string "a" as operand of "+"}}
 test expr-old-26.2 {error conditions} -body {
     expr 2+4*
 } -returnCodes error -match glob -result *
@@ -504,10 +504,10 @@ test expr-old-26.4 {error conditions} {
 set a xx
 test expr-old-26.5 {error conditions} {
     list [catch {expr {2+$a}} msg] $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string "xx" as operand of "+"}}
 test expr-old-26.6 {error conditions} {
     list [catch {expr {2+[set a]}} msg] $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string "xx" as operand of "+"}}
 test expr-old-26.7 {error conditions} -body {
     expr {2+(4}
 } -returnCodes error -match glob -result *
@@ -531,7 +531,7 @@ test expr-old-26.12 {error conditions} -body {
 } -returnCodes error -match glob -result *
 test expr-old-26.13 {error conditions} {
     list [catch {expr {"a"/"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "/"}}
+} {1 {can't use non-numeric string "a" as operand of "/"}}
 test expr-old-26.14 {error conditions} -body {
     expr 2:3
 } -returnCodes error -match glob -result *
@@ -943,13 +943,14 @@ test expr-old-34.15 {errors in math functions} {
 test expr-old-34.16 {errors in math functions} {
     expr round(-1.0e30)
 } -1000000000000000019884624838656
+
 test expr-old-36.1 {ExprLooksLikeInt procedure} -body {
     expr 0o289
 } -returnCodes error -match glob -result {*invalid octal number*}
 test expr-old-36.2 {ExprLooksLikeInt procedure} {
     set x 0o289
     list [catch {expr {$x+1}} msg] $msg
-} {1 {can't use invalid octal number as operand of "+"}}
+} {1 {can't use invalid octal number "0o289" as operand of "+"}}
 test expr-old-36.3 {ExprLooksLikeInt procedure} {
     list [catch {expr 0289.1} msg] $msg
 } {0 289.1}
@@ -989,11 +990,11 @@ test expr-old-36.11 {ExprLooksLikeInt procedure} {
 test expr-old-36.12 {ExprLooksLikeInt procedure} {
     set x "10;"
     list [catch {expr {$x+1}} msg] $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string "10;" as operand of "+"}}
 test expr-old-36.13 {ExprLooksLikeInt procedure} {
     set x " +"
     list [catch {expr {$x+1}} msg] $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string " +" as operand of "+"}}
 test expr-old-36.14 {ExprLooksLikeInt procedure} {
     set x "123456789012345678901234567890 "
     expr {$x+1}
@@ -1001,7 +1002,7 @@ test expr-old-36.14 {ExprLooksLikeInt procedure} {
 test expr-old-36.15 {ExprLooksLikeInt procedure} {
     set x "0o99 "
     list [catch {expr {$x+1}} msg] $msg
-} {1 {can't use invalid octal number as operand of "+"}}
+} {1 {can't use invalid octal number "0o99 " as operand of "+"}}
 test expr-old-36.16 {ExprLooksLikeInt procedure} {
     set x " 0xffffffffffffffffffffffffffffffffffffff  "
     expr {$x+1}
diff --git a/tests/expr.test b/tests/expr.test
index 32706d9..25a02e3 100644
--- a/tests/expr.test
+++ b/tests/expr.test
@@ -138,9 +138,9 @@ proc do_twelve_days {} {
 
 catch {unset a b i x}
 
-test expr-1.1 {TclCompileExprCmd: no expression} {
-    list [catch {expr  } msg] $msg
-} {1 {wrong # args: should be "expr arg ?arg ...?"}}
+test expr-1.1 {TclCompileExprCmd: no expression} -body {
+    expr
+} -returnCodes error -result {wrong # args: should be "expr arg ?arg ...?"}
 test expr-1.2 {TclCompileExprCmd: one expression word} {
     expr -25
 } -25
@@ -187,12 +187,12 @@ test expr-1.13 {TclCompileExprCmd: second level of substitutions in expr not in
 } foo
 test expr-1.14 {TclCompileExprCmd: second level of substitutions in expr with comparison as top-level operator} {
     set a xxx
-    set x 2;  set b {$x};  set a [expr $b == 2]
+    set x 2;  set b {$x};  set a [expr $b==2]
     set a
 } 1
 test expr-1.15 {TclCompileExprCmd: second level of substitutions in expr with comparison as top-level operator} {
     set a xxx
-    set x 2;  set b {$x};  set a [expr $b eq 2]
+    set x 2;  set b {$x};  set a [expr "$b eq 2"]
     set a
 } 1
 
@@ -252,7 +252,7 @@ test expr-4.9 {CompileLorExpr: long lor arm} {
 } 1
 test expr-4.10 {CompileLorExpr: error compiling ! operand} {
     list [catch {expr {!"a"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "!"}}
+} {1 {can't use non-numeric string "a" as operand of "!"}}
 test expr-4.11 {CompileLorExpr: error compiling land arms} {
     list [catch {expr {"a"||0}} msg] $msg
 } {1 {expected boolean value but got "a"}}
@@ -299,10 +299,10 @@ test expr-6.8 {CompileBitXorExpr: error compiling bitxor arm} -body {
 } -returnCodes error -match glob -result *
 test expr-6.9 {CompileBitXorExpr: runtime error in bitxor arm} {
     list [catch {expr {24.0^3}} msg] $msg
-} {1 {can't use floating-point value as operand of "^"}}
+} {1 {can't use floating-point value "24.0" as operand of "^"}}
 test expr-6.10 {CompileBitXorExpr: runtime error in bitxor arm} {
     list [catch {expr {"a"^"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "^"}}
+} {1 {can't use non-numeric string "a" as operand of "^"}}
 
 test expr-7.1 {CompileBitAndExpr: just equality expr} {expr 3==2} 0
 test expr-7.2 {CompileBitAndExpr: just equality expr} {expr 2.0==2} 1
@@ -323,10 +323,10 @@ test expr-7.11 {CompileBitAndExpr: error compiling bitand arm} -body {
 } -returnCodes error -match glob -result *
 test expr-7.12 {CompileBitAndExpr: runtime error in bitand arm} {
     list [catch {expr {24.0&3}} msg] $msg
-} {1 {can't use floating-point value as operand of "&"}}
+} {1 {can't use floating-point value "24.0" as operand of "&"}}
 test expr-7.13 {CompileBitAndExpr: runtime error in bitand arm} {
     list [catch {expr {"a"&"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "&"}}
+} {1 {can't use non-numeric string "a" as operand of "&"}}
 test expr-7.14 {CompileBitAndExpr: equality expr} {expr 3eq2} 0
 test expr-7.18 {CompileBitAndExpr: equality expr} {expr {"abc" eq "abd"}} 0
 test expr-7.20 {CompileBitAndExpr: error in equality expr} -body {
@@ -468,10 +468,10 @@ test expr-10.9 {CompileShiftExpr: error compiling shift arm} -body {
 } -returnCodes error -match glob -result *
 test expr-10.10 {CompileShiftExpr: runtime error} {
     list [catch {expr {24.0>>43}} msg] $msg
-} {1 {can't use floating-point value as operand of ">>"}}
+} {1 {can't use floating-point value "24.0" as operand of ">>"}}
 test expr-10.11 {CompileShiftExpr: runtime error} {
     list [catch {expr {"a"<<"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "<<"}}
+} {1 {can't use non-numeric string "a" as operand of "<<"}}
 
 test expr-11.1 {CompileAddExpr: just multiply expr} {expr 4*-2} -8
 test expr-11.2 {CompileAddExpr: just multiply expr} {expr 0xff%2} 1
@@ -490,10 +490,10 @@ test expr-11.9 {CompileAddExpr: error compiling add arm} -body {
 } -returnCodes error -match glob -result *
 test expr-11.10 {CompileAddExpr: runtime error} {
     list [catch {expr {24.0+"xx"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string "xx" as operand of "+"}}
 test expr-11.11 {CompileAddExpr: runtime error} {
     list [catch {expr {"a"-"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "-"}}
+} {1 {can't use non-numeric string "a" as operand of "-"}}
 test expr-11.12 {CompileAddExpr: runtime error} {
     list [catch {expr {3/0}} msg] $msg
 } {1 {divide by zero}}
@@ -521,10 +521,10 @@ test expr-12.9 {CompileMultiplyExpr: error compiling multiply arm} -body {
 } -returnCodes error -match glob -result *
 test expr-12.10 {CompileMultiplyExpr: runtime error} {
     list [catch {expr {24.0*"xx"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "*"}}
+} {1 {can't use non-numeric string "xx" as operand of "*"}}
 test expr-12.11 {CompileMultiplyExpr: runtime error} {
     list [catch {expr {"a"/"b"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "/"}}
+} {1 {can't use non-numeric string "a" as operand of "/"}}
 
 test expr-13.1 {CompileUnaryExpr: unary exprs} {expr -0xff} -255
 test expr-13.2 {CompileUnaryExpr: unary exprs} {expr +0o00123} 83
@@ -541,10 +541,10 @@ test expr-13.9 {CompileUnaryExpr: error compiling unary expr} -body {
 } -returnCodes error -match glob -result *
 test expr-13.10 {CompileUnaryExpr: runtime error} {
     list [catch {expr {~"xx"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "~"}}
+} {1 {can't use non-numeric string "xx" as operand of "~"}}
 test expr-13.11 {CompileUnaryExpr: runtime error} {
     list [catch {expr ~4.0} msg] $msg
-} {1 {can't use floating-point value as operand of "~"}}
+} {1 {can't use floating-point value "4.0" as operand of "~"}}
 test expr-13.12 {CompileUnaryExpr: just primary expr} {expr 0x123} 291
 test expr-13.13 {CompileUnaryExpr: just primary expr} {
     set a 27
@@ -821,15 +821,15 @@ test expr-21.13 {non-numeric boolean literals} -body {
 } -returnCodes error -match glob -result *
 test expr-21.14 {non-numeric boolean literals} {
     list [catch {expr !"truef"} err] $err
-} {1 {can't use non-numeric string as operand of "!"}}
+} {1 {can't use non-numeric string "truef" as operand of "!"}}
 test expr-21.15 {non-numeric boolean variables} {
     set v truef
     list [catch {expr {!$v}} err] $err
-} {1 {can't use non-numeric string as operand of "!"}}
+} {1 {can't use non-numeric string "truef" as operand of "!"}}
 test expr-21.16 {non-numeric boolean variables} {
     set v "true "
     list [catch {expr {!$v}} err] $err
-} {1 {can't use non-numeric string as operand of "!"}}
+} {1 {can't use non-numeric string "true " as operand of "!"}}
 test expr-21.17 {non-numeric boolean variables} {
     set v "tru"
     list [catch {expr {!$v}} err] $err
@@ -849,23 +849,23 @@ test expr-21.20 {non-numeric boolean variables} {
 test expr-21.21 {non-numeric boolean variables} {
     set v "o"
     list [catch {expr {!$v}} err] $err
-} {1 {can't use non-numeric string as operand of "!"}}
+} {1 {can't use non-numeric string "o" as operand of "!"}}
 test expr-21.22 {non-numeric boolean variables} {
     set v ""
     list [catch {expr {!$v}} err] $err
-} {1 {can't use empty string as operand of "!"}}
+} {1 {can't use empty string "" as operand of "!"}}
 
 # Test for non-numeric float handling.
 test expr-22.1 {non-numeric floats} {
     list [catch {expr {NaN + 1}} msg] $msg
-} {1 {can't use non-numeric floating-point value as operand of "+"}}
+} {1 {can't use non-numeric floating-point value "NaN" as operand of "+"}}
 test expr-22.2 {non-numeric floats} !ieeeFloatingPoint {
     list [catch {expr {Inf + 1}} msg] $msg
 } {1 {can't use infinite floating-point value as operand of "+"}}
 test expr-22.3 {non-numeric floats} {
     set nan NaN
     list [catch {expr {$nan + 1}} msg] $msg
-} {1 {can't use non-numeric floating-point value as operand of "+"}}
+} {1 {can't use non-numeric floating-point value "NaN" as operand of "+"}}
 test expr-22.4 {non-numeric floats} !ieeeFloatingPoint {
     set inf Inf
     list [catch {expr {$inf + 1}} msg] $msg
@@ -878,7 +878,7 @@ test expr-22.6 {non-numeric floats} !ieeeFloatingPoint {
 } {1 {floating-point value too large to represent}}
 test expr-22.7 {non-numeric floats} {
     list [catch {expr {1 / NaN}} msg] $msg
-} {1 {can't use non-numeric floating-point value as operand of "/"}}
+} {1 {can't use non-numeric floating-point value "NaN" as operand of "/"}}
 test expr-22.8 {non-numeric floats} !ieeeFloatingPoint {
     list [catch {expr {1 / Inf}} msg] $msg
 } {1 {can't use infinite floating-point value as operand of "/"}}
@@ -914,10 +914,10 @@ test expr-23.8 {CompileExponentialExpr: error compiling expo arm} -body {
 } -returnCodes error -match glob -result *
 test expr-23.9 {CompileExponentialExpr: runtime error} {
     list [catch {expr {24.0**"xx"}} msg] $msg
-} {1 {can't use non-numeric string as operand of "**"}}
+} {1 {can't use non-numeric string "xx" as operand of "**"}}
 test expr-23.10 {CompileExponentialExpr: runtime error} {
     list [catch {expr {"a"**2}} msg] $msg
-} {1 {can't use non-numeric string as operand of "**"}}
+} {1 {can't use non-numeric string "a" as operand of "**"}}
 test expr-23.11 {CompileExponentialExpr: runtime error} {
     list [catch {expr {0**-1}} msg] $msg
 } {1 {exponentiation of zero by negative power}}
diff --git a/tests/mathop.test b/tests/mathop.test
index e38001d..13a0543 100644
--- a/tests/mathop.test
+++ b/tests/mathop.test
@@ -114,22 +114,22 @@ namespace eval ::testmathop {
     test mathop-1.10 {compiled +} { + 1 2 3000000000000000000000 } 3000000000000000000003
     test mathop-1.11 {compiled +: errors} -returnCodes error -body {
 	+ x 0
-    } -result {can't use non-numeric string as operand of "+"}
+    } -result {can't use non-numeric string "x" as operand of "+"}
     test mathop-1.12 {compiled +: errors} -returnCodes error -body {
 	+ nan 0
-    } -result {can't use non-numeric floating-point value as operand of "+"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "+"}
     test mathop-1.13 {compiled +: errors} -returnCodes error -body {
 	+ 0 x
-    } -result {can't use non-numeric string as operand of "+"}
+    } -result {can't use non-numeric string "x" as operand of "+"}
     test mathop-1.14 {compiled +: errors} -returnCodes error -body {
 	+ 0 nan
-    } -result {can't use non-numeric floating-point value as operand of "+"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "+"}
     test mathop-1.15 {compiled +: errors} -returnCodes error -body {
 	+ 0o8 0
-    } -result {can't use invalid octal number as operand of "+"}
+    } -result {can't use invalid octal number "0o8" as operand of "+"}
     test mathop-1.16 {compiled +: errors} -returnCodes error -body {
 	+ 0 0o8
-    } -result {can't use invalid octal number as operand of "+"}
+    } -result {can't use invalid octal number "0o8" as operand of "+"}
     test mathop-1.17 {compiled +: errors} -returnCodes error -body {
 	+ 0 [error expectedError]
     } -result expectedError
@@ -152,22 +152,22 @@ namespace eval ::testmathop {
     test mathop-1.28 {interpreted +} { $op 1 2 3000000000000000000000 } 3000000000000000000003
     test mathop-1.29 {interpreted +: errors} -returnCodes error -body {
 	$op x 0
-    } -result {can't use non-numeric string as operand of "+"}
+    } -result {can't use non-numeric string "x" as operand of "+"}
     test mathop-1.30 {interpreted +: errors} -returnCodes error -body {
 	$op nan 0
-    } -result {can't use non-numeric floating-point value as operand of "+"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "+"}
     test mathop-1.31 {interpreted +: errors} -returnCodes error -body {
 	$op 0 x
-    } -result {can't use non-numeric string as operand of "+"}
+    } -result {can't use non-numeric string "x" as operand of "+"}
     test mathop-1.32 {interpreted +: errors} -returnCodes error -body {
 	$op 0 nan
-    } -result {can't use non-numeric floating-point value as operand of "+"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "+"}
     test mathop-1.33 {interpreted +: errors} -returnCodes error -body {
 	$op 0o8 0
-    } -result {can't use invalid octal number as operand of "+"}
+    } -result {can't use invalid octal number "0o8" as operand of "+"}
     test mathop-1.34 {interpreted +: errors} -returnCodes error -body {
 	$op 0 0o8
-    } -result {can't use invalid octal number as operand of "+"}
+    } -result {can't use invalid octal number "0o8" as operand of "+"}
     test mathop-1.35 {interpreted +: errors} -returnCodes error -body {
 	$op 0 [error expectedError]
     } -result expectedError
@@ -189,22 +189,22 @@ namespace eval ::testmathop {
     test mathop-2.10 {compiled *} { * 1 2 3000000000000000000000 } 6000000000000000000000
     test mathop-2.11 {compiled *: errors} -returnCodes error -body {
 	* x 0
-    } -result {can't use non-numeric string as operand of "*"}
+    } -result {can't use non-numeric string "x" as operand of "*"}
     test mathop-2.12 {compiled *: errors} -returnCodes error -body {
 	* nan 0
-    } -result {can't use non-numeric floating-point value as operand of "*"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "*"}
     test mathop-2.13 {compiled *: errors} -returnCodes error -body {
 	* 0 x
-    } -result {can't use non-numeric string as operand of "*"}
+    } -result {can't use non-numeric string "x" as operand of "*"}
     test mathop-2.14 {compiled *: errors} -returnCodes error -body {
 	* 0 nan
-    } -result {can't use non-numeric floating-point value as operand of "*"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "*"}
     test mathop-2.15 {compiled *: errors} -returnCodes error -body {
 	* 0o8 0
-    } -result {can't use invalid octal number as operand of "*"}
+    } -result {can't use invalid octal number "0o8" as operand of "*"}
     test mathop-2.16 {compiled *: errors} -returnCodes error -body {
 	* 0 0o8
-    } -result {can't use invalid octal number as operand of "*"}
+    } -result {can't use invalid octal number "0o8" as operand of "*"}
     test mathop-2.17 {compiled *: errors} -returnCodes error -body {
 	* 0 [error expectedError]
     } -result expectedError
@@ -227,22 +227,22 @@ namespace eval ::testmathop {
     test mathop-2.28 {interpreted *} { $op 1 2 3000000000000000000000 } 6000000000000000000000
     test mathop-2.29 {interpreted *: errors} -returnCodes error -body {
 	$op x 0
-    } -result {can't use non-numeric string as operand of "*"}
+    } -result {can't use non-numeric string "x" as operand of "*"}
     test mathop-2.30 {interpreted *: errors} -returnCodes error -body {
 	$op nan 0
-    } -result {can't use non-numeric floating-point value as operand of "*"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "*"}
     test mathop-2.31 {interpreted *: errors} -returnCodes error -body {
 	$op 0 x
-    } -result {can't use non-numeric string as operand of "*"}
+    } -result {can't use non-numeric string "x" as operand of "*"}
     test mathop-2.32 {interpreted *: errors} -returnCodes error -body {
 	$op 0 nan
-    } -result {can't use non-numeric floating-point value as operand of "*"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "*"}
     test mathop-2.33 {interpreted *: errors} -returnCodes error -body {
 	$op 0o8 0
-    } -result {can't use invalid octal number as operand of "*"}
+    } -result {can't use invalid octal number "0o8" as operand of "*"}
     test mathop-2.34 {interpreted *: errors} -returnCodes error -body {
 	$op 0 0o8
-    } -result {can't use invalid octal number as operand of "*"}
+    } -result {can't use invalid octal number "0o8" as operand of "*"}
     test mathop-2.35 {interpreted *: errors} -returnCodes error -body {
 	$op 0 [error expectedError]
     } -result expectedError
@@ -261,7 +261,7 @@ namespace eval ::testmathop {
     test mathop-3.7 {compiled !} {! 10000000000000000000000000} 0
     test mathop-3.8 {compiled !: errors} -body {
 	! foobar
-    } -returnCodes error -result {can't use non-numeric string as operand of "!"}
+    } -returnCodes error -result {can't use non-numeric string "foobar" as operand of "!"}
     test mathop-3.9 {compiled !: errors} -body {
 	! 0 0
     } -returnCodes error -result "wrong # args: should be \"! boolean\""
@@ -278,7 +278,7 @@ namespace eval ::testmathop {
     test mathop-3.17 {interpreted !} {$op 10000000000000000000000000} 0
     test mathop-3.18 {interpreted !: errors} -body {
 	$op foobar
-    } -returnCodes error -result {can't use non-numeric string as operand of "!"}
+    } -returnCodes error -result {can't use non-numeric string "foobar" as operand of "!"}
     test mathop-3.19 {interpreted !: errors} -body {
 	$op 0 0
     } -returnCodes error -result "wrong # args: should be \"! boolean\""
@@ -287,10 +287,10 @@ namespace eval ::testmathop {
     } -returnCodes error -result "wrong # args: should be \"! boolean\""
     test mathop-3.21 {compiled !: error} -returnCodes error -body {
 	! NaN
-    } -result {can't use non-numeric floating-point value as operand of "!"}
+    } -result {can't use non-numeric floating-point value "NaN" as operand of "!"}
     test mathop-3.22 {interpreted !: error} -returnCodes error -body {
 	$op NaN
-    } -result {can't use non-numeric floating-point value as operand of "!"}
+    } -result {can't use non-numeric floating-point value "NaN" as operand of "!"}
 
     test mathop-4.1 {compiled ~} {~ 0} -1
     test mathop-4.2 {compiled ~} {~ 1} -2
@@ -301,7 +301,7 @@ namespace eval ::testmathop {
     test mathop-4.7 {compiled ~} {~ 10000000000000000000000000} -10000000000000000000000001
     test mathop-4.8 {compiled ~: errors} -body {
 	~ foobar
-    } -returnCodes error -result {can't use non-numeric string as operand of "~"}
+    } -returnCodes error -result {can't use non-numeric string "foobar" as operand of "~"}
     test mathop-4.9 {compiled ~: errors} -body {
 	~ 0 0
     } -returnCodes error -result "wrong # args: should be \"~ integer\""
@@ -310,10 +310,10 @@ namespace eval ::testmathop {
     } -returnCodes error -result "wrong # args: should be \"~ integer\""
     test mathop-4.11 {compiled ~: errors} -returnCodes error -body {
 	~ 0.0
-    } -result {can't use floating-point value as operand of "~"}
+    } -result {can't use floating-point value "0.0" as operand of "~"}
     test mathop-4.12 {compiled ~: errors} -returnCodes error -body {
 	~ NaN
-    } -result {can't use non-numeric floating-point value as operand of "~"}
+    } -result {can't use non-numeric floating-point value "NaN" as operand of "~"}
     set op ~
     test mathop-4.13 {interpreted ~} {$op 0} -1
     test mathop-4.14 {interpreted ~} {$op 1} -2
@@ -324,7 +324,7 @@ namespace eval ::testmathop {
     test mathop-4.19 {interpreted ~} {$op 10000000000000000000000000} -10000000000000000000000001
     test mathop-4.20 {interpreted ~: errors} -body {
 	$op foobar
-    } -returnCodes error -result {can't use non-numeric string as operand of "~"}
+    } -returnCodes error -result {can't use non-numeric string "foobar" as operand of "~"}
     test mathop-4.21 {interpreted ~: errors} -body {
 	$op 0 0
     } -returnCodes error -result "wrong # args: should be \"~ integer\""
@@ -333,10 +333,10 @@ namespace eval ::testmathop {
     } -returnCodes error -result "wrong # args: should be \"~ integer\""
     test mathop-4.23 {interpreted ~: errors} -returnCodes error -body {
 	$op 0.0
-    } -result {can't use floating-point value as operand of "~"}
+    } -result {can't use floating-point value "0.0" as operand of "~"}
     test mathop-4.24 {interpreted ~: errors} -returnCodes error -body {
 	$op NaN
-    } -result {can't use non-numeric floating-point value as operand of "~"}
+    } -result {can't use non-numeric floating-point value "NaN" as operand of "~"}
 
     test mathop-5.1 {compiled eq} {eq {} a} 0
     test mathop-5.2 {compiled eq} {eq a a} 1
@@ -377,32 +377,32 @@ namespace eval ::testmathop {
     test mathop-6.4 {compiled &} { & 3 7 6 } 2
     test mathop-6.5 {compiled &} -returnCodes error -body {
 	& 1.0 2 3
-    } -result {can't use floating-point value as operand of "&"}
+    } -result {can't use floating-point value "1.0" as operand of "&"}
     test mathop-6.6 {compiled &} -returnCodes error -body {
 	& 1 2 3.0
-    } -result {can't use floating-point value as operand of "&"}
+    } -result {can't use floating-point value "3.0" as operand of "&"}
     test mathop-6.7 {compiled &} { & 100000000002 18 -126 } 2
     test mathop-6.8 {compiled &} { & 0xff 0o377 333333333333 } 85
     test mathop-6.9 {compiled &} { & 1000000000000000000002 18 -126 } 2
     test mathop-6.10 {compiled &} { & 0xff 0o377 3333333333333333333333 } 85
     test mathop-6.11 {compiled &: errors} -returnCodes error -body {
 	& x 0
-    } -result {can't use non-numeric string as operand of "&"}
+    } -result {can't use non-numeric string "x" as operand of "&"}
     test mathop-6.12 {compiled &: errors} -returnCodes error -body {
 	& nan 0
-    } -result {can't use non-numeric floating-point value as operand of "&"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "&"}
     test mathop-6.13 {compiled &: errors} -returnCodes error -body {
 	& 0 x
-    } -result {can't use non-numeric string as operand of "&"}
+    } -result {can't use non-numeric string "x" as operand of "&"}
     test mathop-6.14 {compiled &: errors} -returnCodes error -body {
 	& 0 nan
-    } -result {can't use non-numeric floating-point value as operand of "&"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "&"}
     test mathop-6.15 {compiled &: errors} -returnCodes error -body {
 	& 0o8 0
-    } -result {can't use invalid octal number as operand of "&"}
+    } -result {can't use invalid octal number "0o8" as operand of "&"}
     test mathop-6.16 {compiled &: errors} -returnCodes error -body {
 	& 0 0o8
-    } -result {can't use invalid octal number as operand of "&"}
+    } -result {can't use invalid octal number "0o8" as operand of "&"}
     test mathop-6.17 {compiled &: errors} -returnCodes error -body {
 	& 0 [error expectedError]
     } -result expectedError
@@ -419,32 +419,32 @@ namespace eval ::testmathop {
     test mathop-6.22 {interpreted &} { $op 3 7 6 } 2
     test mathop-6.23 {interpreted &} -returnCodes error -body {
 	$op 1.0 2 3
-    } -result {can't use floating-point value as operand of "&"}
+    } -result {can't use floating-point value "1.0" as operand of "&"}
     test mathop-6.24 {interpreted &} -returnCodes error -body {
 	$op 1 2 3.0
-    } -result {can't use floating-point value as operand of "&"}
+    } -result {can't use floating-point value "3.0" as operand of "&"}
     test mathop-6.25 {interpreted &} { $op 100000000002 18 -126 } 2
     test mathop-6.26 {interpreted &} { $op 0xff 0o377 333333333333 } 85
     test mathop-6.27 {interpreted &} { $op 1000000000000000000002 18 -126 } 2
     test mathop-6.28 {interpreted &} { $op 0xff 0o377 3333333333333333333333 } 85
     test mathop-6.29 {interpreted &: errors} -returnCodes error -body {
 	$op x 0
-    } -result {can't use non-numeric string as operand of "&"}
+    } -result {can't use non-numeric string "x" as operand of "&"}
     test mathop-6.30 {interpreted &: errors} -returnCodes error -body {
 	$op nan 0
-    } -result {can't use non-numeric floating-point value as operand of "&"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "&"}
     test mathop-6.31 {interpreted &: errors} -returnCodes error -body {
 	$op 0 x
-    } -result {can't use non-numeric string as operand of "&"}
+    } -result {can't use non-numeric string "x" as operand of "&"}
     test mathop-6.32 {interpreted &: errors} -returnCodes error -body {
 	$op 0 nan
-    } -result {can't use non-numeric floating-point value as operand of "&"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "&"}
     test mathop-6.33 {interpreted &: errors} -returnCodes error -body {
 	$op 0o8 0
-    } -result {can't use invalid octal number as operand of "&"}
+    } -result {can't use invalid octal number "0o8" as operand of "&"}
     test mathop-6.34 {interpreted &: errors} -returnCodes error -body {
 	$op 0 0o8
-    } -result {can't use invalid octal number as operand of "&"}
+    } -result {can't use invalid octal number "0o8" as operand of "&"}
     test mathop-6.35 {interpreted &: errors} -returnCodes error -body {
 	$op 0 [error expectedError]
     } -result expectedError
@@ -487,32 +487,32 @@ namespace eval ::testmathop {
     test mathop-7.4 {compiled |} { | 3 7 6 } 7
     test mathop-7.5 {compiled |} -returnCodes error -body {
 	| 1.0 2 3
-    } -result {can't use floating-point value as operand of "|"}
+    } -result {can't use floating-point value "1.0" as operand of "|"}
     test mathop-7.6 {compiled |} -returnCodes error -body {
 	| 1 2 3.0
-    } -result {can't use floating-point value as operand of "|"}
+    } -result {can't use floating-point value "3.0" as operand of "|"}
     test mathop-7.7 {compiled |} { | 100000000002 18 -126 } -110
     test mathop-7.8 {compiled |} { | 0xff 0o377 333333333333 } 333333333503
     test mathop-7.9 {compiled |} { | 1000000000000000000002 18 -126 } -110
     test mathop-7.10 {compiled |} { | 0xff 0o377 3333333333333333333333 } 3333333333333333333503
     test mathop-7.11 {compiled |: errors} -returnCodes error -body {
 	| x 0
-    } -result {can't use non-numeric string as operand of "|"}
+    } -result {can't use non-numeric string "x" as operand of "|"}
     test mathop-7.12 {compiled |: errors} -returnCodes error -body {
 	| nan 0
-    } -result {can't use non-numeric floating-point value as operand of "|"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "|"}
     test mathop-7.13 {compiled |: errors} -returnCodes error -body {
 	| 0 x
-    } -result {can't use non-numeric string as operand of "|"}
+    } -result {can't use non-numeric string "x" as operand of "|"}
     test mathop-7.14 {compiled |: errors} -returnCodes error -body {
 	| 0 nan
-    } -result {can't use non-numeric floating-point value as operand of "|"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "|"}
     test mathop-7.15 {compiled |: errors} -returnCodes error -body {
 	| 0o8 0
-    } -result {can't use invalid octal number as operand of "|"}
+    } -result {can't use invalid octal number "0o8" as operand of "|"}
     test mathop-7.16 {compiled |: errors} -returnCodes error -body {
 	| 0 0o8
-    } -result {can't use invalid octal number as operand of "|"}
+    } -result {can't use invalid octal number "0o8" as operand of "|"}
     test mathop-7.17 {compiled |: errors} -returnCodes error -body {
 	| 0 [error expectedError]
     } -result expectedError
@@ -529,32 +529,32 @@ namespace eval ::testmathop {
     test mathop-7.22 {interpreted |} { $op 3 7 6 } 7
     test mathop-7.23 {interpreted |} -returnCodes error -body {
 	$op 1.0 2 3
-    } -result {can't use floating-point value as operand of "|"}
+    } -result {can't use floating-point value "1.0" as operand of "|"}
     test mathop-7.24 {interpreted |} -returnCodes error -body {
 	$op 1 2 3.0
-    } -result {can't use floating-point value as operand of "|"}
+    } -result {can't use floating-point value "3.0" as operand of "|"}
     test mathop-7.25 {interpreted |} { $op 100000000002 18 -126 } -110
     test mathop-7.26 {interpreted |} { $op 0xff 0o377 333333333333 } 333333333503
     test mathop-7.27 {interpreted |} { $op 1000000000000000000002 18 -126 } -110
     test mathop-7.28 {interpreted |} { $op 0xff 0o377 3333333333333333333333 } 3333333333333333333503
     test mathop-7.29 {interpreted |: errors} -returnCodes error -body {
 	$op x 0
-    } -result {can't use non-numeric string as operand of "|"}
+    } -result {can't use non-numeric string "x" as operand of "|"}
     test mathop-7.30 {interpreted |: errors} -returnCodes error -body {
 	$op nan 0
-    } -result {can't use non-numeric floating-point value as operand of "|"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "|"}
     test mathop-7.31 {interpreted |: errors} -returnCodes error -body {
 	$op 0 x
-    } -result {can't use non-numeric string as operand of "|"}
+    } -result {can't use non-numeric string "x" as operand of "|"}
     test mathop-7.32 {interpreted |: errors} -returnCodes error -body {
 	$op 0 nan
-    } -result {can't use non-numeric floating-point value as operand of "|"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "|"}
     test mathop-7.33 {interpreted |: errors} -returnCodes error -body {
 	$op 0o8 0
-    } -result {can't use invalid octal number as operand of "|"}
+    } -result {can't use invalid octal number "0o8" as operand of "|"}
     test mathop-7.34 {interpreted |: errors} -returnCodes error -body {
 	$op 0 0o8
-    } -result {can't use invalid octal number as operand of "|"}
+    } -result {can't use invalid octal number "0o8" as operand of "|"}
     test mathop-7.35 {interpreted |: errors} -returnCodes error -body {
 	$op 0 [error expectedError]
     } -result expectedError
@@ -597,32 +597,32 @@ namespace eval ::testmathop {
     test mathop-8.4 {compiled ^} { ^ 3 7 6 } 2
     test mathop-8.5 {compiled ^} -returnCodes error -body {
 	^ 1.0 2 3
-    } -result {can't use floating-point value as operand of "^"}
+    } -result {can't use floating-point value "1.0" as operand of "^"}
     test mathop-8.6 {compiled ^} -returnCodes error -body {
 	^ 1 2 3.0
-    } -result {can't use floating-point value as operand of "^"}
+    } -result {can't use floating-point value "3.0" as operand of "^"}
     test mathop-8.7 {compiled ^} { ^ 100000000002 18 -126 } -100000000110
     test mathop-8.8 {compiled ^} { ^ 0xff 0o377 333333333333 } 333333333333
     test mathop-8.9 {compiled ^} { ^ 1000000000000000000002 18 -126 } -1000000000000000000110
     test mathop-8.10 {compiled ^} { ^ 0xff 0o377 3333333333333333333333 } 3333333333333333333333
     test mathop-8.11 {compiled ^: errors} -returnCodes error -body {
 	^ x 0
-    } -result {can't use non-numeric string as operand of "^"}
+    } -result {can't use non-numeric string "x" as operand of "^"}
     test mathop-8.12 {compiled ^: errors} -returnCodes error -body {
 	^ nan 0
-    } -result {can't use non-numeric floating-point value as operand of "^"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "^"}
     test mathop-8.13 {compiled ^: errors} -returnCodes error -body {
 	^ 0 x
-    } -result {can't use non-numeric string as operand of "^"}
+    } -result {can't use non-numeric string "x" as operand of "^"}
     test mathop-8.14 {compiled ^: errors} -returnCodes error -body {
 	^ 0 nan
-    } -result {can't use non-numeric floating-point value as operand of "^"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "^"}
     test mathop-8.15 {compiled ^: errors} -returnCodes error -body {
 	^ 0o8 0
-    } -result {can't use invalid octal number as operand of "^"}
+    } -result {can't use invalid octal number "0o8" as operand of "^"}
     test mathop-8.16 {compiled ^: errors} -returnCodes error -body {
 	^ 0 0o8
-    } -result {can't use invalid octal number as operand of "^"}
+    } -result {can't use invalid octal number "0o8" as operand of "^"}
     test mathop-8.17 {compiled ^: errors} -returnCodes error -body {
 	^ 0 [error expectedError]
     } -result expectedError
@@ -639,32 +639,32 @@ namespace eval ::testmathop {
     test mathop-8.22 {interpreted ^} { $op 3 7 6 } 2
     test mathop-8.23 {interpreted ^} -returnCodes error -body {
 	$op 1.0 2 3
-    } -result {can't use floating-point value as operand of "^"}
+    } -result {can't use floating-point value "1.0" as operand of "^"}
     test mathop-8.24 {interpreted ^} -returnCodes error -body {
 	$op 1 2 3.0
-    } -result {can't use floating-point value as operand of "^"}
+    } -result {can't use floating-point value "3.0" as operand of "^"}
     test mathop-8.25 {interpreted ^} { $op 100000000002 18 -126 } -100000000110
     test mathop-8.26 {interpreted ^} { $op 0xff 0o377 333333333333 } 333333333333
     test mathop-8.27 {interpreted ^} { $op 1000000000000000000002 18 -126 } -1000000000000000000110
     test mathop-8.28 {interpreted ^} { $op 0xff 0o377 3333333333333333333333 } 3333333333333333333333
     test mathop-8.29 {interpreted ^: errors} -returnCodes error -body {
 	$op x 0
-    } -result {can't use non-numeric string as operand of "^"}
+    } -result {can't use non-numeric string "x" as operand of "^"}
     test mathop-8.30 {interpreted ^: errors} -returnCodes error -body {
 	$op nan 0
-    } -result {can't use non-numeric floating-point value as operand of "^"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "^"}
     test mathop-8.31 {interpreted ^: errors} -returnCodes error -body {
 	$op 0 x
-    } -result {can't use non-numeric string as operand of "^"}
+    } -result {can't use non-numeric string "x" as operand of "^"}
     test mathop-8.32 {interpreted ^: errors} -returnCodes error -body {
 	$op 0 nan
-    } -result {can't use non-numeric floating-point value as operand of "^"}
+    } -result {can't use non-numeric floating-point value "nan" as operand of "^"}
     test mathop-8.33 {interpreted ^: errors} -returnCodes error -body {
 	$op 0o8 0
-    } -result {can't use invalid octal number as operand of "^"}
+    } -result {can't use invalid octal number "0o8" as operand of "^"}
     test mathop-8.34 {interpreted ^: errors} -returnCodes error -body {
 	$op 0 0o8
-    } -result {can't use invalid octal number as operand of "^"}
+    } -result {can't use invalid octal number "0o8" as operand of "^"}
     test mathop-8.35 {interpreted ^: errors} -returnCodes error -body {
 	$op 0 [error expectedError]
     } -result expectedError
@@ -775,13 +775,13 @@ test mathop-20.6 { one arg, error } {
         # skipping - for now, knownbug...
         foreach op {+ * / & | ^ **} {
             lappend res [TestOp $op {*}$vals]
-            lappend exp "can't use non-numeric string as operand of \"$op\"\
+            lappend exp "can't use non-numeric string \"x\" as operand of \"$op\"\
 		ARITH DOMAIN {non-numeric string}"
         }
     }
     foreach op {+ * / & | ^ **} {
 	lappend res [TestOp $op NaN 1]
-	lappend exp "can't use non-numeric floating-point value as operand of \"$op\"\
+	lappend exp "can't use non-numeric floating-point value \"NaN\" as operand of \"$op\"\
 	    ARITH DOMAIN {non-numeric floating-point value}"
     }
     expr {$res eq $exp ? 0 : $res}
@@ -850,15 +850,15 @@ test mathop-21.5 { unary ops, bad values } {
     set res {}
     set exp {}
     lappend res [TestOp / x]
-    lappend exp "can't use non-numeric string as operand of \"/\" ARITH DOMAIN {non-numeric string}"
+    lappend exp "can't use non-numeric string \"x\" as operand of \"/\" ARITH DOMAIN {non-numeric string}"
     lappend res [TestOp - x]
-    lappend exp "can't use non-numeric string as operand of \"-\" ARITH DOMAIN {non-numeric string}"
+    lappend exp "can't use non-numeric string \"x\" as operand of \"-\" ARITH DOMAIN {non-numeric string}"
     lappend res [TestOp ~ x]
-    lappend exp "can't use non-numeric string as operand of \"~\" ARITH DOMAIN {non-numeric string}"
+    lappend exp "can't use non-numeric string \"x\" as operand of \"~\" ARITH DOMAIN {non-numeric string}"
     lappend res [TestOp ! x]
-    lappend exp "can't use non-numeric string as operand of \"!\" ARITH DOMAIN {non-numeric string}"
+    lappend exp "can't use non-numeric string \"x\" as operand of \"!\" ARITH DOMAIN {non-numeric string}"
     lappend res [TestOp ~ 5.0]
-    lappend exp "can't use floating-point value as operand of \"~\" ARITH DOMAIN {floating-point value}"
+    lappend exp "can't use floating-point value \"5.0\" as operand of \"~\" ARITH DOMAIN {floating-point value}"
     expr {$res eq $exp ? 0 : $res}
 } 0
 test mathop-21.6 { unary ops, too many } {
@@ -965,9 +965,9 @@ test mathop-22.4 { unary ops, bad values } {
     set exp {}
     foreach op {& | ^} {
         lappend res [TestOp $op x 5]
-        lappend exp "can't use non-numeric string as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
+        lappend exp "can't use non-numeric string \"x\" as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
         lappend res [TestOp $op 5 x]
-        lappend exp "can't use non-numeric string as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
+        lappend exp "can't use non-numeric string \"x\" as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
     }
     expr {$res eq $exp ? 0 : $res}
 } 0
@@ -1080,15 +1080,15 @@ test mathop-24.3 { binary ops, bad values } {
     set exp {}
     foreach op {% << >>} {
         lappend res [TestOp $op x 1]
-        lappend exp "can't use non-numeric string as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
+        lappend exp "can't use non-numeric string \"x\" as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
         lappend res [TestOp $op 1 x]
-        lappend exp "can't use non-numeric string as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
+        lappend exp "can't use non-numeric string \"x\" as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
     }
     foreach op {% << >>} {
         lappend res [TestOp $op 5.0 1]
-        lappend exp "can't use floating-point value as operand of \"$op\" ARITH DOMAIN {floating-point value}"
+        lappend exp "can't use floating-point value \"5.0\" as operand of \"$op\" ARITH DOMAIN {floating-point value}"
         lappend res [TestOp $op 1 5.0]
-        lappend exp "can't use floating-point value as operand of \"$op\" ARITH DOMAIN {floating-point value}"
+        lappend exp "can't use floating-point value \"5.0\" as operand of \"$op\" ARITH DOMAIN {floating-point value}"
     }
     foreach op {in ni} {
         lappend res [TestOp $op 5 "a b \{ c"]
@@ -1266,9 +1266,9 @@ test mathop-25.41 { exp operator errors } {
     lappend res [TestOp ** $huge 2.1]
     lappend exp "Inf"
     lappend res [TestOp ** 2 foo]
-    lappend exp "can't use non-numeric string as operand of \"**\" ARITH DOMAIN {non-numeric string}"
+    lappend exp "can't use non-numeric string \"foo\" as operand of \"**\" ARITH DOMAIN {non-numeric string}"
     lappend res [TestOp ** foo 2]
-    lappend exp "can't use non-numeric string as operand of \"**\" ARITH DOMAIN {non-numeric string}"
+    lappend exp "can't use non-numeric string \"foo\" as operand of \"**\" ARITH DOMAIN {non-numeric string}"
 
     expr {$res eq $exp ? 0 : $res}
 } 0
diff --git a/tests/while-old.test b/tests/while-old.test
index 9c8cacc..b5b69dc 100644
--- a/tests/while-old.test
+++ b/tests/while-old.test
@@ -92,7 +92,7 @@ test while-old-4.3 {errors in while loops} {
 test while-old-4.4 {errors in while loops} {
     set err [catch {while {"a"+"b"} {error "loop aborted"}} msg]
     list $err $msg
-} {1 {can't use non-numeric string as operand of "+"}}
+} {1 {can't use non-numeric string "a" as operand of "+"}}
 test while-old-4.5 {errors in while loops} {
     catch {unset x}
     set x 1
diff --git a/tests/while.test b/tests/while.test
index 6ea8548..2bfab2a 100644
--- a/tests/while.test
+++ b/tests/while.test
@@ -32,7 +32,7 @@ test while-1.2 {TclCompileWhileCmd: error in test expression} -body {
 } -match glob -result {*"while {$i<} break"}
 test while-1.3 {TclCompileWhileCmd: error in test expression} -body {
     while {"a"+"b"} {error "loop aborted"}
-} -returnCodes error -result {can't use non-numeric string as operand of "+"}
+} -returnCodes error -result {can't use non-numeric string "a" as operand of "+"}
 test while-1.4 {TclCompileWhileCmd: multiline test expr} -body {
     set value 1
     while {($tcl_platform(platform) != "foobar1") && \
@@ -343,7 +343,7 @@ test while-4.3 {while (not compiled): error in test expression} -body {
 test while-4.4 {while (not compiled): error in test expression} -body {
     set z while
     $z {"a"+"b"} {error "loop aborted"}
-} -returnCodes error -result {can't use non-numeric string as operand of "+"}
+} -returnCodes error -result {can't use non-numeric string "a" as operand of "+"}
 test while-4.5 {while (not compiled): multiline test expr} -body {
     set value 1
     set z while