Merge trunk

29 files changed, 604 insertions, 368 deletions

diff --git a/.travis.yml b/.travis.yml
index 62fb2ba..334ab6c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -288,7 +288,7 @@ matrix:
       before_install: &makepreinst
         - choco install -y make zip
         - cd ${BUILD_DIR}
-    - name: "Windows/GCC/Shared: UTF_MAX"
+    - name: "Windows/GCC/Shared: UTF_MAX=3"
       os: windows
       compiler: gcc
       env:
diff --git a/doc/TraceVar.3 b/doc/TraceVar.3
index 8dc221a..dd72563 100644
--- a/doc/TraceVar.3
+++ b/doc/TraceVar.3
@@ -5,7 +5,7 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\"
-.TH Tcl_TraceVar 3 7.4 Tcl "Tcl Library Procedures"
+.TH Tcl_TraceVar 3 9.0 Tcl "Tcl Library Procedures"
 .so man.macros
 .BS
 .SH NAME
@@ -95,7 +95,7 @@ Invoke \fIproc\fR whenever an attempt is made to modify the variable.
 Invoke \fIproc\fR whenever the variable is unset.
 A variable may be unset either explicitly by an \fBunset\fR command,
 or implicitly when a procedure returns (its local variables are
-automatically unset) or when the interpreter is deleted (all
+automatically unset) or when the interpreter or namespace is deleted (all
 variables are automatically unset).
 .TP
 \fBTCL_TRACE_ARRAY\fR
@@ -160,10 +160,6 @@ The bit \fBTCL_TRACE_DESTROYED\fR will be set in \fIflags\fR if the trace is
 about to be destroyed;  this information may be useful to \fIproc\fR
 so that it can clean up its own internal data structures (see
 the section \fBTCL_TRACE_DESTROYED\fR below for more details).
-Lastly, the bit \fBTCL_INTERP_DESTROYED\fR will be set if the entire
-interpreter is being destroyed.
-When this bit is set, \fIproc\fR must be especially careful in
-the things it does (see the section \fBTCL_INTERP_DESTROYED\fR below).
 The trace procedure's return value should normally be NULL;  see
 \fBERROR RETURNS\fR below for information on other possibilities.
 .PP
@@ -330,6 +326,16 @@ During unset traces, the return value is ignored and all relevant
 trace procedures will always be invoked.
 .SH "RESTRICTIONS"
 .PP
