Tcl Source Code

Check-in [81502a66ed]
Login
Bounty program for improvements to Tcl and certain Tcl packages.
Tcl 2019 Conference, Houston/TX, US, Nov 4-8
Send your abstracts to tclconference@googlegroups.com
or submit via the online form by Sep 9.

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Merge 8.7 Move up some stub entries related to Tcl_UniChar Use TCL_UTF_MAX=4 for full Unicode in stead of TCL_UTF_MAX=6 (TCL_UTF_MAX: 3 is default)
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | utf-max-6
Files: files | file ages | folders
SHA3-256:81502a66ed4175657f249d26c80f7f2361a5db4181feb1e5b8fd962db800a470
User & Date: jan.nijtmans 2019-03-16 21:10:20
Context
2019-03-17
22:01
More WIP. Seems to be *almost* working. check-in: ab13cbd74c user: jan.nijtmans tags: utf-max-6
2019-03-16
21:10
Merge 8.7 Move up some stub entries related to Tcl_UniChar Use TCL_UTF_MAX=4 for full Unicode in ste... check-in: 81502a66ed user: jan.nijtmans tags: utf-max-6
2019-03-15
20:52
Eliminate usage of mp_isneg(), just check bignum->sign directly (as libtommath itself does) Make Tcl... check-in: 515a22d41d user: jan.nijtmans tags: core-8-branch
2019-03-14
20:59
Merge 8.7. Fix 2 test-cases which were failing for TCL_UTF_MAX=6 check-in: 4032e7fe99 user: jan.nijtmans tags: utf-max-6
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to .travis.yml.

    76     76           apt:
    77     77             sources:
    78     78               - ubuntu-toolchain-r-test
    79     79             packages:
    80     80               - g++-7
    81     81         env:
    82     82           - BUILD_DIR=unix
    83         -        - CFGOPT=CFLAGS=-DTCL_UTF_MAX=6
           83  +        - CFGOPT=CFLAGS=-DTCL_UTF_MAX=4
           84  +    - os: linux
           85  +      dist: xenial
           86  +      compiler: gcc-7
           87  +      addons:
           88  +        apt:
           89  +          sources:
           90  +            - ubuntu-toolchain-r-test
           91  +          packages:
           92  +            - g++-7
           93  +      env:
           94  +        - BUILD_DIR=unix
           95  +        - CFGOPT=CFLAGS=-DTCL_NO_DEPRECATED=1
    84     96       - os: osx
    85     97         osx_image: xcode8
    86     98         env:
    87     99           - BUILD_DIR=unix
    88    100       - os: osx
    89    101         osx_image: xcode8
    90    102         env:
................................................................................
   132    144               - binutils-mingw-w64-i686
   133    145               - gcc-mingw-w64-i686
   134    146               - gcc-mingw-w64
   135    147               - gcc-multilib
   136    148               - wine
   137    149         env:
   138    150           - BUILD_DIR=win
   139         -        - CFGOPT="--host=i686-w64-mingw32 CFLAGS=-DTCL_UTF_MAX=6"
          151  +        - CFGOPT="--host=i686-w64-mingw32 CFLAGS=-DTCL_UTF_MAX=4"
          152  +        - NO_DIRECT_TEST=1
          153  +    - os: linux
          154  +      dist: xenial
          155  +      compiler: i686-w64-mingw32-gcc
          156  +      addons:
          157  +        apt:
          158  +          packages:
          159  +            - gcc-mingw-w64-base
          160  +            - binutils-mingw-w64-i686
          161  +            - gcc-mingw-w64-i686
          162  +            - gcc-mingw-w64
          163  +            - gcc-multilib
          164  +            - wine
          165  +      env:
          166  +        - BUILD_DIR=win
          167  +        - CFGOPT="--host=i686-w64-mingw32 CFLAGS=-DTCL_NO_DEPRECATED=1"
   140    168           - NO_DIRECT_TEST=1
   141    169   # Test with mingw-w64 (64 bit)
   142    170       - os: linux
   143    171         dist: xenial
   144    172         compiler: x86_64-w64-mingw32-gcc
   145    173         addons:
   146    174           apt:
................................................................................
   163    191               - gcc-mingw-w64-base
   164    192               - binutils-mingw-w64-x86-64
   165    193               - gcc-mingw-w64-x86-64
   166    194               - gcc-mingw-w64
   167    195               - wine
   168    196         env:
   169    197           - BUILD_DIR=win
   170         -        - CFGOPT="--host=x86_64-w64-mingw32 --enable-64bit CFLAGS=-DTCL_UTF_MAX=6"
          198  +        - CFGOPT="--host=x86_64-w64-mingw32 --enable-64bit CFLAGS=-DTCL_UTF_MAX=4"
   171    199           - NO_DIRECT_TEST=1
   172         -
          200  +    - os: linux
          201  +      dist: xenial
          202  +      compiler: x86_64-w64-mingw32-gcc
          203  +      addons:
          204  +        apt:
          205  +          packages:
          206  +            - gcc-mingw-w64-base
          207  +            - binutils-mingw-w64-x86-64
          208  +            - gcc-mingw-w64-x86-64
          209  +            - gcc-mingw-w64
          210  +            - wine
          211  +      env:
          212  +        - BUILD_DIR=win
          213  +        - CFGOPT="--host=x86_64-w64-mingw32 --enable-64bit CFLAGS=-DTCL_NO_DEPRECATED=1"
          214  +        - NO_DIRECT_TEST=1
   173    215   before_install:
   174    216     - export ERROR_ON_FAILURES=1
   175    217     - cd ${BUILD_DIR}
   176    218   install:
   177    219     - test -n "$NO_DIRECT_CONFIGURE" || ./configure ${CFGOPT}
   178    220   script:
   179    221     - make
   180    222     # The styles=develop avoids some weird problems on OSX
   181    223     - test -n "$NO_DIRECT_TEST" || make test styles=develop

Changes to generic/regcustom.h.

    84     84   typedef Tcl_UniChar chr;	/* The type itself. */
    85     85   typedef int pchr;		/* What it promotes to. */
    86     86   typedef unsigned uchr;		/* Unsigned type that will hold a chr. */
    87     87   typedef int celt;		/* Type to hold chr, or NOCELT */
    88     88   #define	NOCELT (-1)		/* Celt value which is not valid chr */
    89     89   #define	CHR(c) (UCHAR(c))	/* Turn char literal into chr literal */
    90     90   #define	DIGITVAL(c) ((c)-'0')	/* Turn chr digit into its value */
    91         -#if TCL_UTF_MAX > 4
           91  +#if TCL_UTF_MAX > 3
    92     92   #define	CHRBITS	32		/* Bits in a chr; must not use sizeof */
    93     93   #define	CHR_MIN	0x00000000	/* Smallest and largest chr; the value */
    94     94   #define	CHR_MAX	0x10ffff	/* CHR_MAX-CHR_MIN+1 should fit in uchr */
    95     95   #else
    96     96   #define	CHRBITS	16		/* Bits in a chr; must not use sizeof */
    97     97   #define	CHR_MIN	0x0000		/* Smallest and largest chr; the value */
    98     98   #define	CHR_MAX	0xffff		/* CHR_MAX-CHR_MIN+1 should fit in uchr */

Changes to generic/tcl.decls.

  1193   1193   }
  1194   1194   declare 334 {
  1195   1195       int Tcl_UtfToLower(char *src)
  1196   1196   }
  1197   1197   declare 335 {
  1198   1198       int Tcl_UtfToTitle(char *src)
  1199   1199   }
  1200         -declare 336 {
  1201         -    int Tcl_UtfToUniChar(const char *src, Tcl_UniChar *chPtr)
  1202         -}
         1200  +#declare 336 {
         1201  +#    int Tcl_UtfToUniChar(const char *src, Tcl_UniChar *chPtr)
         1202  +#}
  1203   1203   declare 337 {
  1204   1204       int Tcl_UtfToUpper(char *src)
  1205   1205   }
  1206   1206   declare 338 {
  1207   1207       int Tcl_WriteChars(Tcl_Channel chan, const char *src, int srcLen)
  1208   1208   }
  1209   1209   declare 339 {
................................................................................
  1241   1241   }
  1242   1242   declare 350 {
  1243   1243       int Tcl_UniCharIsUpper(int ch)
  1244   1244   }
  1245   1245   declare 351 {
  1246   1246       int Tcl_UniCharIsWordChar(int ch)
  1247   1247   }
  1248         -declare 352 {
  1249         -    int Tcl_UniCharLen(const Tcl_UniChar *uniStr)
  1250         -}
  1251         -declare 353 {
  1252         -    int Tcl_UniCharNcmp(const Tcl_UniChar *ucs, const Tcl_UniChar *uct,
  1253         -	    unsigned long numChars)
  1254         -}
  1255         -declare 354 {
  1256         -    char *Tcl_UniCharToUtfDString(const Tcl_UniChar *uniStr,
  1257         -	    int uniLength, Tcl_DString *dsPtr)
  1258         -}
  1259         -declare 355 {
  1260         -    Tcl_UniChar *Tcl_UtfToUniCharDString(const char *src,
  1261         -	    int length, Tcl_DString *dsPtr)
  1262         -}
         1248  +#declare 352 {
         1249  +#    int Tcl_UniCharLen(const Tcl_UniChar *uniStr)
         1250  +#}
         1251  +#declare 353 {
         1252  +#    int Tcl_UniCharNcmp(const Tcl_UniChar *ucs, const Tcl_UniChar *uct,
         1253  +#	    unsigned long numChars)
         1254  +#}
         1255  +#declare 354 {
         1256  +#    char *Tcl_UniCharToUtfDString(const Tcl_UniChar *uniStr,
         1257  +#	    int uniLength, Tcl_DString *dsPtr)
         1258  +#}
         1259  +#declare 355 {
         1260  +#    Tcl_UniChar *Tcl_UtfToUniCharDString(const char *src,
         1261  +#	    int length, Tcl_DString *dsPtr)
         1262  +#}
  1263   1263   declare 356 {
  1264   1264       Tcl_RegExp Tcl_GetRegExpFromObj(Tcl_Interp *interp, Tcl_Obj *patObj,
  1265   1265   	    int flags)
  1266   1266   }
  1267   1267   declare 357 {deprecated {Use Tcl_EvalTokensStandard}} {
  1268   1268       Tcl_Obj *Tcl_EvalTokens(Tcl_Interp *interp, Tcl_Token *tokenPtr,
  1269   1269   	    int count)
................................................................................
  2375   2375       void Tcl_DecrRefCount(Tcl_Obj *objPtr)
  2376   2376   }
  2377   2377   
  2378   2378   declare 643 {
  2379   2379       int Tcl_IsShared(Tcl_Obj *objPtr)
  2380   2380   }
  2381   2381   
         2382  +# TIP #???
  2382   2383   declare 644 {
  2383   2384       int *Tcl_GetUnicodeFromObj(Tcl_Obj *objPtr, int *lengthPtr)
  2384   2385   }
  2385   2386   declare 645 {
  2386   2387       Tcl_Obj *Tcl_NewUnicodeObj(const int *unicode, int numChars)
  2387   2388   }
         2389  +declare 646 {
         2390  +    int Tcl_UtfToUniChar(const char *src, Tcl_UniChar *chPtr)
         2391  +}
         2392  +declare 647 {
         2393  +    int Tcl_UniCharLen(const Tcl_UniChar *uniStr)
         2394  +}
         2395  +declare 648 {
         2396  +    int Tcl_UniCharNcmp(const Tcl_UniChar *ucs, const Tcl_UniChar *uct,
         2397  +	    unsigned long numChars)
         2398  +}
         2399  +declare 649 {
         2400  +    char *Tcl_UniCharToUtfDString(const Tcl_UniChar *uniStr,
         2401  +	    int uniLength, Tcl_DString *dsPtr)
         2402  +}
         2403  +declare 650 {
         2404  +    Tcl_UniChar *Tcl_UtfToUniCharDString(const char *src,
         2405  +	    int length, Tcl_DString *dsPtr)
         2406  +}
         2407  +
  2388   2408   
  2389   2409   # ----- BASELINE -- FOR -- 8.7.0 ----- #
  2390   2410   
  2391   2411   ##############################################################################
  2392   2412   
  2393   2413   # Define the platform specific public Tcl interface. These functions are only
  2394   2414   # available on the designated platform.

Changes to generic/tcl.h.

  2138   2138    * then Tcl_UniChar must be 2-bytes in size (UCS-2) (the default). If 6,
  2139   2139    * then Tcl_UniChar must be 4-bytes in size (UCS-4). At this time UCS-2 mode
  2140   2140    * is the default and recommended mode. UCS-4 is experimental and not
  2141   2141    * recommended. It works for the core, but most extensions expect UCS-2.
  2142   2142    */
  2143   2143   
  2144   2144   #ifndef TCL_UTF_MAX
  2145         -#define TCL_UTF_MAX		4
         2145  +#define TCL_UTF_MAX		3
  2146   2146   #endif
  2147   2147   
  2148   2148   /*
  2149   2149    * This represents a Unicode character. Any changes to this should also be
  2150   2150    * reflected in regcustom.h.
  2151   2151    */
  2152   2152   
  2153         -#if TCL_UTF_MAX > 4
         2153  +#if TCL_UTF_MAX > 3
  2154   2154       /*
  2155   2155        * unsigned int isn't 100% accurate as it should be a strict 4-byte value
  2156   2156        * (perhaps wchar_t). 64-bit systems may have troubles. The size of this
  2157   2157        * value must be reflected correctly in regcustom.h and
  2158   2158        * in tclEncoding.c.
  2159   2159        * XXX: Tcl is currently UCS-2 and planning UTF-16 for the Unicode
  2160   2160        * XXX: string rep that Tcl_UniChar represents.  Changing the size
................................................................................
  2335   2335   
  2336   2336   typedef int (Tcl_NRPostProc) (ClientData data[], Tcl_Interp *interp,
  2337   2337   				int result);
  2338   2338   
  2339   2339   /*
  2340   2340    *----------------------------------------------------------------------------
  2341   2341    * The following constant is used to test for older versions of Tcl in the
  2342         - * stubs tables. If TCL_UTF_MAX>4 use a different value.
         2342  + * stubs tables.
  2343   2343    */
  2344   2344   
  2345         -#define TCL_STUB_MAGIC		((int) 0xFCA3BACF + (TCL_UTF_MAX>4))
         2345  +#define TCL_STUB_MAGIC		((int) 0xFCA3BACF)
  2346   2346   
  2347   2347   /*
  2348   2348    * The following function is required to be defined in all stubs aware
  2349   2349    * extensions. The function is actually implemented in the stub library, not
  2350   2350    * the main Tcl library, although there is a trivial implementation in the
  2351   2351    * main library in case an extension is statically linked into an application.
  2352   2352    */

Changes to generic/tclBasic.c.

  7556   7556   	    }
  7557   7557   	}
  7558   7558   	break;
  7559   7559       case TCL_NUMBER_BIG:
  7560   7560   	if (Tcl_GetBignumFromObj(interp, objv[1], &big) != TCL_OK) {
  7561   7561   	    return TCL_ERROR;
  7562   7562   	}
  7563         -	if (mp_isneg(&big)) {
         7563  +	if (big.sign != MP_ZPOS) {
  7564   7564   	    mp_clear(&big);
  7565   7565   	    goto negarg;
  7566   7566   	}
  7567   7567   	break;
  7568   7568       default:
  7569   7569   	if (TclGetWideIntFromObj(interp, objv[1], &w) != TCL_OK) {
  7570   7570   	    return TCL_ERROR;
................................................................................
  7785   7785       if (TclGetNumberFromObj(interp, objv[1], &ptr, &type) != TCL_OK) {
  7786   7786   	return TCL_ERROR;
  7787   7787       }
  7788   7788   
  7789   7789       if (type == TCL_NUMBER_INT) {
  7790   7790   	Tcl_WideInt l = *((const Tcl_WideInt *) ptr);
  7791   7791   
  7792         -	if (l > (Tcl_WideInt)0) {
         7792  +	if (l > 0) {
  7793   7793   	    goto unChanged;
  7794         -	} else if (l == (Tcl_WideInt)0) {
         7794  +	} else if (l == 0) {
  7795   7795   	    if (TclHasStringRep(objv[1])) {
  7796   7796   		int numBytes;
  7797   7797   		const char *bytes = TclGetStringFromObj(objv[1], &numBytes);
  7798   7798   
  7799   7799   		while (numBytes) {
  7800   7800   		    if (*bytes == '-') {
  7801   7801   			Tcl_SetObjResult(interp, Tcl_NewWideIntObj(0));
................................................................................
  7830   7830   	    goto unChanged;
  7831   7831   	}
  7832   7832   	Tcl_SetObjResult(interp, Tcl_NewDoubleObj(-d));
  7833   7833   	return TCL_OK;
  7834   7834       }
  7835   7835   
  7836   7836       if (type == TCL_NUMBER_BIG) {
  7837         -	if (mp_isneg((const mp_int *) ptr)) {
         7837  +	if (((const mp_int *) ptr)->sign != MP_ZPOS) {
  7838   7838   	    Tcl_GetBignumFromObj(NULL, objv[1], &big);
  7839   7839   	tooLarge:
  7840   7840   	    mp_neg(&big, &big);
  7841   7841   	    Tcl_SetObjResult(interp, Tcl_NewBignumObj(&big));
  7842   7842   	} else {
  7843   7843   	unChanged:
  7844   7844   	    Tcl_SetObjResult(interp, objv[1]);

Changes to generic/tclBinary.c.

  1350   1350    badIndex:
  1351   1351       errorString = "not enough arguments for all format specifiers";
  1352   1352       goto error;
  1353   1353   
  1354   1354    badField:
  1355   1355       {
  1356   1356   	Tcl_UniChar ch = 0;
  1357         -	char buf[TCL_UTF_MAX + 1] = "";
         1357  +	char buf[5] = "";
  1358   1358   
  1359   1359   	TclUtfToUniChar(errorString, &ch);
  1360   1360   	buf[Tcl_UniCharToUtf(ch, buf)] = '\0';
  1361   1361   	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
  1362   1362   		"bad field specifier \"%s\"", buf));
  1363   1363   	return TCL_ERROR;
  1364   1364       }
................................................................................
  1720   1720    badIndex:
  1721   1721       errorString = "not enough arguments for all format specifiers";
  1722   1722       goto error;
  1723   1723   
  1724   1724    badField:
  1725   1725       {
  1726   1726   	Tcl_UniChar ch = 0;
  1727         -	char buf[TCL_UTF_MAX + 1] = "";
         1727  +	char buf[5] = "";
  1728   1728   
  1729   1729   	TclUtfToUniChar(errorString, &ch);
  1730   1730   	buf[Tcl_UniCharToUtf(ch, buf)] = '\0';
  1731   1731   	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
  1732   1732   		"bad field specifier \"%s\"", buf));
  1733   1733   	return TCL_ERROR;
  1734   1734       }

Changes to generic/tclCmdMZ.c.

  1217   1217   	Tcl_InitHashTable(&charReuseTable, TCL_ONE_WORD_KEYS);
  1218   1218   
  1219   1219   	for ( ; stringPtr < end; stringPtr += len) {
  1220   1220   	    int fullchar;
  1221   1221   	    len = TclUtfToUniChar(stringPtr, &ch);
  1222   1222   	    fullchar = ch;
  1223   1223   
  1224         -#if TCL_UTF_MAX <= 4
         1224  +#if TCL_UTF_MAX == 3
  1225   1225   	    if ((ch >= 0xD800) && (len < 3)) {
  1226   1226   		len += TclUtfToUniChar(stringPtr + len, &ch);
  1227   1227   		fullchar = (((fullchar & 0x3ff) << 10) | (ch & 0x3ff)) + 0x10000;
  1228   1228   	    }
  1229   1229   #endif
  1230   1230   
  1231   1231   	    /*
................................................................................
  1441   1441   	 */
  1442   1442   
  1443   1443   	if (TclIsPureByteArray(objv[1])) {
  1444   1444   	    unsigned char uch = (unsigned char) ch;
  1445   1445   
  1446   1446   	    Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(&uch, 1));
  1447   1447   	} else {
  1448         -	    char buf[TCL_UTF_MAX] = "";
         1448  +	    char buf[4] = "";
  1449   1449   
  1450   1450   	    length = Tcl_UniCharToUtf(ch, buf);
  1451   1451   	    if ((ch >= 0xD800) && (length < 3)) {
  1452   1452   		length += Tcl_UniCharToUtf(-1, buf + length);
  1453   1453   	    }
  1454   1454   	    Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, length));
  1455   1455   	}
................................................................................
  1850   1850   	    goto str_is_done;
  1851   1851   	}
  1852   1852   	end = string1 + length1;
  1853   1853   	for (; string1 < end; string1 += length2, failat++) {
  1854   1854   	    int fullchar;
  1855   1855   	    length2 = TclUtfToUniChar(string1, &ch);
  1856   1856   	    fullchar = ch;
  1857         -#if TCL_UTF_MAX <= 4
         1857  +#if TCL_UTF_MAX == 3
  1858   1858   	    if ((ch >= 0xD800) && (length2 < 3)) {
  1859   1859   	    	length2 += TclUtfToUniChar(string1 + length2, &ch);
  1860   1860   	    	fullchar = (((fullchar & 0x3ff) << 10) | (ch & 0x3ff)) + 0x10000;
  1861   1861   	    }
  1862   1862   #endif
  1863   1863   	    if (!chcomp(fullchar)) {
  1864   1864   		result = 0;

Changes to generic/tclCompCmdsSZ.c.

  1498   1498   	PUSH("");
  1499   1499   	count++;
  1500   1500       }
  1501   1501   
  1502   1502       for (endTokenPtr = tokenPtr + parse.numTokens;
  1503   1503   	    tokenPtr < endTokenPtr; tokenPtr = TokenAfter(tokenPtr)) {
  1504   1504   	int length, literal, catchRange, breakJump;
  1505         -	char buf[TCL_UTF_MAX] = "";
         1505  +	char buf[4] = "";
  1506   1506   	JumpFixup startFixup, okFixup, returnFixup, breakFixup;
  1507   1507   	JumpFixup continueFixup, otherFixup, endFixup;
  1508   1508   
  1509   1509   	switch (tokenPtr->type) {
  1510   1510   	case TCL_TOKEN_TEXT:
  1511   1511   	    literal = TclRegisterLiteral(envPtr,
  1512   1512   		    tokenPtr->start, tokenPtr->size, 0);

Changes to generic/tclCompExpr.c.

  2062   2062        * have no direct relevance here.
  2063   2063        */
  2064   2064   
  2065   2065       if (!TclIsBareword(*start) || *start == '_') {
  2066   2066   	if (Tcl_UtfCharComplete(start, numBytes)) {
  2067   2067   	    scanned = TclUtfToUniChar(start, &ch);
  2068   2068   	} else {
  2069         -	    char utfBytes[TCL_UTF_MAX];
         2069  +	    char utfBytes[4];
  2070   2070   
  2071   2071   	    memcpy(utfBytes, start, numBytes);
  2072   2072   	    utfBytes[numBytes] = '\0';
  2073   2073   	    scanned = TclUtfToUniChar(utfBytes, &ch);
  2074   2074   	}
  2075   2075   	*lexemePtr = INVALID;
  2076   2076   	Tcl_DecrRefCount(literal);

Changes to generic/tclCompile.c.

  1740   1740   	    if (tempPtr != NULL) {
  1741   1741   		Tcl_AppendToObj(tempPtr, tokenPtr->start, tokenPtr->size);
  1742   1742   	    }
  1743   1743   	    break;
  1744   1744   
  1745   1745   	case TCL_TOKEN_BS:
  1746   1746   	    if (tempPtr != NULL) {
  1747         -		char utfBuf[TCL_UTF_MAX] = "";
         1747  +		char utfBuf[4] = "";
  1748   1748   		int length = TclParseBackslash(tokenPtr->start,
  1749   1749   			tokenPtr->size, NULL, utfBuf);
  1750   1750   
  1751   1751   		Tcl_AppendToObj(tempPtr, utfBuf, length);
  1752   1752   	    }
  1753   1753   	    break;
  1754   1754   
................................................................................
  2354   2354   				 * compile. */
  2355   2355       int count,			/* Number of tokens to consider at tokenPtr.
  2356   2356   				 * Must be at least 1. */
  2357   2357       CompileEnv *envPtr)		/* Holds the resulting instructions. */
  2358   2358   {
  2359   2359       Tcl_DString textBuffer;	/* Holds concatenated chars from adjacent
  2360   2360   				 * TCL_TOKEN_TEXT, TCL_TOKEN_BS tokens. */
  2361         -    char buffer[TCL_UTF_MAX] = "";
         2361  +    char buffer[4] = "";
  2362   2362       int i, numObjsToConcat, length, adjust;
  2363   2363       unsigned char *entryCodeNext = envPtr->codeNext;
  2364   2364   #define NUM_STATIC_POS 20
  2365   2365       int isLiteral, maxNumCL, numCL;
  2366   2366       int *clPosition = NULL;
  2367   2367       int depth = TclGetStackDepth(envPtr);
  2368   2368   

Changes to generic/tclDecls.h.

  1021   1021   EXTERN char *		Tcl_UtfToExternalDString(Tcl_Encoding encoding,
  1022   1022   				const char *src, int srcLen,
  1023   1023   				Tcl_DString *dsPtr);
  1024   1024   /* 334 */
  1025   1025   EXTERN int		Tcl_UtfToLower(char *src);
  1026   1026   /* 335 */
  1027   1027   EXTERN int		Tcl_UtfToTitle(char *src);
  1028         -/* 336 */
  1029         -EXTERN int		Tcl_UtfToUniChar(const char *src, Tcl_UniChar *chPtr);
         1028  +/* Slot 336 is reserved */
  1030   1029   /* 337 */
  1031   1030   EXTERN int		Tcl_UtfToUpper(char *src);
  1032   1031   /* 338 */
  1033   1032   EXTERN int		Tcl_WriteChars(Tcl_Channel chan, const char *src,
  1034   1033   				int srcLen);
  1035   1034   /* 339 */
  1036   1035   EXTERN int		Tcl_WriteObj(Tcl_Channel chan, Tcl_Obj *objPtr);
................................................................................
  1056   1055   EXTERN int		Tcl_UniCharIsLower(int ch);
  1057   1056   /* 349 */
  1058   1057   EXTERN int		Tcl_UniCharIsSpace(int ch);
  1059   1058   /* 350 */
  1060   1059   EXTERN int		Tcl_UniCharIsUpper(int ch);
  1061   1060   /* 351 */
  1062   1061   EXTERN int		Tcl_UniCharIsWordChar(int ch);
  1063         -/* 352 */
  1064         -EXTERN int		Tcl_UniCharLen(const Tcl_UniChar *uniStr);
  1065         -/* 353 */
  1066         -EXTERN int		Tcl_UniCharNcmp(const Tcl_UniChar *ucs,
  1067         -				const Tcl_UniChar *uct,
  1068         -				unsigned long numChars);
  1069         -/* 354 */
  1070         -EXTERN char *		Tcl_UniCharToUtfDString(const Tcl_UniChar *uniStr,
  1071         -				int uniLength, Tcl_DString *dsPtr);
  1072         -/* 355 */
  1073         -EXTERN Tcl_UniChar *	Tcl_UtfToUniCharDString(const char *src, int length,
  1074         -				Tcl_DString *dsPtr);
         1062  +/* Slot 352 is reserved */
         1063  +/* Slot 353 is reserved */
         1064  +/* Slot 354 is reserved */
         1065  +/* Slot 355 is reserved */
  1075   1066   /* 356 */
  1076   1067   EXTERN Tcl_RegExp	Tcl_GetRegExpFromObj(Tcl_Interp *interp,
  1077   1068   				Tcl_Obj *patObj, int flags);
  1078   1069   /* 357 */
  1079   1070   TCL_DEPRECATED("Use Tcl_EvalTokensStandard")
  1080   1071   Tcl_Obj *		Tcl_EvalTokens(Tcl_Interp *interp,
  1081   1072   				Tcl_Token *tokenPtr, int count);
................................................................................
  1896   1887   /* 643 */
  1897   1888   EXTERN int		Tcl_IsShared(Tcl_Obj *objPtr);
  1898   1889   /* 644 */
  1899   1890   EXTERN int *		Tcl_GetUnicodeFromObj(Tcl_Obj *objPtr,
  1900   1891   				int *lengthPtr);
  1901   1892   /* 645 */
  1902   1893   EXTERN Tcl_Obj *	Tcl_NewUnicodeObj(const int *unicode, int numChars);
         1894  +/* 646 */
         1895  +EXTERN int		Tcl_UtfToUniChar(const char *src, Tcl_UniChar *chPtr);
         1896  +/* 647 */
         1897  +EXTERN int		Tcl_UniCharLen(const Tcl_UniChar *uniStr);
         1898  +/* 648 */
         1899  +EXTERN int		Tcl_UniCharNcmp(const Tcl_UniChar *ucs,
         1900  +				const Tcl_UniChar *uct,
         1901  +				unsigned long numChars);
         1902  +/* 649 */
         1903  +EXTERN char *		Tcl_UniCharToUtfDString(const Tcl_UniChar *uniStr,
         1904  +				int uniLength, Tcl_DString *dsPtr);
         1905  +/* 650 */
         1906  +EXTERN Tcl_UniChar *	Tcl_UtfToUniCharDString(const char *src, int length,
         1907  +				Tcl_DString *dsPtr);
  1903   1908   
  1904   1909   typedef struct {
  1905   1910       const struct TclPlatStubs *tclPlatStubs;
  1906   1911       const struct TclIntStubs *tclIntStubs;
  1907   1912       const struct TclIntPlatStubs *tclIntPlatStubs;
  1908   1913   } TclStubHooks;
  1909   1914   
................................................................................
  2267   2272       const char * (*tcl_UtfFindLast) (const char *src, int ch); /* 329 */
  2268   2273       const char * (*tcl_UtfNext) (const char *src); /* 330 */
  2269   2274       const char * (*tcl_UtfPrev) (const char *src, const char *start); /* 331 */
  2270   2275       int (*tcl_UtfToExternal) (Tcl_Interp *interp, Tcl_Encoding encoding, const char *src, int srcLen, int flags, Tcl_EncodingState *statePtr, char *dst, int dstLen, int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr); /* 332 */
  2271   2276       char * (*tcl_UtfToExternalDString) (Tcl_Encoding encoding, const char *src, int srcLen, Tcl_DString *dsPtr); /* 333 */
  2272   2277       int (*tcl_UtfToLower) (char *src); /* 334 */
  2273   2278       int (*tcl_UtfToTitle) (char *src); /* 335 */
  2274         -    int (*tcl_UtfToUniChar) (const char *src, Tcl_UniChar *chPtr); /* 336 */
         2279  +    void (*reserved336)(void);
  2275   2280       int (*tcl_UtfToUpper) (char *src); /* 337 */
  2276   2281       int (*tcl_WriteChars) (Tcl_Channel chan, const char *src, int srcLen); /* 338 */
  2277   2282       int (*tcl_WriteObj) (Tcl_Channel chan, Tcl_Obj *objPtr); /* 339 */
  2278   2283       char * (*tcl_GetString) (Tcl_Obj *objPtr); /* 340 */
  2279   2284       TCL_DEPRECATED_API("Use Tcl_GetEncodingSearchPath") const char * (*tcl_GetDefaultEncodingDir) (void); /* 341 */
  2280   2285       TCL_DEPRECATED_API("Use Tcl_SetEncodingSearchPath") void (*tcl_SetDefaultEncodingDir) (const char *path); /* 342 */
  2281   2286       void (*tcl_AlertNotifier) (ClientData clientData); /* 343 */
................................................................................
  2283   2288       int (*tcl_UniCharIsAlnum) (int ch); /* 345 */
  2284   2289       int (*tcl_UniCharIsAlpha) (int ch); /* 346 */
  2285   2290       int (*tcl_UniCharIsDigit) (int ch); /* 347 */
  2286   2291       int (*tcl_UniCharIsLower) (int ch); /* 348 */
  2287   2292       int (*tcl_UniCharIsSpace) (int ch); /* 349 */
  2288   2293       int (*tcl_UniCharIsUpper) (int ch); /* 350 */
  2289   2294       int (*tcl_UniCharIsWordChar) (int ch); /* 351 */
  2290         -    int (*tcl_UniCharLen) (const Tcl_UniChar *uniStr); /* 352 */
  2291         -    int (*tcl_UniCharNcmp) (const Tcl_UniChar *ucs, const Tcl_UniChar *uct, unsigned long numChars); /* 353 */
  2292         -    char * (*tcl_UniCharToUtfDString) (const Tcl_UniChar *uniStr, int uniLength, Tcl_DString *dsPtr); /* 354 */
  2293         -    Tcl_UniChar * (*tcl_UtfToUniCharDString) (const char *src, int length, Tcl_DString *dsPtr); /* 355 */
         2295  +    void (*reserved352)(void);
         2296  +    void (*reserved353)(void);
         2297  +    void (*reserved354)(void);
         2298  +    void (*reserved355)(void);
  2294   2299       Tcl_RegExp (*tcl_GetRegExpFromObj) (Tcl_Interp *interp, Tcl_Obj *patObj, int flags); /* 356 */
  2295   2300       TCL_DEPRECATED_API("Use Tcl_EvalTokensStandard") Tcl_Obj * (*tcl_EvalTokens) (Tcl_Interp *interp, Tcl_Token *tokenPtr, int count); /* 357 */
  2296   2301       void (*tcl_FreeParse) (Tcl_Parse *parsePtr); /* 358 */
  2297   2302       void (*tcl_LogCommandInfo) (Tcl_Interp *interp, const char *script, const char *command, int length); /* 359 */
  2298   2303       int (*tcl_ParseBraces) (Tcl_Interp *interp, const char *start, int numBytes, Tcl_Parse *parsePtr, int append, const char **termPtr); /* 360 */
  2299   2304       int (*tcl_ParseCommand) (Tcl_Interp *interp, const char *start, int numBytes, int nested, Tcl_Parse *parsePtr); /* 361 */
  2300   2305       int (*tcl_ParseExpr) (Tcl_Interp *interp, const char *start, int numBytes, Tcl_Parse *parsePtr); /* 362 */
................................................................................
  2577   2582       void (*tcl_StoreIntRep) (Tcl_Obj *objPtr, const Tcl_ObjType *typePtr, const Tcl_ObjIntRep *irPtr); /* 639 */
  2578   2583       int (*tcl_HasStringRep) (Tcl_Obj *objPtr); /* 640 */
  2579   2584       void (*tcl_IncrRefCount) (Tcl_Obj *objPtr); /* 641 */
  2580   2585       void (*tcl_DecrRefCount) (Tcl_Obj *objPtr); /* 642 */
  2581   2586       int (*tcl_IsShared) (Tcl_Obj *objPtr); /* 643 */
  2582   2587       int * (*tcl_GetUnicodeFromObj) (Tcl_Obj *objPtr, int *lengthPtr); /* 644 */
  2583   2588       Tcl_Obj * (*tcl_NewUnicodeObj) (const int *unicode, int numChars); /* 645 */
         2589  +    int (*tcl_UtfToUniChar) (const char *src, Tcl_UniChar *chPtr); /* 646 */
         2590  +    int (*tcl_UniCharLen) (const Tcl_UniChar *uniStr); /* 647 */
         2591  +    int (*tcl_UniCharNcmp) (const Tcl_UniChar *ucs, const Tcl_UniChar *uct, unsigned long numChars); /* 648 */
         2592  +    char * (*tcl_UniCharToUtfDString) (const Tcl_UniChar *uniStr, int uniLength, Tcl_DString *dsPtr); /* 649 */
         2593  +    Tcl_UniChar * (*tcl_UtfToUniCharDString) (const char *src, int length, Tcl_DString *dsPtr); /* 650 */
  2584   2594   } TclStubs;
  2585   2595   
  2586   2596   extern const TclStubs *tclStubsPtr;
  2587   2597   
  2588   2598   #ifdef __cplusplus
  2589   2599   }
  2590   2600   #endif
................................................................................
  3279   3289   	(tclStubsPtr->tcl_UtfToExternal) /* 332 */
  3280   3290   #define Tcl_UtfToExternalDString \
  3281   3291   	(tclStubsPtr->tcl_UtfToExternalDString) /* 333 */
  3282   3292   #define Tcl_UtfToLower \
  3283   3293   	(tclStubsPtr->tcl_UtfToLower) /* 334 */
  3284   3294   #define Tcl_UtfToTitle \
  3285   3295   	(tclStubsPtr->tcl_UtfToTitle) /* 335 */
  3286         -#define Tcl_UtfToUniChar \
  3287         -	(tclStubsPtr->tcl_UtfToUniChar) /* 336 */
         3296  +/* Slot 336 is reserved */
  3288   3297   #define Tcl_UtfToUpper \
  3289   3298   	(tclStubsPtr->tcl_UtfToUpper) /* 337 */
  3290   3299   #define Tcl_WriteChars \
  3291   3300   	(tclStubsPtr->tcl_WriteChars) /* 338 */
  3292   3301   #define Tcl_WriteObj \
  3293   3302   	(tclStubsPtr->tcl_WriteObj) /* 339 */
  3294   3303   #define Tcl_GetString \
................................................................................
  3311   3320   	(tclStubsPtr->tcl_UniCharIsLower) /* 348 */
  3312   3321   #define Tcl_UniCharIsSpace \
  3313   3322   	(tclStubsPtr->tcl_UniCharIsSpace) /* 349 */
  3314   3323   #define Tcl_UniCharIsUpper \
  3315   3324   	(tclStubsPtr->tcl_UniCharIsUpper) /* 350 */
  3316   3325   #define Tcl_UniCharIsWordChar \
  3317   3326   	(tclStubsPtr->tcl_UniCharIsWordChar) /* 351 */
  3318         -#define Tcl_UniCharLen \
  3319         -	(tclStubsPtr->tcl_UniCharLen) /* 352 */
  3320         -#define Tcl_UniCharNcmp \
  3321         -	(tclStubsPtr->tcl_UniCharNcmp) /* 353 */
  3322         -#define Tcl_UniCharToUtfDString \
  3323         -	(tclStubsPtr->tcl_UniCharToUtfDString) /* 354 */
  3324         -#define Tcl_UtfToUniCharDString \
  3325         -	(tclStubsPtr->tcl_UtfToUniCharDString) /* 355 */
         3327  +/* Slot 352 is reserved */
         3328  +/* Slot 353 is reserved */
         3329  +/* Slot 354 is reserved */
         3330  +/* Slot 355 is reserved */
  3326   3331   #define Tcl_GetRegExpFromObj \
  3327   3332   	(tclStubsPtr->tcl_GetRegExpFromObj) /* 356 */
  3328   3333   #define Tcl_EvalTokens \
  3329   3334   	(tclStubsPtr->tcl_EvalTokens) /* 357 */
  3330   3335   #define Tcl_FreeParse \
  3331   3336   	(tclStubsPtr->tcl_FreeParse) /* 358 */
  3332   3337   #define Tcl_LogCommandInfo \
................................................................................
  3899   3904   	(tclStubsPtr->tcl_DecrRefCount) /* 642 */
  3900   3905   #define Tcl_IsShared \
  3901   3906   	(tclStubsPtr->tcl_IsShared) /* 643 */
  3902   3907   #define Tcl_GetUnicodeFromObj \
  3903   3908   	(tclStubsPtr->tcl_GetUnicodeFromObj) /* 644 */
  3904   3909   #define Tcl_NewUnicodeObj \
  3905   3910   	(tclStubsPtr->tcl_NewUnicodeObj) /* 645 */
         3911  +#define Tcl_UtfToUniChar \
         3912  +	(tclStubsPtr->tcl_UtfToUniChar) /* 646 */
         3913  +#define Tcl_UniCharLen \
         3914  +	(tclStubsPtr->tcl_UniCharLen) /* 647 */
         3915  +#define Tcl_UniCharNcmp \
         3916  +	(tclStubsPtr->tcl_UniCharNcmp) /* 648 */
         3917  +#define Tcl_UniCharToUtfDString \
         3918  +	(tclStubsPtr->tcl_UniCharToUtfDString) /* 649 */
         3919  +#define Tcl_UtfToUniCharDString \
         3920  +	(tclStubsPtr->tcl_UtfToUniCharDString) /* 650 */
  3906   3921   
  3907   3922   #endif /* defined(USE_TCL_STUBS) */
  3908   3923   
  3909   3924   /* !END!: Do not edit above this line. */
  3910   3925   
  3911   3926   #if defined(USE_TCL_STUBS)
  3912   3927   #   undef Tcl_CreateInterp
................................................................................
  4080   4095   #undef Tcl_SetLongObj
  4081   4096   #define Tcl_SetLongObj(objPtr, value)	Tcl_SetWideIntObj((objPtr), (long)(value))
  4082   4097   #undef Tcl_GetUnicode
  4083   4098   #define Tcl_GetUnicode(objPtr)	Tcl_GetUnicodeFromObj((objPtr), NULL)
  4084   4099   #undef Tcl_BackgroundError
  4085   4100   #define Tcl_BackgroundError(interp)	Tcl_BackgroundException((interp), TCL_ERROR)
  4086   4101   
  4087         -#if TCL_UTF_MAX <= 4
         4102  +#if TCL_UTF_MAX == 3
  4088   4103   #   undef Tcl_GetUnicodeFromObj
  4089   4104   #   define Tcl_GetUnicodeFromObj Tcl_GetUtf16FromObj
  4090   4105   #   undef Tcl_NewUnicodeObj
  4091   4106   #   define Tcl_NewUnicodeObj Tcl_NewUtf16Obj
  4092   4107   #endif
  4093   4108   
  4094   4109   /*

Changes to generic/tclDisassemble.c.

   899    899   	    i += 2;
   900    900   	    continue;
   901    901   	case '\v':
   902    902   	    Tcl_AppendToObj(appendObj, "\\v", -1);
   903    903   	    i += 2;
   904    904   	    continue;
   905    905   	default:
   906         -#if TCL_UTF_MAX > 4
          906  +#if TCL_UTF_MAX > 3
   907    907   	    if (ch > 0xffff) {
   908    908   		Tcl_AppendPrintfToObj(appendObj, "\\U%08x", ch);
   909    909   		i += 10;
   910    910   	    } else
   911    911   #else
   912    912   	    /* If len == 0, this means we have a char > 0xffff, resulting in
   913    913   	     * TclUtfToUniChar producing a surrogate pair. We want to output

Changes to generic/tclEncoding.c.

  1293   1293   
  1294   1294   	result = encodingPtr->toUtfProc(encodingPtr->clientData, src, srcLen,
  1295   1295   		flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr,
  1296   1296   		dstCharsPtr);
  1297   1297   	if (*dstCharsPtr <= maxChars) {
  1298   1298   	    break;
  1299   1299   	}
  1300         -	dstLen = Tcl_UtfAtIndex(dst, maxChars) - 1 - dst + TCL_UTF_MAX;
         1300  +	dstLen = Tcl_UtfAtIndex(dst, maxChars) - dst + (TCL_UTF_MAX - 1);
  1301   1301   	flags = savedFlags;
  1302   1302   	*statePtr = savedState;
  1303   1303       } while (1);
  1304   1304       if (!noTerminate) {
  1305   1305   	/* ...and then append it */
  1306   1306   
  1307   1307   	dst[*dstWrotePtr] = '\0';
................................................................................
  2397   2397   	    *chPtr = (unsigned char) *src;
  2398   2398   	    src += 1;
  2399   2399   	    dst += Tcl_UniCharToUtf(*chPtr, dst);
  2400   2400   	} else {
  2401   2401   	    int len = TclUtfToUniChar(src, chPtr);
  2402   2402   	    src += len;
  2403   2403   	    dst += Tcl_UniCharToUtf(*chPtr, dst);
  2404         -#if TCL_UTF_MAX <= 4
         2404  +#if TCL_UTF_MAX == 3
  2405   2405   	    if ((*chPtr >= 0xD800) && (len < 3)) {
  2406   2406   		src += TclUtfToUniChar(src + len, chPtr);
  2407   2407   		dst += Tcl_UniCharToUtf(*chPtr, dst);
  2408   2408   	    }
  2409   2409   #endif
  2410   2410   	}
  2411   2411       }
................................................................................
  2586   2586   
  2587   2587   	/*
  2588   2588   	 * Need to handle this in a way that won't cause misalignment by
  2589   2589   	 * casting dst to a Tcl_UniChar. [Bug 1122671]
  2590   2590   	 */
  2591   2591   
  2592   2592   #ifdef WORDS_BIGENDIAN
  2593         -#if TCL_UTF_MAX > 4
         2593  +#if TCL_UTF_MAX > 3
  2594   2594   	if (*chPtr <= 0xFFFF) {
  2595   2595   	    *dst++ = (*chPtr >> 8);
  2596   2596   	    *dst++ = (*chPtr & 0xFF);
  2597   2597   	} else {
  2598   2598   	    *dst++ = ((*chPtr & 0x3) >> 8) | 0xDC;
  2599   2599   	    *dst++ = (*chPtr & 0xFF);
  2600   2600   	    *dst++ = (((*chPtr - 0x10000) >> 18) & 0x3) | 0xD8;
................................................................................
  2601   2601   	    *dst++ = (((*chPtr - 0x10000) >> 10) & 0xFF);
  2602   2602   	}
  2603   2603   #else
  2604   2604   	*dst++ = (*chPtr >> 8);
  2605   2605   	*dst++ = (*chPtr & 0xFF);
  2606   2606   #endif
  2607   2607   #else
  2608         -#if TCL_UTF_MAX > 4
         2608  +#if TCL_UTF_MAX > 3
  2609   2609   	if (*chPtr <= 0xFFFF) {
  2610   2610   	    *dst++ = (*chPtr & 0xFF);
  2611   2611   	    *dst++ = (*chPtr >> 8);
  2612   2612   	} else {
  2613   2613   	    *dst++ = (((*chPtr - 0x10000) >> 10) & 0xFF);
  2614   2614   	    *dst++ = (((*chPtr - 0x10000) >> 18) & 0x3) | 0xD8;
  2615   2615   	    *dst++ = (*chPtr & 0xFF);
................................................................................
  2669   2669   				 * the conversion. */
  2670   2670       int *dstCharsPtr)		/* Filled with the number of characters that
  2671   2671   				 * correspond to the bytes stored in the
  2672   2672   				 * output buffer. */
  2673   2673   {
  2674   2674       const char *srcStart, *srcEnd, *srcClose, *dstStart, *dstEnd;
  2675   2675       int result, numChars;
  2676         -#if TCL_UTF_MAX <= 4
         2676  +#if TCL_UTF_MAX == 3
  2677   2677       int len;
  2678   2678   #endif
  2679   2679       Tcl_UniChar ch = 0;
  2680   2680   
  2681   2681       srcStart = src;
  2682   2682       srcEnd = src + srcLen;
  2683   2683       srcClose = srcEnd;
................................................................................
  2699   2699   	    result = TCL_CONVERT_MULTIBYTE;
  2700   2700   	    break;
  2701   2701   	}
  2702   2702   	if (dst > dstEnd) {
  2703   2703   	    result = TCL_CONVERT_NOSPACE;
  2704   2704   	    break;
  2705   2705   	}
  2706         -#if TCL_UTF_MAX <= 4
         2706  +#if TCL_UTF_MAX == 3
  2707   2707   	src += (len = TclUtfToUniChar(src, &ch));
  2708   2708   	if ((ch >= 0xD800) && (len < 3)) {
  2709   2709   	    src += TclUtfToUniChar(src, &ch);
  2710   2710   	    ch = 0xFFFD;
  2711   2711   	}
  2712   2712   #else
  2713   2713   	src += TclUtfToUniChar(src, &ch);
................................................................................
  2923   2923   	     */
  2924   2924   
  2925   2925   	    result = TCL_CONVERT_MULTIBYTE;
  2926   2926   	    break;
  2927   2927   	}
  2928   2928   	len = TclUtfToUniChar(src, &ch);
  2929   2929   
  2930         -#if TCL_UTF_MAX > 4
         2930  +#if TCL_UTF_MAX > 3
  2931   2931   	/*
  2932   2932   	 * This prevents a crash condition. More evaluation is required for
  2933   2933   	 * full support of int Tcl_UniChar. [Bug 1004065]
  2934   2934   	 */
  2935   2935   
  2936   2936   	if (ch & 0xffff0000) {
  2937   2937   	    word = 0;
................................................................................
  3134   3134   	len = TclUtfToUniChar(src, &ch);
  3135   3135   
  3136   3136   	/*
  3137   3137   	 * Check for illegal characters.
  3138   3138   	 */
  3139   3139   
  3140   3140   	if (ch > 0xff
  3141         -#if TCL_UTF_MAX <= 4
         3141  +#if TCL_UTF_MAX == 3
  3142   3142   		|| ((ch >= 0xD800) && (len < 3))
  3143   3143   #endif
  3144   3144   		) {
  3145   3145   	    if (flags & TCL_ENCODING_STOPONERROR) {
  3146   3146   		result = TCL_CONVERT_UNKNOWN;
  3147   3147   		break;
  3148   3148   	    }
  3149         -#if TCL_UTF_MAX <= 4
         3149  +#if TCL_UTF_MAX == 3
  3150   3150   	    if ((ch >= 0xD800) && (len < 3)) len = 4;
  3151   3151   #endif
  3152   3152   	    /*
  3153   3153   	     * Plunge on, using '?' as a fallback character.
  3154   3154   	     */
  3155   3155   
  3156   3156   	    ch = (Tcl_UniChar) '?';

Changes to generic/tclExecute.c.

  5211   5211   	} else if (TclIsPureByteArray(valuePtr)) {
  5212   5212   	    objResultPtr = Tcl_NewByteArrayObj(
  5213   5213   		    Tcl_GetByteArrayFromObj(valuePtr, NULL)+index, 1);
  5214   5214   	} else if (valuePtr->bytes && length == valuePtr->length) {
  5215   5215   	    objResultPtr = Tcl_NewStringObj((const char *)
  5216   5216   		    valuePtr->bytes+index, 1);
  5217   5217   	} else {
  5218         -	    char buf[TCL_UTF_MAX] = "";
         5218  +	    char buf[4] = "";
  5219   5219   	    int ch = Tcl_GetUniChar(valuePtr, index);
  5220   5220   
  5221   5221   	    /*
  5222   5222   	     * This could be: Tcl_NewUnicodeObj((const Tcl_UniChar *)&ch, 1)
  5223   5223   	     * but creating the object as a string seems to be faster in
  5224   5224   	     * practical use.
  5225   5225   	     */
................................................................................
  7981   7981   		/*
  7982   7982   		 * Force Tcl's integer division rules.
  7983   7983   		 * TODO: examine for logic simplification
  7984   7984   		 */
  7985   7985   
  7986   7986   		if (((wQuotient < (Tcl_WideInt) 0)
  7987   7987   			|| ((wQuotient == (Tcl_WideInt) 0)
  7988         -			&& ((w1 < (Tcl_WideInt)0 && w2 > (Tcl_WideInt)0)
  7989         -			|| (w1 > (Tcl_WideInt)0 && w2 < (Tcl_WideInt)0))))
         7988  +			&& ((w1 < 0 && w2 > 0)
         7989  +			|| (w1 > 0 && w2 < 0))))
  7990   7990   			&& (wQuotient * w2 != w1)) {
  7991   7991   		    wQuotient -= (Tcl_WideInt) 1;
  7992   7992   		}
  7993   7993   		wRemainder = w1 - w2*wQuotient;
  7994   7994   		WIDE_RESULT(wRemainder);
  7995   7995   	    }
  7996   7996   
