Still WIP. All test-cases pass now in 32-bit

generic/tcl.decls

@@ -2329,6 +2329,21 @@ declare 631 {
 	    const char *host, unsigned int flags, Tcl_TcpAcceptProc *acceptProc,
 	    ClientData callbackData)
 }
+# TIP #481
+declare 634 {
+    int Tcl_GetValue(Tcl_Interp *interp, Tcl_Obj *objPtr,
+	    void *intPtr, int flags)
+}
+declare 635 {
+    char *Tcl_GetStringFromObj2(Tcl_Obj *objPtr, size_t *lengthPtr)
+}
+declare 636 {
+    Tcl_UniChar *Tcl_GetUnicodeFromObj2(Tcl_Obj *objPtr, size_t *lengthPtr)
+}
+declare 637 {
+    unsigned char *Tcl_GetByteArrayFromObj2(Tcl_Obj *objPtr, size_t *lengthPtr)
+}
+
 
 # ----- BASELINE -- FOR -- 8.7.0 ----- #
 

generic/tcl.h

@@ -1106,6 +1106,13 @@ typedef struct Tcl_DString {
 #define TCL_LINK_FLOAT		13
 #define TCL_LINK_WIDE_UINT	14
 #define TCL_LINK_READ_ONLY	0x80
+
+/*
+ * Types for Tcl_GetValue():
+ */
+
+#define TCL_TYPE_I(type) (0x100 | (int)sizeof(type)) /* signed integer */
+#define TCL_TYPE_D(type) (0x300 | (int)sizeof(type)) /* float/double/long double */
 
 /*
  *----------------------------------------------------------------------------

generic/tclBasic.c

@@ -116,7 +116,6 @@ static Tcl_ObjCmdProc	ExprCeilFunc;
 static Tcl_ObjCmdProc	ExprDoubleFunc;
 static Tcl_ObjCmdProc	ExprEntierFunc;
 static Tcl_ObjCmdProc	ExprFloorFunc;
-static Tcl_ObjCmdProc	ExprIntFunc;
 static Tcl_ObjCmdProc	ExprIsqrtFunc;
 static Tcl_ObjCmdProc	ExprMaxFunc;
 static Tcl_ObjCmdProc	ExprMinFunc;
@@ -125,7 +124,7 @@ static Tcl_ObjCmdProc	ExprRoundFunc;
 static Tcl_ObjCmdProc	ExprSqrtFunc;
 static Tcl_ObjCmdProc	ExprSrandFunc;
 static Tcl_ObjCmdProc	ExprUnaryFunc;
-static Tcl_ObjCmdProc	ExprWideFunc;
+static Tcl_ObjCmdProc	ExprIntFunc;
 static void		MathFuncWrongNumArgs(Tcl_Interp *interp, int expected,
 			    int actual, Tcl_Obj *const *objv);
 static Tcl_NRPostProc	NRCoroutineCallerCallback;
@@ -336,7 +335,7 @@ static const BuiltinFuncDef BuiltinFuncTable[] = {
     { "srand",	ExprSrandFunc,	NULL			},
     { "tan",	ExprUnaryFunc,	(ClientData) tan	},
     { "tanh",	ExprUnaryFunc,	(ClientData) tanh	},
-    { "wide",	ExprWideFunc,	NULL			},
+    { "wide",	ExprIntFunc,	NULL			},
     { NULL, NULL, NULL }
 };
 
@@ -3660,16 +3659,8 @@ OldMathFuncProc(
 	    args[k].doubleValue = d;
 	    break;
 	case TCL_INT:
-	    if (ExprIntFunc(NULL, interp, 2, &objv[j-1]) != TCL_OK) {
-		ckfree(args);
-		return TCL_ERROR;
-	    }
-	    valuePtr = Tcl_GetObjResult(interp);
-	    Tcl_GetLongFromObj(NULL, valuePtr, &args[k].intValue);
-	    Tcl_ResetResult(interp);
-	    break;
 	case TCL_WIDE_INT:
-	    if (ExprWideFunc(NULL, interp, 2, &objv[j-1]) != TCL_OK) {
+	    if (ExprIntFunc(NULL, interp, 2, &objv[j-1]) != TCL_OK) {
 		ckfree(args);
 		return TCL_ERROR;
 	    }
@@ -7679,38 +7670,6 @@ ExprIntFunc(
 				 * function. */
     int objc,			/* Actual parameter count. */
     Tcl_Obj *const *objv)	/* Actual parameter vector. */