+Because operations on variables may take place as part of the deletion
+of the interp that contains them, \fIproc\fR must be careful about checking
+what the \fIinterp\fR parameter can be used to do.
+The routine \fBTcl_InterpDeleted\fR is an important tool for this.
+When \fBTcl_InterpDeleted\fR returns 1, \fIproc\fR will not be able
+to invoke any scripts in \fIinterp\fR. You may encounter old code using
+a deprecated flag value \fBTCL_INTERP_DESTROYED\fR to signal this
+condition, but Tcl 9 no longer supports this. Any supported code
+must be converted to stop using it.
+.PP
 A trace procedure can be called at any time, even when there
 are partially formed results stored in the interpreter.  If
 the trace procedure does anything that could damage this result (such
@@ -354,24 +360,8 @@ Traces on a variable are always removed whenever the variable
 is deleted;  the only time \fBTCL_TRACE_DESTROYED\fR is not set is for
 a whole-array trace invoked when only a single element of an
 array is unset.
-.SH "TCL_INTERP_DESTROYED"
-.PP
-When an interpreter is destroyed, unset traces are called for
-all of its variables.
-The \fBTCL_INTERP_DESTROYED\fR bit will be set in the \fIflags\fR
-argument passed to the trace procedures.
-Trace procedures must be extremely careful in what they do if
-the \fBTCL_INTERP_DESTROYED\fR bit is set.
-It is not safe for the procedures to invoke any Tcl procedures
-on the interpreter, since its state is partially deleted.
-All that trace procedures should do under these circumstances is
-to clean up and free their own internal data structures.
 .SH BUGS
 .PP
-Tcl does not do any error checking to prevent trace procedures
-from misusing the interpreter during traces with \fBTCL_INTERP_DESTROYED\fR
-set.
-.PP
 Array traces are not yet integrated with the Tcl \fBinfo exists\fR command,
 nor is there Tcl-level access to array traces.
 .SH "SEE ALSO"
diff --git a/doc/lappend.n b/doc/lappend.n
index 66bea5f..89b6909 100644
--- a/doc/lappend.n
+++ b/doc/lappend.n
@@ -49,8 +49,9 @@ Using \fBlappend\fR to build up a list of numbers.
 1 2 3 4 5
 .CE
 .SH "SEE ALSO"
-list(n), lindex(n), linsert(n), llength(n), lset(n),
-lsort(n), lrange(n)
+list(n), lassign(n), lindex(n), linsert(n), llength(n),
+lmap(n), lpop(n), lrange(n), lremove(n), lrepeat(n), lreplace(n),
+lreverse(n), lsearch(n), lset(n), lsort(n)
 .SH KEYWORDS
 append, element, list, variable
 .\" Local variables:
diff --git a/doc/lassign.n b/doc/lassign.n
index 5620de6..67048ba 100644
--- a/doc/lassign.n
+++ b/doc/lassign.n
@@ -52,7 +52,9 @@ command in many shell languages like this:
 set ::argv [\fBlassign\fR $::argv argumentToReadOff]
 .CE
 .SH "SEE ALSO"
-lindex(n), list(n), lrange(n), lset(n), set(n)
+list(n), lappend(n), lindex(n), linsert(n), llength(n),
+lmap(n), lpop(n), lrange(n), lremove(n), lrepeat(n), lreplace(n),
+lreverse(n), lsearch(n), lset(n), lsort(n)
 .SH KEYWORDS
 assign, element, list, multiple, set, variable
 '\"Local Variables:
diff --git a/doc/lindex.n b/doc/lindex.n
index be4f169..01e0d8b 100644
--- a/doc/lindex.n
+++ b/doc/lindex.n
@@ -115,8 +115,9 @@ set idx 3
       \fI\(-> f\fR
 .CE
 .SH "SEE ALSO"
-list(n), lappend(n), linsert(n), llength(n), lsearch(n),
-lset(n), lsort(n), lrange(n), lreplace(n),
+list(n), lappend(n), lassign(n), linsert(n), llength(n),
+lmap(n), lpop(n), lrange(n), lremove(n), lrepeat(n), lreplace(n),
+lreverse(n), lsearch(n), lset(n), lsort(n),
 string(n)
 .SH KEYWORDS
 element, index, list
diff --git a/doc/linsert.n b/doc/linsert.n
index 91db726..3179256 100644
--- a/doc/linsert.n
+++ b/doc/linsert.n
@@ -45,8 +45,9 @@ set newList [\fBlinsert\fR $midList end-1 lazy]
 set newerList [\fBlinsert\fR [\fBlinsert\fR $oldList end-1 quick] 1 lazy]
 .CE
 .SH "SEE ALSO"
-list(n), lappend(n), lindex(n), llength(n), lsearch(n),
-lset(n), lsort(n), lrange(n), lreplace(n),
+list(n), lappend(n), lassign(n), lindex(n), llength(n),
+lmap(n), lpop(n), lrange(n), lremove(n), lrepeat(n), lreplace(n),
+lreverse(n), lsearch(n), lset(n), lsort(n),
 string(n)
 .SH KEYWORDS
 element, insert, list
diff --git a/doc/list.n b/doc/list.n
index a182fc8..3fa1975 100644
--- a/doc/list.n
+++ b/doc/list.n
@@ -46,9 +46,9 @@ while \fBconcat\fR with the same arguments will return
 \fBa b c d e f {g h}\fR
 .CE
 .SH "SEE ALSO"
-lappend(n), lindex(n), linsert(n), llength(n), lrange(n),
-lrepeat(n),
-lreplace(n), lsearch(n), lset(n), lsort(n)
+lappend(n), lassign(n), lindex(n), linsert(n), llength(n),
+lmap(n), lpop(n), lrange(n), lremove(n), lrepeat(n), lreplace(n),
+lreverse(n), lsearch(n), lset(n), lsort(n)
 .SH KEYWORDS
 element, list, quoting
 '\"Local Variables:
diff --git a/doc/llength.n b/doc/llength.n
index 7e46064..26824a0 100644
--- a/doc/llength.n
+++ b/doc/llength.n
@@ -49,8 +49,9 @@ An empty list is not necessarily an empty string:
 1,0
 .CE
 .SH "SEE ALSO"
-list(n), lappend(n), lindex(n), linsert(n), lsearch(n),
-lset(n), lsort(n), lrange(n), lreplace(n)
+list(n), lappend(n), lassign(n), lindex(n), linsert(n),
+lmap(n), lpop(n), lrange(n), lremove(n), lrepeat(n), lreplace(n),
+lreverse(n), lsearch(n), lset(n), lsort(n)
 .SH KEYWORDS
 element, list, length
 '\" Local Variables:
diff --git a/doc/lmap.n b/doc/lmap.n
index 1a7858d..026e9d0 100644
--- a/doc/lmap.n
+++ b/doc/lmap.n
@@ -77,7 +77,10 @@ set prefix [\fBlmap\fR x $values {expr {
 # The value of prefix is "8 7 6 5 4"
 .CE
 .SH "SEE ALSO"
-break(n), continue(n), for(n), foreach(n), while(n)
+break(n), continue(n), for(n), foreach(n), while(n),
+list(n), lappend(n), lassign(n), lindex(n), linsert(n), llength(n),
+lpop(n), lrange(n), lremove(n), lrepeat(n), lreplace(n),
+lreverse(n), lsearch(n), lset(n), lsort(n)
 .SH KEYWORDS
 foreach, iteration, list, loop, map
 '\" Local Variables:
diff --git a/doc/lpop.n b/doc/lpop.n
index 0ce8ff8..631bc58 100644
--- a/doc/lpop.n
+++ b/doc/lpop.n
@@ -86,8 +86,9 @@ The indicated value becomes the new value of \fIx\fR.
       \fI\(-> {{a b} {c d}} {{e f} h}\fR
 .CE
 .SH "SEE ALSO"
-list(n), lappend(n), lindex(n), linsert(n), llength(n), lsearch(n),
-lsort(n), lrange(n), lreplace(n), lset(n)
+list(n), lappend(n), lassign(n), lindex(n), linsert(n), llength(n),
+lmap(n), lrange(n), lremove(n), lrepeat(n), lreplace(n),
+lreverse(n), lsearch(n), lset(n), lsort(n),
 string(n)
 .SH KEYWORDS
 element, index, list, remove, pop, stack, queue
diff --git a/doc/lrange.n b/doc/lrange.n
index a4fd98b..0d4b261 100644
--- a/doc/lrange.n
+++ b/doc/lrange.n
@@ -71,8 +71,9 @@ elements to
 {elements to}
 .CE
 .SH "SEE ALSO"
-list(n), lappend(n), lindex(n), linsert(n), llength(n), lsearch(n),
-lset(n), lremove(n), lreplace(n), lsort(n),
+list(n), lappend(n), lassign(n), lindex(n), linsert(n), llength(n),
+lmap(n), lpop(n), lremove(n), lrepeat(n), lreplace(n),
+lreverse(n), lsearch(n), lset(n), lsort(n),
 string(n)
 .SH KEYWORDS
 element, list, range, sublist
diff --git a/doc/lremove.n b/doc/lremove.n
index b947863..59d261b 100644
--- a/doc/lremove.n
+++ b/doc/lremove.n
@@ -46,7 +46,9 @@ Removing the same element indicated in two different ways:
 a b d e
 .CE
 .SH "SEE ALSO"
-list(n), lrange(n), lsearch(n), lsearch(n)
+list(n), lappend(n), lassign(n), lindex(n), linsert(n), llength(n),
+lmap(n), lpop(n), lrange(n), lrepeat(n), lreplace(n),
+lreverse(n), lsearch(n), lset(n), lsort(n)
 .SH KEYWORDS
 element, list, remove
 .\" Local variables:
diff --git a/doc/lrepeat.n b/doc/lrepeat.n
index 4719bfd..2e17f9c 100644
--- a/doc/lrepeat.n
+++ b/doc/lrepeat.n
@@ -32,7 +32,9 @@ is identical to \fBlist element ...\fR.
       \fI\(-> {a a} b c {a a} b c {a a} b c\fR
 .CE
 .SH "SEE ALSO"
-list(n), lappend(n), linsert(n), llength(n), lset(n)
+list(n), lappend(n), lassign(n), lindex(n), linsert(n), llength(n),
+lmap(n), lpop(n), lrange(n), lremove(n), lreplace(n),
+lreverse(n), lsearch(n), lset(n), lsort(n)
 .SH KEYWORDS
 element, index, list
 '\" Local Variables:
diff --git a/doc/lreplace.n b/doc/lreplace.n
index 68cddfe..bc9d7ca 100644
--- a/doc/lreplace.n
+++ b/doc/lreplace.n
@@ -95,8 +95,9 @@ a b c d e f g h i
 .CE
 .VE TIP505
 .SH "SEE ALSO"
-list(n), lappend(n), lindex(n), linsert(n), llength(n), lsearch(n),
-lset(n), lrange(n), lremove(n), lsort(n),
+list(n), lappend(n), lassign(n), lindex(n), linsert(n), llength(n),
+lmap(n), lpop(n), lrange(n), lremove(n), lrepeat(n),
+lreverse(n), lsearch(n), lset(n), lsort(n),
 string(n)
 .SH KEYWORDS
 element, list, replace
diff --git a/doc/lreverse.n b/doc/lreverse.n
index 4c2f762..2ed496a 100644
--- a/doc/lreverse.n
+++ b/doc/lreverse.n
@@ -25,8 +25,9 @@ input list, \fIlist\fR, except with the elements in the reverse order.
       \fI\(-> f e {c d} b a\fR
 .CE
 .SH "SEE ALSO"
-list(n), lsearch(n), lsort(n)
-
+list(n), lappend(n), lassign(n), lindex(n), linsert(n), llength(n),
+lmap(n), lpop(n), lrange(n), lremove(n), lrepeat(n), lreplace(n),
+lsearch(n), lset(n), lsort(n)
 .SH KEYWORDS
 element, list, reverse
 '\" Local Variables:
diff --git a/doc/lsearch.n b/doc/lsearch.n
index 9172d96..f38afc9 100644
--- a/doc/lsearch.n
+++ b/doc/lsearch.n
@@ -227,8 +227,10 @@ The same thing for a flattened list:
       \fI\(-> {a abc b bcd}\fR
 .CE
 .SH "SEE ALSO"
-foreach(n), list(n), lappend(n), lindex(n), linsert(n), llength(n),
-lset(n), lsort(n), lrange(n), lreplace(n),
+foreach(n), 
+list(n), lappend(n), lassign(n), lindex(n), linsert(n), llength(n),
+lmap(n), lpop(n), lrange(n), lremove(n), lrepeat(n), lreplace(n),
+lreverse(n), lset(n), lsort(n),
 string(n)
 .SH KEYWORDS
 binary search, linear search,
diff --git a/doc/lset.n b/doc/lset.n
index e425274..afc721f 100644
--- a/doc/lset.n
+++ b/doc/lset.n
@@ -136,8 +136,9 @@ The indicated return value also becomes the new value of \fIx\fR.
       \fI\(-> {{a b} {c d}} {{e f} {j h}}\fR
 .CE
 .SH "SEE ALSO"
-list(n), lappend(n), lindex(n), linsert(n), llength(n), lsearch(n),
-lsort(n), lrange(n), lreplace(n),
+list(n), lappend(n), lassign(n), lindex(n), linsert(n), llength(n),
+lmap(n), lpop(n), lrange(n), lremove(n), lrepeat(n), lreplace(n),
+lreverse(n), lsearch(n), lsort(n)
 string(n)
 .SH KEYWORDS
 element, index, list, replace, set
diff --git a/doc/lsort.n b/doc/lsort.n
index 17a921a..2018e30 100644
--- a/doc/lsort.n
+++ b/doc/lsort.n
@@ -264,8 +264,9 @@ More complex sorting using a comparison function:
 {1 dingo} {2 banana} {0x2 carrot} {3 apple}
 .CE
 .SH "SEE ALSO"
-list(n), lappend(n), lindex(n), linsert(n), llength(n), lsearch(n),
-lset(n), lrange(n), lreplace(n)
+list(n), lappend(n), lassign(n), lindex(n), linsert(n), llength(n),
+lmap(n), lpop(n), lrange(n), lremove(n), lrepeat(n), lreplace(n),
+lreverse(n), lsearch(n), lset(n)
 .SH KEYWORDS
 element, list, order, sort
 '\" Local Variables:
diff --git a/generic/tcl.h b/generic/tcl.h
index 4439fcd..c853e85 100644
--- a/generic/tcl.h
+++ b/generic/tcl.h
@@ -874,7 +874,7 @@ typedef struct Tcl_DString {
 #define TCL_TRACE_WRITES	 0x20
 #define TCL_TRACE_UNSETS	 0x40
 #define TCL_TRACE_DESTROYED	 0x80
-#define TCL_INTERP_DESTROYED	 0x100
+
 #define TCL_LEAVE_ERR_MSG	 0x200
 #define TCL_TRACE_ARRAY		 0x800
 #ifndef TCL_REMOVE_OBSOLETE_TRACES
diff --git a/generic/tclBasic.c b/generic/tclBasic.c
index 182ec0e..106a01a 100644
--- a/generic/tclBasic.c
+++ b/generic/tclBasic.c
@@ -6919,10 +6919,16 @@ ExprIsqrtFunc(
 	Tcl_SetObjResult(interp, Tcl_NewWideIntObj((Tcl_WideInt) sqrt(d)));
     } else {
 	mp_int root;
+	mp_err err;
 
-	mp_init(&root);
-	mp_sqrt(&big, &root);
+	err = mp_init(&root);
+	if (err == MP_OKAY) {
+	    err = mp_sqrt(&big, &root);
+	}
 	mp_clear(&big);
+	if (err != MP_OKAY) {
+	    return TCL_ERROR;
+	}
 	Tcl_SetObjResult(interp, Tcl_NewBignumObj(&root));
     }
     return TCL_OK;
@@ -6968,10 +6974,17 @@ ExprSqrtFunc(
     if ((d >= 0.0) && TclIsInfinite(d)
 	    && (Tcl_GetBignumFromObj(NULL, objv[1], &big) == TCL_OK)) {
 	mp_int root;
+	mp_err err;
 
-	mp_init(&root);
-	mp_sqrt(&big, &root);
+	err = mp_init(&root);
+	if (err == MP_OKAY) {
+	    err = mp_sqrt(&big, &root);
+	}
 	mp_clear(&big);
+	if (err != MP_OKAY) {
+	    mp_clear(&root);
+	    return TCL_ERROR;
+	}
 	Tcl_SetObjResult(interp, Tcl_NewDoubleObj(TclBignumToDouble(&root)));
 	mp_clear(&root);
     } else {
@@ -7137,7 +7150,9 @@ ExprAbsFunc(
 	    }
 	    goto unChanged;
 	} else if (l == WIDE_MIN) {
-	    mp_init_i64(&big, l);
+	    if (mp_init_i64(&big, l) != MP_OKAY) {
+		return TCL_ERROR;
+	    }
 	    goto tooLarge;
 	}
 	Tcl_SetObjResult(interp, Tcl_NewWideIntObj(-l));
@@ -7168,7 +7183,9 @@ ExprAbsFunc(
 	if (mp_isneg((const mp_int *) ptr)) {
 	    Tcl_GetBignumFromObj(NULL, objv[1], &big);
 	tooLarge:
-	    (void)mp_neg(&big, &big);
+	    if (mp_neg(&big, &big) != MP_OKAY) {
+		return TCL_ERROR;
+	    }
 	    Tcl_SetObjResult(interp, Tcl_NewBignumObj(&big));
 	} else {
 	unChanged:
@@ -7504,15 +7521,19 @@ ExprRoundFunc(
 	}
 	if ((intPart >= (double)max) || (intPart <= (double)min)) {
 	    mp_int big;
+	    mp_err err = MP_OKAY;
 
 	    if (Tcl_InitBignumFromDouble(interp, intPart, &big) != TCL_OK) {
 		/* Infinity */
 		return TCL_ERROR;
 	    }
 	    if (fractPart <= -0.5) {
-		mp_sub_d(&big, 1, &big);
+		err = mp_sub_d(&big, 1, &big);
 	    } else if (fractPart >= 0.5) {
-		mp_add_d(&big, 1, &big);
+		err = mp_add_d(&big, 1, &big);
+	    }
+	    if (err != MP_OKAY) {
+		return TCL_ERROR;
 	    }
 	    Tcl_SetObjResult(interp, Tcl_NewBignumObj(&big));
 	    return TCL_OK;
diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index be458f3..793f3fd 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -604,6 +604,7 @@ static const size_t Exp64ValueSize = sizeof(Exp64Value) / sizeof(Tcl_WideInt);
 #define DIVIDED_BY_ZERO		((Tcl_Obj *) -1)
 #define EXPONENT_OF_ZERO	((Tcl_Obj *) -2)
 #define GENERAL_ARITHMETIC_ERROR ((Tcl_Obj *) -3)
+#define OUT_OF_MEMORY ((Tcl_Obj *) -4)
 
 /*
  * Declarations for local procedures to this file:
@@ -1749,6 +1750,7 @@ TclIncrObj(
     ClientData ptr1, ptr2;
     int type1, type2;
     mp_int value, incr;
+    mp_err err;
 
     if (Tcl_IsShared(valuePtr)) {
 	Tcl_Panic("%s called with shared object", "TclIncrObj");
@@ -1807,8 +1809,11 @@ TclIncrObj(
 
     Tcl_TakeBignumFromObj(interp, valuePtr, &value);
     Tcl_GetBignumFromObj(interp, incrPtr, &incr);
-    mp_add(&value, &incr, &value);
+    err = mp_add(&value, &incr, &value);
     mp_clear(&incr);
+    if (err != MP_OKAY) {
+	return TCL_ERROR;
+    }
     Tcl_SetBignumObj(valuePtr, &value);
     return TCL_OK;
 }
@@ -5960,6 +5965,9 @@ TEBCresume(
 	} else if (objResultPtr == GENERAL_ARITHMETIC_ERROR) {
 	    TRACE_ERROR(interp);
 	    goto gotError;
+	} else if (objResultPtr == OUT_OF_MEMORY) {
+	    TRACE_APPEND(("OUT OF MEMORY\n"));
+	    goto outOfMemory;
 	} else if (objResultPtr == NULL) {
 	    TRACE_APPEND(("%s\n", O2S(valuePtr)));
 	    NEXT_INST_F(1, 1, 0);
@@ -7248,6 +7256,13 @@ TEBCresume(
 	CACHE_STACK_INFO();
 	goto gotError;
 
+    outOfMemory:
+	Tcl_SetObjResult(interp, Tcl_NewStringObj("out of memory", -1));
+	DECACHE_STACK_INFO();
+	Tcl_SetErrorCode(interp, "ARITH", "OUTOFMEMORY", "out of memory", NULL);
+	CACHE_STACK_INFO();
+	goto gotError;
+
 	/*
 	 * Exponentiation of zero by negative number in an expression. Control
 	 * only reaches this point by "goto exponOfZero".
@@ -7689,6 +7704,7 @@ ExecuteExtendedBinaryMathOp(
     Tcl_Obj *objResultPtr;
     int invalid, zero;
     long shift;
+	mp_err err;
 
     (void) GetNumberFromObj(NULL, valuePtr, &ptr1, &type1);
     (void) GetNumberFromObj(NULL, value2Ptr, &ptr2, &type2);
@@ -7750,9 +7766,14 @@ ExecuteExtendedBinaryMathOp(
 		 * Arguments are opposite sign; remainder is sum.
 		 */
 
-		mp_init_i64(&big1, w1);
-		mp_add(&big2, &big1, &big2);
-		mp_clear(&big1);
+		err = mp_init_i64(&big1, w1);
+		if (err == MP_OKAY) {
+		    err = mp_add(&big2, &big1, &big2);
+		    mp_clear(&big1);
+		}
+		if (err != MP_OKAY) {
+		    return OUT_OF_MEMORY;
+		}
 		BIG_RESULT(&big2);
 	    }
 
@@ -7765,21 +7786,27 @@ ExecuteExtendedBinaryMathOp(
 	}
 	Tcl_GetBignumFromObj(NULL, valuePtr, &big1);
 	Tcl_GetBignumFromObj(NULL, value2Ptr, &big2);
-	mp_init(&bigResult);
-	mp_init(&bigRemainder);
-	mp_div(&big1, &big2, &bigResult, &bigRemainder);
-	if (!mp_iszero(&bigRemainder) && (bigRemainder.sign != big2.sign)) {
+	err = mp_init_multi(&bigResult, &bigRemainder, NULL);
+	if (err == MP_OKAY) {
+	    err = mp_div(&big1, &big2, &bigResult, &bigRemainder);
+	}
+	if ((err == MP_OKAY) && !mp_iszero(&bigRemainder) && (bigRemainder.sign != big2.sign)) {
 	    /*
 	     * Convert to Tcl's integer division rules.
 	     */
 
-	    mp_sub_d(&bigResult, 1, &bigResult);
-	    mp_add(&bigRemainder, &big2, &bigRemainder);
+	    if ((mp_sub_d(&bigResult, 1, &bigResult) != MP_OKAY)
+		    || (mp_add(&bigRemainder, &big2, &bigRemainder) != MP_OKAY)) {
+		return OUT_OF_MEMORY;
+	    }
 	}
-	mp_copy(&bigRemainder, &bigResult);
+	err = mp_copy(&bigRemainder, &bigResult);
 	mp_clear(&bigRemainder);
 	mp_clear(&big1);
 	mp_clear(&big2);
+	if (err != MP_OKAY) {
+	    return OUT_OF_MEMORY;
+	}
 	BIG_RESULT(&bigResult);
 
     case INST_LSHIFT:
@@ -7905,11 +7932,16 @@ ExecuteExtendedBinaryMathOp(
 
 	Tcl_TakeBignumFromObj(NULL, valuePtr, &big1);
 
-	mp_init(&bigResult);
-	if (opcode == INST_LSHIFT) {
-	    mp_mul_2d(&big1, shift, &bigResult);
-	} else {
-	    mp_signed_rsh(&big1, shift, &bigResult);
+	err = mp_init(&bigResult);
+	if (err == MP_OKAY) {
+	    if (opcode == INST_LSHIFT) {
+		err = mp_mul_2d(&big1, shift, &bigResult);
+	    } else {
+		err = mp_signed_rsh(&big1, shift, &bigResult);
+	    }
+	}
+	if (err != MP_OKAY) {
+	    return OUT_OF_MEMORY;
 	}
 	mp_clear(&big1);
 	BIG_RESULT(&bigResult);
@@ -7922,20 +7954,25 @@ ExecuteExtendedBinaryMathOp(
 	    Tcl_TakeBignumFromObj(NULL, valuePtr, &big1);
 	    Tcl_TakeBignumFromObj(NULL, value2Ptr, &big2);
 
-	    mp_init(&bigResult);
+	    err = mp_init(&bigResult);
 
-	    switch (opcode) {
-	    case INST_BITAND:
-		mp_and(&big1, &big2, &bigResult);
-		break;
+	    if (err == MP_OKAY) {
+		switch (opcode) {
+		case INST_BITAND:
+		    err = mp_and(&big1, &big2, &bigResult);
+		    break;
 
-	    case INST_BITOR:
-		mp_or(&big1, &big2, &bigResult);
-		break;
+		case INST_BITOR:
+		    err = mp_or(&big1, &big2, &bigResult);
+		    break;
 
-	    case INST_BITXOR:
-		mp_xor(&big1, &big2, &bigResult);
-		break;
+		case INST_BITXOR:
+		    err = mp_xor(&big1, &big2, &bigResult);
+		    break;
+		}
+	    }
+	    if (err != MP_OKAY) {
+		return OUT_OF_MEMORY;
 	    }
 
 	    mp_clear(&big1);
@@ -7998,8 +8035,8 @@ ExecuteExtendedBinaryMathOp(
 	} else {
 	    Tcl_TakeBignumFromObj(NULL, value2Ptr, &big2);
 	    negativeExponent = mp_isneg(&big2);
-	    mp_mod_2d(&big2, 1, &big2);
-	    oddExponent = !mp_iszero(&big2);
+	    err = mp_mod_2d(&big2, 1, &big2);
+	    oddExponent = (err == MP_OKAY) && !mp_iszero(&big2);
 	    mp_clear(&big2);
 	}
 
@@ -8156,8 +8193,13 @@ ExecuteExtendedBinaryMathOp(
 	    return GENERAL_ARITHMETIC_ERROR;
 	}
 	Tcl_TakeBignumFromObj(NULL, valuePtr, &big1);
-	mp_init(&bigResult);
-	mp_expt_u32(&big1, (unsigned int)w2, &bigResult);
+	err = mp_init(&bigResult);
+	if (err == MP_OKAY) {
+	    err = mp_expt_u32(&big1, (unsigned int)w2, &bigResult);
+	}
+	if (err != MP_OKAY) {
+	    return OUT_OF_MEMORY;
+	}
 	mp_clear(&big1);
 	BIG_RESULT(&bigResult);
     }
@@ -8304,38 +8346,44 @@ ExecuteExtendedBinaryMathOp(
     overflowBasic:
 	Tcl_TakeBignumFromObj(NULL, valuePtr, &big1);
 	Tcl_TakeBignumFromObj(NULL, value2Ptr, &big2);
-	mp_init(&bigResult);
+	err = mp_init(&bigResult);
+	if (err == MP_OKAY) {
 	switch (opcode) {
 	case INST_ADD:
-	    mp_add(&big1, &big2, &bigResult);
-	    break;
+		err = mp_add(&big1, &big2, &bigResult);
+		break;
 	case INST_SUB:
-	    mp_sub(&big1, &big2, &bigResult);
-	    break;
+		err = mp_sub(&big1, &big2, &bigResult);
+		break;
 	case INST_MULT:
-	    mp_mul(&big1, &big2, &bigResult);
-	    break;
+		err = mp_mul(&big1, &big2, &bigResult);
+		break;
 	case INST_DIV:
-	    if (mp_iszero(&big2)) {
-		mp_clear(&big1);
-		mp_clear(&big2);
-		mp_clear(&bigResult);
-		return DIVIDED_BY_ZERO;
-	    }
-	    mp_init(&bigRemainder);
-	    mp_div(&big1, &big2, &bigResult, &bigRemainder);
-	    /* TODO: internals intrusion */
-	    if (!mp_iszero(&bigRemainder)
-		    && (bigRemainder.sign != big2.sign)) {
-		/*
-		 * Convert to Tcl's integer division rules.
-		 */
+		if (mp_iszero(&big2)) {
+		    mp_clear(&big1);
+		    mp_clear(&big2);
+		    mp_clear(&bigResult);
+		    return DIVIDED_BY_ZERO;
+		}
+		err = mp_init(&bigRemainder);
+		if (err == MP_OKAY) {
+		    err = mp_div(&big1, &big2, &bigResult, &bigRemainder);
+		}
+		/* TODO: internals intrusion */
+		if (!mp_iszero(&bigRemainder)
+			&& (bigRemainder.sign != big2.sign)) {
+		    /*
+		     * Convert to Tcl's integer division rules.
+		     */
 
-		mp_sub_d(&bigResult, 1, &bigResult);
-		mp_add(&bigRemainder, &big2, &bigRemainder);
+		    err = mp_sub_d(&bigResult, 1, &bigResult);
+		    if (err == MP_OKAY) {
+			err = mp_add(&bigRemainder, &big2, &bigRemainder);
+		    }
+		}
+		mp_clear(&bigRemainder);
+		break;
 	    }
-	    mp_clear(&bigRemainder);
-	    break;
 	}
 	mp_clear(&big1);
 	mp_clear(&big2);
@@ -8356,6 +8404,7 @@ ExecuteExtendedUnaryMathOp(
     Tcl_WideInt w;
     mp_int big;
     Tcl_Obj *objResultPtr;
+    mp_err err = MP_OKAY;
 
     (void) GetNumberFromObj(NULL, valuePtr, &ptr, &type);
 
@@ -8367,8 +8416,13 @@ ExecuteExtendedUnaryMathOp(
 	}
 	Tcl_TakeBignumFromObj(NULL, valuePtr, &big);
 	/* ~a = - a - 1 */
-	(void)mp_neg(&big, &big);
-	mp_sub_d(&big, 1, &big);
+	err = mp_neg(&big, &big);
+	if (err == MP_OKAY) {
+	    err = mp_sub_d(&big, 1, &big);
+	}
+	if (err != MP_OKAY) {
+	    return OUT_OF_MEMORY;
+	}
 	BIG_RESULT(&big);
     case INST_UMINUS:
 	switch (type) {
@@ -8379,12 +8433,18 @@ ExecuteExtendedUnaryMathOp(
 	    if (w != WIDE_MIN) {
 		WIDE_RESULT(-w);
 	    }
-	    mp_init_i64(&big, w);
+	    err = mp_init_i64(&big, w);
+	    if (err != MP_OKAY) {
+		return OUT_OF_MEMORY;
+	    }
 	    break;
 	default:
 	    Tcl_TakeBignumFromObj(NULL, valuePtr, &big);
 	}
-	(void)mp_neg(&big, &big);
+	err = mp_neg(&big, &big);
+	if (err != MP_OKAY) {
+	    return OUT_OF_MEMORY;
+	}
 	BIG_RESULT(&big);
     }
 
diff --git a/generic/tclObj.c b/generic/tclObj.c
index b27260a..58bc480 100644
--- a/generic/tclObj.c
+++ b/generic/tclObj.c
@@ -182,10 +182,7 @@ static Tcl_ThreadDataKey pendingObjDataKey;
 	*temp = bignum;                                                 \
 	(objPtr)->internalRep.twoPtrValue.ptr1 = temp;                 \
 	(objPtr)->internalRep.twoPtrValue.ptr2 = INT2PTR(-1); \
-    } else {                                                            \
-	if ((bignum).alloc > 0x7fff) {                                  \
-	    mp_shrink(&(bignum));                                       \
-	}                                                               \
+    } else if (((bignum).alloc <= 0x7fff) || (mp_shrink(&(bignum))) == MP_OKAY) { \
 	(objPtr)->internalRep.twoPtrValue.ptr1 = (bignum).dp;           \
 	(objPtr)->internalRep.twoPtrValue.ptr2 = INT2PTR( ((bignum).sign << 30) \
 		| ((bignum).alloc << 15) | ((bignum).used));            \
@@ -2890,14 +2887,20 @@ TclGetWideBitsFromObj(
 	}
 	if (objPtr->typePtr == &tclBignumType) {
 	    mp_int big;
+	    mp_err err;
 
 	    Tcl_WideUInt value = 0, scratch;
 	    size_t numBytes;
 	    unsigned char *bytes = (unsigned char *) &scratch;
 
 	    Tcl_GetBignumFromObj(NULL, objPtr, &big);
-	    mp_mod_2d(&big, (int) (CHAR_BIT * sizeof(Tcl_WideInt)), &big);
-	    mp_to_ubin(&big, bytes, sizeof(Tcl_WideInt), &numBytes);
+	    err = mp_mod_2d(&big, (int) (CHAR_BIT * sizeof(Tcl_WideInt)), &big);
+	    if (err == MP_OKAY) {
+		err = mp_to_ubin(&big, bytes, sizeof(Tcl_WideInt), &numBytes);
+	    }
+	    if (err != MP_OKAY) {
+		return TCL_ERROR;
+	    }
 	    while (numBytes-- > 0) {
 		value = (value << CHAR_BIT) | *bytes++;
 	    }
@@ -3137,7 +3140,9 @@ GetBignumFromObj(
 		mp_int temp;
 
 		TclUnpackBignum(objPtr, temp);
-		mp_init_copy(bignumValue, &temp);
+		if (mp_init_copy(bignumValue, &temp) != MP_OKAY) {
+		    return TCL_ERROR;
+		}
 	    } else {
 		TclUnpackBignum(objPtr, *bignumValue);
 		/* Optimized TclFreeIntRep */
@@ -3156,8 +3161,10 @@ GetBignumFromObj(
 	    return TCL_OK;
 	}
 	if (objPtr->typePtr == &tclIntType) {
-	    mp_init_i64(bignumValue,
-		    objPtr->internalRep.wideValue);
+	    if (mp_init_i64(bignumValue,
+		    objPtr->internalRep.wideValue) != MP_OKAY) {
+		return TCL_ERROR;
+	    }
 	    return TCL_OK;
 	}
 	if (objPtr->typePtr == &tclDoubleType) {
diff --git a/generic/tclStrToD.c b/generic/tclStrToD.c
index e0c9f15..7ef1c8c 100644
--- a/generic/tclStrToD.c
+++ b/generic/tclStrToD.c
@@ -303,7 +303,7 @@ static double		MakeNaN(int signum, Tcl_WideUInt tag);
 #endif
 static double		RefineApproximation(double approx,
 			    mp_int *exactSignificand, int exponent);
-static void		MulPow5(mp_int *, unsigned, mp_int *);
+static mp_err	MulPow5(mp_int *, unsigned, mp_int *) MP_WUR;
 static int 		NormalizeRightward(Tcl_WideUInt *);
 static int		RequiredPrecision(Tcl_WideUInt);
 static void		DoubleToExpAndSig(double, Tcl_WideUInt *, int *,
@@ -533,6 +533,7 @@ TclParseNumber(
     char d = 0;			/* Last hexadecimal digit scanned; initialized
 				 * to avoid a compiler warning. */
     int shift = 0;		/* Amount to shift when accumulating binary */
+    mp_err err = MP_OKAY;
 
 #define ALL_BITS	((Tcl_WideUInt)-1)
 #define MOST_BITS	(ALL_BITS >> 1)
@@ -711,7 +712,7 @@ TclParseNumber(
 				|| (octalSignificandWide >
 					((Tcl_WideUInt)-1 >> shift)))) {
 			    octalSignificandOverflow = 1;
-			    mp_init_u64(&octalSignificandBig,
+			    err = mp_init_u64(&octalSignificandBig,
 				    octalSignificandWide);
 			}
 		    }
@@ -719,10 +720,17 @@ TclParseNumber(
 			octalSignificandWide =
 				(octalSignificandWide << shift) + (c - '0');
 		    } else {
-			mp_mul_2d(&octalSignificandBig, shift,
-				&octalSignificandBig);
-			mp_add_d(&octalSignificandBig, (mp_digit)(c - '0'),
-				&octalSignificandBig);
+			if (err == MP_OKAY) {
+			    err = mp_mul_2d(&octalSignificandBig, shift,
+				    &octalSignificandBig);
+			}
+			if (err == MP_OKAY) {
+			    err = mp_add_d(&octalSignificandBig, (mp_digit)(c - '0'),
+				    &octalSignificandBig);
+			}
+		    }
+		    if (err != MP_OKAY) {
+			return TCL_ERROR;
 		    }
 		}
 		if (numSigDigs != 0) {
@@ -776,17 +784,22 @@ TclParseNumber(
 			    ((size_t)shift >= CHAR_BIT*sizeof(Tcl_WideUInt) ||
 			    significandWide > ((Tcl_WideUInt)-1 >> shift))) {
 			significandOverflow = 1;
-			mp_init_u64(&significandBig,
+			err = mp_init_u64(&significandBig,
 				significandWide);
 		    }
 		}
 		if (!significandOverflow) {
 		    significandWide = (significandWide << shift) + d;
-		} else {
-		    mp_mul_2d(&significandBig, shift, &significandBig);
-		    mp_add_d(&significandBig, (mp_digit) d, &significandBig);
+		} else if (err == MP_OKAY) {
+		    err = mp_mul_2d(&significandBig, shift, &significandBig);
+		    if (err == MP_OKAY) {
+			err = mp_add_d(&significandBig, (mp_digit) d, &significandBig);
+		    }
 		}
 	    }
+	    if (err != MP_OKAY) {
+		return TCL_ERROR;
+	    }
 	    numTrailZeros = 0;
 	    state = HEXADECIMAL;
 	    break;
@@ -818,17 +831,22 @@ TclParseNumber(
 			    ((size_t)shift >= CHAR_BIT*sizeof(Tcl_WideUInt) ||
 			    significandWide > ((Tcl_WideUInt)-1 >> shift))) {
 			significandOverflow = 1;
-			mp_init_u64(&significandBig,
+			err = mp_init_u64(&significandBig,
 				significandWide);
 		    }
 		}
 		if (!significandOverflow) {
 		    significandWide = (significandWide << shift) + 1;
-		} else {
-		    mp_mul_2d(&significandBig, shift, &significandBig);
-		    mp_add_d(&significandBig, (mp_digit) 1, &significandBig);
+		} else if (err == MP_OKAY) {
+		    err = mp_mul_2d(&significandBig, shift, &significandBig);
+		    if (err == MP_OKAY) {
+			err = mp_add_d(&significandBig, (mp_digit) 1, &significandBig);
+		    }
 		}
 	    }
+	    if (err != MP_OKAY) {
+		return TCL_ERROR;
+	    }
 	    numTrailZeros = 0;
 	    state = BINARY;
 	    break;
@@ -1160,15 +1178,18 @@ TclParseNumber(
 		    ((size_t)shift >= CHAR_BIT*sizeof(Tcl_WideUInt) ||
 		    significandWide > (MOST_BITS + signum) >> shift)) {
 		significandOverflow = 1;
-		mp_init_u64(&significandBig, significandWide);
+		err = mp_init_u64(&significandBig, significandWide);
 	    }
 	    if (shift) {
 		if (!significandOverflow) {
 		    significandWide <<= shift;
-		} else {
-		    mp_mul_2d(&significandBig, shift, &significandBig);
+		} else if (err == MP_OKAY) {
+		    err = mp_mul_2d(&significandBig, shift, &significandBig);
 		}
 	    }
+	    if (err != MP_OKAY) {
+		return TCL_ERROR;
+	    }
 	    goto returnInteger;
 
 	case HEXADECIMAL:
@@ -1181,15 +1202,18 @@ TclParseNumber(
 		    ((size_t)shift >= CHAR_BIT*sizeof(Tcl_WideUInt) ||
 		    significandWide > (MOST_BITS + signum) >> shift)) {
 		significandOverflow = 1;
-		mp_init_u64(&significandBig, significandWide);
+		err = mp_init_u64(&significandBig, significandWide);
 	    }
 	    if (shift) {
 		if (!significandOverflow) {
 		    significandWide <<= shift;
-		} else {
-		    mp_mul_2d(&significandBig, shift, &significandBig);
+		} else if (err == MP_OKAY) {
+		    err = mp_mul_2d(&significandBig, shift, &significandBig);
 		}
 	    }
+	    if (err != MP_OKAY) {
+		return TCL_ERROR;
+	    }
 	    goto returnInteger;
 
 	case OCTAL:
@@ -1202,20 +1226,20 @@ TclParseNumber(
 		    ((size_t)shift >= CHAR_BIT*sizeof(Tcl_WideUInt) ||
 		    octalSignificandWide > (MOST_BITS + signum) >> shift)) {
 		octalSignificandOverflow = 1;
-		mp_init_u64(&octalSignificandBig,
+		err = mp_init_u64(&octalSignificandBig,
 			octalSignificandWide);
 	    }
 	    if (shift) {
 		if (!octalSignificandOverflow) {
 		    octalSignificandWide <<= shift;
-		} else {
-		    mp_mul_2d(&octalSignificandBig, shift,
+		} else if (err == MP_OKAY) {
+		    err = mp_mul_2d(&octalSignificandBig, shift,
 			    &octalSignificandBig);
 		}
 	    }
 	    if (!octalSignificandOverflow) {
-		if (octalSignificandWide > (MOST_BITS + signum)) {
-		    mp_init_u64(&octalSignificandBig,
+		if ((err == MP_OKAY) && (octalSignificandWide > (MOST_BITS + signum))) {
+		    err = mp_init_u64(&octalSignificandBig,
 			    octalSignificandWide);
 		    octalSignificandOverflow = 1;
 		} else {
@@ -1229,26 +1253,29 @@ TclParseNumber(
 		    }
 		}
 	    }
-	    if (octalSignificandOverflow) {
+	    if ((err == MP_OKAY) && octalSignificandOverflow) {
 		if (signum) {
-		    (void)mp_neg(&octalSignificandBig, &octalSignificandBig);
+		    err = mp_neg(&octalSignificandBig, &octalSignificandBig);
 		}
 		TclSetBignumIntRep(objPtr, &octalSignificandBig);
 	    }
+	    if (err != MP_OKAY) {
+		return TCL_ERROR;
+	    }
 	    break;
 
 	case ZERO:
 	case DECIMAL:
 	    significandOverflow = AccumulateDecimalDigit(0, numTrailZeros-1,
 		    &significandWide, &significandBig, significandOverflow);
-	    if (!significandOverflow && (significandWide > MOST_BITS+signum)) {
+	    if ((err == MP_OKAY) && !significandOverflow && (significandWide > MOST_BITS+signum)) {
 		significandOverflow = 1;
-		mp_init_u64(&significandBig, significandWide);
+		err = mp_init_u64(&significandBig, significandWide);
 	    }
 	returnInteger:
 	    if (!significandOverflow) {
-		if (significandWide > MOST_BITS+signum) {
-		    mp_init_u64(&significandBig,
+		if ((err == MP_OKAY) && (significandWide > MOST_BITS+signum)) {
+		    err = mp_init_u64(&significandBig,
 			    significandWide);
 		    significandOverflow = 1;
 		} else {
@@ -1262,12 +1289,15 @@ TclParseNumber(
 		    }
 		}
 	    }
-	    if (significandOverflow) {
+	    if ((err == MP_OKAY) && significandOverflow) {
 		if (signum) {
-		    (void)mp_neg(&significandBig, &significandBig);
+		    err = mp_neg(&significandBig, &significandBig);
 		}
 		TclSetBignumIntRep(objPtr, &significandBig);
 	    }
+	    if (err != MP_OKAY) {
+		return TCL_ERROR;
+	    }
 	    break;
 
 	case FRACTION:
@@ -1429,7 +1459,9 @@ AccumulateDecimalDigit(
 	     * bignum and fall through into the bignum case.
 	     */
 
-	    mp_init_u64(bignumRepPtr, w);
+	    if (mp_init_u64(bignumRepPtr, w) != MP_OKAY) {
+		return 0;
+	    }
 	} else {
 	    /*
 	     * Wide multiplication.
@@ -1449,10 +1481,12 @@ AccumulateDecimalDigit(
 	 * Up to about 8 zeros - single digit multiplication.
 	 */
 
-	mp_mul_d(bignumRepPtr, (mp_digit) pow10_wide[numZeros+1],
-		bignumRepPtr);
-	mp_add_d(bignumRepPtr, (mp_digit) digit, bignumRepPtr);
+	if ((mp_mul_d(bignumRepPtr, (mp_digit) pow10_wide[numZeros+1],
+		bignumRepPtr) != MP_OKAY)
+		|| (mp_add_d(bignumRepPtr, (mp_digit) digit, bignumRepPtr) != MP_OKAY))
+	return 0;
     } else {
+	mp_err err;
 	/*
 	 * More than single digit multiplication. Multiply by the appropriate
 	 * small powers of 5, and then shift. Large strings of zeroes are
@@ -1463,18 +1497,21 @@ AccumulateDecimalDigit(
 	 */
 
 	n = numZeros + 1;
-	mp_mul_d(bignumRepPtr, (mp_digit) pow10_wide[n&0x7], bignumRepPtr);
-	for (i=3; i<=7; ++i) {
+	err = mp_mul_d(bignumRepPtr, (mp_digit) pow10_wide[n&0x7], bignumRepPtr);
+	for (i = 3; (err == MP_OKAY) && (i <= 7); ++i) {
 	    if (n & (1 << i)) {
-		mp_mul(bignumRepPtr, pow5+i, bignumRepPtr);
+		err = mp_mul(bignumRepPtr, pow5+i, bignumRepPtr);
 	    }
 	}
-	while (n >= 256) {
-	    mp_mul(bignumRepPtr, pow5+8, bignumRepPtr);
+	while ((err == MP_OKAY) && (n >= 256)) {
+	    err = mp_mul(bignumRepPtr, pow5+8, bignumRepPtr);
 	    n -= 256;
 	}
-	mp_mul_2d(bignumRepPtr, (int)(numZeros+1)&~0x7, bignumRepPtr);
-	mp_add_d(bignumRepPtr, (mp_digit) digit, bignumRepPtr);
+	if ((err != MP_OKAY)
+		|| (mp_mul_2d(bignumRepPtr, (int)(numZeros+1)&~0x7, bignumRepPtr) != MP_OKAY)
+		|| (mp_add_d(bignumRepPtr, (mp_digit) digit, bignumRepPtr) != MP_OKAY)) {
+	    return 0;
+	}
     }
 
     return 1;
@@ -1575,7 +1612,9 @@ MakeLowPrecisionDouble(
      * call MakeHighPrecisionDouble to do it the hard way.
      */
 
-    mp_init_u64(&significandBig, significand);
+    if (mp_init_u64(&significandBig, significand) != MP_OKAY) {
+	return 0.0;
+    }
     retval = MakeHighPrecisionDouble(0, &significandBig, numSigDigs,
 	    exponent);
     mp_clear(&significandBig);
@@ -1624,7 +1663,7 @@ MakeHighPrecisionDouble(
     long exponent)		/* Power of 10 by which to multiply */
 {
     double retval;
-    int machexp;		/* Machine exponent of a power of 10. */
+    int machexp = 0;		/* Machine exponent of a power of 10. */
 
     /*
      * With gcc on x86, the floating point rounding mode is double-extended.
@@ -1789,6 +1828,7 @@ RefineApproximation(
     Tcl_WideInt rteSigWide;	/* Wide integer version of the significand
 				 * for testing evenness */
     int i;
+    mp_err err = MP_OKAY;
 
     /*
      * The first approximation is always low. If we find that it's HUGE_VAL,
@@ -1837,7 +1877,9 @@ RefineApproximation(
 
     msb = binExponent + M2;	/* 1008 */
     nDigits = msb / MP_DIGIT_BIT + 1;
-    mp_init_size(&twoMv, nDigits);
+    if (mp_init_size(&twoMv, nDigits) != MP_OKAY) {
+	return approxResult;
+    }
     i = (msb % MP_DIGIT_BIT + 1);
     twoMv.used = nDigits;
     significand *= SafeLdExp(1.0, i);
@@ -1847,8 +1889,9 @@ RefineApproximation(
 	significand = SafeLdExp(significand, MP_DIGIT_BIT);
     }
     for (i = 0; i <= 8; ++i) {
-	if (M5 & (1 << i)) {
-	    mp_mul(&twoMv, pow5+i, &twoMv);
+	if (M5 & (1 << i) && (mp_mul(&twoMv, pow5+i, &twoMv) != MP_OKAY)) {
+	    mp_clear(&twoMv);
+	    return approxResult;
 	}
     }
 
@@ -1858,20 +1901,27 @@ RefineApproximation(
      * by 2**(M5+exponent+1), which is, of couse, a left shift.
      */
 
-    mp_init_copy(&twoMd, exactSignificand);
-    for (i=0; i<=8; ++i) {
+    if (mp_init_copy(&twoMd, exactSignificand) != MP_OKAY) {
+	mp_clear(&twoMv);
+	return approxResult;
+    }
+    for (i = 0; (i <= 8); ++i) {
 	if ((M5 + exponent) & (1 << i)) {
-	    mp_mul(&twoMd, pow5+i, &twoMd);
+	    err = mp_mul(&twoMd, pow5+i, &twoMd);
 	}
     }
-    mp_mul_2d(&twoMd, M2+exponent+1, &twoMd);
+    if (err == MP_OKAY) {
+	err = mp_mul_2d(&twoMd, M2+exponent+1, &twoMd);
+    }
 
     /*
      * Now let twoMd = twoMd - twoMv, the difference between the exact and
      * approximate values.
      */
 
-    mp_sub(&twoMd, &twoMv, &twoMd);
+    if (err == MP_OKAY) {
+	err = mp_sub(&twoMd, &twoMv, &twoMd);
+    }
 
     /*
      * The result, 2Mv-2Md, needs to be divided by 2M to yield a correction
@@ -1882,16 +1932,25 @@ RefineApproximation(
 
     scale = binExponent - mantBits - 1;
     mp_set_u64(&twoMv, 1);
-    for (i=0; i<=8; ++i) {
+    for (i = 0; (i <= 8) && (err == MP_OKAY); ++i) {
 	if (M5 & (1 << i)) {
-	    mp_mul(&twoMv, pow5+i, &twoMv);
+	    err = mp_mul(&twoMv, pow5+i, &twoMv);
 	}
     }
     multiplier = M2 + scale + 1;
-    if (multiplier > 0) {
-	mp_mul_2d(&twoMv, multiplier, &twoMv);
+    if (err != MP_OKAY) {
+	mp_clear(&twoMd);
+	mp_clear(&twoMv);
+	return approxResult;
+    } else if (multiplier > 0) {
+	err = mp_mul_2d(&twoMv, multiplier, &twoMv);
     } else if (multiplier < 0) {
-	mp_div_2d(&twoMv, -multiplier, &twoMv, NULL);
+	err = mp_div_2d(&twoMv, -multiplier, &twoMv, NULL);
+    }
+    if (err != MP_OKAY) {
+	mp_clear(&twoMd);
+	mp_clear(&twoMv);
+	return approxResult;
     }
 
     /*
@@ -1940,8 +1999,15 @@ RefineApproximation(
      */
     shift = mp_count_bits(&twoMv) - FP_PRECISION - 1;
     if (shift > 0) {
-	mp_div_2d(&twoMv, shift, &twoMv, NULL);
-	mp_div_2d(&twoMd, shift, &twoMd, NULL);
+	err = mp_div_2d(&twoMv, shift, &twoMv, NULL);
+	if (err == MP_OKAY) {
+	    err = mp_div_2d(&twoMd, shift, &twoMd, NULL);
+	}
+    }
+    if (err != MP_OKAY) {
+	mp_clear(&twoMd);
+	mp_clear(&twoMv);
+	return approxResult;
     }
 
     /*
@@ -1980,7 +2046,7 @@ RefineApproximation(
  *----------------------------------------------------------------------
  */
 
-static inline void
+static inline mp_err
 MulPow5(
     mp_int *base, 		/* Number to multiply. */
     unsigned n,			/* Power of 5 to multiply by. */
@@ -1989,23 +2055,25 @@ MulPow5(
     mp_int *p = base;
     int n13 = n / 13;
     int r = n % 13;
+    mp_err err = MP_OKAY;
 
     if (r != 0) {
-	mp_mul_d(p, dpow5[r], result);
+	err = mp_mul_d(p, dpow5[r], result);
 	p = result;
     }
     r = 0;
-    while (n13 != 0) {
+    while ((err == MP_OKAY) && (n13 != 0)) {
 	if (n13 & 1) {
-	    mp_mul(p, pow5_13+r, result);
+	    err = mp_mul(p, pow5_13+r, result);
 	    p = result;
 	}
 	n13 >>= 1;
 	++r;
     }
-    if (p != result) {
-	mp_copy(p, result);
+    if ((err == MP_OKAY) && (p != result)) {
+	err = mp_copy(p, result);
     }
+    return err;
 }
 
 /*
@@ -3205,8 +3273,7 @@ ShouldBankerRoundUpToNextPowD(
      * 2**(MP_DIGIT_BIT*sd)
      */
 
-    mp_add(b, m, temp);
-    if (temp->used <= sd) {	/* Too few digits to be > s */
+    if ((mp_add(b, m, temp) != MP_OKAY) || (temp->used <= sd)) {	/* Too few digits to be > s */
 	return 0;
     }
     if (temp->used > sd+1 || temp->dp[sd] > 1) {
@@ -3274,23 +3341,31 @@ ShorteningBignumConversionPowD(
     int i;			/* Index in the output buffer. */
     mp_int temp;
     int r1;
+    mp_err err = MP_OKAY;
 
     /*
      * b = bw * 2**b2 * 5**b5
      * mminus = 5**m5
      */
 
-    mp_init_u64(&b, bw);
-    mp_init_set(&mminus, 1);
-    MulPow5(&b, b5, &b);
-    mp_mul_2d(&b, b2, &b);
+    if ((retval == NULL) || (mp_init_u64(&b, bw) != MP_OKAY)) {
+	return NULL;
+    }
+    if (mp_init_set(&mminus, 1) != MP_OKAY) {
+	mp_clear(&b);
+	return NULL;
+    }
+    err = MulPow5(&b, b5, &b);
+    if (err == MP_OKAY) {
+	err = mp_mul_2d(&b, b2, &b);
+    }
 
     /*
      * Adjust if the logarithm was guessed wrong.
      */
 
-    if (b.used <= sd) {
-	mp_mul_d(&b, 10, &b);
+    if ((err == MP_OKAY) && (b.used <= sd)) {
+	err = mp_mul_d(&b, 10, &b);
 	++m2plus; ++m2minus; ++m5;
 	ilim = ilim1;
 	--k;
@@ -3301,13 +3376,21 @@ ShorteningBignumConversionPowD(
      * mplus = 5**m5 * 2**m2plus
      */
 
-    mp_mul_2d(&mminus, m2minus, &mminus);
-    MulPow5(&mminus, m5, &mminus);
-    if (m2plus > m2minus) {
-	mp_init_copy(&mplus, &mminus);
-	mp_mul_2d(&mplus, m2plus-m2minus, &mplus);
+    if (err == MP_OKAY) {
+	err = mp_mul_2d(&mminus, m2minus, &mminus);
+    }
+    if (err == MP_OKAY) {
+	err = MulPow5(&mminus, m5, &mminus);
+    }
+    if ((err == MP_OKAY) && (m2plus > m2minus)) {
+	err = mp_init_copy(&mplus, &mminus);
+	if (err == MP_OKAY) {
+	    err = mp_mul_2d(&mplus, m2plus-m2minus, &mplus);
+	}
+    }
+    if (err == MP_OKAY) {
+	err = mp_init(&temp);
     }
-    mp_init(&temp);
 
     /*
      * Loop through the digits. Do division and mod by s == 2**(sd*MP_DIGIT_BIT)
@@ -3389,10 +3472,14 @@ ShorteningBignumConversionPowD(
 	 * Advance to the next digit.
 	 */
 
-	mp_mul_d(&b, 10, &b);
-	mp_mul_d(&mminus, 10, &mminus);
-	if (m2plus > m2minus) {
-	    mp_mul_2d(&mminus, m2plus-m2minus, &mplus);
+	if (err == MP_OKAY) {
+	    err = mp_mul_d(&b, 10, &b);
+	}
+	if (err == MP_OKAY) {
+	    err = mp_mul_d(&mminus, 10, &mminus);
+	}
+	if ((err == MP_OKAY) && (m2plus > m2minus)) {
+	    err = mp_mul_2d(&mminus, m2plus-m2minus, &mplus);
 	}
 	++i;
     }
@@ -3411,7 +3498,7 @@ ShorteningBignumConversionPowD(
     if (endPtr) {
 	*endPtr = s;
     }
-    return retval;
+    return (err == MP_OKAY) ? retval : NULL;
 }
 
 /*
@@ -3459,21 +3546,26 @@ StrictBignumConversionPowD(
     mp_digit digit;		/* Current output digit. */
     char *s = retval;		/* Cursor in the output buffer. */
     int i;			/* Index in the output buffer. */
+    mp_err err;
 
     /*
      * b = bw * 2**b2 * 5**b5
      */
 
-    mp_init_u64(&b, bw);
-    MulPow5(&b, b5, &b);
-    mp_mul_2d(&b, b2, &b);
+    if (mp_init_u64(&b, bw) != MP_OKAY) {
+	return NULL;
+    }
+    err = MulPow5(&b, b5, &b);
+    if (err == MP_OKAY) {
+	err = mp_mul_2d(&b, b2, &b);
+    }
 
     /*
      * Adjust if the logarithm was guessed wrong.
      */
 
-    if (b.used <= sd) {
-	mp_mul_d(&b, 10, &b);
+    if ((err == MP_OKAY) && (b.used <= sd)) {
+	err = mp_mul_d(&b, 10, &b);
 	ilim = ilim1;
 	--k;
     }
@@ -3484,7 +3576,7 @@ StrictBignumConversionPowD(
      */
 
     i = 1;
-    for (;;) {
+    while (err == MP_OKAY) {
 	if (b.used <= sd) {
 	    digit = 0;
 	} else {
@@ -3516,7 +3608,7 @@ StrictBignumConversionPowD(
 	 * Advance to the next digit.
 	 */
 
-	mp_mul_d(&b, 10, &b);
+	err = mp_mul_d(&b, 10, &b);
 	++i;
     }
 
@@ -3598,8 +3690,9 @@ ShouldBankerRoundUpToNext(
      * Compare b and S-m: this is the same as comparing B+m and S.
      */
 
-    mp_init(&temp);
-    mp_add(b, m, &temp);
+    if ((mp_init(&temp) != MP_OKAY) || (mp_add(b, m, &temp) != MP_OKAY)) {
+	return 0;
+    }
     r = mp_cmp_mag(&temp, S);
     mp_clear(&temp);
     switch(r) {
@@ -3658,23 +3751,33 @@ ShorteningBignumConversion(
     int minit = 1;		/* Fudge factor for when we misguess k. */
     int i;
     int r1;
+    mp_err err;
 
     /*
      * b = bw * 2**b2 * 5**b5
      * S = 2**s2 * 5*s5
      */
 
-    mp_init_u64(&b, bw);
-    mp_mul_2d(&b, b2, &b);
-    mp_init_set(&S, 1);
-    MulPow5(&S, s5, &S); mp_mul_2d(&S, s2, &S);
+    if ((retval == NULL) || (mp_init_u64(&b, bw) != MP_OKAY)) {
+	return NULL;
+    }
+    err = mp_mul_2d(&b, b2, &b);
+    if (err == MP_OKAY) {
+	err = mp_init_set(&S, 1);
+    }
+    if (err == MP_OKAY) {
+	err = MulPow5(&S, s5, &S);
+    }
+    if (err == MP_OKAY) {
+	err = mp_mul_2d(&S, s2, &S);
+    }
 
     /*
      * Handle the case where we guess the position of the decimal point wrong.
      */
 
-    if (mp_cmp_mag(&b, &S) == MP_LT) {
-	mp_mul_d(&b, 10, &b);
+    if ((err == MP_OKAY) && (mp_cmp_mag(&b, &S) == MP_LT)) {
+	err = mp_mul_d(&b, 10, &b);
 	minit = 10;
 	ilim =ilim1;
 	--k;
@@ -3684,21 +3787,29 @@ ShorteningBignumConversion(
      * mminus = 2**m2minus * 5**m5
      */
 
-    mp_init_set(&mminus, minit);
-    mp_mul_2d(&mminus, m2minus, &mminus);
-    if (m2plus > m2minus) {
-	mp_init_copy(&mplus, &mminus);
-	mp_mul_2d(&mplus, m2plus-m2minus, &mplus);
+    if (err == MP_OKAY) {
+	err = mp_init_set(&mminus, minit);
+    }
+    if (err == MP_OKAY) {
+	err = mp_mul_2d(&mminus, m2minus, &mminus);
+    }
+    if ((err == MP_OKAY) && (m2plus > m2minus)) {
+	err = mp_init_copy(&mplus, &mminus);
+	if (err == MP_OKAY) {
+	    err = mp_mul_2d(&mplus, m2plus-m2minus, &mplus);
+	}
     }
 
     /*
      * Loop through the digits.
      */
 
-    mp_init(&dig);
+    if (err == MP_OKAY) {
+	err = mp_init(&dig);
+    }
     i = 1;
-    for (;;) {
-	mp_div(&b, &S, &dig, &b);
+    while (err == MP_OKAY) {
+	err = mp_div(&b, &S, &dig, &b);
 	if (dig.used > 1 || dig.dp[0] >= 10) {
 	    Tcl_Panic("wrong digit!");
 	}
@@ -3711,7 +3822,7 @@ ShorteningBignumConversion(
 
 	r1 = mp_cmp_mag(&b, (m2plus > m2minus)? &mplus : &mminus);
 	if (r1 == MP_LT || (r1 == MP_EQ && (dPtr->w.word1 & 1) == 0)) {
-	    mp_mul_2d(&b, 1, &b);
+	    err = mp_mul_2d(&b, 1, &b);
 	    if (ShouldBankerRoundUp(&b, &S, digit&1)) {
 		++digit;
 		if (digit == 10) {
@@ -3746,8 +3857,8 @@ ShorteningBignumConversion(
 	 */
 
 	*s++ = '0' + digit;
-	if (i == ilim) {
-	    mp_mul_2d(&b, 1, &b);
+	if ((err == MP_OKAY) && (i == ilim)) {
+	    err = mp_mul_2d(&b, 1, &b);
 	    if (ShouldBankerRoundUp(&b, &S, digit&1)) {
 		s = BumpUp(s, retval, &k);
 	    }
@@ -3758,17 +3869,21 @@ ShorteningBignumConversion(
 	 * Advance to the next digit.
 	 */
 
-	if (s5 > 0) {
+	if ((err == MP_OKAY) && (s5 > 0)) {
 	    /*
 	     * Can possibly shorten the denominator.
 	     */
 
-	    mp_mul_2d(&b, 1, &b);
-	    mp_mul_2d(&mminus, 1, &mminus);
-	    if (m2plus > m2minus) {
-		mp_mul_2d(&mplus, 1, &mplus);
+	    err = mp_mul_2d(&b, 1, &b);
+	    if (err == MP_OKAY) {
+		err = mp_mul_2d(&mminus, 1, &mminus);
+	    }
+	    if ((err == MP_OKAY) && (m2plus > m2minus)) {
+		err = mp_mul_2d(&mplus, 1, &mplus);
+	    }
+	    if (err == MP_OKAY) {
+		err = mp_div_d(&S, 5, &S, NULL);
 	    }
-	    mp_div_d(&S, 5, &S, NULL);
 	    --s5;
 
 	    /*
@@ -3798,11 +3913,13 @@ ShorteningBignumConversion(
 	     * 10**42  16 trips
 	     * thereafter no gain.
 	     */
-	} else {
-	    mp_mul_d(&b, 10, &b);
-	    mp_mul_d(&mminus, 10, &mminus);
-	    if (m2plus > m2minus) {
-		mp_mul_2d(&mplus, 10, &mplus);
+	} else if (err == MP_OKAY) {
+	    err = mp_mul_d(&b, 10, &b);
+	    if (err == MP_OKAY) {
+		err = mp_mul_d(&mminus, 10, &mminus);
+	    }
+	    if ((err == MP_OKAY) && (m2plus > m2minus)) {
+		err = mp_mul_2d(&mplus, 10, &mplus);
 	    }
 	}
 
@@ -3866,24 +3983,36 @@ StrictBignumConversion(
     int digit;			/* Current digit of the result. */
     int g;			/* Size of the current digit ground. */
     int i, j;
+    mp_err err;
 
     /*
      * b = bw * 2**b2 * 5**b5
      * S = 2**s2 * 5*s5
      */
 
-    mp_init_multi(&dig, NULL);
-    mp_init_u64(&b, bw);
-    mp_mul_2d(&b, b2, &b);
-    mp_init_set(&S, 1);
-    MulPow5(&S, s5, &S); mp_mul_2d(&S, s2, &S);
+    if (mp_init(&dig) != MP_OKAY) {
+	return NULL;
+    }
+    if (mp_init_u64(&b, bw) != MP_OKAY) {
+	mp_clear(&dig);
+	return NULL;
+    }
+    err = mp_mul_2d(&b, b2, &b);
+    if (err == MP_OKAY) {
+ 	err = mp_init_set(&S, 1);
+    }
+    if (err == MP_OKAY) {
+	err = MulPow5(&S, s5, &S);
+	if (err == MP_OKAY) {
+	    err = mp_mul_2d(&S, s2, &S);
+	}
+    }
 
     /*
      * Handle the case where we guess the position of the decimal point wrong.
      */
 
-    if (mp_cmp_mag(&b, &S) == MP_LT) {
-	mp_mul_d(&b, 10, &b);
+    if ((mp_cmp_mag(&b, &S) == MP_LT) && (mp_mul_d(&b, 10, &b) == MP_OKAY)) {
 	ilim =ilim1;
 	--k;
     }
@@ -3893,7 +4022,7 @@ StrictBignumConversion(
      */
 
     i = 0;
-    mp_div(&b, &S, &dig, &b);
+    err = mp_div(&b, &S, &dig, &b);
     if (dig.used > 1 || dig.dp[0] >= 10) {
 	Tcl_Panic("wrong digit!");
     }
@@ -3905,12 +4034,11 @@ StrictBignumConversion(
 
     *s++ = '0' + digit;
     if (++i >= ilim) {
-	mp_mul_2d(&b, 1, &b);
-	if (ShouldBankerRoundUp(&b, &S, digit&1)) {
+	if ((mp_mul_2d(&b, 1, &b) == MP_OKAY) && ShouldBankerRoundUp(&b, &S, digit&1)) {
 	    s = BumpUp(s, retval, &k);
 	}
     } else {
-	for (;;) {
+	while (err == MP_OKAY) {
 	    /*
 	     * Shift by a group of digits.
 	     */
@@ -3920,16 +4048,20 @@ StrictBignumConversion(
 		g = DIGIT_GROUP;
 	    }
 	    if (s5 >= g) {
-		mp_div_d(&S, dpow5[g], &S, NULL);
+		err = mp_div_d(&S, dpow5[g], &S, NULL);
 		s5 -= g;
 	    } else if (s5 > 0) {
-		mp_div_d(&S, dpow5[s5], &S, NULL);
-		mp_mul_d(&b, dpow5[g - s5], &b);
+		err = mp_div_d(&S, dpow5[s5], &S, NULL);
+		if (err == MP_OKAY) {
+		    err = mp_mul_d(&b, dpow5[g - s5], &b);
+		}
 		s5 = 0;
 	    } else {
-		mp_mul_d(&b, dpow5[g], &b);
+		err = mp_mul_d(&b, dpow5[g], &b);
+	    }
+	    if (err == MP_OKAY) {
+		err = mp_mul_2d(&b, g, &b);
 	    }
-	    mp_mul_2d(&b, g, &b);
 
 	    /*
 	     * As with the shortening bignum conversion, it's possible at this
@@ -3943,8 +4075,8 @@ StrictBignumConversion(
 	     * Extract the next group of digits.
 	     */
 
-	    mp_div(&b, &S, &dig, &b);
-	    if (dig.used > 1) {
+
+	    if ((err != MP_OKAY) || (mp_div(&b, &S, &dig, &b) != MP_OKAY) || (dig.used > 1)) {
 		Tcl_Panic("wrong digit!");
 	    }
 	    digit = dig.dp[0];
@@ -3961,8 +4093,7 @@ StrictBignumConversion(
 	     */
 
 	    if (i == ilim) {
-		mp_mul_2d(&b, 1, &b);
-		if (ShouldBankerRoundUp(&b, &S, digit&1)) {
+		if ((mp_mul_2d(&b, 1, &b) == MP_OKAY) && ShouldBankerRoundUp(&b, &S, digit&1)) {
 		    s = BumpUp(s, retval, &k);
 		}
 		break;
@@ -4336,6 +4467,7 @@ TclInitDoubleConversion(void)
 	Tcl_WideUInt iv;
     } bitwhack;
 #endif
+    mp_err err = MP_OKAY;
 #if defined(__sgi) && defined(_COMPILER_VERSION)
     union fpc_csr mipsCR;
 
@@ -4392,16 +4524,19 @@ TclInitDoubleConversion(void)
      */
 
     for (i=0; i<9; ++i) {
-	mp_init(pow5 + i);
+	err = err || mp_init(pow5 + i);
     }
     mp_set_u64(pow5, 5);
     for (i=0; i<8; ++i) {
-	mp_sqr(pow5+i, pow5+i+1);
+	err = err || mp_sqr(pow5+i, pow5+i+1);
     }
-    mp_init_u64(pow5_13, 1220703125);
+    err = err || mp_init_u64(pow5_13, 1220703125);
     for (i = 1; i < 5; ++i) {
-	mp_init(pow5_13 + i);
-	mp_sqr(pow5_13 + i - 1, pow5_13 + i);
+	err = err || mp_init(pow5_13 + i);
+	err = err || mp_sqr(pow5_13 + i - 1, pow5_13 + i);
+    }
+    if (err != MP_OKAY) {
+	Tcl_Panic("out of memory");
     }
 
     /*
@@ -4493,6 +4628,7 @@ Tcl_InitBignumFromDouble(
 {
     double fract;
     int expt;
+    mp_err err;
 
     /*
      * Infinite values can't convert to bignum.
@@ -4510,19 +4646,24 @@ Tcl_InitBignumFromDouble(
 
     fract = frexp(d, &expt);
     if (expt <= 0) {
-	mp_init(b);
+	err = mp_init(b);
 	mp_zero(b);
     } else {
 	Tcl_WideInt w = (Tcl_WideInt) ldexp(fract, mantBits);
 	int shift = expt - mantBits;
 
-	mp_init_i64(b, w);
-	if (shift < 0) {
-	    mp_div_2d(b, -shift, b, NULL);
+	err = mp_init_i64(b, w);
+	if (err != MP_OKAY) {
+		/* just skip */
+	} else if (shift < 0) {
+	    err = mp_div_2d(b, -shift, b, NULL);
 	} else if (shift > 0) {
-	    mp_mul_2d(b, shift, b);
+	    err = mp_mul_2d(b, shift, b);
 	}
     }
+    if (err != MP_OKAY) {
+	return TCL_ERROR;
+    }
     return TCL_OK;
 }
 
@@ -4548,6 +4689,7 @@ TclBignumToDouble(
     mp_int b;
     int bits, shift, i, lsb;
     double r;
+    mp_err err;
 
 
     /*
@@ -4576,11 +4718,13 @@ TclBignumToDouble(
      * 'rounded to even'.
      */
 
-    mp_init(&b);
-    if (shift == 0) {
-	mp_copy(a, &b);
+    err = mp_init(&b);
+    if (err != MP_OKAY) {
+	/* just skip */
+    } else if (shift == 0) {
+	err = mp_copy(a, &b);
     } else if (shift > 0) {
-	mp_mul_2d(a, shift, &b);
+	err = mp_mul_2d(a, shift, &b);
     } else if (shift < 0) {
 	lsb = mp_cnt_lsb(a);
 	if (lsb == -1-shift) {
@@ -4589,12 +4733,12 @@ TclBignumToDouble(
 	     * Round to even
 	     */
 
-	    mp_div_2d(a, -shift, &b, NULL);
-	    if (mp_isodd(&b)) {
+	    err = mp_div_2d(a, -shift, &b, NULL);
+	    if ((err == MP_OKAY) && mp_isodd(&b)) {
 		if (mp_isneg(&b)) {
-		    mp_sub_d(&b, 1, &b);
+		    err = mp_sub_d(&b, 1, &b);
 		} else {
-		    mp_add_d(&b, 1, &b);
+		    err = mp_add_d(&b, 1, &b);
 		}
 	    }
 	} else {
@@ -4603,13 +4747,15 @@ TclBignumToDouble(
 	     * Ordinary rounding
 	     */
 
-	    mp_div_2d(a, -1-shift, &b, NULL);
-	    if (mp_isneg(&b)) {
-		mp_sub_d(&b, 1, &b);
+	    err = mp_div_2d(a, -1-shift, &b, NULL);
+	    if (err != MP_OKAY) {
+		/* just skip */
+	    } else if (mp_isneg(&b)) {
+		err = mp_sub_d(&b, 1, &b);
 	    } else {
-		mp_add_d(&b, 1, &b);
+		err = mp_add_d(&b, 1, &b);
 	    }
-	    mp_div_2d(&b, 1, &b, NULL);
+	    err = mp_div_2d(&b, 1, &b, NULL);
 	}
     }
 
@@ -4617,8 +4763,11 @@ TclBignumToDouble(
      * Accumulate the result, one mp_digit at a time.
      */
 
+    if (err != MP_OKAY) {
+	return 0.0;
+    }
     r = 0.0;
-    for (i=b.used-1 ; i>=0 ; --i) {
+    for (i = b.used-1; i>=0; --i) {
 	r = ldexp(r, MP_DIGIT_BIT) + b.dp[i];
     }
     mp_clear(&b);
@@ -4660,10 +4809,11 @@ TclCeil(
 {
     double r = 0.0;
     mp_int b;
+    mp_err err;
 
-    mp_init(&b);
-    if (mp_isneg(a)) {
-	mp_neg(a, &b);
+    err = mp_init(&b);
+    if ((err == MP_OKAY) && mp_isneg(a)) {
+	err = mp_neg(a, &b);
 	r = -TclFloor(&b);
     } else {
 	int bits = mp_count_bits(a);
@@ -4673,19 +4823,26 @@ TclCeil(
 	} else {
 	    int i, exact = 1, shift = mantBits - bits;
 
-	    if (shift > 0) {
-		mp_mul_2d(a, shift, &b);
+	    if (err != MP_OKAY) {
+		/* just skip */
+	    } else if (shift > 0) {
+		err = mp_mul_2d(a, shift, &b);
 	    } else if (shift < 0) {
 		mp_int d;
-		mp_init(&d);
-		mp_div_2d(a, -shift, &b, &d);
+		err = mp_init(&d);
+		if (err == MP_OKAY) {
+		    err = mp_div_2d(a, -shift, &b, &d);
+		}
 		exact = mp_iszero(&d);
 		mp_clear(&d);
 	    } else {
-		mp_copy(a, &b);
+		err = mp_copy(a, &b);
 	    }
-	    if (!exact) {
-		mp_add_d(&b, 1, &b);
+	    if ((err == MP_OKAY) && !exact) {
+		err = mp_add_d(&b, 1, &b);
+	    }
+	    if (err != MP_OKAY) {
+		return 0.0;
 	    }
 	    for (i=b.used-1 ; i>=0 ; --i) {
 		r = ldexp(r, MP_DIGIT_BIT) + b.dp[i];
@@ -4717,10 +4874,11 @@ TclFloor(
 {
     double r = 0.0;
     mp_int b;
+    mp_err err;
 
-    mp_init(&b);
-    if (mp_isneg(a)) {
-	mp_neg(a, &b);
+    err = mp_init(&b);
+    if ((err == MP_OKAY) && mp_isneg(a)) {
+	err = mp_neg(a, &b);
 	r = -TclCeil(&b);
     } else {
 	int bits = mp_count_bits(a);
@@ -4731,11 +4889,14 @@ TclFloor(
 	    int i, shift = mantBits - bits;
 
 	    if (shift > 0) {
-		mp_mul_2d(a, shift, &b);
+		err = mp_mul_2d(a, shift, &b);
 	    } else if (shift < 0) {
-		mp_div_2d(a, -shift, &b, NULL);
+		err = mp_div_2d(a, -shift, &b, NULL);
 	    } else {
-		mp_copy(a, &b);
+		err = mp_copy(a, &b);
+	    }
+	    if (err != MP_OKAY) {
+		return 0.0;
 	    }
 	    for (i=b.used-1 ; i>=0 ; --i) {
 		r = ldexp(r, MP_DIGIT_BIT) + b.dp[i];
@@ -4777,6 +4938,7 @@ BignumToBiasedFrExp(
     int shift;
     int i;
     double r;
+    mp_err err = MP_OKAY;
 
     /*
      * Determine how many bits we need, and extract that many from the input.
@@ -4785,13 +4947,15 @@ BignumToBiasedFrExp(
 
     bits = mp_count_bits(a);
     shift = mantBits - 2 - bits;
-    mp_init(&b);
+    if (mp_init(&b)) {
+	return 0.0;
+    }
     if (shift > 0) {
-	mp_mul_2d(a, shift, &b);
+	err = mp_mul_2d(a, shift, &b);
     } else if (shift < 0) {
-	mp_div_2d(a, -shift, &b, NULL);
+	err = mp_div_2d(a, -shift, &b, NULL);
     } else {
-	mp_copy(a, &b);
+	err = mp_copy(a, &b);
     }
 
     /*
@@ -4799,8 +4963,10 @@ BignumToBiasedFrExp(
      */
 
     r = 0.0;
-    for (i=b.used-1; i>=0; --i) {
-	r = ldexp(r, MP_DIGIT_BIT) + b.dp[i];
+    if (err == MP_OKAY) {
+	for (i=b.used-1; i>=0; --i) {
+	    r = ldexp(r, MP_DIGIT_BIT) + b.dp[i];
+	}
     }
     mp_clear(&b);
 
diff --git a/generic/tclTestObj.c b/generic/tclTestObj.c
index 6fc1176..1e35a75 100644
--- a/generic/tclTestObj.c
+++ b/generic/tclTestObj.c
@@ -164,7 +164,7 @@ TestbignumobjCmd(
     };
     int index, varIndex;
     const char *string;
-    mp_int bignumValue, newValue;
+    mp_int bignumValue;
     Tcl_Obj **varPtr;
 
     if (objc < 3) {
@@ -237,19 +237,16 @@ TestbignumobjCmd(
 		&bignumValue) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	if (mp_init(&newValue) != MP_OKAY
-		|| (mp_mul_d(&bignumValue, 10, &newValue) != MP_OKAY)) {
+	if (mp_mul_d(&bignumValue, 10, &bignumValue) != MP_OKAY) {
 	    mp_clear(&bignumValue);
-	    mp_clear(&newValue);
 	    Tcl_SetObjResult(interp,
 		    Tcl_NewStringObj("error in mp_mul_d", -1));
 	    return TCL_ERROR;
 	}
-	mp_clear(&bignumValue);
 	if (!Tcl_IsShared(varPtr[varIndex])) {
-	    Tcl_SetBignumObj(varPtr[varIndex], &newValue);
+	    Tcl_SetBignumObj(varPtr[varIndex], &bignumValue);
 	} else {
-	    SetVarToObj(varPtr, varIndex, Tcl_NewBignumObj(&newValue));
+	    SetVarToObj(varPtr, varIndex, Tcl_NewBignumObj(&bignumValue));
 	}
 	break;
 
@@ -265,19 +262,16 @@ TestbignumobjCmd(
 		&bignumValue) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	if (mp_init(&newValue) != MP_OKAY
-		|| (mp_div_d(&bignumValue, 10, &newValue, NULL) != MP_OKAY)) {
+	if (mp_div_d(&bignumValue, 10, &bignumValue, NULL) != MP_OKAY) {
 	    mp_clear(&bignumValue);
-	    mp_clear(&newValue);
 	    Tcl_SetObjResult(interp,
 		    Tcl_NewStringObj("error in mp_div_d", -1));
 	    return TCL_ERROR;
 	}
-	mp_clear(&bignumValue);
 	if (!Tcl_IsShared(varPtr[varIndex])) {
-	    Tcl_SetBignumObj(varPtr[varIndex], &newValue);
+	    Tcl_SetBignumObj(varPtr[varIndex], &bignumValue);
 	} else {
-	    SetVarToObj(varPtr, varIndex, Tcl_NewBignumObj(&newValue));
+	    SetVarToObj(varPtr, varIndex, Tcl_NewBignumObj(&bignumValue));
 	}
 	break;
 
@@ -293,10 +287,16 @@ TestbignumobjCmd(
 		&bignumValue) != TCL_OK) {
 	    return TCL_ERROR;
 	}
+	if (mp_mod_2d(&bignumValue, 1, &bignumValue) != MP_OKAY) {
+	    mp_clear(&bignumValue);
+	    Tcl_SetObjResult(interp,
+		    Tcl_NewStringObj("error in mp_mod_2d", -1));
+	    return TCL_ERROR;
+	}
 	if (!Tcl_IsShared(varPtr[varIndex])) {
-	    Tcl_SetIntObj(varPtr[varIndex], !mp_isodd(&bignumValue));
+	    Tcl_SetIntObj(varPtr[varIndex], mp_iszero(&bignumValue));
 	} else {
-	    SetVarToObj(varPtr, varIndex, Tcl_NewIntObj(!mp_isodd(&bignumValue)));
+	    SetVarToObj(varPtr, varIndex, Tcl_NewIntObj(mp_iszero(&bignumValue)));
 	}
 	mp_clear(&bignumValue);
 	break;
diff --git a/generic/tclTrace.c b/generic/tclTrace.c
index 9d73064..c00bbe4 100644
--- a/generic/tclTrace.c
+++ b/generic/tclTrace.c
@@ -79,8 +79,7 @@ typedef struct {
  * TCL_TRACE_EXEC_DIRECT	- This execution trace is triggered directly
  *				  by the command being traced, not because of
  *				  an internal trace.
- * The flags 'TCL_TRACE_DESTROYED' and 'TCL_INTERP_DESTROYED' may also be used
- * in command execution traces.
+ * The flag 'TCL_TRACE_DESTROYED' may also be used in command execution traces.
  */
 
 #define TCL_TRACE_ENTER_DURING_EXEC	4
@@ -2645,13 +2644,6 @@ TclCallVarTraces(
     }
 
     /*
-     * Ignore any caller-provided TCL_INTERP_DESTROYED flag.  Only we can
-     * set it correctly.
-     */
-
-    flags &= ~TCL_INTERP_DESTROYED;
-
-    /*
      * Invoke traces on the array containing the variable, if relevant.
      */
 
@@ -2673,9 +2665,6 @@ TclCallVarTraces(
 	    if (state == NULL) {
 		state = Tcl_SaveInterpState((Tcl_Interp *) iPtr, code);
 	    }
-	    if (Tcl_InterpDeleted((Tcl_Interp *) iPtr)) {
-		flags |= TCL_INTERP_DESTROYED;
-	    }
 	    result = tracePtr->traceProc(tracePtr->clientData,
 		    (Tcl_Interp *) iPtr, part1, part2, flags);
 	    if (result != NULL) {
@@ -2717,9 +2706,6 @@ TclCallVarTraces(
 	    if (state == NULL) {
 		state = Tcl_SaveInterpState((Tcl_Interp *) iPtr, code);
 	    }
-	    if (Tcl_InterpDeleted((Tcl_Interp *) iPtr)) {
-		flags |= TCL_INTERP_DESTROYED;
-	    }
 	    result = tracePtr->traceProc(tracePtr->clientData,
 		    (Tcl_Interp *) iPtr, part1, part2, flags);
 	    if (result != NULL) {
diff --git a/unix/Makefile.in b/unix/Makefile.in
index b98a415..1b682d9 100644
--- a/unix/Makefile.in
+++ b/unix/Makefile.in
@@ -282,7 +282,7 @@ STUB_CC_SWITCHES = -I"${BUILD_DIR}" -I${UNIX_DIR} -I${GENERIC_DIR} -I${TOMMATH_D
 	${AC_FLAGS} ${PROTO_FLAGS} ${ENV_FLAGS} ${EXTRA_CFLAGS} \
 	@EXTRA_CC_SWITCHES@
 
-CC_SWITCHES = $(STUB_CC_SWITCHES) ${NO_DEPRECATED_FLAGS} -DMP_FIXED_CUTOFFS -DMP_NO_STDINT -DMP_WUR=
+CC_SWITCHES = $(STUB_CC_SWITCHES) ${NO_DEPRECATED_FLAGS} -DMP_FIXED_CUTOFFS -DMP_NO_STDINT
 
 APP_CC_SWITCHES = $(CC_SWITCHES) @EXTRA_APP_CC_SWITCHES@
 
diff --git a/win/Makefile.in b/win/Makefile.in
index dc3facf..9dae1b2 100644
--- a/win/Makefile.in
+++ b/win/Makefile.in
@@ -82,7 +82,7 @@ CFLAGS_OPTIMIZE	= @CFLAGS_OPTIMIZE@
 #CFLAGS = 		$(CFLAGS_DEBUG)
 #CFLAGS = 		$(CFLAGS_OPTIMIZE)
 #CFLAGS = 		$(CFLAGS_DEBUG) $(CFLAGS_OPTIMIZE)
-CFLAGS = 		@CFLAGS@ @CFLAGS_DEFAULT@ -D_ATL_XP_TARGETING -DMP_FIXED_CUTOFFS -DMP_NO_STDINT -DMP_WUR=
+CFLAGS = 		@CFLAGS@ @CFLAGS_DEFAULT@ -DMP_FIXED_CUTOFFS -DMP_NO_STDINT
 
 # To compile without backward compatibility and deprecated code uncomment the
 # following
diff --git a/win/makefile.vc b/win/makefile.vc
index a2bfaa2..4112ffc 100644
--- a/win/makefile.vc
+++ b/win/makefile.vc
@@ -52,7 +52,7 @@
 # turn on the 64-bit compiler, if your SDK has it.

 #

 # Basic macros and options usable on the commandline (see rules.vc for more info):

-#	OPTS=msvcrt,nothreads,pdbs,profile,static,staticpkg,symbols,thrdalloc,unchecked,utfmax,none

+#	OPTS=msvcrt,nothreads,pdbs,profile,static,staticpkg,symbols,thrdalloc,unchecked,none

 #		Sets special options for the core.  The default is for none.

 #		Any combination of the above may be used (comma separated).

 #		'none' will over-ride everything to nothing.

@@ -74,8 +74,6 @@
 #		unchecked = Allows a symbols build to not use the debug

 #			    enabled runtime (msvcrt.dll not msvcrtd.dll

 #			    or libcmt.lib not libcmtd.lib).

-#		utfmax    = Forces a build allowing 4-byte UTF-8 sequences

-#			    internally.

 #

 #	STATS=compdbg,memdbg,none

 #		Sets optional memory and bytecode compiler debugging code added

@@ -437,7 +435,7 @@ PKGSDIR		= $(ROOT)\pkgs
 # Additional include and C macro definitions for the implicit rules

 # defined in rules.vc

 PRJ_INCLUDES	= -I"$(TOMMATHDIR)"

-PRJ_DEFINES	= /DTCL_TOMMATH /DMP_PREC=4 /Dinline=__inline /DHAVE_ZLIB=1 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /DMP_FIXED_CUTOFFS /DMP_WUR=

+PRJ_DEFINES	= /DTCL_TOMMATH /DMP_PREC=4 /Dinline=__inline /DHAVE_ZLIB=1 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /DMP_FIXED_CUTOFFS

 

 # Additional Link libraries needed beyond those in rules.vc

 PRJ_LIBS   = netapi32.lib user32.lib userenv.lib ws2_32.lib

diff --git a/win/rules.vc b/win/rules.vc
index d1d8581..8c1a9ce 100644
--- a/win/rules.vc
+++ b/win/rules.vc
@@ -684,7 +684,6 @@ LINKERFLAGS     = $(LINKERFLAGS) -ltcg
 # USE_STUBS - 1 -> compile to use stubs interfaces, 0 -> direct linking

 # CONFIG_CHECK - 1 -> check current build configuration against Tcl

 #           configuration (ignored for Tcl itself)

-# TCL_UTF_MAX=4 - forces a build allowing 4-byte UTF-8 sequences internally.

 # Further, LINKERFLAGS are modified based on above.

 

 # Default values for all the above

@@ -753,11 +752,6 @@ TCL_THREADS    = 1
 USE_THREAD_ALLOC= 1

 !endif

 

-!if [nmakehlp -f $(OPTS) "utfmax"]

-!message *** Force allowing 4-byte UTF-8 sequences internally

-TCL_UTF_MAX = 4

-!endif

-

 # Yes, it's weird that the "symbols" option controls DEBUG and

 # the "pdbs" option controls SYMBOLS. That's historical.

 !if [nmakehlp -f $(OPTS) "symbols"]

@@ -1353,13 +1347,6 @@ OPTDEFINES	= $(OPTDEFINES) /DTCL_CFG_DO64BIT
 OPTDEFINES	= $(OPTDEFINES) /DNO_STRTOI64=1

 !endif

 

-!if "$(TCL_UTF_MAX)" == "4"

-OPTDEFINES	= $(OPTDEFINES) /DTCL_UTF_MAX=4

-!endif

-

-# _ATL_XP_TARGETING - Newer SDK's need this to build for XP

-COMPILERFLAGS  = /D_ATL_XP_TARGETING

-

 # Like the TEA system only set this non empty for non-Tk extensions

 # Note: some extensions use PACKAGE_NAME and others use PACKAGE_TCLNAME

 # so we pass both