................................................................................
  8016   8016   	    return NULL;
  8017   8017   	}
  8018   8018   	Tcl_GetBignumFromObj(NULL, valuePtr, &big1);
  8019   8019   	Tcl_GetBignumFromObj(NULL, value2Ptr, &big2);
  8020   8020   	mp_init(&bigResult);
  8021   8021   	mp_init(&bigRemainder);
  8022   8022   	mp_div(&big1, &big2, &bigResult, &bigRemainder);
  8023         -	if (!mp_iszero(&bigRemainder) && (bigRemainder.sign != big2.sign)) {
         8023  +	if ((bigRemainder.used != 0) && (bigRemainder.sign != big2.sign)) {
  8024   8024   	    /*
  8025   8025   	     * Convert to Tcl's integer division rules.
  8026   8026   	     */
  8027   8027   
  8028   8028   	    mp_sub_d(&bigResult, 1, &bigResult);
  8029   8029   	    mp_add(&bigRemainder, &big2, &bigRemainder);
  8030   8030   	}
................................................................................
  8038   8038       case INST_RSHIFT: {
  8039   8039   	/*
  8040   8040   	 * Reject negative shift argument.
  8041   8041   	 */
  8042   8042   
  8043   8043   	switch (type2) {
  8044   8044   	case TCL_NUMBER_INT:
  8045         -	    invalid = (*((const Tcl_WideInt *)ptr2) < (Tcl_WideInt)0);
         8045  +	    invalid = (*((const Tcl_WideInt *)ptr2) < 0);
  8046   8046   	    break;
  8047   8047   	case TCL_NUMBER_BIG:
  8048   8048   	    Tcl_TakeBignumFromObj(NULL, value2Ptr, &big2);
  8049         -	    invalid = mp_isneg(&big2);
         8049  +	    invalid = big2.sign != MP_ZPOS;
  8050   8050   	    mp_clear(&big2);
  8051   8051   	    break;
  8052   8052   	default:
  8053   8053   	    /* Unused, here to silence compiler warning */
  8054   8054   	    invalid = 0;
  8055   8055   	}
  8056   8056   	if (invalid) {
................................................................................
  8059   8059   	    return GENERAL_ARITHMETIC_ERROR;
  8060   8060   	}
  8061   8061   
  8062   8062   	/*
  8063   8063   	 * Zero shifted any number of bits is still zero.
  8064   8064   	 */
  8065   8065   
  8066         -	if ((type1==TCL_NUMBER_INT) && (*((const Tcl_WideInt *)ptr1) == (Tcl_WideInt)0)) {
         8066  +	if ((type1==TCL_NUMBER_INT) && (*((const Tcl_WideInt *)ptr1) == 0)) {
  8067   8067   	    return constants[0];
  8068   8068   	}
  8069   8069   
  8070   8070   	if (opcode == INST_LSHIFT) {
  8071   8071   	    /*
  8072   8072   	     * Large left shifts create integer overflow.
  8073   8073   	     *
................................................................................
  8117   8117   		 * not take us to the result of 0 or -1, but since we're using
  8118   8118   		 * mp_div_2d to do the work, and it takes only an int
  8119   8119   		 * argument, we draw the line there.
  8120   8120   		 */
  8121   8121   
  8122   8122   		switch (type1) {
  8123   8123   		case TCL_NUMBER_INT:
  8124         -		    zero = (*(const Tcl_WideInt *)ptr1 > (Tcl_WideInt)0);
         8124  +		    zero = (*(const Tcl_WideInt *)ptr1 > 0);
  8125   8125   		    break;
  8126   8126   		case TCL_NUMBER_BIG:
  8127   8127   		    Tcl_TakeBignumFromObj(NULL, valuePtr, &big1);
  8128         -		    zero = (!mp_isneg(&big1));
         8128  +		    zero = (big1.sign == MP_ZPOS);
  8129   8129   		    mp_clear(&big1);
  8130   8130   		    break;
  8131   8131   		default:
  8132   8132   		    /* Unused, here to silence compiler warning. */
  8133   8133   		    zero = 0;
  8134   8134   		}
  8135   8135   		if (zero) {
................................................................................
  8142   8142   	    /*
  8143   8143   	     * Handle shifts within the native wide range.
  8144   8144   	     */
  8145   8145   
  8146   8146   	    if (type1 == TCL_NUMBER_INT) {
  8147   8147   		w1 = *(const Tcl_WideInt *)ptr1;
  8148   8148   		if ((size_t)shift >= CHAR_BIT*sizeof(Tcl_WideInt)) {
  8149         -		    if (w1 >= (Tcl_WideInt)0) {
         8149  +		    if (w1 >= 0) {
  8150   8150   			return constants[0];
  8151   8151   		    }
  8152   8152   		    WIDE_RESULT(-1);
  8153   8153   		}
  8154   8154   		WIDE_RESULT(w1 >> shift);
  8155   8155   	    }
  8156   8156   	}
................................................................................
  8245   8245   		return NULL;
  8246   8246   	    }
  8247   8247   
  8248   8248   	    negativeExponent = (w2 < 0);
  8249   8249   	    oddExponent = (int) (w2 & (Tcl_WideInt)1);
  8250   8250   	} else {
  8251   8251   	    Tcl_TakeBignumFromObj(NULL, value2Ptr, &big2);
  8252         -	    negativeExponent = mp_isneg(&big2);
         8252  +	    negativeExponent = big2.sign != MP_ZPOS;
  8253   8253   	    mp_mod_2d(&big2, 1, &big2);
  8254         -	    oddExponent = !mp_iszero(&big2);
         8254  +	    oddExponent = big2.used != 0;
  8255   8255   	    mp_clear(&big2);
  8256   8256   	}
  8257   8257   
  8258   8258   	if (type1 == TCL_NUMBER_INT) {
  8259   8259   	    w1 = *((const Tcl_WideInt *)ptr1);
  8260   8260   
  8261   8261   	    if (negativeExponent) {
................................................................................
  8564   8564   	case INST_SUB:
  8565   8565   	    mp_sub(&big1, &big2, &bigResult);
  8566   8566   	    break;
  8567   8567   	case INST_MULT:
  8568   8568   	    mp_mul(&big1, &big2, &bigResult);
  8569   8569   	    break;
  8570   8570   	case INST_DIV:
  8571         -	    if (mp_iszero(&big2)) {
         8571  +	    if (big2.used == 0) {
  8572   8572   		mp_clear(&big1);
  8573   8573   		mp_clear(&big2);
  8574   8574   		mp_clear(&bigResult);
  8575   8575   		return DIVIDED_BY_ZERO;
  8576   8576   	    }
  8577   8577   	    mp_init(&bigRemainder);
  8578   8578   	    mp_div(&big1, &big2, &bigResult, &bigRemainder);
  8579   8579   	    /* TODO: internals intrusion */
  8580         -	    if (!mp_iszero(&bigRemainder)
         8580  +	    if ((bigRemainder.used != 0)
  8581   8581   		    && (bigRemainder.sign != big2.sign)) {
  8582   8582   		/*
  8583   8583   		 * Convert to Tcl's integer division rules.
  8584   8584   		 */
  8585   8585   
  8586   8586   		mp_sub_d(&bigResult, 1, &bigResult);
  8587   8587   		mp_add(&bigRemainder, &big2, &bigRemainder);
................................................................................
  8720   8720   	    if (d2 > (double)WIDE_MAX) {
  8721   8721   		return MP_LT;
  8722   8722   	    }
  8723   8723   	    w2 = (Tcl_WideInt) d2;
  8724   8724   	    goto wideCompare;
  8725   8725   	case TCL_NUMBER_BIG:
  8726   8726   	    Tcl_TakeBignumFromObj(NULL, value2Ptr, &big2);
  8727         -	    if (mp_isneg(&big2)) {
         8727  +	    if (big2.sign != MP_ZPOS) {
  8728   8728   		compare = MP_GT;
  8729   8729   	    } else {
  8730   8730   		compare = MP_LT;
  8731   8731   	    }
  8732   8732   	    mp_clear(&big2);
  8733   8733   	    return compare;
  8734   8734   	}
................................................................................
  8757   8757   	    goto wideCompare;
  8758   8758   	case TCL_NUMBER_BIG:
  8759   8759   	    if (TclIsInfinite(d1)) {
  8760   8760   		return (d1 > 0.0) ? MP_GT : MP_LT;
  8761   8761   	    }
  8762   8762   	    Tcl_TakeBignumFromObj(NULL, value2Ptr, &big2);
  8763   8763   	    if ((d1 < (double)WIDE_MAX) && (d1 > (double)WIDE_MIN)) {
  8764         -		if (mp_isneg(&big2)) {
         8764  +		if (big2.sign != MP_ZPOS) {
  8765   8765   		    compare = MP_GT;
  8766   8766   		} else {
  8767   8767   		    compare = MP_LT;
  8768   8768   		}
  8769   8769   		mp_clear(&big2);
  8770   8770   		return compare;
  8771   8771   	    }

Changes to generic/tclIO.c.

  4701   4701   	    if (GotFlag(statePtr, INPUT_SAW_CR)) {
  4702   4702   		ResetFlag(statePtr, INPUT_SAW_CR);
  4703   4703   		if ((eol < dstEnd) && (*eol == '\n')) {
  4704   4704   		    /*
  4705   4705   		     * Skip the raw bytes that make up the '\n'.
  4706   4706   		     */
  4707   4707   
  4708         -		    char tmp[TCL_UTF_MAX];
         4708  +		    char tmp[4];
  4709   4709   		    int rawRead;
  4710   4710   
  4711   4711   		    bufPtr = gs.bufPtr;
  4712   4712   		    Tcl_ExternalToUtf(NULL, gs.encoding, RemovePoint(bufPtr),
  4713   4713   			    gs.rawRead, statePtr->inputEncodingFlags
  4714   4714   				| TCL_ENCODING_NO_TERMINATE, &gs.state, tmp,
  4715   4715   			    TCL_UTF_MAX, &rawRead, NULL, NULL);
................................................................................
  6212   6212   		{
  6213   6213   		    /*
  6214   6214   		     * There are chars leading the buffer before the eof char.
  6215   6215   		     * Adjust the dstLimit so we go back and read only those
  6216   6216   		     * and do not encounter the eof char this time.
  6217   6217   		     */
  6218   6218   
  6219         -		    dstLimit = dstRead - 1 + TCL_UTF_MAX;
         6219  +		    dstLimit = dstRead + (TCL_UTF_MAX - 1);
  6220   6220   		    statePtr->flags = savedFlags;
  6221   6221   		    statePtr->inputEncodingFlags = savedIEFlags;
  6222   6222   		    statePtr->inputEncodingState = savedState;
  6223   6223   		    continue;
  6224   6224   		}
  6225   6225   	    }
  6226   6226   
................................................................................
  6237   6237   		/*
  6238   6238   		 * There are chars we can read before we hit the bare CR.  Go
  6239   6239   		 * back with a smaller dstLimit so we get them in the next
  6240   6240   		 * pass, compute a matching srcRead, and don't end up back
  6241   6241   		 * here in this call.
  6242   6242   		 */
  6243   6243   
  6244         -		dstLimit = dstRead - 1 + TCL_UTF_MAX;
         6244  +		dstLimit = dstRead + (TCL_UTF_MAX - 1);
  6245   6245   		statePtr->flags = savedFlags;
  6246   6246   		statePtr->inputEncodingFlags = savedIEFlags;
  6247   6247   		statePtr->inputEncodingState = savedState;
  6248   6248   		continue;
  6249   6249   	    }
  6250   6250   
  6251   6251   	    assert(dstWrote == 0);
................................................................................
  6254   6254   	    /*
  6255   6255   	     * We decoded only the bare CR, and we cannot read a translated
  6256   6256   	     * char from that alone. We have to know what's next.  So why do
  6257   6257   	     * we only have the one decoded char?
  6258   6258   	     */
  6259   6259   
  6260   6260   	    if (code != TCL_OK) {
  6261         -		char buffer[TCL_UTF_MAX + 1];
         6261  +		char buffer[5];
  6262   6262   		int read, decoded, count;
  6263   6263   
  6264   6264   		/*
  6265   6265   		 * Didn't get everything the buffer could offer
  6266   6266   		 */
  6267   6267   
  6268   6268   		statePtr->flags = savedFlags;

Changes to generic/tclInt.h.

  3056   3056   MODULE_SCOPE int	TclInfoGlobalsCmd(ClientData dummy, Tcl_Interp *interp,
  3057   3057   			    int objc, Tcl_Obj *const objv[]);
  3058   3058   MODULE_SCOPE int	TclInfoLocalsCmd(ClientData dummy, Tcl_Interp *interp,
  3059   3059   			    int objc, Tcl_Obj *const objv[]);
  3060   3060   MODULE_SCOPE int	TclInfoVarsCmd(ClientData dummy, Tcl_Interp *interp,
  3061   3061   			    int objc, Tcl_Obj *const objv[]);
  3062   3062   MODULE_SCOPE void	TclInitAlloc(void);
  3063         -MODULE_SCOPE void	TclInitBignumFromLong(mp_int *, long);
  3064   3063   MODULE_SCOPE void	TclInitBignumFromWideInt(mp_int *, Tcl_WideInt);
  3065   3064   MODULE_SCOPE void	TclInitBignumFromWideUInt(mp_int *, Tcl_WideUInt);
  3066   3065   MODULE_SCOPE void	TclInitDbCkalloc(void);
  3067   3066   MODULE_SCOPE void	TclInitDoubleConversion(void);
  3068   3067   MODULE_SCOPE void	TclInitEmbeddedConfigurationInformation(
  3069   3068   			    Tcl_Interp *interp);
  3070   3069   MODULE_SCOPE void	TclInitEncodingSubsystem(void);
................................................................................
  3237   3236   			    const char *trim, int numTrim);
  3238   3237   MODULE_SCOPE int	TclTrimRight(const char *bytes, int numBytes,
  3239   3238   			    const char *trim, int numTrim);
  3240   3239   MODULE_SCOPE const char*TclGetCommandTypeName(Tcl_Command command);
  3241   3240   MODULE_SCOPE void	TclRegisterCommandTypeName(
  3242   3241   			    Tcl_ObjCmdProc *implementationProc,
  3243   3242   			    const char *nameStr);
  3244         -#if (TCL_UTF_MAX > 4) && (defined(__CYGWIN__) || defined(_WIN32))
         3243  +#if (TCL_UTF_MAX > 3) && (defined(__CYGWIN__) || defined(_WIN32))
  3245   3244   MODULE_SCOPE int TclUtfToUtf16(const char *src, unsigned short *chPtr);
  3246   3245   MODULE_SCOPE char *	Tcl_Utf16ToUtfDString(const unsigned short *uniStr,
  3247   3246   			    int uniLength, Tcl_DString *dsPtr);
  3248   3247   MODULE_SCOPE unsigned short * Tcl_UtfToUtf16DString(const char *src,
  3249   3248   			    int length, Tcl_DString *dsPtr);
  3250   3249   #else
  3251   3250   #   define TclUtfToUtf16 TclUtfToUniChar

Changes to generic/tclMain.c.

    55     55   
    56     56   /*
    57     57    * Further on, in UNICODE mode we just use Tcl_NewUnicodeObj, otherwise
    58     58    * NewNativeObj is needed (which provides proper conversion from native
    59     59    * encoding to UTF-8).
    60     60    */
    61     61   
    62         -#if defined(UNICODE) && (TCL_UTF_MAX <= 4)
           62  +#if defined(UNICODE) && (TCL_UTF_MAX == 3)
    63     63   #   define NewNativeObj Tcl_NewUnicodeObj
    64         -#else /* !UNICODE || (TCL_UTF_MAX > 4) */
           64  +#else /* !UNICODE || (TCL_UTF_MAX > 3) */
    65     65   static inline Tcl_Obj *
    66     66   NewNativeObj(
    67     67       TCHAR *string,
    68     68       int length)
    69     69   {
    70     70       Tcl_DString ds;
    71     71   
................................................................................
    75     75       }
    76     76       Tcl_WinTCharToUtf(string, length, &ds);
    77     77   #else
    78     78       Tcl_ExternalToUtfDString(NULL, (char *) string, length, &ds);
    79     79   #endif
    80     80       return TclDStringToObj(&ds);
    81     81   }
    82         -#endif /* !UNICODE || (TCL_UTF_MAX > 4) */
           82  +#endif /* !UNICODE || (TCL_UTF_MAX > 3) */
    83     83   
    84     84   /*
    85     85    * Declarations for various library functions and variables (don't want to
    86     86    * include tclPort.h here, because people might copy this file out of the Tcl
    87     87    * source directory to make their own modified versions).
    88     88    */
    89     89   

Changes to generic/tclParse.c.

   787    787   				 * written. At most TCL_UTF_MAX bytes will be
   788    788   				 * written there. */
   789    789   {
   790    790       register const char *p = src+1;
   791    791       Tcl_UniChar unichar = 0;
   792    792       int result;
   793    793       int count;
   794         -    char buf[TCL_UTF_MAX] = "";
          794  +    char buf[4] = "";
   795    795   
   796    796       if (numBytes == 0) {
   797    797   	if (readPtr != NULL) {
   798    798   	    *readPtr = 0;
   799    799   	}
   800    800   	return 0;
   801    801       }
................................................................................
   920    920   	 * special, we shouldn't break up a correct utf-8 character. [Bug
   921    921   	 * #217987] test subst-3.2
   922    922   	 */
   923    923   
   924    924   	if (Tcl_UtfCharComplete(p, numBytes - 1)) {
   925    925   	    count = TclUtfToUniChar(p, &unichar) + 1;	/* +1 for '\' */
   926    926   	} else {
   927         -	    char utfBytes[TCL_UTF_MAX];
          927  +	    char utfBytes[5];
   928    928   
   929    929   	    memcpy(utfBytes, p, numBytes - 1);
   930    930   	    utfBytes[numBytes - 1] = '\0';
   931    931   	    count = TclUtfToUniChar(utfBytes, &unichar) + 1;
   932    932   	}
   933    933   	result = unichar;
   934    934   	break;
................................................................................
  2147   2147   
  2148   2148       adjust = 0;
  2149   2149       result = NULL;
  2150   2150       for (; count>0 && code==TCL_OK ; count--, tokenPtr++) {
  2151   2151   	Tcl_Obj *appendObj = NULL;
  2152   2152   	const char *append = NULL;
  2153   2153   	int appendByteLength = 0;
  2154         -	char utfCharBytes[TCL_UTF_MAX] = "";
         2154  +	char utfCharBytes[4] = "";
  2155   2155   
  2156   2156   	switch (tokenPtr->type) {
  2157   2157   	case TCL_TOKEN_TEXT:
  2158   2158   	    append = tokenPtr->start;
  2159   2159   	    appendByteLength = tokenPtr->size;
  2160   2160   	    break;
  2161   2161   

Changes to generic/tclPipe.c.

   329    329   	 * Make sure we start at the beginning of the file.
   330    330   	 */
   331    331   
   332    332   	if (interp != NULL) {
   333    333   	    int count;
   334    334   	    Tcl_Obj *objPtr;
   335    335   
   336         -	    Tcl_Seek(errorChan, (Tcl_WideInt)0, SEEK_SET);
          336  +	    Tcl_Seek(errorChan, 0, SEEK_SET);
   337    337   	    objPtr = Tcl_NewObj();
   338    338   	    count = Tcl_ReadChars(errorChan, objPtr, -1, 0);
   339    339   	    if (count < 0) {
   340    340   		result = TCL_ERROR;
   341    341   		Tcl_DecrRefCount(objPtr);
   342    342   		Tcl_ResetResult(interp);
   343    343   		Tcl_SetObjResult(interp, Tcl_ObjPrintf(

Changes to generic/tclScan.c.

   257    257   				 * required. */
   258    258   {
   259    259       int gotXpg, gotSequential, value, i, flags;
   260    260       char *end;
   261    261       Tcl_UniChar ch = 0;
   262    262       int objIndex, xpgSize, nspace = numVars;
   263    263       int *nassign = TclStackAlloc(interp, nspace * sizeof(int));
   264         -    char buf[TCL_UTF_MAX+1] = "";
          264  +    char buf[5] = "";
   265    265       Tcl_Obj *errorMsg;		/* Place to build an error messages. Note that
   266    266   				 * these are messy operations because we do
   267    267   				 * not want to use the formatting engine;
   268    268   				 * we're inside there! */
   269    269   
   270    270       /*
   271    271        * Initialize an array that records the number of times a variable is
................................................................................
   877    877   	case 'c':
   878    878   	    /*
   879    879   	     * Scan a single Unicode character.
   880    880   	     */
   881    881   
   882    882   	    offset = TclUtfToUniChar(string, &sch);
   883    883   	    i = (int)sch;
   884         -#if TCL_UTF_MAX <= 4
          884  +#if TCL_UTF_MAX == 3
   885    885   	    if ((sch >= 0xD800) && (offset < 3)) {
   886    886   		offset += TclUtfToUniChar(string+offset, &sch);
   887    887   		i = (((i<<10) & 0x0FFC00) + 0x10000) + (sch & 0x3FF);
   888    888   	    }
   889    889   #endif
   890    890   	    string += offset;
   891    891   	    if (!(flags & SCAN_SUPPRESS)) {
................................................................................
   939    939   		}
   940    940   	    } else if (flags & SCAN_BIG) {
   941    941   		if (flags & SCAN_UNSIGNED) {
   942    942   		    mp_int big;
   943    943   		    int code = Tcl_GetBignumFromObj(interp, objPtr, &big);
   944    944   
   945    945   		    if (code == TCL_OK) {
   946         -			if (mp_isneg(&big)) {
          946  +			if (big.sign != MP_ZPOS) {
   947    947   			    code = TCL_ERROR;
   948    948   			}
   949    949   			mp_clear(&big);
   950    950   		    }
   951    951   
   952    952   		    if (code == TCL_ERROR) {
   953    953   			if (objs != NULL) {

Changes to generic/tclStrToD.c.

   526    526   				 * point. */
   527    527       int status = TCL_OK;	/* Status to return to caller. */
   528    528       char d = 0;			/* Last hexadecimal digit scanned; initialized
   529    529   				 * to avoid a compiler warning. */
   530    530       int shift = 0;		/* Amount to shift when accumulating binary */
   531    531       int explicitOctal = 0;
   532    532   
   533         -#define ALL_BITS	(~(Tcl_WideUInt)0)
          533  +#define ALL_BITS	((Tcl_WideUInt)-1)
   534    534   #define MOST_BITS	(ALL_BITS >> 1)
   535    535   
   536    536       /*
   537    537        * Initialize bytes to start of the object's string rep if the caller
   538    538        * didn't pass anything else.
   539    539        */
   540    540   
................................................................................
   705    705   			 * too large shifts first.
   706    706   			 */
   707    707   
   708    708   			if ((octalSignificandWide != 0)
   709    709   				&& (((size_t)shift >=
   710    710   					CHAR_BIT*sizeof(Tcl_WideUInt))
   711    711   				|| (octalSignificandWide >
   712         -					(~(Tcl_WideUInt)0 >> shift)))) {
          712  +					((Tcl_WideUInt)-1 >> shift)))) {
   713    713   			    octalSignificandOverflow = 1;
   714    714   			    TclInitBignumFromWideUInt(&octalSignificandBig,
   715    715   				    octalSignificandWide);
   716    716   			}
   717    717   		    }
   718    718   		    if (!octalSignificandOverflow) {
   719    719   			octalSignificandWide =
................................................................................
   822    822   		     * Shifting by more bits than are in the value being
   823    823   		     * shifted is at least de facto nonportable. Check for too
   824    824   		     * large shifts first.
   825    825   		     */
   826    826   
   827    827   		    if (significandWide != 0 &&
   828    828   			    ((size_t)shift >= CHAR_BIT*sizeof(Tcl_WideUInt) ||
   829         -			    significandWide > (~(Tcl_WideUInt)0 >> shift))) {
          829  +			    significandWide > ((Tcl_WideUInt)-1 >> shift))) {
   830    830   			significandOverflow = 1;
   831    831   			TclInitBignumFromWideUInt(&significandBig,
   832    832   				significandWide);
   833    833   		    }
   834    834   		}
   835    835   		if (!significandOverflow) {
   836    836   		    significandWide = (significandWide << shift) + d;
................................................................................
   863    863   		     * Shifting by more bits than are in the value being
   864    864   		     * shifted is at least de facto nonportable. Check for too
   865    865   		     * large shifts first.
   866    866   		     */
   867    867   
   868    868   		    if (significandWide != 0 &&
   869    869   			    ((size_t)shift >= CHAR_BIT*sizeof(Tcl_WideUInt) ||
   870         -			    significandWide > (~(Tcl_WideUInt)0 >> shift))) {
          870  +			    significandWide > ((Tcl_WideUInt)-1 >> shift))) {
   871    871   			significandOverflow = 1;
   872    872   			TclInitBignumFromWideUInt(&significandBig,
   873    873   				significandWide);
   874    874   		    }
   875    875   		}
   876    876   		if (!significandOverflow) {
   877    877   		    significandWide = (significandWide << shift) + 1;
................................................................................
  1447   1447   	    /*
  1448   1448   	     * There's no need to multiply if the multiplicand is zero.
  1449   1449   	     */
  1450   1450   
  1451   1451   	    *wideRepPtr = digit;
  1452   1452   	    return 0;
  1453   1453   	} else if (numZeros >= maxpow10_wide
  1454         -		|| w > ((~(Tcl_WideUInt)0)-digit)/pow10_wide[numZeros+1]) {
         1454  +		|| w > ((Tcl_WideUInt)-1-digit)/pow10_wide[numZeros+1]) {
  1455   1455   	    /*
  1456   1456   	     * Wide multiplication will overflow.  Expand the number to a
  1457   1457   	     * bignum and fall through into the bignum case.
  1458   1458   	     */
  1459   1459   
  1460   1460   	    TclInitBignumFromWideUInt(bignumRepPtr, w);
  1461   1461   	} else {
................................................................................
  4645   4645   TclCeil(
  4646   4646       const mp_int *a)			/* Integer to convert. */
  4647   4647   {
  4648   4648       double r = 0.0;
  4649   4649       mp_int b;
  4650   4650   
  4651   4651       mp_init(&b);
  4652         -    if (mp_isneg(a)) {
         4652  +    if (a->sign != MP_ZPOS) {
  4653   4653   	mp_neg(a, &b);
  4654   4654   	r = -TclFloor(&b);
  4655   4655       } else {
  4656   4656   	int bits = mp_count_bits(a);
  4657   4657   
  4658   4658   	if (bits > DBL_MAX_EXP*log2FLT_RADIX) {
  4659   4659   	    r = HUGE_VAL;
................................................................................
  4662   4662   
  4663   4663   	    if (shift > 0) {
  4664   4664   		mp_mul_2d(a, shift, &b);
  4665   4665   	    } else if (shift < 0) {
  4666   4666   		mp_int d;
  4667   4667   		mp_init(&d);
  4668   4668   		mp_div_2d(a, -shift, &b, &d);
  4669         -		exact = mp_iszero(&d);
         4669  +		exact = d.used == 0;
  4670   4670   		mp_clear(&d);
  4671   4671   	    } else {
  4672   4672   		mp_copy(a, &b);
  4673   4673   	    }
  4674   4674   	    if (!exact) {
  4675   4675   		mp_add_d(&b, 1, &b);
  4676   4676   	    }
................................................................................
  4702   4702   TclFloor(
  4703   4703       const mp_int *a)			/* Integer to convert. */
  4704   4704   {
  4705   4705       double r = 0.0;
  4706   4706       mp_int b;
  4707   4707   
  4708   4708       mp_init(&b);
  4709         -    if (mp_isneg(a)) {
         4709  +    if (a->sign != MP_ZPOS) {
  4710   4710   	mp_neg(a, &b);
  4711   4711   	r = -TclCeil(&b);
  4712   4712       } else {
  4713   4713   	int bits = mp_count_bits(a);
  4714   4714   
  4715   4715   	if (bits > DBL_MAX_EXP*log2FLT_RADIX) {
  4716   4716   	    r = DBL_MAX;

Changes to generic/tclStringObj.c.

   564    564   	stringPtr = GET_STRING(objPtr);
   565    565       }
   566    566   
   567    567       if (index >= stringPtr->numChars) {
   568    568   	return -1;
   569    569       }
   570    570       ch = stringPtr->unicode[index];
   571         -#if TCL_UTF_MAX <= 4
          571  +#if TCL_UTF_MAX == 3
   572    572       /* See: bug [11ae2be95dac9417] */
   573    573       if ((ch & 0xF800) == 0xD800) {
   574    574   	if (ch & 0x400) {
   575    575   	    if ((index > 0)
   576    576   		    && ((stringPtr->unicode[index-1] & 0xFC00) == 0xD800)) {
   577    577   		ch = -1; /* low surrogate preceded by high surrogate */
   578    578   	    }
................................................................................
   602    602    *
   603    603    * Side effects:
   604    604    *	Converts the object to have the String internal rep.
   605    605    *
   606    606    *----------------------------------------------------------------------
   607    607    */
   608    608   
   609         -#if !defined(TCL_NO_DEPRECATED) && (TCL_UTF_MAX<=4)
          609  +#if !defined(TCL_NO_DEPRECATED) && (TCL_UTF_MAX==3)
   610    610   #undef Tcl_GetUnicode
   611    611   unsigned short *
   612    612   Tcl_GetUnicode(
   613    613       Tcl_Obj *objPtr)		/* The object to find the unicode string
   614    614   				 * for. */
   615    615   {
   616    616       return Tcl_GetUtf16FromObj(objPtr, NULL);
................................................................................
   748    748       }
   749    749       if (last > stringPtr->numChars) {
   750    750   	last = stringPtr->numChars;
   751    751       }
   752    752       if (last < first) {
   753    753   	return Tcl_NewObj();
   754    754       }
   755         -#if TCL_UTF_MAX <= 4
          755  +#if TCL_UTF_MAX == 3
   756    756       /* See: bug [11ae2be95dac9417] */
   757    757       if ((first > 0) && ((stringPtr->unicode[first] & 0xFC00) == 0xDC00)
   758    758   	    && ((stringPtr->unicode[first-1] & 0xFC00) == 0xD800)) {
   759    759   	++first;
   760    760       }
   761    761       if ((last + 1 < stringPtr->numChars)
   762    762   	    && ((stringPtr->unicode[last+1] & 0xFC00) == 0xDC00)
................................................................................
  2037   2037   		    numChars = precision;
  2038   2038   		    Tcl_IncrRefCount(segment);
  2039   2039   		    allocSegment = 1;
  2040   2040   		}
  2041   2041   	    }
  2042   2042   	    break;
  2043   2043   	case 'c': {
  2044         -	    char buf[TCL_UTF_MAX] = "";
         2044  +	    char buf[4] = "";
  2045   2045   	    int code, length;
  2046   2046   
  2047   2047   	    if (TclGetIntFromObj(interp, segment, &code) != TCL_OK) {
  2048   2048   		goto error;
  2049   2049   	    }
  2050   2050   	    length = Tcl_UniCharToUtf(code, buf);
  2051   2051   	    if ((code >= 0xD800) && (length < 3)) {

Changes to generic/tclStubInit.c.

    53     53   #undef Tcl_SetLongObj
    54     54   #undef TclpInetNtoa
    55     55   #undef TclWinGetServByName
    56     56   #undef TclWinGetSockOpt
    57     57   #undef TclWinSetSockOpt
    58     58   #undef TclWinNToHS
    59     59   #undef TclStaticPackage
           60  +#undef TclBNInitBignumFromLong
    60     61   #undef Tcl_BackgroundError
    61     62   #define TclStaticPackage Tcl_StaticPackage
    62     63   #undef Tcl_GetUnicodeFromObj
    63     64   #undef Tcl_NewUnicodeObj
    64     65   
    65     66   static void uniCodePanic() {
    66         -#if TCL_UTF_MAX <= 4
    67         -    Tcl_Panic("This extension is compiled with -DTCL_UTF_MAX=6, but Tcl is compiled with -DTCL_UTF_MAX=4");
           67  +#if TCL_UTF_MAX == 3
           68  +    Tcl_Panic("This extension is compiled with -DTCL_UTF_MAX>3, but Tcl is compiled with -DTCL_UTF_MAX==3");
    68     69   #else
    69         -    Tcl_Panic("This extension is compiled with -DTCL_UTF_MAX=4, but Tcl is compiled with -DTCL_UTF_MAX=6");
           70  +    Tcl_Panic("This extension is compiled with -DTCL_UTF_MAX==3, but Tcl is compiled with -DTCL_UTF_MAX>3");
    70     71   #endif
    71     72   }
    72         -#if TCL_UTF_MAX <= 4
           73  +#if TCL_UTF_MAX == 3
    73     74   #   define Tcl_GetUnicodeFromObj (int *(*)(Tcl_Obj *, int *)) uniCodePanic
    74     75   #   define Tcl_NewUnicodeObj (Tcl_Obj *(*)(const int *, int)) uniCodePanic
    75     76   #else
    76     77   #   define Tcl_GetUtf16FromObj (unsigned short *(*)(Tcl_Obj *, int *)) uniCodePanic
    77     78   #   define Tcl_GetUnicode (unsigned short *(*)(Tcl_Obj *)) uniCodePanic
    78     79   #   define Tcl_NewUtf16Obj (Tcl_Obj *(*)(const unsigned short *, int)) uniCodePanic
    79     80   #endif
................................................................................
   116    117   #   define Tcl_ListMathFuncs 0
   117    118   #   define Tcl_SetIntObj 0
   118    119   #   define Tcl_SetLongObj 0
   119    120   #   define Tcl_NewIntObj 0
   120    121   #   define Tcl_NewLongObj 0
   121    122   #   define Tcl_DbNewLongObj 0
   122    123   #   define Tcl_BackgroundError 0
   123         -
   124    124   #else
          125  +#define TclBNInitBignumFromLong initBignumFromLong
          126  +static void TclBNInitBignumFromLong(mp_int *a, long b)
          127  +{
          128  +    TclInitBignumFromWideInt(a, b);
          129  +}
   125    130   #define TclSetStartupScriptPath setStartupScriptPath
   126    131   static void TclSetStartupScriptPath(Tcl_Obj *path)
   127    132   {
   128    133       Tcl_SetStartupScript(path, NULL);
   129    134   }
   130    135   #define TclGetStartupScriptPath getStartupScriptPath
   131    136   static Tcl_Obj *TclGetStartupScriptPath(void)
................................................................................
   168    173       return 2; /* VER_PLATFORM_WIN32_NT */;
   169    174   }
   170    175   #define TclWinResetInterfaces doNothing
   171    176   #define TclWinSetInterfaces (void (*) (int)) doNothing
   172    177   #endif
   173    178   #   define TclBNInitBignumFromWideUInt TclInitBignumFromWideUInt
   174    179   #   define TclBNInitBignumFromWideInt TclInitBignumFromWideInt
   175         -#   define TclBNInitBignumFromLong TclInitBignumFromLong
   176    180   #endif /* TCL_NO_DEPRECATED */
   177    181   
   178    182   #ifdef _WIN32
   179    183   #   define TclUnixWaitForFile 0
   180    184   #   define TclUnixCopyFile 0
   181    185   #   define TclUnixOpenTemporaryFile 0
   182    186   #   define TclpReaddir 0
................................................................................
  1327   1331       Tcl_UtfFindLast, /* 329 */
  1328   1332       Tcl_UtfNext, /* 330 */
  1329   1333       Tcl_UtfPrev, /* 331 */
  1330   1334       Tcl_UtfToExternal, /* 332 */
  1331   1335       Tcl_UtfToExternalDString, /* 333 */
  1332   1336       Tcl_UtfToLower, /* 334 */
  1333   1337       Tcl_UtfToTitle, /* 335 */
  1334         -    Tcl_UtfToUniChar, /* 336 */
         1338  +    0, /* 336 */
  1335   1339       Tcl_UtfToUpper, /* 337 */
  1336   1340       Tcl_WriteChars, /* 338 */
  1337   1341       Tcl_WriteObj, /* 339 */
  1338   1342       Tcl_GetString, /* 340 */
  1339   1343       Tcl_GetDefaultEncodingDir, /* 341 */
  1340   1344       Tcl_SetDefaultEncodingDir, /* 342 */
  1341   1345       Tcl_AlertNotifier, /* 343 */
................................................................................
  1343   1347       Tcl_UniCharIsAlnum, /* 345 */
  1344   1348       Tcl_UniCharIsAlpha, /* 346 */
  1345   1349       Tcl_UniCharIsDigit, /* 347 */
  1346   1350       Tcl_UniCharIsLower, /* 348 */
  1347   1351       Tcl_UniCharIsSpace, /* 349 */
  1348   1352       Tcl_UniCharIsUpper, /* 350 */
  1349   1353       Tcl_UniCharIsWordChar, /* 351 */
  1350         -    Tcl_UniCharLen, /* 352 */
  1351         -    Tcl_UniCharNcmp, /* 353 */
  1352         -    Tcl_UniCharToUtfDString, /* 354 */
  1353         -    Tcl_UtfToUniCharDString, /* 355 */
         1354  +    0, /* 352 */
         1355  +    0, /* 353 */
         1356  +    0, /* 354 */
         1357  +    0, /* 355 */
  1354   1358       Tcl_GetRegExpFromObj, /* 356 */
  1355   1359       Tcl_EvalTokens, /* 357 */
  1356   1360       Tcl_FreeParse, /* 358 */
  1357   1361       Tcl_LogCommandInfo, /* 359 */
  1358   1362       Tcl_ParseBraces, /* 360 */
  1359   1363       Tcl_ParseCommand, /* 361 */
  1360   1364       Tcl_ParseExpr, /* 362 */
................................................................................
  1637   1641       Tcl_StoreIntRep, /* 639 */
  1638   1642       Tcl_HasStringRep, /* 640 */
  1639   1643       Tcl_IncrRefCount, /* 641 */
  1640   1644       Tcl_DecrRefCount, /* 642 */
  1641   1645       Tcl_IsShared, /* 643 */
  1642   1646       Tcl_GetUnicodeFromObj, /* 644 */
  1643   1647       Tcl_NewUnicodeObj, /* 645 */
         1648  +    Tcl_UtfToUniChar, /* 646 */
         1649  +    Tcl_UniCharLen, /* 647 */
         1650  +    Tcl_UniCharNcmp, /* 648 */
         1651  +    Tcl_UniCharToUtfDString, /* 649 */
         1652  +    Tcl_UtfToUniCharDString, /* 650 */
  1644   1653   };
  1645   1654   
  1646   1655   /* !END!: Do not edit above this line. */

Changes to generic/tclTomMathDecls.h.

    26     26   
    27     27   #define Tcl_TomMath_InitStubs(interp,version) \
    28     28       (TclTomMathInitializeStubs((interp),(version),\
    29     29                                  TCLTOMMATH_EPOCH,TCLTOMMATH_REVISION))
    30     30   
    31     31   /* Define custom memory allocation for libtommath */
    32     32   
    33         -/* MODULE_SCOPE void* TclBNAlloc( size_t ); */
    34         -#define TclBNAlloc(s) ((void*)ckalloc((size_t)(s)))
    35         -/* MODULE_SCOPE void* TclBNRealloc( void*, size_t ); */
    36         -#define TclBNRealloc(x,s) ((void*)ckrealloc((char*)(x),(size_t)(s)))
    37         -/* MODULE_SCOPE void  TclBNFree( void* ); */
    38         -#define TclBNFree(x) (ckfree((char*)(x)))
    39         -/* MODULE_SCOPE void* TclBNCalloc( size_t, size_t ); */
    40         -/* unused - no macro */
    41         -
    42         -#define XMALLOC(x) TclBNAlloc(x)
    43         -#define XFREE(x) TclBNFree(x)
    44         -#define XREALLOC(x,n) TclBNRealloc(x,n)
    45         -#define XCALLOC(n,x) TclBNCalloc(n,x)
           33  +/* MODULE_SCOPE void* XMALLOC( size_t ); */
           34  +#define XMALLOC(s) ((void*)ckalloc((size_t)(s)))
           35  +/* MODULE_SCOPE void* XREALLOC( void*, size_t ); */
           36  +#define XREALLOC(x,s) ((void*)ckrealloc((char*)(x),(size_t)(s)))
           37  +/* MODULE_SCOPE void  XFREE( void* ); */
           38  +#define XFREE(x) (ckfree((char*)(x)))
    46     39   
    47     40   /* Rename the global symbols in libtommath to avoid linkage conflicts */
    48     41   
    49     42   #define KARATSUBA_MUL_CUTOFF TclBNKaratsubaMulCutoff
    50     43   #define KARATSUBA_SQR_CUTOFF TclBNKaratsubaSqrCutoff
    51     44   #define TOOM_MUL_CUTOFF TclBNToomMulCutoff
    52     45   #define TOOM_SQR_CUTOFF TclBNToomSqrCutoff

Changes to generic/tclTomMathInterface.c.

    89     89   {
    90     90       return TCLTOMMATH_REVISION;
    91     91   }
    92     92   
    93     93   /*
    94     94    *----------------------------------------------------------------------
    95     95    *
    96         - * TclInitBignumFromLong --
    97         - *
    98         - *	Allocate and initialize a 'bignum' from a native 'long'.
    99         - *
   100         - * Results:
   101         - *	None.
   102         - *
   103         - * Side effects:
   104         - *	The 'bignum' is constructed.
   105         - *
   106         - *----------------------------------------------------------------------
   107         - */
   108         -
   109         -void
   110         -TclInitBignumFromLong(
   111         -    mp_int *a,
   112         -    long v)
   113         -{
   114         -    if (mp_init_size(a, (CHAR_BIT * sizeof(long) + DIGIT_BIT - 1) / DIGIT_BIT) != MP_OKAY) {
   115         -	Tcl_Panic("initialization failure in TclInitBignumFromLong");
   116         -    }
   117         -    if (v < (long)0) {
   118         -	mp_set_long_long(a, (Tcl_WideUInt)(-(Tcl_WideInt)v));
   119         -	mp_neg(a, a);
   120         -    } else {
   121         -	mp_set_long_long(a, (Tcl_WideUInt)v);
   122         -    }
   123         -}
   124         -
   125         -/*
   126         - *----------------------------------------------------------------------
   127         - *
   128         - * TclBNInitBignumFromWideInt --
           96  + * TclInitBignumFromWideInt --
   129     97    *
   130     98    *	Allocate and initialize a 'bignum' from a Tcl_WideInt
   131     99    *
   132    100    * Results:
   133    101    *	None.
   134    102    *
   135    103    * Side effects:
................................................................................
   142    110   TclInitBignumFromWideInt(
   143    111       mp_int *a,			/* Bignum to initialize */
   144    112       Tcl_WideInt v)		/* Initial value */
   145    113   {
   146    114   	if (mp_init_size(a, (CHAR_BIT * sizeof(Tcl_WideUInt) + DIGIT_BIT - 1) / DIGIT_BIT) != MP_OKAY) {
   147    115   		Tcl_Panic("initialization failure in TclInitBignumFromWideInt");
   148    116   	}
   149         -    if (v < (Tcl_WideInt)0) {
          117  +    if (v < 0) {
   150    118   	mp_set_long_long(a, (Tcl_WideUInt)(-v));
   151    119   	mp_neg(a, a);
   152    120       } else {
   153    121   	mp_set_long_long(a, (Tcl_WideUInt)v);
   154    122       }
   155    123   }
   156    124   
   157    125   /*
   158    126    *----------------------------------------------------------------------
   159    127    *
   160         - * TclBNInitBignumFromWideUInt --
          128  + * TclInitBignumFromWideUInt --
   161    129    *
   162    130    *	Allocate and initialize a 'bignum' from a Tcl_WideUInt
   163    131    *
   164    132    * Results:
   165    133    *	None.
   166    134    *
   167    135    * Side effects:

Changes to generic/tclUniData.c.

   191    191       9920, 9920, 9920, 9920, 9920, 9920, 9920, 9920, 9920, 9920, 9920, 9920,
   192    192       9920, 9920, 9920, 9920, 9920, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   193    193       1344, 1344, 1344, 1344, 9952, 1344, 1344, 9984, 1824, 10016, 10048,
   194    194       10080, 1344, 1344, 10112, 10144, 1344, 1344, 1344, 1344, 1344, 1344,
   195    195       1344, 1344, 1344, 1344, 10176, 10208, 1344, 10240, 1344, 10272, 10304,
   196    196       10336, 10368, 10400, 10432, 1344, 1344, 1344, 10464, 10496, 64, 10528,
   197    197       10560, 10592, 4736, 10624, 10656
   198         -#if TCL_UTF_MAX > 3
          198  +#if TCL_UTF_MAX > 3 || TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6
   199    199       ,10688, 10720, 10752, 1824, 1344, 1344, 1344, 8288, 10784, 10816, 10848,
   200    200       10880, 10912, 10944, 10976, 11008, 1824, 1824, 1824, 1824, 9280, 1344,
   201    201       11040, 11072, 1344, 11104, 11136, 11168, 11200, 1344, 11232, 1824,
   202    202       11264, 11296, 11328, 1344, 11360, 11392, 11424, 11456, 1344, 11488,
   203    203       1344, 11520, 1824, 1824, 1824, 1824, 1344, 1344, 1344, 1344, 1344,
   204    204       1344, 1344, 1344, 1344, 7776, 4704, 10272, 1824, 1824, 1824, 1824,
   205    205       11552, 11584, 11616, 11648, 4736, 11680, 1824, 11712, 11744, 11776,
................................................................................
  1149   1149       5, 6, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 15, 15, 15,
  1150   1150       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1151   1151       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1152   1152       15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 0, 0, 15, 15, 15, 15, 15, 15,
  1153   1153       0, 0, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 0, 0, 15,
  1154   1154       15, 15, 0, 0, 0, 4, 4, 7, 11, 14, 4, 4, 0, 14, 7, 7, 7, 7, 14, 14,
  1155   1155       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 14, 14, 0, 0
  1156         -#if TCL_UTF_MAX > 3
         1156  +#if TCL_UTF_MAX > 3 || TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6
  1157   1157       ,15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15,
  1158   1158       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1159   1159       15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1160   1160       15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 0, 15, 15, 15, 15, 15, 15,
  1161   1161       15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15,
  1162   1162       15, 15, 15, 15, 15, 15, 15, 0, 0, 3, 3, 3, 0, 0, 0, 0, 18, 18, 18,
  1163   1163       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
................................................................................
  1609   1609       -2750143, -976319, -2746047, 2763650, 2762882, -2759615, -2751679,
  1610   1610       -2760383, -2760127, -2768575, 1859714, -9044927, -10823615, -12158,
  1611   1611       -10830783, -10833599, -10832575, -10830015, -10817983, -10824127,
  1612   1612       -10818751, 237633, -12223, -10830527, -9058239, 237698, 9949314,
  1613   1613       18, 17, 10305, 10370, 8769, 8834
  1614   1614   };
  1615   1615   
  1616         -#if TCL_UTF_MAX > 3
         1616  +#if TCL_UTF_MAX > 3 || TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6
  1617   1617   #   define UNICODE_OUT_OF_RANGE(ch) (((ch) & 0x1fffff) >= 0x2fa20)
  1618   1618   #else
  1619   1619   #   define UNICODE_OUT_OF_RANGE(ch) (((ch) & 0x1f0000) != 0)
  1620   1620   #endif
  1621   1621   
  1622   1622   /*
  1623   1623    * The following constants are used to determine the category of a
................................................................................
  1668   1668   #define GetDelta(info) ((info) >> 8)
  1669   1669   
  1670   1670   /*
  1671   1671    * This macro extracts the information about a character from the
  1672   1672    * Unicode character tables.
  1673   1673    */
  1674   1674   
  1675         -#if TCL_UTF_MAX > 3
         1675  +#if TCL_UTF_MAX > 3 || TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6
  1676   1676   #   define GetUniCharInfo(ch) (groups[groupMap[pageMap[((ch) & 0x1fffff) >> OFFSET_BITS] | ((ch) & ((1 << OFFSET_BITS)-1))]])
  1677   1677   #else
  1678   1678   #   define GetUniCharInfo(ch) (groups[groupMap[pageMap[((ch) & 0xffff) >> OFFSET_BITS] | ((ch) & ((1 << OFFSET_BITS)-1))]])
  1679   1679   #endif

Changes to generic/tclUtf.c.

   262    262   	p += Tcl_UniCharToUtf(-1, p);
   263    263       }
   264    264       Tcl_DStringSetLength(dsPtr, oldLength + (p - string));
   265    265   
   266    266       return string;
   267    267   }
   268    268   
   269         -#if (TCL_UTF_MAX > 4) && (defined(__CYGWIN__) || defined(_WIN32))
          269  +#if (TCL_UTF_MAX > 3) && (defined(__CYGWIN__) || defined(_WIN32))
   270    270   char *
   271    271   Tcl_Utf16ToUtfDString(
   272    272       const unsigned short *uniStr,	/* Utf-16 string to convert to UTF-8. */
   273    273       int uniLength,		/* Length of Utf-16 string (must be >= 0). */
   274    274       Tcl_DString *dsPtr)		/* UTF-8 representation of string is appended
   275    275   				 * to this previously initialized DString. */
   276    276   {
................................................................................
   369    369   	 * Handles properly formed UTF-8 characters between 0x01 and 0x7F.
   370    370   	 * Treats naked trail bytes 0x80 to 0x9F as valid characters from
   371    371   	 * the cp1252 table. See: <https://en.wikipedia.org/wiki/UTF-8>
   372    372   	 * Also treats \0 and other naked trail bytes 0xA0 to 0xBF as valid
   373    373   	 * characters representing themselves.
   374    374   	 */
   375    375   
   376         -#if TCL_UTF_MAX <= 4
          376  +#if TCL_UTF_MAX == 3
   377    377   	/* If *chPtr contains a high surrogate (produced by a previous
   378    378   	 * Tcl_UtfToUniChar() call) and the next 3 bytes are UTF-8 continuation
   379    379   	 * bytes, then we must produce a follow-up low surrogate. We only
   380    380   	 * do that if the high surrogate matches the bits we encounter.
   381    381   	 */
   382    382   	if ((byte >= 0x80)
   383    383   		&& (((((byte - 0x10) << 2) & 0xFC) | 0xD800) == (*chPtr & 0xFCFC))
................................................................................
   428    428   	 */
   429    429       }
   430    430       else if (byte < 0xF8) {
   431    431   	if (((src[1] & 0xC0) == 0x80) && ((src[2] & 0xC0) == 0x80) && ((src[3] & 0xC0) == 0x80)) {
   432    432   	    /*
   433    433   	     * Four-byte-character lead byte followed by three trail bytes.
   434    434   	     */
   435         -#if TCL_UTF_MAX <= 4
          435  +#if TCL_UTF_MAX == 3
   436    436   	    Tcl_UniChar high = (((byte & 0x07) << 8) | ((src[1] & 0x3F) << 2)
   437    437   		    | ((src[2] & 0x3F) >> 4)) - 0x40;
   438    438   	    if (high >= 0x400) {
   439    439   		/* out of range, < 0x10000 or > 0x10ffff */
   440    440   	    } else {
   441    441   		/* produce high surrogate, advance source pointer */
   442    442   		*chPtr = 0xD800 + high;
................................................................................
   457    457   	 */
   458    458       }
   459    459   
   460    460       *chPtr = byte;
   461    461       return 1;
   462    462   }
   463    463   
   464         -#if (TCL_UTF_MAX > 4) && (defined(__CYGWIN__) || defined(_WIN32))
          464  +#if (TCL_UTF_MAX > 3) && (defined(__CYGWIN__) || defined(_WIN32))
   465    465   int
   466    466   TclUtfToUtf16(
   467    467       const char *src,	/* The UTF-8 string. */
   468    468       unsigned short *chPtr)/* Filled with the Utf-16 representation of
   469    469   				 * the UTF-8 string. */
   470    470   {
   471    471       unsigned short byte;
................................................................................
   630    630       *w = '\0';
   631    631       Tcl_DStringSetLength(dsPtr,
   632    632   	    oldLength + ((char *) w - (char *) wString));
   633    633   
   634    634       return wString;
   635    635   }
   636    636   
   637         -#if (TCL_UTF_MAX > 4) && (defined(__CYGWIN__) || defined(_WIN32))
          637  +#if (TCL_UTF_MAX > 3) && (defined(__CYGWIN__) || defined(_WIN32))
   638    638   unsigned short *
   639    639   Tcl_UtfToUtf16DString(
   640    640       const char *src,		/* UTF-8 string to convert to Unicode. */
   641    641       int length,			/* Length of UTF-8 string in bytes, or -1 for
   642    642   				 * strlen(). */
   643    643       Tcl_DString *dsPtr)		/* Unicode representation of string is
   644    644   				 * appended to this previously initialized
................................................................................
   801    801   {
   802    802       int len, fullchar;
   803    803       Tcl_UniChar find = 0;
   804    804   
   805    805       while (1) {
   806    806   	len = TclUtfToUniChar(src, &find);
   807    807   	fullchar = find;
   808         -#if TCL_UTF_MAX <= 4
          808  +#if TCL_UTF_MAX == 3
   809    809   	if ((ch >= 0xD800) && (len < 3)) {
   810    810   	    len += TclUtfToUniChar(src + len, &find);
   811    811   	    fullchar = (((fullchar & 0x3ff) << 10) | (find & 0x3ff)) + 0x10000;
   812    812   	}
   813    813   #endif
   814    814   	if (fullchar == ch) {
   815    815   	    return src;
................................................................................
   849    849       Tcl_UniChar find = 0;
   850    850       const char *last;
   851    851   
   852    852       last = NULL;
   853    853       while (1) {
   854    854   	len = TclUtfToUniChar(src, &find);
   855    855   	fullchar = find;
   856         -#if TCL_UTF_MAX <= 4
          856  +#if TCL_UTF_MAX == 3
   857    857   	if ((ch >= 0xD800) && (len < 3)) {
   858    858   	    len += TclUtfToUniChar(src + len, &find);
   859    859   	    fullchar = (((fullchar & 0x3ff) << 10) | (find & 0x3ff)) + 0x10000;
   860    860   	}
   861    861   #endif
   862    862   	if (fullchar == ch) {
   863    863   	    last = src;
................................................................................
   892    892   const char *
   893    893   Tcl_UtfNext(
   894    894       const char *src)		/* The current location in the string. */
   895    895   {
   896    896       Tcl_UniChar ch = 0;
   897    897       int len = TclUtfToUniChar(src, &ch);
   898    898   
   899         -#if TCL_UTF_MAX <= 4
          899  +#if TCL_UTF_MAX == 3
   900    900       if ((ch >= 0xD800) && (len < 3)) {
   901    901   	len += TclUtfToUniChar(src + len, &ch);
   902    902       }
   903    903   #endif
   904    904       return src + len;
   905    905   }
   906    906   
................................................................................
   974    974   int
   975    975   Tcl_UniCharAtIndex(
   976    976       register const char *src,	/* The UTF-8 string to dereference. */
   977    977       register int index)		/* The position of the desired character. */
   978    978   {
   979    979       Tcl_UniChar ch = 0;
   980    980       int fullchar = 0;
   981         -#if TCL_UTF_MAX <= 4
          981  +#if TCL_UTF_MAX == 3
   982    982   	int len = 0;
   983    983   #endif
   984    984   
   985    985       while (index-- >= 0) {
   986         -#if TCL_UTF_MAX <= 4
          986  +#if TCL_UTF_MAX == 3
   987    987   	src += (len = TclUtfToUniChar(src, &ch));
   988    988   #else
   989    989   	src += TclUtfToUniChar(src, &ch);
   990    990   #endif
   991    991       }
   992    992       fullchar = ch;
   993         -#if TCL_UTF_MAX <= 4
          993  +#if TCL_UTF_MAX == 3
   994    994       if ((ch >= 0xD800) && (len < 3)) {
   995    995   	/* If last Tcl_UniChar was a high surrogate, combine with low surrogate */
   996    996   	(void)TclUtfToUniChar(src, &ch);
   997    997   	fullchar = (((fullchar & 0x3ff) << 10) | (ch & 0x3ff)) + 0x10000;
   998    998       }
   999    999   #endif
  1000   1000       return fullchar;
................................................................................
  1002   1002   
  1003   1003   /*
  1004   1004    *---------------------------------------------------------------------------
  1005   1005    *
  1006   1006    * Tcl_UtfAtIndex --
  1007   1007    *
  1008   1008    *	Returns a pointer to the specified character (not byte) position in
  1009         - *	the UTF-8 string. If TCL_UTF_MAX <= 4, characters > U+FFFF count as
         1009  + *	the UTF-8 string. If TCL_UTF_MAX == 3, characters > U+FFFF count as
  1010   1010    *	2 positions, but then the pointer should never be placed between
  1011   1011    *	the two positions.
  1012   1012    *
  1013   1013    * Results:
  1014   1014    *	As above.
  1015   1015    *
  1016   1016    * Side effects:
................................................................................
  1027   1027       Tcl_UniChar ch = 0;
  1028   1028       int len = 0;
  1029   1029   
  1030   1030       while (index-- > 0) {
  1031   1031   	len = TclUtfToUniChar(src, &ch);
  1032   1032   	src += len;
  1033   1033       }
  1034         -#if TCL_UTF_MAX <= 4
         1034  +#if TCL_UTF_MAX == 3
  1035   1035       if ((ch >= 0xD800) && (len < 3)) {
  1036   1036   	/* Index points at character following high Surrogate */
  1037   1037   	src += TclUtfToUniChar(src, &ch);
  1038   1038       }
  1039   1039   #endif
  1040   1040       return src;
  1041   1041   }
................................................................................
  1124   1124        * Iterate over the string until we hit the terminating null.
  1125   1125        */
  1126   1126   
  1127   1127       src = dst = str;
  1128   1128       while (*src) {
  1129   1129   	len = TclUtfToUniChar(src, &ch);
  1130   1130   	upChar = ch;
  1131         -#if TCL_UTF_MAX <= 4
         1131  +#if TCL_UTF_MAX == 3
  1132   1132   	if ((ch >= 0xD800) && (len < 3)) {
  1133   1133   	    len += TclUtfToUniChar(src + len, &ch);
  1134   1134   	    /* Combine surrogates */
  1135   1135   	    upChar = (((upChar & 0x3ff) << 10) | (ch & 0x3ff)) + 0x10000;
  1136   1136   	}
  1137   1137   #endif
  1138   1138   	upChar = Tcl_UniCharToUpper(upChar);
................................................................................
  1186   1186        * Iterate over the string until we hit the terminating null.
  1187   1187        */
  1188   1188   
  1189   1189       src = dst = str;
  1190   1190       while (*src) {
  1191   1191   	len = TclUtfToUniChar(src, &ch);
  1192   1192   	lowChar = ch;
  1193         -#if TCL_UTF_MAX <= 4
         1193  +#if TCL_UTF_MAX == 3
  1194   1194   	if ((ch >= 0xD800) && (len < 3)) {
  1195   1195   	    len += TclUtfToUniChar(src + len, &ch);
  1196   1196   	    /* Combine surrogates */
  1197   1197   	    lowChar = (((lowChar & 0x3ff) << 10) | (ch & 0x3ff)) + 0x10000;
  1198   1198   	}
  1199   1199   #endif
  1200   1200   	lowChar = Tcl_UniCharToLower(lowChar);
................................................................................
  1251   1251        */
  1252   1252   
  1253   1253       src = dst = str;
  1254   1254   
  1255   1255       if (*src) {
  1256   1256   	len = TclUtfToUniChar(src, &ch);
  1257   1257   	titleChar = ch;
  1258         -#if TCL_UTF_MAX <= 4
         1258  +#if TCL_UTF_MAX == 3
  1259   1259   	if ((ch >= 0xD800) && (len < 3)) {
  1260   1260   	    len += TclUtfToUniChar(src + len, &ch);
  1261   1261   	    /* Combine surrogates */
  1262   1262   	    titleChar = (((titleChar & 0x3ff) << 10) | (ch & 0x3ff)) + 0x10000;
  1263   1263   	}
  1264   1264   #endif
  1265   1265   	titleChar = Tcl_UniCharToTitle(titleChar);
................................................................................
  1271   1271   	    dst += Tcl_UniCharToUtf(titleChar, dst);
  1272   1272   	}
  1273   1273   	src += len;
  1274   1274       }
  1275   1275       while (*src) {
  1276   1276   	len = TclUtfToUniChar(src, &ch);
  1277   1277   	lowChar = ch;
  1278         -#if TCL_UTF_MAX <= 4
         1278  +#if TCL_UTF_MAX == 3
  1279   1279   	if ((ch >= 0xD800) && (len < 3)) {
  1280   1280   	    len += TclUtfToUniChar(src + len, &ch);
  1281   1281   	    /* Combine surrogates */
  1282   1282   	    lowChar = (((lowChar & 0x3ff) << 10) | (ch & 0x3ff)) + 0x10000;
  1283   1283   	}
  1284   1284   #endif
  1285   1285   	/* Special exception for Georgian Asomtavruli chars, no titlecase. */
................................................................................
  1383   1383   	 * only when both strings are of at least n chars long (no need for \0
  1384   1384   	 * check)
  1385   1385   	 */
  1386   1386   
  1387   1387   	cs += TclUtfToUniChar(cs, &ch1);
  1388   1388   	ct += TclUtfToUniChar(ct, &ch2);
  1389   1389   	if (ch1 != ch2) {
  1390         -#if TCL_UTF_MAX <= 4
         1390  +#if TCL_UTF_MAX == 3
  1391   1391   	    /* Surrogates always report higher than non-surrogates */
  1392   1392   	    if (((ch1 & 0xFC00) == 0xD800)) {
  1393   1393   	    if ((ch2 & 0xFC00) != 0xD800) {
  1394   1394   		return ch1;
  1395   1395   	    }
  1396   1396   	    } else if ((ch2 & 0xFC00) == 0xD800) {
  1397   1397   		return -ch2;
................................................................................
  1434   1434   	 * n must be interpreted as chars, not bytes.
  1435   1435   	 * This should be called only when both strings are of
  1436   1436   	 * at least n chars long (no need for \0 check)
  1437   1437   	 */
  1438   1438   	cs += TclUtfToUniChar(cs, &ch1);
  1439   1439   	ct += TclUtfToUniChar(ct, &ch2);
  1440   1440   	if (ch1 != ch2) {
  1441         -#if TCL_UTF_MAX <= 4
         1441  +#if TCL_UTF_MAX == 3
  1442   1442   	    /* Surrogates always report higher than non-surrogates */
  1443   1443   	    if (((ch1 & 0xFC00) == 0xD800)) {
  1444   1444   	    if ((ch2 & 0xFC00) != 0xD800) {
  1445   1445   		return ch1;
  1446   1446   	    }
  1447   1447   	    } else if ((ch2 & 0xFC00) == 0xD800) {
  1448   1448   		return -ch2;
................................................................................
  1483   1483   {
  1484   1484       Tcl_UniChar ch1 = 0, ch2 = 0;
  1485   1485   
  1486   1486       while (*cs && *ct) {
  1487   1487   	cs += TclUtfToUniChar(cs, &ch1);
  1488   1488   	ct += TclUtfToUniChar(ct, &ch2);
  1489   1489   	if (ch1 != ch2) {
  1490         -#if TCL_UTF_MAX <= 4
         1490  +#if TCL_UTF_MAX == 3
  1491   1491   	    /* Surrogates always report higher than non-surrogates */
  1492   1492   	    if (((ch1 & 0xFC00) == 0xD800)) {
  1493   1493   	    if ((ch2 & 0xFC00) != 0xD800) {
  1494   1494   		return ch1;
  1495   1495   	    }
  1496   1496   	    } else if ((ch2 & 0xFC00) == 0xD800) {
  1497   1497   		return -ch2;
................................................................................
  1529   1529   {
  1530   1530       Tcl_UniChar ch1 = 0, ch2 = 0;
  1531   1531   
  1532   1532       while (*cs && *ct) {
  1533   1533   	cs += TclUtfToUniChar(cs, &ch1);
  1534   1534   	ct += TclUtfToUniChar(ct, &ch2);
  1535   1535   	if (ch1 != ch2) {
  1536         -#if TCL_UTF_MAX <= 4
         1536  +#if TCL_UTF_MAX == 3
  1537   1537   	    /* Surrogates always report higher than non-surrogates */
  1538   1538   	    if (((ch1 & 0xFC00) == 0xD800)) {
  1539   1539   	    if ((ch2 & 0xFC00) != 0xD800) {
  1540   1540   		return ch1;
  1541   1541   	    }
  1542   1542   	    } else if ((ch2 & 0xFC00) == 0xD800) {
  1543   1543   		return -ch2;

Changes to generic/tclUtil.c.

  1650   1650   char
  1651   1651   Tcl_Backslash(
  1652   1652       const char *src,		/* Points to the backslash character of a
  1653   1653   				 * backslash sequence. */
  1654   1654       int *readPtr)		/* Fill in with number of characters read from
  1655   1655   				 * src, unless NULL. */
  1656   1656   {
  1657         -    char buf[TCL_UTF_MAX] = "";
         1657  +    char buf[4] = "";
  1658   1658       Tcl_UniChar ch = 0;
  1659   1659   
  1660   1660       Tcl_UtfBackslash(src, readPtr, buf);
  1661   1661       TclUtfToUniChar(buf, &ch);
  1662   1662       return (char) ch;
  1663   1663   }
  1664   1664   #endif /* !TCL_NO_DEPRECATED */
................................................................................
  3722   3722   	if (numType != TCL_NUMBER_BIG) {
  3723   3723   	    /* Must be a double -> not a valid index */
  3724   3724   	    goto parseError;
  3725   3725   	}
  3726   3726   
  3727   3727   	/* objPtr holds an integer outside the signed wide range */
  3728   3728   	/* Truncate to the signed wide range. */
  3729         -	*widePtr = mp_isneg((mp_int *)cd) ? WIDE_MIN : WIDE_MAX;
         3729  +	*widePtr = (((mp_int *)cd)->sign != MP_ZPOS) ? WIDE_MIN : WIDE_MAX;
  3730   3730       return TCL_OK;
  3731   3731       }
  3732   3732   
  3733   3733       /* objPtr does not hold a number, check the end+/- format... */
  3734   3734       if (GetEndOffsetFromObj(objPtr, endValue, widePtr) == TCL_OK) {
  3735   3735   	return TCL_OK;
  3736   3736       }
................................................................................
  3835   3835   
  3836   3836   		if (numType == TCL_NUMBER_INT) {
  3837   3837   		    /* sum holds an integer in the signed wide range */
  3838   3838   			*widePtr = *(Tcl_WideInt *)cd;
  3839   3839   		} else {
  3840   3840   		    /* sum holds an integer outside the signed wide range */
  3841   3841   		    /* Truncate to the signed wide range. */
  3842         -		    if (mp_isneg((mp_int *)cd)) {
         3842  +		    if (((mp_int *)cd)->sign != MP_ZPOS) {
  3843   3843   			*widePtr = WIDE_MIN;
  3844   3844   		    } else {
  3845   3845   			*widePtr = WIDE_MAX;
  3846   3846   		    }
  3847   3847   		}
  3848   3848   		Tcl_DecrRefCount(sum);
  3849   3849   	    }
................................................................................
  3982   3982   	    }
  3983   3983   
  3984   3984   	    /* Got an integer offset; pull it from where parser left it. */
  3985   3985   	    TclGetNumberFromObj(NULL, objPtr, &cd, &t);
  3986   3986   
  3987   3987   	    if (t == TCL_NUMBER_BIG) {
  3988   3988   		/* Truncate to the signed wide range. */
  3989         -		if (mp_isneg((mp_int *)cd)) {
         3989  +		if (((mp_int *)cd)->sign != MP_ZPOS) {
  3990   3990   		    offset = (bytes[3] == '-') ? WIDE_MAX : WIDE_MIN;
  3991   3991   		} else {
  3992   3992   		    offset = (bytes[3] == '-') ? WIDE_MIN : WIDE_MAX;
  3993   3993   		}
  3994   3994   	    } else {
  3995   3995   		/* assert (t == TCL_NUMBER_INT); */
  3996   3996   		offset = (*(Tcl_WideInt *)cd);

Changes to tests/binary.test.

  2908   2908       apply {{a b} {
  2909   2909   	set one [binary format H* $a]
  2910   2910   	return $one[binary format H* $b]
  2911   2911       }} ab cd
  2912   2912   } [binary format H* abcd]
  2913   2913   
  2914   2914   test binary-78.1 {unicode (out of BMP) to byte-array conversion, bug-[bd94500678]} -body {
  2915         -    # just test for BO-segfault (high surrogate w/o advance source pointer for out of BMP char if TCL_UTF_MAX <= 4):
         2915  +    # just test for BO-segfault (high surrogate w/o advance source pointer for out of BMP char if TCL_UTF_MAX == 3):
  2916   2916       binary encode hex \U0001f415
  2917   2917       binary scan \U0001f415 a* v; set v
  2918   2918       set str {}
  2919   2919   } -result {}
  2920   2920   
  2921   2921   # ----------------------------------------------------------------------
  2922   2922   # cleanup

Changes to tests/util.test.

    17     17   
    18     18   testConstraint controversialNaN 1
    19     19   testConstraint testbytestring [llength [info commands testbytestring]]
    20     20   testConstraint testdstring [llength [info commands testdstring]]
    21     21   testConstraint testconcatobj [llength [info commands testconcatobj]]
    22     22   testConstraint testdoubledigits [llength [info commands testdoubledigits]]
    23     23   testConstraint testprint [llength [info commands testprint]]
           24  +
           25  +testConstraint precision [expr {![catch {set saved_precision $::tcl_precision}]}]
           26  +
    24     27   
    25     28   # Big test for correct ordering of data in [expr]
    26     29   
    27     30   proc testIEEE {} {
    28     31       variable ieeeValues
    29     32       binary scan [binary format dd -1.0 1.0] c* c
    30     33       switch -exact -- $c {
................................................................................
   381    384   test util-5.50 {Tcl_StringMatch} {
   382    385       Wrapper_Tcl_StringMatch *. ""
   383    386   } 0
   384    387   test util-5.51 {Tcl_StringMatch} {
   385    388       Wrapper_Tcl_StringMatch "" ""
   386    389   } 1
   387    390   
   388         -test util-6.1 {Tcl_PrintDouble - using tcl_precision} -setup {
          391  +test util-6.1 {Tcl_PrintDouble - using tcl_precision} -constraints precision -setup {
   389    392       set old_precision $::tcl_precision
   390    393       set ::tcl_precision 12
   391    394   } -body {
   392    395       concat x[expr 1.4]
   393    396   } -cleanup {
   394    397       set ::tcl_precision $old_precision
   395    398   } -result {x1.4}
   396         -test util-6.2 {Tcl_PrintDouble - using tcl_precision} -setup {
          399  +test util-6.2 {Tcl_PrintDouble - using tcl_precision} -constraints precision -setup {
   397    400       set old_precision $::tcl_precision
   398    401       set ::tcl_precision 12
   399    402   } -body {
   400    403       concat x[expr 1.39999999999]
   401    404   } -cleanup {
   402    405       set ::tcl_precision $old_precision
   403    406   } -result {x1.39999999999}
   404         -test util-6.3 {Tcl_PrintDouble - using tcl_precision} -setup {
          407  +test util-6.3 {Tcl_PrintDouble - using tcl_precision} -constraints precision -setup {
   405    408       set old_precision $::tcl_precision
   406    409       set ::tcl_precision 12
   407    410   } -body {
   408    411       concat x[expr 1.399999999999]
   409    412   } -cleanup {
   410    413       set ::tcl_precision $old_precision
   411    414   } -result {x1.4}
   412         -test util-6.4 {Tcl_PrintDouble - using tcl_precision} -setup {
          415  +test util-6.4 {Tcl_PrintDouble - using tcl_precision} -constraints precision -setup {
   413    416       set old_precision $::tcl_precision
   414    417       set ::tcl_precision 5
   415    418   } -body {
   416    419       concat x[expr 1.123412341234]
   417    420   } -cleanup {
   418    421       set tcl_precision $old_precision
   419    422   } -result {x1.1234}
................................................................................
   420    423   test util-6.5 {Tcl_PrintDouble - make sure there's a decimal point} {
   421    424       concat x[expr 2.0]
   422    425   } {x2.0}
   423    426   test util-6.6 {Tcl_PrintDouble - make sure there's a decimal point} {
   424    427       concat x[expr 3.0e98]
   425    428   } {x3e+98}
   426    429   
   427         -test util-7.1 {TclPrecTraceProc - unset callbacks} -setup {
          430  +test util-7.1 {TclPrecTraceProc - unset callbacks} -constraints precision -setup {
   428    431       set old_precision $::tcl_precision
   429    432   } -body {
   430    433       set tcl_precision 7
   431    434       set x $tcl_precision
   432    435       unset tcl_precision
   433    436       list $x $tcl_precision
   434    437   } -cleanup {
   435    438       set ::tcl_precision $old_precision
   436    439   } -result {7 7}
   437         -test util-7.2 {TclPrecTraceProc - read traces, sharing among interpreters}  -setup {
          440  +test util-7.2 {TclPrecTraceProc - read traces, sharing among interpreters} -constraints precision  -setup {
   438    441       set old_precision $::tcl_precision
   439    442   } -body {
   440    443       set tcl_precision 12
   441    444       interp create child
   442    445       set x [child eval set tcl_precision]
   443    446       child eval {set tcl_precision 6}
   444    447       interp delete child
   445    448       list $x $tcl_precision
   446    449   } -cleanup {
   447    450       set ::tcl_precision $old_precision
   448    451   } -result {12 6}
   449         -test util-7.3 {TclPrecTraceProc - write traces, safe interpreters} -setup {
          452  +test util-7.3 {TclPrecTraceProc - write traces, safe interpreters} -constraints precision -setup {
   450    453       set old_precision $::tcl_precision
   451    454   } -body {
   452    455       set tcl_precision 12
   453    456       interp create -safe child
   454    457       set x [child eval {
   455    458   	list [catch {set tcl_precision 8} msg] $msg
   456    459       }]
   457    460       interp delete child
   458    461       list $x $tcl_precision
   459    462   } -cleanup {
   460    463       set ::tcl_precision $old_precision
   461    464   } -result {{1 {can't set "tcl_precision": can't modify precision from a safe interpreter}} 12}
   462         -test util-7.4 {TclPrecTraceProc - write traces, bogus values} -setup {
          465  +test util-7.4 {TclPrecTraceProc - write traces, bogus values} -constraints precision -setup {
   463    466       set old_precision $::tcl_precision
   464    467   } -body {
   465    468       set tcl_precision 12
   466    469       list [catch {set tcl_precision abc} msg] $msg $tcl_precision
   467    470   } -cleanup {
   468    471       set ::tcl_precision $old_precision
   469    472   } -result {1 {can't set "tcl_precision": improper value for precision} 12}
................................................................................
  2177   2180       }
  2178   2181       -result 0x8010000000000000
  2179   2182       -cleanup {
  2180   2183   	unset x
  2181   2184       }
  2182   2185   }
  2183   2186   
  2184         -set saved_precision $::tcl_precision
  2185   2187   foreach ::tcl_precision {0 12} {
  2186   2188       for {set e -312} {$e < -9} {incr e} {
  2187   2189   	test util-16.1.$::tcl_precision.$e {shortening of numbers} \
  2188   2190   	    "expr 1.1e$e" 1.1e$e
  2189   2191       }
  2190   2192   }
  2191   2193   set tcl_precision 0
  2192   2194   for {set e -9} {$e < -4} {incr e} {
  2193   2195       test util-16.1.$::tcl_precision.$e {shortening of numbers} \
  2194   2196   	"expr 1.1e$e" 1.1e$e
  2195   2197   }
  2196   2198   set tcl_precision 12
  2197   2199   for {set e -9} {$e < -4} {incr e} {
  2198         -    test util-16.1.$::tcl_precision.$e {8.4 compatible formatting of doubles} \
         2200  +    test util-16.1.$::tcl_precision.$e {8.4 compatible formatting of doubles} precision \
  2199   2201   	"expr 1.1e$e" 1.1e[format %+03d $e]
  2200   2202   }
  2201   2203   foreach ::tcl_precision {0 12} {
  2202   2204       test util-16.1.$::tcl_precision.-4 {shortening of numbers} \
  2203   2205   	{expr 1.1e-4} \
  2204   2206   	0.00011
  2205   2207       test util-16.1.$::tcl_precision.-3 {shortening of numbers} \
................................................................................
  2221   2223       }
  2222   2224       for {set e 17} {$e < 309} {incr e} {
  2223   2225   	test util-16.1.$::tcl_precision.$e {shortening of numbers} \
  2224   2226   	    "expr 1.1e$e" 1.1e+$e
  2225   2227       }
  2226   2228   }
  2227   2229   set tcl_precision 17
  2228         -test util-16.1.17.-300 {8.4 compatible formatting of doubles} \
         2230  +test util-16.1.17.-300 {8.4 compatible formatting of doubles} precision \
  2229   2231       {expr 1e-300} \
  2230   2232       1e-300
  2231         -test util-16.1.17.-299 {8.4 compatible formatting of doubles} \
         2233  +test util-16.1.17.-299 {8.4 compatible formatting of doubles} precision \
  2232   2234       {expr 1e-299} \
  2233   2235       9.9999999999999999e-300
  2234         -test util-16.1.17.-298 {8.4 compatible formatting of doubles} \
         2236  +test util-16.1.17.-298 {8.4 compatible formatting of doubles} precision \
  2235   2237       {expr 1e-298} \
  2236   2238       9.9999999999999991e-299
  2237         -test util-16.1.17.-297 {8.4 compatible formatting of doubles} \
         2239  +test util-16.1.17.-297 {8.4 compatible formatting of doubles} precision \
  2238   2240       {expr 1e-297} \
  2239   2241       1e-297
  2240         -test util-16.1.17.-296 {8.4 compatible formatting of doubles} \
         2242  +test util-16.1.17.-296 {8.4 compatible formatting of doubles} precision \
  2241   2243       {expr 1e-296} \
  2242   2244       1e-296
  2243         -test util-16.1.17.-295 {8.4 compatible formatting of doubles} \
         2245  +test util-16.1.17.-295 {8.4 compatible formatting of doubles} precision \
  2244   2246       {expr 1e-295} \
  2245   2247       1.0000000000000001e-295
  2246         -test util-16.1.17.-294 {8.4 compatible formatting of doubles} \
         2248  +test util-16.1.17.-294 {8.4 compatible formatting of doubles} precision \
  2247   2249       {expr 1e-294} \
  2248   2250       1e-294
  2249         -test util-16.1.17.-293 {8.4 compatible formatting of doubles} \
         2251  +test util-16.1.17.-293 {8.4 compatible formatting of doubles} precision \
  2250   2252       {expr 1e-293} \
  2251   2253       1.0000000000000001e-293
  2252         -test util-16.1.17.-292 {8.4 compatible formatting of doubles} \
         2254  +test util-16.1.17.-292 {8.4 compatible formatting of doubles} precision \
  2253   2255       {expr 1e-292} \
  2254   2256       1.0000000000000001e-292
  2255         -test util-16.1.17.-291 {8.4 compatible formatting of doubles} \
         2257  +test util-16.1.17.-291 {8.4 compatible formatting of doubles} precision \
  2256   2258       {expr 1e-291} \
  2257   2259       9.9999999999999996e-292
  2258         -test util-16.1.17.-290 {8.4 compatible formatting of doubles} \
         2260  +test util-16.1.17.-290 {8.4 compatible formatting of doubles} precision \
  2259   2261       {expr 1e-290} \
  2260   2262       1.0000000000000001e-290
  2261         -test util-16.1.17.-289 {8.4 compatible formatting of doubles} \
         2263  +test util-16.1.17.-289 {8.4 compatible formatting of doubles} precision \
  2262   2264       {expr 1e-289} \
  2263   2265       1e-289
  2264         -test util-16.1.17.-288 {8.4 compatible formatting of doubles} \
         2266  +test util-16.1.17.-288 {8.4 compatible formatting of doubles} precision \
  2265   2267       {expr 1e-288} \
  2266   2268       1.0000000000000001e-288
  2267         -test util-16.1.17.-287 {8.4 compatible formatting of doubles} \
         2269  +test util-16.1.17.-287 {8.4 compatible formatting of doubles} precision \
  2268   2270       {expr 1e-287} \
  2269   2271       1e-287
  2270         -test util-16.1.17.-286 {8.4 compatible formatting of doubles} \
         2272  +test util-16.1.17.-286 {8.4 compatible formatting of doubles} precision \
  2271   2273       {expr 1e-286} \
  2272   2274       1.0000000000000001e-286
  2273         -test util-16.1.17.-285 {8.4 compatible formatting of doubles} \
         2275  +test util-16.1.17.-285 {8.4 compatible formatting of doubles} precision \
  2274   2276       {expr 1e-285} \
  2275   2277       1.0000000000000001e-285
  2276         -test util-16.1.17.-284 {8.4 compatible formatting of doubles} \
         2278  +test util-16.1.17.-284 {8.4 compatible formatting of doubles} precision \
  2277   2279       {expr 1e-284} \
  2278   2280       1e-284
  2279         -test util-16.1.17.-283 {8.4 compatible formatting of doubles} \
         2281  +test util-16.1.17.-283 {8.4 compatible formatting of doubles} precision \
  2280   2282       {expr 1e-283} \
  2281   2283       9.9999999999999995e-284
  2282         -test util-16.1.17.-282 {8.4 compatible formatting of doubles} \
         2284  +test util-16.1.17.-282 {8.4 compatible formatting of doubles} precision \
  2283   2285       {expr 1e-282} \
  2284   2286       1e-282
  2285         -test util-16.1.17.-281 {8.4 compatible formatting of doubles} \
         2287  +test util-16.1.17.-281 {8.4 compatible formatting of doubles} precision \
  2286   2288       {expr 1e-281} \
  2287   2289       1e-281
  2288         -test util-16.1.17.-280 {8.4 compatible formatting of doubles} \
         2290  +test util-16.1.17.-280 {8.4 compatible formatting of doubles} precision \
  2289   2291       {expr 1e-280} \
  2290   2292       9.9999999999999996e-281
  2291         -test util-16.1.17.-279 {8.4 compatible formatting of doubles} \
         2293  +test util-16.1.17.-279 {8.4 compatible formatting of doubles} precision \
  2292   2294       {expr 1e-279} \
  2293   2295       1.0000000000000001e-279
  2294         -test util-16.1.17.-278 {8.4 compatible formatting of doubles} \
         2296  +test util-16.1.17.-278 {8.4 compatible formatting of doubles} precision \
  2295   2297       {expr 1e-278} \
  2296   2298       9.9999999999999994e-279
  2297         -test util-16.1.17.-277 {8.4 compatible formatting of doubles} \
         2299  +test util-16.1.17.-277 {8.4 compatible formatting of doubles} precision \
  2298   2300       {expr 1e-277} \
  2299   2301       9.9999999999999997e-278
  2300         -test util-16.1.17.-276 {8.4 compatible formatting of doubles} \
         2302  +test util-16.1.17.-276 {8.4 compatible formatting of doubles} precision \
  2301   2303       {expr 1e-276} \
  2302   2304       1.0000000000000001e-276
  2303         -test util-16.1.17.-275 {8.4 compatible formatting of doubles} \
         2305  +test util-16.1.17.-275 {8.4 compatible formatting of doubles} precision \
  2304   2306       {expr 1e-275} \
  2305   2307       9.9999999999999993e-276
  2306         -test util-16.1.17.-274 {8.4 compatible formatting of doubles} \
         2308  +test util-16.1.17.-274 {8.4 compatible formatting of doubles} precision \
  2307   2309       {expr 1e-274} \
  2308   2310       9.9999999999999997e-275
  2309         -test util-16.1.17.-273 {8.4 compatible formatting of doubles} \
         2311  +test util-16.1.17.-273 {8.4 compatible formatting of doubles} precision \
  2310   2312       {expr 1e-273} \
  2311   2313       1.0000000000000001e-273
  2312         -test util-16.1.17.-272 {8.4 compatible formatting of doubles} \
         2314  +test util-16.1.17.-272 {8.4 compatible formatting of doubles} precision \
  2313   2315       {expr 1e-272} \
  2314   2316       9.9999999999999993e-273
  2315         -test util-16.1.17.-271 {8.4 compatible formatting of doubles} \
         2317  +test util-16.1.17.-271 {8.4 compatible formatting of doubles} precision \
  2316   2318       {expr 1e-271} \
  2317   2319       9.9999999999999996e-272
  2318         -test util-16.1.17.-270 {8.4 compatible formatting of doubles} \
         2320  +test util-16.1.17.-270 {8.4 compatible formatting of doubles} precision \
  2319   2321       {expr 1e-270} \
  2320   2322       1e-270
  2321         -test util-16.1.17.-269 {8.4 compatible formatting of doubles} \
         2323  +test util-16.1.17.-269 {8.4 compatible formatting of doubles} precision \
  2322   2324       {expr 1e-269} \
  2323   2325       9.9999999999999996e-270
  2324         -test util-16.1.17.-268 {8.4 compatible formatting of doubles} \
         2326  +test util-16.1.17.-268 {8.4 compatible formatting of doubles} precision \
  2325   2327       {expr 1e-268} \
  2326   2328       9.9999999999999996e-269
  2327         -test util-16.1.17.-267 {8.4 compatible formatting of doubles} \
         2329  +test util-16.1.17.-267 {8.4 compatible formatting of doubles} precision \
  2328   2330       {expr 1e-267} \
  2329   2331       9.9999999999999998e-268
  2330         -test util-16.1.17.-266 {8.4 compatible formatting of doubles} \
         2332  +test util-16.1.17.-266 {8.4 compatible formatting of doubles} precision \
  2331   2333       {expr 1e-266} \
  2332   2334       9.9999999999999998e-267
  2333         -test util-16.1.17.-265 {8.4 compatible formatting of doubles} \
         2335  +test util-16.1.17.-265 {8.4 compatible formatting of doubles} precision \
  2334   2336       {expr 1e-265} \
  2335   2337       9.9999999999999998e-266
  2336         -test util-16.1.17.-264 {8.4 compatible formatting of doubles} \
         2338  +test util-16.1.17.-264 {8.4 compatible formatting of doubles} precision \
  2337   2339       {expr 1e-264} \
  2338   2340       1e-264
  2339         -test util-16.1.17.-263 {8.4 compatible formatting of doubles} \
         2341  +test util-16.1.17.-263 {8.4 compatible formatting of doubles} precision \
  2340   2342       {expr 1e-263} \
  2341   2343       1e-263
  2342         -test util-16.1.17.-262 {8.4 compatible formatting of doubles} \
         2344  +test util-16.1.17.-262 {8.4 compatible formatting of doubles} precision \
  2343   2345       {expr 1e-262} \
  2344   2346       1e-262
  2345         -test util-16.1.17.-261 {8.4 compatible formatting of doubles} \
         2347  +test util-16.1.17.-261 {8.4 compatible formatting of doubles} precision \
  2346   2348       {expr 1e-261} \
  2347   2349       9.9999999999999998e-262
  2348         -test util-16.1.17.-260 {8.4 compatible formatting of doubles} \
         2350  +test util-16.1.17.-260 {8.4 compatible formatting of doubles} precision \
  2349   2351       {expr 1e-260} \
  2350   2352       9.9999999999999996e-261
  2351         -test util-16.1.17.-259 {8.4 compatible formatting of doubles} \
         2353  +test util-16.1.17.-259 {8.4 compatible formatting of doubles} precision \
  2352   2354       {expr 1e-259} \
  2353   2355       1.0000000000000001e-259
  2354         -test util-16.1.17.-258 {8.4 compatible formatting of doubles} \
         2356  +test util-16.1.17.-258 {8.4 compatible formatting of doubles} precision \
  2355   2357       {expr 1e-258} \
  2356   2358       9.9999999999999995e-259
  2357         -test util-16.1.17.-257 {8.4 compatible formatting of doubles} \
         2359  +test util-16.1.17.-257 {8.4 compatible formatting of doubles} precision \
  2358   2360       {expr 1e-257} \
  2359   2361       9.9999999999999998e-258
  2360         -test util-16.1.17.-256 {8.4 compatible formatting of doubles} \
         2362  +test util-16.1.17.-256 {8.4 compatible formatting of doubles} precision \
  2361   2363       {expr 1e-256} \
  2362   2364       9.9999999999999998e-257
  2363         -test util-16.1.17.-255 {8.4 compatible formatting of doubles} \
         2365  +test util-16.1.17.-255 {8.4 compatible formatting of doubles} precision \
  2364   2366       {expr 1e-255} \
  2365   2367       1e-255
  2366         -test util-16.1.17.-254 {8.4 compatible formatting of doubles} \
         2368  +test util-16.1.17.-254 {8.4 compatible formatting of doubles} precision \
  2367   2369       {expr 1e-254} \
  2368   2370       9.9999999999999991e-255
  2369         -test util-16.1.17.-253 {8.4 compatible formatting of doubles} \
         2371  +test util-16.1.17.-253 {8.4 compatible formatting of doubles} precision \
  2370   2372       {expr 1e-253} \
  2371   2373       1.0000000000000001e-253
  2372         -test util-16.1.17.-252 {8.4 compatible formatting of doubles} \
         2374  +test util-16.1.17.-252 {8.4 compatible formatting of doubles} precision \
  2373   2375       {expr 1e-252} \
  2374   2376       9.9999999999999994e-253
  2375         -test util-16.1.17.-251 {8.4 compatible formatting of doubles} \
         2377  +test util-16.1.17.-251 {8.4 compatible formatting of doubles} precision \
  2376   2378       {expr 1e-251} \
  2377   2379       1e-251
  2378         -test util-16.1.17.-250 {8.4 compatible formatting of doubles} \
         2380  +test util-16.1.17.-250 {8.4 compatible formatting of doubles} precision \
  2379   2381       {expr 1e-250} \
  2380   2382       1.0000000000000001e-250
  2381         -test util-16.1.17.-249 {8.4 compatible formatting of doubles} \
         2383  +test util-16.1.17.-249 {8.4 compatible formatting of doubles} precision \
  2382   2384       {expr 1e-249} \
  2383   2385       1.0000000000000001e-249
  2384         -test util-16.1.17.-248 {8.4 compatible formatting of doubles} \
         2386  +test util-16.1.17.-248 {8.4 compatible formatting of doubles} precision \
  2385   2387       {expr 1e-248} \
  2386   2388       9.9999999999999998e-249
  2387         -test util-16.1.17.-247 {8.4 compatible formatting of doubles} \
         2389  +test util-16.1.17.-247 {8.4 compatible formatting of doubles} precision \
  2388   2390       {expr 1e-247} \
  2389   2391       1e-247
  2390         -test util-16.1.17.-246 {8.4 compatible formatting of doubles} \
         2392  +test util-16.1.17.-246 {8.4 compatible formatting of doubles} precision \
  2391   2393       {expr 1e-246} \
  2392   2394       9.9999999999999996e-247
  2393         -test util-16.1.17.-245 {8.4 compatible formatting of doubles} \
         2395  +test util-16.1.17.-245 {8.4 compatible formatting of doubles} precision \
  2394   2396       {expr 1e-245} \
  2395   2397       9.9999999999999993e-246
  2396         -test util-16.1.17.-244 {8.4 compatible formatting of doubles} \
         2398  +test util-16.1.17.-244 {8.4 compatible formatting of doubles} precision \
  2397   2399       {expr 1e-244} \
  2398   2400       9.9999999999999993e-245
  2399         -test util-16.1.17.-243 {8.4 compatible formatting of doubles} \
         2401  +test util-16.1.17.-243 {8.4 compatible formatting of doubles} precision \
  2400   2402       {expr 1e-243} \
  2401   2403       1e-243
  2402         -test util-16.1.17.-242 {8.4 compatible formatting of doubles} \
         2404  +test util-16.1.17.-242 {8.4 compatible formatting of doubles} precision \
  2403   2405       {expr 1e-242} \
  2404   2406       9.9999999999999997e-243
  2405         -test util-16.1.17.-241 {8.4 compatible formatting of doubles} \
         2407  +test util-16.1.17.-241 {8.4 compatible formatting of doubles} precision \
  2406   2408       {expr 1e-241} \
  2407   2409       9.9999999999999997e-242
  2408         -test util-16.1.17.-240 {8.4 compatible formatting of doubles} \
         2410  +test util-16.1.17.-240 {8.4 compatible formatting of doubles} precision \
  2409   2411       {expr 1e-240} \
  2410   2412       9.9999999999999997e-241
  2411         -test util-16.1.17.-239 {8.4 compatible formatting of doubles} \
         2413  +test util-16.1.17.-239 {8.4 compatible formatting of doubles} precision \
  2412   2414       {expr 1e-239} \
  2413   2415       1.0000000000000001e-239
  2414         -test util-16.1.17.-238 {8.4 compatible formatting of doubles} \
         2416  +test util-16.1.17.-238 {8.4 compatible formatting of doubles} precision \
  2415   2417       {expr 1e-238} \
  2416   2418       9.9999999999999999e-239
  2417         -test util-16.1.17.-237 {8.4 compatible formatting of doubles} \
         2419  +test util-16.1.17.-237 {8.4 compatible formatting of doubles} precision \
  2418   2420       {expr 1e-237} \
  2419   2421       9.9999999999999999e-238
  2420         -test util-16.1.17.-236 {8.4 compatible formatting of doubles} \
         2422  +test util-16.1.17.-236 {8.4 compatible formatting of doubles} precision \
  2421   2423       {expr 1e-236} \
  2422   2424       1e-236
  2423         -test util-16.1.17.-235 {8.4 compatible formatting of doubles} \
         2425  +test util-16.1.17.-235 {8.4 compatible formatting of doubles} precision \
  2424   2426       {expr 1e-235} \
  2425   2427       9.9999999999999996e-236
  2426         -test util-16.1.17.-234 {8.4 compatible formatting of doubles} \
         2428  +test util-16.1.17.-234 {8.4 compatible formatting of doubles} precision \
  2427   2429       {expr 1e-234} \
  2428   2430       9.9999999999999996e-235
  2429         -test util-16.1.17.-233 {8.4 compatible formatting of doubles} \
         2431  +test util-16.1.17.-233 {8.4 compatible formatting of doubles} precision \
  2430   2432       {expr 1e-233} \
  2431   2433       9.9999999999999996e-234
  2432         -test util-16.1.17.-232 {8.4 compatible formatting of doubles} \
         2434  +test util-16.1.17.-232 {8.4 compatible formatting of doubles} precision \
  2433   2435       {expr 1e-232} \
  2434   2436       1e-232
  2435         -test util-16.1.17.-231 {8.4 compatible formatting of doubles} \
         2437  +test util-16.1.17.-231 {8.4 compatible formatting of doubles} precision \
  2436   2438       {expr 1e-231} \
  2437   2439       9.9999999999999999e-232
  2438         -test util-16.1.17.-230 {8.4 compatible formatting of doubles} \
         2440  +test util-16.1.17.-230 {8.4 compatible formatting of doubles} precision \
  2439   2441       {expr 1e-230} \
  2440   2442       1e-230
  2441         -test util-16.1.17.-229 {8.4 compatible formatting of doubles} \
         2443  +test util-16.1.17.-229 {8.4 compatible formatting of doubles} precision \
  2442   2444       {expr 1e-229} \
  2443   2445       1.0000000000000001e-229
  2444         -test util-16.1.17.-228 {8.4 compatible formatting of doubles} \
         2446  +test util-16.1.17.-228 {8.4 compatible formatting of doubles} precision \
  2445   2447       {expr 1e-228} \
  2446   2448       1e-228
  2447         -test util-16.1.17.-227 {8.4 compatible formatting of doubles} \
         2449  +test util-16.1.17.-227 {8.4 compatible formatting of doubles} precision \
  2448   2450       {expr 1e-227} \
  2449   2451       9.9999999999999994e-228
  2450         -test util-16.1.17.-226 {8.4 compatible formatting of doubles} \
         2452  +test util-16.1.17.-226 {8.4 compatible formatting of doubles} precision \
  2451   2453       {expr 1e-226} \
  2452   2454       9.9999999999999992e-227
  2453         -test util-16.1.17.-225 {8.4 compatible formatting of doubles} \
         2455  +test util-16.1.17.-225 {8.4 compatible formatting of doubles} precision \
  2454   2456       {expr 1e-225} \
  2455   2457       9.9999999999999996e-226
  2456         -test util-16.1.17.-224 {8.4 compatible formatting of doubles} \
         2458  +test util-16.1.17.-224 {8.4 compatible formatting of doubles} precision \
  2457   2459       {expr 1e-224} \
  2458   2460       1e-224
  2459         -test util-16.1.17.-223 {8.4 compatible formatting of doubles} \
         2461  +test util-16.1.17.-223 {8.4 compatible formatting of doubles} precision \
  2460   2462       {expr 1e-223} \
  2461   2463       9.9999999999999997e-224
  2462         -test util-16.1.17.-222 {8.4 compatible formatting of doubles} \
         2464  +test util-16.1.17.-222 {8.4 compatible formatting of doubles} precision \
  2463   2465       {expr 1e-222} \
  2464   2466       1e-222
  2465         -test util-16.1.17.-221 {8.4 compatible formatting of doubles} \
         2467  +test util-16.1.17.-221 {8.4 compatible formatting of doubles} precision \
  2466   2468       {expr 1e-221} \
  2467   2469       1e-221
  2468         -test util-16.1.17.-220 {8.4 compatible formatting of doubles} \
         2470  +test util-16.1.17.-220 {8.4 compatible formatting of doubles} precision \
  2469   2471       {expr 1e-220} \
  2470   2472       9.9999999999999999e-221
  2471         -test util-16.1.17.-219 {8.4 compatible formatting of doubles} \
         2473  +test util-16.1.17.-219 {8.4 compatible formatting of doubles} precision \
  2472   2474       {expr 1e-219} \
  2473   2475       1e-219
  2474         -test util-16.1.17.-218 {8.4 compatible formatting of doubles} \
         2476  +test util-16.1.17.-218 {8.4 compatible formatting of doubles} precision \
  2475   2477       {expr 1e-218} \
  2476   2478       1e-218
  2477         -test util-16.1.17.-217 {8.4 compatible formatting of doubles} \
         2479  +test util-16.1.17.-217 {8.4 compatible formatting of doubles} precision \
  2478   2480       {expr 1e-217} \
  2479   2481       1.0000000000000001e-217
  2480         -test util-16.1.17.-216 {8.4 compatible formatting of doubles} \
         2482  +test util-16.1.17.-216 {8.4 compatible formatting of doubles} precision \
  2481   2483       {expr 1e-216} \
  2482   2484       1e-216
  2483         -test util-16.1.17.-215 {8.4 compatible formatting of doubles} \
         2485  +test util-16.1.17.-215 {8.4 compatible formatting of doubles} precision \
  2484   2486       {expr 1e-215} \
  2485   2487       1e-215
  2486         -test util-16.1.17.-214 {8.4 compatible formatting of doubles} \
         2488  +test util-16.1.17.-214 {8.4 compatible formatting of doubles} precision \
  2487   2489       {expr 1e-214} \
  2488   2490       9.9999999999999991e-215
  2489         -test util-16.1.17.-213 {8.4 compatible formatting of doubles} \
         2491  +test util-16.1.17.-213 {8.4 compatible formatting of doubles} precision \
  2490   2492       {expr 1e-213} \
  2491   2493       9.9999999999999995e-214
  2492         -test util-16.1.17.-212 {8.4 compatible formatting of doubles} \
         2494  +test util-16.1.17.-212 {8.4 compatible formatting of doubles} precision \
  2493   2495       {expr 1e-212} \
  2494   2496       9.9999999999999995e-213
  2495         -test util-16.1.17.-211 {8.4 compatible formatting of doubles} \
         2497  +test util-16.1.17.-211 {8.4 compatible formatting of doubles} precision \
  2496   2498       {expr 1e-211} \
  2497   2499       1.0000000000000001e-211
  2498         -test util-16.1.17.-210 {8.4 compatible formatting of doubles} \
         2500  +test util-16.1.17.-210 {8.4 compatible formatting of doubles} precision \
  2499   2501       {expr 1e-210} \
  2500   2502       1e-210
  2501         -test util-16.1.17.-209 {8.4 compatible formatting of doubles} \
         2503  +test util-16.1.17.-209 {8.4 compatible formatting of doubles} precision \
  2502   2504       {expr 1e-209} \
  2503   2505       1e-209
  2504         -test util-16.1.17.-208 {8.4 compatible formatting of doubles} \
         2506  +test util-16.1.17.-208 {8.4 compatible formatting of doubles} precision \
  2505   2507       {expr 1e-208} \
  2506   2508       1.0000000000000001e-208
  2507         -test util-16.1.17.-207 {8.4 compatible formatting of doubles} \
         2509  +test util-16.1.17.-207 {8.4 compatible formatting of doubles} precision \
  2508   2510       {expr 1e-207} \
  2509   2511       9.9999999999999993e-208
  2510         -test util-16.1.17.-206 {8.4 compatible formatting of doubles} \
         2512  +test util-16.1.17.-206 {8.4 compatible formatting of doubles} precision \
  2511   2513       {expr 1e-206} \
  2512   2514       1e-206
  2513         -test util-16.1.17.-205 {8.4 compatible formatting of doubles} \
         2515  +test util-16.1.17.-205 {8.4 compatible formatting of doubles} precision \
  2514   2516       {expr 1e-205} \
  2515   2517       1e-205
  2516         -test util-16.1.17.-204 {8.4 compatible formatting of doubles} \
         2518  +test util-16.1.17.-204 {8.4 compatible formatting of doubles} precision \
  2517   2519       {expr 1e-204} \
  2518   2520       1e-204
  2519         -test util-16.1.17.-203 {8.4 compatible formatting of doubles} \
         2521  +test util-16.1.17.-203 {8.4 compatible formatting of doubles} precision \
  2520   2522       {expr 1e-203} \
  2521   2523       1e-203
  2522         -test util-16.1.17.-202 {8.4 compatible formatting of doubles} \
         2524  +test util-16.1.17.-202 {8.4 compatible formatting of doubles} precision \
  2523   2525       {expr 1e-202} \
  2524   2526       1e-202
  2525         -test util-16.1.17.-201 {8.4 compatible formatting of doubles} \
         2527  +test util-16.1.17.-201 {8.4 compatible formatting of doubles} precision \
  2526   2528       {expr 1e-201} \
  2527   2529       9.9999999999999995e-202
  2528         -test util-16.1.17.-200 {8.4 compatible formatting of doubles} \
         2530  +test util-16.1.17.-200 {8.4 compatible formatting of doubles} precision \
  2529   2531       {expr 1e-200} \
  2530   2532       9.9999999999999998e-201
  2531         -test util-16.1.17.-199 {8.4 compatible formatting of doubles} \
         2533  +test util-16.1.17.-199 {8.4 compatible formatting of doubles} precision \
  2532   2534       {expr 1e-199} \
  2533   2535       9.9999999999999998e-200
  2534         -test util-16.1.17.-198 {8.4 compatible formatting of doubles} \
         2536  +test util-16.1.17.-198 {8.4 compatible formatting of doubles} precision \
  2535   2537       {expr 1e-198} \
  2536   2538       9.9999999999999991e-199
  2537         -test util-16.1.17.-197 {8.4 compatible formatting of doubles} \
         2539  +test util-16.1.17.-197 {8.4 compatible formatting of doubles} precision \
  2538   2540       {expr 1e-197} \
  2539   2541       9.9999999999999999e-198
  2540         -test util-16.1.17.-196 {8.4 compatible formatting of doubles} \
         2542  +test util-16.1.17.-196 {8.4 compatible formatting of doubles} precision \
  2541   2543       {expr 1e-196} \
  2542   2544       1e-196
  2543         -test util-16.1.17.-195 {8.4 compatible formatting of doubles} \
         2545  +test util-16.1.17.-195 {8.4 compatible formatting of doubles} precision \
  2544   2546       {expr 1e-195} \
  2545   2547       1.0000000000000001e-195
  2546         -test util-16.1.17.-194 {8.4 compatible formatting of doubles} \
         2548  +test util-16.1.17.-194 {8.4 compatible formatting of doubles} precision \
  2547   2549       {expr 1e-194} \
  2548   2550       1e-194
  2549         -test util-16.1.17.-193 {8.4 compatible formatting of doubles} \
         2551  +test util-16.1.17.-193 {8.4 compatible formatting of doubles} precision \
  2550   2552       {expr 1e-193} \
  2551   2553       1e-193
  2552         -test util-16.1.17.-192 {8.4 compatible formatting of doubles} \
         2554  +test util-16.1.17.-192 {8.4 compatible formatting of doubles} precision \
  2553   2555       {expr 1e-192} \
  2554   2556       1.0000000000000001e-192
  2555         -test util-16.1.17.-191 {8.4 compatible formatting of doubles} \
         2557  +test util-16.1.17.-191 {8.4 compatible formatting of doubles} precision \
  2556   2558       {expr 1e-191} \
  2557   2559       1e-191
  2558         -test util-16.1.17.-190 {8.4 compatible formatting of doubles} \
         2560  +test util-16.1.17.-190 {8.4 compatible formatting of doubles} precision \
  2559   2561       {expr 1e-190} \
  2560   2562       1e-190
  2561         -test util-16.1.17.-189 {8.4 compatible formatting of doubles} \
         2563  +test util-16.1.17.-189 {8.4 compatible formatting of doubles} precision \
  2562   2564       {expr 1e-189} \
  2563   2565       1.0000000000000001e-189
  2564         -test util-16.1.17.-188 {8.4 compatible formatting of doubles} \
         2566  +test util-16.1.17.-188 {8.4 compatible formatting of doubles} precision \
  2565   2567       {expr 1e-188} \
  2566   2568       9.9999999999999995e-189
  2567         -test util-16.1.17.-187 {8.4 compatible formatting of doubles} \
         2569  +test util-16.1.17.-187 {8.4 compatible formatting of doubles} precision \
  2568   2570       {expr 1e-187} \
  2569   2571       1e-187
  2570         -test util-16.1.17.-186 {8.4 compatible formatting of doubles} \
         2572  +test util-16.1.17.-186 {8.4 compatible formatting of doubles} precision \
  2571   2573       {expr 1e-186} \
  2572   2574       9.9999999999999991e-187
  2573         -test util-16.1.17.-185 {8.4 compatible formatting of doubles} \
         2575  +test util-16.1.17.-185 {8.4 compatible formatting of doubles} precision \
  2574   2576       {expr 1e-185} \
  2575   2577       9.9999999999999999e-186
  2576         -test util-16.1.17.-184 {8.4 compatible formatting of doubles} \
         2578  +test util-16.1.17.-184 {8.4 compatible formatting of doubles} precision \
  2577   2579       {expr 1e-184} \
  2578   2580       1.0000000000000001e-184
  2579         -test util-16.1.17.-183 {8.4 compatible formatting of doubles} \
         2581  +test util-16.1.17.-183 {8.4 compatible formatting of doubles} precision \
  2580   2582       {expr 1e-183} \
  2581   2583       1e-183
  2582         -test util-16.1.17.-182 {8.4 compatible formatting of doubles} \
         2584  +test util-16.1.17.-182 {8.4 compatible formatting of doubles} precision \
  2583   2585       {expr 1e-182} \
  2584   2586       1e-182
  2585         -test util-16.1.17.-181 {8.4 compatible formatting of doubles} \
         2587  +test util-16.1.17.-181 {8.4 compatible formatting of doubles} precision \
  2586   2588       {expr 1e-181} \
  2587   2589       1e-181
  2588         -test util-16.1.17.-180 {8.4 compatible formatting of doubles} \
         2590  +test util-16.1.17.-180 {8.4 compatible formatting of doubles} precision \
  2589   2591       {expr 1e-180} \
  2590   2592       1e-180
  2591         -test util-16.1.17.-179 {8.4 compatible formatting of doubles} \
         2593  +test util-16.1.17.-179 {8.4 compatible formatting of doubles} precision \
  2592   2594       {expr 1e-179} \
  2593   2595       1e-179
  2594         -test util-16.1.17.-178 {8.4 compatible formatting of doubles} \
         2596  +test util-16.1.17.-178 {8.4 compatible formatting of doubles} precision \
  2595   2597       {expr 1e-178} \
  2596   2598       9.9999999999999995e-179
  2597         -test util-16.1.17.-177 {8.4 compatible formatting of doubles} \
         2599  +test util-16.1.17.-177 {8.4 compatible formatting of doubles} precision \
  2598   2600       {expr 1e-177} \
  2599   2601       9.9999999999999995e-178
  2600         -test util-16.1.17.-176 {8.4 compatible formatting of doubles} \
         2602  +test util-16.1.17.-176 {8.4 compatible formatting of doubles} precision \
  2601   2603       {expr 1e-176} \
  2602   2604       1e-176
  2603         -test util-16.1.17.-175 {8.4 compatible formatting of doubles} \
         2605  +test util-16.1.17.-175 {8.4 compatible formatting of doubles} precision \
  2604   2606       {expr 1e-175} \
  2605   2607       1e-175
  2606         -test util-16.1.17.-174 {8.4 compatible formatting of doubles} \
         2608  +test util-16.1.17.-174 {8.4 compatible formatting of doubles} precision \
  2607   2609       {expr 1e-174} \
  2608   2610       1e-174
  2609         -test util-16.1.17.-173 {8.4 compatible formatting of doubles} \
         2611  +test util-16.1.17.-173 {8.4 compatible formatting of doubles} precision \
  2610   2612       {expr 1e-173} \
  2611   2613       1e-173
  2612         -test util-16.1.17.-172 {8.4 compatible formatting of doubles} \
         2614  +test util-16.1.17.-172 {8.4 compatible formatting of doubles} precision \
  2613   2615       {expr 1e-172} \
  2614   2616       1e-172
  2615         -test util-16.1.17.-171 {8.4 compatible formatting of doubles} \
         2617  +test util-16.1.17.-171 {8.4 compatible formatting of doubles} precision \
  2616   2618       {expr 1e-171} \
  2617   2619       9.9999999999999998e-172
  2618         -test util-16.1.17.-170 {8.4 compatible formatting of doubles} \
         2620  +test util-16.1.17.-170 {8.4 compatible formatting of doubles} precision \
  2619   2621       {expr 1e-170} \
  2620   2622       9.9999999999999998e-171
  2621         -test util-16.1.17.-169 {8.4 compatible formatting of doubles} \
         2623  +test util-16.1.17.-169 {8.4 compatible formatting of doubles} precision \
  2622   2624       {expr 1e-169} \
  2623   2625       1e-169
  2624         -test util-16.1.17.-168 {8.4 compatible formatting of doubles} \
         2626  +test util-16.1.17.-168 {8.4 compatible formatting of doubles} precision \
  2625   2627       {expr 1e-168} \
  2626   2628       1e-168
  2627         -test util-16.1.17.-167 {8.4 compatible formatting of doubles} \
         2629  +test util-16.1.17.-167 {8.4 compatible formatting of doubles} precision \
  2628   2630       {expr 1e-167} \
  2629   2631       1e-167
  2630         -test util-16.1.17.-166 {8.4 compatible formatting of doubles} \
         2632  +test util-16.1.17.-166 {8.4 compatible formatting of doubles} precision \
  2631   2633       {expr 1e-166} \
  2632   2634       1e-166
  2633         -test util-16.1.17.-165 {8.4 compatible formatting of doubles} \
         2635  +test util-16.1.17.-165 {8.4 compatible formatting of doubles} precision \
  2634   2636       {expr 1e-165} \
  2635   2637       1e-165
  2636         -test util-16.1.17.-164 {8.4 compatible formatting of doubles} \
         2638  +test util-16.1.17.-164 {8.4 compatible formatting of doubles} precision \
  2637   2639       {expr 1e-164} \
  2638   2640       9.9999999999999996e-165
  2639         -test util-16.1.17.-163 {8.4 compatible formatting of doubles} \
         2641  +test util-16.1.17.-163 {8.4 compatible formatting of doubles} precision \
  2640   2642       {expr 1e-163} \
  2641   2643       9.9999999999999992e-164
  2642         -test util-16.1.17.-162 {8.4 compatible formatting of doubles} \
         2644  +test util-16.1.17.-162 {8.4 compatible formatting of doubles} precision \
  2643   2645       {expr 1e-162} \
  2644   2646       9.9999999999999995e-163
  2645         -test util-16.1.17.-161 {8.4 compatible formatting of doubles} \
         2647  +test util-16.1.17.-161 {8.4 compatible formatting of doubles} precision \
  2646   2648       {expr 1e-161} \
  2647   2649       1e-161
  2648         -test util-16.1.17.-160 {8.4 compatible formatting of doubles} \
         2650  +test util-16.1.17.-160 {8.4 compatible formatting of doubles} precision \
  2649   2651       {expr 1e-160} \
  2650   2652       9.9999999999999999e-161
  2651         -test util-16.1.17.-159 {8.4 compatible formatting of doubles} \
         2653  +test util-16.1.17.-159 {8.4 compatible formatting of doubles} precision \
  2652   2654       {expr 1e-159} \
  2653   2655       9.9999999999999999e-160
  2654         -test util-16.1.17.-158 {8.4 compatible formatting of doubles} \
         2656  +test util-16.1.17.-158 {8.4 compatible formatting of doubles} precision \
  2655   2657       {expr 1e-158} \
  2656   2658       1.0000000000000001e-158
  2657         -test util-16.1.17.-157 {8.4 compatible formatting of doubles} \
         2659  +test util-16.1.17.-157 {8.4 compatible formatting of doubles} precision \
  2658   2660       {expr 1e-157} \
  2659   2661       9.9999999999999994e-158
  2660         -test util-16.1.17.-156 {8.4 compatible formatting of doubles} \
         2662  +test util-16.1.17.-156 {8.4 compatible formatting of doubles} precision \
  2661   2663       {expr 1e-156} \
  2662   2664       1e-156
  2663         -test util-16.1.17.-155 {8.4 compatible formatting of doubles} \
         2665  +test util-16.1.17.-155 {8.4 compatible formatting of doubles} precision \
  2664   2666       {expr 1e-155} \
  2665   2667       1e-155
  2666         -test util-16.1.17.-154 {8.4 compatible formatting of doubles} \
         2668  +test util-16.1.17.-154 {8.4 compatible formatting of doubles} precision \
  2667   2669       {expr 1e-154} \
  2668   2670       9.9999999999999997e-155
  2669         -test util-16.1.17.-153 {8.4 compatible formatting of doubles} \
         2671  +test util-16.1.17.-153 {8.4 compatible formatting of doubles} precision \
  2670   2672       {expr 1e-153} \
  2671   2673       1e-153
  2672         -test util-16.1.17.-152 {8.4 compatible formatting of doubles} \
         2674  +test util-16.1.17.-152 {8.4 compatible formatting of doubles} precision \
  2673   2675       {expr 1e-152} \
  2674   2676       1.0000000000000001e-152
  2675         -test util-16.1.17.-151 {8.4 compatible formatting of doubles} \
         2677  +test util-16.1.17.-151 {8.4 compatible formatting of doubles} precision \
  2676   2678       {expr 1e-151} \
  2677   2679       9.9999999999999994e-152
  2678         -test util-16.1.17.-150 {8.4 compatible formatting of doubles} \
         2680  +test util-16.1.17.-150 {8.4 compatible formatting of doubles} precision \
  2679   2681       {expr 1e-150} \
  2680   2682       1e-150
  2681         -test util-16.1.17.-149 {8.4 compatible formatting of doubles} \
         2683  +test util-16.1.17.-149 {8.4 compatible formatting of doubles} precision \
  2682   2684       {expr 1e-149} \
  2683   2685       9.9999999999999998e-150
  2684         -test util-16.1.17.-148 {8.4 compatible formatting of doubles} \
         2686  +test util-16.1.17.-148 {8.4 compatible formatting of doubles} precision \
  2685   2687       {expr 1e-148} \
  2686   2688       9.9999999999999994e-149
  2687         -test util-16.1.17.-147 {8.4 compatible formatting of doubles} \
         2689  +test util-16.1.17.-147 {8.4 compatible formatting of doubles} precision \
  2688   2690       {expr 1e-147} \
  2689   2691       9.9999999999999997e-148
  2690         -test util-16.1.17.-146 {8.4 compatible formatting of doubles} \
         2692  +test util-16.1.17.-146 {8.4 compatible formatting of doubles} precision \
  2691   2693       {expr 1e-146} \
  2692   2694       1e-146
  2693         -test util-16.1.17.-145 {8.4 compatible formatting of doubles} \
         2695  +test util-16.1.17.-145 {8.4 compatible formatting of doubles} precision \
  2694   2696       {expr 1e-145} \
  2695   2697       9.9999999999999991e-146
  2696         -test util-16.1.17.-144 {8.4 compatible formatting of doubles} \
         2698  +test util-16.1.17.-144 {8.4 compatible formatting of doubles} precision \
  2697   2699       {expr 1e-144} \
  2698   2700       9.9999999999999995e-145
  2699         -test util-16.1.17.-143 {8.4 compatible formatting of doubles} \
         2701  +test util-16.1.17.-143 {8.4 compatible formatting of doubles} precision \
  2700   2702       {expr 1e-143} \
  2701   2703       9.9999999999999995e-144
  2702         -test util-16.1.17.-142 {8.4 compatible formatting of doubles} \
         2704  +test util-16.1.17.-142 {8.4 compatible formatting of doubles} precision \
  2703   2705       {expr 1e-142} \
  2704   2706       1e-142
  2705         -test util-16.1.17.-141 {8.4 compatible formatting of doubles} \
         2707  +test util-16.1.17.-141 {8.4 compatible formatting of doubles} precision \
  2706   2708       {expr 1e-141} \
  2707   2709       1e-141
  2708         -test util-16.1.17.-140 {8.4 compatible formatting of doubles} \
         2710  +test util-16.1.17.-140 {8.4 compatible formatting of doubles} precision \
  2709   2711       {expr 1e-140} \
  2710   2712       9.9999999999999998e-141
  2711         -test util-16.1.17.-139 {8.4 compatible formatting of doubles} \
         2713  +test util-16.1.17.-139 {8.4 compatible formatting of doubles} precision \
  2712   2714       {expr 1e-139} \
  2713   2715       1e-139
  2714         -test util-16.1.17.-138 {8.4 compatible formatting of doubles} \
         2716  +test util-16.1.17.-138 {8.4 compatible formatting of doubles} precision \
  2715   2717       {expr 1e-138} \
  2716   2718       1.0000000000000001e-138
  2717         -test util-16.1.17.-137 {8.4 compatible formatting of doubles} \
         2719  +test util-16.1.17.-137 {8.4 compatible formatting of doubles} precision \
  2718   2720       {expr 1e-137} \
  2719   2721       9.9999999999999998e-138
  2720         -test util-16.1.17.-136 {8.4 compatible formatting of doubles} \
         2722  +test util-16.1.17.-136 {8.4 compatible formatting of doubles} precision \
  2721   2723       {expr 1e-136} \
  2722   2724       1e-136
  2723         -test util-16.1.17.-135 {8.4 compatible formatting of doubles} \
         2725  +test util-16.1.17.-135 {8.4 compatible formatting of doubles} precision \
  2724   2726       {expr 1e-135} \
  2725   2727       1e-135
  2726         -test util-16.1.17.-134 {8.4 compatible formatting of doubles} \
         2728  +test util-16.1.17.-134 {8.4 compatible formatting of doubles} precision \
  2727   2729       {expr 1e-134} \
  2728   2730       1e-134
  2729         -test util-16.1.17.-133 {8.4 compatible formatting of doubles} \
         2731  +test util-16.1.17.-133 {8.4 compatible formatting of doubles} precision \
  2730   2732       {expr 1e-133} \
  2731   2733       1.0000000000000001e-133
  2732         -test util-16.1.17.-132 {8.4 compatible formatting of doubles} \
         2734  +test util-16.1.17.-132 {8.4 compatible formatting of doubles} precision \
  2733   2735       {expr 1e-132} \
  2734   2736       9.9999999999999999e-133
  2735         -test util-16.1.17.-131 {8.4 compatible formatting of doubles} \
         2737  +test util-16.1.17.-131 {8.4 compatible formatting of doubles} precision \
  2736   2738       {expr 1e-131} \
  2737   2739       9.9999999999999999e-132
  2738         -test util-16.1.17.-130 {8.4 compatible formatting of doubles} \
         2740  +test util-16.1.17.-130 {8.4 compatible formatting of doubles} precision \
  2739   2741       {expr 1e-130} \
  2740   2742       1.0000000000000001e-130
  2741         -test util-16.1.17.-129 {8.4 compatible formatting of doubles} \
         2743  +test util-16.1.17.-129 {8.4 compatible formatting of doubles} precision \
  2742   2744       {expr 1e-129} \
  2743   2745       9.9999999999999993e-130
  2744         -test util-16.1.17.-128 {8.4 compatible formatting of doubles} \
         2746  +test util-16.1.17.-128 {8.4 compatible formatting of doubles} precision \
  2745   2747       {expr 1e-128} \
  2746   2748       1.0000000000000001e-128
  2747         -test util-16.1.17.-127 {8.4 compatible formatting of doubles} \
         2749  +test util-16.1.17.-127 {8.4 compatible formatting of doubles} precision \
  2748   2750       {expr 1e-127} \
  2749   2751       1e-127
  2750         -test util-16.1.17.-126 {8.4 compatible formatting of doubles} \
         2752  +test util-16.1.17.-126 {8.4 compatible formatting of doubles} precision \
  2751   2753       {expr 1e-126} \
  2752   2754       9.9999999999999995e-127
  2753         -test util-16.1.17.-125 {8.4 compatible formatting of doubles} \
         2755  +test util-16.1.17.-125 {8.4 compatible formatting of doubles} precision \
  2754   2756       {expr 1e-125} \
  2755   2757       1e-125
  2756         -test util-16.1.17.-124 {8.4 compatible formatting of doubles} \
         2758  +test util-16.1.17.-124 {8.4 compatible formatting of doubles} precision \
  2757   2759       {expr 1e-124} \
  2758   2760       9.9999999999999993e-125
  2759         -test util-16.1.17.-123 {8.4 compatible formatting of doubles} \
         2761  +test util-16.1.17.-123 {8.4 compatible formatting of doubles} precision \
  2760   2762       {expr 1e-123} \
  2761   2763       1.0000000000000001e-123
  2762         -test util-16.1.17.-122 {8.4 compatible formatting of doubles} \
         2764  +test util-16.1.17.-122 {8.4 compatible formatting of doubles} precision \
  2763   2765       {expr 1e-122} \
  2764   2766       1.0000000000000001e-122
  2765         -test util-16.1.17.-121 {8.4 compatible formatting of doubles} \
         2767  +test util-16.1.17.-121 {8.4 compatible formatting of doubles} precision \
  2766   2768       {expr 1e-121} \
  2767   2769       9.9999999999999998e-122
  2768         -test util-16.1.17.-120 {8.4 compatible formatting of doubles} \
         2770  +test util-16.1.17.-120 {8.4 compatible formatting of doubles} precision \
  2769   2771       {expr 1e-120} \
  2770   2772       9.9999999999999998e-121
  2771         -test util-16.1.17.-119 {8.4 compatible formatting of doubles} \
         2773  +test util-16.1.17.-119 {8.4 compatible formatting of doubles} precision \
  2772   2774       {expr 1e-119} \
  2773   2775       1e-119
  2774         -test util-16.1.17.-118 {8.4 compatible formatting of doubles} \
         2776  +test util-16.1.17.-118 {8.4 compatible formatting of doubles} precision \
  2775   2777       {expr 1e-118} \
  2776   2778       9.9999999999999999e-119
  2777         -test util-16.1.17.-117 {8.4 compatible formatting of doubles} \
         2779  +test util-16.1.17.-117 {8.4 compatible formatting of doubles} precision \
  2778   2780       {expr 1e-117} \
  2779   2781       1e-117
  2780         -test util-16.1.17.-116 {8.4 compatible formatting of doubles} \
         2782  +test util-16.1.17.-116 {8.4 compatible formatting of doubles} precision \
  2781   2783       {expr 1e-116} \
  2782   2784       9.9999999999999999e-117
  2783         -test util-16.1.17.-115 {8.4 compatible formatting of doubles} \
         2785  +test util-16.1.17.-115 {8.4 compatible formatting of doubles} precision \
  2784   2786       {expr 1e-115} \
  2785   2787       1.0000000000000001e-115
  2786         -test util-16.1.17.-114 {8.4 compatible formatting of doubles} \
         2788  +test util-16.1.17.-114 {8.4 compatible formatting of doubles} precision \
  2787   2789       {expr 1e-114} \
  2788   2790       1.0000000000000001e-114
  2789         -test util-16.1.17.-113 {8.4 compatible formatting of doubles} \
         2791  +test util-16.1.17.-113 {8.4 compatible formatting of doubles} precision \
  2790   2792       {expr 1e-113} \
  2791   2793       9.9999999999999998e-114
  2792         -test util-16.1.17.-112 {8.4 compatible formatting of doubles} \
         2794  +test util-16.1.17.-112 {8.4 compatible formatting of doubles} precision \
  2793   2795       {expr 1e-112} \
  2794   2796       9.9999999999999995e-113
  2795         -test util-16.1.17.-111 {8.4 compatible formatting of doubles} \
         2797  +test util-16.1.17.-111 {8.4 compatible formatting of doubles} precision \
  2796   2798       {expr 1e-111} \
  2797   2799       1.0000000000000001e-111
  2798         -test util-16.1.17.-110 {8.4 compatible formatting of doubles} \
         2800  +test util-16.1.17.-110 {8.4 compatible formatting of doubles} precision \
  2799   2801       {expr 1e-110} \
  2800   2802       1.0000000000000001e-110
  2801         -test util-16.1.17.-109 {8.4 compatible formatting of doubles} \
         2803  +test util-16.1.17.-109 {8.4 compatible formatting of doubles} precision \
  2802   2804       {expr 1e-109} \
  2803   2805       9.9999999999999999e-110
  2804         -test util-16.1.17.-108 {8.4 compatible formatting of doubles} \
         2806  +test util-16.1.17.-108 {8.4 compatible formatting of doubles} precision \
  2805   2807       {expr 1e-108} \
  2806   2808       1e-108
  2807         -test util-16.1.17.-107 {8.4 compatible formatting of doubles} \
         2809  +test util-16.1.17.-107 {8.4 compatible formatting of doubles} precision \
  2808   2810       {expr 1e-107} \
  2809   2811       1e-107
  2810         -test util-16.1.17.-106 {8.4 compatible formatting of doubles} \
         2812  +test util-16.1.17.-106 {8.4 compatible formatting of doubles} precision \
  2811   2813       {expr 1e-106} \
  2812   2814       9.9999999999999994e-107
  2813         -test util-16.1.17.-105 {8.4 compatible formatting of doubles} \
         2815  +test util-16.1.17.-105 {8.4 compatible formatting of doubles} precision \
  2814   2816       {expr 1e-105} \
  2815   2817       9.9999999999999997e-106
  2816         -test util-16.1.17.-104 {8.4 compatible formatting of doubles} \
         2818  +test util-16.1.17.-104 {8.4 compatible formatting of doubles} precision \
  2817   2819       {expr 1e-104} \
  2818   2820       9.9999999999999993e-105
  2819         -test util-16.1.17.-103 {8.4 compatible formatting of doubles} \
         2821  +test util-16.1.17.-103 {8.4 compatible formatting of doubles} precision \
  2820   2822       {expr 1e-103} \
  2821   2823       9.9999999999999996e-104
  2822         -test util-16.1.17.-102 {8.4 compatible formatting of doubles} \
         2824  +test util-16.1.17.-102 {8.4 compatible formatting of doubles} precision \
  2823   2825       {expr 1e-102} \
  2824   2826       9.9999999999999993e-103
  2825         -test util-16.1.17.-101 {8.4 compatible formatting of doubles} \
         2827  +test util-16.1.17.-101 {8.4 compatible formatting of doubles} precision \
  2826   2828       {expr 1e-101} \
  2827   2829       1.0000000000000001e-101
  2828         -test util-16.1.17.-100 {8.4 compatible formatting of doubles} \
         2830  +test util-16.1.17.-100 {8.4 compatible formatting of doubles} precision \
  2829   2831       {expr 1e-100} \
  2830   2832       1e-100
  2831         -test util-16.1.17.-99 {8.4 compatible formatting of doubles} \
         2833  +test util-16.1.17.-99 {8.4 compatible formatting of doubles} precision \
  2832   2834       {expr 1e-99} \
  2833   2835       1e-99
  2834         -test util-16.1.17.-98 {8.4 compatible formatting of doubles} \
         2836  +test util-16.1.17.-98 {8.4 compatible formatting of doubles} precision \
  2835   2837       {expr 1e-98} \
  2836   2838       9.9999999999999994e-99
  2837         -test util-16.1.17.-97 {8.4 compatible formatting of doubles} \
         2839  +test util-16.1.17.-97 {8.4 compatible formatting of doubles} precision \
  2838   2840       {expr 1e-97} \
  2839   2841       1e-97
  2840         -test util-16.1.17.-96 {8.4 compatible formatting of doubles} \
         2842  +test util-16.1.17.-96 {8.4 compatible formatting of doubles} precision \
  2841   2843       {expr 1e-96} \
  2842   2844       9.9999999999999991e-97
  2843         -test util-16.1.17.-95 {8.4 compatible formatting of doubles} \
         2845  +test util-16.1.17.-95 {8.4 compatible formatting of doubles} precision \
  2844   2846       {expr 1e-95} \
  2845   2847       9.9999999999999999e-96
  2846         -test util-16.1.17.-94 {8.4 compatible formatting of doubles} \
         2848  +test util-16.1.17.-94 {8.4 compatible formatting of doubles} precision \
  2847   2849       {expr 1e-94} \
  2848   2850       9.9999999999999996e-95
  2849         -test util-16.1.17.-93 {8.4 compatible formatting of doubles} \
         2851  +test util-16.1.17.-93 {8.4 compatible formatting of doubles} precision \
  2850   2852       {expr 1e-93} \
  2851   2853       9.999999999999999e-94
  2852         -test util-16.1.17.-92 {8.4 compatible formatting of doubles} \
         2854  +test util-16.1.17.-92 {8.4 compatible formatting of doubles} precision \
  2853   2855       {expr 1e-92} \
  2854   2856       9.9999999999999999e-93
  2855         -test util-16.1.17.-91 {8.4 compatible formatting of doubles} \
         2857  +test util-16.1.17.-91 {8.4 compatible formatting of doubles} precision \
  2856   2858       {expr 1e-91} \
  2857   2859       1e-91
  2858         -test util-16.1.17.-90 {8.4 compatible formatting of doubles} \
         2860  +test util-16.1.17.-90 {8.4 compatible formatting of doubles} precision \
  2859   2861       {expr 1e-90} \
  2860   2862       9.9999999999999999e-91
  2861         -test util-16.1.17.-89 {8.4 compatible formatting of doubles} \
         2863  +test util-16.1.17.-89 {8.4 compatible formatting of doubles} precision \
  2862   2864       {expr 1e-89} \
  2863   2865       1e-89
  2864         -test util-16.1.17.-88 {8.4 compatible formatting of doubles} \
         2866  +test util-16.1.17.-88 {8.4 compatible formatting of doubles} precision \
  2865   2867       {expr 1e-88} \
  2866   2868       9.9999999999999993e-89
  2867         -test util-16.1.17.-87 {8.4 compatible formatting of doubles} \
         2869  +test util-16.1.17.-87 {8.4 compatible formatting of doubles} precision \
  2868   2870       {expr 1e-87} \
  2869   2871       1e-87
  2870         -test util-16.1.17.-86 {8.4 compatible formatting of doubles} \
         2872  +test util-16.1.17.-86 {8.4 compatible formatting of doubles} precision \
  2871   2873       {expr 1e-86} \
  2872   2874       1.0000000000000001e-86
  2873         -test util-16.1.17.-85 {8.4 compatible formatting of doubles} \
         2875  +test util-16.1.17.-85 {8.4 compatible formatting of doubles} precision \
  2874   2876       {expr 1e-85} \
  2875   2877       9.9999999999999998e-86
  2876         -test util-16.1.17.-84 {8.4 compatible formatting of doubles} \
         2878  +test util-16.1.17.-84 {8.4 compatible formatting of doubles} precision \
  2877   2879       {expr 1e-84} \
  2878   2880       1e-84
  2879         -test util-16.1.17.-83 {8.4 compatible formatting of doubles} \
         2881  +test util-16.1.17.-83 {8.4 compatible formatting of doubles} precision \
  2880   2882       {expr 1e-83} \
  2881   2883       1e-83
  2882         -test util-16.1.17.-82 {8.4 compatible formatting of doubles} \
         2884  +test util-16.1.17.-82 {8.4 compatible formatting of doubles} precision \
  2883   2885       {expr 1e-82} \
  2884   2886       9.9999999999999996e-83
  2885         -test util-16.1.17.-81 {8.4 compatible formatting of doubles} \
         2887  +test util-16.1.17.-81 {8.4 compatible formatting of doubles} precision \
  2886   2888       {expr 1e-81} \
  2887   2889       9.9999999999999996e-82
  2888         -test util-16.1.17.-80 {8.4 compatible formatting of doubles} \
         2890  +test util-16.1.17.-80 {8.4 compatible formatting of doubles} precision \
  2889   2891       {expr 1e-80} \
  2890   2892       9.9999999999999996e-81
  2891         -test util-16.1.17.-79 {8.4 compatible formatting of doubles} \
         2893  +test util-16.1.17.-79 {8.4 compatible formatting of doubles} precision \
  2892   2894       {expr 1e-79} \
  2893   2895       1e-79
  2894         -test util-16.1.17.-78 {8.4 compatible formatting of doubles} \
         2896  +test util-16.1.17.-78 {8.4 compatible formatting of doubles} precision \
  2895   2897       {expr 1e-78} \
  2896   2898       1e-78
  2897         -test util-16.1.17.-77 {8.4 compatible formatting of doubles} \
         2899  +test util-16.1.17.-77 {8.4 compatible formatting of doubles} precision \
  2898   2900       {expr 1e-77} \
  2899   2901       9.9999999999999993e-78
  2900         -test util-16.1.17.-76 {8.4 compatible formatting of doubles} \
         2902  +test util-16.1.17.-76 {8.4 compatible formatting of doubles} precision \
  2901   2903       {expr 1e-76} \
  2902   2904       9.9999999999999993e-77
  2903         -test util-16.1.17.-75 {8.4 compatible formatting of doubles} \
         2905  +test util-16.1.17.-75 {8.4 compatible formatting of doubles} precision \
  2904   2906       {expr 1e-75} \
  2905   2907       9.9999999999999996e-76
  2906         -test util-16.1.17.-74 {8.4 compatible formatting of doubles} \
         2908  +test util-16.1.17.-74 {8.4 compatible formatting of doubles} precision \
  2907   2909       {expr 1e-74} \
  2908   2910       9.9999999999999996e-75
  2909         -test util-16.1.17.-73 {8.4 compatible formatting of doubles} \
         2911  +test util-16.1.17.-73 {8.4 compatible formatting of doubles} precision \
  2910   2912       {expr 1e-73} \
  2911   2913       1e-73
  2912         -test util-16.1.17.-72 {8.4 compatible formatting of doubles} \
         2914  +test util-16.1.17.-72 {8.4 compatible formatting of doubles} precision \
  2913   2915       {expr 1e-72} \
  2914   2916       9.9999999999999997e-73
  2915         -test util-16.1.17.-71 {8.4 compatible formatting of doubles} \
         2917  +test util-16.1.17.-71 {8.4 compatible formatting of doubles} precision \
  2916   2918       {expr 1e-71} \
  2917   2919       9.9999999999999992e-72
  2918         -test util-16.1.17.-70 {8.4 compatible formatting of doubles} \
         2920  +test util-16.1.17.-70 {8.4 compatible formatting of doubles} precision \
  2919   2921       {expr 1e-70} \
  2920   2922       1e-70
  2921         -test util-16.1.17.-69 {8.4 compatible formatting of doubles} \
         2923  +test util-16.1.17.-69 {8.4 compatible formatting of doubles} precision \
  2922   2924       {expr 1e-69} \
  2923   2925       9.9999999999999996e-70
  2924         -test util-16.1.17.-68 {8.4 compatible formatting of doubles} \
         2926  +test util-16.1.17.-68 {8.4 compatible formatting of doubles} precision \
  2925   2927       {expr 1e-68} \
  2926   2928       1.0000000000000001e-68
  2927         -test util-16.1.17.-67 {8.4 compatible formatting of doubles} \
         2929  +test util-16.1.17.-67 {8.4 compatible formatting of doubles} precision \
  2928   2930       {expr 1e-67} \
  2929   2931       9.9999999999999994e-68
  2930         -test util-16.1.17.-66 {8.4 compatible formatting of doubles} \
         2932  +test util-16.1.17.-66 {8.4 compatible formatting of doubles} precision \
  2931   2933       {expr 1e-66} \
  2932   2934       9.9999999999999998e-67
  2933         -test util-16.1.17.-65 {8.4 compatible formatting of doubles} \
         2935  +test util-16.1.17.-65 {8.4 compatible formatting of doubles} precision \
  2934   2936       {expr 1e-65} \
  2935   2937       9.9999999999999992e-66
  2936         -test util-16.1.17.-64 {8.4 compatible formatting of doubles} \
         2938  +test util-16.1.17.-64 {8.4 compatible formatting of doubles} precision \
  2937   2939       {expr 1e-64} \
  2938   2940       9.9999999999999997e-65
  2939         -test util-16.1.17.-63 {8.4 compatible formatting of doubles} \
         2941  +test util-16.1.17.-63 {8.4 compatible formatting of doubles} precision \
  2940   2942       {expr 1e-63} \
  2941   2943       1.0000000000000001e-63
  2942         -test util-16.1.17.-62 {8.4 compatible formatting of doubles} \
         2944  +test util-16.1.17.-62 {8.4 compatible formatting of doubles} precision \
  2943   2945       {expr 1e-62} \
  2944   2946       1e-62
  2945         -test util-16.1.17.-61 {8.4 compatible formatting of doubles} \
         2947  +test util-16.1.17.-61 {8.4 compatible formatting of doubles} precision \
  2946   2948       {expr 1e-61} \
  2947   2949       1e-61
  2948         -test util-16.1.17.-60 {8.4 compatible formatting of doubles} \
         2950  +test util-16.1.17.-60 {8.4 compatible formatting of doubles} precision \
  2949   2951       {expr 1e-60} \
  2950   2952       9.9999999999999997e-61
  2951         -test util-16.1.17.-59 {8.4 compatible formatting of doubles} \
         2953  +test util-16.1.17.-59 {8.4 compatible formatting of doubles} precision \
  2952   2954       {expr 1e-59} \
  2953   2955       1e-59
  2954         -test util-16.1.17.-58 {8.4 compatible formatting of doubles} \
         2956  +test util-16.1.17.-58 {8.4 compatible formatting of doubles} precision \
  2955   2957       {expr 1e-58} \
  2956   2958       1e-58
  2957         -test util-16.1.17.-57 {8.4 compatible formatting of doubles} \
         2959  +test util-16.1.17.-57 {8.4 compatible formatting of doubles} precision \
  2958   2960       {expr 1e-57} \
  2959   2961       9.9999999999999995e-58
  2960         -test util-16.1.17.-56 {8.4 compatible formatting of doubles} \
         2962  +test util-16.1.17.-56 {8.4 compatible formatting of doubles} precision \
  2961   2963       {expr 1e-56} \
  2962   2964       1e-56
  2963         -test util-16.1.17.-55 {8.4 compatible formatting of doubles} \
         2965  +test util-16.1.17.-55 {8.4 compatible formatting of doubles} precision \
  2964   2966       {expr 1e-55} \
  2965   2967       9.9999999999999999e-56
  2966         -test util-16.1.17.-54 {8.4 compatible formatting of doubles} \
         2968  +test util-16.1.17.-54 {8.4 compatible formatting of doubles} precision \
  2967   2969       {expr 1e-54} \
  2968   2970       1e-54
  2969         -test util-16.1.17.-53 {8.4 compatible formatting of doubles} \
         2971  +test util-16.1.17.-53 {8.4 compatible formatting of doubles} precision \
  2970   2972       {expr 1e-53} \
  2971   2973       1e-53
  2972         -test util-16.1.17.-52 {8.4 compatible formatting of doubles} \
         2974  +test util-16.1.17.-52 {8.4 compatible formatting of doubles} precision \
  2973   2975       {expr 1e-52} \
  2974   2976       1e-52
  2975         -test util-16.1.17.-51 {8.4 compatible formatting of doubles} \
         2977  +test util-16.1.17.-51 {8.4 compatible formatting of doubles} precision \
  2976   2978       {expr 1e-51} \
  2977   2979       1e-51
  2978         -test util-16.1.17.-50 {8.4 compatible formatting of doubles} \
         2980  +test util-16.1.17.-50 {8.4 compatible formatting of doubles} precision \
  2979   2981       {expr 1e-50} \
  2980   2982       1e-50
  2981         -test util-16.1.17.-49 {8.4 compatible formatting of doubles} \
         2983  +test util-16.1.17.-49 {8.4 compatible formatting of doubles} precision \
  2982   2984       {expr 1e-49} \
  2983   2985       9.9999999999999994e-50
  2984         -test util-16.1.17.-48 {8.4 compatible formatting of doubles} \
         2986  +test util-16.1.17.-48 {8.4 compatible formatting of doubles} precision \
  2985   2987       {expr 1e-48} \
  2986   2988       9.9999999999999997e-49
  2987         -test util-16.1.17.-47 {8.4 compatible formatting of doubles} \
         2989  +test util-16.1.17.-47 {8.4 compatible formatting of doubles} precision \
  2988   2990       {expr 1e-47} \
  2989   2991       9.9999999999999997e-48
  2990         -test util-16.1.17.-46 {8.4 compatible formatting of doubles} \
         2992  +test util-16.1.17.-46 {8.4 compatible formatting of doubles} precision \
  2991   2993       {expr 1e-46} \
  2992   2994       1e-46
  2993         -test util-16.1.17.-45 {8.4 compatible formatting of doubles} \
         2995  +test util-16.1.17.-45 {8.4 compatible formatting of doubles} precision \
  2994   2996       {expr 1e-45} \
  2995   2997       9.9999999999999998e-46
  2996         -test util-16.1.17.-44 {8.4 compatible formatting of doubles} \
         2998  +test util-16.1.17.-44 {8.4 compatible formatting of doubles} precision \
  2997   2999       {expr 1e-44} \
  2998   3000       9.9999999999999995e-45
  2999         -test util-16.1.17.-43 {8.4 compatible formatting of doubles} \
         3001  +test util-16.1.17.-43 {8.4 compatible formatting of doubles} precision \
  3000   3002       {expr 1e-43} \
  3001   3003       1.0000000000000001e-43
  3002         -test util-16.1.17.-42 {8.4 compatible formatting of doubles} \
         3004  +test util-16.1.17.-42 {8.4 compatible formatting of doubles} precision \
  3003   3005       {expr 1e-42} \
  3004   3006       1e-42
  3005         -test util-16.1.17.-41 {8.4 compatible formatting of doubles} \
         3007  +test util-16.1.17.-41 {8.4 compatible formatting of doubles} precision \
  3006   3008       {expr 1e-41} \
  3007   3009       1e-41
  3008         -test util-16.1.17.-40 {8.4 compatible formatting of doubles} \
         3010  +test util-16.1.17.-40 {8.4 compatible formatting of doubles} precision \
  3009   3011       {expr 1e-40} \
  3010   3012       9.9999999999999993e-41
  3011         -test util-16.1.17.-39 {8.4 compatible formatting of doubles} \
         3013  +test util-16.1.17.-39 {8.4 compatible formatting of doubles} precision \
  3012   3014       {expr 1e-39} \
  3013   3015       9.9999999999999993e-40
  3014         -test util-16.1.17.-38 {8.4 compatible formatting of doubles} \
         3016  +test util-16.1.17.-38 {8.4 compatible formatting of doubles} precision \
  3015   3017       {expr 1e-38} \
  3016   3018       9.9999999999999996e-39
  3017         -test util-16.1.17.-37 {8.4 compatible formatting of doubles} \
         3019  +test util-16.1.17.-37 {8.4 compatible formatting of doubles} precision \
  3018   3020       {expr 1e-37} \
  3019   3021       1.0000000000000001e-37
  3020         -test util-16.1.17.-36 {8.4 compatible formatting of doubles} \
         3022  +test util-16.1.17.-36 {8.4 compatible formatting of doubles} precision \
  3021   3023       {expr 1e-36} \
  3022   3024       9.9999999999999994e-37
  3023         -test util-16.1.17.-35 {8.4 compatible formatting of doubles} \
         3025  +test util-16.1.17.-35 {8.4 compatible formatting of doubles} precision \
  3024   3026       {expr 1e-35} \
  3025   3027       1e-35
  3026         -test util-16.1.17.-34 {8.4 compatible formatting of doubles} \
         3028  +test util-16.1.17.-34 {8.4 compatible formatting of doubles} precision \
  3027   3029       {expr 1e-34} \
  3028   3030       9.9999999999999993e-35
  3029         -test util-16.1.17.-33 {8.4 compatible formatting of doubles} \
         3031  +test util-16.1.17.-33 {8.4 compatible formatting of doubles} precision \
  3030   3032       {expr 1e-33} \
  3031   3033       1.0000000000000001e-33
  3032         -test util-16.1.17.-32 {8.4 compatible formatting of doubles} \
         3034  +test util-16.1.17.-32 {8.4 compatible formatting of doubles} precision \
  3033   3035       {expr 1e-32} \
  3034   3036       1.0000000000000001e-32
  3035         -test util-16.1.17.-31 {8.4 compatible formatting of doubles} \
         3037  +test util-16.1.17.-31 {8.4 compatible formatting of doubles} precision \
  3036   3038       {expr 1e-31} \
  3037   3039       1.0000000000000001e-31
  3038         -test util-16.1.17.-30 {8.4 compatible formatting of doubles} \
         3040  +test util-16.1.17.-30 {8.4 compatible formatting of doubles} precision \
  3039   3041       {expr 1e-30} \
  3040   3042       1.0000000000000001e-30
  3041         -test util-16.1.17.-29 {8.4 compatible formatting of doubles} \
         3043  +test util-16.1.17.-29 {8.4 compatible formatting of doubles} precision \
  3042   3044       {expr 1e-29} \
  3043   3045       9.9999999999999994e-30
  3044         -test util-16.1.17.-28 {8.4 compatible formatting of doubles} \
         3046  +test util-16.1.17.-28 {8.4 compatible formatting of doubles} precision \
  3045   3047       {expr 1e-28} \
  3046   3048       9.9999999999999997e-29
  3047         -test util-16.1.17.-27 {8.4 compatible formatting of doubles} \
         3049  +test util-16.1.17.-27 {8.4 compatible formatting of doubles} precision \
  3048   3050       {expr 1e-27} \
  3049   3051       1e-27
  3050         -test util-16.1.17.-26 {8.4 compatible formatting of doubles} \
         3052  +test util-16.1.17.-26 {8.4 compatible formatting of doubles} precision \
  3051   3053       {expr 1e-26} \
  3052   3054       1e-26
  3053         -test util-16.1.17.-25 {8.4 compatible formatting of doubles} \
         3055  +test util-16.1.17.-25 {8.4 compatible formatting of doubles} precision \
  3054   3056       {expr 1e-25} \
  3055   3057       1e-25
  3056         -test util-16.1.17.-24 {8.4 compatible formatting of doubles} \
         3058  +test util-16.1.17.-24 {8.4 compatible formatting of doubles} precision \
  3057   3059       {expr 1e-24} \
  3058   3060       9.9999999999999992e-25
  3059         -test util-16.1.17.-23 {8.4 compatible formatting of doubles} \
         3061  +test util-16.1.17.-23 {8.4 compatible formatting of doubles} precision \
  3060   3062       {expr 1e-23} \
  3061   3063       9.9999999999999996e-24
  3062         -test util-16.1.17.-22 {8.4 compatible formatting of doubles} \
         3064  +test util-16.1.17.-22 {8.4 compatible formatting of doubles} precision \
  3063   3065       {expr 1e-22} \
  3064   3066       1e-22
  3065         -test util-16.1.17.-21 {8.4 compatible formatting of doubles} \
         3067  +test util-16.1.17.-21 {8.4 compatible formatting of doubles} precision \
  3066   3068       {expr 1e-21} \
  3067   3069       9.9999999999999991e-22
  3068         -test util-16.1.17.-20 {8.4 compatible formatting of doubles} \
         3070  +test util-16.1.17.-20 {8.4 compatible formatting of doubles} precision \
  3069   3071       {expr 1e-20} \
  3070   3072       9.9999999999999995e-21
  3071         -test util-16.1.17.-19 {8.4 compatible formatting of doubles} \
         3073  +test util-16.1.17.-19 {8.4 compatible formatting of doubles} precision \
  3072   3074       {expr 1e-19} \
  3073   3075       9.9999999999999998e-20
  3074         -test util-16.1.17.-18 {8.4 compatible formatting of doubles} \
         3076  +test util-16.1.17.-18 {8.4 compatible formatting of doubles} precision \
  3075   3077       {expr 1e-18} \
  3076   3078       1.0000000000000001e-18
  3077         -test util-16.1.17.-17 {8.4 compatible formatting of doubles} \
         3079  +test util-16.1.17.-17 {8.4 compatible formatting of doubles} precision \
  3078   3080       {expr 1e-17} \
  3079   3081       1.0000000000000001e-17
  3080         -test util-16.1.17.-16 {8.4 compatible formatting of doubles} \
         3082  +test util-16.1.17.-16 {8.4 compatible formatting of doubles} precision \
  3081   3083       {expr 1e-16} \
  3082   3084       9.9999999999999998e-17
  3083         -test util-16.1.17.-15 {8.4 compatible formatting of doubles} \
         3085  +test util-16.1.17.-15 {8.4 compatible formatting of doubles} precision \
  3084   3086       {expr 1e-15} \
  3085   3087       1.0000000000000001e-15
  3086         -test util-16.1.17.-14 {8.4 compatible formatting of doubles} \
         3088  +test util-16.1.17.-14 {8.4 compatible formatting of doubles} precision \
  3087   3089       {expr 1e-14} \
  3088   3090       1e-14
  3089         -test util-16.1.17.-13 {8.4 compatible formatting of doubles} \
         3091  +test util-16.1.17.-13 {8.4 compatible formatting of doubles} precision \
  3090   3092       {expr 1e-13} \
  3091   3093       1e-13
  3092         -test util-16.1.17.-12 {8.4 compatible formatting of doubles} \
         3094  +test util-16.1.17.-12 {8.4 compatible formatting of doubles} precision \
  3093   3095       {expr 1e-12} \
  3094   3096       9.9999999999999998e-13
  3095         -test util-16.1.17.-11 {8.4 compatible formatting of doubles} \
         3097  +test util-16.1.17.-11 {8.4 compatible formatting of doubles} precision \
  3096   3098       {expr 1e-11} \
  3097   3099       9.9999999999999994e-12
  3098         -test util-16.1.17.-10 {8.4 compatible formatting of doubles} \
         3100  +test util-16.1.17.-10 {8.4 compatible formatting of doubles} precision \
  3099   3101       {expr 1e-10} \
  3100   3102       1e-10
  3101         -test util-16.1.17.-9 {8.4 compatible formatting of doubles} \
         3103  +test util-16.1.17.-9 {8.4 compatible formatting of doubles} precision \
  3102   3104       {expr 1e-9} \
  3103   3105       1.0000000000000001e-09
  3104         -test util-16.1.17.-8 {8.4 compatible formatting of doubles} \
         3106  +test util-16.1.17.-8 {8.4 compatible formatting of doubles} precision \
  3105   3107       {expr 1e-8} \
  3106   3108       1e-08
  3107         -test util-16.1.17.-7 {8.4 compatible formatting of doubles} \
         3109  +test util-16.1.17.-7 {8.4 compatible formatting of doubles} precision \
  3108   3110       {expr 1e-7} \
  3109   3111       9.9999999999999995e-08
  3110         -test util-16.1.17.-6 {8.4 compatible formatting of doubles} \
         3112  +test util-16.1.17.-6 {8.4 compatible formatting of doubles} precision \
  3111   3113       {expr 1e-6} \
  3112   3114       9.9999999999999995e-07
  3113         -test util-16.1.17.-5 {8.4 compatible formatting of doubles} \
         3115  +test util-16.1.17.-5 {8.4 compatible formatting of doubles} precision \
  3114   3116       {expr 1e-5} \
  3115   3117       1.0000000000000001e-05
  3116         -test util-16.1.17.-4 {8.4 compatible formatting of doubles} \
         3118  +test util-16.1.17.-4 {8.4 compatible formatting of doubles} precision \
  3117   3119       {expr 1e-4} \
  3118   3120       0.0001
  3119         -test util-16.1.17.-3 {8.4 compatible formatting of doubles} \
         3121  +test util-16.1.17.-3 {8.4 compatible formatting of doubles} precision \
  3120   3122       {expr 1e-3} \
  3121   3123       0.001
  3122         -test util-16.1.17.-2 {8.4 compatible formatting of doubles} \
         3124  +test util-16.1.17.-2 {8.4 compatible formatting of doubles} precision \
  3123   3125       {expr 1e-2} \
  3124   3126       0.01
  3125         -test util-16.1.17.-1 {8.4 compatible formatting of doubles} \
         3127  +test util-16.1.17.-1 {8.4 compatible formatting of doubles} precision \
  3126   3128       {expr 1e-1} \
  3127   3129       0.10000000000000001
  3128         -test util-16.1.17.0 {8.4 compatible formatting of doubles} \
         3130  +test util-16.1.17.0 {8.4 compatible formatting of doubles} precision \
  3129   3131       {expr 1e0} \
  3130   3132       1.0
  3131         -test util-16.1.17.1 {8.4 compatible formatting of doubles} \
         3133  +test util-16.1.17.1 {8.4 compatible formatting of doubles} precision \
  3132   3134       {expr 1e1} \
  3133   3135       10.0
  3134         -test util-16.1.17.2 {8.4 compatible formatting of doubles} \
         3136  +test util-16.1.17.2 {8.4 compatible formatting of doubles} precision \
  3135   3137       {expr 1e2} \
  3136   3138       100.0
  3137         -test util-16.1.17.3 {8.4 compatible formatting of doubles} \
         3139  +test util-16.1.17.3 {8.4 compatible formatting of doubles} precision \
  3138   3140       {expr 1e3} \
  3139   3141       1000.0
  3140         -test util-16.1.17.4 {8.4 compatible formatting of doubles} \
         3142  +test util-16.1.17.4 {8.4 compatible formatting of doubles} precision \
  3141   3143       {expr 1e4} \
  3142   3144       10000.0
  3143         -test util-16.1.17.5 {8.4 compatible formatting of doubles} \
         3145  +test util-16.1.17.5 {8.4 compatible formatting of doubles} precision \
  3144   3146       {expr 1e5} \
  3145   3147       100000.0
  3146         -test util-16.1.17.6 {8.4 compatible formatting of doubles} \
         3148  +test util-16.1.17.6 {8.4 compatible formatting of doubles} precision \
  3147   3149       {expr 1e6} \
  3148   3150       1000000.0
  3149         -test util-16.1.17.7 {8.4 compatible formatting of doubles} \
         3151  +test util-16.1.17.7 {8.4 compatible formatting of doubles} precision \
  3150   3152       {expr 1e7} \
  3151   3153       10000000.0
  3152         -test util-16.1.17.8 {8.4 compatible formatting of doubles} \
         3154  +test util-16.1.17.8 {8.4 compatible formatting of doubles} precision \
  3153   3155       {expr 1e8} \
  3154   3156       100000000.0
  3155         -test util-16.1.17.9 {8.4 compatible formatting of doubles} \
         3157  +test util-16.1.17.9 {8.4 compatible formatting of doubles} precision \
  3156   3158       {expr 1e9} \
  3157   3159       1000000000.0
  3158         -test util-16.1.17.10 {8.4 compatible formatting of doubles} \
         3160  +test util-16.1.17.10 {8.4 compatible formatting of doubles} precision \
  3159   3161       {expr 1e10} \
  3160   3162       10000000000.0
  3161         -test util-16.1.17.11 {8.4 compatible formatting of doubles} \
         3163  +test util-16.1.17.11 {8.4 compatible formatting of doubles} precision \
  3162   3164       {expr 1e11} \
  3163   3165       100000000000.0
  3164         -test util-16.1.17.12 {8.4 compatible formatting of doubles} \
         3166  +test util-16.1.17.12 {8.4 compatible formatting of doubles} precision \
  3165   3167       {expr 1e12} \
  3166   3168       1000000000000.0
  3167         -test util-16.1.17.13 {8.4 compatible formatting of doubles} \
         3169  +test util-16.1.17.13 {8.4 compatible formatting of doubles} precision \
  3168   3170       {expr 1e13} \
  3169   3171       10000000000000.0
  3170         -test util-16.1.17.14 {8.4 compatible formatting of doubles} \
         3172  +test util-16.1.17.14 {8.4 compatible formatting of doubles} precision \
  3171   3173       {expr 1e14} \
  3172   3174       100000000000000.0
  3173         -test util-16.1.17.15 {8.4 compatible formatting of doubles} \
         3175  +test util-16.1.17.15 {8.4 compatible formatting of doubles} precision \
  3174   3176       {expr 1e15} \
  3175   3177       1000000000000000.0
  3176         -test util-16.1.17.16 {8.4 compatible formatting of doubles} \
         3178  +test util-16.1.17.16 {8.4 compatible formatting of doubles} precision \
  3177   3179       {expr 1e16} \
  3178   3180       10000000000000000.0
  3179         -test util-16.1.17.17 {8.4 compatible formatting of doubles} \
         3181  +test util-16.1.17.17 {8.4 compatible formatting of doubles} precision \
  3180   3182       {expr 1e17} \
  3181   3183       1e+17
  3182         -test util-16.1.17.18 {8.4 compatible formatting of doubles} \
         3184  +test util-16.1.17.18 {8.4 compatible formatting of doubles} precision \
  3183   3185       {expr 1e18} \
  3184   3186       1e+18
  3185         -test util-16.1.17.19 {8.4 compatible formatting of doubles} \
         3187  +test util-16.1.17.19 {8.4 compatible formatting of doubles} precision \
  3186   3188       {expr 1e19} \
  3187   3189       1e+19
  3188         -test util-16.1.17.20 {8.4 compatible formatting of doubles} \
         3190  +test util-16.1.17.20 {8.4 compatible formatting of doubles} precision \
  3189   3191       {expr 1e20} \
  3190   3192       1e+20
  3191         -test util-16.1.17.21 {8.4 compatible formatting of doubles} \
         3193  +test util-16.1.17.21 {8.4 compatible formatting of doubles} precision \
  3192   3194       {expr 1e21} \
  3193   3195       1e+21
  3194         -test util-16.1.17.22 {8.4 compatible formatting of doubles} \
         3196  +test util-16.1.17.22 {8.4 compatible formatting of doubles} precision \
  3195   3197       {expr 1e22} \
  3196   3198       1e+22
  3197         -test util-16.1.17.23 {8.4 compatible formatting of doubles} \
         3199  +test util-16.1.17.23 {8.4 compatible formatting of doubles} precision \
  3198   3200       {expr 1e23} \
  3199   3201       9.9999999999999992e+22
  3200         -test util-16.1.17.24 {8.4 compatible formatting of doubles} \
         3202  +test util-16.1.17.24 {8.4 compatible formatting of doubles} precision \
  3201   3203       {expr 1e24} \
  3202   3204       9.9999999999999998e+23
  3203         -test util-16.1.17.25 {8.4 compatible formatting of doubles} \
         3205  +test util-16.1.17.25 {8.4 compatible formatting of doubles} precision \
  3204   3206       {expr 1e25} \
  3205   3207       1.0000000000000001e+25
  3206         -test util-16.1.17.26 {8.4 compatible formatting of doubles} \
         3208  +test util-16.1.17.26 {8.4 compatible formatting of doubles} precision \
  3207   3209       {expr 1e26} \
  3208   3210       1e+26
  3209         -test util-16.1.17.27 {8.4 compatible formatting of doubles} \
         3211  +test util-16.1.17.27 {8.4 compatible formatting of doubles} precision \
  3210   3212       {expr 1e27} \
  3211   3213       1e+27
  3212         -test util-16.1.17.28 {8.4 compatible formatting of doubles} \
         3214  +test util-16.1.17.28 {8.4 compatible formatting of doubles} precision \
  3213   3215       {expr 1e28} \
  3214   3216       9.9999999999999996e+27
  3215         -test util-16.1.17.29 {8.4 compatible formatting of doubles} \
         3217  +test util-16.1.17.29 {8.4 compatible formatting of doubles} precision \
  3216   3218       {expr 1e29} \
  3217   3219       9.9999999999999991e+28
  3218         -test util-16.1.17.30 {8.4 compatible formatting of doubles} \
         3220  +test util-16.1.17.30 {8.4 compatible formatting of doubles} precision \
  3219   3221       {expr 1e30} \
  3220   3222       1e+30
  3221         -test util-16.1.17.31 {8.4 compatible formatting of doubles} \
         3223  +test util-16.1.17.31 {8.4 compatible formatting of doubles} precision \
  3222   3224       {expr 1e31} \
  3223   3225       9.9999999999999996e+30
  3224         -test util-16.1.17.32 {8.4 compatible formatting of doubles} \
         3226  +test util-16.1.17.32 {8.4 compatible formatting of doubles} precision \
  3225   3227       {expr 1e32} \
  3226   3228       1.0000000000000001e+32
  3227         -test util-16.1.17.33 {8.4 compatible formatting of doubles} \
         3229  +test util-16.1.17.33 {8.4 compatible formatting of doubles} precision \
  3228   3230       {expr 1e33} \
  3229   3231       9.9999999999999995e+32
  3230         -test util-16.1.17.34 {8.4 compatible formatting of doubles} \
         3232  +test util-16.1.17.34 {8.4 compatible formatting of doubles} precision \
  3231   3233       {expr 1e34} \
  3232   3234       9.9999999999999995e+33
  3233         -test util-16.1.17.35 {8.4 compatible formatting of doubles} \
         3235  +test util-16.1.17.35 {8.4 compatible formatting of doubles} precision \
  3234   3236       {expr 1e35} \
  3235   3237       9.9999999999999997e+34
  3236         -test util-16.1.17.36 {8.4 compatible formatting of doubles} \
         3238  +test util-16.1.17.36 {8.4 compatible formatting of doubles} precision \
  3237   3239       {expr 1e36} \
  3238   3240       1e+36
  3239         -test util-16.1.17.37 {8.4 compatible formatting of doubles} \
         3241  +test util-16.1.17.37 {8.4 compatible formatting of doubles} precision \
  3240   3242       {expr 1e37} \
  3241   3243       9.9999999999999995e+36
  3242         -test util-16.1.17.38 {8.4 compatible formatting of doubles} \
         3244  +test util-16.1.17.38 {8.4 compatible formatting of doubles} precision \
  3243   3245       {expr 1e38} \
  3244   3246       9.9999999999999998e+37
  3245         -test util-16.1.17.39 {8.4 compatible formatting of doubles} \
         3247  +test util-16.1.17.39 {8.4 compatible formatting of doubles} precision \
  3246   3248       {expr 1e39} \
  3247   3249       9.9999999999999994e+38
  3248         -test util-16.1.17.40 {8.4 compatible formatting of doubles} \
         3250  +test util-16.1.17.40 {8.4 compatible formatting of doubles} precision \
  3249   3251       {expr 1e40} \
  3250   3252       1e+40
  3251         -test util-16.1.17.41 {8.4 compatible formatting of doubles} \
         3253  +test util-16.1.17.41 {8.4 compatible formatting of doubles} precision \
  3252   3254       {expr 1e41} \
  3253   3255       1e+41
  3254         -test util-16.1.17.42 {8.4 compatible formatting of doubles} \
         3256  +test util-16.1.17.42 {8.4 compatible formatting of doubles} precision \
  3255   3257       {expr 1e42} \
  3256   3258       1e+42
  3257         -test util-16.1.17.43 {8.4 compatible formatting of doubles} \
         3259  +test util-16.1.17.43 {8.4 compatible formatting of doubles} precision \
  3258   3260       {expr 1e43} \
  3259   3261       1e+43
  3260         -test util-16.1.17.44 {8.4 compatible formatting of doubles} \
         3262  +test util-16.1.17.44 {8.4 compatible formatting of doubles} precision \
  3261   3263       {expr 1e44} \
  3262   3264       1.0000000000000001e+44
  3263         -test util-16.1.17.45 {8.4 compatible formatting of doubles} \
         3265  +test util-16.1.17.45 {8.4 compatible formatting of doubles} precision \
  3264   3266       {expr 1e45} \
  3265   3267       9.9999999999999993e+44
  3266         -test util-16.1.17.46 {8.4 compatible formatting of doubles} \
         3268  +test util-16.1.17.46 {8.4 compatible formatting of doubles} precision \
  3267   3269       {expr 1e46} \
  3268   3270       9.9999999999999999e+45
  3269         -test util-16.1.17.47 {8.4 compatible formatting of doubles} \
         3271  +test util-16.1.17.47 {8.4 compatible formatting of doubles} precision \
  3270   3272       {expr 1e47} \
  3271   3273       1e+47
  3272         -test util-16.1.17.48 {8.4 compatible formatting of doubles} \
         3274  +test util-16.1.17.48 {8.4 compatible formatting of doubles} precision \
  3273   3275       {expr 1e48} \
  3274   3276       1e+48
  3275         -test util-16.1.17.49 {8.4 compatible formatting of doubles} \
         3277  +test util-16.1.17.49 {8.4 compatible formatting of doubles} precision \
  3276   3278       {expr 1e49} \
  3277   3279       9.9999999999999995e+48
  3278         -test util-16.1.17.50 {8.4 compatible formatting of doubles} \
         3280  +test util-16.1.17.50 {8.4 compatible formatting of doubles} precision \
  3279   3281       {expr 1e50} \
  3280   3282       1.0000000000000001e+50
  3281         -test util-16.1.17.51 {8.4 compatible formatting of doubles} \
         3283  +test util-16.1.17.51 {8.4 compatible formatting of doubles} precision \
  3282   3284       {expr 1e51} \
  3283   3285       9.9999999999999999e+50
  3284         -test util-16.1.17.52 {8.4 compatible formatting of doubles} \
         3286  +test util-16.1.17.52 {8.4 compatible formatting of doubles} precision \
  3285   3287       {expr 1e52} \
  3286   3288       9.9999999999999999e+51
  3287         -test util-16.1.17.53 {8.4 compatible formatting of doubles} \
         3289  +test util-16.1.17.53 {8.4 compatible formatting of doubles} precision \
  3288   3290       {expr 1e53} \
  3289   3291       9.9999999999999999e+52
  3290         -test util-16.1.17.54 {8.4 compatible formatting of doubles} \
         3292  +test util-16.1.17.54 {8.4 compatible formatting of doubles} precision \
  3291   3293       {expr 1e54} \
  3292   3294       1.0000000000000001e+54
  3293         -test util-16.1.17.55 {8.4 compatible formatting of doubles} \
         3295  +test util-16.1.17.55 {8.4 compatible formatting of doubles} precision \
  3294   3296       {expr 1e55} \
  3295   3297       1e+55
  3296         -test util-16.1.17.56 {8.4 compatible formatting of doubles} \
         3298  +test util-16.1.17.56 {8.4 compatible formatting of doubles} precision \
  3297   3299       {expr 1e56} \
  3298   3300       1.0000000000000001e+56
  3299         -test util-16.1.17.57 {8.4 compatible formatting of doubles} \
         3301  +test util-16.1.17.57 {8.4 compatible formatting of doubles} precision \
  3300   3302       {expr 1e57} \
  3301   3303       1e+57
  3302         -test util-16.1.17.58 {8.4 compatible formatting of doubles} \
         3304  +test util-16.1.17.58 {8.4 compatible formatting of doubles} precision \
  3303   3305       {expr 1e58} \
  3304   3306       9.9999999999999994e+57
  3305         -test util-16.1.17.59 {8.4 compatible formatting of doubles} \
         3307  +test util-16.1.17.59 {8.4 compatible formatting of doubles} precision \
  3306   3308       {expr 1e59} \
  3307   3309       9.9999999999999997e+58
  3308         -test util-16.1.17.60 {8.4 compatible formatting of doubles} \
         3310  +test util-16.1.17.60 {8.4 compatible formatting of doubles} precision \
  3309   3311       {expr 1e60} \
  3310   3312       9.9999999999999995e+59
  3311         -test util-16.1.17.61 {8.4 compatible formatting of doubles} \
         3313  +test util-16.1.17.61 {8.4 compatible formatting of doubles} precision \
  3312   3314       {expr 1e61} \
  3313   3315       9.9999999999999995e+60
  3314         -test util-16.1.17.62 {8.4 compatible formatting of doubles} \
         3316  +test util-16.1.17.62 {8.4 compatible formatting of doubles} precision \
  3315   3317       {expr 1e62} \
  3316   3318       1e+62
  3317         -test util-16.1.17.63 {8.4 compatible formatting of doubles} \
         3319  +test util-16.1.17.63 {8.4 compatible formatting of doubles} precision \
  3318   3320       {expr 1e63} \
  3319   3321       1.0000000000000001e+63
  3320         -test util-16.1.17.64 {8.4 compatible formatting of doubles} \
         3322  +test util-16.1.17.64 {8.4 compatible formatting of doubles} precision \
  3321   3323       {expr 1e64} \
  3322   3324       1e+64
  3323         -test util-16.1.17.65 {8.4 compatible formatting of doubles} \
         3325  +test util-16.1.17.65 {8.4 compatible formatting of doubles} precision \
  3324   3326       {expr 1e65} \
  3325   3327       9.9999999999999999e+64
  3326         -test util-16.1.17.66 {8.4 compatible formatting of doubles} \
         3328  +test util-16.1.17.66 {8.4 compatible formatting of doubles} precision \
  3327   3329       {expr 1e66} \
  3328   3330       9.9999999999999995e+65
  3329         -test util-16.1.17.67 {8.4 compatible formatting of doubles} \
         3331  +test util-16.1.17.67 {8.4 compatible formatting of doubles} precision \
  3330   3332       {expr 1e67} \
  3331   3333       9.9999999999999998e+66
  3332         -test util-16.1.17.68 {8.4 compatible formatting of doubles} \
         3334  +test util-16.1.17.68 {8.4 compatible formatting of doubles} precision \
  3333   3335       {expr 1e68} \
  3334   3336       9.9999999999999995e+67
  3335         -test util-16.1.17.69 {8.4 compatible formatting of doubles} \
         3337  +test util-16.1.17.69 {8.4 compatible formatting of doubles} precision \
  3336   3338       {expr 1e69} \
  3337   3339       1.0000000000000001e+69
  3338         -test util-16.1.17.70 {8.4 compatible formatting of doubles} \
         3340  +test util-16.1.17.70 {8.4 compatible formatting of doubles} precision \
  3339   3341       {expr 1e70} \
  3340   3342       1.0000000000000001e+70
  3341         -test util-16.1.17.71 {8.4 compatible formatting of doubles} \
         3343  +test util-16.1.17.71 {8.4 compatible formatting of doubles} precision \
  3342   3344       {expr 1e71} \
  3343   3345       1e+71
  3344         -test util-16.1.17.72 {8.4 compatible formatting of doubles} \
         3346  +test util-16.1.17.72 {8.4 compatible formatting of doubles} precision \
  3345   3347       {expr 1e72} \
  3346   3348       9.9999999999999994e+71
  3347         -test util-16.1.17.73 {8.4 compatible formatting of doubles} \
         3349  +test util-16.1.17.73 {8.4 compatible formatting of doubles} precision \
  3348   3350       {expr 1e73} \
  3349   3351       9.9999999999999998e+72
  3350         -test util-16.1.17.74 {8.4 compatible formatting of doubles} \
         3352  +test util-16.1.17.74 {8.4 compatible formatting of doubles} precision \
  3351   3353       {expr 1e74} \
  3352   3354       9.9999999999999995e+73
  3353         -test util-16.1.17.75 {8.4 compatible formatting of doubles} \
         3355  +test util-16.1.17.75 {8.4 compatible formatting of doubles} precision \
  3354   3356       {expr 1e75} \
  3355   3357       9.9999999999999993e+74
  3356         -test util-16.1.17.76 {8.4 compatible formatting of doubles} \
         3358  +test util-16.1.17.76 {8.4 compatible formatting of doubles} precision \
  3357   3359       {expr 1e76} \
  3358   3360       1e+76
  3359         -test util-16.1.17.77 {8.4 compatible formatting of doubles} \
         3361  +test util-16.1.17.77 {8.4 compatible formatting of doubles} precision \
  3360   3362       {expr 1e77} \
  3361   3363       9.9999999999999998e+76
  3362         -test util-16.1.17.78 {8.4 compatible formatting of doubles} \
         3364  +test util-16.1.17.78 {8.4 compatible formatting of doubles} precision \
  3363   3365       {expr 1e78} \
  3364   3366       1e+78
  3365         -test util-16.1.17.79 {8.4 compatible formatting of doubles} \
         3367  +test util-16.1.17.79 {8.4 compatible formatting of doubles} precision \
  3366   3368       {expr 1e79} \
  3367   3369       9.9999999999999997e+78
  3368         -test util-16.1.17.80 {8.4 compatible formatting of doubles} \
         3370  +test util-16.1.17.80 {8.4 compatible formatting of doubles} precision \
  3369   3371       {expr 1e80} \
  3370   3372       1e+80
  3371         -test util-16.1.17.81 {8.4 compatible formatting of doubles} \
         3373  +test util-16.1.17.81 {8.4 compatible formatting of doubles} precision \
  3372   3374       {expr 1e81} \
  3373   3375       9.9999999999999992e+80
  3374         -test util-16.1.17.82 {8.4 compatible formatting of doubles} \
         3376  +test util-16.1.17.82 {8.4 compatible formatting of doubles} precision \
  3375   3377       {expr 1e82} \
  3376   3378       9.9999999999999996e+81
  3377         -test util-16.1.17.83 {8.4 compatible formatting of doubles} \
         3379  +test util-16.1.17.83 {8.4 compatible formatting of doubles} precision \
  3378   3380       {expr 1e83} \
  3379   3381       1e+83
  3380         -test util-16.1.17.84 {8.4 compatible formatting of doubles} \
         3382  +test util-16.1.17.84 {8.4 compatible formatting of doubles} precision \
  3381   3383       {expr 1e84} \
  3382   3384       1.0000000000000001e+84
  3383         -test util-16.1.17.85 {8.4 compatible formatting of doubles} \
         3385  +test util-16.1.17.85 {8.4 compatible formatting of doubles} precision \
  3384   3386       {expr 1e85} \
  3385   3387       1e+85
  3386         -test util-16.1.17.86 {8.4 compatible formatting of doubles} \
         3388  +test util-16.1.17.86 {8.4 compatible formatting of doubles} precision \
  3387   3389       {expr 1e86} \
  3388   3390       1e+86
  3389         -test util-16.1.17.87 {8.4 compatible formatting of doubles} \
         3391  +test util-16.1.17.87 {8.4 compatible formatting of doubles} precision \
  3390   3392       {expr 1e87} \
  3391   3393       9.9999999999999996e+86
  3392         -test util-16.1.17.88 {8.4 compatible formatting of doubles} \
         3394  +test util-16.1.17.88 {8.4 compatible formatting of doubles} precision \
  3393   3395       {expr 1e88} \
  3394   3396       9.9999999999999996e+87
  3395         -test util-16.1.17.89 {8.4 compatible formatting of doubles} \
         3397  +test util-16.1.17.89 {8.4 compatible formatting of doubles} precision \
  3396   3398       {expr 1e89} \
  3397   3399       9.9999999999999999e+88
  3398         -test util-16.1.17.90 {8.4 compatible formatting of doubles} \
         3400  +test util-16.1.17.90 {8.4 compatible formatting of doubles} precision \
  3399   3401       {expr 1e90} \
  3400   3402       9.9999999999999997e+89
  3401         -test util-16.1.17.91 {8.4 compatible formatting of doubles} \
         3403  +test util-16.1.17.91 {8.4 compatible formatting of doubles} precision \
  3402   3404       {expr 1e91} \
  3403   3405       1.0000000000000001e+91
  3404         -test util-16.1.17.92 {8.4 compatible formatting of doubles} \
         3406  +test util-16.1.17.92 {8.4 compatible formatting of doubles} precision \
  3405   3407       {expr 1e92} \
  3406   3408       1e+92
  3407         -test util-16.1.17.93 {8.4 compatible formatting of doubles} \
         3409  +test util-16.1.17.93 {8.4 compatible formatting of doubles} precision \
  3408   3410       {expr 1e93} \
  3409   3411       1e+93
  3410         -test util-16.1.17.94 {8.4 compatible formatting of doubles} \
         3412  +test util-16.1.17.94 {8.4 compatible formatting of doubles} precision \
  3411   3413       {expr 1e94} \
  3412   3414       1e+94
  3413         -test util-16.1.17.95 {8.4 compatible formatting of doubles} \
         3415  +test util-16.1.17.95 {8.4 compatible formatting of doubles} precision \
  3414   3416       {expr 1e95} \
  3415   3417       1e+95
  3416         -test util-16.1.17.96 {8.4 compatible formatting of doubles} \
         3418  +test util-16.1.17.96 {8.4 compatible formatting of doubles} precision \
  3417   3419       {expr 1e96} \
  3418   3420       1e+96
  3419         -test util-16.1.17.97 {8.4 compatible formatting of doubles} \
         3421  +test util-16.1.17.97 {8.4 compatible formatting of doubles} precision \
  3420   3422       {expr 1e97} \
  3421   3423       1.0000000000000001e+97
  3422         -test util-16.1.17.98 {8.4 compatible formatting of doubles} \
         3424  +test util-16.1.17.98 {8.4 compatible formatting of doubles} precision \
  3423   3425       {expr 1e98} \
  3424   3426       1e+98
  3425         -test util-16.1.17.99 {8.4 compatible formatting of doubles} \
         3427  +test util-16.1.17.99 {8.4 compatible formatting of doubles} precision \
  3426   3428       {expr 1e99} \
  3427   3429       9.9999999999999997e+98
  3428         -test util-16.1.17.100 {8.4 compatible formatting of doubles} \
         3430  +test util-16.1.17.100 {8.4 compatible formatting of doubles} precision \
  3429   3431       {expr 1e100} \
  3430   3432       1e+100
  3431         -test util-16.1.17.101 {8.4 compatible formatting of doubles} \
         3433  +test util-16.1.17.101 {8.4 compatible formatting of doubles} precision \
  3432   3434       {expr 1e101} \
  3433   3435       9.9999999999999998e+100
  3434         -test util-16.1.17.102 {8.4 compatible formatting of doubles} \
         3436  +test util-16.1.17.102 {8.4 compatible formatting of doubles} precision \
  3435   3437       {expr 1e102} \
  3436   3438       9.9999999999999998e+101
  3437         -test util-16.1.17.103 {8.4 compatible formatting of doubles} \
         3439  +test util-16.1.17.103 {8.4 compatible formatting of doubles} precision \
  3438   3440       {expr 1e103} \
  3439   3441       1e+103
  3440         -test util-16.1.17.104 {8.4 compatible formatting of doubles} \
         3442  +test util-16.1.17.104 {8.4 compatible formatting of doubles} precision \
  3441   3443       {expr 1e104} \
  3442   3444       1e+104
  3443         -test util-16.1.17.105 {8.4 compatible formatting of doubles} \
         3445  +test util-16.1.17.105 {8.4 compatible formatting of doubles} precision \
  3444   3446       {expr 1e105} \
  3445   3447       9.9999999999999994e+104
  3446         -test util-16.1.17.106 {8.4 compatible formatting of doubles} \
         3448  +test util-16.1.17.106 {8.4 compatible formatting of doubles} precision \
  3447   3449       {expr 1e106} \
  3448   3450       1.0000000000000001e+106
  3449         -test util-16.1.17.107 {8.4 compatible formatting of doubles} \
         3451  +test util-16.1.17.107 {8.4 compatible formatting of doubles} precision \
  3450   3452       {expr 1e107} \
  3451   3453       9.9999999999999997e+106
  3452         -test util-16.1.17.108 {8.4 compatible formatting of doubles} \
         3454  +test util-16.1.17.108 {8.4 compatible formatting of doubles} precision \
  3453   3455       {expr 1e108} \
  3454   3456       1e+108
  3455         -test util-16.1.17.109 {8.4 compatible formatting of doubles} \
         3457  +test util-16.1.17.109 {8.4 compatible formatting of doubles} precision \
  3456   3458       {expr 1e109} \
  3457   3459       9.9999999999999998e+108
  3458         -test util-16.1.17.110 {8.4 compatible formatting of doubles} \
         3460  +test util-16.1.17.110 {8.4 compatible formatting of doubles} precision \
  3459   3461       {expr 1e110} \
  3460   3462       1e+110
  3461         -test util-16.1.17.111 {8.4 compatible formatting of doubles} \
         3463  +test util-16.1.17.111 {8.4 compatible formatting of doubles} precision \
  3462   3464       {expr 1e111} \
  3463   3465       9.9999999999999996e+110
  3464         -test util-16.1.17.112 {8.4 compatible formatting of doubles} \
         3466  +test util-16.1.17.112 {8.4 compatible formatting of doubles} precision \
  3465   3467       {expr 1e112} \
  3466   3468       9.9999999999999993e+111
  3467         -test util-16.1.17.113 {8.4 compatible formatting of doubles} \
         3469  +test util-16.1.17.113 {8.4 compatible formatting of doubles} precision \
  3468   3470       {expr 1e113} \
  3469   3471       1e+113
  3470         -test util-16.1.17.114 {8.4 compatible formatting of doubles} \
         3472  +test util-16.1.17.114 {8.4 compatible formatting of doubles} precision \
  3471   3473       {expr 1e114} \
  3472   3474       1e+114
  3473         -test util-16.1.17.115 {8.4 compatible formatting of doubles} \
         3475  +test util-16.1.17.115 {8.4 compatible formatting of doubles} precision \
  3474   3476       {expr 1e115} \
  3475   3477       1e+115
  3476         -test util-16.1.17.116 {8.4 compatible formatting of doubles} \
         3478  +test util-16.1.17.116 {8.4 compatible formatting of doubles} precision \
  3477   3479       {expr 1e116} \
  3478   3480       1e+116
  3479         -test util-16.1.17.117 {8.4 compatible formatting of doubles} \
         3481  +test util-16.1.17.117 {8.4 compatible formatting of doubles} precision \
  3480   3482       {expr 1e117} \
  3481   3483       1.0000000000000001e+117
  3482         -test util-16.1.17.118 {8.4 compatible formatting of doubles} \
         3484  +test util-16.1.17.118 {8.4 compatible formatting of doubles} precision \
  3483   3485       {expr 1e118} \
  3484   3486       9.9999999999999997e+117
  3485         -test util-16.1.17.119 {8.4 compatible formatting of doubles} \
         3487  +test util-16.1.17.119 {8.4 compatible formatting of doubles} precision \
  3486   3488       {expr 1e119} \
  3487   3489       9.9999999999999994e+118
  3488         -test util-16.1.17.120 {8.4 compatible formatting of doubles} \
         3490  +test util-16.1.17.120 {8.4 compatible formatting of doubles} precision \
  3489   3491       {expr 1e120} \
  3490   3492       9.9999999999999998e+119
  3491         -test util-16.1.17.121 {8.4 compatible formatting of doubles} \
         3493  +test util-16.1.17.121 {8.4 compatible formatting of doubles} precision \
  3492   3494       {expr 1e121} \
  3493   3495       1e+121
  3494         -test util-16.1.17.122 {8.4 compatible formatting of doubles} \
         3496  +test util-16.1.17.122 {8.4 compatible formatting of doubles} precision \
  3495   3497       {expr 1e122} \
  3496   3498       1e+122
  3497         -test util-16.1.17.123 {8.4 compatible formatting of doubles} \
         3499  +test util-16.1.17.123 {8.4 compatible formatting of doubles} precision \
  3498   3500       {expr 1e123} \
  3499   3501       9.9999999999999998e+122
  3500         -test util-16.1.17.124 {8.4 compatible formatting of doubles} \
         3502  +test util-16.1.17.124 {8.4 compatible formatting of doubles} precision \
  3501   3503       {expr 1e124} \
  3502   3504       9.9999999999999995e+123
  3503         -test util-16.1.17.125 {8.4 compatible formatting of doubles} \
         3505  +test util-16.1.17.125 {8.4 compatible formatting of doubles} precision \
  3504   3506       {expr 1e125} \
  3505   3507       9.9999999999999992e+124
  3506         -test util-16.1.17.126 {8.4 compatible formatting of doubles} \
         3508  +test util-16.1.17.126 {8.4 compatible formatting of doubles} precision \
  3507   3509       {expr 1e126} \
  3508   3510       9.9999999999999992e+125
  3509         -test util-16.1.17.127 {8.4 compatible formatting of doubles} \
         3511  +test util-16.1.17.127 {8.4 compatible formatting of doubles} precision \
  3510   3512       {expr 1e127} \
  3511   3513       9.9999999999999995e+126
  3512         -test util-16.1.17.128 {8.4 compatible formatting of doubles} \
         3514  +test util-16.1.17.128 {8.4 compatible formatting of doubles} precision \
  3513   3515       {expr 1e128} \
  3514   3516       1.0000000000000001e+128
  3515         -test util-16.1.17.129 {8.4 compatible formatting of doubles} \
         3517  +test util-16.1.17.129 {8.4 compatible formatting of doubles} precision \
  3516   3518       {expr 1e129} \
  3517   3519       1e+129
  3518         -test util-16.1.17.130 {8.4 compatible formatting of doubles} \
         3520  +test util-16.1.17.130 {8.4 compatible formatting of doubles} precision \
  3519   3521       {expr 1e130} \
  3520   3522       1.0000000000000001e+130
  3521         -test util-16.1.17.131 {8.4 compatible formatting of doubles} \
         3523  +test util-16.1.17.131 {8.4 compatible formatting of doubles} precision \
  3522   3524       {expr 1e131} \
  3523   3525       9.9999999999999991e+130
  3524         -test util-16.1.17.132 {8.4 compatible formatting of doubles} \
         3526  +test util-16.1.17.132 {8.4 compatible formatting of doubles} precision \
  3525   3527       {expr 1e132} \
  3526   3528       9.9999999999999999e+131
  3527         -test util-16.1.17.133 {8.4 compatible formatting of doubles} \
         3529  +test util-16.1.17.133 {8.4 compatible formatting of doubles} precision \
  3528   3530       {expr 1e133} \
  3529   3531       1e+133
  3530         -test util-16.1.17.134 {8.4 compatible formatting of doubles} \
         3532  +test util-16.1.17.134 {8.4 compatible formatting of doubles} precision \
  3531   3533       {expr 1e134} \
  3532   3534       9.9999999999999992e+133
  3533         -test util-16.1.17.135 {8.4 compatible formatting of doubles} \
         3535  +test util-16.1.17.135 {8.4 compatible formatting of doubles} precision \
  3534   3536       {expr 1e135} \
  3535   3537       9.9999999999999996e+134
  3536         -test util-16.1.17.136 {8.4 compatible formatting of doubles} \
         3538  +test util-16.1.17.136 {8.4 compatible formatting of doubles} precision \
  3537   3539       {expr 1e136} \
  3538   3540       1.0000000000000001e+136
  3539         -test util-16.1.17.137 {8.4 compatible formatting of doubles} \
         3541  +test util-16.1.17.137 {8.4 compatible formatting of doubles} precision \
  3540   3542       {expr 1e137} \
  3541   3543       1e+137
  3542         -test util-16.1.17.138 {8.4 compatible formatting of doubles} \
         3544  +test util-16.1.17.138 {8.4 compatible formatting of doubles} precision \
  3543   3545       {expr 1e138} \
  3544   3546       1e+138
  3545         -test util-16.1.17.139 {8.4 compatible formatting of doubles} \
         3547  +test util-16.1.17.139 {8.4 compatible formatting of doubles} precision \
  3546   3548       {expr 1e139} \
  3547   3549       1e+139
  3548         -test util-16.1.17.140 {8.4 compatible formatting of doubles} \
         3550  +test util-16.1.17.140 {8.4 compatible formatting of doubles} precision \
  3549   3551       {expr 1e140} \
  3550   3552       1.0000000000000001e+140
  3551         -test util-16.1.17.141 {8.4 compatible formatting of doubles} \
         3553  +test util-16.1.17.141 {8.4 compatible formatting of doubles} precision \
  3552   3554       {expr 1e141} \
  3553   3555       1e+141
  3554         -test util-16.1.17.142 {8.4 compatible formatting of doubles} \
         3556  +test util-16.1.17.142 {8.4 compatible formatting of doubles} precision \
  3555   3557       {expr 1e142} \
  3556   3558       1.0000000000000001e+142
  3557         -test util-16.1.17.143 {8.4 compatible formatting of doubles} \
         3559  +test util-16.1.17.143 {8.4 compatible formatting of doubles} precision \
  3558   3560       {expr 1e143} \
  3559   3561       1e+143
  3560         -test util-16.1.17.144 {8.4 compatible formatting of doubles} \
         3562  +test util-16.1.17.144 {8.4 compatible formatting of doubles} precision \
  3561   3563       {expr 1e144} \
  3562   3564       1e+144
  3563         -test util-16.1.17.145 {8.4 compatible formatting of doubles} \
         3565  +test util-16.1.17.145 {8.4 compatible formatting of doubles} precision \
  3564   3566       {expr 1e145} \
  3565   3567       9.9999999999999999e+144
  3566         -test util-16.1.17.146 {8.4 compatible formatting of doubles} \
         3568  +test util-16.1.17.146 {8.4 compatible formatting of doubles} precision \
  3567   3569       {expr 1e146} \
  3568   3570       9.9999999999999993e+145
  3569         -test util-16.1.17.147 {8.4 compatible formatting of doubles} \
         3571  +test util-16.1.17.147 {8.4 compatible formatting of doubles} precision \
  3570   3572       {expr 1e147} \
  3571   3573       9.9999999999999998e+146
  3572         -test util-16.1.17.148 {8.4 compatible formatting of doubles} \
         3574  +test util-16.1.17.148 {8.4 compatible formatting of doubles} precision \
  3573   3575       {expr 1e148} \
  3574   3576       1e+148
  3575         -test util-16.1.17.149 {8.4 compatible formatting of doubles} \
         3577  +test util-16.1.17.149 {8.4 compatible formatting of doubles} precision \
  3576   3578       {expr 1e149} \
  3577   3579       1e+149
  3578         -test util-16.1.17.150 {8.4 compatible formatting of doubles} \
         3580  +test util-16.1.17.150 {8.4 compatible formatting of doubles} precision \
  3579   3581       {expr 1e150} \
  3580   3582       9.9999999999999998e+149
  3581         -test util-16.1.17.151 {8.4 compatible formatting of doubles} \
         3583  +test util-16.1.17.151 {8.4 compatible formatting of doubles} precision \
  3582   3584       {expr 1e151} \
  3583   3585       1e+151
  3584         -test util-16.1.17.152 {8.4 compatible formatting of doubles} \
         3586  +test util-16.1.17.152 {8.4 compatible formatting of doubles} precision \
  3585   3587       {expr 1e152} \
  3586   3588       1e+152
  3587         -test util-16.1.17.153 {8.4 compatible formatting of doubles} \
         3589  +test util-16.1.17.153 {8.4 compatible formatting of doubles} precision \
  3588   3590       {expr 1e153} \
  3589   3591       1e+153
  3590         -test util-16.1.17.154 {8.4 compatible formatting of doubles} \
         3592  +test util-16.1.17.154 {8.4 compatible formatting of doubles} precision \
  3591   3593       {expr 1e154} \
  3592   3594       1e+154
  3593         -test util-16.1.17.155 {8.4 compatible formatting of doubles} \
         3595  +test util-16.1.17.155 {8.4 compatible formatting of doubles} precision \
  3594   3596       {expr 1e155} \
  3595   3597       1e+155
  3596         -test util-16.1.17.156 {8.4 compatible formatting of doubles} \
         3598  +test util-16.1.17.156 {8.4 compatible formatting of doubles} precision \
  3597   3599       {expr 1e156} \
  3598   3600       9.9999999999999998e+155
  3599         -test util-16.1.17.157 {8.4 compatible formatting of doubles} \
         3601  +test util-16.1.17.157 {8.4 compatible formatting of doubles} precision \
  3600   3602       {expr 1e157} \
  3601   3603       9.9999999999999998e+156
  3602         -test util-16.1.17.158 {8.4 compatible formatting of doubles} \
         3604  +test util-16.1.17.158 {8.4 compatible formatting of doubles} precision \
  3603   3605       {expr 1e158} \
  3604   3606       9.9999999999999995e+157
  3605         -test util-16.1.17.159 {8.4 compatible formatting of doubles} \
         3607  +test util-16.1.17.159 {8.4 compatible formatting of doubles} precision \
  3606   3608       {expr 1e159} \
  3607   3609       9.9999999999999993e+158
  3608         -test util-16.1.17.160 {8.4 compatible formatting of doubles} \
         3610  +test util-16.1.17.160 {8.4 compatible formatting of doubles} precision \
  3609   3611       {expr 1e160} \
  3610   3612       1e+160
  3611         -test util-16.1.17.161 {8.4 compatible formatting of doubles} \
         3613  +test util-16.1.17.161 {8.4 compatible formatting of doubles} precision \
  3612   3614       {expr 1e161} \
  3613   3615       1e+161
  3614         -test util-16.1.17.162 {8.4 compatible formatting of doubles} \
         3616  +test util-16.1.17.162 {8.4 compatible formatting of doubles} precision \
  3615   3617       {expr 1e162} \
  3616   3618       9.9999999999999994e+161
  3617         -test util-16.1.17.163 {8.4 compatible formatting of doubles} \
         3619  +test util-16.1.17.163 {8.4 compatible formatting of doubles} precision \
  3618   3620       {expr 1e163} \
  3619   3621       9.9999999999999994e+162
  3620         -test util-16.1.17.164 {8.4 compatible formatting of doubles} \
         3622  +test util-16.1.17.164 {8.4 compatible formatting of doubles} precision \
  3621   3623       {expr 1e164} \
  3622   3624       1e+164
  3623         -test util-16.1.17.165 {8.4 compatible formatting of doubles} \
         3625  +test util-16.1.17.165 {8.4 compatible formatting of doubles} precision \
  3624   3626       {expr 1e165} \
  3625   3627       9.999999999999999e+164
  3626         -test util-16.1.17.166 {8.4 compatible formatting of doubles} \
         3628  +test util-16.1.17.166 {8.4 compatible formatting of doubles} precision \
  3627   3629       {expr 1e166} \
  3628   3630       9.9999999999999994e+165
  3629         -test util-16.1.17.167 {8.4 compatible formatting of doubles} \
         3631  +test util-16.1.17.167 {8.4 compatible formatting of doubles} precision \
  3630   3632       {expr 1e167} \
  3631   3633       1e+167
  3632         -test util-16.1.17.168 {8.4 compatible formatting of doubles} \
         3634  +test util-16.1.17.168 {8.4 compatible formatting of doubles} precision \
  3633   3635       {expr 1e168} \
  3634   3636       9.9999999999999993e+167
  3635         -test util-16.1.17.169 {8.4 compatible formatting of doubles} \
         3637  +test util-16.1.17.169 {8.4 compatible formatting of doubles} precision \
  3636   3638       {expr 1e169} \
  3637   3639       9.9999999999999993e+168
  3638         -test util-16.1.17.170 {8.4 compatible formatting of doubles} \
         3640  +test util-16.1.17.170 {8.4 compatible formatting of doubles} precision \
  3639   3641       {expr 1e170} \
  3640   3642       1e+170
  3641         -test util-16.1.17.171 {8.4 compatible formatting of doubles} \
         3643  +test util-16.1.17.171 {8.4 compatible formatting of doubles} precision \
  3642   3644       {expr 1e171} \
  3643   3645       9.9999999999999995e+170
  3644         -test util-16.1.17.172 {8.4 compatible formatting of doubles} \
         3646  +test util-16.1.17.172 {8.4 compatible formatting of doubles} precision \
  3645   3647       {expr 1e172} \
  3646   3648       1.0000000000000001e+172
  3647         -test util-16.1.17.173 {8.4 compatible formatting of doubles} \
         3649  +test util-16.1.17.173 {8.4 compatible formatting of doubles} precision \
  3648   3650       {expr 1e173} \
  3649   3651       1e+173
  3650         -test util-16.1.17.174 {8.4 compatible formatting of doubles} \
         3652  +test util-16.1.17.174 {8.4 compatible formatting of doubles} precision \
  3651   3653       {expr 1e174} \
  3652   3654       1.0000000000000001e+174
  3653         -test util-16.1.17.175 {8.4 compatible formatting of doubles} \
         3655  +test util-16.1.17.175 {8.4 compatible formatting of doubles} precision \
  3654   3656       {expr 1e175} \
  3655   3657       9.9999999999999994e+174
  3656         -test util-16.1.17.176 {8.4 compatible formatting of doubles} \
         3658  +test util-16.1.17.176 {8.4 compatible formatting of doubles} precision \
  3657   3659       {expr 1e176} \
  3658   3660       1e+176
  3659         -test util-16.1.17.177 {8.4 compatible formatting of doubles} \
         3661  +test util-16.1.17.177 {8.4 compatible formatting of doubles} precision \
  3660   3662       {expr 1e177} \
  3661   3663       1e+177
  3662         -test util-16.1.17.178 {8.4 compatible formatting of doubles} \
         3664  +test util-16.1.17.178 {8.4 compatible formatting of doubles} precision \
  3663   3665       {expr 1e178} \
  3664   3666       1.0000000000000001e+178
  3665         -test util-16.1.17.179 {8.4 compatible formatting of doubles} \
         3667  +test util-16.1.17.179 {8.4 compatible formatting of doubles} precision \
  3666   3668       {expr 1e179} \
  3667   3669       9.9999999999999998e+178
  3668         -test util-16.1.17.180 {8.4 compatible formatting of doubles} \
         3670  +test util-16.1.17.180 {8.4 compatible formatting of doubles} precision \
  3669   3671       {expr 1e180} \
  3670   3672       1e+180
  3671         -test util-16.1.17.181 {8.4 compatible formatting of doubles} \
         3673  +test util-16.1.17.181 {8.4 compatible formatting of doubles} precision \
  3672   3674       {expr 1e181} \
  3673   3675       9.9999999999999992e+180
  3674         -test util-16.1.17.182 {8.4 compatible formatting of doubles} \
         3676  +test util-16.1.17.182 {8.4 compatible formatting of doubles} precision \
  3675   3677       {expr 1e182} \
  3676   3678       1.0000000000000001e+182
  3677         -test util-16.1.17.183 {8.4 compatible formatting of doubles} \
         3679  +test util-16.1.17.183 {8.4 compatible formatting of doubles} precision \
  3678   3680       {expr 1e183} \
  3679   3681       9.9999999999999995e+182
  3680         -test util-16.1.17.184 {8.4 compatible formatting of doubles} \
         3682  +test util-16.1.17.184 {8.4 compatible formatting of doubles} precision \
  3681   3683       {expr 1e184} \
  3682   3684       1e+184
  3683         -test util-16.1.17.185 {8.4 compatible formatting of doubles} \
         3685  +test util-16.1.17.185 {8.4 compatible formatting of doubles} precision \
  3684   3686       {expr 1e185} \
  3685   3687       9.9999999999999998e+184
  3686         -test util-16.1.17.186 {8.4 compatible formatting of doubles} \
         3688  +test util-16.1.17.186 {8.4 compatible formatting of doubles} precision \
  3687   3689       {expr 1e186} \
  3688   3690       9.9999999999999998e+185
  3689         -test util-16.1.17.187 {8.4 compatible formatting of doubles} \
         3691  +test util-16.1.17.187 {8.4 compatible formatting of doubles} precision \
  3690   3692       {expr 1e187} \
  3691   3693       9.9999999999999991e+186
  3692         -test util-16.1.17.188 {8.4 compatible formatting of doubles} \
         3694  +test util-16.1.17.188 {8.4 compatible formatting of doubles} precision \
  3693   3695       {expr 1e188} \
  3694   3696       1e+188
  3695         -test util-16.1.17.189 {8.4 compatible formatting of doubles} \
         3697  +test util-16.1.17.189 {8.4 compatible formatting of doubles} precision \
  3696   3698       {expr 1e189} \
  3697   3699       1e+189
  3698         -test util-16.1.17.190 {8.4 compatible formatting of doubles} \
         3700  +test util-16.1.17.190 {8.4 compatible formatting of doubles} precision \
  3699   3701       {expr 1e190} \
  3700   3702       1.0000000000000001e+190
  3701         -test util-16.1.17.191 {8.4 compatible formatting of doubles} \
         3703  +test util-16.1.17.191 {8.4 compatible formatting of doubles} precision \
  3702   3704       {expr 1e191} \
  3703   3705       1.0000000000000001e+191
  3704         -test util-16.1.17.192 {8.4 compatible formatting of doubles} \
         3706  +test util-16.1.17.192 {8.4 compatible formatting of doubles} precision \
  3705   3707       {expr 1e192} \
  3706   3708       1e+192
  3707         -test util-16.1.17.193 {8.4 compatible formatting of doubles} \
         3709  +test util-16.1.17.193 {8.4 compatible formatting of doubles} precision \
  3708   3710       {expr 1e193} \
  3709   3711       1.0000000000000001e+193
  3710         -test util-16.1.17.194 {8.4 compatible formatting of doubles} \
         3712  +test util-16.1.17.194 {8.4 compatible formatting of doubles} precision \
  3711   3713       {expr 1e194} \
  3712   3714       9.9999999999999994e+193
  3713         -test util-16.1.17.195 {8.4 compatible formatting of doubles} \
         3715  +test util-16.1.17.195 {8.4 compatible formatting of doubles} precision \
  3714   3716       {expr 1e195} \
  3715   3717       9.9999999999999998e+194
  3716         -test util-16.1.17.196 {8.4 compatible formatting of doubles} \
         3718  +test util-16.1.17.196 {8.4 compatible formatting of doubles} precision \
  3717   3719       {expr 1e196} \
  3718   3720       9.9999999999999995e+195
  3719         -test util-16.1.17.197 {8.4 compatible formatting of doubles} \
         3721  +test util-16.1.17.197 {8.4 compatible formatting of doubles} precision \
  3720   3722       {expr 1e197} \
  3721   3723       9.9999999999999995e+196
  3722         -test util-16.1.17.198 {8.4 compatible formatting of doubles} \
         3724  +test util-16.1.17.198 {8.4 compatible formatting of doubles} precision \
  3723   3725       {expr 1e198} \
  3724   3726       1e+198
  3725         -test util-16.1.17.199 {8.4 compatible formatting of doubles} \
         3727  +test util-16.1.17.199 {8.4 compatible formatting of doubles} precision \
  3726   3728       {expr 1e199} \
  3727   3729       1.0000000000000001e+199
  3728         -test util-16.1.17.200 {8.4 compatible formatting of doubles} \
         3730  +test util-16.1.17.200 {8.4 compatible formatting of doubles} precision \
  3729   3731       {expr 1e200} \
  3730   3732       9.9999999999999997e+199
  3731         -test util-16.1.17.201 {8.4 compatible formatting of doubles} \
         3733  +test util-16.1.17.201 {8.4 compatible formatting of doubles} precision \
  3732   3734       {expr 1e201} \
  3733   3735       1e+201
  3734         -test util-16.1.17.202 {8.4 compatible formatting of doubles} \
         3736  +test util-16.1.17.202 {8.4 compatible formatting of doubles} precision \
  3735   3737       {expr 1e202} \
  3736   3738       9.999999999999999e+201
  3737         -test util-16.1.17.203 {8.4 compatible formatting of doubles} \
         3739  +test util-16.1.17.203 {8.4 compatible formatting of doubles} precision \
  3738   3740       {expr 1e203} \
  3739   3741       9.9999999999999999e+202
  3740         -test util-16.1.17.204 {8.4 compatible formatting of doubles} \
         3742  +test util-16.1.17.204 {8.4 compatible formatting of doubles} precision \
  3741   3743       {expr 1e204} \
  3742   3744       9.9999999999999999e+203
  3743         -test util-16.1.17.205 {8.4 compatible formatting of doubles} \
         3745  +test util-16.1.17.205 {8.4 compatible formatting of doubles} precision \
  3744   3746       {expr 1e205} \
  3745   3747       1e+205
  3746         -test util-16.1.17.206 {8.4 compatible formatting of doubles} \
         3748  +test util-16.1.17.206 {8.4 compatible formatting of doubles} precision \
  3747   3749       {expr 1e206} \
  3748   3750       1e+206
  3749         -test util-16.1.17.207 {8.4 compatible formatting of doubles} \
         3751  +test util-16.1.17.207 {8.4 compatible formatting of doubles} precision \
  3750   3752       {expr 1e207} \
  3751   3753       1e+207
  3752         -test util-16.1.17.208 {8.4 compatible formatting of doubles} \
         3754  +test util-16.1.17.208 {8.4 compatible formatting of doubles} precision \
  3753   3755       {expr 1e208} \
  3754   3756       9.9999999999999998e+207
  3755         -test util-16.1.17.209 {8.4 compatible formatting of doubles} \
         3757  +test util-16.1.17.209 {8.4 compatible formatting of doubles} precision \
  3756   3758       {expr 1e209} \
  3757   3759       1.0000000000000001e+209
  3758         -test util-16.1.17.210 {8.4 compatible formatting of doubles} \
         3760  +test util-16.1.17.210 {8.4 compatible formatting of doubles} precision \
  3759   3761       {expr 1e210} \
  3760   3762       9.9999999999999993e+209
  3761         -test util-16.1.17.211 {8.4 compatible formatting of doubles} \
         3763  +test util-16.1.17.211 {8.4 compatible formatting of doubles} precision \
  3762   3764       {expr 1e211} \
  3763   3765       9.9999999999999996e+210
  3764         -test util-16.1.17.212 {8.4 compatible formatting of doubles} \
         3766  +test util-16.1.17.212 {8.4 compatible formatting of doubles} precision \
  3765   3767       {expr 1e212} \
  3766   3768       9.9999999999999991e+211
  3767         -test util-16.1.17.213 {8.4 compatible formatting of doubles} \
         3769  +test util-16.1.17.213 {8.4 compatible formatting of doubles} precision \
  3768   3770       {expr 1e213} \
  3769   3771       9.9999999999999998e+212
  3770         -test util-16.1.17.214 {8.4 compatible formatting of doubles} \
         3772  +test util-16.1.17.214 {8.4 compatible formatting of doubles} precision \
  3771   3773       {expr 1e214} \
  3772   3774       9.9999999999999995e+213
  3773         -test util-16.1.17.215 {8.4 compatible formatting of doubles} \
         3775  +test util-16.1.17.215 {8.4 compatible formatting of doubles} precision \
  3774   3776       {expr 1e215} \
  3775   3777       9.9999999999999991e+214
  3776         -test util-16.1.17.216 {8.4 compatible formatting of doubles} \
         3778  +test util-16.1.17.216 {8.4 compatible formatting of doubles} precision \
  3777   3779       {expr 1e216} \
  3778   3780       1e+216
  3779         -test util-16.1.17.217 {8.4 compatible formatting of doubles} \
         3781  +test util-16.1.17.217 {8.4 compatible formatting of doubles} precision \
  3780   3782       {expr 1e217} \
  3781   3783       9.9999999999999996e+216
  3782         -test util-16.1.17.218 {8.4 compatible formatting of doubles} \
         3784  +test util-16.1.17.218 {8.4 compatible formatting of doubles} precision \
  3783   3785       {expr 1e218} \
  3784   3786       1.0000000000000001e+218
  3785         -test util-16.1.17.219 {8.4 compatible formatting of doubles} \
         3787  +test util-16.1.17.219 {8.4 compatible formatting of doubles} precision \
  3786   3788       {expr 1e219} \
  3787   3789       9.9999999999999997e+218
  3788         -test util-16.1.17.220 {8.4 compatible formatting of doubles} \
         3790  +test util-16.1.17.220 {8.4 compatible formatting of doubles} precision \
  3789   3791       {expr 1e220} \
  3790   3792       1e+220
  3791         -test util-16.1.17.221 {8.4 compatible formatting of doubles} \
         3793  +test util-16.1.17.221 {8.4 compatible formatting of doubles} precision \
  3792   3794       {expr 1e221} \
  3793   3795       1e+221
  3794         -test util-16.1.17.222 {8.4 compatible formatting of doubles} \
         3796  +test util-16.1.17.222 {8.4 compatible formatting of doubles} precision \
  3795   3797       {expr 1e222} \
  3796   3798       1e+222
  3797         -test util-16.1.17.223 {8.4 compatible formatting of doubles} \
         3799  +test util-16.1.17.223 {8.4 compatible formatting of doubles} precision \
  3798   3800       {expr 1e223} \
  3799   3801       1e+223
  3800         -test util-16.1.17.224 {8.4 compatible formatting of doubles} \
         3802  +test util-16.1.17.224 {8.4 compatible formatting of doubles} precision \
  3801   3803       {expr 1e224} \
  3802   3804       9.9999999999999997e+223
  3803         -test util-16.1.17.225 {8.4 compatible formatting of doubles} \
         3805  +test util-16.1.17.225 {8.4 compatible formatting of doubles} precision \
  3804   3806       {expr 1e225} \
  3805   3807       9.9999999999999993e+224
  3806         -test util-16.1.17.226 {8.4 compatible formatting of doubles} \
         3808  +test util-16.1.17.226 {8.4 compatible formatting of doubles} precision \
  3807   3809       {expr 1e226} \
  3808   3810       9.9999999999999996e+225
  3809         -test util-16.1.17.227 {8.4 compatible formatting of doubles} \
         3811  +test util-16.1.17.227 {8.4 compatible formatting of doubles} precision \
  3810   3812       {expr 1e227} \
  3811   3813       1.0000000000000001e+227
  3812         -test util-16.1.17.228 {8.4 compatible formatting of doubles} \
         3814  +test util-16.1.17.228 {8.4 compatible formatting of doubles} precision \
  3813   3815       {expr 1e228} \
  3814   3816       9.9999999999999992e+227
  3815         -test util-16.1.17.229 {8.4 compatible formatting of doubles} \
         3817  +test util-16.1.17.229 {8.4 compatible formatting of doubles} precision \
  3816   3818       {expr 1e229} \
  3817   3819       9.9999999999999999e+228
  3818         -test util-16.1.17.230 {8.4 compatible formatting of doubles} \
         3820  +test util-16.1.17.230 {8.4 compatible formatting of doubles} precision \
  3819   3821       {expr 1e230} \
  3820   3822       1.0000000000000001e+230
  3821         -test util-16.1.17.231 {8.4 compatible formatting of doubles} \
         3823  +test util-16.1.17.231 {8.4 compatible formatting of doubles} precision \
  3822   3824       {expr 1e231} \
  3823   3825       1.0000000000000001e+231
  3824         -test util-16.1.17.232 {8.4 compatible formatting of doubles} \
         3826  +test util-16.1.17.232 {8.4 compatible formatting of doubles} precision \
  3825   3827       {expr 1e232} \
  3826   3828       1.0000000000000001e+232
  3827         -test util-16.1.17.233 {8.4 compatible formatting of doubles} \
         3829  +test util-16.1.17.233 {8.4 compatible formatting of doubles} precision \
  3828   3830       {expr 1e233} \
  3829   3831       9.9999999999999997e+232
  3830         -test util-16.1.17.234 {8.4 compatible formatting of doubles} \
         3832  +test util-16.1.17.234 {8.4 compatible formatting of doubles} precision \
  3831   3833       {expr 1e234} \
  3832   3834       1e+234
  3833         -test util-16.1.17.235 {8.4 compatible formatting of doubles} \
         3835  +test util-16.1.17.235 {8.4 compatible formatting of doubles} precision \
  3834   3836       {expr 1e235} \
  3835   3837       1.0000000000000001e+235
  3836         -test util-16.1.17.236 {8.4 compatible formatting of doubles} \
         3838  +test util-16.1.17.236 {8.4 compatible formatting of doubles} precision \
  3837   3839       {expr 1e236} \
  3838   3840       1.0000000000000001e+236
  3839         -test util-16.1.17.237 {8.4 compatible formatting of doubles} \
         3841  +test util-16.1.17.237 {8.4 compatible formatting of doubles} precision \
  3840   3842       {expr 1e237} \
  3841   3843       9.9999999999999994e+236
  3842         -test util-16.1.17.238 {8.4 compatible formatting of doubles} \
         3844  +test util-16.1.17.238 {8.4 compatible formatting of doubles} precision \
  3843   3845       {expr 1e238} \
  3844   3846       1e+238
  3845         -test util-16.1.17.239 {8.4 compatible formatting of doubles} \
         3847  +test util-16.1.17.239 {8.4 compatible formatting of doubles} precision \
  3846   3848       {expr 1e239} \
  3847   3849       9.9999999999999999e+238
  3848         -test util-16.1.17.240 {8.4 compatible formatting of doubles} \
         3850  +test util-16.1.17.240 {8.4 compatible formatting of doubles} precision \
  3849   3851       {expr 1e240} \
  3850   3852       1e+240
  3851         -test util-16.1.17.241 {8.4 compatible formatting of doubles} \
         3853  +test util-16.1.17.241 {8.4 compatible formatting of doubles} precision \
  3852   3854       {expr 1e241} \
  3853   3855       1.0000000000000001e+241
  3854         -test util-16.1.17.242 {8.4 compatible formatting of doubles} \
         3856  +test util-16.1.17.242 {8.4 compatible formatting of doubles} precision \
  3855   3857       {expr 1e242} \
  3856   3858       1.0000000000000001e+242
  3857         -test util-16.1.17.243 {8.4 compatible formatting of doubles} \
         3859  +test util-16.1.17.243 {8.4 compatible formatting of doubles} precision \
  3858   3860       {expr 1e243} \
  3859   3861       1.0000000000000001e+243
  3860         -test util-16.1.17.244 {8.4 compatible formatting of doubles} \
         3862  +test util-16.1.17.244 {8.4 compatible formatting of doubles} precision \
  3861   3863       {expr 1e244} \
  3862   3864       1.0000000000000001e+244
  3863         -test util-16.1.17.245 {8.4 compatible formatting of doubles} \
         3865  +test util-16.1.17.245 {8.4 compatible formatting of doubles} precision \
  3864   3866       {expr 1e245} \
  3865   3867       1e+245
  3866         -test util-16.1.17.246 {8.4 compatible formatting of doubles} \
         3868  +test util-16.1.17.246 {8.4 compatible formatting of doubles} precision \
  3867   3869       {expr 1e246} \
  3868   3870       1.0000000000000001e+246
  3869         -test util-16.1.17.247 {8.4 compatible formatting of doubles} \
         3871  +test util-16.1.17.247 {8.4 compatible formatting of doubles} precision \
  3870   3872       {expr 1e247} \
  3871   3873       9.9999999999999995e+246
  3872         -test util-16.1.17.248 {8.4 compatible formatting of doubles} \
         3874  +test util-16.1.17.248 {8.4 compatible formatting of doubles} precision \
  3873   3875       {expr 1e248} \
  3874   3876       1e+248
  3875         -test util-16.1.17.249 {8.4 compatible formatting of doubles} \
         3877  +test util-16.1.17.249 {8.4 compatible formatting of doubles} precision \
  3876   3878       {expr 1e249} \
  3877   3879       9.9999999999999992e+248
  3878         -test util-16.1.17.250 {8.4 compatible formatting of doubles} \
         3880  +test util-16.1.17.250 {8.4 compatible formatting of doubles} precision \
  3879   3881       {expr 1e250} \
  3880   3882       9.9999999999999992e+249
  3881         -test util-16.1.17.251 {8.4 compatible formatting of doubles} \
         3883  +test util-16.1.17.251 {8.4 compatible formatting of doubles} precision \
  3882   3884       {expr 1e251} \
  3883   3885       1e+251
  3884         -test util-16.1.17.252 {8.4 compatible formatting of doubles} \
         3886  +test util-16.1.17.252 {8.4 compatible formatting of doubles} precision \
  3885   3887       {expr 1e252} \
  3886   3888       1.0000000000000001e+252
  3887         -test util-16.1.17.253 {8.4 compatible formatting of doubles} \
         3889  +test util-16.1.17.253 {8.4 compatible formatting of doubles} precision \
  3888   3890       {expr 1e253} \
  3889   3891       9.9999999999999994e+252
  3890         -test util-16.1.17.254 {8.4 compatible formatting of doubles} \
         3892  +test util-16.1.17.254 {8.4 compatible formatting of doubles} precision \
  3891   3893       {expr 1e254} \
  3892   3894       9.9999999999999994e+253
  3893         -test util-16.1.17.255 {8.4 compatible formatting of doubles} \
         3895  +test util-16.1.17.255 {8.4 compatible formatting of doubles} precision \
  3894   3896       {expr 1e255} \
  3895   3897       9.9999999999999999e+254
  3896         -test util-16.1.17.256 {8.4 compatible formatting of doubles} \
         3898  +test util-16.1.17.256 {8.4 compatible formatting of doubles} precision \
  3897   3899       {expr 1e256} \
  3898   3900       1e+256
  3899         -test util-16.1.17.257 {8.4 compatible formatting of doubles} \
         3901  +test util-16.1.17.257 {8.4 compatible formatting of doubles} precision \
  3900   3902       {expr 1e257} \
  3901   3903       1e+257
  3902         -test util-16.1.17.258 {8.4 compatible formatting of doubles} \
         3904  +test util-16.1.17.258 {8.4 compatible formatting of doubles} precision \
  3903   3905       {expr 1e258} \
  3904   3906       1.0000000000000001e+258
  3905         -test util-16.1.17.259 {8.4 compatible formatting of doubles} \
         3907  +test util-16.1.17.259 {8.4 compatible formatting of doubles} precision \
  3906   3908       {expr 1e259} \
  3907   3909       9.9999999999999993e+258
  3908         -test util-16.1.17.260 {8.4 compatible formatting of doubles} \
         3910  +test util-16.1.17.260 {8.4 compatible formatting of doubles} precision \
  3909   3911       {expr 1e260} \
  3910   3912       1.0000000000000001e+260
  3911         -test util-16.1.17.261 {8.4 compatible formatting of doubles} \
         3913  +test util-16.1.17.261 {8.4 compatible formatting of doubles} precision \
  3912   3914       {expr 1e261} \
  3913   3915       9.9999999999999993e+260
  3914         -test util-16.1.17.262 {8.4 compatible formatting of doubles} \
         3916  +test util-16.1.17.262 {8.4 compatible formatting of doubles} precision \
  3915   3917       {expr 1e262} \
  3916   3918       1e+262
  3917         -test util-16.1.17.263 {8.4 compatible formatting of doubles} \
         3919  +test util-16.1.17.263 {8.4 compatible formatting of doubles} precision \
  3918   3920       {expr 1e263} \
  3919   3921       1e+263
  3920         -test util-16.1.17.264 {8.4 compatible formatting of doubles} \
         3922  +test util-16.1.17.264 {8.4 compatible formatting of doubles} precision \
  3921   3923       {expr 1e264} \
  3922   3924       1e+264
  3923         -test util-16.1.17.265 {8.4 compatible formatting of doubles} \
         3925  +test util-16.1.17.265 {8.4 compatible formatting of doubles} precision \
  3924   3926       {expr 1e265} \
  3925   3927       1.0000000000000001e+265
  3926         -test util-16.1.17.266 {8.4 compatible formatting of doubles} \
         3928  +test util-16.1.17.266 {8.4 compatible formatting of doubles} precision \
  3927   3929       {expr 1e266} \
  3928   3930       1e+266
  3929         -test util-16.1.17.267 {8.4 compatible formatting of doubles} \
         3931  +test util-16.1.17.267 {8.4 compatible formatting of doubles} precision \
  3930   3932       {expr 1e267} \
  3931   3933       9.9999999999999997e+266
  3932         -test util-16.1.17.268 {8.4 compatible formatting of doubles} \
         3934  +test util-16.1.17.268 {8.4 compatible formatting of doubles} precision \
  3933   3935       {expr 1e268} \
  3934   3936       9.9999999999999997e+267
  3935         -test util-16.1.17.269 {8.4 compatible formatting of doubles} \
         3937  +test util-16.1.17.269 {8.4 compatible formatting of doubles} precision \
  3936   3938       {expr 1e269} \
  3937   3939       1e+269
  3938         -test util-16.1.17.270 {8.4 compatible formatting of doubles} \
         3940  +test util-16.1.17.270 {8.4 compatible formatting of doubles} precision \
  3939   3941       {expr 1e270} \
  3940   3942       1e+270
  3941         -test util-16.1.17.271 {8.4 compatible formatting of doubles} \
         3943  +test util-16.1.17.271 {8.4 compatible formatting of doubles} precision \
  3942   3944       {expr 1e271} \
  3943   3945       9.9999999999999995e+270
  3944         -test util-16.1.17.272 {8.4 compatible formatting of doubles} \
         3946  +test util-16.1.17.272 {8.4 compatible formatting of doubles} precision \
  3945   3947       {expr 1e272} \
  3946   3948       1.0000000000000001e+272
  3947         -test util-16.1.17.273 {8.4 compatible formatting of doubles} \
         3949  +test util-16.1.17.273 {8.4 compatible formatting of doubles} precision \
  3948   3950       {expr 1e273} \
  3949   3951       9.9999999999999995e+272
  3950         -test util-16.1.17.274 {8.4 compatible formatting of doubles} \
         3952  +test util-16.1.17.274 {8.4 compatible formatting of doubles} precision \
  3951   3953       {expr 1e274} \
  3952   3954       9.9999999999999992e+273
  3953         -test util-16.1.17.275 {8.4 compatible formatting of doubles} \
         3955  +test util-16.1.17.275 {8.4 compatible formatting of doubles} precision \
  3954   3956       {expr 1e275} \
  3955   3957       9.9999999999999996e+274
  3956         -test util-16.1.17.276 {8.4 compatible formatting of doubles} \
         3958  +test util-16.1.17.276 {8.4 compatible formatting of doubles} precision \
  3957   3959       {expr 1e276} \
  3958   3960       1.0000000000000001e+276
  3959         -test util-16.1.17.277 {8.4 compatible formatting of doubles} \
         3961  +test util-16.1.17.277 {8.4 compatible formatting of doubles} precision \
  3960   3962       {expr 1e277} \
  3961   3963       1e+277
  3962         -test util-16.1.17.278 {8.4 compatible formatting of doubles} \
         3964  +test util-16.1.17.278 {8.4 compatible formatting of doubles} precision \
  3963   3965       {expr 1e278} \
  3964   3966       9.9999999999999996e+277
  3965         -test util-16.1.17.279 {8.4 compatible formatting of doubles} \
         3967  +test util-16.1.17.279 {8.4 compatible formatting of doubles} precision \
  3966   3968       {expr 1e279} \
  3967   3969       1.0000000000000001e+279
  3968         -test util-16.1.17.280 {8.4 compatible formatting of doubles} \
         3970  +test util-16.1.17.280 {8.4 compatible formatting of doubles} precision \
  3969   3971       {expr 1e280} \
  3970   3972       1e+280
  3971         -test util-16.1.17.281 {8.4 compatible formatting of doubles} \
         3973  +test util-16.1.17.281 {8.4 compatible formatting of doubles} precision \
  3972   3974       {expr 1e281} \
  3973   3975       1e+281
  3974         -test util-16.1.17.282 {8.4 compatible formatting of doubles} \
         3976  +test util-16.1.17.282 {8.4 compatible formatting of doubles} precision \
  3975   3977       {expr 1e282} \
  3976   3978       1e+282
  3977         -test util-16.1.17.283 {8.4 compatible formatting of doubles} \
         3979  +test util-16.1.17.283 {8.4 compatible formatting of doubles} precision \
  3978   3980       {expr 1e283} \
  3979   3981       9.9999999999999996e+282
  3980         -test util-16.1.17.284 {8.4 compatible formatting of doubles} \
         3982  +test util-16.1.17.284 {8.4 compatible formatting of doubles} precision \
  3981   3983       {expr 1e284} \
  3982   3984       1.0000000000000001e+284
  3983         -test util-16.1.17.285 {8.4 compatible formatting of doubles} \
         3985  +test util-16.1.17.285 {8.4 compatible formatting of doubles} precision \
  3984   3986       {expr 1e285} \
  3985   3987       9.9999999999999998e+284
  3986         -test util-16.1.17.286 {8.4 compatible formatting of doubles} \
         3988  +test util-16.1.17.286 {8.4 compatible formatting of doubles} precision \
  3987   3989       {expr 1e286} \
  3988   3990       1e+286
  3989         -test util-16.1.17.287 {8.4 compatible formatting of doubles} \
         3991  +test util-16.1.17.287 {8.4 compatible formatting of doubles} precision \
  3990   3992       {expr 1e287} \
  3991   3993       1.0000000000000001e+287
  3992         -test util-16.1.17.288 {8.4 compatible formatting of doubles} \
         3994  +test util-16.1.17.288 {8.4 compatible formatting of doubles} precision \
  3993   3995       {expr 1e288} \
  3994   3996       1e+288
  3995         -test util-16.1.17.289 {8.4 compatible formatting of doubles} \
         3997  +test util-16.1.17.289 {8.4 compatible formatting of doubles} precision \
  3996   3998       {expr 1e289} \
  3997   3999       1.0000000000000001e+289
  3998         -test util-16.1.17.290 {8.4 compatible formatting of doubles} \
         4000  +test util-16.1.17.290 {8.4 compatible formatting of doubles} precision \
  3999   4001       {expr 1e290} \
  4000   4002       1.0000000000000001e+290
  4001         -test util-16.1.17.291 {8.4 compatible formatting of doubles} \
         4003  +test util-16.1.17.291 {8.4 compatible formatting of doubles} precision \
  4002   4004       {expr 1e291} \
  4003   4005       9.9999999999999996e+290
  4004         -test util-16.1.17.292 {8.4 compatible formatting of doubles} \
         4006  +test util-16.1.17.292 {8.4 compatible formatting of doubles} precision \
  4005   4007       {expr 1e292} \
  4006   4008       1e+292
  4007         -test util-16.1.17.293 {8.4 compatible formatting of doubles} \
         4009  +test util-16.1.17.293 {8.4 compatible formatting of doubles} precision \
  4008   4010       {expr 1e293} \
  4009   4011       9.9999999999999992e+292
  4010         -test util-16.1.17.294 {8.4 compatible formatting of doubles} \
         4012  +test util-16.1.17.294 {8.4 compatible formatting of doubles} precision \
  4011   4013       {expr 1e294} \
  4012   4014       1.0000000000000001e+294
  4013         -test util-16.1.17.295 {8.4 compatible formatting of doubles} \
         4015  +test util-16.1.17.295 {8.4 compatible formatting of doubles} precision \
  4014   4016       {expr 1e295} \
  4015   4017       9.9999999999999998e+294
  4016         -test util-16.1.17.296 {8.4 compatible formatting of doubles} \
         4018  +test util-16.1.17.296 {8.4 compatible formatting of doubles} precision \
  4017   4019       {expr 1e296} \
  4018   4020       9.9999999999999998e+295
  4019         -test util-16.1.17.297 {8.4 compatible formatting of doubles} \
         4021  +test util-16.1.17.297 {8.4 compatible formatting of doubles} precision \
  4020   4022       {expr 1e297} \
  4021   4023       1e+297
  4022         -test util-16.1.17.298 {8.4 compatible formatting of doubles} \
         4024  +test util-16.1.17.298 {8.4 compatible formatting of doubles} precision \
  4023   4025       {expr 1e298} \
  4024   4026       9.9999999999999996e+297
  4025         -test util-16.1.17.299 {8.4 compatible formatting of doubles} \
         4027  +test util-16.1.17.299 {8.4 compatible formatting of doubles} precision \
  4026   4028       {expr 1e299} \
  4027   4029       1.0000000000000001e+299
  4028         -test util-16.1.17.300 {8.4 compatible formatting of doubles} \
         4030  +test util-16.1.17.300 {8.4 compatible formatting of doubles} precision \
  4029   4031       {expr 1e300} \
  4030   4032       1.0000000000000001e+300
  4031         -test util-16.1.17.301 {8.4 compatible formatting of doubles} \
         4033  +test util-16.1.17.301 {8.4 compatible formatting of doubles} precision \
  4032   4034       {expr 1e301} \
  4033   4035       1.0000000000000001e+301
  4034         -test util-16.1.17.302 {8.4 compatible formatting of doubles} \
         4036  +test util-16.1.17.302 {8.4 compatible formatting of doubles} precision \
  4035   4037       {expr 1e302} \
  4036   4038       1.0000000000000001e+302
  4037         -test util-16.1.17.303 {8.4 compatible formatting of doubles} \
         4039  +test util-16.1.17.303 {8.4 compatible formatting of doubles} precision \
  4038   4040       {expr 1e303} \
  4039   4041       1e+303
  4040         -test util-16.1.17.304 {8.4 compatible formatting of doubles} \
         4042  +test util-16.1.17.304 {8.4 compatible formatting of doubles} precision \
  4041   4043       {expr 1e304} \
  4042   4044       9.9999999999999994e+303
  4043         -test util-16.1.17.305 {8.4 compatible formatting of doubles} \
         4045  +test util-16.1.17.305 {8.4 compatible formatting of doubles} precision \
  4044   4046       {expr 1e305} \
  4045   4047       9.9999999999999994e+304
  4046         -test util-16.1.17.306 {8.4 compatible formatting of doubles} \
         4048  +test util-16.1.17.306 {8.4 compatible formatting of doubles} precision \
  4047   4049       {expr 1e306} \
  4048   4050       1e+306
  4049         -test util-16.1.17.307 {8.4 compatible formatting of doubles} \
         4051  +test util-16.1.17.307 {8.4 compatible formatting of doubles} precision \
  4050   4052       {expr 1e307} \
  4051   4053       9.9999999999999999e+306
  4052   4054   
  4053   4055   test util-17.1 {bankers' rounding [Bug 3349507]} {ieeeFloatingPoint} {
  4054   4056       set r {}
  4055   4057       foreach {input} {
  4056   4058   	0x1ffffffffffffc000
................................................................................
  4123   4125       testprint "%I64d %td" 65536
  4124   4126   } {65536 65536}
  4125   4127   
  4126   4128   test util-18.12 {Tcl_ObjPrintf} {testprint} {
  4127   4129       testprint "%I64d %Id" 65537
  4128   4130   } {65537 65537}
  4129   4131   
  4130         -set ::tcl_precision $saved_precision
         4132  +if {[catch {set ::tcl_precision $saved_precision}]} {
         4133  +    unset ::tcl_precision 
         4134  +}
  4131   4135   
  4132   4136   # cleanup
  4133   4137   ::tcltest::cleanupTests
  4134   4138   return
  4135   4139   
  4136   4140   # Local Variables:
  4137   4141   # mode: tcl
  4138   4142   # End:

Changes to tools/uniParse.tcl.

   208    208       set last [expr {[llength $pMap] - 1}]
   209    209       for {set i 0} {$i <= $last} {incr i} {
   210    210   	if {$i == [expr {0x10000 >> $shift}]} {
   211    211   	    set line [string trimright $line " \t,"]
   212    212   	    puts $f $line
   213    213   	    set lastpage [expr {[lindex $line end] >> $shift}]
   214    214   	    puts stdout "lastpage: $lastpage"
   215         -	    puts $f "#if TCL_UTF_MAX > 3"
          215  +	    puts $f "#if TCL_UTF_MAX > 3 || TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6"
   216    216   	    set line "    ,"
   217    217   	}
   218    218   	append line [lindex $pMap $i]
   219    219   	if {$i != $last} {
   220    220   	    append line ", "
   221    221   	}
   222    222   	if {[string length $line] > 70} {
................................................................................
   238    238       set line "    "
   239    239       set lasti [expr {[llength $pages] - 1}]
   240    240       for {set i 0} {$i <= $lasti} {incr i} {
   241    241   	set page [lindex $pages $i]
   242    242   	set lastj [expr {[llength $page] - 1}]
   243    243   	if {$i == ($lastpage + 1)} {
   244    244   	    puts $f [string trimright $line " \t,"]
   245         -	    puts $f "#if TCL_UTF_MAX > 3"
          245  +	    puts $f "#if TCL_UTF_MAX > 3 || TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6"
   246    246   	    set line "    ,"
   247    247   	}
   248    248   	for {set j 0} {$j <= $lastj} {incr j} {
   249    249   	    append line [lindex $page $j]
   250    250   	    if {$j != $lastj || $i != $lasti} {
   251    251   		append line ", "
   252    252   	    }
................................................................................
   338    338   	    puts $f [string trimright $line]
   339    339   	    set line "    "
   340    340   	}
   341    341       }
   342    342       puts $f $line
   343    343       puts -nonewline $f "};
   344    344   
   345         -#if TCL_UTF_MAX > 3
          345  +#if TCL_UTF_MAX > 3 || TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6
   346    346   #   define UNICODE_OUT_OF_RANGE(ch) (((ch) & 0x1fffff) >= [format 0x%x $next])
   347    347   #else
   348    348   #   define UNICODE_OUT_OF_RANGE(ch) (((ch) & 0x1f0000) != 0)
   349    349   #endif
   350    350   
   351    351   /*
   352    352    * The following constants are used to determine the category of a
................................................................................
   397    397   #define GetDelta(info) ((info) >> 8)
   398    398   
   399    399   /*
   400    400    * This macro extracts the information about a character from the
   401    401    * Unicode character tables.
   402    402    */
   403    403   
   404         -#if TCL_UTF_MAX > 3
          404  +#if TCL_UTF_MAX > 3 || TCL_MAJOR_VERSION > 8 || TCL_MINOR_VERSION > 6
   405    405   #   define GetUniCharInfo(ch) (groups\[groupMap\[pageMap\[((ch) & 0x1fffff) >> OFFSET_BITS\] | ((ch) & ((1 << OFFSET_BITS)-1))\]\])
   406    406   #else
   407    407   #   define GetUniCharInfo(ch) (groups\[groupMap\[pageMap\[((ch) & 0xffff) >> OFFSET_BITS\] | ((ch) & ((1 << OFFSET_BITS)-1))\]\])
   408    408   #endif
   409    409   "
   410    410   
   411    411       close $f
   412    412   }
   413    413   
   414    414   uni::main
   415    415   
   416    416   return

Changes to win/tclWinSerial.c.

  2073   2073        */
  2074   2074   
  2075   2075       if (len == 0) {
  2076   2076   	Tcl_DStringAppendElement(dsPtr, "-xchar");
  2077   2077   	Tcl_DStringStartSublist(dsPtr);
  2078   2078       }
  2079   2079       if (len==0 || (len>1 && strncmp(optionName, "-xchar", len) == 0)) {
  2080         -	char buf[TCL_UTF_MAX];
         2080  +	char buf[4];
  2081   2081   	valid = 1;
  2082   2082   
  2083   2083   	if (!GetCommState(infoPtr->handle, &dcb)) {
  2084   2084   	    if (interp != NULL) {
  2085   2085   		TclWinConvertError(GetLastError());
  2086   2086   		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
  2087   2087   			"can't get comm state: %s", Tcl_PosixError(interp)));