-{
-    long iResult;
-    Tcl_Obj *objPtr;
-    if (ExprEntierFunc(NULL, interp, objc, objv) != TCL_OK) {
-	return TCL_ERROR;
-    }
-    objPtr = Tcl_GetObjResult(interp);
-    if (TclGetLongFromObj(NULL, objPtr, &iResult) != TCL_OK) {
-	/*
-	 * Truncate the bignum; keep only bits in long range.
-	 */
-
-	mp_int big;
-
-	Tcl_GetBignumFromObj(NULL, objPtr, &big);
-	mp_mod_2d(&big, (int) CHAR_BIT * sizeof(long), &big);
-	objPtr = Tcl_NewBignumObj(&big);
-	Tcl_IncrRefCount(objPtr);
-	TclGetLongFromObj(NULL, objPtr, &iResult);
-	Tcl_DecrRefCount(objPtr);
-    }
-    Tcl_SetObjResult(interp, Tcl_NewLongObj(iResult));
-    return TCL_OK;
-}
-
-static int
-ExprWideFunc(
-    ClientData clientData,	/* Ignored. */
-    Tcl_Interp *interp,		/* The interpreter in which to execute the
-				 * function. */
-    int objc,			/* Actual parameter count. */
-    Tcl_Obj *const *objv)	/* Actual parameter vector. */
 {
     Tcl_WideInt wResult;
     Tcl_Obj *objPtr;

generic/tclBinary.c

@@ -268,9 +268,9 @@ const Tcl_ObjType tclByteArrayType = {
  */
 
 typedef struct ByteArray {
-    int used;			/* The number of bytes used in the byte
+    unsigned int used;		/* The number of bytes used in the byte
 				 * array. */
-    int allocated;		/* The amount of space actually allocated
+    unsigned int allocated;	/* The amount of space actually allocated
 				 * minus 1 byte. */
     unsigned char bytes[1];	/* The array of bytes. The actual size of this
 				 * field depends on the 'allocated' field
@@ -278,7 +278,7 @@ typedef struct ByteArray {
 } ByteArray;
 
 #define BYTEARRAY_SIZE(len) \
-		((unsigned) (TclOffset(ByteArray, bytes) + (len)))
+		(TclOffset(ByteArray, bytes) + (len))
 #define GET_BYTEARRAY(objPtr) \
 		((ByteArray *) (objPtr)->internalRep.twoPtrValue.ptr1)
 #define SET_BYTEARRAY(objPtr, baPtr) \
@@ -427,7 +427,7 @@ Tcl_SetByteArrayObj(
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_GetByteArrayFromObj --
+ * Tcl_GetByteArrayFromObj/Tcl_GetByteArrayFromObj2 --
  *
  *	Attempt to get the array of bytes from the Tcl object. If the object
  *	is not already a ByteArray object, an attempt will be made to convert
@@ -442,6 +442,7 @@ Tcl_SetByteArrayObj(
  *----------------------------------------------------------------------
  */
 
+#undef Tcl_GetByteArrayFromObj
 unsigned char *
 Tcl_GetByteArrayFromObj(
     Tcl_Obj *objPtr,		/* The ByteArray object. */
@@ -461,6 +462,26 @@ Tcl_GetByteArrayFromObj(
     }
     return (unsigned char *) baPtr->bytes;
 }
+
+unsigned char *
+Tcl_GetByteArrayFromObj2(
+    Tcl_Obj *objPtr,		/* The ByteArray object. */
+    size_t *lengthPtr)		/* If non-NULL, filled with length of the
+				 * array of bytes in the ByteArray object. */
+{
+    ByteArray *baPtr;
+
+    if ((objPtr->typePtr != &properByteArrayType)
+	    && (objPtr->typePtr != &tclByteArrayType)) {
+	SetByteArrayFromAny(NULL, objPtr);
+    }
+    baPtr = GET_BYTEARRAY(objPtr);
+
+    if (lengthPtr != NULL) {
+	*lengthPtr = baPtr->used;
+    }
+    return (unsigned char *) baPtr->bytes;
+}
 
 /*
  *----------------------------------------------------------------------
@@ -500,7 +521,7 @@ Tcl_SetByteArrayLength(
     }
 
     byteArrayPtr = GET_BYTEARRAY(objPtr);
-    if (length > byteArrayPtr->allocated) {
+    if ((size_t)length > byteArrayPtr->allocated) {
 	byteArrayPtr = ckrealloc(byteArrayPtr, BYTEARRAY_SIZE(length));
 	byteArrayPtr->allocated = length;
 	SET_BYTEARRAY(objPtr, byteArrayPtr);
@@ -718,7 +739,7 @@ TclAppendBytesToByteArray(
     int len)
 {
     ByteArray *byteArrayPtr;
-    int needed;
+    size_t needed;
 
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object","TclAppendBytesToByteArray");
@@ -737,7 +758,7 @@ TclAppendBytesToByteArray(
     }
     byteArrayPtr = GET_BYTEARRAY(objPtr);
 
-    if (len > INT_MAX - byteArrayPtr->used) {
+    if ((size_t)len + byteArrayPtr->used > INT_MAX) {
 	Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
     }
 

generic/tclCmdMZ.c

@@ -1622,11 +1622,6 @@ StringIsCmd(
     case STR_IS_GRAPH:
 	chcomp = Tcl_UniCharIsGraph;
 	break;
-    case STR_IS_INT:
-	if (TCL_OK == TclGetIntFromObj(NULL, objPtr, &i)) {
-	    break;
-	}
-	goto failedIntParse;
     case STR_IS_ENTIER:
 	if ((objPtr->typePtr == &tclIntType) ||
 		(objPtr->typePtr == &tclBignumType)) {
@@ -1669,12 +1664,12 @@ StringIsCmd(
 	    failat = 0;
 	}
 	break;
+    case STR_IS_INT:
     case STR_IS_WIDE:
 	if (TCL_OK == TclGetWideIntFromObj(NULL, objPtr, &w)) {
 	    break;
 	}
 
-    failedIntParse:
 	string1 = TclGetStringFromObj(objPtr, &length1);
 	if (length1 == 0) {
 	    if (strict) {

generic/tclCompCmdsSZ.c

@@ -692,9 +692,6 @@ TclCompileStringIsCmd(
 
 	switch (t) {
 	case STR_IS_INT:
-	    PUSH(	"1");
-	    OP(		EQ);
-	    break;
 	case STR_IS_WIDE:
 	    PUSH(	"2");
 	    OP(		LE);

generic/tclDecls.h

@@ -1862,6 +1862,20 @@ EXTERN Tcl_Channel	Tcl_OpenTcpServerEx(Tcl_Interp *interp,
 				unsigned int flags,
 				Tcl_TcpAcceptProc *acceptProc,
 				ClientData callbackData);
+/* Slot 632 is reserved */
+/* Slot 633 is reserved */
+/* 634 */
+EXTERN int		Tcl_GetValue(Tcl_Interp *interp, Tcl_Obj *objPtr,
+				void *intPtr, int flags);
+/* 635 */
+EXTERN char *		Tcl_GetStringFromObj2(Tcl_Obj *objPtr,
+				size_t *lengthPtr);
+/* 636 */
+EXTERN Tcl_UniChar *	Tcl_GetUnicodeFromObj2(Tcl_Obj *objPtr,
+				size_t *lengthPtr);
+/* 637 */
+EXTERN unsigned char *	Tcl_GetByteArrayFromObj2(Tcl_Obj *objPtr,
+				size_t *lengthPtr);
 
 typedef struct {
     const struct TclPlatStubs *tclPlatStubs;
@@ -2529,6 +2543,12 @@ typedef struct TclStubs {
     int (*tcl_FSUnloadFile) (Tcl_Interp *interp, Tcl_LoadHandle handlePtr); /* 629 */
     void (*tcl_ZlibStreamSetCompressionDictionary) (Tcl_ZlibStream zhandle, Tcl_Obj *compressionDictionaryObj); /* 630 */
     Tcl_Channel (*tcl_OpenTcpServerEx) (Tcl_Interp *interp, const char *service, const char *host, unsigned int flags, Tcl_TcpAcceptProc *acceptProc, ClientData callbackData); /* 631 */
+    void (*reserved632)(void);
+    void (*reserved633)(void);
+    int (*tcl_GetValue) (Tcl_Interp *interp, Tcl_Obj *objPtr, void *intPtr, int flags); /* 634 */
+    char * (*tcl_GetStringFromObj2) (Tcl_Obj *objPtr, size_t *lengthPtr); /* 635 */
+    Tcl_UniChar * (*tcl_GetUnicodeFromObj2) (Tcl_Obj *objPtr, size_t *lengthPtr); /* 636 */
+    unsigned char * (*tcl_GetByteArrayFromObj2) (Tcl_Obj *objPtr, size_t *lengthPtr); /* 637 */
 } TclStubs;
 
 extern const TclStubs *tclStubsPtr;
@@ -3823,6 +3843,16 @@ extern const TclStubs *tclStubsPtr;
 	(tclStubsPtr->tcl_ZlibStreamSetCompressionDictionary) /* 630 */
 #define Tcl_OpenTcpServerEx \
 	(tclStubsPtr->tcl_OpenTcpServerEx) /* 631 */
+/* Slot 632 is reserved */
+/* Slot 633 is reserved */
+#define Tcl_GetValue \
+	(tclStubsPtr->tcl_GetValue) /* 634 */
+#define Tcl_GetStringFromObj2 \
+	(tclStubsPtr->tcl_GetStringFromObj2) /* 635 */
+#define Tcl_GetUnicodeFromObj2 \
+	(tclStubsPtr->tcl_GetUnicodeFromObj2) /* 636 */
+#define Tcl_GetByteArrayFromObj2 \
+	(tclStubsPtr->tcl_GetByteArrayFromObj2) /* 637 */
 
 #endif /* defined(USE_TCL_STUBS) */
 
@@ -3988,6 +4018,40 @@ extern const TclStubs *tclStubsPtr;
 #   endif
 #endif
 
+#undef Tcl_GetDoubleFromObj
+#undef Tcl_GetIntFromObj
+#undef Tcl_GetStringFromObj
+#undef Tcl_GetUnicodeFromObj
+#undef Tcl_GetByteArrayFromObj
+#undef Tcl_GetUnicode
+#if defined(USE_TCL_STUBS)
+#define Tcl_GetDoubleFromObj(interp, objPtr, dblPtr) \
+	(sizeof(*dblPtr) == sizeof(double) ? tclStubsPtr->tcl_GetDoubleFromObj(interp, objPtr, (double *)dblPtr) : tclStubsPtr->tcl_GetValue(interp, objPtr, dblPtr, TCL_TYPE_D(*dblPtr)))
+#define Tcl_GetIntFromObj(interp, objPtr, intPtr) \
+	(sizeof(*intPtr) == sizeof(int) ? tclStubsPtr->tcl_GetIntFromObj(interp, objPtr, (int *)intPtr) : tclStubsPtr->tcl_GetValue(interp, objPtr, intPtr, TCL_TYPE_I(*intPtr)))
+#define Tcl_GetStringFromObj(objPtr, sizePtr) \
+	(sizeof(*sizePtr) <= sizeof(int) ? tclStubsPtr->tcl_GetStringFromObj(objPtr, (int *)sizePtr) : tclStubsPtr->tcl_GetStringFromObj2(objPtr, (size_t *)sizePtr))
+#define Tcl_GetByteArrayFromObj(objPtr, sizePtr) \
+	(sizeof(*sizePtr) <= sizeof(int) ? tclStubsPtr->tcl_GetByteArrayFromObj(objPtr, (int *)sizePtr) : tclStubsPtr->tcl_GetByteArrayFromObj2(objPtr, (size_t *)sizePtr))
+#define Tcl_GetUnicodeFromObj(objPtr, sizePtr) \
+	(sizeof(*sizePtr) <= sizeof(int) ? tclStubsPtr->tcl_GetUnicodeFromObj(objPtr, (int *)sizePtr) : tclStubsPtr->tcl_GetUnicodeFromObj2(objPtr, (size_t *)sizePtr))
+#define Tcl_GetUnicode(objPtr) \
+	tclStubsPtr->tcl_GetUnicodeFromObj(objPtr, NULL)
+#else
+#define Tcl_GetDoubleFromObj(interp, objPtr, dblPtr) \
+	(sizeof(*dblPtr) == sizeof(double) ? (Tcl_GetDoubleFromObj)(interp, objPtr, (double *)dblPtr) : Tcl_GetValue(interp, objPtr, dblPtr, TCL_TYPE_D(*dblPtr)))
+#define Tcl_GetIntFromObj(interp, objPtr, intPtr) \
+	(sizeof(*intPtr) == sizeof(int) ? (Tcl_GetIntFromObj)(interp, objPtr, (int *)intPtr) : Tcl_GetValue(interp, objPtr, intPtr, TCL_TYPE_I(*intPtr)))
+#define Tcl_GetStringFromObj(objPtr, sizePtr) \
+	(sizeof(*sizePtr) <= sizeof(int) ? (Tcl_GetStringFromObj)(objPtr, (int *)sizePtr) : Tcl_GetStringFromObj2(objPtr, (size_t *)sizePtr))
+#define Tcl_GetByteArrayFromObj(objPtr, sizePtr) \
+	(sizeof(*sizePtr) <= sizeof(int) ? (Tcl_GetByteArrayFromObj)(objPtr, (int *)sizePtr) : Tcl_GetByteArrayFromObj2(objPtr, (size_t *)sizePtr))
+#define Tcl_GetUnicodeFromObj(objPtr, sizePtr) \
+	(sizeof(*sizePtr) <= sizeof(int) ? (Tcl_GetUnicodeFromObj)(objPtr, (int *)sizePtr) : Tcl_GetUnicodeFromObj2(objPtr, (size_t *)sizePtr))
+#define Tcl_GetUnicode(objPtr) \
+	(Tcl_GetUnicodeFromObj)(objPtr, NULL)
+#endif
+
 #undef Tcl_NewLongObj
 #define Tcl_NewLongObj(value) Tcl_NewWideIntObj((long)(value))
 #undef Tcl_NewIntObj
@@ -3998,8 +4062,6 @@ extern const TclStubs *tclStubsPtr;
 #define Tcl_SetIntObj(objPtr, value)	Tcl_SetWideIntObj((objPtr), (int)(value))
 #undef Tcl_SetLongObj
 #define Tcl_SetLongObj(objPtr, value)	Tcl_SetWideIntObj((objPtr), (long)(value))
-#undef Tcl_GetUnicode
-#define Tcl_GetUnicode(objPtr)	Tcl_GetUnicodeFromObj((objPtr), NULL)
 
 /*
  * Deprecated Tcl procedures:

generic/tclExecute.c

@@ -5634,18 +5634,9 @@ TEBCresume(
     case INST_NUM_TYPE:
 	if (GetNumberFromObj(NULL, OBJ_AT_TOS, &ptr1, &type1) != TCL_OK) {
 	    type1 = 0;
-	} else if (type1 == TCL_NUMBER_WIDE) {
-	    /* value is between LLONG_MIN and LLONG_MAX */
-	    /* [string is integer] is -UINT_MAX to UINT_MAX range */
-	    /* [string is wideinteger] is -ULLONG_MAX to ULLONG_MAX range */
-	    int i;
-
-	    if (Tcl_GetIntFromObj(NULL, OBJ_AT_TOS, &i) == TCL_OK) {
-		type1 = TCL_NUMBER_LONG;
-	    }
 	} else if (type1 == TCL_NUMBER_BIG) {
 	    /* value is an integer outside the LLONG_MIN to LLONG_MAX range */
-	    /* [string is wideinteger] is -ULLONG_MAX to ULLONG_MAX range */
+	    /* [string is wideinteger] is LLONG_MIN to LLONG_MAX range */
 	    Tcl_WideInt w;
 
 	    if (Tcl_GetWideIntFromObj(NULL, OBJ_AT_TOS, &w) == TCL_OK) {

generic/tclInt.h

@@ -2493,7 +2493,7 @@ typedef struct List {
 #else
 #define TclGetLongFromObj(interp, objPtr, longPtr) \
     (((objPtr)->typePtr == &tclIntType \
-	    && (objPtr)->internalRep.wideValue >= -(Tcl_WideInt)(ULONG_MAX) \
+	    && (objPtr)->internalRep.wideValue >= (Tcl_WideInt)(LONG_MIN) \
 	    && (objPtr)->internalRep.wideValue <= (Tcl_WideInt)(ULONG_MAX))	\
 	    ? ((*(longPtr) = (long)(objPtr)->internalRep.wideValue), TCL_OK) \
 	    : Tcl_GetLongFromObj((interp), (objPtr), (longPtr)))
@@ -2501,7 +2501,7 @@ typedef struct List {
 
 #define TclGetIntFromObj(interp, objPtr, intPtr) \
     (((objPtr)->typePtr == &tclIntType \
-	    && (objPtr)->internalRep.wideValue >= -(Tcl_WideInt)(UINT_MAX) \
+	    && (objPtr)->internalRep.wideValue >= (Tcl_WideInt)(INT_MIN) \
 	    && (objPtr)->internalRep.wideValue <= (Tcl_WideInt)(UINT_MAX))	\
 	    ? ((*(intPtr) = (int)(objPtr)->internalRep.wideValue), TCL_OK) \
 	    : Tcl_GetIntFromObj((interp), (objPtr), (intPtr)))
@@ -2705,8 +2705,11 @@ typedef struct ProcessGlobalValue {
  *----------------------------------------------------------------------
  */
 
-#define TCL_NUMBER_LONG		1
-#define TCL_NUMBER_WIDE		2
+#define TCL_NUMBER_INT		2
+#if TCL_MAJOR_VERSION < 9
+#   define TCL_NUMBER_LONG		1 /* deprecated, not used any more */
+#   define TCL_NUMBER_WIDE		TCL_NUMBER_INT /* deprecated */
+#endif
 #define TCL_NUMBER_BIG		3
 #define TCL_NUMBER_DOUBLE	4
 #define TCL_NUMBER_NAN		5

generic/tclObj.c

@@ -1663,7 +1663,7 @@ Tcl_GetString(
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_GetStringFromObj --
+ * Tcl_GetStringFromObj/Tcl_GetStringFromObj2 --
  *
  *	Returns the string representation's byte array pointer and length for
  *	an object.
@@ -1683,6 +1683,7 @@ Tcl_GetString(
  *----------------------------------------------------------------------
  */
 
+#undef Tcl_GetStringFromObj
 char *
 Tcl_GetStringFromObj(
     register Tcl_Obj *objPtr,	/* Object whose string rep byte pointer should
@@ -1721,6 +1722,50 @@ Tcl_GetStringFromObj(
     }
     return objPtr->bytes;
 }
+
+char *
+Tcl_GetStringFromObj2(
+    Tcl_Obj *objPtr,	/* Object whose string rep byte pointer should
+				 * be returned. */
+    size_t *lengthPtr)	/* If non-NULL, the location where the string
+				 * rep's byte array length should * be stored.
+				 * If NULL, no length is stored. */
+{
+    if (objPtr->bytes == NULL) {
+	/*
+	 * Note we do not check for objPtr->typePtr == NULL.  An invariant
+	 * of a properly maintained Tcl_Obj is that at least  one of
+	 * objPtr->bytes and objPtr->typePtr must not be NULL.  If broken
+	 * extensions fail to maintain that invariant, we can crash here.
+	 */
+
+	if (objPtr->typePtr->updateStringProc == NULL) {
+	    /*
+	     * Those Tcl_ObjTypes which choose not to define an
+	     * updateStringProc must be written in such a way that
+	     * (objPtr->bytes) never becomes NULL.
+	     */
+	    Tcl_Panic("UpdateStringProc should not be invoked for type %s",
+		    objPtr->typePtr->name);
+	}
+	objPtr->typePtr->updateStringProc(objPtr);
+	if (objPtr->bytes == NULL || objPtr->length < 0
+		|| objPtr->bytes[objPtr->length] != '\0') {
+	    Tcl_Panic("UpdateStringProc for type '%s' "
+		    "failed to create a valid string rep",
+		    objPtr->typePtr->name);
+	}
+    }
+    if (lengthPtr != NULL) {
+#if TK_MAJOR_VERSION > 8
+	*lengthPtr = objPtr->length;
+#else
+	*lengthPtr = (unsigned)objPtr->length;
+#endif
+    }
+    return objPtr->bytes;
+}
+
 
 /*
  *----------------------------------------------------------------------
@@ -2292,6 +2337,7 @@ Tcl_SetDoubleObj(
  *----------------------------------------------------------------------
  */
 
+#undef Tcl_GetDoubleFromObj
 int
 Tcl_GetDoubleFromObj(
     Tcl_Interp *interp,         /* Used for error reporting if not NULL. */
@@ -2479,7 +2525,7 @@ Tcl_SetIntObj(
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_GetIntFromObj --
+ * Tcl_GetIntFromObj/Tcl_GetValue --
  *
  *	Attempt to return an int from the Tcl object "objPtr". If the object
  *	is not already an int, an attempt will be made to convert it to one.
@@ -2501,7 +2547,8 @@ Tcl_SetIntObj(
  *
  *----------------------------------------------------------------------
  */
-
+ 
+#undef Tcl_GetIntFromObj
 int
 Tcl_GetIntFromObj(
     Tcl_Interp *interp,         /* Used for error reporting if not NULL. */
@@ -2516,7 +2563,7 @@ Tcl_GetIntFromObj(
     if (TclGetLongFromObj(interp, objPtr, &l) != TCL_OK) {
 	return TCL_ERROR;
     }
-    if ((ULONG_MAX > UINT_MAX) && ((l > UINT_MAX) || (l < -(long)UINT_MAX))) {
+    if ((ULONG_MAX > UINT_MAX) && ((l > (long)(UINT_MAX)) || (l < (long)(INT_MIN)))) {
 	if (interp != NULL) {
 	    const char *s =
 		    "integer value too large to represent as non-long integer";
@@ -2529,6 +2576,33 @@ Tcl_GetIntFromObj(
     return TCL_OK;
 #endif
 }
+
+int
+Tcl_GetValue(
+    Tcl_Interp *interp,        /* Used for error reporting if not NULL. */
+    Tcl_Obj *objPtr,           /* The object from which to get a int. */
+    void *ptr,                 /* Place to store resulting int. */
+    int flags)
+{
+    double value;
+    int result;
+    if (flags == TCL_TYPE_I(int)) {
+	return Tcl_GetIntFromObj(interp, objPtr, ptr);
+    }
+    if (flags == TCL_TYPE_I(Tcl_WideInt)) {
+	return Tcl_GetWideIntFromObj(interp, objPtr, ptr);
+    }
+    result = Tcl_GetDoubleFromObj(interp, objPtr, &value);
+    if (flags == TCL_TYPE_D(double)) {
+	*(double *)ptr = value;
+    } else if (flags == TCL_TYPE_D(float)) {
+	*(float *)ptr = (float) value;
+    } else {
+	*(long double *)ptr = (long double) value;
+    }
+    return result;
+}
+
 
 /*
  *----------------------------------------------------------------------
@@ -2796,7 +2870,7 @@ Tcl_GetLongFromObj(
 #else
 	if (objPtr->typePtr == &tclIntType) {
 	    /*
-	     * We return any integer in the range -ULONG_MAX to ULONG_MAX
+	     * We return any integer in the range LONG_MIN to ULONG_MAX
 	     * converted to a long, ignoring overflow. The rule preserves
 	     * existing semantics for conversion of integers on input, but
 	     * avoids inadvertent demotion of wide integers to 32-bit ones in
@@ -2805,7 +2879,7 @@ Tcl_GetLongFromObj(
 
 	    Tcl_WideInt w = objPtr->internalRep.wideValue;
 
-	    if (w >= -(Tcl_WideInt)(ULONG_MAX)
+	    if (w >= (Tcl_WideInt)(LONG_MIN)
 		    && w <= (Tcl_WideInt)(ULONG_MAX)) {
 		*longPtr = Tcl_WideAsLong(w);
 		return TCL_OK;

generic/tclScan.c

@@ -571,11 +571,10 @@ Tcl_ScanObjCmd(
     const char *format;
     int numVars, nconversions, totalVars = -1;
     int objIndex, offset, i, result, code;
-    long value;
+    Tcl_WideInt value;
     const char *string, *end, *baseString;
     char op = 0;
     int width, underflow = 0;
-    Tcl_WideInt wideValue;
     Tcl_UniChar ch = 0, sch = 0;
     Tcl_Obj **objs = NULL, *objPtr = NULL;
     int flags;
@@ -924,21 +923,7 @@ Tcl_ScanObjCmd(
 		Tcl_DecrRefCount(objPtr);
 		break;
 	    }
-	    if (flags & SCAN_LONGER) {
-		if (Tcl_GetWideIntFromObj(NULL, objPtr, &wideValue) != TCL_OK) {
-		    wideValue = LLONG_MAX;
-		    if (TclGetString(objPtr)[0] == '-') {
-			wideValue = LLONG_MIN;
-		    }
-		}
-		if ((flags & SCAN_UNSIGNED) && (wideValue < 0)) {
-		    sprintf(buf, "%" TCL_LL_MODIFIER "u",
-			    (Tcl_WideUInt)wideValue);
-		    Tcl_SetStringObj(objPtr, buf, -1);
-		} else {
-		    TclSetIntObj(objPtr, wideValue);
-		}
-	    } else if (flags & SCAN_BIG) {
+	    if (flags & SCAN_BIG) {
 		if (flags & SCAN_UNSIGNED) {
 		    mp_int big;
 		    int code = Tcl_GetBignumFromObj(interp, objPtr, &big);
@@ -963,15 +948,15 @@ Tcl_ScanObjCmd(
 		    }
 		}
 	    } else {
-		if (TclGetLongFromObj(NULL, objPtr, &value) != TCL_OK) {
+		if (TclGetWideIntFromObj(NULL, objPtr, &value) != TCL_OK) {
 		    if (TclGetString(objPtr)[0] == '-') {
-			value = LONG_MIN;
+			value = LLONG_MIN;
 		    } else {
-			value = LONG_MAX;
+			value = LLONG_MAX;
 		    }
 		}
 		if ((flags & SCAN_UNSIGNED) && (value < 0)) {
-		    sprintf(buf, "%lu", value);	/* INTL: ISO digit */
+		    sprintf(buf, "%" TCL_LL_MODIFIER "u", value);	/* INTL: ISO digit */
 		    Tcl_SetStringObj(objPtr, buf, -1);
 		} else {
 		    TclSetIntObj(objPtr, value);

generic/tclStringObj.c

@@ -620,7 +620,7 @@ Tcl_GetUnicode(
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_GetUnicodeFromObj --
+ * Tcl_GetUnicodeFromObj/Tcl_GetUnicodeFromObj2 --
  *
  *	Get the Unicode form of the String object with length. If the object
  *	is not already a String object, it will be converted to one. If the
@@ -636,6 +636,7 @@ Tcl_GetUnicode(
  *----------------------------------------------------------------------
  */
 
+#undef Tcl_GetUnicodeFromObj
 Tcl_UniChar *
 Tcl_GetUnicodeFromObj(
     Tcl_Obj *objPtr,		/* The object to find the unicode string
@@ -659,6 +660,29 @@ Tcl_GetUnicodeFromObj(
     }
     return stringPtr->unicode;
 }
+Tcl_UniChar *
+Tcl_GetUnicodeFromObj2(
+    Tcl_Obj *objPtr,		/* The object to find the unicode string
+				 * for. */
+    size_t *lengthPtr)		/* If non-NULL, the location where the string
+				 * rep's unichar length should be stored. If
+				 * NULL, no length is stored. */
+{
+    String *stringPtr;
+
+    SetStringFromAny(NULL, objPtr);
+    stringPtr = GET_STRING(objPtr);
+
+    if (stringPtr->hasUnicode == 0) {
+	FillUnicodeRep(objPtr);
+	stringPtr = GET_STRING(objPtr);
+    }
+
+    if (lengthPtr != NULL) {
+	*lengthPtr = stringPtr->numChars;
+    }
+    return stringPtr->unicode;
+}
 
 /*
  *----------------------------------------------------------------------
@@ -1793,9 +1817,6 @@ Tcl_AppendFormatToObj(
 	char *end;
 	int gotMinus = 0, gotHash = 0, gotZero = 0, gotSpace = 0, gotPlus = 0;
 	int width, gotPrecision, precision, sawFlag, useShort = 0, useBig = 0;
-#ifndef TCL_WIDE_INT_IS_LONG
-	int useWide = 0;
-#endif
 	int newXpg, numChars, allocSegment = 0, segmentLimit, segmentNumBytes;
 	Tcl_Obj *segment;
 	int step = TclUtfToUniChar(format, &ch);
@@ -1986,18 +2007,11 @@ Tcl_AppendFormatToObj(
 		useBig = 1;
 		format += step;
 		step = TclUtfToUniChar(format, &ch);
-#ifndef TCL_WIDE_INT_IS_LONG
-	    } else {
-		useWide = 1;
-#endif
 	    }
 	} else if (ch == 'I') {
 	    if ((format[1] == '6') && (format[2] == '4')) {
 		format += (step + 2);
 		step = TclUtfToUniChar(format, &ch);
-#ifndef TCL_WIDE_INT_IS_LONG
-		useWide = 1;
-#endif
 	    } else if ((format[1] == '3') && (format[2] == '2')) {
 		format += (step + 2);
 		step = TclUtfToUniChar(format, &ch);
@@ -2067,16 +2081,10 @@ Tcl_AppendFormatToObj(
 	case 'b': {
 	    short s = 0;	/* Silence compiler warning; only defined and
 				 * used when useShort is true. */
-	    long l;
 	    Tcl_WideInt w;
 	    mp_int big;
 	    int toAppend, isNegative = 0;
 
-#ifndef TCL_WIDE_INT_IS_LONG
-	    if (ch == 'p') {
-		useWide = 1;
-	    }
-#endif
 	    if (useBig) {
 		int cmpResult;
 		if (Tcl_GetBignumFromObj(interp, segment, &big) != TCL_OK) {
@@ -2095,53 +2103,32 @@ Tcl_AppendFormatToObj(
 			ch = 'd';
 		    }
 		}
-#ifndef TCL_WIDE_INT_IS_LONG
-	    } else if (useWide) {
-		if (TclGetWideIntFromObj(NULL, segment, &w) != TCL_OK) {
-		    Tcl_Obj *objPtr;
+	    } else if (TclGetWideIntFromObj(NULL, segment, &w) != TCL_OK) {
+		Tcl_Obj *objPtr;
 
-		    if (Tcl_GetBignumFromObj(interp,segment,&big) != TCL_OK) {
-			goto error;
-		    }
-		    mp_mod_2d(&big, (int) CHAR_BIT*sizeof(Tcl_WideInt), &big);
-		    objPtr = Tcl_NewBignumObj(&big);
-		    Tcl_IncrRefCount(objPtr);
-		    TclGetWideIntFromObj(NULL, objPtr, &w);
-		    Tcl_DecrRefCount(objPtr);
-		}
-		isNegative = (w < (Tcl_WideInt) 0);
-		if (w == (Tcl_WideInt) 0) gotHash = 0;
-#endif
-	    } else if (TclGetLongFromObj(NULL, segment, &l) != TCL_OK) {
-		if (TclGetWideIntFromObj(NULL, segment, &w) != TCL_OK) {
-		    Tcl_Obj *objPtr;
-
-		    if (Tcl_GetBignumFromObj(interp,segment,&big) != TCL_OK) {
-			goto error;
-		    }
-		    mp_mod_2d(&big, (int) CHAR_BIT * sizeof(long), &big);
-		    objPtr = Tcl_NewBignumObj(&big);
-		    Tcl_IncrRefCount(objPtr);
-		    TclGetLongFromObj(NULL, objPtr, &l);
-		    Tcl_DecrRefCount(objPtr);
-		} else {
-		    l = Tcl_WideAsLong(w);
+		if (Tcl_GetBignumFromObj(interp,segment,&big) != TCL_OK) {
+		    goto error;
 		}
+		mp_mod_2d(&big, (int) CHAR_BIT * sizeof(long), &big);
+		objPtr = Tcl_NewBignumObj(&big);
+		Tcl_IncrRefCount(objPtr);
+		TclGetWideIntFromObj(NULL, objPtr, &w);
+		Tcl_DecrRefCount(objPtr);
 		if (useShort) {
-		    s = (short) l;
+		    s = (short) w;
 		    isNegative = (s < (short) 0);
 		    if (s == (short) 0) gotHash = 0;
 		} else {
-		    isNegative = (l < (long) 0);
-		    if (l == (long) 0) gotHash = 0;
+		    isNegative = (w < (long) 0);
+		    if (w == (long) 0) gotHash = 0;
 		}
 	    } else if (useShort) {
-		s = (short) l;
+		s = (short) w;
 		isNegative = (s < (short) 0);
 		if (s == (short) 0) gotHash = 0;
 	    } else {
-		isNegative = (l < (long) 0);
-		if (l == (long) 0) gotHash = 0;
+		isNegative = (w < (Tcl_WideInt) 0);
+		if (w == (Tcl_WideInt) 0) gotHash = 0;
 	    }
 
 	    segment = Tcl_NewObj();
@@ -2190,14 +2177,10 @@ Tcl_AppendFormatToObj(
 
 		if (useShort) {
 		    pure = Tcl_NewIntObj((int) s);
-#ifndef TCL_WIDE_INT_IS_LONG
-		} else if (useWide) {
-		    pure = Tcl_NewWideIntObj(w);
-#endif
 		} else if (useBig) {
 		    pure = Tcl_NewBignumObj(&big);
 		} else {
-		    pure = Tcl_NewLongObj(l);
+		    pure = Tcl_NewWideIntObj(w);
 		}
 		Tcl_IncrRefCount(pure);
 		bytes = TclGetStringFromObj(pure, &length);
@@ -2277,16 +2260,6 @@ Tcl_AppendFormatToObj(
 			numDigits++;
 			us /= base;
 		    }
-#ifndef TCL_WIDE_INT_IS_LONG
-		} else if (useWide) {
-		    Tcl_WideUInt uw = (Tcl_WideUInt) w;
-
-		    bits = uw;
-		    while (uw) {
-			numDigits++;
-			uw /= base;
-		    }
-#endif
 		} else if (useBig && big.used) {
 		    int leftover = (big.used * DIGIT_BIT) % numBits;
 		    mp_digit mask = (~(mp_digit)0) << (DIGIT_BIT-leftover);
@@ -2303,12 +2276,12 @@ Tcl_AppendFormatToObj(
 			goto errorMsg;
 		    }
 		} else if (!useBig) {
-		    unsigned long ul = (unsigned long) l;
+		    Tcl_WideUInt uw = (Tcl_WideUInt) w;
 
-		    bits = (Tcl_WideUInt) ul;
-		    while (ul) {
+		    bits = (Tcl_WideUInt) uw;
+		    while (uw) {
 			numDigits++;
-			ul /= base;
+			uw /= base;
 		    }
 		}
 

generic/tclStubInit.c

@@ -271,7 +271,7 @@ static int exprInt(Tcl_Interp *interp, const char *expr, int *ptr){
     long longValue;
     int result = Tcl_ExprLong(interp, expr, &longValue);
     if (result == TCL_OK) {
-	    if ((longValue >= -(long)(UINT_MAX))
+	    if ((longValue >= (long)(INT_MIN))
 		    && (longValue <= (long)(UINT_MAX))) {
 	    *ptr = (int)longValue;
 	} else {
@@ -287,7 +287,7 @@ static int exprIntObj(Tcl_Interp *interp, Tcl_Obj*expr, int *ptr){
     long longValue;
     int result = Tcl_ExprLongObj(interp, expr, &longValue);
     if (result == TCL_OK) {
-	    if ((longValue >= -(long)(UINT_MAX))
+	    if ((longValue >= (long)(INT_MIN))
 		    && (longValue <= (long)(UINT_MAX))) {
 	    *ptr = (int)longValue;
 	} else {
@@ -1590,6 +1590,12 @@ const TclStubs tclStubs = {
     Tcl_FSUnloadFile, /* 629 */
     Tcl_ZlibStreamSetCompressionDictionary, /* 630 */
     Tcl_OpenTcpServerEx, /* 631 */
+    0, /* 632 */
+    0, /* 633 */
+    Tcl_GetValue, /* 634 */
+    Tcl_GetStringFromObj2, /* 635 */
+    Tcl_GetUnicodeFromObj2, /* 636 */
+    Tcl_GetByteArrayFromObj2, /* 637 */
 };
 
 /* !END!: Do not edit above this line. */

generic/tclTest.c

@@ -1724,9 +1724,9 @@ TestdoubledigitsObjCmd(ClientData unused,
     };
 
     const Tcl_ObjType* doubleType;
-    double d;
+    long double d;
     int status;
-    int ndigits;
+    size_t ndigits;
     int type;
     int decpt;
     int signum;
@@ -1743,16 +1743,18 @@ TestdoubledigitsObjCmd(ClientData unused,
     if (status != TCL_OK) {
 	doubleType = Tcl_GetObjType("double");
 	if (objv[1]->typePtr == doubleType
-	    || TclIsNaN(objv[1]->internalRep.doubleValue)) {
+	    && TclIsNaN(objv[1]->internalRep.doubleValue)) {
+	    double d1;
 	    status = TCL_OK;
-	    memcpy(&d, &(objv[1]->internalRep.doubleValue), sizeof(double));
+	    memcpy(&d1, &(objv[1]->internalRep.doubleValue), sizeof(double));
+	    d = d1;
 	}
     }
     if (status != TCL_OK
 	|| Tcl_GetIntFromObj(interp, objv[2], &ndigits) != TCL_OK
 	|| Tcl_GetIndexFromObj(interp, objv[3], options, "conversion type",
 			       TCL_EXACT, &type) != TCL_OK) {
-	fprintf(stderr, "bad value? %g\n", d);
+	fprintf(stderr, "bad value? %Lg\n", d);
 	return TCL_ERROR;
     }
     type = types[type];
@@ -3078,7 +3080,7 @@ TestlinkCmd(
 	}
 	if (argv[6][0] != 0) {
 	    tmp = Tcl_NewStringObj(argv[6], -1);
-	    if (Tcl_GetWideIntFromObj(interp, tmp, &wideVar) != TCL_OK) {
+	    if (Tcl_GetIntFromObj(interp, tmp, &wideVar) != TCL_OK) {
 		Tcl_DecrRefCount(tmp);
 		return TCL_ERROR;
 	    }
@@ -3136,7 +3138,7 @@ TestlinkCmd(
 	if (argv[15][0]) {
 	    Tcl_WideInt w;
 	    tmp = Tcl_NewStringObj(argv[15], -1);
-	    if (Tcl_GetWideIntFromObj(interp, tmp, &w) != TCL_OK) {
+	    if (Tcl_GetIntFromObj(interp, tmp, &w) != TCL_OK) {
 		Tcl_DecrRefCount(tmp);
 		return TCL_ERROR;
 	    }
@@ -3186,7 +3188,7 @@ TestlinkCmd(
 	}
 	if (argv[6][0] != 0) {
 	    tmp = Tcl_NewStringObj(argv[6], -1);
-	    if (Tcl_GetWideIntFromObj(interp, tmp, &wideVar) != TCL_OK) {
+	    if (Tcl_GetIntFromObj(interp, tmp, &wideVar) != TCL_OK) {
 		Tcl_DecrRefCount(tmp);
 		return TCL_ERROR;
 	    }
@@ -3253,7 +3255,7 @@ TestlinkCmd(
 	if (argv[15][0]) {
 	    Tcl_WideInt w;
 	    tmp = Tcl_NewStringObj(argv[15], -1);
-	    if (Tcl_GetWideIntFromObj(interp, tmp, &w) != TCL_OK) {
+	    if (Tcl_GetIntFromObj(interp, tmp, &w) != TCL_OK) {
 		Tcl_DecrRefCount(tmp);
 		return TCL_ERROR;
 	    }
@@ -3381,7 +3383,7 @@ TestparserObjCmd(
     Tcl_Obj *const objv[])	/* The argument objects. */
 {
     const char *script;
-    int length, dummy;
+    size_t length, dummy;
     Tcl_Parse parse;
 
     if (objc != 3) {
@@ -3437,7 +3439,7 @@ TestexprparserObjCmd(
     Tcl_Obj *const objv[])	/* The argument objects. */
 {
     const char *script;
-    int length, dummy;
+    size_t length, dummy;
     Tcl_Parse parse;
 
     if (objc != 3) {
@@ -3724,7 +3726,7 @@ TestprintObjCmd(
     }
 
     if (objc > 1) {
-	Tcl_GetWideIntFromObj(interp, objv[2], &argv1);
+	Tcl_GetIntFromObj(interp, objv[2], &argv1);
     }
     argv2 = (size_t)argv1;
     Tcl_SetObjResult(interp, Tcl_ObjPrintf(Tcl_GetString(objv[1]), argv1, argv2, argv2));

generic/tclTestObj.c

@@ -1171,7 +1171,8 @@ TeststringobjCmd(
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Tcl_UniChar *unicode;
-    int varIndex, option, i, length;
+    int varIndex, option;
+    size_t length, i;
 #define MAX_STRINGS 11
     const char *index, *string, *strings[MAX_STRINGS+1];
     String *strPtr;
@@ -1238,7 +1239,7 @@ TeststringobjCmd(
 	    if (Tcl_IsShared(varPtr[varIndex])) {
 		SetVarToObj(varPtr, varIndex, Tcl_DuplicateObj(varPtr[varIndex]));
 	    }
-	    for (i = 3;  i < objc;  i++) {
+	    for (i = 3;  i < (size_t)objc;  i++) {
 		strings[i-3] = Tcl_GetString(objv[i]);
 	    }
 	    for ( ; i < 12 + 3; i++) {

tests/get.test

@@ -45,14 +45,14 @@ test get-1.7 {Tcl_GetInt procedure} {testgetint longIs64bit} {
     list [catch {testgetint 44 18446744073709551616} msg] $msg $errorCode
 } {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}
 test get-1.8 {Tcl_GetInt procedure} {testgetint longIs64bit} {
-    list [catch {testgetint 18446744073709551614} msg] $msg
-} {0 -2}
+    list [catch {testgetint 18446744073709551614} msg] $msg $errorCode
+} {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}
 test get-1.9 {Tcl_GetInt procedure} {testgetint longIs64bit} {
-    list [catch {testgetint +18446744073709551614} msg] $msg
-} {0 -2}
+    list [catch {testgetint +18446744073709551614} msg] $msg $errorCode
+} {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}
 test get-1.10 {Tcl_GetInt procedure} {testgetint longIs64bit} {
-    list [catch {testgetint -18446744073709551614} msg] $msg
-} {0 2}
+    list [catch {testgetint -18446744073709551614} msg] $msg $errorCode
+} {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}
 test get-1.11 {Tcl_GetInt procedure} {testgetint longIs32bit} {
     list [catch {testgetint 44 4294967296} msg] $msg $errorCode
 } {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}

tests/obj.test

@@ -558,9 +558,9 @@ test obj-33.2 {integer overflow on input} {longIs32bit wideBiggerThanInt} {
     list [string is integer $x] [expr { wide($x) }]
 } {1 4294967295}
 test obj-33.3 {integer overflow on input} {
-    set x 0x10000; append x 0000
-    list [string is integer $x] [expr { wide($x) }]
-} {0 4294967296}
+    set x 0x100000000; append x 00000000
+    list [string is integer $x] [expr { $x }]
+} {0 18446744073709551616}
 test obj-33.4 {integer overflow on input} {longIs32bit wideBiggerThanInt} {
     set x -0x8000; append x 0000
     list [string is integer $x] [expr { wide($x) }]
@@ -574,9 +574,9 @@ test obj-33.6 {integer overflow on input} {longIs32bit wideBiggerThanInt} {
     list [string is integer $x] [expr { wide($x) }]
 } {1 -4294967295}
 test obj-33.7 {integer overflow on input} {
-    set x -0x10000; append x 0000
-    list [string is integer $x] [expr { wide($x) }]
-} {0 -4294967296}
+    set x -0x100000000; append x 00000000
+    list [string is integer $x] [expr { $x }]
+} {0 -18446744073709551616}
 
 test obj-34.1 {mp_iseven} testobj {
     set result ""

tests/platform.test

@@ -43,7 +43,7 @@ test platform-1.1 {TclpSetVariables: tcl_platform} {
 # everything these days.  Note that this does *not* use wide(), and
 # this is intentional since that could make Tcl's numbers wider than
 # the machine-integer on some platforms...
-test platform-2.1 {tcl_platform(wordSize) indicates size of native word} {
+test platform-2.1 {tcl_platform(wordSize) indicates size of native word} nonPortable {
     set result [expr {int(1 << (8 * $tcl_platform(wordSize) - 1))}]
     # Result must be the largest bit in a machine word, which this checks
     # without assuming how wide the word really is

tests/string.test

@@ -807,20 +807,20 @@ test string-6.91.$noComp {string is double, bad doubles} {
     }
     return $result
 } {1 1 0 0 0 1 0 0}
-test string-6.92.$noComp {string is integer, 32-bit overflow} {
+test string-6.92.$noComp {string is integer, 64-bit overflow} {
     # Bug 718878
-    set x 0x100000000
+    set x 0x10000000000000000
     list [run {string is integer -failindex var $x}] $var
 } {0 -1}
-test string-6.93.$noComp {string is integer, 32-bit overflow} {
+test string-6.93.$noComp {string is integer, 64-bit overflow} {
     # Bug 718878
-    set x 0x100000000
+    set x 0x10000000000000000
     append x ""
     list [run {string is integer -failindex var $x}] $var
 } {0 -1}
-test string-6.94.$noComp {string is integer, 32-bit overflow} {
+test string-6.94.$noComp {string is integer, 64-bit overflow} {
     # Bug 718878
-    set x 0x100000000
+    set x 0x10000000000000000
     list [run {string is integer -failindex var [expr {$x}]}] $var
 } {0 -1}
 test string-6.95.$noComp {string is wideinteger, true} {

tests/uplevel.test

@@ -137,18 +137,18 @@ test uplevel-4.15 {level parsing} {
 test uplevel-4.16 {level parsing} {
     apply {{} {uplevel #[expr 1] {}}}
 } {}
-test uplevel-4.17 {level parsing} {
+test uplevel-4.17 {level parsing} -returnCodes error -body {
     apply {{} {uplevel -0xffffffff {}}}
-} {}
-test uplevel-4.18 {level parsing} {
+} -result {invalid command name "-0xffffffff"}
+test uplevel-4.18 {level parsing} -returnCodes error -body {
     apply {{} {uplevel #-0xffffffff {}}}
-} {}
-test uplevel-4.19 {level parsing} {
+} -result {bad level "#-0xffffffff"}
+test uplevel-4.19 {level parsing} -returnCodes error -body {
     apply {{} {uplevel [expr -0xffffffff] {}}}
-} {}
-test uplevel-4.20 {level parsing} {
+} -result {invalid command name "-4294967295"}
+test uplevel-4.20 {level parsing} -returnCodes error -body {
     apply {{} {uplevel #[expr -0xffffffff] {}}}
-} {}
+} -result {bad level "#-4294967295"}
 test uplevel-4.21 {level parsing} -body {
     apply {{} {uplevel -1 {}}}
 } -returnCodes error -result {invalid command name "-1"}