Use C enums instead of clusters of #defines

2021-04-17 23:26:50 +00:00
314 changed files with 7203 additions and 28926 deletions
@@ -1,3 +1,3 @@
 Important Note
 ==========
-Please do not file issues with Tcl on Github. They are unlikely to be noticed in a timely fashion. Tcl issues are hosted in the [tcl fossil repository on core.tcl-lang.org](https://core.tcl-lang.org/tcl/tktnew); please post them there.
+Please do not file issues with Tcl on Github. They are unlikely to be noticed in a timely fashion. Tcl issues are hosted in the [tcl fossil repository on core.tcl.tk](https://core.tcl.tk/tcl/tktnew); please post them there.
@@ -1,3 +1,3 @@
 Important Note
 ==========
-Please do not file pull requests with Tcl on Github. They are unlikely to be noticed in a timely fashion. Tcl issues (including patches) are hosted in the [tcl fossil repository on core.tcl-lang.org](https://core.tcl-lang.org/tcl/tktnew); please post them there.
+Please do not file pull requests with Tcl on Github. They are unlikely to be noticed in a timely fashion. Tcl issues (including patches) are hosted in the [tcl fossil repository on core.tcl.tk](https://core.tcl.tk/tcl/tktnew); please post them there.
@@ -2,7 +2,7 @@ name: macOS
 on: [push]
 jobs:
  xcode:
-    runs-on: macos-11
+    runs-on: macos-11.0
    defaults:
      run:
        shell: bash
@@ -24,7 +24,7 @@ jobs:
          ERROR_ON_FAILURES: 1
          MAC_CI: 1
  clang:
-    runs-on: macos-11
+    runs-on: macos-11.0
    strategy:
      matrix:
        cfgopt:
@@ -3,7 +3,7 @@ on: [push]
 jobs:
  linux:
    name: Linux
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-16.04
    defaults:
      run:
        shell: bash
@@ -27,18 +27,18 @@ jobs:
        working-directory: unix
      - name: Package
        run: |
-          cp ../unix/tclsh tclsh${TCL_PATCHLEVEL}_snapshot
-          chmod +x tclsh${TCL_PATCHLEVEL}_snapshot
-          tar -cf tclsh${TCL_PATCHLEVEL}_snapshot.tar tclsh${TCL_PATCHLEVEL}_snapshot
+          cp ../unix/tclsh tclsh${TCL_PATCHLEVEL}_unofficial
+          chmod +x tclsh${TCL_PATCHLEVEL}_unofficial
+          tar -cf tclsh${TCL_PATCHLEVEL}_unofficial.tar tclsh${TCL_PATCHLEVEL}_unofficial
        working-directory: 1dist
      - name: Upload
        uses: actions/upload-artifact@v2
        with:
-          name: Tclsh ${{ env.TCL_PATCHLEVEL }} Linux single-file build (snapshot)
+          name: Tclsh ${{ env.TCL_PATCHLEVEL }} Linux single-file build (unofficial)
          path: 1dist/*.tar
  macos:
    name: macOS
-    runs-on: macos-11
+    runs-on: macos-11.0
    defaults:
      run:
        shell: bash
@@ -74,8 +74,8 @@ jobs:
      - name: Package
        run: |
          mkdir contents
-          cp $TCL_BIN contents/tclsh${TCL_PATCHLEVEL}_snapshot
-          chmod +x contents/tclsh${TCL_PATCHLEVEL}_snapshot
+          cp $TCL_BIN contents/tclsh${TCL_PATCHLEVEL}_unofficial
+          chmod +x contents/tclsh${TCL_PATCHLEVEL}_unofficial
          cat > contents/README.txt <<EOF
          This is a single-file executable developer preview of Tcl $TCL_PATCHLEVEL

@@ -83,38 +83,32 @@ jobs:
          Use strictly at your own risk.

          To run it, you need to copy the executable out and run:
-              xattr -d com.apple.quarantine tclsh${TCL_PATCHLEVEL}_snapshot
+              xattr -d com.apple.quarantine tclsh${TCL_PATCHLEVEL}_unofficial
          to mark the executable as runnable on your machine.
          EOF
          $CREATE_DMG \
-              --volname "Tcl $TCL_PATCHLEVEL (snapshot)" \
+              --volname "Tcl $TCL_PATCHLEVEL (unofficial)" \
              --window-pos 200 120 \
              --window-size 800 400 \
-              "Tcl-$TCL_PATCHLEVEL-(snapshot).dmg" \
+              "Tcl-$TCL_PATCHLEVEL-(unofficial).dmg" \
              "contents/"
        working-directory: 1dist
      - name: Upload
        uses: actions/upload-artifact@v2
        with:
-          name: Tclsh ${{ env.TCL_PATCHLEVEL }} macOS single-file build (snapshot)
+          name: Tclsh ${{ env.TCL_PATCHLEVEL }} macOS single-file build (unofficial)
          path: 1dist/*.dmg
  win:
    name: Windows
    runs-on: windows-latest
    defaults:
      run:
-        shell: msys2 {0}
-    env:
-      CC: gcc
-      CFGOPT: --disable-symbols --disable-shared
+        shell: bash
    steps:
-      - name: Install MSYS2
-        uses: msys2/setup-msys2@v2
-        with:
-          msystem: UCRT64
-          install: git mingw-w64-ucrt-x86_64-toolchain make zip
      - name: Checkout
        uses: actions/checkout@v2
+      - name: Install MSYS2
+        uses: msys2/setup-msys2@v2
      - name: Prepare
        run: |
          touch generic/tclStubInit.c generic/tclOOStubInit.c
@@ -122,7 +116,7 @@ jobs:
          mkdir 1dist
        working-directory: .
      - name: Configure
-        run: ./configure $CFGOPT
+        run: ./configure --disable-symbols --disable-shared --enable-zipfs
        working-directory: win
      - name: Build
        run: |
@@ -135,10 +129,10 @@ jobs:
        working-directory: win
      - name: Set Executable Name
        run: |
-          cp ../win/tclsh*.exe tclsh${TCL_PATCHLEVEL}_snapshot.exe
+          cp ../win/tclsh*.exe tclsh${TCL_PATCHLEVEL}_unofficial.exe
        working-directory: 1dist
      - name: Upload
        uses: actions/upload-artifact@v2
        with:
-          name: Tclsh ${{ env.TCL_PATCHLEVEL }} Windows single-file build (snapshot)
-          path: '1dist/*_snapshot.exe'
+          name: Tclsh ${{ env.TCL_PATCHLEVEL }} Windows single-file build (unofficial)
+          path: '1dist/*_unofficial.exe'
@@ -1,7 +1,5 @@
 name: Windows
 on: [push]
-env:
-  ERROR_ON_FAILURES: 1
 jobs:
  msvc:
    runs-on: windows-latest
@@ -43,12 +41,13 @@ jobs:
             throw "nmake exit code: $lastexitcode"
          }
        env:
+          ERROR_ON_FAILURES: 1
          CI_BUILD_WITH_MSVC: 1
  gcc:
    runs-on: windows-latest
    defaults:
      run:
-        shell: msys2 {0}
+        shell: bash
        working-directory: win
    strategy:
      matrix:
@@ -61,13 +60,10 @@ jobs:
          - "--enable-symbols=mem"
    # Using powershell means we need to explicitly stop on failure
    steps:
-      - name: Install MSYS2
-        uses: msys2/setup-msys2@v2
-        with:
-          msystem: MINGW64
-          install: git mingw-w64-x86_64-toolchain make
      - name: Checkout
        uses: actions/checkout@v2
+      - name: Install MSYS2 and Make
+        run: choco install msys2 make
      - name: Prepare
        run: |
          touch tclStubInit.c tclOOStubInit.c tclOOScript.h
@@ -84,6 +80,8 @@ jobs:
        run: make tcltest
      - name: Run Tests
        run: make test
+        env:
+          ERROR_ON_FAILURES: 1

 # If you add builds with Wine, be sure to define the environment variable
 # CI_USING_WINE when running them so that broken tests know not to run.
@@ -8096,7 +8096,7 @@ a better first place to look now.
 2009-03-25  Jan Nijtmans  <nijtmans@users.sf.net>

 	* doc/tclsh.1:		 Bring doc and tools in line with
-	* tools/installData.tcl: https://wiki.tcl-lang.org/page/exec+magic
+	* tools/installData.tcl: http://wiki.tcl.tk/812
 	* tools/str2c
 	* tools/tcltk-man2html.tcl

@@ -345,7 +345,7 @@
 	* library/clock.tcl: Corrected the regular expressions that match a
 	time zone to allow for time zones specified as +HH or -HH.
 	* tests/clock.test: Added regression test case for the above issue.
-	Thanks to Rolf Ade for reporting this issue [https://wiki.tcl-lang.org/page/Parsing+ISO8601+dates+and+times]
+	Thanks to Rolf Ade for reporting this issue [http://wiki.tcl.tk/13094]
 	* win/tclWinDde.c (Tcl_DdeObjCmd): Corrected a typo that caused a
 	compilation failure on VC++.

@@ -5262,7 +5262,7 @@
 	* generic/tclStrToD.c: Added code to support the "middle endian"
 	floating point format used in the Nokia N770's software-based floating
 	point. Thanks to Bruce Johnson for reporting this bug, originally on
-	https://wiki.tcl-lang.org/page/Nokia+770.
+	http://wiki.tcl.tk/15408.
 	* library/clock.tcl: Fixed a bug with Daylight Saving Time and Posix
 	time zone specifiers reported by Martin Lemburg in
 	http://groups.google.com/group/comp.lang.tcl/browse_thread/thread/9a8b15a4dfc0b7a0
@@ -1,6 +1,6 @@
 # README:  Tcl

-This is the **Tcl 8.7a6** source distribution.
+This is the **Tcl 8.7a4** source distribution.

 You can get any source release of Tcl from [our distribution
 site](https://sourceforge.net/projects/tcl/files/Tcl/).
@@ -45,7 +45,7 @@ and selling it either in whole or in part.  See the file
 ## <a id="doc">2.</a> Documentation
 Extensive documentation is available on our website.
 The home page for this release, including new features, is
-[here](https://www.tcl-lang.org/software/tcltk/8.7.html).
+[here](https://www.tcl.tk/software/tcltk/8.7.html).
 Detailed release notes can be found at the
 [file distributions page](https://sourceforge.net/projects/tcl/files/Tcl/)
 by clicking on the relevant version.
@@ -96,7 +96,7 @@ Tcl Dev Kit builds on the earlier TclPro toolset and provides a debugger,
 static code checker, single-file wrapping utility, bytecode compiler, and
 more.  More information can be found at

-	https://www.activestate.com/products/tcl/
+	http://www.ActiveState.com/Tcl

 ## <a id="complangtcl">5.</a> Tcl newsgroup
 There is a USENET newsgroup, "`comp.lang.tcl`", intended for the exchange of
@@ -8843,7 +8843,7 @@ in this changeset (new minor version) rather than bug fixes:

 2017-09-02 (bug)[0e4d88] replace command, delete trace kills namespace (porter)

--- Released 8.7a1, September 8, 2017 --- https://core.tcl-lang.org/tcl/ for details
+--- Released 8.7a1, September 8, 2017 --- http://core.tcl.tk/tcl/ for details

 2017-08-10 [array names -regexp] supports backrefs (goth)

@@ -8942,7 +8942,7 @@ in this changeset (new minor version) rather than bug fixes:

 2018-11-16 (bug)[00d04c] Repair [binary encode base64] (sebres)

- Released 8.6.9, November 16, 2018 - details at https://core.tcl-lang.org/tcl/ -
+- Released 8.6.9, November 16, 2018 - details at http://core.tcl-lang.org/tcl/ -

 2018-11-22 (bug)[7a9dc5] [file normalize ~/~foo] segfault (sebres)

@@ -8990,7 +8990,7 @@ in this changeset (new minor version) rather than bug fixes:

 2019-11-15 (bug)[135804] segfault in [next] after destroy (coulter,sebres)

- Released 8.6.10, Nov 21, 2019 - details at https://core.tcl-lang.org/tcl/ -
+- Released 8.6.10, Nov 21, 2019 - details at http://core.tcl-lang.org/tcl/ -

 2019-12-03 (bug)[3cd9be] Corner case in surrogate handling (nijtmans)

@@ -9119,7 +9119,7 @@ See RFC 2045

 2020-12-23 tzdata updated to Olson's tzdata2020e (jima)

- Released 8.6.11, Dec 31, 2020 - details at https://core.tcl-lang.org/tcl/ -
+- Released 8.6.11, Dec 31, 2020 - details at http://core.tcl-lang.org/tcl/ -

 Changes to 8.7a3 include all changes to the 8.6 line through 8.6.10,
 plus the following, which focuses on the high-level feature changes
@@ -9228,9 +9228,6 @@ in this changeset (new minor version) rather than bug fixes:

 2019-04-16 [TIP 342] [dict getwithdefault]

-2019-04-23 (bug)[67a5ea] make [chan postevent] asynchronous
-        *** POTENTIAL INCOMPATIBILITY ***
-
 2019-05-25 [TIP 431] [file tempdir]

 2019-05-25 [TIP 383] [coroinject], [coroprobe]
@@ -9257,76 +9254,4 @@ Changes to 8.7a5 include all changes to the 8.6 line through 8.6.11,
 plus the following, which focuses on the high-level feature changes
 in this changeset (new minor version) rather than bug fixes:

-2019-12-13 [TIP 538] Externalize libtommath
-
-2020-01-20 [TIP 542] Support for switchable Full Unicode support
-
-2020-01-21 [TIP 543] Eliminate `TCL_INTERP_DESTROYED` flag value
-
-2020-01-24 [TIP 559] Eliminate public routine `Tcl_FreeResult
-
-2020-01-31 (new) Implement 64-bit seek on Zip channels. (nijtmans)
-
-2020-02-28 [TIP 557] C++ support for Tcl
-
-2020-02-28 [TIP 562] Deprecate channel types 1-4
-
-2020-03-11 (bug)[234d6c] Segfault in [set l {}; lpop l] (sebres)
-
-2020-03-12 (bug) Crash in tests binary-79.[12] (porter)
-
-2020-03-13 [TIP 569] Eliminate Comments That Serve Lint
-
-2020-04-06 (bug)[dd010c] [string trim*] on astral characters (porter,nijtmans)
-
-2020-05-30 [TIP 551] Permit underscore in numerical literals in source code
-
-2020-07-03 [TIP 578] Death to TCL_DBGX
-
-2020-08-11 (bug)[e87000] Win32 crash in [fconfigure stdout] (werner,nijtmans)
-
-2020-09-06 (bug)[c1a376] deletion trace on imported ensemble (coulter)
-
-2020-09-13 [TIP 585] Promote the INDEX_TEMP_TABLE flag of Tcl_GetIndexFromObj*() to the public interface
-
-2020-09-15 (bug)[b5777d] crash in [string index abcd 0-0x10000000000000000]
-
-2020-09-19 [b9ecf3] revised stork mgmt [uplevel [list $cmd ...]] (coulter)
-
-2020-10-23 [TIP 587] Default utf-8 for source command
-
-2020-10-27 (bug)[11229b] test string-31.26.* (porter)
-
-2020-11-08 [TIP 582] Comments in Expressions
-
-2020-11-16 [TIP 586] C String Parsing Support for binary scan
-
-2020-12-07 [TIP 590] Recommend lowercase Package Names
-
-2021-01-06 Bump to tcltest 2.5.4
-
-2021-01-15 [TIP 481] `Tcl_GetStringFromObj()` with `size_t` length parameter
-
-2021-01-15 [TIP 592] End support: Windows XP, Server 2003, Vista, Server 2008
-
-2021-01-25 tzdata updated to Olson's tzdata2021a (nijtmans)
-
-2021-01-29 (bug)[113be1] zipfs on mac
-
-2021-03-15 [TIP 575] Switchable Tcl_UtfCharComplete()/Tcl_UtfNext()/Tcl_UtfPrev()
-
-2021-03-19 (new)[0221b9] Drop TCL_WINDOW_EVENTS from Tcl's [update idletasks]
-
-2021-03-30 (new)[4b4830] [chan truncate] for reflected channels
-
-2021-04-30 [TIP 597] "string is unicode" and better utf-8/utf-16/cesu-8 encodings
-
-2021-04-09 [TIP 598] export TclWinConvertError
-
-2021-05-15 (bug)[463b7a] segfault from Tcl_Unload (coulter)
-
-2021-05-15 (bug)[fb2a41] tclZipfs.c free all memory (coulter)
-
-2021-05-18 (bug)[688fcc,28027d] namespace teardown reform (coulter)
-
- Released 8.7a5, Jun 18, 2021 --- http://core.tcl-lang.org/tcl/ for details -
+- Released 8.7a5, Jan 21, 2021 --- http://core.tcl-lang.org/tcl/ for details -
@@ -1,186 +1,186 @@
-/* inffas8664.c is a hand tuned assembler version of inffast.c - fast decoding
- * version for AMD64 on Windows using Microsoft C compiler
- *
- * Copyright (C) 1995-2003 Mark Adler
- * For conditions of distribution and use, see copyright notice in zlib.h
- *
- * Copyright (C) 2003 Chris Anderson <christop@charm.net>
- * Please use the copyright conditions above.
- *
- * 2005 - Adaptation to Microsoft C Compiler for AMD64 by Gilles Vollant
- *
- * inffas8664.c call function inffas8664fnc in inffasx64.asm
- *  inffasx64.asm is automatically convert from AMD64 portion of inffas86.c
- *
- * Dec-29-2003 -- I added AMD64 inflate asm support.  This version is also
- * slightly quicker on x86 systems because, instead of using rep movsb to copy
- * data, it uses rep movsw, which moves data in 2-byte chunks instead of single
- * bytes.  I've tested the AMD64 code on a Fedora Core 1 + the x86_64 updates
- * from http://fedora.linux.duke.edu/fc1_x86_64
- * which is running on an Athlon 64 3000+ / Gigabyte GA-K8VT800M system with
- * 1GB ram.  The 64-bit version is about 4% faster than the 32-bit version,
- * when decompressing mozilla-source-1.3.tar.gz.
- *
- * Mar-13-2003 -- Most of this is derived from inffast.S which is derived from
- * the gcc -S output of zlib-1.2.0/inffast.c.  Zlib-1.2.0 is in beta release at
- * the moment.  I have successfully compiled and tested this code with gcc2.96,
- * gcc3.2, icc5.0, msvc6.0.  It is very close to the speed of inffast.S
- * compiled with gcc -DNO_MMX, but inffast.S is still faster on the P3 with MMX
- * enabled.  I will attempt to merge the MMX code into this version.  Newer
- * versions of this and inffast.S can be found at
- * http://www.eetbeetee.com/zlib/ and http://www.charm.net/~christop/zlib/
- *
- */
-
-#include <stdio.h>
-#include "zutil.h"
-#include "inftrees.h"
-#include "inflate.h"
-#include "inffast.h"
-
-/* Mark Adler's comments from inffast.c: */
-
-/*
-   Decode literal, length, and distance codes and write out the resulting
-   literal and match bytes until either not enough input or output is
-   available, an end-of-block is encountered, or a data error is encountered.
-   When large enough input and output buffers are supplied to inflate(), for
-   example, a 16K input buffer and a 64K output buffer, more than 95% of the
-   inflate execution time is spent in this routine.
-
-   Entry assumptions:
-
-        state->mode == LEN
-        strm->avail_in >= 6
-        strm->avail_out >= 258
-        start >= strm->avail_out
-        state->bits < 8
-
-   On return, state->mode is one of:
-
-        LEN -- ran out of enough output space or enough available input
-        TYPE -- reached end of block code, inflate() to interpret next block
-        BAD -- error in block data
-
-   Notes:
-
-    - The maximum input bits used by a length/distance pair is 15 bits for the
-      length code, 5 bits for the length extra, 15 bits for the distance code,
-      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
-      Therefore if strm->avail_in >= 6, then there is enough input to avoid
-      checking for available input while decoding.
-
-    - The maximum bytes that a single length/distance pair can output is 258
-      bytes, which is the maximum length that can be coded.  inflate_fast()
-      requires strm->avail_out >= 258 for each loop to avoid checking for
-      output space.
- */
-
-
-
-    typedef struct inffast_ar {
-/* 64   32                               x86  x86_64 */
-/* ar offset                              register */
-/*  0    0 */ void *esp;                /* esp save */
-/*  8    4 */ void *ebp;                /* ebp save */
-/* 16    8 */ unsigned char FAR *in;    /* esi rsi  local strm->next_in */
-/* 24   12 */ unsigned char FAR *last;  /*     r9   while in < last */
-/* 32   16 */ unsigned char FAR *out;   /* edi rdi  local strm->next_out */
-/* 40   20 */ unsigned char FAR *beg;   /*          inflate()'s init next_out */
-/* 48   24 */ unsigned char FAR *end;   /*     r10  while out < end */
-/* 56   28 */ unsigned char FAR *window;/*          size of window, wsize!=0 */
-/* 64   32 */ code const FAR *lcode;    /* ebp rbp  local strm->lencode */
-/* 72   36 */ code const FAR *dcode;    /*     r11  local strm->distcode */
-/* 80   40 */ size_t /*unsigned long */hold;       /* edx rdx  local strm->hold */
-/* 88   44 */ unsigned bits;            /* ebx rbx  local strm->bits */
-/* 92   48 */ unsigned wsize;           /*          window size */
-/* 96   52 */ unsigned write;           /*          window write index */
-/*100   56 */ unsigned lmask;           /*     r12  mask for lcode */
-/*104   60 */ unsigned dmask;           /*     r13  mask for dcode */
-/*108   64 */ unsigned len;             /*     r14  match length */
-/*112   68 */ unsigned dist;            /*     r15  match distance */
-/*116   72 */ unsigned status;          /*          set when state chng*/
-    } type_ar;
-#ifdef ASMINF
-
-void inflate_fast(strm, start)
-z_streamp strm;
-unsigned start;         /* inflate()'s starting value for strm->avail_out */
-{
-    struct inflate_state FAR *state;
-    type_ar ar;
-    void inffas8664fnc(struct inffast_ar * par);
-
-
-
-#if (defined( __GNUC__ ) && defined( __amd64__ ) && ! defined( __i386 )) || (defined(_MSC_VER) && defined(_M_AMD64))
-#define PAD_AVAIL_IN 6
-#define PAD_AVAIL_OUT 258
-#else
-#define PAD_AVAIL_IN 5
-#define PAD_AVAIL_OUT 257
-#endif
-
-    /* copy state to local variables */
-    state = (struct inflate_state FAR *)strm->state;
-
-    ar.in = strm->next_in;
-    ar.last = ar.in + (strm->avail_in - PAD_AVAIL_IN);
-    ar.out = strm->next_out;
-    ar.beg = ar.out - (start - strm->avail_out);
-    ar.end = ar.out + (strm->avail_out - PAD_AVAIL_OUT);
-    ar.wsize = state->wsize;
-    ar.write = state->wnext;
-    ar.window = state->window;
-    ar.hold = state->hold;
-    ar.bits = state->bits;
-    ar.lcode = state->lencode;
-    ar.dcode = state->distcode;
-    ar.lmask = (1U << state->lenbits) - 1;
-    ar.dmask = (1U << state->distbits) - 1;
-
-    /* decode literals and length/distances until end-of-block or not enough
-       input data or output space */
-
-    /* align in on 1/2 hold size boundary */
-    while (((size_t)(void *)ar.in & (sizeof(ar.hold) / 2 - 1)) != 0) {
-        ar.hold += (unsigned long)*ar.in++ << ar.bits;
-        ar.bits += 8;
-    }
-
-    inffas8664fnc(&ar);
-
-    if (ar.status > 1) {
-        if (ar.status == 2)
-            strm->msg = "invalid literal/length code";
-        else if (ar.status == 3)
-            strm->msg = "invalid distance code";
-        else
-            strm->msg = "invalid distance too far back";
-        state->mode = BAD;
-    }
-    else if ( ar.status == 1 ) {
-        state->mode = TYPE;
-    }
-
-    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
-    ar.len = ar.bits >> 3;
-    ar.in -= ar.len;
-    ar.bits -= ar.len << 3;
-    ar.hold &= (1U << ar.bits) - 1;
-
-    /* update state and return */
-    strm->next_in = ar.in;
-    strm->next_out = ar.out;
-    strm->avail_in = (unsigned)(ar.in < ar.last ?
-                                PAD_AVAIL_IN + (ar.last - ar.in) :
-                                PAD_AVAIL_IN - (ar.in - ar.last));
-    strm->avail_out = (unsigned)(ar.out < ar.end ?
-                                 PAD_AVAIL_OUT + (ar.end - ar.out) :
-                                 PAD_AVAIL_OUT - (ar.out - ar.end));
-    state->hold = (unsigned long)ar.hold;
-    state->bits = ar.bits;
-    return;
-}
-
-#endif
+/* inffas8664.c is a hand tuned assembler version of inffast.c - fast decoding
+ * version for AMD64 on Windows using Microsoft C compiler
+ *
+ * Copyright (C) 1995-2003 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Copyright (C) 2003 Chris Anderson <christop@charm.net>
+ * Please use the copyright conditions above.
+ *
+ * 2005 - Adaptation to Microsoft C Compiler for AMD64 by Gilles Vollant
+ *
+ * inffas8664.c call function inffas8664fnc in inffasx64.asm
+ *  inffasx64.asm is automatically convert from AMD64 portion of inffas86.c
+ *
+ * Dec-29-2003 -- I added AMD64 inflate asm support.  This version is also
+ * slightly quicker on x86 systems because, instead of using rep movsb to copy
+ * data, it uses rep movsw, which moves data in 2-byte chunks instead of single
+ * bytes.  I've tested the AMD64 code on a Fedora Core 1 + the x86_64 updates
+ * from http://fedora.linux.duke.edu/fc1_x86_64
+ * which is running on an Athlon 64 3000+ / Gigabyte GA-K8VT800M system with
+ * 1GB ram.  The 64-bit version is about 4% faster than the 32-bit version,
+ * when decompressing mozilla-source-1.3.tar.gz.
+ *
+ * Mar-13-2003 -- Most of this is derived from inffast.S which is derived from
+ * the gcc -S output of zlib-1.2.0/inffast.c.  Zlib-1.2.0 is in beta release at
+ * the moment.  I have successfully compiled and tested this code with gcc2.96,
+ * gcc3.2, icc5.0, msvc6.0.  It is very close to the speed of inffast.S
+ * compiled with gcc -DNO_MMX, but inffast.S is still faster on the P3 with MMX
+ * enabled.  I will attempt to merge the MMX code into this version.  Newer
+ * versions of this and inffast.S can be found at
+ * http://www.eetbeetee.com/zlib/ and http://www.charm.net/~christop/zlib/
+ *
+ */
+
+#include <stdio.h>
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+/* Mark Adler's comments from inffast.c: */
+
+/*
+   Decode literal, length, and distance codes and write out the resulting
+   literal and match bytes until either not enough input or output is
+   available, an end-of-block is encountered, or a data error is encountered.
+   When large enough input and output buffers are supplied to inflate(), for
+   example, a 16K input buffer and a 64K output buffer, more than 95% of the
+   inflate execution time is spent in this routine.
+
+   Entry assumptions:
+
+        state->mode == LEN
+        strm->avail_in >= 6
+        strm->avail_out >= 258
+        start >= strm->avail_out
+        state->bits < 8
+
+   On return, state->mode is one of:
+
+        LEN -- ran out of enough output space or enough available input
+        TYPE -- reached end of block code, inflate() to interpret next block
+        BAD -- error in block data
+
+   Notes:
+
+    - The maximum input bits used by a length/distance pair is 15 bits for the
+      length code, 5 bits for the length extra, 15 bits for the distance code,
+      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
+      Therefore if strm->avail_in >= 6, then there is enough input to avoid
+      checking for available input while decoding.
+
+    - The maximum bytes that a single length/distance pair can output is 258
+      bytes, which is the maximum length that can be coded.  inflate_fast()
+      requires strm->avail_out >= 258 for each loop to avoid checking for
+      output space.
+ */
+
+
+
+    typedef struct inffast_ar {
+/* 64   32                               x86  x86_64 */
+/* ar offset                              register */
+/*  0    0 */ void *esp;                /* esp save */
+/*  8    4 */ void *ebp;                /* ebp save */
+/* 16    8 */ unsigned char FAR *in;    /* esi rsi  local strm->next_in */
+/* 24   12 */ unsigned char FAR *last;  /*     r9   while in < last */
+/* 32   16 */ unsigned char FAR *out;   /* edi rdi  local strm->next_out */
+/* 40   20 */ unsigned char FAR *beg;   /*          inflate()'s init next_out */
+/* 48   24 */ unsigned char FAR *end;   /*     r10  while out < end */
+/* 56   28 */ unsigned char FAR *window;/*          size of window, wsize!=0 */
+/* 64   32 */ code const FAR *lcode;    /* ebp rbp  local strm->lencode */
+/* 72   36 */ code const FAR *dcode;    /*     r11  local strm->distcode */
+/* 80   40 */ size_t /*unsigned long */hold;       /* edx rdx  local strm->hold */
+/* 88   44 */ unsigned bits;            /* ebx rbx  local strm->bits */
+/* 92   48 */ unsigned wsize;           /*          window size */
+/* 96   52 */ unsigned write;           /*          window write index */
+/*100   56 */ unsigned lmask;           /*     r12  mask for lcode */
+/*104   60 */ unsigned dmask;           /*     r13  mask for dcode */
+/*108   64 */ unsigned len;             /*     r14  match length */
+/*112   68 */ unsigned dist;            /*     r15  match distance */
+/*116   72 */ unsigned status;          /*          set when state chng*/
+    } type_ar;
+#ifdef ASMINF
+
+void inflate_fast(strm, start)
+z_streamp strm;
+unsigned start;         /* inflate()'s starting value for strm->avail_out */
+{
+    struct inflate_state FAR *state;
+    type_ar ar;
+    void inffas8664fnc(struct inffast_ar * par);
+
+
+
+#if (defined( __GNUC__ ) && defined( __amd64__ ) && ! defined( __i386 )) || (defined(_MSC_VER) && defined(_M_AMD64))
+#define PAD_AVAIL_IN 6
+#define PAD_AVAIL_OUT 258
+#else
+#define PAD_AVAIL_IN 5
+#define PAD_AVAIL_OUT 257
+#endif
+
+    /* copy state to local variables */
+    state = (struct inflate_state FAR *)strm->state;
+
+    ar.in = strm->next_in;
+    ar.last = ar.in + (strm->avail_in - PAD_AVAIL_IN);
+    ar.out = strm->next_out;
+    ar.beg = ar.out - (start - strm->avail_out);
+    ar.end = ar.out + (strm->avail_out - PAD_AVAIL_OUT);
+    ar.wsize = state->wsize;
+    ar.write = state->wnext;
+    ar.window = state->window;
+    ar.hold = state->hold;
+    ar.bits = state->bits;
+    ar.lcode = state->lencode;
+    ar.dcode = state->distcode;
+    ar.lmask = (1U << state->lenbits) - 1;
+    ar.dmask = (1U << state->distbits) - 1;
+
+    /* decode literals and length/distances until end-of-block or not enough
+       input data or output space */
+
+    /* align in on 1/2 hold size boundary */
+    while (((size_t)(void *)ar.in & (sizeof(ar.hold) / 2 - 1)) != 0) {
+        ar.hold += (unsigned long)*ar.in++ << ar.bits;
+        ar.bits += 8;
+    }
+
+    inffas8664fnc(&ar);
+
+    if (ar.status > 1) {
+        if (ar.status == 2)
+            strm->msg = "invalid literal/length code";
+        else if (ar.status == 3)
+            strm->msg = "invalid distance code";
+        else
+            strm->msg = "invalid distance too far back";
+        state->mode = BAD;
+    }
+    else if ( ar.status == 1 ) {
+        state->mode = TYPE;
+    }
+
+    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
+    ar.len = ar.bits >> 3;
+    ar.in -= ar.len;
+    ar.bits -= ar.len << 3;
+    ar.hold &= (1U << ar.bits) - 1;
+
+    /* update state and return */
+    strm->next_in = ar.in;
+    strm->next_out = ar.out;
+    strm->avail_in = (unsigned)(ar.in < ar.last ?
+                                PAD_AVAIL_IN + (ar.last - ar.in) :
+                                PAD_AVAIL_IN - (ar.in - ar.last));
+    strm->avail_out = (unsigned)(ar.out < ar.end ?
+                                 PAD_AVAIL_OUT + (ar.end - ar.out) :
+                                 PAD_AVAIL_OUT - (ar.out - ar.end));
+    state->hold = (unsigned long)ar.hold;
+    state->bits = ar.bits;
+    return;
+}
+
+#endif
@@ -1,275 +1,275 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <windows.h>
-
-#include "zlib.h"
-
-
-void MyDoMinus64(LARGE_INTEGER *R,LARGE_INTEGER A,LARGE_INTEGER B)
-{
-    R->HighPart = A.HighPart - B.HighPart;
-    if (A.LowPart >= B.LowPart)
-        R->LowPart = A.LowPart - B.LowPart;
-    else
-    {
-        R->LowPart = A.LowPart - B.LowPart;
-        R->HighPart --;
-    }
-}
-
-#ifdef _M_X64
-// see http://msdn2.microsoft.com/library/twchhe95(en-us,vs.80).aspx for __rdtsc
-unsigned __int64 __rdtsc(void);
-void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
-{
- //   printf("rdtsc = %I64x\n",__rdtsc());
-   pbeginTime64->QuadPart=__rdtsc();
-}
-
-LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
-{
-    LARGE_INTEGER LIres;
-    unsigned _int64 res=__rdtsc()-((unsigned _int64)(beginTime64.QuadPart));
-    LIres.QuadPart=res;
-   // printf("rdtsc = %I64x\n",__rdtsc());
-    return LIres;
-}
-#else
-#ifdef _M_IX86
-void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
-{
-    DWORD dwEdx,dwEax;
-    _asm
-    {
-        rdtsc
-        mov dwEax,eax
-        mov dwEdx,edx
-    }
-    pbeginTime64->LowPart=dwEax;
-    pbeginTime64->HighPart=dwEdx;
-}
-
-void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
-{
-    myGetRDTSC32(pbeginTime64);
-}
-
-LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
-{
-    LARGE_INTEGER LIres,endTime64;
-    myGetRDTSC32(&endTime64);
-
-    LIres.LowPart=LIres.HighPart=0;
-    MyDoMinus64(&LIres,endTime64,beginTime64);
-    return LIres;
-}
-#else
-void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
-{
-}
-
-void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
-{
-}
-
-LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
-{
-    LARGE_INTEGER lr;
-    lr.QuadPart=0;
-    return lr;
-}
-#endif
-#endif
-
-void BeginCountPerfCounter(LARGE_INTEGER * pbeginTime64,BOOL fComputeTimeQueryPerf)
-{
-    if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(pbeginTime64)))
-    {
-        pbeginTime64->LowPart = GetTickCount();
-        pbeginTime64->HighPart = 0;
-    }
-}
-
-DWORD GetMsecSincePerfCounter(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
-{
-    LARGE_INTEGER endTime64,ticksPerSecond,ticks;
-    DWORDLONG ticksShifted,tickSecShifted;
-    DWORD dwLog=16+0;
-    DWORD dwRet;
-    if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(&endTime64)))
-        dwRet = (GetTickCount() - beginTime64.LowPart)*1;
-    else
-    {
-        MyDoMinus64(&ticks,endTime64,beginTime64);
-        QueryPerformanceFrequency(&ticksPerSecond);
-
-
-        {
-            ticksShifted = Int64ShrlMod32(*(DWORDLONG*)&ticks,dwLog);
-            tickSecShifted = Int64ShrlMod32(*(DWORDLONG*)&ticksPerSecond,dwLog);
-
-        }
-
-        dwRet = (DWORD)((((DWORD)ticksShifted)*1000)/(DWORD)(tickSecShifted));
-        dwRet *=1;
-    }
-    return dwRet;
-}
-
-int ReadFileMemory(const char* filename,long* plFileSize,unsigned char** pFilePtr)
-{
-    FILE* stream;
-    unsigned char* ptr;
-    int retVal=1;
-    stream=fopen(filename, "rb");
-    if (stream==NULL)
-        return 0;
-
-    fseek(stream,0,SEEK_END);
-
-    *plFileSize=ftell(stream);
-    fseek(stream,0,SEEK_SET);
-    ptr=malloc((*plFileSize)+1);
-    if (ptr==NULL)
-        retVal=0;
-    else
-    {
-        if (fread(ptr, 1, *plFileSize,stream) != (*plFileSize))
-            retVal=0;
-    }
-    fclose(stream);
-    *pFilePtr=ptr;
-    return retVal;
-}
-
-int main(int argc, char *argv[])
-{
-    int BlockSizeCompress=0x8000;
-    int BlockSizeUncompress=0x8000;
-    int cprLevel=Z_DEFAULT_COMPRESSION ;
-    long lFileSize;
-    unsigned char* FilePtr;
-    long lBufferSizeCpr;
-    long lBufferSizeUncpr;
-    long lCompressedSize=0;
-    unsigned char* CprPtr;
-    unsigned char* UncprPtr;
-    long lSizeCpr,lSizeUncpr;
-    DWORD dwGetTick,dwMsecQP;
-    LARGE_INTEGER li_qp,li_rdtsc,dwResRdtsc;
-
-    if (argc<=1)
-    {
-        printf("run TestZlib <File> [BlockSizeCompress] [BlockSizeUncompress] [compres. level]\n");
-        return 0;
-    }
-
-    if (ReadFileMemory(argv[1],&lFileSize,&FilePtr)==0)
-    {
-        printf("error reading %s\n",argv[1]);
-        return 1;
-    }
-    else printf("file %s read, %u bytes\n",argv[1],lFileSize);
-
-    if (argc>=3)
-        BlockSizeCompress=atol(argv[2]);
-
-    if (argc>=4)
-        BlockSizeUncompress=atol(argv[3]);
-
-    if (argc>=5)
-        cprLevel=(int)atol(argv[4]);
-
-    lBufferSizeCpr = lFileSize + (lFileSize/0x10) + 0x200;
-    lBufferSizeUncpr = lBufferSizeCpr;
-
-    CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress);
-
-    BeginCountPerfCounter(&li_qp,TRUE);
-    dwGetTick=GetTickCount();
-    BeginCountRdtsc(&li_rdtsc);
-    {
-        z_stream zcpr;
-        int ret=Z_OK;
-        long lOrigToDo = lFileSize;
-        long lOrigDone = 0;
-        int step=0;
-        memset(&zcpr,0,sizeof(z_stream));
-        deflateInit(&zcpr,cprLevel);
-
-        zcpr.next_in = FilePtr;
-        zcpr.next_out = CprPtr;
-
-
-        do
-        {
-            long all_read_before = zcpr.total_in;
-            zcpr.avail_in = min(lOrigToDo,BlockSizeCompress);
-            zcpr.avail_out = BlockSizeCompress;
-            ret=deflate(&zcpr,(zcpr.avail_in==lOrigToDo) ? Z_FINISH : Z_SYNC_FLUSH);
-            lOrigDone += (zcpr.total_in-all_read_before);
-            lOrigToDo -= (zcpr.total_in-all_read_before);
-            step++;
-        } while (ret==Z_OK);
-
-        lSizeCpr=zcpr.total_out;
-        deflateEnd(&zcpr);
-        dwGetTick=GetTickCount()-dwGetTick;
-        dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
-        dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
-        printf("total compress size = %u, in %u step\n",lSizeCpr,step);
-        printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
-        printf("defcpr time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
-        printf("defcpr result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
-    }
-
-    CprPtr=(unsigned char*)realloc(CprPtr,lSizeCpr);
-    UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress);
-
-    BeginCountPerfCounter(&li_qp,TRUE);
-    dwGetTick=GetTickCount();
-    BeginCountRdtsc(&li_rdtsc);
-    {
-        z_stream zcpr;
-        int ret=Z_OK;
-        long lOrigToDo = lSizeCpr;
-        long lOrigDone = 0;
-        int step=0;
-        memset(&zcpr,0,sizeof(z_stream));
-        inflateInit(&zcpr);
-
-        zcpr.next_in = CprPtr;
-        zcpr.next_out = UncprPtr;
-
-
-        do
-        {
-            long all_read_before = zcpr.total_in;
-            zcpr.avail_in = min(lOrigToDo,BlockSizeUncompress);
-            zcpr.avail_out = BlockSizeUncompress;
-            ret=inflate(&zcpr,Z_SYNC_FLUSH);
-            lOrigDone += (zcpr.total_in-all_read_before);
-            lOrigToDo -= (zcpr.total_in-all_read_before);
-            step++;
-        } while (ret==Z_OK);
-
-        lSizeUncpr=zcpr.total_out;
-        inflateEnd(&zcpr);
-        dwGetTick=GetTickCount()-dwGetTick;
-        dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
-        dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
-        printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step);
-        printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
-        printf("uncpr  time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
-        printf("uncpr  result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
-    }
-
-    if (lSizeUncpr==lFileSize)
-    {
-        if (memcmp(FilePtr,UncprPtr,lFileSize)==0)
-            printf("compare ok\n");
-
-    }
-
-    return 0;
-}
+#include <stdio.h>
+#include <stdlib.h>
+#include <windows.h>
+
+#include "zlib.h"
+
+
+void MyDoMinus64(LARGE_INTEGER *R,LARGE_INTEGER A,LARGE_INTEGER B)
+{
+    R->HighPart = A.HighPart - B.HighPart;
+    if (A.LowPart >= B.LowPart)
+        R->LowPart = A.LowPart - B.LowPart;
+    else
+    {
+        R->LowPart = A.LowPart - B.LowPart;
+        R->HighPart --;
+    }
+}
+
+#ifdef _M_X64
+// see http://msdn2.microsoft.com/library/twchhe95(en-us,vs.80).aspx for __rdtsc
+unsigned __int64 __rdtsc(void);
+void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
+{
+ //   printf("rdtsc = %I64x\n",__rdtsc());
+   pbeginTime64->QuadPart=__rdtsc();
+}
+
+LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
+{
+    LARGE_INTEGER LIres;
+    unsigned _int64 res=__rdtsc()-((unsigned _int64)(beginTime64.QuadPart));
+    LIres.QuadPart=res;
+   // printf("rdtsc = %I64x\n",__rdtsc());
+    return LIres;
+}
+#else
+#ifdef _M_IX86
+void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
+{
+    DWORD dwEdx,dwEax;
+    _asm
+    {
+        rdtsc
+        mov dwEax,eax
+        mov dwEdx,edx
+    }
+    pbeginTime64->LowPart=dwEax;
+    pbeginTime64->HighPart=dwEdx;
+}
+
+void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
+{
+    myGetRDTSC32(pbeginTime64);
+}
+
+LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
+{
+    LARGE_INTEGER LIres,endTime64;
+    myGetRDTSC32(&endTime64);
+
+    LIres.LowPart=LIres.HighPart=0;
+    MyDoMinus64(&LIres,endTime64,beginTime64);
+    return LIres;
+}
+#else
+void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
+{
+}
+
+void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
+{
+}
+
+LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
+{
+    LARGE_INTEGER lr;
+    lr.QuadPart=0;
+    return lr;
+}
+#endif
+#endif
+
+void BeginCountPerfCounter(LARGE_INTEGER * pbeginTime64,BOOL fComputeTimeQueryPerf)
+{
+    if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(pbeginTime64)))
+    {
+        pbeginTime64->LowPart = GetTickCount();
+        pbeginTime64->HighPart = 0;
+    }
+}
+
+DWORD GetMsecSincePerfCounter(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
+{
+    LARGE_INTEGER endTime64,ticksPerSecond,ticks;
+    DWORDLONG ticksShifted,tickSecShifted;
+    DWORD dwLog=16+0;
+    DWORD dwRet;
+    if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(&endTime64)))
+        dwRet = (GetTickCount() - beginTime64.LowPart)*1;
+    else
+    {
+        MyDoMinus64(&ticks,endTime64,beginTime64);
+        QueryPerformanceFrequency(&ticksPerSecond);
+
+
+        {
+            ticksShifted = Int64ShrlMod32(*(DWORDLONG*)&ticks,dwLog);
+            tickSecShifted = Int64ShrlMod32(*(DWORDLONG*)&ticksPerSecond,dwLog);
+
+        }
+
+        dwRet = (DWORD)((((DWORD)ticksShifted)*1000)/(DWORD)(tickSecShifted));
+        dwRet *=1;
+    }
+    return dwRet;
+}
+
+int ReadFileMemory(const char* filename,long* plFileSize,unsigned char** pFilePtr)
+{
+    FILE* stream;
+    unsigned char* ptr;
+    int retVal=1;
+    stream=fopen(filename, "rb");
+    if (stream==NULL)
+        return 0;
+
+    fseek(stream,0,SEEK_END);
+
+    *plFileSize=ftell(stream);
+    fseek(stream,0,SEEK_SET);
+    ptr=malloc((*plFileSize)+1);
+    if (ptr==NULL)
+        retVal=0;
+    else
+    {
+        if (fread(ptr, 1, *plFileSize,stream) != (*plFileSize))
+            retVal=0;
+    }
+    fclose(stream);
+    *pFilePtr=ptr;
+    return retVal;
+}
+
+int main(int argc, char *argv[])
+{
+    int BlockSizeCompress=0x8000;
+    int BlockSizeUncompress=0x8000;
+    int cprLevel=Z_DEFAULT_COMPRESSION ;
+    long lFileSize;
+    unsigned char* FilePtr;
+    long lBufferSizeCpr;
+    long lBufferSizeUncpr;
+    long lCompressedSize=0;
+    unsigned char* CprPtr;
+    unsigned char* UncprPtr;
+    long lSizeCpr,lSizeUncpr;
+    DWORD dwGetTick,dwMsecQP;
+    LARGE_INTEGER li_qp,li_rdtsc,dwResRdtsc;
+
+    if (argc<=1)
+    {
+        printf("run TestZlib <File> [BlockSizeCompress] [BlockSizeUncompress] [compres. level]\n");
+        return 0;
+    }
+
+    if (ReadFileMemory(argv[1],&lFileSize,&FilePtr)==0)
+    {
+        printf("error reading %s\n",argv[1]);
+        return 1;
+    }
+    else printf("file %s read, %u bytes\n",argv[1],lFileSize);
+
+    if (argc>=3)
+        BlockSizeCompress=atol(argv[2]);
+
+    if (argc>=4)
+        BlockSizeUncompress=atol(argv[3]);
+
+    if (argc>=5)
+        cprLevel=(int)atol(argv[4]);
+
+    lBufferSizeCpr = lFileSize + (lFileSize/0x10) + 0x200;
+    lBufferSizeUncpr = lBufferSizeCpr;
+
+    CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress);
+
+    BeginCountPerfCounter(&li_qp,TRUE);
+    dwGetTick=GetTickCount();
+    BeginCountRdtsc(&li_rdtsc);
+    {
+        z_stream zcpr;
+        int ret=Z_OK;
+        long lOrigToDo = lFileSize;
+        long lOrigDone = 0;
+        int step=0;
+        memset(&zcpr,0,sizeof(z_stream));
+        deflateInit(&zcpr,cprLevel);
+
+        zcpr.next_in = FilePtr;
+        zcpr.next_out = CprPtr;
+
+
+        do
+        {
+            long all_read_before = zcpr.total_in;
+            zcpr.avail_in = min(lOrigToDo,BlockSizeCompress);
+            zcpr.avail_out = BlockSizeCompress;
+            ret=deflate(&zcpr,(zcpr.avail_in==lOrigToDo) ? Z_FINISH : Z_SYNC_FLUSH);
+            lOrigDone += (zcpr.total_in-all_read_before);
+            lOrigToDo -= (zcpr.total_in-all_read_before);
+            step++;
+        } while (ret==Z_OK);
+
+        lSizeCpr=zcpr.total_out;
+        deflateEnd(&zcpr);
+        dwGetTick=GetTickCount()-dwGetTick;
+        dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
+        dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
+        printf("total compress size = %u, in %u step\n",lSizeCpr,step);
+        printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
+        printf("defcpr time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
+        printf("defcpr result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
+    }
+
+    CprPtr=(unsigned char*)realloc(CprPtr,lSizeCpr);
+    UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress);
+
+    BeginCountPerfCounter(&li_qp,TRUE);
+    dwGetTick=GetTickCount();
+    BeginCountRdtsc(&li_rdtsc);
+    {
+        z_stream zcpr;
+        int ret=Z_OK;
+        long lOrigToDo = lSizeCpr;
+        long lOrigDone = 0;
+        int step=0;
+        memset(&zcpr,0,sizeof(z_stream));
+        inflateInit(&zcpr);
+
+        zcpr.next_in = CprPtr;
+        zcpr.next_out = UncprPtr;
+
+
+        do
+        {
+            long all_read_before = zcpr.total_in;
+            zcpr.avail_in = min(lOrigToDo,BlockSizeUncompress);
+            zcpr.avail_out = BlockSizeUncompress;
+            ret=inflate(&zcpr,Z_SYNC_FLUSH);
+            lOrigDone += (zcpr.total_in-all_read_before);
+            lOrigToDo -= (zcpr.total_in-all_read_before);
+            step++;
+        } while (ret==Z_OK);
+
+        lSizeUncpr=zcpr.total_out;
+        inflateEnd(&zcpr);
+        dwGetTick=GetTickCount()-dwGetTick;
+        dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
+        dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
+        printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step);
+        printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
+        printf("uncpr  time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
+        printf("uncpr  result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
+    }
+
+    if (lSizeUncpr==lFileSize)
+    {
+        if (memcmp(FilePtr,UncprPtr,lFileSize)==0)
+            printf("compare ok\n");
+
+    }
+
+    return 0;
+}
@@ -20,7 +20,7 @@ int
 \fBTcl_Stat\fR(\fIpath\fR, \fIstatPtr\fR)
 .SH ARGUMENTS
 .AS "struct stat" *statPtr out
-.AP "const char" *path in
+.AP char *path in
 Native name of the file to check the attributes of.
 .AP int mode in
 Mask consisting of one or more of \fBR_OK\fR, \fBW_OK\fR, \fBX_OK\fR and
@@ -49,7 +49,7 @@ Interpreter in which to record information.
 The code returned from script evaluation.
 .AP Tcl_Obj *options
 A dictionary of return options.
-.AP "const char" *message in
+.AP char *message in
 For \fBTcl_AddErrorInfo\fR,
 this is a conventional C string to append to the \fB\-errorinfo\fR return option.
 For \fBTcl_AddObjErrorInfo\fR,
@@ -66,7 +66,7 @@ appending to the \fB\-errorinfo\fR return option.
 If negative, all bytes up to the first null byte are used.
 .AP Tcl_Obj *errorObjPtr in
 The \fB\-errorcode\fR return option will be set to this value.
-.AP "const char" *element in
+.AP char *element in
 String to record as one element of the \fB\-errorcode\fR return option.
 Last \fIelement\fR argument must be NULL.
 .AP va_list argList in
@@ -308,22 +308,6 @@ The global variables \fBerrorInfo\fR and
 \fBerrorCode\fR are not modified by \fBTcl_ResetResult\fR
 so they continue to hold a record of information about the
 most recent error seen in an interpreter.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The result of \fBTcl_GetReturnOptions\fR will have at least one
-reference to it from the Tcl interpreter. If not using it immediately,
-you should use \fBTcl_IncrRefCount\fR to add your own reference.
-.PP
-The \fIoptions\fR argument to \fBTcl_SetReturnOptions\fR will have a
-reference added by the Tcl interpreter; it may safely be called with a
-zero-reference value.
-.PP
-\fBTcl_AppendObjToErrorInfo\fR only reads its \fIobjPtr\fR argument;
-it does not modify its reference count at all.
-.PP
-The \fIerrorObjPtr\fR argument to \fBTcl_SetObjErrorCode\fR will have a
-reference added by the Tcl interpreter; it may safely be called with a
-zero-reference value.
 .SH "SEE ALSO"
 Tcl_DecrRefCount(3), Tcl_IncrRefCount(3), Tcl_Interp(3), Tcl_ResetResult(3),
 Tcl_SetErrno(3), errorCode(n), errorInfo(n)
@@ -9,7 +9,7 @@
 .so man.macros
 .BS
 .SH NAME
-Tcl_AsyncCreate, Tcl_AsyncMark, Tcl_AsyncMarkFromSignal, Tcl_AsyncInvoke, Tcl_AsyncDelete, Tcl_AsyncReady \- handle asynchronous events
+Tcl_AsyncCreate, Tcl_AsyncMark, Tcl_AsyncInvoke, Tcl_AsyncDelete, Tcl_AsyncReady \- handle asynchronous events
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -17,16 +17,11 @@ Tcl_AsyncCreate, Tcl_AsyncMark, Tcl_AsyncMarkFromSignal, Tcl_AsyncInvoke, Tcl_As
 Tcl_AsyncHandler
 \fBTcl_AsyncCreate\fR(\fIproc, clientData\fR)
 .sp
-void
 \fBTcl_AsyncMark\fR(\fIasync\fR)
 .sp
 int
-\fBTcl_AsyncMarkFromSignal\fR(\fIasync\fR, \fIsigNumber\fR)
-.sp
-int
 \fBTcl_AsyncInvoke\fR(\fIinterp, code\fR)
 .sp
-void
 \fBTcl_AsyncDelete\fR(\fIasync\fR)
 .sp
 int
@@ -39,8 +34,6 @@ Procedure to invoke to handle an asynchronous event.
 One-word value to pass to \fIproc\fR.
 .AP Tcl_AsyncHandler async in
 Token for asynchronous event handler.
-.AP int sigNumber in
-POSIX signal number, when used in a signal context.
 .AP Tcl_Interp *interp in
 Tcl interpreter in which command was being evaluated when handler was
 invoked, or NULL if handler was invoked when there was no interpreter
@@ -67,11 +60,10 @@ to a clean state, such as after the current Tcl command completes.
 .PP
 \fBTcl_AsyncCreate\fR, \fBTcl_AsyncDelete\fR, and \fBTcl_AsyncReady\fR
 are thread sensitive.  They access and/or set a thread-specific data
-structure in the event of a core built with \fI\-\-enable\-threads\fR.
-The token created by \fBTcl_AsyncCreate\fR contains the needed thread
-information it was called from so that calling \fBTcl_AsyncMarkFromSignal\fR
-or \fBTcl_AsyncMark\fR with this token will only yield the origin
-thread into the asynchronous handler.
+structure in the event of a core built with \fI\-\-enable\-threads\fR.  The token
+created by \fBTcl_AsyncCreate\fR contains the needed thread information it
+was called from so that calling \fBTcl_AsyncMark\fR(\fItoken\fR) will only yield
+the origin thread into the asynchronous handler.
 .PP
 \fBTcl_AsyncCreate\fR creates an asynchronous handler and returns
 a token for it.
@@ -80,16 +72,13 @@ any occurrences of the asynchronous event that it is intended
 to handle (it is not safe to create a handler at the time of
 an event).
 When an asynchronous event occurs the code that detects the event
-(such as a POSIX signal handler) should call \fBTcl_AsyncMarkFromSignal\fR
-with the token for the handler and the POSIX signal number. The
-return value of this function is true, when the handler will be
-marked, false otherwise.
-For non-signal contexts, \fBTcl_AsyncMark\fR serves the same purpose.
-\fBTcl_AsyncMarkFromSignal\fR and \fBTcl_AsyncMark\fR will mark
-the handler as ready to execute, but will not invoke the handler
-immediately. Tcl will call the \fIproc\fR associated with the
-handler later, when the world is in a safe state, and \fIproc\fR
-can then carry out the actions associated with the asynchronous event.
+(such as a signal handler) should call \fBTcl_AsyncMark\fR with the
+token for the handler.
+\fBTcl_AsyncMark\fR will mark the handler as ready to execute, but it
+will not invoke the handler immediately.
+Tcl will call the \fIproc\fR associated with the handler later, when
+the world is in a safe state, and \fIproc\fR can then carry out
+the actions associated with the asynchronous event.
 \fIProc\fR should have arguments and result that match the
 type \fBTcl_AsyncProc\fR:
 .PP
@@ -18,7 +18,7 @@ char
 \fBTcl_Backslash\fR(\fIsrc, countPtr\fR)
 .SH ARGUMENTS
 .AS char *countPtr out
-.AP "const char" *src in
+.AP char *src in
 Pointer to a string starting with a backslash.
 .AP int *countPtr out
 If \fIcountPtr\fR is not NULL, \fI*countPtr\fR gets filled
@@ -88,18 +88,6 @@ will lead to a \fBTCL_OK\fR return (and the boolean value 1),
 while the same value passed to \fBTcl_GetBoolean\fR will lead to
 a \fBTCL_ERROR\fR return.

-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_NewBooleanObj\fR always returns a zero-reference object, much
-like \fBTcl_NewObj\fR.
-.PP
-\fBTcl_SetBooleanObj\fR does not modify the reference count of its
-\fIobjPtr\fR argument, but does require that the object be unshared.
-.PP
-\fBTcl_GetBooleanFromObj\fR does not modify the reference count of its
-\fIobjPtr\fR argument; it only reads. Note however that this function
-may set the interpreter result; if that is the only place that
-is holding a reference to the object, it will be deleted.
 .SH "SEE ALSO"
 Tcl_NewObj, Tcl_IsShared, Tcl_GetBoolean

@@ -8,175 +8,85 @@
 .so man.macros
 .BS
 .SH NAME
-Tcl_NewByteArrayObj, Tcl_SetByteArrayObj, Tcl_GetBytesFromObj, Tcl_GetByteArrayFromObj, Tcl_SetByteArrayLength \- manipulate a Tcl value as an array of bytes
+Tcl_NewByteArrayObj, Tcl_SetByteArrayObj, Tcl_GetByteArrayFromObj, Tcl_SetByteArrayLength \- manipulate Tcl values as a arrays of bytes
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
 Tcl_Obj *
-\fBTcl_NewByteArrayObj\fR(\fIbytes, numBytes\fR)
+\fBTcl_NewByteArrayObj\fR(\fIbytes, length\fR)
 .sp
 void
-\fBTcl_SetByteArrayObj\fR(\fIobjPtr, bytes, numBytes\fR)
-.sp
-.VS TIP568
-unsigned char *
-\fBTcl_GetBytesFromObj\fR(\fIinterp, objPtr, numBytesPtr\fR)
-.VE TIP568
+\fBTcl_SetByteArrayObj\fR(\fIobjPtr, bytes, length\fR)
 .sp
 unsigned char *
-\fBTcl_GetByteArrayFromObj\fR(\fIobjPtr, numBytesPtr\fR)
+\fBTcl_GetByteArrayFromObj\fR(\fIobjPtr, lengthPtr\fR)
 .sp
 unsigned char *
-\fBTcl_SetByteArrayLength\fR(\fIobjPtr, numBytes\fR)
+\fBTcl_SetByteArrayLength\fR(\fIobjPtr, length\fR)
 .SH ARGUMENTS
-.AS "const unsigned char" *numBytesPtr in/out
+.AS "const unsigned char" *lengthPtr in/out
 .AP "const unsigned char" *bytes in
 The array of bytes used to initialize or set a byte-array value. May be NULL
-even if \fInumBytes\fR is non-zero.
-.AP int numBytes in
-The number of bytes in the array.  It must be >= 0.
+even if \fIlength\fR is non-zero.
+.AP int length in
+The length of the array of bytes.  It must be >= 0.
 .AP Tcl_Obj *objPtr in/out
-For \fBTcl_SetByteArrayObj\fR, this points to an unshared value to be
-overwritten by a byte-array value.  For \fBTcl_GetBytesFromObj\fR,
-\fBTcl_GetByteArrayFromObj\fR and \fBTcl_SetByteArrayLength\fR, this points
-to the value from which to extract an array of bytes.
-.AP Tcl_Interp *interp in
-Interpreter to use for error reporting.
-.AP "size_t | int" *numBytesPtr out
-Points to space where the number of bytes in the array may be written.
-Caller may pass NULL when it does not need this information.
+For \fBTcl_SetByteArrayObj\fR, this points to the value to be converted to
+byte-array type.  For \fBTcl_GetByteArrayFromObj\fR and
+\fBTcl_SetByteArrayLength\fR, this points to the value from which to get
+the byte-array value; if \fIobjPtr\fR does not already point to a byte-array
+value, it will be converted to one.
+.AP size_t | int *lengthPtr out
+Filled with the length of the array of bytes in the value.
+May be (int *)NULL when not used.
 .BE

 .SH DESCRIPTION
 .PP
-These routines are used to create, modify, store, transfer, and retrieve
-arbitrary binary data in Tcl values.  Specifically, data that can be
-represented as a sequence of arbitrary byte values is supported.
-This includes data read from binary channels, values created by the
-\fBbinary\fR command, encrypted data, or other information representable as
-a finite byte sequence.
-.PP
-A byte is an 8-bit quantity with no inherent meaning.  When the 8 bits are
-interpreted as an integer value, the range of possible values is (0-255).
-The C type best suited to store a byte is the \fBunsigned char\fR.
-An \fBunsigned char\fR array of size \fIN\fR stores an aribtrary binary
-value of size \fIN\fR bytes.  We call this representation a byte-array.
-Here we document the routines that allow us to operate on Tcl values as
-byte-arrays.
-.PP
-All Tcl values must correspond to a string representation.
-When a byte-array value must be processed as a string, the sequence
-of \fIN\fR bytes is transformed into the corresponding sequence
-of \fIN\fR characters, where each byte value transforms to the same
-character codepoint value in the range (U+0000 - U+00FF).  Obtaining the
+These procedures are used to create, modify, and read Tcl byte-array values
+from C code.  Byte-array values are typically used to hold the
+results of binary IO operations or data structures created with the
+\fBbinary\fR command.  In Tcl, an array of bytes is not equivalent to a
+string.  Conceptually, a string is an array of Unicode characters, while a
+byte-array is an array of 8-bit quantities with no implicit meaning.
+Accessor functions are provided to get the string representation of a
+byte-array or to convert an arbitrary value to a byte-array.  Obtaining the
 string representation of a byte-array value (by calling
-\fBTcl_GetStringFromObj\fR) produces this string in Tcl's usual
-Modified UTF-8 encoding.
+\fBTcl_GetStringFromObj\fR) produces a properly formed UTF-8 sequence with a
+one-to-one mapping between the bytes in the internal representation and the
+UTF-8 characters in the string representation.
 .PP
-\fBTcl_NewByteArrayObj\fR and \fBTcl_SetByteArrayObj\fR 
-create a new value or overwrite an existing unshared value, respectively,
-to hold a byte-array value of \fInumBytes\fR bytes.  When a caller
-passes a non-NULL value of \fIbytes\fR, it must point to memory from 
-which \fInumBytes\fR bytes can be read.  These routines
-allocate \fInumBytes\fR bytes of memory, copy \fInumBytes\fR
-bytes from \fIbytes\fR into it, and keep the result in the internal
-representation of the new or overwritten value.  
-When the caller passes a NULL value of \fIbytes\fR, the data copying
-step is skipped, and the bytes stored in the value are undefined.
-A \fIbytes\fR value of NULL is useful only when the caller will arrange
-to write known contents into the byte-array through a pointer retrieved
-by a call to one of the routines explained below.  \fBTcl_NewByteArrayObj\fR
-returns a pointer to the created value with a reference count of zero.
-\fBTcl_SetByteArrayObj\fR overwrites and invalidates any old contents
-of the unshared \fIobjPtr\fR as appropriate, and keeps its reference
-count (0 or 1) unchanged.  The value produced by these routines has no
-string representation.  Any memory allocation failure may cause a panic.
-Note that the type of the \fInumBytes\fR argument is \fBint\fR; consequently
-the largest byte-array value that can be produced by these routines is one
-holding \fBINT_MAX\fR bytes.  Note also that the string representation of
-any Tcl value is limited to \fBINT_MAX\fR bytes, so caution should be
-taken with any byte-array of more than \fBINT_MAX / 2\fR bytes.
+\fBTcl_NewByteArrayObj\fR and \fBTcl_SetByteArrayObj\fR will
+create a new value of byte-array type or modify an existing value to have a
+byte-array type.  Both of these procedures set the value's type to be
+byte-array and set the value's internal representation to a copy of the
+array of bytes given by \fIbytes\fR. \fBTcl_NewByteArrayObj\fR returns a
+pointer to a newly allocated value with a reference count of zero.
+\fBTcl_SetByteArrayObj\fR invalidates any old string representation and, if
+the value is not already a byte-array value, frees any old internal
+representation. If \fIbytes\fR is NULL then the new byte array contains
+arbitrary values.
 .PP
-\fBTcl_GetBytesFromObj\fR performs the opposite function of
-\fBTcl_SetByteArrayObj\fR, providing access to read a byte-array from
-a Tcl value that was previously written into it.  When \fIobjPtr\fR
-is a value previously produced by \fBTcl_NewByteArrayObj\fR or
-\fBTcl_SetByteArrayObj\fR, then \fBTcl_GetBytesFromObj\fR returns
-a pointer to the byte-array kept in the value's internal representation.
-If the caller provides a non-NULL value for \fInumBytesPtr\fR, it must
-point to memory where \fBTcl_GetBytesFromObj\fR can write the number
-of bytes in the value's internal byte-array.  With both pieces of
-information, the caller is able to retrieve any information about the
-contents of that byte-array that it seeks.  When \fIobjPtr\fR does
-not already contain an internal byte-array, \fBTcl_GetBytesFromObj\fR
-will try to create one from the value's string representation.  Any
-string value that does not include any character codepoints outside
-the range (U+0000 - U+00FF) will successfully translate to a unique
-byte-array value.  With the created byte-array, the routine returns
-as before.  For any string representation which does contain
-a forbidden character codepoint, the conversion fails, and 
-\fBTcl_GetBytesFromObj\fR returns NULL to signal that failure.  On
-failure, nothing will be written to \fInumBytesPtr\fR, and if
-the \fIinterp\fR argument is non-NULL, then error messages and
-codes are left in it recording the error.  
+\fBTcl_GetByteArrayFromObj\fR converts a Tcl value to byte-array type and
+returns a pointer to the value's new internal representation as an array of
+bytes.  The length of this array is stored in \fIlengthPtr\fR if
+\fIlengthPtr\fR is non-NULL.  The storage for the array of bytes is owned by
+the value and should not be freed.  The contents of the array may be
+modified by the caller only if the value is not shared and the caller
+invalidates the string representation.
 .PP
-\fBTcl_GetByteArrayFromObj\fR performs nearly the same function as
-\fBTcl_GetBytesFromObj\fR.  They differ only in the circumstance when
-a byte-array internal value must be created by transformation of
-a string representation, and that string representation contains a
-character with codepoint greater than U+00FF.  Instead of failing
-the conversion, \fBTcl_GetByteArrayFromObj\fR will use the 8 least
-significant bits of each codepoint to produce a valid byte value
-from any character codepoint value.  In any other circumstance,
-\fBTcl_GetByteArrayFromObj\fR performs just as \fBTcl_GetBytesFromObj\fR
-does.  Since the conversion cannot fail, \fBTcl_GetByteArrayFromObj\fR
-has no need for an \fIinterp\fR argument to record any errors and
-the caller can assume \fBTcl_GetByteArrayFromObj\fR does not return NULL.
-.PP
-\fBTcl_GetByteArrayFromObj\fR must be used with caution.  Because of the
-truncation on conversion, the byte-array made available to the caller
-cannot reliably complete a round-trip back to the original string
-representation.  This creates opportunities for bugs due to blindness
-to differences in values.  This routine exists in this form primarily
-for compatibility with codebases written for earlier releases of Tcl.
-It is expected this routine will incompatibly change in Tcl 9 so that
-it also signals failed conversions with a NULL return.
-.PP
-On success, both \fBTcl_GetByteFromObj\fR and \fBTcl_GetByteArrayFromObj\fR
-return a pointer into the internal representation of a \fBTcl_Obj\fR.
-That pointer must not be freed by the caller, and should not be retained
-for use beyond the known time the internal representation of the value
-has not been disturbed.  The pointer may be used to overwrite the byte
-contents of the internal representation, so long as the value is unshared
-and any string representation is invalidated.
-.PP
-\fBTcl_SetByteArrayLength\fR enables a caller to change the size of a
-byte-array in the internal representation of an unshared \fIobjPtr\fR to
-become \fInumBytes\fR bytes.  This is most often useful after the
-bytes of the internal byte-array have been directly overwritten and it
-has been discovered that the required size differs from the first
-estimate used in the allocation. \fBTcl_SetByteArrayLength\fR returns
-a pointer to the resized byte-array.  Along with such resizing, any
-string representation of \fIobjPtr\fR must be invalidated.  If resizing
-grows the byte-array, the new byte values are undefined.  If \fIobjPtr\fR
-does not already possess an internal byte-array, one is produced in the
-same way that \fBTcl_GetByteArrayFromObj\fR does, with all the cautions
-that go along with that.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_NewByteArrayObj\fR always returns a zero-reference object, much
-like \fBTcl_NewObj\fR.
-.PP
-\fBTcl_SetByteArrayObj\fR and \fBTcl_SetByteArrayLength\fR do not modify the
-reference count of their \fIobjPtr\fR arguments, but do require that the
-object be unshared.
-.PP
-\fBTcl_GetBytesFromObj\fR and \fBTcl_GetByteArrayFromObj\fR do not modify
-the reference count of \fIobjPtr\fR; they only read.
+\fBTcl_SetByteArrayLength\fR converts the Tcl value to byte-array type
+and changes the length of the value's internal representation as an
+array of bytes.  If \fIlength\fR is greater than the space currently
+allocated for the array, the array is reallocated to the new length; the
+newly allocated bytes at the end of the array have arbitrary values.  If
+\fIlength\fR is less than the space currently allocated for the array,
+the length of array is reduced to the new length.  The return value is a
+pointer to the value's new array of bytes.

 .SH "SEE ALSO"
 Tcl_GetStringFromObj, Tcl_NewObj, Tcl_IncrRefCount, Tcl_DecrRefCount

 .SH KEYWORDS
-value, binary data, byte array, utf, unicode
+value, binary data, byte array, utf, unicode, internationalization
@@ -67,14 +67,6 @@ other procedures.  If an error is returned and this bit is set in
 result, where it can be retrieved with \fBTcl_GetObjResult\fR or
 \fBTcl_GetStringResult\fR.  If this flag bit is not set then no error
 message is left and the interpreter's result will not be modified.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_CancelEval\fR always decrements the reference count of its
-\fIresultObjPtr\fR argument (if that is non-NULL). It is expected to
-be usually called with an object with zero reference count. If the
-object is shared with some other location (including the Tcl
-evaluation stack) it should have its reference count incremented
-before calling this function.
 .SH "SEE ALSO"
 interp(n), Tcl_Eval(3),
 TIP 285
@@ -55,14 +55,6 @@ Tcl_ObjectMapMethodNameProc
 \fBTcl_ObjectGetMethodNameMapper\fR(\fIobject\fR)
 .sp
 \fBTcl_ObjectSetMethodNameMapper\fR(\fIobject\fR, \fImethodNameMapper\fR)
-.sp
-.VS "TIP 605"
-Tcl_Class
-\fBTcl_GetClassOfObject\fR(\fIobject\fR)
-.sp
-Tcl_Obj *
-\fBTcl_GetObjectClassName\fR(\fIinterp\fR, \fIobject\fR)
-.VE "TIP 605"
 .SH ARGUMENTS
 .AS ClientData metadata in/out
 .AP Tcl_Interp *interp in/out
@@ -122,13 +114,6 @@ function. Note that the Tcl_Obj reference returned by \fBTcl_GetObjectName\fR
 is a shared reference. You can also get whether the object has been marked for
 deletion with \fBTcl_ObjectDeleted\fR (it returns true if deletion of the
 object has begun); this can be useful during the processing of methods.
-.VS "TIP 605"
-The class of an object can be retrieved with \fBTcl_GetClassOfObject\fR, and
-the name of the class of an object with \fBTcl_GetObjectClassName\fR; note
-that these two \fImay\fR return NULL during deletion of an object (this is
-transient, and only occurs when the object is a long way through being
-deleted).
-.VE "TIP 605"
 .PP
 Instances of classes are created using \fBTcl_NewObjectInstance\fR, which
 creates an object from any class (and which is internally called by both
@@ -256,29 +241,6 @@ NULL if the whole chain is to be processed (the argument itself is never
 NULL); this variable may be updated by the callback. The \fImethodNameObj\fR
 parameter gives an unshared object containing the name of the method being
 invoked, as provided by the user; this object may be updated by the callback.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The \fIobjPtr\fR argument to \fBTcl_GetObjectFromObj\fR will not have its
-reference count manipulated, but this function may modify the interpreter
-result (to report any error) so interpreter results should not be fed into
-this without an additional reference being used.
-.PP
-The result of \fBTcl_GetObjectName\fR is a value that is owned by the object
-that is regenerated when this function is first called after the object is
-renamed.  If the value is to be retained at all, the caller should increment
-the reference count.
-.PP
-The first \fIobjc\fR values in the \fIobjv\fR argument to
-\fBTcl_NewObjectInstance\fR are the arguments to pass to the constructor. They
-must have a reference count of at least 1, and may have their reference counts
-changed during the running of the constructor. Constructors may modify the
-interpreter result, which consequently means that interpreter results should
-not be used as arguments without an additional reference being taken.
-.PP
-The \fImethodNameObj\fR argument to a Tcl_ObjectMapMethodNameProc
-implementation will be a value with a reference count of at least 1 where at
-least one reference is not held by the interpreter result. It is expected that
-method name mappers will only read their \fImethodNameObj\fR arguments.
 .SH "SEE ALSO"
 Method(3), oo::class(n), oo::copy(n), oo::define(n), oo::object(n)
 .SH KEYWORDS
@@ -243,16 +243,8 @@ any script evaluation mechanism will fail.
 .PP
 For a description of the Tcl interface to multiple interpreters, see
 \fIinterp(n)\fR.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_CreateAliasObj\fR increments the reference counts of the values
-in its \fIobjv\fR argument. (That reference lasts the same length of
-time as the owning alias.)
-.PP
-\fBTcl_GetAliasObj\fR returns (via its \fIobjvPtr\fR argument) a
-pointer to values that it holds a reference to.
 .SH "SEE ALSO"
-interp(n)
+interp

 .SH KEYWORDS
 alias, command, exposed commands, hidden commands, interpreter, invoke,
@@ -156,10 +156,6 @@ pointed to by \fIargTypesPointer\fR.
 \fBTcl_ListMathFuncs\fR returns a Tcl value containing a list of all
 the math functions defined in the interpreter whose name matches
 \fIpattern\fR.  The returned value has a reference count of zero.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_ListMathFuncs\fR always returns a zero-reference object, much
-like \fBTcl_NewObj\fR.
 .SH "SEE ALSO"
 expr(n), info(n), Tcl_CreateObjCommand(3), Tcl_Free(3), Tcl_NewListObj(3)
 .SH KEYWORDS
@@ -54,7 +54,7 @@ const char *
 .AS Tcl_CmdDeleteProc *deleteProc in/out
 .AP Tcl_Interp *interp in
 Interpreter in which to create a new command or that contains a command.
-.AP "const char" *cmdName in
+.AP char *cmdName in
 Name of command.
 .AP Tcl_ObjCmdProc *proc in
 Implementation of the new command: \fIproc\fR will be called whenever
@@ -323,21 +323,6 @@ instead. The result from \fBTcl_GetCommandTypeName\fR will be exactly that
 string which was registered, and not a copy; use of a compile-time constant
 string is \fIstrongly recommended\fR.
 .VE "info cmdtype feature"
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-When the \fIproc\fR passed to \fBTcl_CreateObjCommand\fR is called,
-the values in its \fIobjv\fR argument will have a reference count of
-at least 1, with that guaranteed reference being from the Tcl
-evaluation stack. You should not call \fBTcl_DecrRefCount\fR on any of
-those values unless you call \fBTcl_IncrRefCount\fR on them first.
-Also, when the \fIproc\fR is called, the interpreter result is
-guaranteed to be an empty string value with a reference count of 1.
-.PP
-\fBTcl_GetCommandFullName\fR does not modify the reference count of its
-\fIobjPtr\fR argument, but does require that the object be unshared.
-.PP
-\fBTcl_GetCommandFromObj\fR does not modify the reference count of its
-\fIobjPtr\fR argument; it only reads.
 .SH "SEE ALSO"
 Tcl_CreateCommand(3), Tcl_ResetResult(3), Tcl_SetObjResult(3)
 .SH KEYWORDS
@@ -187,14 +187,5 @@ There is no way to be notified when the trace created by
 \fBTcl_CreateTrace\fR is deleted.  There is no way for the \fIproc\fR
 associated with a call to \fBTcl_CreateTrace\fR to abort execution of
 \fIcommand\fR.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-When the \fIproc\fR passed to \fBTcl_CreateObjTrace\fR is called,
-the values in its \fIobjv\fR argument will have a reference count of
-at least 1, with that guaranteed reference being from the Tcl
-evaluation stack. You should not call \fBTcl_DecrRefCount\fR on any of
-those values unless you call \fBTcl_IncrRefCount\fR on them first.
-.SH "SEE ALSO"
-trace(n)
 .SH KEYWORDS
 command, create, delete, interpreter, trace
@@ -190,73 +190,6 @@ path as this is easy to construct from repeated use of
 dictionaries are created for non-terminal keys where they do not
 already exist. With \fBTcl_DictObjRemoveKeyList\fR, all non-terminal
 keys must exist and have dictionaries as their values.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_NewDictObj\fR always returns a zero-reference object, much like
-\fBTcl_NewObj\fR.
-.PP
-\fBTcl_DictObjPut\fR does not modify the reference count of its \fIdictPtr\fR
-argument, but does require that the object be unshared.  If
-\fBTcl_DictObjPut\fR returns \fBTCL_ERROR\fR it does not manipulate any
-reference counts; but if it returns \fBTCL_OK\fR then it definitely increments
-the reference count of \fIvaluePtr\fR and may increment the reference count of
-\fIkeyPtr\fR; the latter case happens exactly when the key did not previously
-exist in the dictionary.  Note however that this function may set the
-interpreter result; if that is the only place that is holding a reference to
-an object, it will be deleted.
-.PP
-\fBTcl_DictObjGet\fR only reads from its \fIdictPtr\fR and \fIkeyPtr\fR
-arguments, and does not manipulate their reference counts at all.  If the
-\fIvaluePtrPtr\fR argument is not set to NULL (and the function doesn't return
-\fBTCL_ERROR\fR), it will be set to a value with a reference count of at least
-1, with a reference owned by the dictionary.  Note however that this function
-may set the interpreter result; if that is the only place that is holding a
-reference to an object, it will be deleted.
-.PP
-\fBTcl_DictObjRemove\fR does not modify the reference count of its
-\fIdictPtr\fR argument, but does require that the object be unshared. It does
-not manipulate the reference count of its \fIkeyPtr\fR argument at all.  Note
-however that this function may set the interpreter result; if that is the only
-place that is holding a reference to an object, it will be deleted.
-.PP
-\fBTcl_DictObjSize\fR does not modify the reference count of its \fIdictPtr\fR
-argument; it only reads.  Note however that this function may set the
-interpreter result; if that is the only place that is holding a reference to
-the dictionary object, it will be deleted.
-.PP
-\fBTcl_DictObjFirst\fR does not modify the reference count of its
-\fIdictPtr\fR argument; it only reads. The variables given by the
-\fIkeyPtrPtr\fR and \fIvaluePtrPtr\fR arguments (if not NULL) will be updated
-to contain references to the relevant values in the dictionary; their
-reference counts will be at least 1 (due to the dictionary holding a reference
-to them). It may also manipulate internal references; these are not exposed to
-user code, but require a matching \fBTcl_DictObjDone\fR call.  Note however
-that this function may set the interpreter result; if that is the only place
-that is holding a reference to the dictionary object, it will be deleted.
-.PP
-Similarly for \fBTcl_DictObjNext\fR; the variables given by the
-\fIkeyPtrPtr\fR and \fIvaluePtrPtr\fR arguments (if not NULL) will be updated
-to contain references to the relevant values in the dictionary; their
-reference counts will be at least 1 (due to the dictionary holding a reference
-to them).
-.PP
-\fBTcl_DictObjDone\fR does not manipulate (user-visible) reference counts.
-.PP
-\fBTcl_DictObjPutKeyList\fR is similar to \fBTcl_DictObjPut\fR; it does not
-modify the reference count of its \fIdictPtr\fR argument, but does require
-that the object be unshared. It may increment the reference count of any value
-passed in the \fIkeyv\fR argument, and will increment the reference count of
-the \fIvaluePtr\fR argument on success. It is recommended that values passed
-via \fIkeyv\fR and \fIvaluePtr\fR do not have zero reference counts.  Note
-however that this function may set the interpreter result; if that is the only
-place that is holding a reference to an object, it will be deleted.
-.PP
-\fBTcl_DictObjRemoveKeyList\fR is similar to \fBTcl_DictObjRemove\fR; it does
-not modify the reference count of its \fIdictPtr\fR argument, but does require
-that the object be unshared, and does not modify the reference counts of any
-of the values passed in the \fIkeyv\fR argument.  Note however that this
-function may set the interpreter result; if that is the only place that is
-holding a reference to an object, it will be deleted.
 .SH EXAMPLE
 Using the dictionary iteration interface to search determine if there
 is a key that maps to itself:
@@ -58,18 +58,6 @@ and if \fIinterp\fR is non-NULL, an error message is left in \fIinterp\fR.
 The \fBTcl_ObjType\fR of \fIobjPtr\fR may be changed to make subsequent
 calls to \fBTcl_GetDoubleFromObj\fR more efficient.
 '\" TODO: add discussion of treatment of NaN value
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_NewDoubleObj\fR always returns a zero-reference object, much
-like \fBTcl_NewObj\fR.
-.PP
-\fBTcl_SetDoubleObj\fR does not modify the reference count of its
-\fIobjPtr\fR argument, but does require that the object be unshared.
-.PP
-\fBTcl_GetDoubleFromObj\fR does not modify the reference count of its
-\fIobjPtr\fR argument; it only reads. Note however that this function
-may set the interpreter result; if that is the only place that
-is holding a reference to the object, it will be deleted.
 .SH "SEE ALSO"
 Tcl_NewObj, Tcl_DecrRefCount, Tcl_IncrRefCount, Tcl_GetObjResult
 .SH KEYWORDS
@@ -556,16 +556,5 @@ been loaded, it attempts to load an encoding file called \fIname\fB.enc\fR
 from the \fBencoding\fR subdirectory of each directory that Tcl searches
 for its script library.  If the encoding file exists, but is
 malformed, an error message will be left in \fIinterp\fR.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_GetEncodingFromObj\fR does not modify the reference count of its
-\fIobjPtr\fR argument; it only reads. Note however that this function may set
-the interpreter result; if that is the only place that is holding a reference
-to the object, it will be deleted.
-.PP
-\fBTcl_GetEncodingSearchPath\fR returns an object with a reference count of at
-least 1.
-.SH "SEE ALSO"
-encoding(n)
 .SH KEYWORDS
 utf, encoding, convert
@@ -209,27 +209,6 @@ namespace whose list of exported commands is used if both the mapping
 dictionary and the subcommand list properties are NULL. May be read
 using \fBTcl_GetEnsembleNamespace\fR which returns a Tcl result code
 (\fBTCL_OK\fR, or \fBTCL_ERROR\fR if the token does not refer to an ensemble).
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_FindEnsemble\fR does not modify the reference count of its
-\fIcmdNameObj\fR argument; it only reads. Note however that this function may
-set the interpreter result; if that is the only place that is holding a
-reference to the object, it will be deleted.
-.PP
-The ensemble property getters (\fBTcl_GetEnsembleMappingDict\fR,
-\fBTcl_GetEnsembleParameterList\fR, \fBTcl_GetEnsembleSubcommandList\fR, and
-\fBTcl_GetEnsembleUnknownHandler\fR) do not manipulate the reference count of
-the values they provide out; if those are non-NULL, they will have a reference
-count of at least 1.  Note that these functions may set the interpreter
-result.
-.PP
-The ensemble property setters (\fBTcl_SetEnsembleMappingDict\fR,
-\fBTcl_SetEnsembleParameterList\fR, \fBTcl_SetEnsembleSubcommandList\fR, and
-\fBTcl_SetEnsembleUnknownHandler\fR) will increment the reference count of the
-new value of the property they are given if they succeed (and decrement the
-reference count of the old value of the property, if relevant). If the
-property setters return \fBTCL_ERROR\fR, the reference count of the Tcl_Obj
-argument is left unchanged.
 .SH "SEE ALSO"
 namespace(n), Tcl_DeleteCommandFromToken(3)
 .SH KEYWORDS
@@ -65,7 +65,7 @@ null terminating character.  If \-1, then all characters up to the
 first null byte are used.
 .AP "const char" *script in
 Points to first byte of script to execute (null-terminated and UTF-8).
-.AP "const char" *part in
+.AP char *part in
 String forming part of a Tcl script.
 .AP va_list argList in
 An argument list which must have been initialized using
@@ -207,20 +207,6 @@ the \fBreturn\fR, \fBbreak\fR, or \fBcontinue\fR command was
 invoked in an inappropriate place.
 This means that top-level applications should never see a return code
 from \fBTcl_EvalObjEx\fR other than \fBTCL_OK\fR or \fBTCL_ERROR\fR.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_EvalObjEx\fR and \fBTcl_GlobalEvalObj\fR both increment and
-decrement the reference count of their \fIobjPtr\fR argument; you must
-not pass them any value with a reference count of zero. They also
-manipulate the interpreter result; you must not count on the
-interpreter result to hold the reference count of any value over
-these calls.
-.PP
-\fBTcl_EvalObjv\fR may increment and decrement the reference count of
-any value passed via its \fIobjv\fR argument; you must not pass any
-value with a reference count of zero. This function also manipulates
-the interpreter result; you must not count on the interpreter result
-to hold the reference count of any value over this call.

 .SH KEYWORDS
 execute, file, global, result, script, value
@@ -98,15 +98,6 @@ containing the expression's value at \fI*resultPtrPtr\fR.
 In this case, the caller is responsible for calling
 \fBTcl_DecrRefCount\fR to decrement the value's reference count
 when it is finished with the value.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_ExprLongObj\fR, \fBTcl_ExprDoubleObj\fR,
-\fBTcl_ExprBooleanObj\fR, and \fBTcl_ExprObj\fR all increment and
-decrement the reference count of their \fIobjPtr\fR arguments; you
-must not pass them any value with a reference count of zero. They also
-manipulate the interpreter result; you must not count on the
-interpreter result to hold the reference count of any value over these
-calls.

 .SH "SEE ALSO"
 Tcl_ExprLong, Tcl_ExprDouble, Tcl_ExprBoolean, Tcl_ExprString, Tcl_GetObjResult
@@ -45,7 +45,7 @@ int
 \fBTcl_FSDeleteFile\fR(\fIpathPtr\fR)
 .sp
 int
-\fBTcl_FSRemoveDirectory\fR(\fIpathPtr, recursive, errorPtr\fR)
+\fBTcl_FSRemoveDirectory\fR(\fIpathPtr, int recursive, errorPtr\fR)
 .sp
 int
 \fBTcl_FSRenameFile\fR(\fIsrcPathPtr, destPathPtr\fR)
@@ -79,10 +79,10 @@ int
 \fBTcl_FSUtime\fR(\fIpathPtr, tval\fR)
 .sp
 int
-\fBTcl_FSFileAttrsGet\fR(\fIinterp, index, pathPtr, objPtrRef\fR)
+\fBTcl_FSFileAttrsGet\fR(\fIinterp, int index, pathPtr, objPtrRef\fR)
 .sp
 int
-\fBTcl_FSFileAttrsSet\fR(\fIinterp, index, pathPtr, objPtr\fR)
+\fBTcl_FSFileAttrsSet\fR(\fIinterp, int index, pathPtr, Tcl_Obj *objPtr\fR)
 .sp
 const char *const *
 \fBTcl_FSFileAttrStrings\fR(\fIpathPtr, objPtrRef\fR)
@@ -197,8 +197,6 @@ rename operation.
 .AP Tcl_Obj *destPathPtr in
 As for \fIpathPtr\fR, but used for the destination filename for a copy or
 rename operation.
-.AP int recursive in
-Whether to remove subdirectories and their contents as well.
 .AP "const char" *encodingName in
 The encoding of the data stored in the
 file identified by \fIpathPtr\fR and to be evaluated.
@@ -226,10 +224,6 @@ be joined together. If negative, then all elements are joined.
 .AP Tcl_Obj **errorPtr out
 In the case of an error, filled with a value containing the name of
 the file which caused an error in the various copy/rename operations.
-.AP int index in
-The index of the attribute in question.
-.AP Tcl_Obj *objPtr in
-The value to set in the operation.
 .AP Tcl_Obj **objPtrRef out
 Filled with a value containing the result of the operation.
 .AP Tcl_Obj *resultPtr out
@@ -1634,158 +1628,6 @@ typedef int \fBTcl_FSChdirProc\fR(
 The \fBTcl_FSChdirProc\fR changes the applications current working
 directory to the value specified in \fIpathPtr\fR. The function returns
 -1 on error or 0 on success.
-.SH "REFERENCE COUNT MANAGEMENT"
-.SS "PUBLIC API CALLS"
-.PP
-For all of these functions, \fIpathPtr\fR (including the \fIsrcPathPtr\fR and
-\fIdestPathPtr\fR arguments to \fBTcl_FSCopyFile\fR,
-\fBTcl_FSCopyDirectory\fR, and \fBTcl_FSRenameFile\fR, the \fIfirstPtr\fR and
-\fIsecondPtr\fR arguments to \fBTcl_FSEqualPaths\fR, and the \fIlinkNamePtr\fR
-and \fItoPtr\fR arguments to \fBTcl_FSLink\fR) must not be a zero reference
-count value; references may be retained in internal caches even for
-theoretically read-only operations.  These functions may also manipulate the
-interpreter result (if they take and are given a non-NULL \fIinterp\fR
-argument); you must not count on the interpreter result to hold the reference
-count of any argument value over these calls and should manage your own
-references there. However, references held by the arguments to a Tcl command
-\fIare\fR suitable for reference count management purposes for the duration of
-the implementation of that command.
-.PP
-The \fIerrorPtr\fR argument to \fBTcl_FSCopyDirectory\fR and
-\fBTcl_FSRemoveDirectory\fR is, when an object is set into it at all, set to
-an object with a non-zero reference count that should be passed to
-\fBTcl_DecrRefCount\fR when no longer needed.
-.PP
-\fBTcl_FSListVolumes\fR always returns a zero-reference object, much
-like \fBTcl_NewObj\fR.
-.PP
-\fBTcl_FSLink\fR always returns a non-zero-reference object when it is
-asked to read; you must call \fBTcl_DecrRefCount\fR on the object
-once you no longer need it.
-.PP
-\fBTcl_FSGetCwd\fR always returns a non-zero-reference object; you
-must call \fBTcl_DecrRefCount\fR on the object once you no longer need
-it.
-.PP
-\fBTcl_FSPathSeparator\fR always returns a zero-reference object, much
-like \fBTcl_NewObj\fR.
-.PP
-\fBTcl_FSJoinPath\fR always returns a zero-reference object, much
-like \fBTcl_NewObj\fR. Its \fIlistObj\fR argument can have any reference
-count; it is only read by this function.
-.PP
-\fBTcl_FSSplitPath\fR always returns a zero-reference object, much
-like \fBTcl_NewObj\fR.
-.PP
-\fBTcl_FSGetNormalizedPath\fR returns an object with a non-zero
-reference count where Tcl is the owner. You should increment its
-reference count if you want to retain it, but do not need to if you
-are just using the value immediately.
-.PP
-\fBTcl_FSJoinToPath\fR always returns a zero-reference object, much like
-\fBTcl_NewObj\fR. Its \fIbasePtr\fR argument follows the rules above for
-\fIpathPtr\fR, as do the values in the \fIobjv\fR argument.
-.PP
-\fBTcl_FSGetTranslatedPath\fR returns a non-zero-reference object (or
-NULL in the error case); you must call \fBTcl_DecrRefCount\fR on the
-object once you no longer need it.
-.PP
-\fBTcl_FSNewNativePath\fR always returns a zero-reference object (or
-NULL), much like \fBTcl_NewObj\fR.
-.PP
-\fBTcl_FSFileSystemInfo\fR always returns a zero-reference object (or
-NULL), much like \fBTcl_NewObj\fR.
-.PP
-The \fIobjPtr\fR and \fIobjPtrRef\fR arguments to \fBTcl_FSFileAttrsGet\fR,
-\fBTcl_FSFileAttrsSet\fR and \fBTcl_FSFileAttrStrings\fR are conventional Tcl
-values; the \fIobjPtr\fR argument will be read but not retained, and the
-\fIobjPtrRef\fR argument will have (on success) a zero-reference value written
-into it (as with \fBTcl_NewObj\fR). \fBTcl_FSFileAttrsGet\fR and
-\fBTcl_FSFileAttrsSet\fR may also manipulate the interpreter result.
-.PP
-The \fIresultPtr\fR argument to \fBTcl_FSMatchInDirectory\fR will not have its
-reference count manipulated, but it should have a reference count of no more
-than 1, and should not be the current interpreter result (as the function may
-overwrite that on error).
-.SS "VIRTUAL FILESYSTEM INTERFACE"
-.PP
-For all virtual filesystem implementation functions, any \fIpathPtr\fR
-arguments should not have their reference counts manipulated. If they take an
-\fIinterp\fR argument, they may set an error message in that, but must not
-manipulate the \fIpathPtr\fR afterwards. Aside from that:
-.TP
-\fIinternalToNormalizedProc\fR
-.
-This should return a zero-reference count value, as if allocated with
-\fBTcl_NewObj\fR.
-.TP
-\fInormalizePathProc\fR
-.
-Unlike with other API implementation functions, the \fIpathPtr\fR argument
-here is guaranteed to be an unshared object that should be updated. Its
-reference count should not be modified.
-.TP
-\fIfilesystemPathTypeProc\fR
-.
-The return value (if non-NULL) either has a reference count of zero or needs
-to be maintained (on a per-thread basis) by the filesystem. Tcl will increment
-the reference count of the value if it wishes to retain it.
-.TP
-\fIfilesystemSeparatorProc\fR
-.
-The return value should be a value with reference count of zero.
-.TP
-\fImatchInDirectoryProc\fR
-.
-The \fIresultPtr\fR argument should be assumed to hold a list that can be
-appended to (i.e., that has a reference count no greater than 1). No reference
-to it should be retained.
-.TP
-\fIlinkProc\fR
-.
-If \fItoPtr\fR is NULL, this should return a value with reference count 1 that
-has just been allocated and passed to \fBTcl_IncrRefCount\fR. If \fItoPtr\fR
-is not NULL, it should be returned on success.
-.TP
-\fIlistVolumesProc\fR
-.
-The result value should be a list (if non-NULL); it will have its reference
-count decremented once (with \fBTcl_DecrRefCount\fR) by Tcl once done.
-.TP
-\fIfileAttrStringsProc\fR
-.
-If the result is NULL, the \fIobjPtrRef\fR should have a list value written to
-it; that list will have its reference count both incremented (with
-\fBTcl_IncrRefCount\fR) and decremented (with \fBTcl_DecrRefCount\fR).
-.TP
-\fIfileAttrsGetProc\fR
-.
-The \fIobjPtrRef\fR argument should have (on non-error return) a zero
-reference count value written to it (allocated as if with \fBTcl_NewObj\fR).
-.TP
-\fIfileAttrsSetProc\fR
-.
-The \fIobjPtr\fR argument should either just be read or its reference count
-incremented to retain it.
-.TP
-\fIremoveDirectoryProc\fR
-.
-If an error is being reported, the problem filename reported via
-\fIerrorPtr\fR should be newly allocated (as if with \fBTcl_NewObj\fR) and
-have a reference count of 1 (i.e., have been passed to
-\fBTcl_IncrRefCount\fR).
-.TP
-\fIcopyDirectoryProc\fR
-.
-If an error is being reported, the problem filename reported via
-\fIerrorPtr\fR should be newly allocated (as if with \fBTcl_NewObj\fR) and
-have a reference count of 1 (i.e., have been passed to
-\fBTcl_IncrRefCount\fR).
-.TP
-\fIgetCwdProc\fR
-.
-The result will be passed to \fBTcl_DecrRefCount\fR by the implementation of
-\fBTcl_FSGetCwd\fR after it has been normalized.
 .SH "SEE ALSO"
 cd(n), file(n), filename(n), load(n), open(n), pwd(n), source(n), unload(n)
 .SH KEYWORDS
@@ -17,7 +17,7 @@ char *
 \fBTcl_GetCwd\fR(\fIinterp\fR, \fIbufferPtr\fR)
 .sp
 int
-\fBTcl_Chdir\fR(\fIdirName\fR)
+\fBTcl_Chdir\fR(\fIpath\fR)
 .SH ARGUMENTS
 .AS Tcl_DString *bufferPtr in/out
 .AP Tcl_Interp *interp in
@@ -27,7 +27,7 @@ This dynamic string is used to store the current working directory.
 At the time of the call it should be uninitialized or free.  The
 caller must eventually call \fBTcl_DStringFree\fR to free up
 anything stored here.
-.AP "const char" *dirName in
+.AP char *path in
 File path in UTF\-8 format.
 .BE

@@ -45,7 +45,7 @@ must call \fBTcl_DStringFree()\fR when the result is no longer needed.
 The format of the path is UTF\-8.
 .PP
 \fBTcl_Chdir\fR changes the applications current working directory to
-the value specified in \fIdirName\fR.  The format of the passed in string
+the value specified in \fIpath\fR.  The format of the passed in string
 must be UTF\-8.  The function returns -1 on error or 0 on success.

 .SH KEYWORDS
@@ -105,12 +105,6 @@ array of characters at \fItablePtr\fR+\fIoffset\fR bytes, etc.)
 This is particularly useful when processing things like
 \fBTk_ConfigurationSpec\fR, whose string keys are in the same place in
 each of several array elements.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_GetIndexFromObj\fR and \fBTcl_GetIndexFromObjStruct\fR do not modify
-the reference count of their \fIobjPtr\fR arguments; they only read. Note
-however that these functions may set the interpreter result; if that is the
-only place that is holding a reference to the object, it will be deleted.
 .SH "SEE ALSO"
 prefix(n), Tcl_WrongNumArgs(3)
 .SH KEYWORDS
@@ -330,19 +330,5 @@ typedef void \fBTcl_FreeHashEntryProc\fR(
 If this is NULL then \fBTcl_Free\fR is used to free the space for the entry.
 Tcl_Obj* keys use this function to decrement the reference count on the
 value.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-When a hash table is created with \fBTcl_InitCustomHashTable\fR, the
-\fBTcl_CreateHashEntry\fR function will increment the reference count of its
-\fIkey\fR argument when it creates a key (but not if there is an existing
-matching key). The reference count of the key will be decremented when the
-corresponding hash entry is deleted, whether with \fBTcl_DeleteHashEntry\fR or
-with \fBTcl_DeleteHashTable\fR. The \fBTcl_GetHashKey\fR function will return
-the key without further modifying its reference count.
-.PP
-Custom hash tables that use a Tcl_Obj* as key will generally need to do
-something similar in their \fIallocEntryProc\fR.
-.SH "SEE ALSO"
-Dict(3)
 .SH KEYWORDS
 hash table, key, lookup, search, value
@@ -2,7 +2,7 @@
 '\" Copyright (c) 1998-2000 Scriptics Corporation.
 '\" All rights reserved.
 '\"
-.TH Tcl_Init 3 8.7 Tcl "Tcl Library Procedures"
+.TH Tcl_Init 3 8.0 Tcl "Tcl Library Procedures"
 .so man.macros
 .BS
 .SH NAME
@@ -13,15 +13,10 @@ Tcl_Init \- find and source initialization script
 .sp
 int
 \fBTcl_Init\fR(\fIinterp\fR)
-.sp
-const char *
-\fBTcl_SetPreInitScript\fR(\fIscriptPtr\fR)
 .SH ARGUMENTS
 .AS Tcl_Interp *interp
 .AP Tcl_Interp *interp in
 Interpreter to initialize.
-.AP "const char" *scriptPtr in
-Address of the initialization script.
 .BE

 .SH DESCRIPTION
@@ -31,13 +26,6 @@ Address of the initialization script.
 path.
 .PP
 \fBTcl_Init\fR is typically called from \fBTcl_AppInit\fR procedures.
-.PP
-\fBTcl_SetPreInitScript\fR registers the pre-initialization script and
-returns the former (now replaced) script pointer.
-A value of \fINULL\fR may be passed to not register any script.
-The pre-initialization script is executed by \fBTcl_Init\fR before accessing
-the file system. The purpose is to typically prepare a custom file system
-(like an embedded zip-file) to be activated before the search.

 .SH "SEE ALSO"
 Tcl_AppInit, Tcl_Main
@@ -160,27 +160,6 @@ If anything later in the caller requires
 The \fBTcl_InitBignumFromDouble\fR routine is a utility procedure
 that extracts the integer part of \fIdoubleValue\fR and stores that
 integer value in the \fBmp_int\fR value \fIbigValue\fR.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_NewIntObj\fR, \fBTcl_NewLongObj\fR, \fBTcl_NewWideIntObj\fR, and
-\fBTcl_NewBignumObj\fR always return a zero-reference object, much like
-\fBTcl_NewObj\fR.
-.PP
-\fBTcl_SetIntObj\fR, \fBTcl_SetLongObj\fR, \fBTcl_SetWideIntObj\fR, and
-\fBTcl_SetBignumObj\fR do not modify the reference count of their \fIobjPtr\fR
-arguments, but do require that the object be unshared.
-.PP
-\fBTcl_GetIntFromObj\fR, \fBTcl_GetIntForIndex\fR, \fBTcl_GetLongFromObj\fR,
-\fBTcl_GetWideIntFromObj\fR, \fBTcl_GetBignumFromObj\fR, and
-\fBTcl_TakeBignumFromObj\fR do not modify the reference count of their
-\fIobjPtr\fR arguments; they only read. Note however that this function may
-set the interpreter result; if that is the only place that is holding a
-reference to the object, it will be deleted. Also note that if
-\fBTcl_TakeBignumFromObj\fR is given an unshared value, the value of that
-object may be modified; it is intended to be used when the value is
-.QW consumed
-by the operation at this point.
-
 .SH "SEE ALSO"
 Tcl_NewObj, Tcl_DecrRefCount, Tcl_IncrRefCount, Tcl_GetObjResult
 .SH KEYWORDS
@@ -246,31 +246,6 @@ with a NULL \fIobjvPtr\fR:
 result = \fBTcl_ListObjReplace\fR(interp, listPtr, first, count,
        0, NULL);
 .CE
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_NewListObj\fR always returns a zero-reference object, much like
-\fBTcl_NewObj\fR. If a non-NULL \fIobjv\fR argument is given, the reference
-counts of the first \fIobjc\fR values in that array are incremented.
-.PP
-\fBTcl_SetListObj\fR does not modify the reference count of its \fIobjPtr\fR
-argument, but does require that the object be unshared. The reference counts
-of the first \fIobjc\fR values in the \fIobjv\fR array are incremented.
-.PP
-\fBTcl_ListObjGetElements\fR, \fBTcl_ListObjIndex\fR, and
-\fBTcl_ListObjLength\fR do not modify the reference count of their
-\fIlistPtr\fR arguments; they only read. Note however that these three
-functions may set the interpreter result; if that is the only place that is
-holding a reference to the object, it will be deleted.
-.PP
-\fBTcl_ListObjAppendList\fR, \fBTcl_ListObjAppendElement\fR, and
-\fBTcl_ListObjReplace\fR require an unshared \fIlistPtr\fR argument.
-\fBTcl_ListObjAppendList\fR only reads its \fIelemListPtr\fR argument.
-\fBTcl_ListObjAppendElement\fR increments the reference count of its
-\fIobjPtr\fR on success. \fBTcl_ListObjReplace\fR increments the reference
-count of the first \fIobjc\fR values in the \fIobjv\fR array on success.  Note
-however that all these three functions may set the interpreter result on
-failure; if that is the only place that is holding a reference to the object,
-it will be deleted.
 .SH "SEE ALSO"
 Tcl_NewObj(3), Tcl_DecrRefCount(3), Tcl_IncrRefCount(3), Tcl_GetObjResult(3)
 .SH KEYWORDS
@@ -60,10 +60,6 @@ be unloaded with \fBTcl_FSUnloadFile\fR.
 the symbol cannot be found, it returns NULL and sets an error message in the
 given \fIinterp\fR (if that is non-NULL). Note that it is unsafe to use this
 operation on a handle that has been passed to \fBTcl_FSUnloadFile\fR.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The reference count of the \fIpathPtr\fR argument to \fBTcl_LoadFile\fR may be
-incremented. As such, it should not be given a zero reference count value.
 .SH "SEE ALSO"
 Tcl_FSLoadFile(3), Tcl_FSUnloadFile(3), load(n), unload(n)
 .SH KEYWORDS
@@ -258,32 +258,8 @@ also return TCL_ERROR; it should return TCL_OK otherwise.
 The \fIoldClientData\fR field to a Tcl_CloneProc gives the value from the
 method being copied from, and the \fInewClientDataPtr\fR field will point to
 a variable in which to write the value for the method being copied to.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The \fInameObj\fR argument to \fBTcl_NewMethod\fR and
-\fBTcl_NewInstanceMethod\fR (when non-NULL) will have its reference count
-incremented if there is no existing method with that name in that
-class/object.
-.PP
-The result of \fBTcl_MethodName\fR is a value with a reference count of at
-least one. It should not be modified without first duplicating it (with
-\fBTcl_DuplicateObj\fR).
-.PP
-The values in the first \fIobjc\fR values of the \fIobjv\fR argument to
-\fBTcl_ObjectContextInvokeNext\fR are assumed to have a reference count of at
-least 1; the containing array is assumed to endure until the next method
-implementation (see \fBnext\fR) returns. Be aware that methods may
-\fByield\fR; if any post-call actions are desired (e.g., decrementing the
-reference count of values passed in here), they must be scheduled with
-\fBTcl_NRAddCallback\fR.
-.PP
-The \fIcallProc\fR of the \fBTcl_MethodType\fR structure takes values of at
-least reference count 1 in its \fIobjv\fR argument. It may add its own
-references, but must not decrement the reference count below that level; the
-caller of the method will decrement the reference count once the method
-returns properly (and the reference will be held if the method \fByield\fRs).
 .SH "SEE ALSO"
-Class(3), NRE(3), oo::class(n), oo::define(n), oo::object(n)
+Class(3), oo::class(n), oo::define(n), oo::object(n)
 .SH KEYWORDS
 constructor, method, object

@@ -40,7 +40,7 @@ void
 .AS Tcl_CmdDeleteProc *interp in
 .AP Tcl_Interp *interp in
 The relevant Interpreter.
-.AP "const char" *cmdName in
+.AP char *cmdName in
 Name of the command to create.
 .AP Tcl_ObjCmdProc *proc in
 Called in order to evaluate a command.  Is often just a small wrapper that uses
@@ -227,25 +227,6 @@ int
 Any function comprising a routine can push other functions, making it possible
 implement looping and sequencing constructs using the function stack.
 .PP
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The first \fIobjc\fR values in the \fIobjv\fR array passed to the functions
-\fBTcl_NRCallObjProc\fR, \fBTcl_NREvalObjv\fR, and \fBTcl_NRCmdSwap\fR should
-have a reference count of at least 1; they may have additional references
-taken during the execution.
-.PP
-The \fIobjPtr\fR argument to \fBTcl_NREvalObj\fR and \fBTcl_NRExprObj\fR
-should have a reference count of at least 1, and may have additional
-references taken to it during execution.
-.PP
-The \fIresultObj\fR argument to \fBTcl_NRExprObj\fR should be an unshared
-object.
-.PP
-Use \fBTcl_NRAddCallback\fR to schedule any required final decrementing of the
-reference counts of arguments to any of the other functions on this page, as
-with any other post-processing step in the non-recursive execution engine.
-.PP
-The
 .SH "SEE ALSO"
 Tcl_CreateCommand(3), Tcl_CreateObjCommand(3), Tcl_EvalObjEx(3), Tcl_GetCommandFromObj(3), Tcl_ExprObj(3)
 .SH KEYWORDS
@@ -46,10 +46,10 @@ Tcl_Command
 \fBTcl_FindCommand\fR(\fIinterp, name, contextNsPtr, flags\fR)
 .sp
 Tcl_Obj *
-\fBTcl_GetNamespaceUnknownHandler\fR(\fIinterp, nsPtr\fR)
+\fBTcl_GetNamespaceUnknownHandler(\fIinterp, nsPtr\fR)
 .sp
 int
-\fBTcl_SetNamespaceUnknownHandler\fR(\fIinterp, nsPtr, handlerPtr\fR)
+\fBTcl_SetNamespaceUnknownHandler(\fIinterp, nsPtr, handlerPtr\fR)
 .SH ARGUMENTS
 .AS Tcl_NamespaceDeleteProc allowOverwrite in/out
 .AP Tcl_Interp *interp in/out
@@ -159,18 +159,6 @@ for the namespace, or NULL if none is set.
 \fBTcl_SetNamespaceUnknownHandler\fR sets the unknown command handler for
 the namespace. If \fIhandlerPtr\fR is NULL, then the handler is reset to
 its default.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The \fIobjPtr\fR argument to \fBTcl_AppendExportList\fR should be an
-unshared object, as it will be modified by this function. The
-reference count of \fIobjPtr\fR will not be altered.
-.PP
-\fBTcl_GetNamespaceUnknownHandler\fR returns a possibly shared value.
-Its reference count should be incremented if the value is to be
-retained.
-.PP
-The \fIhandlerPtr\fR argument to \fBTcl_SetNamespaceUnknownHandler\fR
-will have its reference count incremented if it is a non-empty list.
 .SH "SEE ALSO"
 Tcl_CreateCommand(3), Tcl_ListObjAppendList(3), Tcl_SetVar(3)
 .SH KEYWORDS
@@ -283,12 +283,7 @@ to reduce storage requirements.
 Reference counting is used to determine when a value is
 no longer needed and can safely be freed.
 A value just created by \fBTcl_NewObj\fR or \fBTcl_NewStringObj\fR
-has \fIrefCount\fR 0, meaning that the object can often be given to a function
-like \fBTcl_SetObjResult\fR, \fBTcl_ListObjAppendElement\fR, or
-\fBTcl_DictObjPut\fR (as a value) without explicit reference management, all
-of which are common use cases. (The latter two require that the the target
-list or dictionary be well-formed, but that is often easy to arrange when the
-value is being initially constructed.)
+has \fIrefCount\fR 0.
 The macro \fBTcl_IncrRefCount\fR increments the reference count
 when a new reference to the value is created.
 The macro \fBTcl_DecrRefCount\fR decrements the count
@@ -248,28 +248,6 @@ The \fIfreeIntRepProc\fR implementation must not access the
 uses of that field during value deletion.  The defined tasks for
 the \fIfreeIntRepProc\fR have no need to consult the \fIbytes\fR
 member.
-.PP
-Note that if a subsidiary value has its reference count reduced to zero
-during the running of a \fIfreeIntRepProc\fR, that value may be not freed
-immediately, in order to limit stack usage. However, the value will be freed
-before the outermost current \fBTcl_DecrRefCount\fR returns.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The \fIobjPtr\fR argument to \fBTcl_AppendAllObjTypes\fR should be an unshared
-value; this function will not modify the reference count of that value, but
-will modify its contents. If \fIobjPtr\fR is not (interpretable as) a list,
-this function will set the interpreter result and produce an error; using an
-unshared empty value is strongly recommended.
-.PP
-The \fIobjPtr\fR argument to \fBTcl_ConvertToType\fR can have any non-zero
-reference count; this function will not modify the reference count, but may
-write to the interpreter result on error so values that originate from there
-should have an additional reference made before calling this.
-.PP
-None of the callback functions in the \fBTcl_ObjType\fR structure should
-modify the reference count of their arguments, but if the values contain
-subsidiary values (e.g., the elements of a list or the keys of a dictionary)
-then those subsidiary values may have their reference counts modified.
 .SH "SEE ALSO"
 Tcl_NewObj(3), Tcl_DecrRefCount(3), Tcl_IncrRefCount(3)
 .SH KEYWORDS
@@ -641,24 +641,6 @@ the channel was created with \fBTcl_OpenFileChannel\fR,
 \fBTcl_OpenCommandChannel\fR, or \fBTcl_MakeFileChannel\fR.  Other
 channel types may return a different type of handle on Windows
 platforms.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The \fIreadObjPtr\fR argument to \fBTcl_ReadChars\fR must be an unshared
-value; it will be modified by this function.  Using the interpreter result for
-this purpose is \fIstrongly\fR not recommended; the preferred pattern is to
-use a new value from \fBTcl_NewObj\fR to receive the data and only to pass it
-to \fBTcl_SetObjResult\fR if this function succeeds.
-.PP
-The \fIlineObjPtr\fR argument to \fBTcl_GetsObj\fR must be an unshared value;
-it will be modified by this function.  Using the interpreter result for this
-purpose is \fIstrongly\fR not recommended; the preferred pattern is to use a
-new value from \fBTcl_NewObj\fR to receive the data and only to pass it to
-\fBTcl_SetObjResult\fR if this function succeeds.
-.PP
-The \fIwriteObjPtr\fR argument to \fBTcl_WriteObj\fR should be a value with
-any reference count. This function will not modify the reference count. Using
-the interpreter result without adding an additional reference to it is not
-recommended.
 .SH "SEE ALSO"
 DString(3), fconfigure(n), filename(n), fopen(3), Tcl_CreateChannel(3)
 .SH KEYWORDS
@@ -189,12 +189,6 @@ will be stored at \fIdstPtr\fR; the string inside will have a lifetime linked
 to the lifetime of the string representation of the argument value that it
 came from, and so should be copied if it needs to be retained. The
 \fIsrcPtr\fR and \fIclientData\fR fields are ignored.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The values in the \fIobjv\fR argument to \fBTcl_ParseArgsObjv\fR will not have
-their reference counts modified by this function. The interpreter result may
-be modified on error; the values passed should not be the interpreter result
-with no further reference added.
 .SH "SEE ALSO"
 Tcl_GetIndexFromObj(3), Tcl_Main(3), Tcl_CreateObjCommand(3)
 .SH KEYWORDS
@@ -191,7 +191,6 @@ code with one of the values \fBTCL_OK\fR, \fBTCL_ERROR\fR,
 some other integer value originating in an extension.
 In addition, a result value or error message is left in \fIinterp\fR's
 result; it can be retrieved using \fBTcl_GetObjResult\fR.
-.SS "DEPRECATED FUNCTIONS"
 .PP
 \fBTcl_EvalTokens\fR differs from \fBTcl_EvalTokensStandard\fR only in
 the return convention used: it returns the result in a new Tcl_Obj.
@@ -464,12 +463,5 @@ There are additional fields in the Tcl_Parse structure after the
 \fBTcl_ParseCommand\fR, \fBTcl_ParseExpr\fR, \fBTcl_ParseBraces\fR,
 \fBTcl_ParseQuotedString\fR, and \fBTcl_ParseVarName\fR; they should not be
 referenced by code outside of these procedures.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The result of \fBTcl_EvalTokens\fR is an unshared value with a reference count
-of 1; the caller of that function should call \fBTcl_DecrRefCount\fR on the
-result value to dispose of it. (The equivalent with
-\fBTcl_EvalTokenStandard\fR is just the interpreter result, which can be
-retrieved with \fBTcl_GetObjResult\fR.)
 .SH KEYWORDS
 backslash substitution, braces, command, expression, parse, token, variable substitution
@@ -91,10 +91,6 @@ functions.
 \fBTcl_PkgRequireProc\fR is the form of \fBpackage require\fR handling
 multiple requirements. The other forms are present for backward
 compatibility and translate their invocations to this form.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The requirements values given (in the \fIobjv\fR argument) to
-\fBTcl_PkgRequireProc\fR must have non-zero reference counts.
 .SH KEYWORDS
 package, present, provide, require, version
 .SH "SEE ALSO"
@@ -44,12 +44,6 @@ allow the user to re-issue recently invoked commands.
 If the \fIflags\fR argument contains the \fBTCL_NO_EVAL\fR bit then
 the command is recorded without being evaluated.

-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The reference count of the \fIcmdPtr\fR argument to \fBTcl_RecordAndEvalObj\fR
-must be at least 1. This function will modify the interpreter result; do not
-use an existing result as \fIcmdPtr\fR directly without incrementing its
-reference count.
 .SH "SEE ALSO"
 Tcl_EvalObjEx, Tcl_GetObjResult

@@ -51,14 +51,14 @@ can be efficiently searched.
 .AP Tcl_Obj *patObj in/out
 Refers to the value from which to get a regular expression. The
 compiled regular expression is cached in the value.
-.AP "const char" *text in
+.AP char *text in
 Text to search for a match with a regular expression.
 .AP "const char" *pattern in
 String in the form of a regular expression pattern.
 .AP Tcl_RegExp regexp in
 Compiled regular expression.  Must have been returned previously
 by \fBTcl_GetRegExpFromObj\fR or \fBTcl_RegExpCompile\fR.
-.AP "const char" *start in
+.AP char *start in
 If \fItext\fR is just a portion of some other string, this argument
 identifies the beginning of the larger string.
 If it is not the same as \fItext\fR, then no
@@ -377,22 +377,6 @@ If no match was found, then it indicates the earliest point at which a
 match might occur if additional text is appended to the string.  If it
 is no match is possible even with further text, this field will be set
 to \-1.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The \fItextObj\fR and \fIpatObj\fR arguments to \fBTcl_RegExpMatchObj\fR must
-have reference counts of at least 1.  Note however that this function may set
-the interpreter result; neither argument should be the direct interpreter
-result without an additional reference being taken.
-.PP
-The \fIpatObj\fR argument to \fBTcl_GetRegExpFromObj\fR must have a reference
-count of at least 1.  Note however that this function may set the interpreter
-result; the argument should not be the direct interpreter result without an
-additional reference being taken.
-.PP
-The \fItextObj\fR argument to \fBTcl_RegExpExecObj\fR must have a reference
-count of at least 1.  Note however that this function may set the interpreter
-result; the argument should not be the direct interpreter result without an
-additional reference being taken.
 .SH "SEE ALSO"
 re_syntax(n)
 .SH KEYWORDS
@@ -35,20 +35,20 @@ Refers to the Tcl interpreter whose bypass area is accessed.
 .AP Tcl_Obj* msg in
 Error message put into a bypass area. A list of return options and values,
 followed by a string message. Both message and the option/value information
-are optional. This \fImust\fR be a well-formed list.
+are optional.
 .AP Tcl_Obj** msgPtr out
 Reference to a place where the message stored in the accessed bypass area can
 be stored in.
 .BE
 .SH DESCRIPTION
 .PP
-The standard definition of a Tcl channel driver does not permit the direct
+The current definition of a Tcl channel driver does not permit the direct
 return of arbitrary error messages, except for the setting and retrieval of
 channel options. All other functions are restricted to POSIX error codes.
 .PP
 The functions described here overcome this limitation. Channel drivers are
 allowed to use \fBTcl_SetChannelError\fR and \fBTcl_SetChannelErrorInterp\fR
-to place arbitrary error messages in \fIbypass areas\fR defined for channels
+to place arbitrary error messages in \fBbypass areas\fR defined for channels
 and interpreters. And the generic I/O layer uses \fBTcl_GetChannelError\fR and
 \fBTcl_GetChannelErrorInterp\fR to look for messages in the bypass areas and
 arrange for their return as errors. The POSIX error codes set by a driver are
@@ -134,15 +134,6 @@ leave all their error information in the interpreter result.
 .ta 1.9i 4i
 \fBTcl_Close\fR	\fBTcl_UnstackChannel\fR	\fBTcl_UnregisterChannel\fR
 .DE
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The \fImsg\fR argument to \fBTcl_SetChannelError\fR and
-\fBTcl_SetChannelErrorInterp\fR, if not NULL, may have any reference count;
-these functions will copy.
-.PP
-\fBTcl_GetChannelError\fR and \fBTcl_GetChannelErrorInterp\fR write a value
-reference into their \fImsgPtr\fR, but do not manipulate its reference count.
-The reference count will be at least 1 (unless the reference is NULL).
 .SH "SEE ALSO"
 Tcl_Close(3), Tcl_OpenFileChannel(3), Tcl_SetErrno(3)
 .SH KEYWORDS
@@ -239,33 +239,6 @@ typedef void \fBTcl_FreeProc\fR(
 .PP
 When \fIfreeProc\fR is called, its \fIblockPtr\fR will be set to
 the value of \fIresult\fR passed to \fBTcl_SetResult\fR.
-
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The interpreter result is one of the main places that owns references to
-values, along with the bytecode execution stack, argument lists, variables,
-and the list and dictionary collection values.
-.PP
-\fBTcl_SetObjResult\fR takes a value with an arbitrary reference count
-\fI(specifically including zero)\fR and guarantees to increment the reference
-count. If code wishes to continue using the value after setting it as the
-result, it should add its own reference to it with \fBTcl_IncrRefCount\fR.
-.PP
-\fBTcl_GetObjResult\fR returns the current interpreter result value. This will
-have a reference count of at least 1. If the caller wishes to keep the
-interpreter result value, it should increment its reference count.
-.PP
-\fBTcl_GetStringResult\fR does not manipulate reference counts, but the string
-it returns is owned by (and has a lifetime controlled by) the current
-interpreter result value; it should be copied instead of being relied upon to
-persist after the next Tcl API call, as most Tcl operations can modify the
-interpreter result.
-.PP
-\fBTcl_SetResult\fR, \fBTcl_AppendResult\fR, \fBTcl_AppendResultVA\fR,
-\fBTcl_AppendElement\fR, and \fBTcl_ResetResult\fR all modify the interpreter
-result. They may cause the old interpreter result to have its reference count
-decremented and a new interpreter result to be allocated. After they have been
-called, the reference count of the interpreter result is guaranteed to be 1.
 .SH "SEE ALSO"
 Tcl_AddErrorInfo, Tcl_CreateObjCommand, Tcl_SetErrorCode, Tcl_Interp,
 Tcl_GetReturnOptions
@@ -242,27 +242,6 @@ but the array remains.
 If an array name is specified without an index, then the entire
 array is removed.

-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The result of \fBTcl_SetVar2Ex\fR, \fBTcl_ObjSetVar2\fR, \fBTcl_GetVar2Ex\fR,
-and \fBTcl_ObjGetVar2\fR is (if non-NULL) a value with a reference of at least
-1, where that reference is held by the variable that the function has just
-operated upon.
-.PP
-The \fInewValuePtr\fR argument to \fBTcl_SetVar2Ex\fR and \fBTcl_ObjSetVar2\fR
-may be an arbitrary reference count value; its reference count will be
-incremented on success. However, it is recommended to not use a zero reference
-count value, as that makes correct handling of the error case tricky.
-.PP
-The \fIpart1\fR argument to \fBTcl_ObjSetVar2\fR and \fBTcl_ObjGetVar2\fR can
-have any reference count; these functions never modify it. It is recommended
-to not use a zero reference count for this argument.
-.PP
-The \fIpart2\fR argument to \fBTcl_ObjSetVar2\fR and \fBTcl_ObjGetVar2\fR, if
-non-NULL, should not have a zero reference count as these functions may
-retain a reference to it (particularly when it is used to create an array
-element that did not previously exist).
-
 .SH "SEE ALSO"
 Tcl_GetObjResult, Tcl_GetStringResult, Tcl_TraceVar

@@ -36,7 +36,7 @@ int
 .AP Tcl_Interp *interp out
 Interpreter to use for error reporting.  If NULL, then no error message
 is left.
-.AP "const char" *list in
+.AP char *list in
 Pointer to a string with proper list structure.
 .AP int *argcPtr out
 Filled in with number of elements in \fIlist\fR.
@@ -383,33 +383,6 @@ white space, then that value is ignored entirely. This white-space
 removal was added to make the output of the \fBconcat\fR command
 cleaner-looking. \fBTcl_ConcatObj\fR returns a pointer to a
 newly-created value whose ref count is zero.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_NewStringObj\fR, \fBTcl_NewUnicodeObj\fR, \fBTcl_Format\fR,
-\fBTcl_ObjPrintf\fR, and \fBTcl_ConcatObj\fR always return a zero-reference
-object, much like \fBTcl_NewObj\fR.
-.PP
-\fBTcl_GetStringFromObj\fR, \fBTcl_GetString\fR, \fBTcl_GetUnicodeFromObj\fR,
-\fBTcl_GetUnicode\fR, \fBTcl_GetUniChar\fR, \fBTcl_GetCharLength\fR, and
-\fBTcl_GetRange\fR all only work with an existing value; they do not
-manipulate its reference count in any way.
-.PP
-\fBTcl_SetStringObj\fR, \fBTcl_SetUnicodeObj\fR, \fBTcl_AppendToObj\fR,
-\fBTcl_AppendUnicodeToObj\fR, \fBTcl_AppendObjToObj\fR,
-\fBTcl_AppendStringsToObj\fR, \fBTcl_AppendStringsToObjVA\fR,
-\fBTcl_AppendLimitedToObj\fR, \fBTcl_AppendFormatToObj\fR,
-\fBTcl_AppendPrintfToObj\fR, \fBTcl_SetObjLength\fR, and
-\fBTcl_AttemptSetObjLength\fR and require their \fIobjPtr\fR to be an unshared
-value (i.e, a reference count no more than 1) as they will modify it.
-.PP
-Additional arguments to the above functions (the \fIappendObjPtr\fR argument
-to \fBTcl_AppendObjToObj\fR, values in the \fIobjv\fR argument to
-\fBTcl_Format\fR, \fBTcl_AppendFormatToObj\fR, and \fBTcl_ConcatObj\fR) can
-have any reference count, but reference counts of zero are not recommended.
-.PP
-\fBTcl_Format\fR and \fBTcl_AppendFormatToObj\fR may modify the interpreter
-result, which involves changing the reference count of a value.
-
 .SH "SEE ALSO"
 Tcl_NewObj(3), Tcl_IncrRefCount(3), Tcl_DecrRefCount(3), format(n), sprintf(3)
 .SH KEYWORDS
@@ -62,13 +62,6 @@ result of the whole substitution on \fIobjPtr\fR will be truncated at
 the point immediately before the start of the command substitution,
 and no characters will be added to the result or substitutions
 performed after that point.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The \fIobjPtr\fR argument to \fBTcl_SubstObj\fR must not have a reference
-count of zero. This function modifies the interpreter result, both on success
-and on failure; the result of this function on success is exactly the current
-interpreter result. Successful results should have their reference count
-incremented if they are to be retained.
 .SH "SEE ALSO"
 subst(n)
 .SH KEYWORDS
@@ -262,31 +262,6 @@ file named by the \fBfilename\fR field was modified. Suitable for use with
 .
 The type of the uncompressed data (either \fBbinary\fR or \fBtext\fR) if
 known.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_ZlibDeflate\fR and \fBTcl_ZlibInflate\fR take a value with arbitrary
-reference count for their \fIdataObj\fR and \fIdictObj\fR arguments (the
-latter often being NULL instead), and set the interpreter result with their
-output value (or an error).  The existing interpreter result should not be
-passed as any argument value unless an additional reference is held.
-.PP
-\fBTcl_ZlibStreamInit\fR takes a value with arbitrary reference count for its
-\fIdictObj\fR argument; it only reads from it. The existing interpreter result
-should not be passed unless an additional reference is held.
-.PP
-\fBTcl_ZlibStreamGetCommandName\fR returns a zero reference count value, much
-like \fBTcl_NewObj\fR.
-.PP
-The \fIdataObj\fR argument to \fBTcl_ZlibStreamPut\fR is a value with
-arbitrary reference count; it is only ever read from.
-.PP
-The \fIdataObj\fR argument to \fBTcl_ZlibStreamGet\fR is an unshared value
-(see \fBTcl_IsShared\fR) that will be updated by the function.
-.PP
-The \fIcompDict\fR argument to \fBTcl_ZlibStreamSetCompressionDictionary\fR,
-if non-NULL, may be duplicated or may have its reference count incremented.
-Using a zero reference count value is not recommended.
-
 .SH "PORTABILITY NOTES"
 These functions will fail gracefully if Tcl is not linked with the zlib
 library.
@@ -201,15 +201,6 @@ procedure (if any) returns, \fBTcl_Main\fR will also evaluate
 the \fBexit\fR command.
 .PP
 \fBTcl_Main\fR can not be used in stub-enabled extensions.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-\fBTcl_SetStartupScript\fR takes a value (or NULL) for its \fIpath\fR
-argument, and will increment the reference count of it.
-.PP
-\fBTcl_GetStartupScript\fR returns a value with reference count at least 1, or
-NULL. It's \fIencodingPtr\fR is also used (if non-NULL) to return a value with
-a reference count at least 1, or NULL. In both cases, the owner of the values
-is the current thread.
 .SH "SEE ALSO"
 tclsh(1), Tcl_GetStdChannel(3), Tcl_StandardChannels(3), Tcl_AppInit(3),
 exit(n), encoding(n)
@@ -359,14 +359,6 @@ Traces on a variable are always removed whenever the variable
 is deleted;  the only time \fBTCL_TRACE_DESTROYED\fR is not set is for
 a whole-array trace invoked when only a single element of an
 array is unset.
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-When a \fIproc\fR callback is invoked, and that callback was installed with
-the \fBTCL_TRACE_RESULT_OBJECT\fR flag, the result of the callback is a
-Tcl_Obj reference when there is an error. The result will have its reference
-count decremented once when no longer needed, or may have additional
-references made to it (e.g., by setting it as the interpreter result with
-\fBTcl_SetObjResult\fR).
 .SH BUGS
 .PP
 Array traces are not yet integrated with the Tcl \fBinfo exists\fR command,
@@ -8,7 +8,7 @@
 .so man.macros
 .BS
 .SH NAME
-Tcl_UniCharIsAlnum, Tcl_UniCharIsAlpha, Tcl_UniCharIsControl, Tcl_UniCharIsDigit, Tcl_UniCharIsGraph, Tcl_UniCharIsLower, Tcl_UniCharIsPrint, Tcl_UniCharIsPunct, Tcl_UniCharIsSpace, Tcl_UniCharIsUpper, Tcl_UniCharIsUnicode, Tcl_UniCharIsWordChar \- routines for classification of Tcl_UniChar characters
+Tcl_UniCharIsAlnum, Tcl_UniCharIsAlpha, Tcl_UniCharIsControl, Tcl_UniCharIsDigit, Tcl_UniCharIsGraph, Tcl_UniCharIsLower, Tcl_UniCharIsPrint, Tcl_UniCharIsPunct, Tcl_UniCharIsSpace, Tcl_UniCharIsUpper, Tcl_UniCharIsWordChar \- routines for classification of Tcl_UniChar characters
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -44,9 +44,6 @@ int
 \fBTcl_UniCharIsUpper\fR(\fIch\fR)
 .sp
 int
-\fBTcl_UniCharIsUnicode\fR(\fIch\fR)
-.sp
-int
 \fBTcl_UniCharIsWordChar\fR(\fIch\fR)
 .SH ARGUMENTS
 .AS int ch
@@ -84,9 +81,6 @@ with the various routines.
 .PP
 \fBTcl_UniCharIsUpper\fR tests if the character is an uppercase Unicode character.
 .PP
-\fBTcl_UniCharIsUnicode\fR tests if the character is a Unicode character, not being
-a surrogate or noncharacter.
-.PP
 \fBTcl_UniCharIsWordChar\fR tests if the character is alphanumeric or
 a connector punctuation mark.

@@ -73,12 +73,6 @@ is now an \fIindexObject\fR because it was passed to
 .CS
 wrong # args: should be "foo barfly fileName count"
 .CE
-.SH "REFERENCE COUNT MANAGEMENT"
-.PP
-The \fIobjv\fR argument to \fBTcl_WrongNumArgs\fR should be the exact
-arguments passed to the command or method implementation function that is
-calling \fBTcl_WrongNumArgs\fR. As such, all values referenced in it should
-have reference counts greater than zero; this is usually a non-issue.
 .SH "SEE ALSO"
 Tcl_GetIndexFromObj(3)
 .SH KEYWORDS
@@ -823,7 +823,7 @@ the minus sign one west of Greenwich.
 A time zone string conforming to the Posix specification of the \fBTZ\fR
 environment variable will be recognized.  The specification
 may be found at
-\fIhttps://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap08.html\fR.
+\fIhttp://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap08.html\fR.
 .PP
 If the Posix time zone string contains a DST (Daylight Savings Time)
 part, but doesn't contain a rule stating when DST starts or ends,
@@ -847,7 +847,7 @@ to use it as a location name, as above.
 .SH "LOCALIZATION"
 .PP
 Developers wishing to localize the date and time formatting and parsing
-are referred to \fIhttps://tip.tcl-lang.org/173\fR for a
+are referred to \fIhttp://tip.tcl.tk/173\fR for a
 specification.
 .SH "FREE FORM SCAN"
 .PP
@@ -182,7 +182,7 @@ set cookiedb ~/.tclcookies.db
 http::configure -cookiejar [\fBhttp::cookiejar new\fR $cookiedb]

 # No further explicit steps are required to use cookies
-set tok [http::geturl http://core.tcl-lang.org/]
+set tok [http::geturl http://core.tcl.tk/]
 .CE
 .PP
 To only allow a particular domain to use cookies, perhaps because you only
@@ -205,7 +205,7 @@ set cookiedb ~/.tclcookies.db
 http::configure -cookiejar [MyCookieJar new $cookiedb]

 # No further explicit steps are required to use cookies
-set tok [http::geturl http://core.tcl-lang.org/]
+set tok [http::geturl http://core.tcl.tk/]
 .CE
 .SH "SEE ALSO"
 http(n), oo::class(n), sqlite3(n)
@@ -172,7 +172,7 @@ particularly important website:
 .PP
 .CS
 package require dde
-\fBdde execute\fR -async iexplore WWW_OpenURL http://www.tcl-lang.org/
+\fBdde execute\fR -async iexplore WWW_OpenURL http://www.tcl.tk/
 .CE
 .SH "SEE ALSO"
 tk(n), winfo(n), send(n)
@@ -81,13 +81,29 @@ omitted then the command returns the current system encoding.  The
 system encoding is used whenever Tcl passes strings to system calls.
 .SH EXAMPLE
 .PP
-The following example converts a byte sequence in Japanese euc-jp encoding to a TCL string:
+It is common practice to write script files using a text editor that
+produces output in the euc-jp encoding, which represents the ASCII
+characters as singe bytes and Japanese characters as two bytes.  This
+makes it easy to embed literal strings that correspond to non-ASCII
+characters by simply typing the strings in place in the script.
+However, because the \fBsource\fR command always reads files using the
+current system encoding, Tcl will only source such files correctly
+when the encoding used to write the file is the same.  This tends not
+to be true in an internationalized setting.  For example, if such a
+file was sourced in North America (where the ISO8859\-1 is normally
+used), each byte in the file would be treated as a separate character
+that maps to the 00 page in Unicode.  The resulting Tcl strings will
+not contain the expected Japanese characters.  Instead, they will
+contain a sequence of Latin-1 characters that correspond to the bytes
+of the original string.  The \fBencoding\fR command can be used to
+convert this string to the expected Japanese Unicode characters.  For
+example,
 .PP
 .CS
 set s [\fBencoding convertfrom\fR euc-jp "\exA4\exCF"]
 .CE
 .PP
-The result is the unicode codepoint:
+would return the Unicode string
 .QW "\eu306F" ,
 which is the Hiragana letter HA.
 .SH "SEE ALSO"
@@ -6,14 +6,14 @@
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 '\"
-.TH "http" n 2.10 http "Tcl Bundled Packages"
+.TH "http" n 2.9 http "Tcl Bundled Packages"
 .so man.macros
 .BS
 '\" Note:  do not modify the .SH NAME line immediately below!
 .SH NAME
 http \- Client-side implementation of the HTTP/1.1 protocol
 .SH SYNOPSIS
-\fBpackage require http\fI ?\fB2.10\fR?
+\fBpackage require http\fI ?\fB2.9\fR?
 .\" See Also -useragent option documentation in body!
 .sp
 \fB::http::config\fR ?\fI\-option value\fR ...?
@@ -735,7 +735,7 @@ To register to a callback, use:
 namespace eval gui {
    msgcat::mcpackageconfig changecmd updateGUI

-    proc updateGUI args {
+    proc updateGui args {
        puts "New locale is '[lindex $args 0]'."
    }
 }
@@ -769,7 +769,7 @@ msgcat::mcpackageconfig unknowncmd ""
 .CE
 As an example, the user requires the week day in a certain locale as follows:
 .CS
-clock format [clock seconds] -format %A -locale fr
+clock format clock seconds -format %A -locale fr
 .CE
 \fBclock\fR sets the package locale to \fBfr\fR and looks for the day name as follows:
 .CS
@@ -319,10 +319,9 @@ specified as for the \fBindex\fR method.  If \fInewstring\fR is
 specified, then it is placed in the removed character range.  If
 \fIfirst\fR is less than zero then it is treated as if it were zero,
 and if \fIlast\fR is greater than or equal to the length of the string
-then it is treated as if it were \fBend\fR.  The initial string is
-returned untouched, if \fIfirst\fR is greater than \fIlast\fR, or if
-\fIfirst\fR is equal to or greater than the length of the initial string,
-or \fIlast\fR is less than 0.
+then it is treated as if it were \fBend\fR.  If \fIfirst\fR is greater
+than \fIlast\fR or the length of the initial string, or \fIlast\fR is
+less than 0, then the initial string is returned untouched.
 .TP
 \fBstring reverse \fIstring\fR
 .
@@ -414,10 +413,10 @@ store the representation is of very low value (except to C extension
 code, which has direct access for the purpose of memory management,
 etc.)
 .PP
-\fICompatibility note:\fR This subcommand is deprecated and will
-be removed in Tcl 9.0. It is better to use the \fBencoding convertto\fR
-command to convert a string to a known encoding (e.g. "utf-8" or "cesu-8")
-and then apply \fBstring length\fR to that.
+\fICompatibility note:\fR it is likely that this subcommand will be
+withdrawn in a future version of Tcl. It is better to use the
+\fBencoding convertto\fR command to convert a string to a known
+encoding and then apply \fBstring length\fR to that.
 .PP
 .CS
 \fBstring length\fR [encoding convertto utf-8 $theString]
@@ -298,9 +298,9 @@ environment variables:
 .SH "SEE ALSO"
 package(n), Tcl Improvement Proposal #189
 .QW "\fITcl Modules\fR"
-(online at https://tip.tcl-lang.org/189.html), Tcl Improvement Proposal #190
+(online at http://tip.tcl.tk/189.html), Tcl Improvement Proposal #190
 .QW "\fIImplementation Choices for Tcl Modules\fR"
-(online at https://tip.tcl-lang.org/190.html)
+(online at http://tip.tcl.tk/190.html)
 .SH "KEYWORDS"
 modules, package
 .\" Local Variables:
@@ -140,34 +140,34 @@ static const crange alphaRangeTable[] = {
    {0x3F7, 0x481}, {0x48A, 0x52F}, {0x531, 0x556}, {0x560, 0x588},
    {0x5D0, 0x5EA}, {0x5EF, 0x5F2}, {0x620, 0x64A}, {0x671, 0x6D3},
    {0x6FA, 0x6FC}, {0x712, 0x72F}, {0x74D, 0x7A5}, {0x7CA, 0x7EA},
-    {0x800, 0x815}, {0x840, 0x858}, {0x860, 0x86A}, {0x870, 0x887},
-    {0x889, 0x88E}, {0x8A0, 0x8C9}, {0x904, 0x939}, {0x958, 0x961},
-    {0x971, 0x980}, {0x985, 0x98C}, {0x993, 0x9A8}, {0x9AA, 0x9B0},
-    {0x9B6, 0x9B9}, {0x9DF, 0x9E1}, {0xA05, 0xA0A}, {0xA13, 0xA28},
-    {0xA2A, 0xA30}, {0xA59, 0xA5C}, {0xA72, 0xA74}, {0xA85, 0xA8D},
-    {0xA8F, 0xA91}, {0xA93, 0xAA8}, {0xAAA, 0xAB0}, {0xAB5, 0xAB9},
-    {0xB05, 0xB0C}, {0xB13, 0xB28}, {0xB2A, 0xB30}, {0xB35, 0xB39},
-    {0xB5F, 0xB61}, {0xB85, 0xB8A}, {0xB8E, 0xB90}, {0xB92, 0xB95},
-    {0xBA8, 0xBAA}, {0xBAE, 0xBB9}, {0xC05, 0xC0C}, {0xC0E, 0xC10},
-    {0xC12, 0xC28}, {0xC2A, 0xC39}, {0xC58, 0xC5A}, {0xC85, 0xC8C},
-    {0xC8E, 0xC90}, {0xC92, 0xCA8}, {0xCAA, 0xCB3}, {0xCB5, 0xCB9},
-    {0xD04, 0xD0C}, {0xD0E, 0xD10}, {0xD12, 0xD3A}, {0xD54, 0xD56},
-    {0xD5F, 0xD61}, {0xD7A, 0xD7F}, {0xD85, 0xD96}, {0xD9A, 0xDB1},
-    {0xDB3, 0xDBB}, {0xDC0, 0xDC6}, {0xE01, 0xE30}, {0xE40, 0xE46},
-    {0xE86, 0xE8A}, {0xE8C, 0xEA3}, {0xEA7, 0xEB0}, {0xEC0, 0xEC4},
-    {0xEDC, 0xEDF}, {0xF40, 0xF47}, {0xF49, 0xF6C}, {0xF88, 0xF8C},
-    {0x1000, 0x102A}, {0x1050, 0x1055}, {0x105A, 0x105D}, {0x106E, 0x1070},
-    {0x1075, 0x1081}, {0x10A0, 0x10C5}, {0x10D0, 0x10FA}, {0x10FC, 0x1248},
-    {0x124A, 0x124D}, {0x1250, 0x1256}, {0x125A, 0x125D}, {0x1260, 0x1288},
-    {0x128A, 0x128D}, {0x1290, 0x12B0}, {0x12B2, 0x12B5}, {0x12B8, 0x12BE},
-    {0x12C2, 0x12C5}, {0x12C8, 0x12D6}, {0x12D8, 0x1310}, {0x1312, 0x1315},
-    {0x1318, 0x135A}, {0x1380, 0x138F}, {0x13A0, 0x13F5}, {0x13F8, 0x13FD},
-    {0x1401, 0x166C}, {0x166F, 0x167F}, {0x1681, 0x169A}, {0x16A0, 0x16EA},
-    {0x16F1, 0x16F8}, {0x1700, 0x1711}, {0x171F, 0x1731}, {0x1740, 0x1751},
+    {0x800, 0x815}, {0x840, 0x858}, {0x860, 0x86A}, {0x8A0, 0x8B4},
+    {0x8B6, 0x8C7}, {0x904, 0x939}, {0x958, 0x961}, {0x971, 0x980},
+    {0x985, 0x98C}, {0x993, 0x9A8}, {0x9AA, 0x9B0}, {0x9B6, 0x9B9},
+    {0x9DF, 0x9E1}, {0xA05, 0xA0A}, {0xA13, 0xA28}, {0xA2A, 0xA30},
+    {0xA59, 0xA5C}, {0xA72, 0xA74}, {0xA85, 0xA8D}, {0xA8F, 0xA91},
+    {0xA93, 0xAA8}, {0xAAA, 0xAB0}, {0xAB5, 0xAB9}, {0xB05, 0xB0C},
+    {0xB13, 0xB28}, {0xB2A, 0xB30}, {0xB35, 0xB39}, {0xB5F, 0xB61},
+    {0xB85, 0xB8A}, {0xB8E, 0xB90}, {0xB92, 0xB95}, {0xBA8, 0xBAA},
+    {0xBAE, 0xBB9}, {0xC05, 0xC0C}, {0xC0E, 0xC10}, {0xC12, 0xC28},
+    {0xC2A, 0xC39}, {0xC58, 0xC5A}, {0xC85, 0xC8C}, {0xC8E, 0xC90},
+    {0xC92, 0xCA8}, {0xCAA, 0xCB3}, {0xCB5, 0xCB9}, {0xD04, 0xD0C},
+    {0xD0E, 0xD10}, {0xD12, 0xD3A}, {0xD54, 0xD56}, {0xD5F, 0xD61},
+    {0xD7A, 0xD7F}, {0xD85, 0xD96}, {0xD9A, 0xDB1}, {0xDB3, 0xDBB},
+    {0xDC0, 0xDC6}, {0xE01, 0xE30}, {0xE40, 0xE46}, {0xE86, 0xE8A},
+    {0xE8C, 0xEA3}, {0xEA7, 0xEB0}, {0xEC0, 0xEC4}, {0xEDC, 0xEDF},
+    {0xF40, 0xF47}, {0xF49, 0xF6C}, {0xF88, 0xF8C}, {0x1000, 0x102A},
+    {0x1050, 0x1055}, {0x105A, 0x105D}, {0x106E, 0x1070}, {0x1075, 0x1081},
+    {0x10A0, 0x10C5}, {0x10D0, 0x10FA}, {0x10FC, 0x1248}, {0x124A, 0x124D},
+    {0x1250, 0x1256}, {0x125A, 0x125D}, {0x1260, 0x1288}, {0x128A, 0x128D},
+    {0x1290, 0x12B0}, {0x12B2, 0x12B5}, {0x12B8, 0x12BE}, {0x12C2, 0x12C5},
+    {0x12C8, 0x12D6}, {0x12D8, 0x1310}, {0x1312, 0x1315}, {0x1318, 0x135A},
+    {0x1380, 0x138F}, {0x13A0, 0x13F5}, {0x13F8, 0x13FD}, {0x1401, 0x166C},
+    {0x166F, 0x167F}, {0x1681, 0x169A}, {0x16A0, 0x16EA}, {0x16F1, 0x16F8},
+    {0x1700, 0x170C}, {0x170E, 0x1711}, {0x1720, 0x1731}, {0x1740, 0x1751},
    {0x1760, 0x176C}, {0x176E, 0x1770}, {0x1780, 0x17B3}, {0x1820, 0x1878},
    {0x1880, 0x1884}, {0x1887, 0x18A8}, {0x18B0, 0x18F5}, {0x1900, 0x191E},
    {0x1950, 0x196D}, {0x1970, 0x1974}, {0x1980, 0x19AB}, {0x19B0, 0x19C9},
-    {0x1A00, 0x1A16}, {0x1A20, 0x1A54}, {0x1B05, 0x1B33}, {0x1B45, 0x1B4C},
+    {0x1A00, 0x1A16}, {0x1A20, 0x1A54}, {0x1B05, 0x1B33}, {0x1B45, 0x1B4B},
    {0x1B83, 0x1BA0}, {0x1BBA, 0x1BE5}, {0x1C00, 0x1C23}, {0x1C4D, 0x1C4F},
    {0x1C5A, 0x1C7D}, {0x1C80, 0x1C88}, {0x1C90, 0x1CBA}, {0x1CBD, 0x1CBF},
    {0x1CE9, 0x1CEC}, {0x1CEE, 0x1CF3}, {0x1D00, 0x1DBF}, {0x1E00, 0x1F15},
@@ -176,78 +176,74 @@ static const crange alphaRangeTable[] = {
    {0x1FC6, 0x1FCC}, {0x1FD0, 0x1FD3}, {0x1FD6, 0x1FDB}, {0x1FE0, 0x1FEC},
    {0x1FF2, 0x1FF4}, {0x1FF6, 0x1FFC}, {0x2090, 0x209C}, {0x210A, 0x2113},
    {0x2119, 0x211D}, {0x212A, 0x212D}, {0x212F, 0x2139}, {0x213C, 0x213F},
-    {0x2145, 0x2149}, {0x2C00, 0x2CE4}, {0x2CEB, 0x2CEE}, {0x2D00, 0x2D25},
-    {0x2D30, 0x2D67}, {0x2D80, 0x2D96}, {0x2DA0, 0x2DA6}, {0x2DA8, 0x2DAE},
-    {0x2DB0, 0x2DB6}, {0x2DB8, 0x2DBE}, {0x2DC0, 0x2DC6}, {0x2DC8, 0x2DCE},
-    {0x2DD0, 0x2DD6}, {0x2DD8, 0x2DDE}, {0x3031, 0x3035}, {0x3041, 0x3096},
-    {0x309D, 0x309F}, {0x30A1, 0x30FA}, {0x30FC, 0x30FF}, {0x3105, 0x312F},
-    {0x3131, 0x318E}, {0x31A0, 0x31BF}, {0x31F0, 0x31FF}, {0x3400, 0x4DBF},
-    {0x4E00, 0xA48C}, {0xA4D0, 0xA4FD}, {0xA500, 0xA60C}, {0xA610, 0xA61F},
-    {0xA640, 0xA66E}, {0xA67F, 0xA69D}, {0xA6A0, 0xA6E5}, {0xA717, 0xA71F},
-    {0xA722, 0xA788}, {0xA78B, 0xA7CA}, {0xA7D5, 0xA7D9}, {0xA7F2, 0xA801},
-    {0xA803, 0xA805}, {0xA807, 0xA80A}, {0xA80C, 0xA822}, {0xA840, 0xA873},
-    {0xA882, 0xA8B3}, {0xA8F2, 0xA8F7}, {0xA90A, 0xA925}, {0xA930, 0xA946},
-    {0xA960, 0xA97C}, {0xA984, 0xA9B2}, {0xA9E0, 0xA9E4}, {0xA9E6, 0xA9EF},
-    {0xA9FA, 0xA9FE}, {0xAA00, 0xAA28}, {0xAA40, 0xAA42}, {0xAA44, 0xAA4B},
-    {0xAA60, 0xAA76}, {0xAA7E, 0xAAAF}, {0xAAB9, 0xAABD}, {0xAADB, 0xAADD},
-    {0xAAE0, 0xAAEA}, {0xAAF2, 0xAAF4}, {0xAB01, 0xAB06}, {0xAB09, 0xAB0E},
-    {0xAB11, 0xAB16}, {0xAB20, 0xAB26}, {0xAB28, 0xAB2E}, {0xAB30, 0xAB5A},
-    {0xAB5C, 0xAB69}, {0xAB70, 0xABE2}, {0xAC00, 0xD7A3}, {0xD7B0, 0xD7C6},
-    {0xD7CB, 0xD7FB}, {0xF900, 0xFA6D}, {0xFA70, 0xFAD9}, {0xFB00, 0xFB06},
-    {0xFB13, 0xFB17}, {0xFB1F, 0xFB28}, {0xFB2A, 0xFB36}, {0xFB38, 0xFB3C},
-    {0xFB46, 0xFBB1}, {0xFBD3, 0xFD3D}, {0xFD50, 0xFD8F}, {0xFD92, 0xFDC7},
-    {0xFDF0, 0xFDFB}, {0xFE70, 0xFE74}, {0xFE76, 0xFEFC}, {0xFF21, 0xFF3A},
-    {0xFF41, 0xFF5A}, {0xFF66, 0xFFBE}, {0xFFC2, 0xFFC7}, {0xFFCA, 0xFFCF},
-    {0xFFD2, 0xFFD7}, {0xFFDA, 0xFFDC}
+    {0x2145, 0x2149}, {0x2C00, 0x2C2E}, {0x2C30, 0x2C5E}, {0x2C60, 0x2CE4},
+    {0x2CEB, 0x2CEE}, {0x2D00, 0x2D25}, {0x2D30, 0x2D67}, {0x2D80, 0x2D96},
+    {0x2DA0, 0x2DA6}, {0x2DA8, 0x2DAE}, {0x2DB0, 0x2DB6}, {0x2DB8, 0x2DBE},
+    {0x2DC0, 0x2DC6}, {0x2DC8, 0x2DCE}, {0x2DD0, 0x2DD6}, {0x2DD8, 0x2DDE},
+    {0x3031, 0x3035}, {0x3041, 0x3096}, {0x309D, 0x309F}, {0x30A1, 0x30FA},
+    {0x30FC, 0x30FF}, {0x3105, 0x312F}, {0x3131, 0x318E}, {0x31A0, 0x31BF},
+    {0x31F0, 0x31FF}, {0x3400, 0x4DBF}, {0x4E00, 0x9FFC}, {0xA000, 0xA48C},
+    {0xA4D0, 0xA4FD}, {0xA500, 0xA60C}, {0xA610, 0xA61F}, {0xA640, 0xA66E},
+    {0xA67F, 0xA69D}, {0xA6A0, 0xA6E5}, {0xA717, 0xA71F}, {0xA722, 0xA788},
+    {0xA78B, 0xA7BF}, {0xA7C2, 0xA7CA}, {0xA7F5, 0xA801}, {0xA803, 0xA805},
+    {0xA807, 0xA80A}, {0xA80C, 0xA822}, {0xA840, 0xA873}, {0xA882, 0xA8B3},
+    {0xA8F2, 0xA8F7}, {0xA90A, 0xA925}, {0xA930, 0xA946}, {0xA960, 0xA97C},
+    {0xA984, 0xA9B2}, {0xA9E0, 0xA9E4}, {0xA9E6, 0xA9EF}, {0xA9FA, 0xA9FE},
+    {0xAA00, 0xAA28}, {0xAA40, 0xAA42}, {0xAA44, 0xAA4B}, {0xAA60, 0xAA76},
+    {0xAA7E, 0xAAAF}, {0xAAB9, 0xAABD}, {0xAADB, 0xAADD}, {0xAAE0, 0xAAEA},
+    {0xAAF2, 0xAAF4}, {0xAB01, 0xAB06}, {0xAB09, 0xAB0E}, {0xAB11, 0xAB16},
+    {0xAB20, 0xAB26}, {0xAB28, 0xAB2E}, {0xAB30, 0xAB5A}, {0xAB5C, 0xAB69},
+    {0xAB70, 0xABE2}, {0xAC00, 0xD7A3}, {0xD7B0, 0xD7C6}, {0xD7CB, 0xD7FB},
+    {0xF900, 0xFA6D}, {0xFA70, 0xFAD9}, {0xFB00, 0xFB06}, {0xFB13, 0xFB17},
+    {0xFB1F, 0xFB28}, {0xFB2A, 0xFB36}, {0xFB38, 0xFB3C}, {0xFB46, 0xFBB1},
+    {0xFBD3, 0xFD3D}, {0xFD50, 0xFD8F}, {0xFD92, 0xFDC7}, {0xFDF0, 0xFDFB},
+    {0xFE70, 0xFE74}, {0xFE76, 0xFEFC}, {0xFF21, 0xFF3A}, {0xFF41, 0xFF5A},
+    {0xFF66, 0xFFBE}, {0xFFC2, 0xFFC7}, {0xFFCA, 0xFFCF}, {0xFFD2, 0xFFD7},
+    {0xFFDA, 0xFFDC}
 #if CHRBITS > 16
    ,{0x10000, 0x1000B}, {0x1000D, 0x10026}, {0x10028, 0x1003A}, {0x1003F, 0x1004D},
    {0x10050, 0x1005D}, {0x10080, 0x100FA}, {0x10280, 0x1029C}, {0x102A0, 0x102D0},
    {0x10300, 0x1031F}, {0x1032D, 0x10340}, {0x10342, 0x10349}, {0x10350, 0x10375},
    {0x10380, 0x1039D}, {0x103A0, 0x103C3}, {0x103C8, 0x103CF}, {0x10400, 0x1049D},
    {0x104B0, 0x104D3}, {0x104D8, 0x104FB}, {0x10500, 0x10527}, {0x10530, 0x10563},
-    {0x10570, 0x1057A}, {0x1057C, 0x1058A}, {0x1058C, 0x10592}, {0x10597, 0x105A1},
-    {0x105A3, 0x105B1}, {0x105B3, 0x105B9}, {0x10600, 0x10736}, {0x10740, 0x10755},
-    {0x10760, 0x10767}, {0x10780, 0x10785}, {0x10787, 0x107B0}, {0x107B2, 0x107BA},
-    {0x10800, 0x10805}, {0x1080A, 0x10835}, {0x1083F, 0x10855}, {0x10860, 0x10876},
-    {0x10880, 0x1089E}, {0x108E0, 0x108F2}, {0x10900, 0x10915}, {0x10920, 0x10939},
-    {0x10980, 0x109B7}, {0x10A10, 0x10A13}, {0x10A15, 0x10A17}, {0x10A19, 0x10A35},
-    {0x10A60, 0x10A7C}, {0x10A80, 0x10A9C}, {0x10AC0, 0x10AC7}, {0x10AC9, 0x10AE4},
-    {0x10B00, 0x10B35}, {0x10B40, 0x10B55}, {0x10B60, 0x10B72}, {0x10B80, 0x10B91},
-    {0x10C00, 0x10C48}, {0x10C80, 0x10CB2}, {0x10CC0, 0x10CF2}, {0x10D00, 0x10D23},
-    {0x10E80, 0x10EA9}, {0x10F00, 0x10F1C}, {0x10F30, 0x10F45}, {0x10F70, 0x10F81},
-    {0x10FB0, 0x10FC4}, {0x10FE0, 0x10FF6}, {0x11003, 0x11037}, {0x11083, 0x110AF},
-    {0x110D0, 0x110E8}, {0x11103, 0x11126}, {0x11150, 0x11172}, {0x11183, 0x111B2},
-    {0x111C1, 0x111C4}, {0x11200, 0x11211}, {0x11213, 0x1122B}, {0x11280, 0x11286},
-    {0x1128A, 0x1128D}, {0x1128F, 0x1129D}, {0x1129F, 0x112A8}, {0x112B0, 0x112DE},
-    {0x11305, 0x1130C}, {0x11313, 0x11328}, {0x1132A, 0x11330}, {0x11335, 0x11339},
-    {0x1135D, 0x11361}, {0x11400, 0x11434}, {0x11447, 0x1144A}, {0x1145F, 0x11461},
-    {0x11480, 0x114AF}, {0x11580, 0x115AE}, {0x115D8, 0x115DB}, {0x11600, 0x1162F},
-    {0x11680, 0x116AA}, {0x11700, 0x1171A}, {0x11740, 0x11746}, {0x11800, 0x1182B},
-    {0x118A0, 0x118DF}, {0x118FF, 0x11906}, {0x1190C, 0x11913}, {0x11918, 0x1192F},
-    {0x119A0, 0x119A7}, {0x119AA, 0x119D0}, {0x11A0B, 0x11A32}, {0x11A5C, 0x11A89},
-    {0x11AB0, 0x11AF8}, {0x11C00, 0x11C08}, {0x11C0A, 0x11C2E}, {0x11C72, 0x11C8F},
-    {0x11D00, 0x11D06}, {0x11D0B, 0x11D30}, {0x11D60, 0x11D65}, {0x11D6A, 0x11D89},
-    {0x11EE0, 0x11EF2}, {0x12000, 0x12399}, {0x12480, 0x12543}, {0x12F90, 0x12FF0},
+    {0x10600, 0x10736}, {0x10740, 0x10755}, {0x10760, 0x10767}, {0x10800, 0x10805},
+    {0x1080A, 0x10835}, {0x1083F, 0x10855}, {0x10860, 0x10876}, {0x10880, 0x1089E},
+    {0x108E0, 0x108F2}, {0x10900, 0x10915}, {0x10920, 0x10939}, {0x10980, 0x109B7},
+    {0x10A10, 0x10A13}, {0x10A15, 0x10A17}, {0x10A19, 0x10A35}, {0x10A60, 0x10A7C},
+    {0x10A80, 0x10A9C}, {0x10AC0, 0x10AC7}, {0x10AC9, 0x10AE4}, {0x10B00, 0x10B35},
+    {0x10B40, 0x10B55}, {0x10B60, 0x10B72}, {0x10B80, 0x10B91}, {0x10C00, 0x10C48},
+    {0x10C80, 0x10CB2}, {0x10CC0, 0x10CF2}, {0x10D00, 0x10D23}, {0x10E80, 0x10EA9},
+    {0x10F00, 0x10F1C}, {0x10F30, 0x10F45}, {0x10FB0, 0x10FC4}, {0x10FE0, 0x10FF6},
+    {0x11003, 0x11037}, {0x11083, 0x110AF}, {0x110D0, 0x110E8}, {0x11103, 0x11126},
+    {0x11150, 0x11172}, {0x11183, 0x111B2}, {0x111C1, 0x111C4}, {0x11200, 0x11211},
+    {0x11213, 0x1122B}, {0x11280, 0x11286}, {0x1128A, 0x1128D}, {0x1128F, 0x1129D},
+    {0x1129F, 0x112A8}, {0x112B0, 0x112DE}, {0x11305, 0x1130C}, {0x11313, 0x11328},
+    {0x1132A, 0x11330}, {0x11335, 0x11339}, {0x1135D, 0x11361}, {0x11400, 0x11434},
+    {0x11447, 0x1144A}, {0x1145F, 0x11461}, {0x11480, 0x114AF}, {0x11580, 0x115AE},
+    {0x115D8, 0x115DB}, {0x11600, 0x1162F}, {0x11680, 0x116AA}, {0x11700, 0x1171A},
+    {0x11800, 0x1182B}, {0x118A0, 0x118DF}, {0x118FF, 0x11906}, {0x1190C, 0x11913},
+    {0x11918, 0x1192F}, {0x119A0, 0x119A7}, {0x119AA, 0x119D0}, {0x11A0B, 0x11A32},
+    {0x11A5C, 0x11A89}, {0x11AC0, 0x11AF8}, {0x11C00, 0x11C08}, {0x11C0A, 0x11C2E},
+    {0x11C72, 0x11C8F}, {0x11D00, 0x11D06}, {0x11D0B, 0x11D30}, {0x11D60, 0x11D65},
+    {0x11D6A, 0x11D89}, {0x11EE0, 0x11EF2}, {0x12000, 0x12399}, {0x12480, 0x12543},
    {0x13000, 0x1342E}, {0x14400, 0x14646}, {0x16800, 0x16A38}, {0x16A40, 0x16A5E},
-    {0x16A70, 0x16ABE}, {0x16AD0, 0x16AED}, {0x16B00, 0x16B2F}, {0x16B40, 0x16B43},
-    {0x16B63, 0x16B77}, {0x16B7D, 0x16B8F}, {0x16E40, 0x16E7F}, {0x16F00, 0x16F4A},
-    {0x16F93, 0x16F9F}, {0x17000, 0x187F7}, {0x18800, 0x18CD5}, {0x18D00, 0x18D08},
-    {0x1AFF0, 0x1AFF3}, {0x1AFF5, 0x1AFFB}, {0x1B000, 0x1B122}, {0x1B150, 0x1B152},
-    {0x1B164, 0x1B167}, {0x1B170, 0x1B2FB}, {0x1BC00, 0x1BC6A}, {0x1BC70, 0x1BC7C},
-    {0x1BC80, 0x1BC88}, {0x1BC90, 0x1BC99}, {0x1D400, 0x1D454}, {0x1D456, 0x1D49C},
-    {0x1D4A9, 0x1D4AC}, {0x1D4AE, 0x1D4B9}, {0x1D4BD, 0x1D4C3}, {0x1D4C5, 0x1D505},
-    {0x1D507, 0x1D50A}, {0x1D50D, 0x1D514}, {0x1D516, 0x1D51C}, {0x1D51E, 0x1D539},
-    {0x1D53B, 0x1D53E}, {0x1D540, 0x1D544}, {0x1D54A, 0x1D550}, {0x1D552, 0x1D6A5},
-    {0x1D6A8, 0x1D6C0}, {0x1D6C2, 0x1D6DA}, {0x1D6DC, 0x1D6FA}, {0x1D6FC, 0x1D714},
-    {0x1D716, 0x1D734}, {0x1D736, 0x1D74E}, {0x1D750, 0x1D76E}, {0x1D770, 0x1D788},
-    {0x1D78A, 0x1D7A8}, {0x1D7AA, 0x1D7C2}, {0x1D7C4, 0x1D7CB}, {0x1DF00, 0x1DF1E},
-    {0x1E100, 0x1E12C}, {0x1E137, 0x1E13D}, {0x1E290, 0x1E2AD}, {0x1E2C0, 0x1E2EB},
-    {0x1E7E0, 0x1E7E6}, {0x1E7E8, 0x1E7EB}, {0x1E7F0, 0x1E7FE}, {0x1E800, 0x1E8C4},
+    {0x16AD0, 0x16AED}, {0x16B00, 0x16B2F}, {0x16B40, 0x16B43}, {0x16B63, 0x16B77},
+    {0x16B7D, 0x16B8F}, {0x16E40, 0x16E7F}, {0x16F00, 0x16F4A}, {0x16F93, 0x16F9F},
+    {0x17000, 0x187F7}, {0x18800, 0x18CD5}, {0x18D00, 0x18D08}, {0x1B000, 0x1B11E},
+    {0x1B150, 0x1B152}, {0x1B164, 0x1B167}, {0x1B170, 0x1B2FB}, {0x1BC00, 0x1BC6A},
+    {0x1BC70, 0x1BC7C}, {0x1BC80, 0x1BC88}, {0x1BC90, 0x1BC99}, {0x1D400, 0x1D454},
+    {0x1D456, 0x1D49C}, {0x1D4A9, 0x1D4AC}, {0x1D4AE, 0x1D4B9}, {0x1D4BD, 0x1D4C3},
+    {0x1D4C5, 0x1D505}, {0x1D507, 0x1D50A}, {0x1D50D, 0x1D514}, {0x1D516, 0x1D51C},
+    {0x1D51E, 0x1D539}, {0x1D53B, 0x1D53E}, {0x1D540, 0x1D544}, {0x1D54A, 0x1D550},
+    {0x1D552, 0x1D6A5}, {0x1D6A8, 0x1D6C0}, {0x1D6C2, 0x1D6DA}, {0x1D6DC, 0x1D6FA},
+    {0x1D6FC, 0x1D714}, {0x1D716, 0x1D734}, {0x1D736, 0x1D74E}, {0x1D750, 0x1D76E},
+    {0x1D770, 0x1D788}, {0x1D78A, 0x1D7A8}, {0x1D7AA, 0x1D7C2}, {0x1D7C4, 0x1D7CB},
+    {0x1E100, 0x1E12C}, {0x1E137, 0x1E13D}, {0x1E2C0, 0x1E2EB}, {0x1E800, 0x1E8C4},
    {0x1E900, 0x1E943}, {0x1EE00, 0x1EE03}, {0x1EE05, 0x1EE1F}, {0x1EE29, 0x1EE32},
    {0x1EE34, 0x1EE37}, {0x1EE4D, 0x1EE4F}, {0x1EE67, 0x1EE6A}, {0x1EE6C, 0x1EE72},
    {0x1EE74, 0x1EE77}, {0x1EE79, 0x1EE7C}, {0x1EE80, 0x1EE89}, {0x1EE8B, 0x1EE9B},
-    {0x1EEA1, 0x1EEA3}, {0x1EEA5, 0x1EEA9}, {0x1EEAB, 0x1EEBB}, {0x20000, 0x2A6DF},
-    {0x2A700, 0x2B738}, {0x2B740, 0x2B81D}, {0x2B820, 0x2CEA1}, {0x2CEB0, 0x2EBE0},
+    {0x1EEA1, 0x1EEA3}, {0x1EEA5, 0x1EEA9}, {0x1EEAB, 0x1EEBB}, {0x20000, 0x2A6DD},
+    {0x2A700, 0x2B734}, {0x2B740, 0x2B81D}, {0x2B820, 0x2CEA1}, {0x2CEB0, 0x2EBE0},
    {0x2F800, 0x2FA1D}, {0x30000, 0x3134A}
 #endif
 };
@@ -263,28 +259,27 @@ static const chr alphaCharTable[] = {
    0xA38, 0xA39, 0xA5E, 0xAB2, 0xAB3, 0xABD, 0xAD0, 0xAE0, 0xAE1,
    0xAF9, 0xB0F, 0xB10, 0xB32, 0xB33, 0xB3D, 0xB5C, 0xB5D, 0xB71,
    0xB83, 0xB99, 0xB9A, 0xB9C, 0xB9E, 0xB9F, 0xBA3, 0xBA4, 0xBD0,
-    0xC3D, 0xC5D, 0xC60, 0xC61, 0xC80, 0xCBD, 0xCDD, 0xCDE, 0xCE0,
-    0xCE1, 0xCF1, 0xCF2, 0xD3D, 0xD4E, 0xDBD, 0xE32, 0xE33, 0xE81,
-    0xE82, 0xE84, 0xEA5, 0xEB2, 0xEB3, 0xEBD, 0xEC6, 0xF00, 0x103F,
-    0x1061, 0x1065, 0x1066, 0x108E, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7,
-    0x17DC, 0x18AA, 0x1AA7, 0x1BAE, 0x1BAF, 0x1CF5, 0x1CF6, 0x1CFA, 0x1F59,
-    0x1F5B, 0x1F5D, 0x1FBE, 0x2071, 0x207F, 0x2102, 0x2107, 0x2115, 0x2124,
-    0x2126, 0x2128, 0x214E, 0x2183, 0x2184, 0x2CF2, 0x2CF3, 0x2D27, 0x2D2D,
-    0x2D6F, 0x2E2F, 0x3005, 0x3006, 0x303B, 0x303C, 0xA62A, 0xA62B, 0xA7D0,
-    0xA7D1, 0xA7D3, 0xA8FB, 0xA8FD, 0xA8FE, 0xA9CF, 0xAA7A, 0xAAB1, 0xAAB5,
-    0xAAB6, 0xAAC0, 0xAAC2, 0xFB1D, 0xFB3E, 0xFB40, 0xFB41, 0xFB43, 0xFB44
+    0xC3D, 0xC60, 0xC61, 0xC80, 0xCBD, 0xCDE, 0xCE0, 0xCE1, 0xCF1,
+    0xCF2, 0xD3D, 0xD4E, 0xDBD, 0xE32, 0xE33, 0xE81, 0xE82, 0xE84,
+    0xEA5, 0xEB2, 0xEB3, 0xEBD, 0xEC6, 0xF00, 0x103F, 0x1061, 0x1065,
+    0x1066, 0x108E, 0x10C7, 0x10CD, 0x1258, 0x12C0, 0x17D7, 0x17DC, 0x18AA,
+    0x1AA7, 0x1BAE, 0x1BAF, 0x1CF5, 0x1CF6, 0x1CFA, 0x1F59, 0x1F5B, 0x1F5D,
+    0x1FBE, 0x2071, 0x207F, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128,
+    0x214E, 0x2183, 0x2184, 0x2CF2, 0x2CF3, 0x2D27, 0x2D2D, 0x2D6F, 0x2E2F,
+    0x3005, 0x3006, 0x303B, 0x303C, 0xA62A, 0xA62B, 0xA8FB, 0xA8FD, 0xA8FE,
+    0xA9CF, 0xAA7A, 0xAAB1, 0xAAB5, 0xAAB6, 0xAAC0, 0xAAC2, 0xFB1D, 0xFB3E,
+    0xFB40, 0xFB41, 0xFB43, 0xFB44
 #if CHRBITS > 16
-    ,0x1003C, 0x1003D, 0x10594, 0x10595, 0x105BB, 0x105BC, 0x10808, 0x10837, 0x10838,
-    0x1083C, 0x108F4, 0x108F5, 0x109BE, 0x109BF, 0x10A00, 0x10EB0, 0x10EB1, 0x10F27,
-    0x11071, 0x11072, 0x11075, 0x11144, 0x11147, 0x11176, 0x111DA, 0x111DC, 0x11288,
-    0x1130F, 0x11310, 0x11332, 0x11333, 0x1133D, 0x11350, 0x114C4, 0x114C5, 0x114C7,
-    0x11644, 0x116B8, 0x11909, 0x11915, 0x11916, 0x1193F, 0x11941, 0x119E1, 0x119E3,
-    0x11A00, 0x11A3A, 0x11A50, 0x11A9D, 0x11C40, 0x11D08, 0x11D09, 0x11D46, 0x11D67,
-    0x11D68, 0x11D98, 0x11FB0, 0x16F50, 0x16FE0, 0x16FE1, 0x16FE3, 0x1AFFD, 0x1AFFE,
-    0x1D49E, 0x1D49F, 0x1D4A2, 0x1D4A5, 0x1D4A6, 0x1D4BB, 0x1D546, 0x1E14E, 0x1E7ED,
-    0x1E7EE, 0x1E94B, 0x1EE21, 0x1EE22, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42,
-    0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE51, 0x1EE52, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B,
-    0x1EE5D, 0x1EE5F, 0x1EE61, 0x1EE62, 0x1EE64, 0x1EE7E
+    ,0x1003C, 0x1003D, 0x10808, 0x10837, 0x10838, 0x1083C, 0x108F4, 0x108F5, 0x109BE,
+    0x109BF, 0x10A00, 0x10EB0, 0x10EB1, 0x10F27, 0x11144, 0x11147, 0x11176, 0x111DA,
+    0x111DC, 0x11288, 0x1130F, 0x11310, 0x11332, 0x11333, 0x1133D, 0x11350, 0x114C4,
+    0x114C5, 0x114C7, 0x11644, 0x116B8, 0x11909, 0x11915, 0x11916, 0x1193F, 0x11941,
+    0x119E1, 0x119E3, 0x11A00, 0x11A3A, 0x11A50, 0x11A9D, 0x11C40, 0x11D08, 0x11D09,
+    0x11D46, 0x11D67, 0x11D68, 0x11D98, 0x11FB0, 0x16F50, 0x16FE0, 0x16FE1, 0x16FE3,
+    0x1D49E, 0x1D49F, 0x1D4A2, 0x1D4A5, 0x1D4A6, 0x1D4BB, 0x1D546, 0x1E14E, 0x1E94B,
+    0x1EE21, 0x1EE22, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49,
+    0x1EE4B, 0x1EE51, 0x1EE52, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F,
+    0x1EE61, 0x1EE62, 0x1EE64, 0x1EE7E
 #endif
 };

@@ -307,7 +302,7 @@ static const crange controlRangeTable[] = {
 #define NUM_CONTROL_RANGE (sizeof(controlRangeTable)/sizeof(crange))

 static const chr controlCharTable[] = {
-    0xAD, 0x61C, 0x6DD, 0x70F, 0x890, 0x891, 0x8E2, 0x180E, 0xFEFF
+    0xAD, 0x61C, 0x6DD, 0x70F, 0x8E2, 0x180E, 0xFEFF
 #if CHRBITS > 16
    ,0x110BD, 0x110CD, 0xE0001
 #endif
@@ -335,9 +330,8 @@ static const crange digitRangeTable[] = {
    {0x11136, 0x1113F}, {0x111D0, 0x111D9}, {0x112F0, 0x112F9}, {0x11450, 0x11459},
    {0x114D0, 0x114D9}, {0x11650, 0x11659}, {0x116C0, 0x116C9}, {0x11730, 0x11739},
    {0x118E0, 0x118E9}, {0x11950, 0x11959}, {0x11C50, 0x11C59}, {0x11D50, 0x11D59},
-    {0x11DA0, 0x11DA9}, {0x16A60, 0x16A69}, {0x16AC0, 0x16AC9}, {0x16B50, 0x16B59},
-    {0x1D7CE, 0x1D7FF}, {0x1E140, 0x1E149}, {0x1E2F0, 0x1E2F9}, {0x1E950, 0x1E959},
-    {0x1FBF0, 0x1FBF9}
+    {0x11DA0, 0x11DA9}, {0x16A60, 0x16A69}, {0x16B50, 0x16B59}, {0x1D7CE, 0x1D7FF},
+    {0x1E140, 0x1E149}, {0x1E2F0, 0x1E2F9}, {0x1E950, 0x1E959}, {0x1FBF0, 0x1FBF9}
 #endif
 };

@@ -353,27 +347,27 @@ static const crange digitRangeTable[] = {

 static const crange punctRangeTable[] = {
    {0x21, 0x23}, {0x25, 0x2A}, {0x2C, 0x2F}, {0x5B, 0x5D},
-    {0x55A, 0x55F}, {0x61D, 0x61F}, {0x66A, 0x66D}, {0x700, 0x70D},
-    {0x7F7, 0x7F9}, {0x830, 0x83E}, {0xF04, 0xF12}, {0xF3A, 0xF3D},
-    {0xFD0, 0xFD4}, {0x104A, 0x104F}, {0x1360, 0x1368}, {0x16EB, 0x16ED},
-    {0x17D4, 0x17D6}, {0x17D8, 0x17DA}, {0x1800, 0x180A}, {0x1AA0, 0x1AA6},
-    {0x1AA8, 0x1AAD}, {0x1B5A, 0x1B60}, {0x1BFC, 0x1BFF}, {0x1C3B, 0x1C3F},
-    {0x1CC0, 0x1CC7}, {0x2010, 0x2027}, {0x2030, 0x2043}, {0x2045, 0x2051},
-    {0x2053, 0x205E}, {0x2308, 0x230B}, {0x2768, 0x2775}, {0x27E6, 0x27EF},
-    {0x2983, 0x2998}, {0x29D8, 0x29DB}, {0x2CF9, 0x2CFC}, {0x2E00, 0x2E2E},
-    {0x2E30, 0x2E4F}, {0x2E52, 0x2E5D}, {0x3001, 0x3003}, {0x3008, 0x3011},
-    {0x3014, 0x301F}, {0xA60D, 0xA60F}, {0xA6F2, 0xA6F7}, {0xA874, 0xA877},
-    {0xA8F8, 0xA8FA}, {0xA9C1, 0xA9CD}, {0xAA5C, 0xAA5F}, {0xFE10, 0xFE19},
-    {0xFE30, 0xFE52}, {0xFE54, 0xFE61}, {0xFF01, 0xFF03}, {0xFF05, 0xFF0A},
-    {0xFF0C, 0xFF0F}, {0xFF3B, 0xFF3D}, {0xFF5F, 0xFF65}
+    {0x55A, 0x55F}, {0x66A, 0x66D}, {0x700, 0x70D}, {0x7F7, 0x7F9},
+    {0x830, 0x83E}, {0xF04, 0xF12}, {0xF3A, 0xF3D}, {0xFD0, 0xFD4},
+    {0x104A, 0x104F}, {0x1360, 0x1368}, {0x16EB, 0x16ED}, {0x17D4, 0x17D6},
+    {0x17D8, 0x17DA}, {0x1800, 0x180A}, {0x1AA0, 0x1AA6}, {0x1AA8, 0x1AAD},
+    {0x1B5A, 0x1B60}, {0x1BFC, 0x1BFF}, {0x1C3B, 0x1C3F}, {0x1CC0, 0x1CC7},
+    {0x2010, 0x2027}, {0x2030, 0x2043}, {0x2045, 0x2051}, {0x2053, 0x205E},
+    {0x2308, 0x230B}, {0x2768, 0x2775}, {0x27E6, 0x27EF}, {0x2983, 0x2998},
+    {0x29D8, 0x29DB}, {0x2CF9, 0x2CFC}, {0x2E00, 0x2E2E}, {0x2E30, 0x2E4F},
+    {0x3001, 0x3003}, {0x3008, 0x3011}, {0x3014, 0x301F}, {0xA60D, 0xA60F},
+    {0xA6F2, 0xA6F7}, {0xA874, 0xA877}, {0xA8F8, 0xA8FA}, {0xA9C1, 0xA9CD},
+    {0xAA5C, 0xAA5F}, {0xFE10, 0xFE19}, {0xFE30, 0xFE52}, {0xFE54, 0xFE61},
+    {0xFF01, 0xFF03}, {0xFF05, 0xFF0A}, {0xFF0C, 0xFF0F}, {0xFF3B, 0xFF3D},
+    {0xFF5F, 0xFF65}
 #if CHRBITS > 16
    ,{0x10100, 0x10102}, {0x10A50, 0x10A58}, {0x10AF0, 0x10AF6}, {0x10B39, 0x10B3F},
-    {0x10B99, 0x10B9C}, {0x10F55, 0x10F59}, {0x10F86, 0x10F89}, {0x11047, 0x1104D},
-    {0x110BE, 0x110C1}, {0x11140, 0x11143}, {0x111C5, 0x111C8}, {0x111DD, 0x111DF},
-    {0x11238, 0x1123D}, {0x1144B, 0x1144F}, {0x115C1, 0x115D7}, {0x11641, 0x11643},
-    {0x11660, 0x1166C}, {0x1173C, 0x1173E}, {0x11944, 0x11946}, {0x11A3F, 0x11A46},
-    {0x11A9A, 0x11A9C}, {0x11A9E, 0x11AA2}, {0x11C41, 0x11C45}, {0x12470, 0x12474},
-    {0x16B37, 0x16B3B}, {0x16E97, 0x16E9A}, {0x1DA87, 0x1DA8B}
+    {0x10B99, 0x10B9C}, {0x10F55, 0x10F59}, {0x11047, 0x1104D}, {0x110BE, 0x110C1},
+    {0x11140, 0x11143}, {0x111C5, 0x111C8}, {0x111DD, 0x111DF}, {0x11238, 0x1123D},
+    {0x1144B, 0x1144F}, {0x115C1, 0x115D7}, {0x11641, 0x11643}, {0x11660, 0x1166C},
+    {0x1173C, 0x1173E}, {0x11944, 0x11946}, {0x11A3F, 0x11A46}, {0x11A9A, 0x11A9C},
+    {0x11A9E, 0x11AA2}, {0x11C41, 0x11C45}, {0x12470, 0x12474}, {0x16B37, 0x16B3B},
+    {0x16E97, 0x16E9A}, {0x1DA87, 0x1DA8B}
 #endif
 };

@@ -383,22 +377,21 @@ static const chr punctCharTable[] = {
    0x3A, 0x3B, 0x3F, 0x40, 0x5F, 0x7B, 0x7D, 0xA1, 0xA7,
    0xAB, 0xB6, 0xB7, 0xBB, 0xBF, 0x37E, 0x387, 0x589, 0x58A,
    0x5BE, 0x5C0, 0x5C3, 0x5C6, 0x5F3, 0x5F4, 0x609, 0x60A, 0x60C,
-    0x60D, 0x61B, 0x6D4, 0x85E, 0x964, 0x965, 0x970, 0x9FD, 0xA76,
-    0xAF0, 0xC77, 0xC84, 0xDF4, 0xE4F, 0xE5A, 0xE5B, 0xF14, 0xF85,
-    0xFD9, 0xFDA, 0x10FB, 0x1400, 0x166E, 0x169B, 0x169C, 0x1735, 0x1736,
-    0x1944, 0x1945, 0x1A1E, 0x1A1F, 0x1B7D, 0x1B7E, 0x1C7E, 0x1C7F, 0x1CD3,
+    0x60D, 0x61B, 0x61E, 0x61F, 0x6D4, 0x85E, 0x964, 0x965, 0x970,
+    0x9FD, 0xA76, 0xAF0, 0xC77, 0xC84, 0xDF4, 0xE4F, 0xE5A, 0xE5B,
+    0xF14, 0xF85, 0xFD9, 0xFDA, 0x10FB, 0x1400, 0x166E, 0x169B, 0x169C,
+    0x1735, 0x1736, 0x1944, 0x1945, 0x1A1E, 0x1A1F, 0x1C7E, 0x1C7F, 0x1CD3,
    0x207D, 0x207E, 0x208D, 0x208E, 0x2329, 0x232A, 0x27C5, 0x27C6, 0x29FC,
-    0x29FD, 0x2CFE, 0x2CFF, 0x2D70, 0x3030, 0x303D, 0x30A0, 0x30FB, 0xA4FE,
-    0xA4FF, 0xA673, 0xA67E, 0xA8CE, 0xA8CF, 0xA8FC, 0xA92E, 0xA92F, 0xA95F,
-    0xA9DE, 0xA9DF, 0xAADE, 0xAADF, 0xAAF0, 0xAAF1, 0xABEB, 0xFD3E, 0xFD3F,
-    0xFE63, 0xFE68, 0xFE6A, 0xFE6B, 0xFF1A, 0xFF1B, 0xFF1F, 0xFF20, 0xFF3F,
-    0xFF5B, 0xFF5D
+    0x29FD, 0x2CFE, 0x2CFF, 0x2D70, 0x2E52, 0x3030, 0x303D, 0x30A0, 0x30FB,
+    0xA4FE, 0xA4FF, 0xA673, 0xA67E, 0xA8CE, 0xA8CF, 0xA8FC, 0xA92E, 0xA92F,
+    0xA95F, 0xA9DE, 0xA9DF, 0xAADE, 0xAADF, 0xAAF0, 0xAAF1, 0xABEB, 0xFD3E,
+    0xFD3F, 0xFE63, 0xFE68, 0xFE6A, 0xFE6B, 0xFF1A, 0xFF1B, 0xFF1F, 0xFF20,
+    0xFF3F, 0xFF5B, 0xFF5D
 #if CHRBITS > 16
    ,0x1039F, 0x103D0, 0x1056F, 0x10857, 0x1091F, 0x1093F, 0x10A7F, 0x10EAD, 0x110BB,
    0x110BC, 0x11174, 0x11175, 0x111CD, 0x111DB, 0x112A9, 0x1145A, 0x1145B, 0x1145D,
-    0x114C6, 0x116B9, 0x1183B, 0x119E2, 0x11C70, 0x11C71, 0x11EF7, 0x11EF8, 0x11FFF,
-    0x12FF1, 0x12FF2, 0x16A6E, 0x16A6F, 0x16AF5, 0x16B44, 0x16FE2, 0x1BC9F, 0x1E95E,
-    0x1E95F
+    0x114C6, 0x1183B, 0x119E2, 0x11C70, 0x11C71, 0x11EF7, 0x11EF8, 0x11FFF, 0x16A6E,
+    0x16A6F, 0x16AF5, 0x16B44, 0x16FE2, 0x1BC9F, 0x1E95E, 0x1E95F
 #endif
 };

@@ -436,20 +429,18 @@ static const crange lowerRangeTable[] = {
    {0x1F50, 0x1F57}, {0x1F60, 0x1F67}, {0x1F70, 0x1F7D}, {0x1F80, 0x1F87},
    {0x1F90, 0x1F97}, {0x1FA0, 0x1FA7}, {0x1FB0, 0x1FB4}, {0x1FC2, 0x1FC4},
    {0x1FD0, 0x1FD3}, {0x1FE0, 0x1FE7}, {0x1FF2, 0x1FF4}, {0x2146, 0x2149},
-    {0x2C30, 0x2C5F}, {0x2C76, 0x2C7B}, {0x2D00, 0x2D25}, {0xA72F, 0xA731},
+    {0x2C30, 0x2C5E}, {0x2C76, 0x2C7B}, {0x2D00, 0x2D25}, {0xA72F, 0xA731},
    {0xA771, 0xA778}, {0xA793, 0xA795}, {0xAB30, 0xAB5A}, {0xAB60, 0xAB68},
    {0xAB70, 0xABBF}, {0xFB00, 0xFB06}, {0xFB13, 0xFB17}, {0xFF41, 0xFF5A}
 #if CHRBITS > 16
-    ,{0x10428, 0x1044F}, {0x104D8, 0x104FB}, {0x10597, 0x105A1}, {0x105A3, 0x105B1},
-    {0x105B3, 0x105B9}, {0x10CC0, 0x10CF2}, {0x118C0, 0x118DF}, {0x16E60, 0x16E7F},
-    {0x1D41A, 0x1D433}, {0x1D44E, 0x1D454}, {0x1D456, 0x1D467}, {0x1D482, 0x1D49B},
-    {0x1D4B6, 0x1D4B9}, {0x1D4BD, 0x1D4C3}, {0x1D4C5, 0x1D4CF}, {0x1D4EA, 0x1D503},
-    {0x1D51E, 0x1D537}, {0x1D552, 0x1D56B}, {0x1D586, 0x1D59F}, {0x1D5BA, 0x1D5D3},
-    {0x1D5EE, 0x1D607}, {0x1D622, 0x1D63B}, {0x1D656, 0x1D66F}, {0x1D68A, 0x1D6A5},
-    {0x1D6C2, 0x1D6DA}, {0x1D6DC, 0x1D6E1}, {0x1D6FC, 0x1D714}, {0x1D716, 0x1D71B},
-    {0x1D736, 0x1D74E}, {0x1D750, 0x1D755}, {0x1D770, 0x1D788}, {0x1D78A, 0x1D78F},
-    {0x1D7AA, 0x1D7C2}, {0x1D7C4, 0x1D7C9}, {0x1DF00, 0x1DF09}, {0x1DF0B, 0x1DF1E},
-    {0x1E922, 0x1E943}
+    ,{0x10428, 0x1044F}, {0x104D8, 0x104FB}, {0x10CC0, 0x10CF2}, {0x118C0, 0x118DF},
+    {0x16E60, 0x16E7F}, {0x1D41A, 0x1D433}, {0x1D44E, 0x1D454}, {0x1D456, 0x1D467},
+    {0x1D482, 0x1D49B}, {0x1D4B6, 0x1D4B9}, {0x1D4BD, 0x1D4C3}, {0x1D4C5, 0x1D4CF},
+    {0x1D4EA, 0x1D503}, {0x1D51E, 0x1D537}, {0x1D552, 0x1D56B}, {0x1D586, 0x1D59F},
+    {0x1D5BA, 0x1D5D3}, {0x1D5EE, 0x1D607}, {0x1D622, 0x1D63B}, {0x1D656, 0x1D66F},
+    {0x1D68A, 0x1D6A5}, {0x1D6C2, 0x1D6DA}, {0x1D6DC, 0x1D6E1}, {0x1D6FC, 0x1D714},
+    {0x1D716, 0x1D71B}, {0x1D736, 0x1D74E}, {0x1D750, 0x1D755}, {0x1D770, 0x1D788},
+    {0x1D78A, 0x1D78F}, {0x1D7AA, 0x1D7C2}, {0x1D7C4, 0x1D7C9}, {0x1E922, 0x1E943}
 #endif
 };

@@ -519,10 +510,10 @@ static const chr lowerCharTable[] = {
    0xA763, 0xA765, 0xA767, 0xA769, 0xA76B, 0xA76D, 0xA76F, 0xA77A, 0xA77C,
    0xA77F, 0xA781, 0xA783, 0xA785, 0xA787, 0xA78C, 0xA78E, 0xA791, 0xA797,
    0xA799, 0xA79B, 0xA79D, 0xA79F, 0xA7A1, 0xA7A3, 0xA7A5, 0xA7A7, 0xA7A9,
-    0xA7AF, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C1, 0xA7C3,
-    0xA7C8, 0xA7CA, 0xA7D1, 0xA7D3, 0xA7D5, 0xA7D7, 0xA7D9, 0xA7F6, 0xA7FA
+    0xA7AF, 0xA7B5, 0xA7B7, 0xA7B9, 0xA7BB, 0xA7BD, 0xA7BF, 0xA7C3, 0xA7C8,
+    0xA7CA, 0xA7F6, 0xA7FA
 #if CHRBITS > 16
-    ,0x105BB, 0x105BC, 0x1D4BB, 0x1D7CB
+    ,0x1D4BB, 0x1D7CB
 #endif
 };

@@ -541,18 +532,18 @@ static const crange upperRangeTable[] = {
    {0x1F18, 0x1F1D}, {0x1F28, 0x1F2F}, {0x1F38, 0x1F3F}, {0x1F48, 0x1F4D},
    {0x1F68, 0x1F6F}, {0x1FB8, 0x1FBB}, {0x1FC8, 0x1FCB}, {0x1FD8, 0x1FDB},
    {0x1FE8, 0x1FEC}, {0x1FF8, 0x1FFB}, {0x210B, 0x210D}, {0x2110, 0x2112},
-    {0x2119, 0x211D}, {0x212A, 0x212D}, {0x2130, 0x2133}, {0x2C00, 0x2C2F},
+    {0x2119, 0x211D}, {0x212A, 0x212D}, {0x2130, 0x2133}, {0x2C00, 0x2C2E},
    {0x2C62, 0x2C64}, {0x2C6D, 0x2C70}, {0x2C7E, 0x2C80}, {0xA7AA, 0xA7AE},
    {0xA7B0, 0xA7B4}, {0xA7C4, 0xA7C7}, {0xFF21, 0xFF3A}
 #if CHRBITS > 16
-    ,{0x10400, 0x10427}, {0x104B0, 0x104D3}, {0x10570, 0x1057A}, {0x1057C, 0x1058A},
-    {0x1058C, 0x10592}, {0x10C80, 0x10CB2}, {0x118A0, 0x118BF}, {0x16E40, 0x16E5F},
-    {0x1D400, 0x1D419}, {0x1D434, 0x1D44D}, {0x1D468, 0x1D481}, {0x1D4A9, 0x1D4AC},
-    {0x1D4AE, 0x1D4B5}, {0x1D4D0, 0x1D4E9}, {0x1D507, 0x1D50A}, {0x1D50D, 0x1D514},
-    {0x1D516, 0x1D51C}, {0x1D53B, 0x1D53E}, {0x1D540, 0x1D544}, {0x1D54A, 0x1D550},
-    {0x1D56C, 0x1D585}, {0x1D5A0, 0x1D5B9}, {0x1D5D4, 0x1D5ED}, {0x1D608, 0x1D621},
-    {0x1D63C, 0x1D655}, {0x1D670, 0x1D689}, {0x1D6A8, 0x1D6C0}, {0x1D6E2, 0x1D6FA},
-    {0x1D71C, 0x1D734}, {0x1D756, 0x1D76E}, {0x1D790, 0x1D7A8}, {0x1E900, 0x1E921}
+    ,{0x10400, 0x10427}, {0x104B0, 0x104D3}, {0x10C80, 0x10CB2}, {0x118A0, 0x118BF},
+    {0x16E40, 0x16E5F}, {0x1D400, 0x1D419}, {0x1D434, 0x1D44D}, {0x1D468, 0x1D481},
+    {0x1D4A9, 0x1D4AC}, {0x1D4AE, 0x1D4B5}, {0x1D4D0, 0x1D4E9}, {0x1D507, 0x1D50A},
+    {0x1D50D, 0x1D514}, {0x1D516, 0x1D51C}, {0x1D53B, 0x1D53E}, {0x1D540, 0x1D544},
+    {0x1D54A, 0x1D550}, {0x1D56C, 0x1D585}, {0x1D5A0, 0x1D5B9}, {0x1D5D4, 0x1D5ED},
+    {0x1D608, 0x1D621}, {0x1D63C, 0x1D655}, {0x1D670, 0x1D689}, {0x1D6A8, 0x1D6C0},
+    {0x1D6E2, 0x1D6FA}, {0x1D71C, 0x1D734}, {0x1D756, 0x1D76E}, {0x1D790, 0x1D7A8},
+    {0x1E900, 0x1E921}
 #endif
 };

@@ -622,11 +613,10 @@ static const chr upperCharTable[] = {
    0xA768, 0xA76A, 0xA76C, 0xA76E, 0xA779, 0xA77B, 0xA77D, 0xA77E, 0xA780,
    0xA782, 0xA784, 0xA786, 0xA78B, 0xA78D, 0xA790, 0xA792, 0xA796, 0xA798,
    0xA79A, 0xA79C, 0xA79E, 0xA7A0, 0xA7A2, 0xA7A4, 0xA7A6, 0xA7A8, 0xA7B6,
-    0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C0, 0xA7C2, 0xA7C9, 0xA7D0, 0xA7D6,
-    0xA7D8, 0xA7F5
+    0xA7B8, 0xA7BA, 0xA7BC, 0xA7BE, 0xA7C2, 0xA7C9, 0xA7F5
 #if CHRBITS > 16
-    ,0x10594, 0x10595, 0x1D49C, 0x1D49E, 0x1D49F, 0x1D4A2, 0x1D4A5, 0x1D4A6, 0x1D504,
-    0x1D505, 0x1D538, 0x1D539, 0x1D546, 0x1D7CA
+    ,0x1D49C, 0x1D49E, 0x1D49F, 0x1D4A2, 0x1D4A5, 0x1D4A6, 0x1D504, 0x1D505, 0x1D538,
+    0x1D539, 0x1D546, 0x1D7CA
 #endif
 };

@@ -640,72 +630,74 @@ static const crange graphRangeTable[] = {
    {0x21, 0x7E}, {0xA1, 0xAC}, {0xAE, 0x377}, {0x37A, 0x37F},
    {0x384, 0x38A}, {0x38E, 0x3A1}, {0x3A3, 0x52F}, {0x531, 0x556},
    {0x559, 0x58A}, {0x58D, 0x58F}, {0x591, 0x5C7}, {0x5D0, 0x5EA},
-    {0x5EF, 0x5F4}, {0x606, 0x61B}, {0x61D, 0x6DC}, {0x6DE, 0x70D},
+    {0x5EF, 0x5F4}, {0x606, 0x61B}, {0x61E, 0x6DC}, {0x6DE, 0x70D},
    {0x710, 0x74A}, {0x74D, 0x7B1}, {0x7C0, 0x7FA}, {0x7FD, 0x82D},
-    {0x830, 0x83E}, {0x840, 0x85B}, {0x860, 0x86A}, {0x870, 0x88E},
-    {0x898, 0x8E1}, {0x8E3, 0x983}, {0x985, 0x98C}, {0x993, 0x9A8},
-    {0x9AA, 0x9B0}, {0x9B6, 0x9B9}, {0x9BC, 0x9C4}, {0x9CB, 0x9CE},
-    {0x9DF, 0x9E3}, {0x9E6, 0x9FE}, {0xA01, 0xA03}, {0xA05, 0xA0A},
-    {0xA13, 0xA28}, {0xA2A, 0xA30}, {0xA3E, 0xA42}, {0xA4B, 0xA4D},
-    {0xA59, 0xA5C}, {0xA66, 0xA76}, {0xA81, 0xA83}, {0xA85, 0xA8D},
-    {0xA8F, 0xA91}, {0xA93, 0xAA8}, {0xAAA, 0xAB0}, {0xAB5, 0xAB9},
-    {0xABC, 0xAC5}, {0xAC7, 0xAC9}, {0xACB, 0xACD}, {0xAE0, 0xAE3},
-    {0xAE6, 0xAF1}, {0xAF9, 0xAFF}, {0xB01, 0xB03}, {0xB05, 0xB0C},
-    {0xB13, 0xB28}, {0xB2A, 0xB30}, {0xB35, 0xB39}, {0xB3C, 0xB44},
-    {0xB4B, 0xB4D}, {0xB55, 0xB57}, {0xB5F, 0xB63}, {0xB66, 0xB77},
-    {0xB85, 0xB8A}, {0xB8E, 0xB90}, {0xB92, 0xB95}, {0xBA8, 0xBAA},
-    {0xBAE, 0xBB9}, {0xBBE, 0xBC2}, {0xBC6, 0xBC8}, {0xBCA, 0xBCD},
-    {0xBE6, 0xBFA}, {0xC00, 0xC0C}, {0xC0E, 0xC10}, {0xC12, 0xC28},
-    {0xC2A, 0xC39}, {0xC3C, 0xC44}, {0xC46, 0xC48}, {0xC4A, 0xC4D},
-    {0xC58, 0xC5A}, {0xC60, 0xC63}, {0xC66, 0xC6F}, {0xC77, 0xC8C},
-    {0xC8E, 0xC90}, {0xC92, 0xCA8}, {0xCAA, 0xCB3}, {0xCB5, 0xCB9},
-    {0xCBC, 0xCC4}, {0xCC6, 0xCC8}, {0xCCA, 0xCCD}, {0xCE0, 0xCE3},
-    {0xCE6, 0xCEF}, {0xD00, 0xD0C}, {0xD0E, 0xD10}, {0xD12, 0xD44},
-    {0xD46, 0xD48}, {0xD4A, 0xD4F}, {0xD54, 0xD63}, {0xD66, 0xD7F},
-    {0xD81, 0xD83}, {0xD85, 0xD96}, {0xD9A, 0xDB1}, {0xDB3, 0xDBB},
-    {0xDC0, 0xDC6}, {0xDCF, 0xDD4}, {0xDD8, 0xDDF}, {0xDE6, 0xDEF},
-    {0xDF2, 0xDF4}, {0xE01, 0xE3A}, {0xE3F, 0xE5B}, {0xE86, 0xE8A},
-    {0xE8C, 0xEA3}, {0xEA7, 0xEBD}, {0xEC0, 0xEC4}, {0xEC8, 0xECD},
-    {0xED0, 0xED9}, {0xEDC, 0xEDF}, {0xF00, 0xF47}, {0xF49, 0xF6C},
-    {0xF71, 0xF97}, {0xF99, 0xFBC}, {0xFBE, 0xFCC}, {0xFCE, 0xFDA},
-    {0x1000, 0x10C5}, {0x10D0, 0x1248}, {0x124A, 0x124D}, {0x1250, 0x1256},
-    {0x125A, 0x125D}, {0x1260, 0x1288}, {0x128A, 0x128D}, {0x1290, 0x12B0},
-    {0x12B2, 0x12B5}, {0x12B8, 0x12BE}, {0x12C2, 0x12C5}, {0x12C8, 0x12D6},
-    {0x12D8, 0x1310}, {0x1312, 0x1315}, {0x1318, 0x135A}, {0x135D, 0x137C},
-    {0x1380, 0x1399}, {0x13A0, 0x13F5}, {0x13F8, 0x13FD}, {0x1400, 0x167F},
-    {0x1681, 0x169C}, {0x16A0, 0x16F8}, {0x1700, 0x1715}, {0x171F, 0x1736},
-    {0x1740, 0x1753}, {0x1760, 0x176C}, {0x176E, 0x1770}, {0x1780, 0x17DD},
-    {0x17E0, 0x17E9}, {0x17F0, 0x17F9}, {0x1800, 0x180D}, {0x180F, 0x1819},
-    {0x1820, 0x1878}, {0x1880, 0x18AA}, {0x18B0, 0x18F5}, {0x1900, 0x191E},
-    {0x1920, 0x192B}, {0x1930, 0x193B}, {0x1944, 0x196D}, {0x1970, 0x1974},
-    {0x1980, 0x19AB}, {0x19B0, 0x19C9}, {0x19D0, 0x19DA}, {0x19DE, 0x1A1B},
-    {0x1A1E, 0x1A5E}, {0x1A60, 0x1A7C}, {0x1A7F, 0x1A89}, {0x1A90, 0x1A99},
-    {0x1AA0, 0x1AAD}, {0x1AB0, 0x1ACE}, {0x1B00, 0x1B4C}, {0x1B50, 0x1B7E},
-    {0x1B80, 0x1BF3}, {0x1BFC, 0x1C37}, {0x1C3B, 0x1C49}, {0x1C4D, 0x1C88},
-    {0x1C90, 0x1CBA}, {0x1CBD, 0x1CC7}, {0x1CD0, 0x1CFA}, {0x1D00, 0x1F15},
-    {0x1F18, 0x1F1D}, {0x1F20, 0x1F45}, {0x1F48, 0x1F4D}, {0x1F50, 0x1F57},
-    {0x1F5F, 0x1F7D}, {0x1F80, 0x1FB4}, {0x1FB6, 0x1FC4}, {0x1FC6, 0x1FD3},
-    {0x1FD6, 0x1FDB}, {0x1FDD, 0x1FEF}, {0x1FF2, 0x1FF4}, {0x1FF6, 0x1FFE},
-    {0x2010, 0x2027}, {0x2030, 0x205E}, {0x2074, 0x208E}, {0x2090, 0x209C},
-    {0x20A0, 0x20C0}, {0x20D0, 0x20F0}, {0x2100, 0x218B}, {0x2190, 0x2426},
-    {0x2440, 0x244A}, {0x2460, 0x2B73}, {0x2B76, 0x2B95}, {0x2B97, 0x2CF3},
-    {0x2CF9, 0x2D25}, {0x2D30, 0x2D67}, {0x2D7F, 0x2D96}, {0x2DA0, 0x2DA6},
-    {0x2DA8, 0x2DAE}, {0x2DB0, 0x2DB6}, {0x2DB8, 0x2DBE}, {0x2DC0, 0x2DC6},
-    {0x2DC8, 0x2DCE}, {0x2DD0, 0x2DD6}, {0x2DD8, 0x2DDE}, {0x2DE0, 0x2E5D},
-    {0x2E80, 0x2E99}, {0x2E9B, 0x2EF3}, {0x2F00, 0x2FD5}, {0x2FF0, 0x2FFB},
-    {0x3001, 0x303F}, {0x3041, 0x3096}, {0x3099, 0x30FF}, {0x3105, 0x312F},
-    {0x3131, 0x318E}, {0x3190, 0x31E3}, {0x31F0, 0x321E}, {0x3220, 0xA48C},
-    {0xA490, 0xA4C6}, {0xA4D0, 0xA62B}, {0xA640, 0xA6F7}, {0xA700, 0xA7CA},
-    {0xA7D5, 0xA7D9}, {0xA7F2, 0xA82C}, {0xA830, 0xA839}, {0xA840, 0xA877},
-    {0xA880, 0xA8C5}, {0xA8CE, 0xA8D9}, {0xA8E0, 0xA953}, {0xA95F, 0xA97C},
-    {0xA980, 0xA9CD}, {0xA9CF, 0xA9D9}, {0xA9DE, 0xA9FE}, {0xAA00, 0xAA36},
-    {0xAA40, 0xAA4D}, {0xAA50, 0xAA59}, {0xAA5C, 0xAAC2}, {0xAADB, 0xAAF6},
-    {0xAB01, 0xAB06}, {0xAB09, 0xAB0E}, {0xAB11, 0xAB16}, {0xAB20, 0xAB26},
-    {0xAB28, 0xAB2E}, {0xAB30, 0xAB6B}, {0xAB70, 0xABED}, {0xABF0, 0xABF9},
-    {0xAC00, 0xD7A3}, {0xD7B0, 0xD7C6}, {0xD7CB, 0xD7FB}, {0xF900, 0xFA6D},
-    {0xFA70, 0xFAD9}, {0xFB00, 0xFB06}, {0xFB13, 0xFB17}, {0xFB1D, 0xFB36},
-    {0xFB38, 0xFB3C}, {0xFB46, 0xFBC2}, {0xFBD3, 0xFD8F}, {0xFD92, 0xFDC7},
-    {0xFDF0, 0xFE19}, {0xFE20, 0xFE52}, {0xFE54, 0xFE66}, {0xFE68, 0xFE6B},
+    {0x830, 0x83E}, {0x840, 0x85B}, {0x860, 0x86A}, {0x8A0, 0x8B4},
+    {0x8B6, 0x8C7}, {0x8D3, 0x8E1}, {0x8E3, 0x983}, {0x985, 0x98C},
+    {0x993, 0x9A8}, {0x9AA, 0x9B0}, {0x9B6, 0x9B9}, {0x9BC, 0x9C4},
+    {0x9CB, 0x9CE}, {0x9DF, 0x9E3}, {0x9E6, 0x9FE}, {0xA01, 0xA03},
+    {0xA05, 0xA0A}, {0xA13, 0xA28}, {0xA2A, 0xA30}, {0xA3E, 0xA42},
+    {0xA4B, 0xA4D}, {0xA59, 0xA5C}, {0xA66, 0xA76}, {0xA81, 0xA83},
+    {0xA85, 0xA8D}, {0xA8F, 0xA91}, {0xA93, 0xAA8}, {0xAAA, 0xAB0},
+    {0xAB5, 0xAB9}, {0xABC, 0xAC5}, {0xAC7, 0xAC9}, {0xACB, 0xACD},
+    {0xAE0, 0xAE3}, {0xAE6, 0xAF1}, {0xAF9, 0xAFF}, {0xB01, 0xB03},
+    {0xB05, 0xB0C}, {0xB13, 0xB28}, {0xB2A, 0xB30}, {0xB35, 0xB39},
+    {0xB3C, 0xB44}, {0xB4B, 0xB4D}, {0xB55, 0xB57}, {0xB5F, 0xB63},
+    {0xB66, 0xB77}, {0xB85, 0xB8A}, {0xB8E, 0xB90}, {0xB92, 0xB95},
+    {0xBA8, 0xBAA}, {0xBAE, 0xBB9}, {0xBBE, 0xBC2}, {0xBC6, 0xBC8},
+    {0xBCA, 0xBCD}, {0xBE6, 0xBFA}, {0xC00, 0xC0C}, {0xC0E, 0xC10},
+    {0xC12, 0xC28}, {0xC2A, 0xC39}, {0xC3D, 0xC44}, {0xC46, 0xC48},
+    {0xC4A, 0xC4D}, {0xC58, 0xC5A}, {0xC60, 0xC63}, {0xC66, 0xC6F},
+    {0xC77, 0xC8C}, {0xC8E, 0xC90}, {0xC92, 0xCA8}, {0xCAA, 0xCB3},
+    {0xCB5, 0xCB9}, {0xCBC, 0xCC4}, {0xCC6, 0xCC8}, {0xCCA, 0xCCD},
+    {0xCE0, 0xCE3}, {0xCE6, 0xCEF}, {0xD00, 0xD0C}, {0xD0E, 0xD10},
+    {0xD12, 0xD44}, {0xD46, 0xD48}, {0xD4A, 0xD4F}, {0xD54, 0xD63},
+    {0xD66, 0xD7F}, {0xD81, 0xD83}, {0xD85, 0xD96}, {0xD9A, 0xDB1},
+    {0xDB3, 0xDBB}, {0xDC0, 0xDC6}, {0xDCF, 0xDD4}, {0xDD8, 0xDDF},
+    {0xDE6, 0xDEF}, {0xDF2, 0xDF4}, {0xE01, 0xE3A}, {0xE3F, 0xE5B},
+    {0xE86, 0xE8A}, {0xE8C, 0xEA3}, {0xEA7, 0xEBD}, {0xEC0, 0xEC4},
+    {0xEC8, 0xECD}, {0xED0, 0xED9}, {0xEDC, 0xEDF}, {0xF00, 0xF47},
+    {0xF49, 0xF6C}, {0xF71, 0xF97}, {0xF99, 0xFBC}, {0xFBE, 0xFCC},
+    {0xFCE, 0xFDA}, {0x1000, 0x10C5}, {0x10D0, 0x1248}, {0x124A, 0x124D},
+    {0x1250, 0x1256}, {0x125A, 0x125D}, {0x1260, 0x1288}, {0x128A, 0x128D},
+    {0x1290, 0x12B0}, {0x12B2, 0x12B5}, {0x12B8, 0x12BE}, {0x12C2, 0x12C5},
+    {0x12C8, 0x12D6}, {0x12D8, 0x1310}, {0x1312, 0x1315}, {0x1318, 0x135A},
+    {0x135D, 0x137C}, {0x1380, 0x1399}, {0x13A0, 0x13F5}, {0x13F8, 0x13FD},
+    {0x1400, 0x167F}, {0x1681, 0x169C}, {0x16A0, 0x16F8}, {0x1700, 0x170C},
+    {0x170E, 0x1714}, {0x1720, 0x1736}, {0x1740, 0x1753}, {0x1760, 0x176C},
+    {0x176E, 0x1770}, {0x1780, 0x17DD}, {0x17E0, 0x17E9}, {0x17F0, 0x17F9},
+    {0x1800, 0x180D}, {0x1810, 0x1819}, {0x1820, 0x1878}, {0x1880, 0x18AA},
+    {0x18B0, 0x18F5}, {0x1900, 0x191E}, {0x1920, 0x192B}, {0x1930, 0x193B},
+    {0x1944, 0x196D}, {0x1970, 0x1974}, {0x1980, 0x19AB}, {0x19B0, 0x19C9},
+    {0x19D0, 0x19DA}, {0x19DE, 0x1A1B}, {0x1A1E, 0x1A5E}, {0x1A60, 0x1A7C},
+    {0x1A7F, 0x1A89}, {0x1A90, 0x1A99}, {0x1AA0, 0x1AAD}, {0x1AB0, 0x1AC0},
+    {0x1B00, 0x1B4B}, {0x1B50, 0x1B7C}, {0x1B80, 0x1BF3}, {0x1BFC, 0x1C37},
+    {0x1C3B, 0x1C49}, {0x1C4D, 0x1C88}, {0x1C90, 0x1CBA}, {0x1CBD, 0x1CC7},
+    {0x1CD0, 0x1CFA}, {0x1D00, 0x1DF9}, {0x1DFB, 0x1F15}, {0x1F18, 0x1F1D},
+    {0x1F20, 0x1F45}, {0x1F48, 0x1F4D}, {0x1F50, 0x1F57}, {0x1F5F, 0x1F7D},
+    {0x1F80, 0x1FB4}, {0x1FB6, 0x1FC4}, {0x1FC6, 0x1FD3}, {0x1FD6, 0x1FDB},
+    {0x1FDD, 0x1FEF}, {0x1FF2, 0x1FF4}, {0x1FF6, 0x1FFE}, {0x2010, 0x2027},
+    {0x2030, 0x205E}, {0x2074, 0x208E}, {0x2090, 0x209C}, {0x20A0, 0x20BF},
+    {0x20D0, 0x20F0}, {0x2100, 0x218B}, {0x2190, 0x2426}, {0x2440, 0x244A},
+    {0x2460, 0x2B73}, {0x2B76, 0x2B95}, {0x2B97, 0x2C2E}, {0x2C30, 0x2C5E},
+    {0x2C60, 0x2CF3}, {0x2CF9, 0x2D25}, {0x2D30, 0x2D67}, {0x2D7F, 0x2D96},
+    {0x2DA0, 0x2DA6}, {0x2DA8, 0x2DAE}, {0x2DB0, 0x2DB6}, {0x2DB8, 0x2DBE},
+    {0x2DC0, 0x2DC6}, {0x2DC8, 0x2DCE}, {0x2DD0, 0x2DD6}, {0x2DD8, 0x2DDE},
+    {0x2DE0, 0x2E52}, {0x2E80, 0x2E99}, {0x2E9B, 0x2EF3}, {0x2F00, 0x2FD5},
+    {0x2FF0, 0x2FFB}, {0x3001, 0x303F}, {0x3041, 0x3096}, {0x3099, 0x30FF},
+    {0x3105, 0x312F}, {0x3131, 0x318E}, {0x3190, 0x31E3}, {0x31F0, 0x321E},
+    {0x3220, 0x9FFC}, {0xA000, 0xA48C}, {0xA490, 0xA4C6}, {0xA4D0, 0xA62B},
+    {0xA640, 0xA6F7}, {0xA700, 0xA7BF}, {0xA7C2, 0xA7CA}, {0xA7F5, 0xA82C},
+    {0xA830, 0xA839}, {0xA840, 0xA877}, {0xA880, 0xA8C5}, {0xA8CE, 0xA8D9},
+    {0xA8E0, 0xA953}, {0xA95F, 0xA97C}, {0xA980, 0xA9CD}, {0xA9CF, 0xA9D9},
+    {0xA9DE, 0xA9FE}, {0xAA00, 0xAA36}, {0xAA40, 0xAA4D}, {0xAA50, 0xAA59},
+    {0xAA5C, 0xAAC2}, {0xAADB, 0xAAF6}, {0xAB01, 0xAB06}, {0xAB09, 0xAB0E},
+    {0xAB11, 0xAB16}, {0xAB20, 0xAB26}, {0xAB28, 0xAB2E}, {0xAB30, 0xAB6B},
+    {0xAB70, 0xABED}, {0xABF0, 0xABF9}, {0xAC00, 0xD7A3}, {0xD7B0, 0xD7C6},
+    {0xD7CB, 0xD7FB}, {0xF900, 0xFA6D}, {0xFA70, 0xFAD9}, {0xFB00, 0xFB06},
+    {0xFB13, 0xFB17}, {0xFB1D, 0xFB36}, {0xFB38, 0xFB3C}, {0xFB46, 0xFBC1},
+    {0xFBD3, 0xFD3F}, {0xFD50, 0xFD8F}, {0xFD92, 0xFDC7}, {0xFDF0, 0xFDFD},
+    {0xFE00, 0xFE19}, {0xFE20, 0xFE52}, {0xFE54, 0xFE66}, {0xFE68, 0xFE6B},
    {0xFE70, 0xFE74}, {0xFE76, 0xFEFC}, {0xFF01, 0xFFBE}, {0xFFC2, 0xFFC7},
    {0xFFCA, 0xFFCF}, {0xFFD2, 0xFFD7}, {0xFFDA, 0xFFDC}, {0xFFE0, 0xFFE6},
    {0xFFE8, 0xFFEE}
@@ -716,74 +708,68 @@ static const crange graphRangeTable[] = {
    {0x102A0, 0x102D0}, {0x102E0, 0x102FB}, {0x10300, 0x10323}, {0x1032D, 0x1034A},
    {0x10350, 0x1037A}, {0x10380, 0x1039D}, {0x1039F, 0x103C3}, {0x103C8, 0x103D5},
    {0x10400, 0x1049D}, {0x104A0, 0x104A9}, {0x104B0, 0x104D3}, {0x104D8, 0x104FB},
-    {0x10500, 0x10527}, {0x10530, 0x10563}, {0x1056F, 0x1057A}, {0x1057C, 0x1058A},
-    {0x1058C, 0x10592}, {0x10597, 0x105A1}, {0x105A3, 0x105B1}, {0x105B3, 0x105B9},
-    {0x10600, 0x10736}, {0x10740, 0x10755}, {0x10760, 0x10767}, {0x10780, 0x10785},
-    {0x10787, 0x107B0}, {0x107B2, 0x107BA}, {0x10800, 0x10805}, {0x1080A, 0x10835},
-    {0x1083F, 0x10855}, {0x10857, 0x1089E}, {0x108A7, 0x108AF}, {0x108E0, 0x108F2},
-    {0x108FB, 0x1091B}, {0x1091F, 0x10939}, {0x10980, 0x109B7}, {0x109BC, 0x109CF},
-    {0x109D2, 0x10A03}, {0x10A0C, 0x10A13}, {0x10A15, 0x10A17}, {0x10A19, 0x10A35},
-    {0x10A38, 0x10A3A}, {0x10A3F, 0x10A48}, {0x10A50, 0x10A58}, {0x10A60, 0x10A9F},
-    {0x10AC0, 0x10AE6}, {0x10AEB, 0x10AF6}, {0x10B00, 0x10B35}, {0x10B39, 0x10B55},
-    {0x10B58, 0x10B72}, {0x10B78, 0x10B91}, {0x10B99, 0x10B9C}, {0x10BA9, 0x10BAF},
-    {0x10C00, 0x10C48}, {0x10C80, 0x10CB2}, {0x10CC0, 0x10CF2}, {0x10CFA, 0x10D27},
-    {0x10D30, 0x10D39}, {0x10E60, 0x10E7E}, {0x10E80, 0x10EA9}, {0x10EAB, 0x10EAD},
-    {0x10F00, 0x10F27}, {0x10F30, 0x10F59}, {0x10F70, 0x10F89}, {0x10FB0, 0x10FCB},
-    {0x10FE0, 0x10FF6}, {0x11000, 0x1104D}, {0x11052, 0x11075}, {0x1107F, 0x110BC},
-    {0x110BE, 0x110C2}, {0x110D0, 0x110E8}, {0x110F0, 0x110F9}, {0x11100, 0x11134},
-    {0x11136, 0x11147}, {0x11150, 0x11176}, {0x11180, 0x111DF}, {0x111E1, 0x111F4},
-    {0x11200, 0x11211}, {0x11213, 0x1123E}, {0x11280, 0x11286}, {0x1128A, 0x1128D},
-    {0x1128F, 0x1129D}, {0x1129F, 0x112A9}, {0x112B0, 0x112EA}, {0x112F0, 0x112F9},
-    {0x11300, 0x11303}, {0x11305, 0x1130C}, {0x11313, 0x11328}, {0x1132A, 0x11330},
-    {0x11335, 0x11339}, {0x1133B, 0x11344}, {0x1134B, 0x1134D}, {0x1135D, 0x11363},
-    {0x11366, 0x1136C}, {0x11370, 0x11374}, {0x11400, 0x1145B}, {0x1145D, 0x11461},
-    {0x11480, 0x114C7}, {0x114D0, 0x114D9}, {0x11580, 0x115B5}, {0x115B8, 0x115DD},
-    {0x11600, 0x11644}, {0x11650, 0x11659}, {0x11660, 0x1166C}, {0x11680, 0x116B9},
-    {0x116C0, 0x116C9}, {0x11700, 0x1171A}, {0x1171D, 0x1172B}, {0x11730, 0x11746},
-    {0x11800, 0x1183B}, {0x118A0, 0x118F2}, {0x118FF, 0x11906}, {0x1190C, 0x11913},
-    {0x11918, 0x11935}, {0x1193B, 0x11946}, {0x11950, 0x11959}, {0x119A0, 0x119A7},
-    {0x119AA, 0x119D7}, {0x119DA, 0x119E4}, {0x11A00, 0x11A47}, {0x11A50, 0x11AA2},
-    {0x11AB0, 0x11AF8}, {0x11C00, 0x11C08}, {0x11C0A, 0x11C36}, {0x11C38, 0x11C45},
-    {0x11C50, 0x11C6C}, {0x11C70, 0x11C8F}, {0x11C92, 0x11CA7}, {0x11CA9, 0x11CB6},
-    {0x11D00, 0x11D06}, {0x11D0B, 0x11D36}, {0x11D3F, 0x11D47}, {0x11D50, 0x11D59},
-    {0x11D60, 0x11D65}, {0x11D6A, 0x11D8E}, {0x11D93, 0x11D98}, {0x11DA0, 0x11DA9},
-    {0x11EE0, 0x11EF8}, {0x11FC0, 0x11FF1}, {0x11FFF, 0x12399}, {0x12400, 0x1246E},
-    {0x12470, 0x12474}, {0x12480, 0x12543}, {0x12F90, 0x12FF2}, {0x13000, 0x1342E},
-    {0x14400, 0x14646}, {0x16800, 0x16A38}, {0x16A40, 0x16A5E}, {0x16A60, 0x16A69},
-    {0x16A6E, 0x16ABE}, {0x16AC0, 0x16AC9}, {0x16AD0, 0x16AED}, {0x16AF0, 0x16AF5},
-    {0x16B00, 0x16B45}, {0x16B50, 0x16B59}, {0x16B5B, 0x16B61}, {0x16B63, 0x16B77},
-    {0x16B7D, 0x16B8F}, {0x16E40, 0x16E9A}, {0x16F00, 0x16F4A}, {0x16F4F, 0x16F87},
-    {0x16F8F, 0x16F9F}, {0x16FE0, 0x16FE4}, {0x17000, 0x187F7}, {0x18800, 0x18CD5},
-    {0x18D00, 0x18D08}, {0x1AFF0, 0x1AFF3}, {0x1AFF5, 0x1AFFB}, {0x1B000, 0x1B122},
-    {0x1B150, 0x1B152}, {0x1B164, 0x1B167}, {0x1B170, 0x1B2FB}, {0x1BC00, 0x1BC6A},
-    {0x1BC70, 0x1BC7C}, {0x1BC80, 0x1BC88}, {0x1BC90, 0x1BC99}, {0x1BC9C, 0x1BC9F},
-    {0x1CF00, 0x1CF2D}, {0x1CF30, 0x1CF46}, {0x1CF50, 0x1CFC3}, {0x1D000, 0x1D0F5},
-    {0x1D100, 0x1D126}, {0x1D129, 0x1D172}, {0x1D17B, 0x1D1EA}, {0x1D200, 0x1D245},
-    {0x1D2E0, 0x1D2F3}, {0x1D300, 0x1D356}, {0x1D360, 0x1D378}, {0x1D400, 0x1D454},
-    {0x1D456, 0x1D49C}, {0x1D4A9, 0x1D4AC}, {0x1D4AE, 0x1D4B9}, {0x1D4BD, 0x1D4C3},
-    {0x1D4C5, 0x1D505}, {0x1D507, 0x1D50A}, {0x1D50D, 0x1D514}, {0x1D516, 0x1D51C},
-    {0x1D51E, 0x1D539}, {0x1D53B, 0x1D53E}, {0x1D540, 0x1D544}, {0x1D54A, 0x1D550},
-    {0x1D552, 0x1D6A5}, {0x1D6A8, 0x1D7CB}, {0x1D7CE, 0x1DA8B}, {0x1DA9B, 0x1DA9F},
-    {0x1DAA1, 0x1DAAF}, {0x1DF00, 0x1DF1E}, {0x1E000, 0x1E006}, {0x1E008, 0x1E018},
-    {0x1E01B, 0x1E021}, {0x1E026, 0x1E02A}, {0x1E100, 0x1E12C}, {0x1E130, 0x1E13D},
-    {0x1E140, 0x1E149}, {0x1E290, 0x1E2AE}, {0x1E2C0, 0x1E2F9}, {0x1E7E0, 0x1E7E6},
-    {0x1E7E8, 0x1E7EB}, {0x1E7F0, 0x1E7FE}, {0x1E800, 0x1E8C4}, {0x1E8C7, 0x1E8D6},
-    {0x1E900, 0x1E94B}, {0x1E950, 0x1E959}, {0x1EC71, 0x1ECB4}, {0x1ED01, 0x1ED3D},
-    {0x1EE00, 0x1EE03}, {0x1EE05, 0x1EE1F}, {0x1EE29, 0x1EE32}, {0x1EE34, 0x1EE37},
-    {0x1EE4D, 0x1EE4F}, {0x1EE67, 0x1EE6A}, {0x1EE6C, 0x1EE72}, {0x1EE74, 0x1EE77},
-    {0x1EE79, 0x1EE7C}, {0x1EE80, 0x1EE89}, {0x1EE8B, 0x1EE9B}, {0x1EEA1, 0x1EEA3},
-    {0x1EEA5, 0x1EEA9}, {0x1EEAB, 0x1EEBB}, {0x1F000, 0x1F02B}, {0x1F030, 0x1F093},
-    {0x1F0A0, 0x1F0AE}, {0x1F0B1, 0x1F0BF}, {0x1F0C1, 0x1F0CF}, {0x1F0D1, 0x1F0F5},
-    {0x1F100, 0x1F1AD}, {0x1F1E6, 0x1F202}, {0x1F210, 0x1F23B}, {0x1F240, 0x1F248},
-    {0x1F260, 0x1F265}, {0x1F300, 0x1F6D7}, {0x1F6DD, 0x1F6EC}, {0x1F6F0, 0x1F6FC},
-    {0x1F700, 0x1F773}, {0x1F780, 0x1F7D8}, {0x1F7E0, 0x1F7EB}, {0x1F800, 0x1F80B},
-    {0x1F810, 0x1F847}, {0x1F850, 0x1F859}, {0x1F860, 0x1F887}, {0x1F890, 0x1F8AD},
-    {0x1F900, 0x1FA53}, {0x1FA60, 0x1FA6D}, {0x1FA70, 0x1FA74}, {0x1FA78, 0x1FA7C},
-    {0x1FA80, 0x1FA86}, {0x1FA90, 0x1FAAC}, {0x1FAB0, 0x1FABA}, {0x1FAC0, 0x1FAC5},
-    {0x1FAD0, 0x1FAD9}, {0x1FAE0, 0x1FAE7}, {0x1FAF0, 0x1FAF6}, {0x1FB00, 0x1FB92},
-    {0x1FB94, 0x1FBCA}, {0x1FBF0, 0x1FBF9}, {0x20000, 0x2A6DF}, {0x2A700, 0x2B738},
-    {0x2B740, 0x2B81D}, {0x2B820, 0x2CEA1}, {0x2CEB0, 0x2EBE0}, {0x2F800, 0x2FA1D},
-    {0x30000, 0x3134A}, {0xE0100, 0xE01EF}
+    {0x10500, 0x10527}, {0x10530, 0x10563}, {0x10600, 0x10736}, {0x10740, 0x10755},
+    {0x10760, 0x10767}, {0x10800, 0x10805}, {0x1080A, 0x10835}, {0x1083F, 0x10855},
+    {0x10857, 0x1089E}, {0x108A7, 0x108AF}, {0x108E0, 0x108F2}, {0x108FB, 0x1091B},
+    {0x1091F, 0x10939}, {0x10980, 0x109B7}, {0x109BC, 0x109CF}, {0x109D2, 0x10A03},
+    {0x10A0C, 0x10A13}, {0x10A15, 0x10A17}, {0x10A19, 0x10A35}, {0x10A38, 0x10A3A},
+    {0x10A3F, 0x10A48}, {0x10A50, 0x10A58}, {0x10A60, 0x10A9F}, {0x10AC0, 0x10AE6},
+    {0x10AEB, 0x10AF6}, {0x10B00, 0x10B35}, {0x10B39, 0x10B55}, {0x10B58, 0x10B72},
+    {0x10B78, 0x10B91}, {0x10B99, 0x10B9C}, {0x10BA9, 0x10BAF}, {0x10C00, 0x10C48},
+    {0x10C80, 0x10CB2}, {0x10CC0, 0x10CF2}, {0x10CFA, 0x10D27}, {0x10D30, 0x10D39},
+    {0x10E60, 0x10E7E}, {0x10E80, 0x10EA9}, {0x10EAB, 0x10EAD}, {0x10F00, 0x10F27},
+    {0x10F30, 0x10F59}, {0x10FB0, 0x10FCB}, {0x10FE0, 0x10FF6}, {0x11000, 0x1104D},
+    {0x11052, 0x1106F}, {0x1107F, 0x110BC}, {0x110BE, 0x110C1}, {0x110D0, 0x110E8},
+    {0x110F0, 0x110F9}, {0x11100, 0x11134}, {0x11136, 0x11147}, {0x11150, 0x11176},
+    {0x11180, 0x111DF}, {0x111E1, 0x111F4}, {0x11200, 0x11211}, {0x11213, 0x1123E},
+    {0x11280, 0x11286}, {0x1128A, 0x1128D}, {0x1128F, 0x1129D}, {0x1129F, 0x112A9},
+    {0x112B0, 0x112EA}, {0x112F0, 0x112F9}, {0x11300, 0x11303}, {0x11305, 0x1130C},
+    {0x11313, 0x11328}, {0x1132A, 0x11330}, {0x11335, 0x11339}, {0x1133B, 0x11344},
+    {0x1134B, 0x1134D}, {0x1135D, 0x11363}, {0x11366, 0x1136C}, {0x11370, 0x11374},
+    {0x11400, 0x1145B}, {0x1145D, 0x11461}, {0x11480, 0x114C7}, {0x114D0, 0x114D9},
+    {0x11580, 0x115B5}, {0x115B8, 0x115DD}, {0x11600, 0x11644}, {0x11650, 0x11659},
+    {0x11660, 0x1166C}, {0x11680, 0x116B8}, {0x116C0, 0x116C9}, {0x11700, 0x1171A},
+    {0x1171D, 0x1172B}, {0x11730, 0x1173F}, {0x11800, 0x1183B}, {0x118A0, 0x118F2},
+    {0x118FF, 0x11906}, {0x1190C, 0x11913}, {0x11918, 0x11935}, {0x1193B, 0x11946},
+    {0x11950, 0x11959}, {0x119A0, 0x119A7}, {0x119AA, 0x119D7}, {0x119DA, 0x119E4},
+    {0x11A00, 0x11A47}, {0x11A50, 0x11AA2}, {0x11AC0, 0x11AF8}, {0x11C00, 0x11C08},
+    {0x11C0A, 0x11C36}, {0x11C38, 0x11C45}, {0x11C50, 0x11C6C}, {0x11C70, 0x11C8F},
+    {0x11C92, 0x11CA7}, {0x11CA9, 0x11CB6}, {0x11D00, 0x11D06}, {0x11D0B, 0x11D36},
+    {0x11D3F, 0x11D47}, {0x11D50, 0x11D59}, {0x11D60, 0x11D65}, {0x11D6A, 0x11D8E},
+    {0x11D93, 0x11D98}, {0x11DA0, 0x11DA9}, {0x11EE0, 0x11EF8}, {0x11FC0, 0x11FF1},
+    {0x11FFF, 0x12399}, {0x12400, 0x1246E}, {0x12470, 0x12474}, {0x12480, 0x12543},
+    {0x13000, 0x1342E}, {0x14400, 0x14646}, {0x16800, 0x16A38}, {0x16A40, 0x16A5E},
+    {0x16A60, 0x16A69}, {0x16AD0, 0x16AED}, {0x16AF0, 0x16AF5}, {0x16B00, 0x16B45},
+    {0x16B50, 0x16B59}, {0x16B5B, 0x16B61}, {0x16B63, 0x16B77}, {0x16B7D, 0x16B8F},
+    {0x16E40, 0x16E9A}, {0x16F00, 0x16F4A}, {0x16F4F, 0x16F87}, {0x16F8F, 0x16F9F},
+    {0x16FE0, 0x16FE4}, {0x17000, 0x187F7}, {0x18800, 0x18CD5}, {0x18D00, 0x18D08},
+    {0x1B000, 0x1B11E}, {0x1B150, 0x1B152}, {0x1B164, 0x1B167}, {0x1B170, 0x1B2FB},
+    {0x1BC00, 0x1BC6A}, {0x1BC70, 0x1BC7C}, {0x1BC80, 0x1BC88}, {0x1BC90, 0x1BC99},
+    {0x1BC9C, 0x1BC9F}, {0x1D000, 0x1D0F5}, {0x1D100, 0x1D126}, {0x1D129, 0x1D172},
+    {0x1D17B, 0x1D1E8}, {0x1D200, 0x1D245}, {0x1D2E0, 0x1D2F3}, {0x1D300, 0x1D356},
+    {0x1D360, 0x1D378}, {0x1D400, 0x1D454}, {0x1D456, 0x1D49C}, {0x1D4A9, 0x1D4AC},
+    {0x1D4AE, 0x1D4B9}, {0x1D4BD, 0x1D4C3}, {0x1D4C5, 0x1D505}, {0x1D507, 0x1D50A},
+    {0x1D50D, 0x1D514}, {0x1D516, 0x1D51C}, {0x1D51E, 0x1D539}, {0x1D53B, 0x1D53E},
+    {0x1D540, 0x1D544}, {0x1D54A, 0x1D550}, {0x1D552, 0x1D6A5}, {0x1D6A8, 0x1D7CB},
+    {0x1D7CE, 0x1DA8B}, {0x1DA9B, 0x1DA9F}, {0x1DAA1, 0x1DAAF}, {0x1E000, 0x1E006},
+    {0x1E008, 0x1E018}, {0x1E01B, 0x1E021}, {0x1E026, 0x1E02A}, {0x1E100, 0x1E12C},
+    {0x1E130, 0x1E13D}, {0x1E140, 0x1E149}, {0x1E2C0, 0x1E2F9}, {0x1E800, 0x1E8C4},
+    {0x1E8C7, 0x1E8D6}, {0x1E900, 0x1E94B}, {0x1E950, 0x1E959}, {0x1EC71, 0x1ECB4},
+    {0x1ED01, 0x1ED3D}, {0x1EE00, 0x1EE03}, {0x1EE05, 0x1EE1F}, {0x1EE29, 0x1EE32},
+    {0x1EE34, 0x1EE37}, {0x1EE4D, 0x1EE4F}, {0x1EE67, 0x1EE6A}, {0x1EE6C, 0x1EE72},
+    {0x1EE74, 0x1EE77}, {0x1EE79, 0x1EE7C}, {0x1EE80, 0x1EE89}, {0x1EE8B, 0x1EE9B},
+    {0x1EEA1, 0x1EEA3}, {0x1EEA5, 0x1EEA9}, {0x1EEAB, 0x1EEBB}, {0x1F000, 0x1F02B},
+    {0x1F030, 0x1F093}, {0x1F0A0, 0x1F0AE}, {0x1F0B1, 0x1F0BF}, {0x1F0C1, 0x1F0CF},
+    {0x1F0D1, 0x1F0F5}, {0x1F100, 0x1F1AD}, {0x1F1E6, 0x1F202}, {0x1F210, 0x1F23B},
+    {0x1F240, 0x1F248}, {0x1F260, 0x1F265}, {0x1F300, 0x1F6D7}, {0x1F6E0, 0x1F6EC},
+    {0x1F6F0, 0x1F6FC}, {0x1F700, 0x1F773}, {0x1F780, 0x1F7D8}, {0x1F7E0, 0x1F7EB},
+    {0x1F800, 0x1F80B}, {0x1F810, 0x1F847}, {0x1F850, 0x1F859}, {0x1F860, 0x1F887},
+    {0x1F890, 0x1F8AD}, {0x1F900, 0x1F978}, {0x1F97A, 0x1F9CB}, {0x1F9CD, 0x1FA53},
+    {0x1FA60, 0x1FA6D}, {0x1FA70, 0x1FA74}, {0x1FA78, 0x1FA7A}, {0x1FA80, 0x1FA86},
+    {0x1FA90, 0x1FAA8}, {0x1FAB0, 0x1FAB6}, {0x1FAC0, 0x1FAC2}, {0x1FAD0, 0x1FAD6},
+    {0x1FB00, 0x1FB92}, {0x1FB94, 0x1FBCA}, {0x1FBF0, 0x1FBF9}, {0x20000, 0x2A6DD},
+    {0x2A700, 0x2B734}, {0x2B740, 0x2B81D}, {0x2B820, 0x2CEA1}, {0x2CEB0, 0x2EBE0},
+    {0x2F800, 0x2FA1D}, {0x30000, 0x3134A}, {0xE0100, 0xE01EF}
 #endif
 };

@@ -795,23 +781,22 @@ static const chr graphCharTable[] = {
    0xA3C, 0xA47, 0xA48, 0xA51, 0xA5E, 0xAB2, 0xAB3, 0xAD0, 0xB0F,
    0xB10, 0xB32, 0xB33, 0xB47, 0xB48, 0xB5C, 0xB5D, 0xB82, 0xB83,
    0xB99, 0xB9A, 0xB9C, 0xB9E, 0xB9F, 0xBA3, 0xBA4, 0xBD0, 0xBD7,
-    0xC55, 0xC56, 0xC5D, 0xCD5, 0xCD6, 0xCDD, 0xCDE, 0xCF1, 0xCF2,
-    0xDBD, 0xDCA, 0xDD6, 0xE81, 0xE82, 0xE84, 0xEA5, 0xEC6, 0x10C7,
-    0x10CD, 0x1258, 0x12C0, 0x1772, 0x1773, 0x1940, 0x1F59, 0x1F5B, 0x1F5D,
-    0x2070, 0x2071, 0x2D27, 0x2D2D, 0x2D6F, 0x2D70, 0xA7D0, 0xA7D1, 0xA7D3,
-    0xFB3E, 0xFB40, 0xFB41, 0xFB43, 0xFB44, 0xFDCF, 0xFFFC, 0xFFFD
+    0xC55, 0xC56, 0xCD5, 0xCD6, 0xCDE, 0xCF1, 0xCF2, 0xDBD, 0xDCA,
+    0xDD6, 0xE81, 0xE82, 0xE84, 0xEA5, 0xEC6, 0x10C7, 0x10CD, 0x1258,
+    0x12C0, 0x1772, 0x1773, 0x1940, 0x1F59, 0x1F5B, 0x1F5D, 0x2070, 0x2071,
+    0x2D27, 0x2D2D, 0x2D6F, 0x2D70, 0xFB3E, 0xFB40, 0xFB41, 0xFB43, 0xFB44,
+    0xFFFC, 0xFFFD
 #if CHRBITS > 16
-    ,0x1003C, 0x1003D, 0x101A0, 0x10594, 0x10595, 0x105BB, 0x105BC, 0x10808, 0x10837,
-    0x10838, 0x1083C, 0x108F4, 0x108F5, 0x1093F, 0x10A05, 0x10A06, 0x10EB0, 0x10EB1,
-    0x11288, 0x1130F, 0x11310, 0x11332, 0x11333, 0x11347, 0x11348, 0x11350, 0x11357,
-    0x11909, 0x11915, 0x11916, 0x11937, 0x11938, 0x11D08, 0x11D09, 0x11D3A, 0x11D3C,
-    0x11D3D, 0x11D67, 0x11D68, 0x11D90, 0x11D91, 0x11FB0, 0x16FF0, 0x16FF1, 0x1AFFD,
-    0x1AFFE, 0x1D49E, 0x1D49F, 0x1D4A2, 0x1D4A5, 0x1D4A6, 0x1D4BB, 0x1D546, 0x1E023,
-    0x1E024, 0x1E14E, 0x1E14F, 0x1E2FF, 0x1E7ED, 0x1E7EE, 0x1E95E, 0x1E95F, 0x1EE21,
-    0x1EE22, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B,
-    0x1EE51, 0x1EE52, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE61,
-    0x1EE62, 0x1EE64, 0x1EE7E, 0x1EEF0, 0x1EEF1, 0x1F250, 0x1F251, 0x1F7F0, 0x1F8B0,
-    0x1F8B1
+    ,0x1003C, 0x1003D, 0x101A0, 0x1056F, 0x10808, 0x10837, 0x10838, 0x1083C, 0x108F4,
+    0x108F5, 0x1093F, 0x10A05, 0x10A06, 0x10EB0, 0x10EB1, 0x11288, 0x1130F, 0x11310,
+    0x11332, 0x11333, 0x11347, 0x11348, 0x11350, 0x11357, 0x11909, 0x11915, 0x11916,
+    0x11937, 0x11938, 0x11D08, 0x11D09, 0x11D3A, 0x11D3C, 0x11D3D, 0x11D67, 0x11D68,
+    0x11D90, 0x11D91, 0x11FB0, 0x16A6E, 0x16A6F, 0x16FF0, 0x16FF1, 0x1D49E, 0x1D49F,
+    0x1D4A2, 0x1D4A5, 0x1D4A6, 0x1D4BB, 0x1D546, 0x1E023, 0x1E024, 0x1E14E, 0x1E14F,
+    0x1E2FF, 0x1E95E, 0x1E95F, 0x1EE21, 0x1EE22, 0x1EE24, 0x1EE27, 0x1EE39, 0x1EE3B,
+    0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE51, 0x1EE52, 0x1EE54, 0x1EE57, 0x1EE59,
+    0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE61, 0x1EE62, 0x1EE64, 0x1EE7E, 0x1EEF0, 0x1EEF1,
+    0x1F250, 0x1F251, 0x1F8B0, 0x1F8B1
 #endif
 };

@@ -108,7 +108,7 @@ declare 22 {deprecated {No longer in use, changed to macro}} {
    Tcl_Obj *Tcl_DbNewBooleanObj(int boolValue, const char *file, int line)
 }
 declare 23 {
-    Tcl_Obj *Tcl_DbNewByteArrayObj(const unsigned char *bytes, int numBytes,
+    Tcl_Obj *Tcl_DbNewByteArrayObj(const unsigned char *bytes, int length,
 	    const char *file, int line)
 }
 declare 24 {
@@ -143,7 +143,7 @@ declare 32 {
 	    int *boolPtr)
 }
 declare 33 {
-    unsigned char *Tcl_GetByteArrayFromObj(Tcl_Obj *objPtr, int *numBytesPtr)
+    unsigned char *Tcl_GetByteArrayFromObj(Tcl_Obj *objPtr, int *lengthPtr)
 }
 declare 34 {
    int Tcl_GetDouble(Tcl_Interp *interp, const char *src, double *doublePtr)
@@ -202,7 +202,7 @@ declare 49 {deprecated {No longer in use, changed to macro}} {
    Tcl_Obj *Tcl_NewBooleanObj(int boolValue)
 }
 declare 50 {
-    Tcl_Obj *Tcl_NewByteArrayObj(const unsigned char *bytes, int numBytes)
+    Tcl_Obj *Tcl_NewByteArrayObj(const unsigned char *bytes, int length)
 }
 declare 51 {
    Tcl_Obj *Tcl_NewDoubleObj(double doubleValue)
@@ -226,11 +226,11 @@ declare 57 {deprecated {No longer in use, changed to macro}} {
    void Tcl_SetBooleanObj(Tcl_Obj *objPtr, int boolValue)
 }
 declare 58 {
-    unsigned char *Tcl_SetByteArrayLength(Tcl_Obj *objPtr, int numBytes)
+    unsigned char *Tcl_SetByteArrayLength(Tcl_Obj *objPtr, int length)
 }
 declare 59 {
    void Tcl_SetByteArrayObj(Tcl_Obj *objPtr, const unsigned char *bytes,
-	    int numBytes)
+	    int length)
 }
 declare 60 {
    void Tcl_SetDoubleObj(Tcl_Obj *objPtr, double doubleValue)
@@ -2348,18 +2348,18 @@ declare 635 {

 # TIP #445
 declare 636 {
-    void Tcl_FreeInternalRep(Tcl_Obj *objPtr)
+    void Tcl_FreeIntRep(Tcl_Obj *objPtr)
 }
 declare 637 {
    char *Tcl_InitStringRep(Tcl_Obj *objPtr, const char *bytes,
 	    unsigned int numBytes)
 }
 declare 638 {
-    Tcl_ObjInternalRep *Tcl_FetchInternalRep(Tcl_Obj *objPtr, const Tcl_ObjType *typePtr)
+    Tcl_ObjIntRep *Tcl_FetchIntRep(Tcl_Obj *objPtr, const Tcl_ObjType *typePtr)
 }
 declare 639 {
-    void Tcl_StoreInternalRep(Tcl_Obj *objPtr, const Tcl_ObjType *typePtr,
-	    const Tcl_ObjInternalRep *irPtr)
+    void Tcl_StoreIntRep(Tcl_Obj *objPtr, const Tcl_ObjType *typePtr,
+	    const Tcl_ObjIntRep *irPtr)
 }
 declare 640 {
    int Tcl_HasStringRep(Tcl_Obj *objPtr)
@@ -2402,16 +2402,6 @@ declare 648 {
 	    int length, Tcl_DString *dsPtr)
 }

-# TIP #568
-declare 649 {
-    unsigned char *TclGetBytesFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
-	    int *numBytesPtr)
-}
-declare 650 {
-    unsigned char *Tcl_GetBytesFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
-	    size_t *numBytesPtr)
-}
-
 # TIP #481
 declare 651 {
    char *TclGetStringFromObj(Tcl_Obj *objPtr, size_t *lengthPtr)
@@ -2420,7 +2410,7 @@ declare 652 {
    Tcl_UniChar *TclGetUnicodeFromObj(Tcl_Obj *objPtr, size_t *lengthPtr)
 }
 declare 653 {
-    unsigned char *TclGetByteArrayFromObj(Tcl_Obj *objPtr, size_t *numBytesPtr)
+    unsigned char *TclGetByteArrayFromObj(Tcl_Obj *objPtr, size_t *lengthPtr)
 }

 # TIP #575
@@ -2433,14 +2423,6 @@ declare 655 {
 declare 656 {
    const char *Tcl_UtfPrev(const char *src, const char *start)
 }
-declare 657 {
-    int Tcl_UniCharIsUnicode(int ch)
-}
-
-# TIP #511
-declare 660 {
-    int Tcl_AsyncMarkFromSignal(Tcl_AsyncHandler async, int sigNumber)
-}

 # ----- BASELINE -- FOR -- 8.7.0 ----- #

@@ -50,10 +50,10 @@ extern "C" {
 #define TCL_MAJOR_VERSION   8
 #define TCL_MINOR_VERSION   7
 #define TCL_RELEASE_LEVEL   TCL_ALPHA_RELEASE
-#define TCL_RELEASE_SERIAL  6
+#define TCL_RELEASE_SERIAL  4

 #define TCL_VERSION	    "8.7"
-#define TCL_PATCH_LEVEL	    "8.7a6"
+#define TCL_PATCH_LEVEL	    "8.7a4"

 #if !defined(TCL_NO_DEPRECATED) || defined(RC_INVOKED)
 /*
@@ -527,33 +527,38 @@ typedef void (Tcl_ThreadCreateProc) (ClientData clientData);
 * Flag values passed to Tcl_StringCaseMatch.
 */

-#define TCL_MATCH_NOCASE	(1<<0)
+enum TclStringCaseMatchFlags {
+    TCL_MATCH_NOCASE = (1<<0)
+};

 /*
 * Flag values passed to Tcl_GetRegExpFromObj.
 */

-#define	TCL_REG_BASIC		000000	/* BREs (convenience). */
-#define	TCL_REG_EXTENDED	000001	/* EREs. */
-#define	TCL_REG_ADVF		000002	/* Advanced features in EREs. */
-#define	TCL_REG_ADVANCED	000003	/* AREs (which are also EREs). */
-#define	TCL_REG_QUOTE		000004	/* No special characters, none. */
-#define	TCL_REG_NOCASE		000010	/* Ignore case. */
-#define	TCL_REG_NOSUB		000020	/* Don't care about subexpressions. */
-#define	TCL_REG_EXPANDED	000040	/* Expanded format, white space &
-					 * comments. */
-#define	TCL_REG_NLSTOP		000100  /* \n doesn't match . or [^ ] */
-#define	TCL_REG_NLANCH		000200  /* ^ matches after \n, $ before. */
-#define	TCL_REG_NEWLINE		000300  /* Newlines are line terminators. */
-#define	TCL_REG_CANMATCH	001000  /* Report details on partial/limited
-					 * matches. */
+enum TclRegExpObjFlags {
+    TCL_REG_BASIC =	00000,	/* BREs (convenience). */
+    TCL_REG_EXTENDED =	00001,	/* EREs. */
+    TCL_REG_ADVF =	00002,	/* Advanced features in EREs. */
+    TCL_REG_ADVANCED =	00003,	/* AREs (which are also EREs). */
+    TCL_REG_QUOTE =	00004,	/* No special characters, none. */
+    TCL_REG_NOCASE =	00010,	/* Ignore case. */
+    TCL_REG_NOSUB =	00020,	/* Don't care about subexpressions. */
+    TCL_REG_EXPANDED =	00040,	/* Expanded format, white space & comments. */
+    TCL_REG_NLSTOP =	00100,	/* \n doesn't match . or [^ ] */
+    TCL_REG_NLANCH =	00200,	/* ^ matches after \n, $ before. */
+    TCL_REG_NEWLINE =	00300,	/* Newlines are line terminators. */
+    TCL_REG_CANMATCH =	01000	/* Report details on partial/limited
+				 * matches. */
+};

 /*
 * Flags values passed to Tcl_RegExpExecObj.
 */

-#define	TCL_REG_NOTBOL	0001	/* Beginning of string does not match ^.  */
-#define	TCL_REG_NOTEOL	0002	/* End of string does not match $. */
+enum TclRegExpExecFlags {
+    TCL_REG_NOTBOL = 0001,	/* Beginning of string does not match ^. */
+    TCL_REG_NOTEOL = 0002	/* End of string does not match $. */
+};

 /*
 * Structures filled in by Tcl_RegExpInfo. Note that all offset values are
@@ -592,25 +597,36 @@ typedef struct stat *Tcl_OldStat_;
 * Tcl_GetObjResult() or Tcl_GetStringResult() to read the interpreter's
 * result. See the SetResult man page for details. Besides this result, the
 * command function returns an integer code, which is one of the following:
- *
- * TCL_OK		Command completed normally; the interpreter's result
- *			contains the command's result.
- * TCL_ERROR		The command couldn't be completed successfully; the
- *			interpreter's result describes what went wrong.
- * TCL_RETURN		The command requests that the current function return;
- *			the interpreter's result contains the function's
- *			return value.
- * TCL_BREAK		The command requests that the innermost loop be
- *			exited; the interpreter's result is meaningless.
- * TCL_CONTINUE		Go on to the next iteration of the current loop; the
- *			interpreter's result is meaningless.
 */

-#define TCL_OK			0
-#define TCL_ERROR		1
-#define TCL_RETURN		2
-#define TCL_BREAK		3
-#define TCL_CONTINUE		4
+enum TclStandardResultCodes {
+    TCL_OK = 0,			/* Command completed normally; the
+				 * interpreter's result contains the command's
+				 * result. */
+    TCL_ERROR = 1,		/* The command couldn't be completed
+				 * successfully; the interpreter's result
+				 * describes what went wrong. */
+    TCL_RETURN = 2,		/* The command requests that the current
+				 * function return; the interpreter's result
+				 * contains the function's return value. */
+    TCL_BREAK = 3,		/* The command requests that the innermost
+				 * loop be exited; the interpreter's result is
+				 * meaningless (conventionally the empty
+				 * string). */
+    TCL_CONTINUE = 4		/* Go on to the next iteration of the current
+				 * loop; the interpreter's result is
+				 * meaningless (conventionally the empty
+				 * string). */
+
+    /*
+     * NOTE: This is NOT a closed set! Application-specific result codes
+     * appear in the wild, usually for doing some sort of "fast exception".
+     * They all behave the same, like an error except that no stack trace is
+     * accumulated in the errorInfo. Because there's no registry of codes
+     * used, they are all reserved to applications; library code cannot safely
+     * use them.
+     */
+};

 #if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
 #define TCL_RESULT_SIZE		200
@@ -621,10 +637,12 @@ typedef struct stat *Tcl_OldStat_;
 * Flags to control what substitutions are performed by Tcl_SubstObj():
 */

-#define TCL_SUBST_COMMANDS	001
-#define TCL_SUBST_VARIABLES	002
-#define TCL_SUBST_BACKSLASHES	004
-#define TCL_SUBST_ALL		007
+enum TclSubstControlFlags {
+    TCL_SUBST_COMMANDS = 001,
+    TCL_SUBST_VARIABLES = 002,
+    TCL_SUBST_BACKSLASHES = 004,
+    TCL_SUBST_ALL = 007
+};

 /*
 * Argument descriptors for math function callbacks in expressions:
@@ -749,13 +767,13 @@ typedef struct Tcl_ObjType {
 } Tcl_ObjType;

 /*
- * The following structure stores an internal representation (internalrep) for
- * a Tcl value. An internalrep is associated with an Tcl_ObjType when both
+ * The following structure stores an internal representation (intrep) for
+ * a Tcl value. An intrep is associated with an Tcl_ObjType when both
 * are stored in the same Tcl_Obj.  The routines of the Tcl_ObjType govern
- * the handling of the internalrep.
+ * the handling of the intrep.
 */

-typedef union Tcl_ObjInternalRep {	/* The internal representation: */
+typedef union Tcl_ObjIntRep {	/* The internal representation: */
    long longValue;		/*   - an long integer value. */
    double doubleValue;		/*   - a double-precision floating value. */
    void *otherValuePtr;	/*   - another, type-specific value, */
@@ -769,7 +787,7 @@ typedef union Tcl_ObjInternalRep {	/* The internal representation: */
 	void *ptr;		/*     not used internally any more. */
 	unsigned long value;
    } ptrAndLongRep;
-} Tcl_ObjInternalRep;
+} Tcl_ObjIntRep;

 /*
 * One of the following structures exists for each object in the Tcl system.
@@ -796,7 +814,7 @@ typedef struct Tcl_Obj {
 				 * corresponds to the type of the object's
 				 * internal rep. NULL indicates the object has
 				 * no internal rep (has no type). */
-    Tcl_ObjInternalRep internalRep;	/* The internal representation: */
+    Tcl_ObjIntRep internalRep;	/* The internal representation: */
 } Tcl_Obj;


@@ -963,55 +981,56 @@ typedef struct Tcl_DString {

 /*
 * Flag values passed to Tcl_ConvertElement.
- * TCL_DONT_USE_BRACES forces it not to enclose the element in braces, but to
- *	use backslash quoting instead.
- * TCL_DONT_QUOTE_HASH disables the default quoting of the '#' character. It
- *	is safe to leave the hash unquoted when the element is not the first
- *	element of a list, and this flag can be used by the caller to indicate
- *	that condition.
 */

-#define TCL_DONT_USE_BRACES	1
-#define TCL_DONT_QUOTE_HASH	8
+enum TclConvertElementFlags {
+    TCL_DONT_USE_BRACES = 1,	/* Force Tcl_ConvertElement not to enclose the
+				 * element in braces, but to use backslash
+				 * quoting instead.*/
+    TCL_DONT_QUOTE_HASH = 8	/* Disable the default quoting of the '#'
+				 * character. It is safe to leave the hash
+				 * unquoted when the element is not the first
+				 * element of a list, and this flag can be
+				 * used by the caller to indicate that
+				 * condition. */
+};

 /*
 * Flags that may be passed to Tcl_GetIndexFromObj.
- * TCL_EXACT disallows abbreviated strings.
- * TCL_INDEX_TEMP_TABLE disallows caching of lookups. A possible use case is
- *      a table that will not live long enough to make it worthwhile.
 */

-#define TCL_EXACT		1
-#define TCL_INDEX_TEMP_TABLE	2
+enum TclGetIndexFromObjFlags {
+    TCL_EXACT = 1,		/* Disallow abbreviated strings. */
+    TCL_INDEX_TEMP_TABLE = 2	/* Disallow caching of lookups. A possible use
+				 * case is a table that will not live long
+				 * enough to make it worthwhile. */
+};

 /*
 *----------------------------------------------------------------------------
 * Flag values passed to Tcl_RecordAndEval, Tcl_EvalObj, Tcl_EvalObjv.
 * WARNING: these bit choices must not conflict with the bit choices for
 * evalFlag bits in tclInt.h!
- *
- * Meanings:
- *	TCL_NO_EVAL:		Just record this command
- *	TCL_EVAL_GLOBAL:	Execute script in global namespace
- *	TCL_EVAL_DIRECT:	Do not compile this script
- *	TCL_EVAL_INVOKE:	Magical Tcl_EvalObjv mode for aliases/ensembles
- *				o Run in iPtr->lookupNsPtr or global namespace
- *				o Cut out of error traces
- *				o Don't reset the flags controlling ensemble
- *				  error message rewriting.
- *	TCL_CANCEL_UNWIND:	Magical Tcl_CancelEval mode that causes the
- *				stack for the script in progress to be
- *				completely unwound.
- *	TCL_EVAL_NOERR:	Do no exception reporting at all, just return
- *				as the caller will report.
 */

-#define TCL_NO_EVAL		0x010000
-#define TCL_EVAL_GLOBAL		0x020000
-#define TCL_EVAL_DIRECT		0x040000
-#define TCL_EVAL_INVOKE		0x080000
-#define TCL_CANCEL_UNWIND	0x100000
-#define TCL_EVAL_NOERR          0x200000
+enum TclEvalFlags {
+    TCL_NO_EVAL =     0x010000,	/* Just record this command */
+    TCL_EVAL_GLOBAL = 0x020000,	/* Execute script in global namespace */
+    TCL_EVAL_DIRECT = 0x040000,	/* Do not compile this script */
+    TCL_EVAL_INVOKE = 0x080000,	/* Magical Tcl_EvalObjv mode for
+				 * aliases/ensembles
+				 * o Run in iPtr->lookupNsPtr or global
+				 *   namespace
+				 * o Cut out of error traces
+				 * o Don't reset the flags controlling
+				 *   ensemble error message rewriting. */
+    TCL_CANCEL_UNWIND = 0x100000,
+				/* Magical Tcl_CancelEval mode that causes the
+				 * stack for the script in progress to be
+				 * completely unwound. */
+    TCL_EVAL_NOERR =  0x200000	/* Do no exception reporting at all, just
+				 * return as the caller will report.  */
+};

 /*
 * Special freeProc values that may be passed to Tcl_SetResult (see the man
@@ -1028,45 +1047,48 @@ typedef struct Tcl_DString {
 * TCL_CANCEL_UNWIND, above.
 */

-#define TCL_GLOBAL_ONLY		 1
-#define TCL_NAMESPACE_ONLY	 2
-#define TCL_APPEND_VALUE	 4
-#define TCL_LIST_ELEMENT	 8
-#define TCL_TRACE_READS		 0x10
-#define TCL_TRACE_WRITES	 0x20
-#define TCL_TRACE_UNSETS	 0x40
-#define TCL_TRACE_DESTROYED	 0x80
-
+enum TclVariableFlags {
+    TCL_GLOBAL_ONLY = 1,
+    TCL_NAMESPACE_ONLY = 2,
+    TCL_APPEND_VALUE = 4,
+    TCL_LIST_ELEMENT = 8,
+    TCL_TRACE_READS = 0x10,
+    TCL_TRACE_WRITES = 0x20,
+    TCL_TRACE_UNSETS = 0x40,
+    TCL_TRACE_DESTROYED = 0x80,
 #if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
-#define TCL_INTERP_DESTROYED	 0x100
+    TCL_INTERP_DESTROYED = 0x100,
 #endif
-
-#define TCL_LEAVE_ERR_MSG	 0x200
-#define TCL_TRACE_ARRAY		 0x800
+    TCL_LEAVE_ERR_MSG = 0x200,
+    TCL_TRACE_ARRAY = 0x800,
 #ifndef TCL_REMOVE_OBSOLETE_TRACES
-/* Required to support old variable/vdelete/vinfo traces. */
-#define TCL_TRACE_OLD_STYLE	 0x1000
+    /* Required to support old variable/vdelete/vinfo traces. */
+    TCL_TRACE_OLD_STYLE = 0x1000,
 #endif
-/* Indicate the semantics of the result of a trace. */
-#define TCL_TRACE_RESULT_DYNAMIC 0x8000
-#define TCL_TRACE_RESULT_OBJECT  0x10000
+    /* Indicate the semantics of the result of a trace. */
+    TCL_TRACE_RESULT_DYNAMIC = 0x8000,
+    TCL_TRACE_RESULT_OBJECT = 0x10000
+};

 /*
 * Flag values for ensemble commands.
 */

-#define TCL_ENSEMBLE_PREFIX 0x02/* Flag value to say whether to allow
+enum TclEnsembleFlags {
+    TCL_ENSEMBLE_PREFIX = 0x02	/* Flag value to say whether to allow
 				 * unambiguous prefixes of commands or to
 				 * require exact matches for command names. */
+};

 /*
 * Flag values passed to command-related functions.
 */

-#define TCL_TRACE_RENAME	0x2000
-#define TCL_TRACE_DELETE	0x4000
-
-#define TCL_ALLOW_INLINE_COMPILATION 0x20000
+enum TclCommandFlags {
+    TCL_TRACE_RENAME = 0x2000,
+    TCL_TRACE_DELETE = 0x4000,
+    TCL_ALLOW_INLINE_COMPILATION = 0x20000
+};

 /*
 * The TCL_PARSE_PART1 flag is deprecated and has no effect. The part1 is now
@@ -1083,28 +1105,30 @@ typedef struct Tcl_DString {
 * Types for linked variables:
 */

-#define TCL_LINK_INT		1
-#define TCL_LINK_DOUBLE		2
-#define TCL_LINK_BOOLEAN	3
-#define TCL_LINK_STRING		4
-#define TCL_LINK_WIDE_INT	5
-#define TCL_LINK_CHAR		6
-#define TCL_LINK_UCHAR		7
-#define TCL_LINK_SHORT		8
-#define TCL_LINK_USHORT		9
-#define TCL_LINK_UINT		10
+enum TclLinkVariableTypes {
+    TCL_LINK_INT = 1,
+    TCL_LINK_DOUBLE = 2,
+    TCL_LINK_BOOLEAN = 3,
+    TCL_LINK_STRING = 4,
+    TCL_LINK_WIDE_INT = 5,
+    TCL_LINK_CHAR = 6,
+    TCL_LINK_UCHAR = 7,
+    TCL_LINK_SHORT = 8,
+    TCL_LINK_USHORT = 9,
+    TCL_LINK_UINT = 10,
+    TCL_LINK_FLOAT = 13,
+    TCL_LINK_WIDE_UINT = 14,
+    TCL_LINK_CHARS = 15,
+    TCL_LINK_BINARY = 16,
 #if defined(TCL_WIDE_INT_IS_LONG) || defined(_WIN32) || defined(__CYGWIN__)
-#define TCL_LINK_LONG		((sizeof(long) != sizeof(int)) ? TCL_LINK_WIDE_INT : TCL_LINK_INT)
-#define TCL_LINK_ULONG		((sizeof(long) != sizeof(int)) ? TCL_LINK_WIDE_UINT : TCL_LINK_UINT)
+    TCL_LINK_LONG = ((sizeof(long) != sizeof(int)) ? TCL_LINK_WIDE_INT : TCL_LINK_INT),
+    TCL_LINK_ULONG = ((sizeof(long) != sizeof(int)) ? TCL_LINK_WIDE_UINT : TCL_LINK_UINT),
 #else
-#define TCL_LINK_LONG		11
-#define TCL_LINK_ULONG		12
+    TCL_LINK_LONG = 11,
+    TCL_LINK_ULONG = 12,
 #endif
-#define TCL_LINK_FLOAT		13
-#define TCL_LINK_WIDE_UINT	14
-#define TCL_LINK_CHARS		15
-#define TCL_LINK_BINARY		16
-#define TCL_LINK_READ_ONLY	0x80
+    TCL_LINK_READ_ONLY = 0x80
+};

 /*
 *----------------------------------------------------------------------------
@@ -1152,21 +1176,23 @@ struct Tcl_HashEntry {

 /*
 * Flags used in Tcl_HashKeyType.
- *
- * TCL_HASH_KEY_RANDOMIZE_HASH -
- *				There are some things, pointers for example
- *				which don't hash well because they do not use
- *				the lower bits. If this flag is set then the
- *				hash table will attempt to rectify this by
- *				randomising the bits and then using the upper
- *				N bits as the index into the table.
- * TCL_HASH_KEY_SYSTEM_HASH -	If this flag is set then all memory internally
- *                              allocated for the hash table that is not for an
- *                              entry will use the system heap.
 */

-#define TCL_HASH_KEY_RANDOMIZE_HASH 0x1
-#define TCL_HASH_KEY_SYSTEM_HASH    0x2
+enum TclHashKeyFlags {
+    TCL_HASH_KEY_RANDOMIZE_HASH = 0x1,
+				/* There are some things, pointers for example
+				 * which don't hash well because they do not
+				 * use the lower bits. If this flag is set
+				 * then the hash table will attempt to rectify
+				 * this by randomising the bits and then using
+				 * the upper N bits as the index into the
+				 * table. */
+    TCL_HASH_KEY_SYSTEM_HASH = 0x2
+				/* If this flag is set then all memory
+				 * internally allocated for the hash table
+				 * that is not for an entry will use the
+				 * system heap. */
+};

 /*
 * Structure definition for the methods associated with a hash table key type.
@@ -1307,12 +1333,14 @@ typedef struct {
 * events:
 */

-#define TCL_DONT_WAIT		(1<<1)
-#define TCL_WINDOW_EVENTS	(1<<2)
-#define TCL_FILE_EVENTS		(1<<3)
-#define TCL_TIMER_EVENTS	(1<<4)
-#define TCL_IDLE_EVENTS		(1<<5)	/* WAS 0x10 ???? */
-#define TCL_ALL_EVENTS		(~TCL_DONT_WAIT)
+enum TclDoOneEventFlags {
+    TCL_DONT_WAIT = (1<<1),
+    TCL_WINDOW_EVENTS = (1<<2),
+    TCL_FILE_EVENTS = (1<<3),
+    TCL_TIMER_EVENTS = (1<<4),
+    TCL_IDLE_EVENTS = (1<<5),	/* WAS 0x10 ???? */
+    TCL_ALL_EVENTS = (~TCL_DONT_WAIT)
+};

 /*
 * The following structure defines a generic event for the Tcl event system.
@@ -1341,8 +1369,10 @@ typedef enum {
 * event routines.
 */

-#define TCL_SERVICE_NONE 0
-#define TCL_SERVICE_ALL 1
+enum TclServiceModes {
+    TCL_SERVICE_NONE = 0,
+    TCL_SERVICE_ALL = 1
+};

 /*
 * The following structure keeps is used to hold a time value, either as an
@@ -1371,9 +1401,11 @@ typedef void (Tcl_ScaleTimeProc) (Tcl_Time *timebuf, ClientData clientData);
 * indicate what sorts of events are of interest:
 */

-#define TCL_READABLE		(1<<1)
-#define TCL_WRITABLE		(1<<2)
-#define TCL_EXCEPTION		(1<<3)
+enum TclChannelHandlerFlags {
+    TCL_READABLE = (1<<1),
+    TCL_WRITABLE = (1<<2),
+    TCL_EXCEPTION = (1<<3)
+};

 /*
 * Flag values to pass to Tcl_OpenCommandChannel to indicate the disposition
@@ -1381,18 +1413,22 @@ typedef void (Tcl_ScaleTimeProc) (Tcl_Time *timebuf, ClientData clientData);
 * Tcl_GetStdChannel.
 */

-#define TCL_STDIN		(1<<1)
-#define TCL_STDOUT		(1<<2)
-#define TCL_STDERR		(1<<3)
-#define TCL_ENFORCE_MODE	(1<<4)
+enum TclOpenCommandChannelFlags {
+    TCL_STDIN = (1<<1),
+    TCL_STDOUT = (1<<2),
+    TCL_STDERR = (1<<3),
+    TCL_ENFORCE_MODE = (1<<4)
+};

 /*
 * Bits passed to Tcl_DriverClose2Proc to indicate which side of a channel
 * should be closed.
 */

-#define TCL_CLOSE_READ		(1<<1)
-#define TCL_CLOSE_WRITE		(1<<2)
+enum TclChannelCloseFlags {
+    TCL_CLOSE_READ = (1<<1),
+    TCL_CLOSE_WRITE = (1<<2)
+};

 /*
 * Value to use as the closeProc for a channel that supports the close2Proc
@@ -1417,8 +1453,10 @@ typedef void (Tcl_ScaleTimeProc) (Tcl_Time *timebuf, ClientData clientData);
 * TIP #218: Channel Actions, Ids for Tcl_DriverThreadActionProc.
 */

-#define TCL_CHANNEL_THREAD_INSERT (0)
-#define TCL_CHANNEL_THREAD_REMOVE (1)
+enum TclChannelThreadActionOperations {
+    TCL_CHANNEL_THREAD_INSERT = 0,
+    TCL_CHANNEL_THREAD_REMOVE = 1
+};

 /*
 * Typedefs for the various operations in a channel type:
@@ -1479,8 +1517,8 @@ typedef struct Tcl_ChannelType {
 				/* Version of the channel type. */
    Tcl_DriverCloseProc *closeProc;
 				/* Function to call to close the channel, or
-				 * NULL or TCL_CLOSE2PROC if the close2Proc should be
-				 * used instead. */
+				 * NULL or TCL_CLOSE2PROC if the close2Proc
+				 * should be used instead. */
    Tcl_DriverInputProc *inputProc;
 				/* Function to call for input on channel. */
    Tcl_DriverOutputProc *outputProc;
@@ -1547,9 +1585,10 @@ typedef struct Tcl_ChannelType {
 * to the blockModeProc function in the above structure.
 */

-#define TCL_MODE_BLOCKING	0	/* Put channel into blocking mode. */
-#define TCL_MODE_NONBLOCKING	1	/* Put channel into nonblocking
-					 * mode. */
+enum TclChannelBlockModeFlags {
+    TCL_MODE_BLOCKING = 0,	/* Put channel into blocking mode. */
+    TCL_MODE_NONBLOCKING = 1	/* Put channel into nonblocking mode. */
+};

 /*
 *----------------------------------------------------------------------------
@@ -1578,27 +1617,33 @@ typedef struct Tcl_GlobTypeData {
 * Type and permission definitions for glob command.
 */

-#define TCL_GLOB_TYPE_BLOCK		(1<<0)
-#define TCL_GLOB_TYPE_CHAR		(1<<1)
-#define TCL_GLOB_TYPE_DIR		(1<<2)
-#define TCL_GLOB_TYPE_PIPE		(1<<3)
-#define TCL_GLOB_TYPE_FILE		(1<<4)
-#define TCL_GLOB_TYPE_LINK		(1<<5)
-#define TCL_GLOB_TYPE_SOCK		(1<<6)
-#define TCL_GLOB_TYPE_MOUNT		(1<<7)
+enum TclGlobTypes {
+    TCL_GLOB_TYPE_BLOCK = (1<<0),
+    TCL_GLOB_TYPE_CHAR = (1<<1),
+    TCL_GLOB_TYPE_DIR = (1<<2),
+    TCL_GLOB_TYPE_PIPE = (1<<3),
+    TCL_GLOB_TYPE_FILE = (1<<4),
+    TCL_GLOB_TYPE_LINK = (1<<5),
+    TCL_GLOB_TYPE_SOCK = (1<<6),
+    TCL_GLOB_TYPE_MOUNT = (1<<7)
+};

-#define TCL_GLOB_PERM_RONLY		(1<<0)
-#define TCL_GLOB_PERM_HIDDEN		(1<<1)
-#define TCL_GLOB_PERM_R			(1<<2)
-#define TCL_GLOB_PERM_W			(1<<3)
-#define TCL_GLOB_PERM_X			(1<<4)
+enum TclGlobPermissions {
+    TCL_GLOB_PERM_RONLY = (1<<0),
+    TCL_GLOB_PERM_HIDDEN = (1<<1),
+    TCL_GLOB_PERM_R = (1<<2),
+    TCL_GLOB_PERM_W = (1<<3),
+    TCL_GLOB_PERM_X = (1<<4)
+};

 /*
 * Flags for the unload callback function.
 */

-#define TCL_UNLOAD_DETACH_FROM_INTERPRETER	(1<<0)
-#define TCL_UNLOAD_DETACH_FROM_PROCESS		(1<<1)
+enum TclUnloadFlags {
+    TCL_UNLOAD_DETACH_FROM_INTERPRETER = (1<<0),
+    TCL_UNLOAD_DETACH_FROM_PROCESS = (1<<1)
+};

 /*
 * Typedefs for the various filesystem operations:
@@ -1804,8 +1849,10 @@ typedef struct Tcl_Filesystem {
 * TCL_CREATE_HARD_LINK -	Create a hard link.
 */

-#define TCL_CREATE_SYMBOLIC_LINK	0x01
-#define TCL_CREATE_HARD_LINK		0x02
+enum TclFileLinkActions {
+    TCL_CREATE_SYMBOLIC_LINK = 0x01,
+    TCL_CREATE_HARD_LINK = 0x02
+};

 /*
 *----------------------------------------------------------------------------
@@ -1848,99 +1895,101 @@ typedef struct Tcl_Token {
 /*
 * Type values defined for Tcl_Token structures. These values are defined as
 * mask bits so that it's easy to check for collections of types.
- *
- * TCL_TOKEN_WORD -		The token describes one word of a command,
- *				from the first non-blank character of the word
- *				(which may be " or {) up to but not including
- *				the space, semicolon, or bracket that
- *				terminates the word. NumComponents counts the
- *				total number of sub-tokens that make up the
- *				word. This includes, for example, sub-tokens
- *				of TCL_TOKEN_VARIABLE tokens.
- * TCL_TOKEN_SIMPLE_WORD -	This token is just like TCL_TOKEN_WORD except
- *				that the word is guaranteed to consist of a
- *				single TCL_TOKEN_TEXT sub-token.
- * TCL_TOKEN_TEXT -		The token describes a range of literal text
- *				that is part of a word. NumComponents is
- *				always 0.
- * TCL_TOKEN_BS -		The token describes a backslash sequence that
- *				must be collapsed. NumComponents is always 0.
- * TCL_TOKEN_COMMAND -		The token describes a command whose result
- *				must be substituted into the word. The token
- *				includes the enclosing brackets. NumComponents
- *				is always 0.
- * TCL_TOKEN_VARIABLE -		The token describes a variable substitution,
- *				including the dollar sign, variable name, and
- *				array index (if there is one) up through the
- *				right parentheses. NumComponents tells how
- *				many additional tokens follow to represent the
- *				variable name. The first token will be a
- *				TCL_TOKEN_TEXT token that describes the
- *				variable name. If the variable is an array
- *				reference then there will be one or more
- *				additional tokens, of type TCL_TOKEN_TEXT,
- *				TCL_TOKEN_BS, TCL_TOKEN_COMMAND, and
- *				TCL_TOKEN_VARIABLE, that describe the array
- *				index; numComponents counts the total number
- *				of nested tokens that make up the variable
- *				reference, including sub-tokens of
- *				TCL_TOKEN_VARIABLE tokens.
- * TCL_TOKEN_SUB_EXPR -		The token describes one subexpression of an
- *				expression, from the first non-blank character
- *				of the subexpression up to but not including
- *				the space, brace, or bracket that terminates
- *				the subexpression. NumComponents counts the
- *				total number of following subtokens that make
- *				up the subexpression; this includes all
- *				subtokens for any nested TCL_TOKEN_SUB_EXPR
- *				tokens. For example, a numeric value used as a
- *				primitive operand is described by a
- *				TCL_TOKEN_SUB_EXPR token followed by a
- *				TCL_TOKEN_TEXT token. A binary subexpression
- *				is described by a TCL_TOKEN_SUB_EXPR token
- *				followed by the TCL_TOKEN_OPERATOR token for
- *				the operator, then TCL_TOKEN_SUB_EXPR tokens
- *				for the left then the right operands.
- * TCL_TOKEN_OPERATOR -		The token describes one expression operator.
- *				An operator might be the name of a math
- *				function such as "abs". A TCL_TOKEN_OPERATOR
- *				token is always preceded by one
- *				TCL_TOKEN_SUB_EXPR token for the operator's
- *				subexpression, and is followed by zero or more
- *				TCL_TOKEN_SUB_EXPR tokens for the operator's
- *				operands. NumComponents is always 0.
- * TCL_TOKEN_EXPAND_WORD -	This token is just like TCL_TOKEN_WORD except
- *				that it marks a word that began with the
- *				literal character prefix "{*}". This word is
- *				marked to be expanded - that is, broken into
- *				words after substitution is complete.
 */

-#define TCL_TOKEN_WORD		1
-#define TCL_TOKEN_SIMPLE_WORD	2
-#define TCL_TOKEN_TEXT		4
-#define TCL_TOKEN_BS		8
-#define TCL_TOKEN_COMMAND	16
-#define TCL_TOKEN_VARIABLE	32
-#define TCL_TOKEN_SUB_EXPR	64
-#define TCL_TOKEN_OPERATOR	128
-#define TCL_TOKEN_EXPAND_WORD	256
+enum TclTokenTypes {
+    TCL_TOKEN_WORD = 1,		/* The token describes one word of a command,
+				 * from the first non-blank character of the
+				 * word (which may be " or {) up to but not
+				 * including the space, semicolon, or bracket
+				 * that terminates the word. NumComponents
+				 * counts the total number of sub-tokens that
+				 * make up the word. This includes, for
+				 * example, sub-tokens of TCL_TOKEN_VARIABLE
+				 * tokens. */
+    TCL_TOKEN_SIMPLE_WORD = 2,	/* This token is just like TCL_TOKEN_WORD
+				 * except that the word is guaranteed to
+				 * consist of a single TCL_TOKEN_TEXT
+				 * sub-token. */
+    TCL_TOKEN_TEXT = 4,		/* The token describes a range of literal text
+				 * that is part of a word. NumComponents is
+				 * always 0. */
+    TCL_TOKEN_BS = 8,		/* The token describes a backslash sequence
+				 * that must be collapsed. NumComponents is
+				 * always 0. */
+    TCL_TOKEN_COMMAND = 16,	/* The token describes a command whose result
+				 * must be substituted into the word. The
+				 * token includes the enclosing brackets.
+				 * NumComponents is always 0. */
+    TCL_TOKEN_VARIABLE = 32,	/* The token describes a variable
+				 * substitution, including the dollar sign,
+				 * variable name, and array index (if there is
+				 * one) up through the right parentheses.
+				 * NumComponents tells how many additional
+				 * tokens follow to represent the variable
+				 * name. The first token will be a
+				 * TCL_TOKEN_TEXT token that describes the
+				 * variable name. If the variable is an array
+				 * reference then there will be one or more
+				 * additional tokens, of type TCL_TOKEN_TEXT,
+				 * TCL_TOKEN_BS, TCL_TOKEN_COMMAND, and
+				 * TCL_TOKEN_VARIABLE, that describe the array
+				 * index; numComponents counts the total
+				 * number of nested tokens that make up the
+				 * variable reference, including sub-tokens of
+				 * TCL_TOKEN_VARIABLE tokens. */
+    TCL_TOKEN_SUB_EXPR = 64,	/* The token describes one subexpression of an
+				 * expression, from the first non-blank
+				 * character of the subexpression up to but
+				 * not including the space, brace, or bracket
+				 * that terminates the subexpression.
+				 * NumComponents counts the total number of
+				 * following subtokens that make up the
+				 * subexpression; this includes all subtokens
+				 * for any nested TCL_TOKEN_SUB_EXPR tokens.
+				 * For example, a numeric value used as a
+				 * primitive operand is described by a
+				 * TCL_TOKEN_SUB_EXPR token followed by a
+				 * TCL_TOKEN_TEXT token. A binary
+				 * subexpression is described by a
+				 * TCL_TOKEN_SUB_EXPR token followed by the
+				 * TCL_TOKEN_OPERATOR token for the operator,
+				 * then TCL_TOKEN_SUB_EXPR tokens for the left
+				 * then the right operands. */
+    TCL_TOKEN_OPERATOR = 128,	/* The token describes one expression
+				 * operator.  An operator might be the name of
+				 * a math function such as "abs". A
+				 * TCL_TOKEN_OPERATOR token is always preceded
+				 * by one TCL_TOKEN_SUB_EXPR token for the
+				 * operator's subexpression, and is followed
+				 * by zero or more TCL_TOKEN_SUB_EXPR tokens
+				 * for the operator's operands. NumComponents
+				 * is always 0. */
+    TCL_TOKEN_EXPAND_WORD = 256	/* This token is just like TCL_TOKEN_WORD
+				 * except that it marks a word that began with
+				 * the literal character prefix "{*}". This
+				 * word is marked to be expanded - that is,
+				 * broken into words after substitution is
+				 * complete. */
+};

 /*
 * Parsing error types. On any parsing error, one of these values will be
 * stored in the error field of the Tcl_Parse structure defined below.
 */

-#define TCL_PARSE_SUCCESS		0
-#define TCL_PARSE_QUOTE_EXTRA		1
-#define TCL_PARSE_BRACE_EXTRA		2
-#define TCL_PARSE_MISSING_BRACE		3
-#define TCL_PARSE_MISSING_BRACKET	4
-#define TCL_PARSE_MISSING_PAREN		5
-#define TCL_PARSE_MISSING_QUOTE		6
-#define TCL_PARSE_MISSING_VAR_BRACE	7
-#define TCL_PARSE_SYNTAX		8
-#define TCL_PARSE_BAD_NUMBER		9
+enum TclParsingErrors {
+    TCL_PARSE_SUCCESS = 0,
+    TCL_PARSE_QUOTE_EXTRA = 1,
+    TCL_PARSE_BRACE_EXTRA = 2,
+    TCL_PARSE_MISSING_BRACE = 3,
+    TCL_PARSE_MISSING_BRACKET = 4,
+    TCL_PARSE_MISSING_PAREN = 5,
+    TCL_PARSE_MISSING_QUOTE = 6,
+    TCL_PARSE_MISSING_VAR_BRACE = 7,
+    TCL_PARSE_SYNTAX = 8,
+    TCL_PARSE_BAD_NUMBER = 9
+};

 /*
 * A structure of the following type is filled in by Tcl_ParseCommand. It
@@ -2035,52 +2084,53 @@ typedef struct Tcl_EncodingType {
 /*
 * The following definitions are used as values for the conversion control
 * flags argument when converting text from one character set to another:
- *
- * TCL_ENCODING_START -		Signifies that the source buffer is the first
- *				block in a (potentially multi-block) input
- *				stream. Tells the conversion function to reset
- *				to an initial state and perform any
- *				initialization that needs to occur before the
- *				first byte is converted. If the source buffer
- *				contains the entire input stream to be
- *				converted, this flag should be set.
- * TCL_ENCODING_END -		Signifies that the source buffer is the last
- *				block in a (potentially multi-block) input
- *				stream. Tells the conversion routine to
- *				perform any finalization that needs to occur
- *				after the last byte is converted and then to
- *				reset to an initial state. If the source
- *				buffer contains the entire input stream to be
- *				converted, this flag should be set.
- * TCL_ENCODING_STOPONERROR -	If set, the converter returns immediately upon
- *				encountering an invalid byte sequence or a
- *				source character that has no mapping in the
- *				target encoding. If clear, the converter
- *				substitues the problematic character(s) with
- *				one or more "close" characters in the
- *				destination buffer and then continues to
- *				convert the source.
- * TCL_ENCODING_NO_TERMINATE - 	If set, Tcl_ExternalToUtf does not append a
- *				terminating NUL byte.  Since it does not need
- *				an extra byte for a terminating NUL, it fills
- *				all dstLen bytes with encoded UTF-8 content if
- *				needed.  If clear, a byte is reserved in the
- *				dst space for NUL termination, and a
- *				terminating NUL is appended.
- * TCL_ENCODING_CHAR_LIMIT -	If set and dstCharsPtr is not NULL, then
- *				Tcl_ExternalToUtf takes the initial value of
- *				*dstCharsPtr as a limit of the maximum number
- *				of chars to produce in the encoded UTF-8
- *				content.  Otherwise, the number of chars
- *				produced is controlled only by other limiting
- *				factors.
 */

-#define TCL_ENCODING_START		0x01
-#define TCL_ENCODING_END		0x02
-#define TCL_ENCODING_STOPONERROR	0x04
-#define TCL_ENCODING_NO_TERMINATE	0x08
-#define TCL_ENCODING_CHAR_LIMIT		0x10
+enum TclEncodingFlags {
+    TCL_ENCODING_START = 1,	/* Signifies that the source buffer is the
+				 * first block in a (potentially multi-block)
+				 * input stream. Tells the conversion function
+				 * to reset to an initial state and perform
+				 * any initialization that needs to occur
+				 * before the first byte is converted. If the
+				 * source buffer contains the entire input
+				 * stream to be converted, this flag should be
+				 * set. */
+    TCL_ENCODING_END = 2,	/* Signifies that the source buffer is the
+				 * last block in a (potentially multi-block)
+				 * input stream. Tells the conversion routine
+				 * to perform any finalization that needs to
+				 * occur after the last byte is converted and
+				 * then to reset to an initial state. If the
+				 * source buffer contains the entire input
+				 * stream to be converted, this flag should be
+				 * set. */
+    TCL_ENCODING_STOPONERROR = 4,
+				/* If set, the converter returns immediately
+				 * upon encountering an invalid byte sequence
+				 * or a source character that has no mapping
+				 * in the target encoding. If clear, the
+				 * converter substitues the problematic
+				 * character(s) with one or more "close"
+				 * characters in the destination buffer and
+				 * then continues to convert the source.*/
+    TCL_ENCODING_NO_TERMINATE = 8,
+				/* If set, Tcl_ExternalToUtf does not append a
+				 * terminating NUL byte. Since it does not
+				 * need an extra byte for a terminating NUL,
+				 * it fills all dstLen bytes with encoded
+				 * UTF-8 content if needed. If clear, a byte
+				 * is reserved in the dst space for NUL
+				 * termination, and a terminating NUL is
+				 * appended. */
+    TCL_ENCODING_CHAR_LIMIT = 16/* If set and dstCharsPtr is not NULL, then
+				 * Tcl_ExternalToUtf takes the initial value
+				 * of *dstCharsPtr as a limit of the maximum
+				 * number of chars to produce in the encoded
+				 * UTF-8 content.  Otherwise, the number of
+				 * chars produced is controlled only by other
+				 * limiting factors. */
+};

 /*
 * The following definitions are the error codes returned by the conversion
@@ -2136,7 +2186,7 @@ typedef struct Tcl_EncodingType {
 #if TCL_UTF_MAX > 3
    /*
     * int isn't 100% accurate as it should be a strict 4-byte value
-     * (perhaps int32_t). ILP64/SILP64 systems may have troubles. The
+     * (perhaps wchar_t). ILP64/SILP64 systems may have troubles. The
     * size of this value must be reflected correctly in regcustom.h.
     */
 typedef int Tcl_UniChar;
@@ -2163,8 +2213,10 @@ typedef struct Tcl_Config {
 * interpreter. Used for Tcl_{Add,Remove}LimitHandler type argument.
 */

-#define TCL_LIMIT_COMMANDS	0x01
-#define TCL_LIMIT_TIME		0x02
+enum TclLimitHandlerTypes {
+    TCL_LIMIT_COMMANDS = 0x01,
+    TCL_LIMIT_TIME = 0x02
+};

 /*
 * Structure containing information about a limit handler to be called when a
@@ -2218,15 +2270,17 @@ typedef struct {
 * documentation for details.
 */

-#define TCL_ARGV_CONSTANT	15
-#define TCL_ARGV_INT		16
-#define TCL_ARGV_STRING		17
-#define TCL_ARGV_REST		18
-#define TCL_ARGV_FLOAT		19
-#define TCL_ARGV_FUNC		20
-#define TCL_ARGV_GENFUNC	21
-#define TCL_ARGV_HELP		22
-#define TCL_ARGV_END		23
+enum TclArgvInfoTypes {
+    TCL_ARGV_CONSTANT = 15,
+    TCL_ARGV_INT = 16,
+    TCL_ARGV_STRING = 17,
+    TCL_ARGV_REST = 18,
+    TCL_ARGV_FLOAT = 19,
+    TCL_ARGV_FUNC = 20,
+    TCL_ARGV_GENFUNC = 21,
+    TCL_ARGV_HELP = 22,
+    TCL_ARGV_END = 23
+};

 /*
 * Types of callback functions for the TCL_ARGV_FUNC and TCL_ARGV_GENFUNC
@@ -2260,18 +2314,20 @@ typedef int (Tcl_ArgvGenFuncProc)(ClientData clientData, Tcl_Interp *interp,
 * Tcl_ZlibStreamInit functions.
 */

-#define TCL_ZLIB_FORMAT_RAW	1
-#define TCL_ZLIB_FORMAT_ZLIB	2
-#define TCL_ZLIB_FORMAT_GZIP	4
-#define TCL_ZLIB_FORMAT_AUTO	8
+enum TclZlibFlags {
+    TCL_ZLIB_FORMAT_RAW = 1,
+    TCL_ZLIB_FORMAT_ZLIB = 2,
+    TCL_ZLIB_FORMAT_GZIP = 4,
+    TCL_ZLIB_FORMAT_AUTO = 8,

-/*
- * Constants that describe whether the stream is to operate in compressing or
- * decompressing mode.
- */
+    /*
+     * Constants that describe whether the stream is to operate in compressing
+     * or decompressing mode.
+     */

-#define TCL_ZLIB_STREAM_DEFLATE	16
-#define TCL_ZLIB_STREAM_INFLATE	32
+    TCL_ZLIB_STREAM_DEFLATE = 16,
+    TCL_ZLIB_STREAM_INFLATE = 32
+};

 /*
 * Constants giving compression levels. Use of TCL_ZLIB_COMPRESS_DEFAULT is
@@ -2287,25 +2343,32 @@ typedef int (Tcl_ArgvGenFuncProc)(ClientData clientData, Tcl_Interp *interp,
 * Constants for types of flushing, used with Tcl_ZlibFlush.
 */

-#define TCL_ZLIB_NO_FLUSH	0
-#define TCL_ZLIB_FLUSH		2
-#define TCL_ZLIB_FULLFLUSH	3
-#define TCL_ZLIB_FINALIZE	4
+enum TclZlibFlushModes {
+    TCL_ZLIB_NO_FLUSH = 0,
+    TCL_ZLIB_FLUSH = 2,
+    TCL_ZLIB_FULLFLUSH = 3,
+    TCL_ZLIB_FINALIZE = 4
+};

 /*
 *----------------------------------------------------------------------------
 * Definitions needed for the Tcl_LoadFile function. [TIP #416]
 */

-#define TCL_LOAD_GLOBAL 1
-#define TCL_LOAD_LAZY 2
+enum TclLoadFileFlags {
+    TCL_LOAD_GLOBAL = 1,
+    TCL_LOAD_LAZY = 2
+};

 /*
 *----------------------------------------------------------------------------
 * Definitions needed for the Tcl_OpenTcpServerEx function. [TIP #456]
 */
-#define TCL_TCPSERVER_REUSEADDR (1<<0)
-#define TCL_TCPSERVER_REUSEPORT (1<<1)
+
+enum TclOpenTcpServerFlags {
+    TCL_TCPSERVER_REUSEADDR = (1<<0),
+    TCL_TCPSERVER_REUSEPORT = (1<<1)
+};

 /*
 * Constants for special int-typed values, see TIP #494
@@ -2385,7 +2448,6 @@ EXTERN const char *	Tcl_PkgInitStubsCheck(Tcl_Interp *interp,
 			    const char *version, int exact);
 EXTERN void		Tcl_InitSubsystems(void);
 EXTERN void		Tcl_GetMemoryInfo(Tcl_DString *dsPtr);
-EXTERN const char *	Tcl_SetPreInitScript(const char *string);
 #ifndef TCL_NO_DEPRECATED
 #   define Tcl_StaticPackage Tcl_StaticLibrary
 #endif
@@ -2479,7 +2541,7 @@ EXTERN int		TclZipfs_AppHook(int *argc, char ***argv);
 	++(objPtr)->refCount
    /*
     * Use do/while0 idiom for optimum correctness without compiler warnings.
-     * https://wiki.c2.com/?TrivialDoWhileLoop
+     * http://c2.com/cgi/wiki?TrivialDoWhileLoop
     */
 #   undef Tcl_DecrRefCount
 #   define Tcl_DecrRefCount(objPtr) \
@@ -865,7 +865,7 @@ CompileAssembleObj(
     * is valid in the current context.
     */

-    ByteCodeGetInternalRep(objPtr, &assembleCodeType, codePtr);
+    ByteCodeGetIntRep(objPtr, &assembleCodeType, codePtr);

    if (codePtr) {
 	namespacePtr = iPtr->varFramePtr->nsPtr;
@@ -882,7 +882,7 @@ CompileAssembleObj(
 	 * Not valid, so free it and regenerate.
 	 */

-	Tcl_StoreInternalRep(objPtr, &assembleCodeType, NULL);
+	Tcl_StoreIntRep(objPtr, &assembleCodeType, NULL);
    }

    /*
@@ -4289,7 +4289,7 @@ AddBasicBlockRangeToErrorInfo(
 * DupAssembleCodeInternalRep --
 *
 *	Part of the Tcl object type implementation for Tcl assembly language
- *	bytecode. We do not copy the bytecode internalrep. Instead, we return
+ *	bytecode. We do not copy the bytecode intrep. Instead, we return
 *	without setting copyPtr->typePtr, so the copy is a plain string copy
 *	of the assembly source, and if it is to be used as a compiled
 *	expression, it will need to be reprocessed.
@@ -4298,7 +4298,7 @@ AddBasicBlockRangeToErrorInfo(
 *	usual (only?) time Tcl_DuplicateObj() will be called is when the copy
 *	is about to be modified, which would invalidate any copied bytecode
 *	anyway. The only reason it might make sense to copy the bytecode is if
- *	we had some modifying routines that operated directly on the internalrep,
+ *	we had some modifying routines that operated directly on the intrep,
 *	as we do for lists and dicts.
 *
 * Results:
@@ -4342,7 +4342,7 @@ FreeAssembleCodeInternalRep(
 {
    ByteCode *codePtr;

-    ByteCodeGetInternalRep(objPtr, &assembleCodeType, codePtr);
+    ByteCodeGetIntRep(objPtr, &assembleCodeType, codePtr);
    assert(codePtr != NULL);

    TclReleaseByteCode(codePtr);
@@ -25,9 +25,9 @@ typedef struct AsyncHandler {
    int ready;			/* Non-zero means this handler should be
 				 * invoked in the next call to
 				 * Tcl_AsyncInvoke. */
-    struct AsyncHandler *nextPtr, *prevPtr;
-				/* Next, previous in list of all handlers
-				 * for the process. */
+    struct AsyncHandler *nextPtr;
+				/* Next in list of all handlers for the
+				 * process. */
    Tcl_AsyncProc *proc;	/* Procedure to call when handler is
 				 * invoked. */
    ClientData clientData;	/* Value to pass to handler when it is
@@ -38,10 +38,16 @@ typedef struct AsyncHandler {
 				 * associated to. */
    Tcl_ThreadId originThrdId;	/* Origin thread where this token was created
 				 * and where it will be yielded. */
-    ClientData notifierData;	/* Platform notifier data or NULL. */
 } AsyncHandler;

 typedef struct ThreadSpecificData {
+    /*
+     * The variables below maintain a list of all existing handlers specific
+     * to the calling thread.
+     */
+    AsyncHandler *firstHandler;	/* First handler defined for process, or NULL
+				 * if none. */
+    AsyncHandler *lastHandler;	/* Last handler or NULL. */
    int asyncReady;		/* This is set to 1 whenever a handler becomes
 				 * ready and it is cleared to zero whenever
 				 * Tcl_AsyncInvoke is called. It can be
@@ -52,29 +58,24 @@ typedef struct ThreadSpecificData {
 				 * currently working. If so then we won't set
 				 * asyncReady again until Tcl_AsyncInvoke
 				 * returns. */
+    Tcl_Mutex asyncMutex;	/* Thread-specific AsyncHandler linked-list
+				 * lock */
 } ThreadSpecificData;
 static Tcl_ThreadDataKey dataKey;
-
-/* Mutex to protect linked-list of AsyncHandlers in the process. */
-TCL_DECLARE_MUTEX(asyncMutex)
-
-/* List of all existing handlers of the process. */
-static AsyncHandler *firstHandler = NULL;
-static AsyncHandler *lastHandler = NULL;

 /*
 *----------------------------------------------------------------------
 *
 * TclFinalizeAsync --
 *
- *	Finalizes the thread local data structure for the async
+ *	Finalizes the mutex in the thread local data structure for the async
 *	subsystem.
 *
 * Results:
 *	None.
 *
 * Side effects:
- *	Cleans up left-over async handlers for the calling thread.
+ *	Forgets knowledge of the mutex should it have been created.
 *
 *----------------------------------------------------------------------
 */
@@ -82,40 +83,10 @@ static AsyncHandler *lastHandler = NULL;
 void
 TclFinalizeAsync(void)
 {
-    AsyncHandler *token, *toDelete = NULL;
-    Tcl_ThreadId self = Tcl_GetCurrentThread();
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

-    Tcl_MutexLock(&asyncMutex);
-    for (token = firstHandler; token != NULL;) {
-	AsyncHandler *nextToken = token->nextPtr;
-
-	if (token->originThrdId == self) {
-	    if (token->prevPtr == NULL) {
-		firstHandler = token->nextPtr;
-		if (firstHandler == NULL) {
-		    lastHandler = NULL;
-		    break;
-		}
-	    } else {
-		token->prevPtr->nextPtr = token->nextPtr;
-		if (token == lastHandler) {
-		    lastHandler = token->prevPtr;
-		}
-	    }
-	    if (token->nextPtr != NULL) {
-		token->nextPtr->prevPtr = token->prevPtr;
-	    }
-	    token->nextPtr = toDelete;
-	    token->prevPtr = NULL;
-	    toDelete = token;
-	}
-	token = nextToken;
-    }
-    Tcl_MutexUnlock(&asyncMutex);
-    while (toDelete != NULL) {
-	token = toDelete;
-	toDelete = toDelete->nextPtr;
-	ckfree(token);
+    if (tsdPtr->asyncMutex != NULL) {
+	Tcl_MutexFinalize(&tsdPtr->asyncMutex);
    }
 }

@@ -150,22 +121,19 @@ Tcl_AsyncCreate(
    asyncPtr = (AsyncHandler*)ckalloc(sizeof(AsyncHandler));
    asyncPtr->ready = 0;
    asyncPtr->nextPtr = NULL;
-    asyncPtr->prevPtr = NULL;
    asyncPtr->proc = proc;
    asyncPtr->clientData = clientData;
    asyncPtr->originTsd = tsdPtr;
    asyncPtr->originThrdId = Tcl_GetCurrentThread();
-    asyncPtr->notifierData = TclpNotifierData();

-    Tcl_MutexLock(&asyncMutex);
-    if (firstHandler == NULL) {
-	firstHandler = asyncPtr;
+    Tcl_MutexLock(&tsdPtr->asyncMutex);
+    if (tsdPtr->firstHandler == NULL) {
+	tsdPtr->firstHandler = asyncPtr;
    } else {
-	asyncPtr->prevPtr = lastHandler;
-	lastHandler->nextPtr = asyncPtr;
+	tsdPtr->lastHandler->nextPtr = asyncPtr;
    }
-    lastHandler = asyncPtr;
-    Tcl_MutexUnlock(&asyncMutex);
+    tsdPtr->lastHandler = asyncPtr;
+    Tcl_MutexUnlock(&tsdPtr->asyncMutex);
    return (Tcl_AsyncHandler) asyncPtr;
 }

@@ -194,86 +162,13 @@ Tcl_AsyncMark(
 {
    AsyncHandler *token = (AsyncHandler *) async;

-    Tcl_MutexLock(&asyncMutex);
+    Tcl_MutexLock(&token->originTsd->asyncMutex);
    token->ready = 1;
    if (!token->originTsd->asyncActive) {
 	token->originTsd->asyncReady = 1;
 	Tcl_ThreadAlert(token->originThrdId);
    }
-    Tcl_MutexUnlock(&asyncMutex);
-
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Tcl_AsyncMarkFromSignal --
- *
- *	This procedure is similar to Tcl_AsyncMark but must be used
- *	in POSIX signal contexts. In addition to Tcl_AsyncMark the
- *	signal number is passed.
- *
- * Results:
- *	True, when the handler will be marked, false otherwise.
- *
- * Side effects:
- *	The handler gets marked for invocation later.
- *
- *----------------------------------------------------------------------
- */
-
-int
-Tcl_AsyncMarkFromSignal(
-    Tcl_AsyncHandler async,		/* Token for handler. */
-    int sigNumber)			/* Signal number. */
-{
-#if TCL_THREADS
-    AsyncHandler *token = (AsyncHandler *) async;
-
-    return TclAsyncNotifier(sigNumber, token->originThrdId,
-	    token->notifierData, &token->ready, -1);
-#else
-    (void)sigNumber;
-
-    Tcl_AsyncMark(async);
-    return 1;
-#endif
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TclAsyncMarkFromNotifier --
- *
- *	This procedure is called from the notifier thread and
- *	invokes Tcl_AsyncMark for specifically marked handlers.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	Handlers get marked for invocation later.
- *
- *----------------------------------------------------------------------
- */
-
-void
-TclAsyncMarkFromNotifier(void)
-{
-    AsyncHandler *token;
-
-    Tcl_MutexLock(&asyncMutex);
-    for (token = firstHandler; token != NULL;
-	    token = token->nextPtr) {
-	if (token->ready == -1) {
-	    token->ready = 1;
-	    if (!token->originTsd->asyncActive) {
-		token->originTsd->asyncReady = 1;
-		Tcl_ThreadAlert(token->originThrdId);
-	    }
-	}
-    }
-    Tcl_MutexUnlock(&asyncMutex);
+    Tcl_MutexUnlock(&token->originTsd->asyncMutex);
 }

 /*
@@ -305,12 +200,11 @@ Tcl_AsyncInvoke(
 {
    AsyncHandler *asyncPtr;
    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-    Tcl_ThreadId self = Tcl_GetCurrentThread();

-    Tcl_MutexLock(&asyncMutex);
+    Tcl_MutexLock(&tsdPtr->asyncMutex);

    if (tsdPtr->asyncReady == 0) {
-	Tcl_MutexUnlock(&asyncMutex);
+	Tcl_MutexUnlock(&tsdPtr->asyncMutex);
 	return code;
    }
    tsdPtr->asyncReady = 0;
@@ -330,11 +224,8 @@ Tcl_AsyncInvoke(
     */

    while (1) {
-	for (asyncPtr = firstHandler; asyncPtr != NULL;
+	for (asyncPtr = tsdPtr->firstHandler; asyncPtr != NULL;
 		asyncPtr = asyncPtr->nextPtr) {
-	    if (asyncPtr->originThrdId != self) {
-		continue;
-	    }
 	    if (asyncPtr->ready) {
 		break;
 	    }
@@ -343,12 +234,12 @@ Tcl_AsyncInvoke(
 	    break;
 	}
 	asyncPtr->ready = 0;
-	Tcl_MutexUnlock(&asyncMutex);
+	Tcl_MutexUnlock(&tsdPtr->asyncMutex);
 	code = asyncPtr->proc(asyncPtr->clientData, interp, code);
-	Tcl_MutexLock(&asyncMutex);
+	Tcl_MutexLock(&tsdPtr->asyncMutex);
    }
    tsdPtr->asyncActive = 0;
-    Tcl_MutexUnlock(&asyncMutex);
+    Tcl_MutexUnlock(&tsdPtr->asyncMutex);
    return code;
 }

@@ -380,7 +271,9 @@ void
 Tcl_AsyncDelete(
    Tcl_AsyncHandler async)		/* Token for handler to delete. */
 {
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
    AsyncHandler *asyncPtr = (AsyncHandler *) async;
+    AsyncHandler *prevPtr, *thisPtr;

    /*
     * Assure early handling of the constraint
@@ -390,22 +283,33 @@ Tcl_AsyncDelete(
 	Tcl_Panic("Tcl_AsyncDelete: async handler deleted by the wrong thread");
    }

-    Tcl_MutexLock(&asyncMutex);
-    if (asyncPtr->prevPtr == NULL) {
-	firstHandler = asyncPtr->nextPtr;
-	if (firstHandler == NULL) {
-	    lastHandler = NULL;
+    /*
+     * If we come to this point when TSD's for the current
+     * thread have already been garbage-collected, we are
+     * in the _serious_ trouble. OTOH, we tolerate calling
+     * with already cleaned-up handler list (should we?).
+     */
+
+    Tcl_MutexLock(&tsdPtr->asyncMutex);
+    if (tsdPtr->firstHandler != NULL) {
+	prevPtr = thisPtr = tsdPtr->firstHandler;
+	while (thisPtr != NULL && thisPtr != asyncPtr) {
+	    prevPtr = thisPtr;
+	    thisPtr = thisPtr->nextPtr;
 	}
-    } else {
-	asyncPtr->prevPtr->nextPtr = asyncPtr->nextPtr;
-	if (asyncPtr == lastHandler) {
-	    lastHandler = asyncPtr->prevPtr;
+	if (thisPtr == NULL) {
+	    Tcl_Panic("Tcl_AsyncDelete: cannot find async handler");
+	}
+	if (asyncPtr == tsdPtr->firstHandler) {
+	    tsdPtr->firstHandler = asyncPtr->nextPtr;
+	} else {
+	    prevPtr->nextPtr = asyncPtr->nextPtr;
+	}
+	if (asyncPtr == tsdPtr->lastHandler) {
+	    tsdPtr->lastHandler = prevPtr;
 	}
    }
-    if (asyncPtr->nextPtr != NULL) {
-	asyncPtr->nextPtr->prevPtr = asyncPtr->prevPtr;
-    }
-    Tcl_MutexUnlock(&asyncMutex);
+    Tcl_MutexUnlock(&tsdPtr->asyncMutex);
    ckfree(asyncPtr);
 }

@@ -1826,28 +1826,28 @@ DeleteInterpProc(
 	ckfree(hTablePtr);
    }

+    /*
+     * Invoke deletion callbacks; note that a callback can create new
+     * callbacks, so we iterate.
+     */

-    if (iPtr->assocData != NULL) {
+    while (iPtr->assocData != NULL) {
 	AssocData *dPtr;

 	hTablePtr = iPtr->assocData;
-	/*
-	 * Invoke deletion callbacks; note that a callback can create new
-	 * callbacks, so we iterate.
-	 */
+	iPtr->assocData = NULL;
 	for (hPtr = Tcl_FirstHashEntry(hTablePtr, &search);
 		hPtr != NULL;
 		hPtr = Tcl_FirstHashEntry(hTablePtr, &search)) {
 	    dPtr = (AssocData *)Tcl_GetHashValue(hPtr);
+	    Tcl_DeleteHashEntry(hPtr);
 	    if (dPtr->proc != NULL) {
 		dPtr->proc(dPtr->clientData, interp);
 	    }
-	    Tcl_DeleteHashEntry(hPtr);
 	    ckfree(dPtr);
 	}
 	Tcl_DeleteHashTable(hTablePtr);
 	ckfree(hTablePtr);
-	iPtr->assocData = NULL;
    }

    /*
@@ -3505,14 +3505,15 @@ Tcl_DeleteCommandFromToken(
    cmdPtr->flags |= CMD_DYING;

    /*
-     * Call each functions and then delete the trace.
+     * Call trace functions for the command being deleted. Then delete its
+     * traces.
     */

    cmdPtr->nsPtr->refCount++;

    if (cmdPtr->tracePtr != NULL) {
 	CommandTrace *tracePtr;
-	/* CallCommandTraces() does not cmdPtr, that's
+	/* Note that CallCommandTraces() never frees cmdPtr, that's
 	 * done just before Tcl_DeleteCommandFromToken() returns  */
 	CallCommandTraces(iPtr,cmdPtr,NULL,NULL,TCL_TRACE_DELETE);

@@ -3959,8 +3960,8 @@ OldMathFuncProc(
 	result = Tcl_GetDoubleFromObj(NULL, valuePtr, &d);
 #ifdef ACCEPT_NAN
 	if (result != TCL_OK) {
-	    const Tcl_ObjInternalRep *irPtr
-		    = TclFetchInternalRep(valuePtr, &tclDoubleType);
+	    const Tcl_ObjIntRep *irPtr
+		    = TclFetchIntRep(valuePtr, &tclDoubleType);

 	    if (irPtr) {
 		d = irPtr->doubleValue;
@@ -4866,7 +4867,6 @@ NRCommand(
    int result)
 {
    Interp *iPtr = (Interp *) interp;
-    Tcl_Obj *listPtr;

    iPtr->numLevels--;

@@ -4875,10 +4875,7 @@ NRCommand(
      */

    if (data[1] && (data[1] != INT2PTR(1))) {
-	listPtr = (Tcl_Obj *)data[1];
-	data[1] = NULL;
-
-	TclNRAddCallback(interp, TclNRTailcallEval, listPtr, NULL, NULL, NULL);
+        TclNRAddCallback(interp, TclNRTailcallEval, data[1], NULL, NULL, NULL);
    }

    /* OPT ??
@@ -7537,7 +7534,7 @@ ExprCeilFunc(
    code = Tcl_GetDoubleFromObj(interp, objv[1], &d);
 #ifdef ACCEPT_NAN
    if (code != TCL_OK) {
-	const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objv[1], &tclDoubleType);
+	const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objv[1], &tclDoubleType);

 	if (irPtr) {
 	    Tcl_SetObjResult(interp, objv[1]);
@@ -7577,7 +7574,7 @@ ExprFloorFunc(
    code = Tcl_GetDoubleFromObj(interp, objv[1], &d);
 #ifdef ACCEPT_NAN
    if (code != TCL_OK) {
-	const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objv[1], &tclDoubleType);
+	const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objv[1], &tclDoubleType);

 	if (irPtr) {
 	    Tcl_SetObjResult(interp, objv[1]);
@@ -7723,7 +7720,7 @@ ExprSqrtFunc(
    code = Tcl_GetDoubleFromObj(interp, objv[1], &d);
 #ifdef ACCEPT_NAN
    if (code != TCL_OK) {
-	const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objv[1], &tclDoubleType);
+	const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objv[1], &tclDoubleType);

 	if (irPtr) {
 	    Tcl_SetObjResult(interp, objv[1]);
@@ -7777,7 +7774,7 @@ ExprUnaryFunc(
    code = Tcl_GetDoubleFromObj(interp, objv[1], &d);
 #ifdef ACCEPT_NAN
    if (code != TCL_OK) {
-	const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objv[1], &tclDoubleType);
+	const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objv[1], &tclDoubleType);

 	if (irPtr) {
 	    d = irPtr->doubleValue;
@@ -7841,7 +7838,7 @@ ExprBinaryFunc(
    code = Tcl_GetDoubleFromObj(interp, objv[1], &d1);
 #ifdef ACCEPT_NAN
    if (code != TCL_OK) {
-	const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objv[1], &tclDoubleType);
+	const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objv[1], &tclDoubleType);

 	if (irPtr) {
 	    d1 = irPtr->doubleValue;
@@ -7856,7 +7853,7 @@ ExprBinaryFunc(
    code = Tcl_GetDoubleFromObj(interp, objv[2], &d2);
 #ifdef ACCEPT_NAN
    if (code != TCL_OK) {
-	const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objv[1], &tclDoubleType);
+	const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objv[1], &tclDoubleType);

 	if (irPtr) {
 	    d2 = irPtr->doubleValue;
@@ -8017,7 +8014,7 @@ ExprDoubleFunc(
    }
    if (Tcl_GetDoubleFromObj(interp, objv[1], &dResult) != TCL_OK) {
 #ifdef ACCEPT_NAN
-	if (TclHasInternalRep(objv[1], &tclDoubleType)) {
+	if (TclHasIntRep(objv[1], &tclDoubleType)) {
 	    Tcl_SetObjResult(interp, objv[1]);
 	    return TCL_OK;
 	}
@@ -9453,7 +9450,6 @@ TclNRYieldToObjCmd(

    iPtr->execEnvPtr = corPtr->callerEEPtr;
    TclSetTailcall(interp, listPtr);
-    corPtr->yieldPtr = listPtr;
    iPtr->execEnvPtr = corPtr->eePtr;

    return TclNRYieldObjCmd(INT2PTR(CORO_ACTIVATE_YIELDM), interp, 1, objv);
@@ -9651,22 +9647,6 @@ TclNRCoroutineActivateCallback(
         */

        if (corPtr->stackLevel != stackLevel) {
-	    NRE_callback *runPtr;
-
-	    iPtr->execEnvPtr = corPtr->callerEEPtr;
-	    if (corPtr->yieldPtr) {
-		for (runPtr = TOP_CB(interp); runPtr; runPtr = runPtr->nextPtr) {
-		    if (runPtr->data[1] == corPtr->yieldPtr) {
-			runPtr->data[1] = NULL;
-			Tcl_DecrRefCount(corPtr->yieldPtr);
-			corPtr->yieldPtr = NULL;
-			break;
-		    }
-		}
-	    }
-	    iPtr->execEnvPtr = corPtr->eePtr;
-
-
            Tcl_SetObjResult(interp, Tcl_NewStringObj(
                    "cannot yield: C stack busy", -1));
            Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "CANT_YIELD",
@@ -9682,7 +9662,6 @@ TclNRCoroutineActivateCallback(
            Tcl_Panic("Yield received an option which is not implemented");
        }

-	corPtr->yieldPtr = NULL;
        corPtr->stackLevel = NULL;

        numLevels = iPtr->numLevels;
@@ -2,7 +2,7 @@
 * tclBinary.c --
 *
 *	This file contains the implementation of the "binary" Tcl built-in
- *	command and the Tcl value internal representation for binary data.
+ *	command and the Tcl binary data object.
 *
 * Copyright © 1997 Sun Microsystems, Inc.
 * Copyright © 1998-1999 Scriptics Corporation.
@@ -165,11 +165,12 @@ static const EnsembleImplMap decodeMap[] = {
 * images to name just two.
 *
 * It's strange to have two Tcl_ObjTypes in place for this task when one would
- * do, so a bit of detail and history will aid understanding.
+ * do, so a bit of detail and history how we got to this point and where we
+ * might go from here.
 *
 * A bytearray is an ordered sequence of bytes. Each byte is an integer value
 * in the range [0-255].  To be a Tcl value type, we need a way to encode each
- * value in the value set as a Tcl string.  A simple encoding is to
+ * value in the value set as a Tcl string.  The simplest encoding is to
 * represent each byte value as the same codepoint value.  A bytearray of N
 * bytes is encoded into a Tcl string of N characters where the codepoint of
 * each character is the value of corresponding byte.  This approach creates a
@@ -180,7 +181,9 @@ static const EnsembleImplMap decodeMap[] = {
 * question arises what to do with strings outside that subset?  That is,
 * those Tcl strings containing at least one codepoint greater than 255?  The
 * obviously correct answer is to raise an error!  That string value does not
- * represent any valid bytearray value. 
+ * represent any valid bytearray value. Full Stop.  The setFromAnyProc
+ * signature has a completion code return value for just this reason, to
+ * reject invalid inputs.
 *
 * Unfortunately this was not the path taken by the authors of the original
 * tclByteArrayType.  They chose to accept all Tcl string values as acceptable
@@ -188,10 +191,33 @@ static const EnsembleImplMap decodeMap[] = {
 * high bits of any codepoint value at all. This meant that every bytearray
 * value had multiple accepted string representations.
 *
- * The implications of this choice are truly ugly, and motivated the proposal
- * of TIP 568 to migrate away from it and to the more sensible design where
- * each bytearray value has only one string representation.  Full details are
- * recorded in that TIP for those who seek them.
+ * The implications of this choice are truly ugly.  When a Tcl value has a
+ * string representation, we are required to accept that as the true value.
+ * Bytearray values that possess a string representation cannot be processed
+ * as bytearrays because we cannot know which true value that bytearray
+ * represents.  The consequence is that we drag around an internal rep that we
+ * cannot make any use of.  This painful price is extracted at any point after
+ * a string rep happens to be generated for the value.  This happens even when
+ * the troublesome codepoints outside the byte range never show up.  This
+ * happens rather routinely in normal Tcl operations unless we burden the
+ * script writer with the cognitive burden of avoiding it.  The price is also
+ * paid by callers of the C interface.  The routine
+ *
+ *	unsigned char *Tcl_GetByteArrayFromObj(objPtr, lenPtr)
+ *
+ * has a guarantee to always return a non-NULL value, but that value points to
+ * a byte sequence that cannot be used by the caller to process the Tcl value
+ * absent some sideband testing that objPtr is "pure".  Tcl offers no public
+ * interface to perform this test, so callers either break encapsulation or
+ * are unavoidably buggy.  Tcl has defined a public interface that cannot be
+ * used correctly. The Tcl source code itself suffers the same problem, and
+ * has been buggy, but progressively less so as more and more portions of the
+ * code have been retrofitted with the required "purity testing".  The set of
+ * values able to pass the purity test can be increased via the introduction
+ * of a "canonical" flag marker, but the only way the broken interface itself
+ * can be discarded is to start over and define the Tcl_ObjType properly.
+ * Bytearrays should simply be usable as bytearrays without a kabuki dance of
+ * testing.
 *
 * The Tcl_ObjType "properByteArrayType" is (nearly) a correct implementation
 * of bytearrays.  Any Tcl value with the type properByteArrayType can have
@@ -200,24 +226,21 @@ static const EnsembleImplMap decodeMap[] = {
 * implies a side testing burden -- past mistakes will not let us avoid that
 * immediately, but it is at least a conventional test of type, and can be
 * implemented entirely by examining the objPtr fields, with no need to query
- * the internalrep, as a canonical flag would require.  This benefit is made
- * available to extensions through the public routine Tcl_GetBytesFromObj(),
- * first available in Tcl 8.7.
+ * the intrep, as a canonical flag would require.
 *
- * The public routines Tcl_GetByteArrayFromObj() and Tcl_SetByteArrayLength()
- * must continue to follow their documented behavior through the 8.* series of
- * releases.  To support that legacy operation, we need a mechanism to retain
- * compatibility with the deployed callers of the broken interface.  That's
- * what the retained "tclByteArrayType" provides.  In those unusual
- * circumstances where we convert an invalid bytearray value to a bytearray
- * type, it is to this legacy type.  Essentially any time this legacy type
- * shows up, it's a signal of a bug being ignored.  
- *  
- * In Tcl 9, the incompatibility in the behavior of these public routines
- * has been approved, and the legacy internal rep is no longer retained.
- * The internal changes seen below are the limit of what can be done 
- * in a Tcl 8.* release.  They provide a great expansion of the histories
- * over which bytearray values can be useful.
+ * Until Tcl_GetByteArrayFromObj() and Tcl_SetByteArrayLength() can be revised
+ * to admit the possibility of returning NULL when the true value is not a
+ * valid bytearray, we need a mechanism to retain compatibility with the
+ * deployed callers of the broken interface.  That's what the retained
+ * "tclByteArrayType" provides.  In those unusual circumstances where we
+ * convert an invalid bytearray value to a bytearray type, it is to this
+ * legacy type.  Essentially any time this legacy type gets used, it's a
+ * signal of a bug being ignored.  A TIP should be drafted to remove this
+ * connection to the broken past so that Tcl 9 will no longer have any trace
+ * of it.  Prescribing a migration path will be the key element of that work.
+ * The internal changes now in place are the limit of what can be done short
+ * of interface repair.  They provide a great expansion of the histories over
+ * which bytearray values can be useful in the meanwhile.
 */

 static const Tcl_ObjType properByteArrayType = {
@@ -244,16 +267,15 @@ const Tcl_ObjType tclByteArrayType = {
 */

 typedef struct ByteArray {
-    unsigned int bad;		/* Index of first character that is a nonbyte.
-				 * If all characters are bytes, bad = used. */
+    unsigned int bad;		/* Index of the character that is a nonbyte.
+				 * If all characters are bytes, bad = used,
+				 * though then we should never read it. */
    unsigned int used;		/* The number of bytes used in the byte
-				 * array.  Must be <= allocated. The bytes
-				 * used to store the value are indexed from
-				 * 0 to used-1. */
-    unsigned int allocated;	/* The number of bytes of space allocated. */
-    unsigned char bytes[TCLFLEXARRAY];
-				/* The array of bytes. The actual size of this
-				 * field is stored in the 'allocated' field
+				 * array. */
+    unsigned int allocated;	/* The amount of space actually allocated
+				 * minus 1 byte. */
+    unsigned char bytes[TCLFLEXARRAY];	/* The array of bytes. The actual size of this
+				 * field depends on the 'allocated' field
 				 * above. */
 } ByteArray;

@@ -267,7 +289,7 @@ int
 TclIsPureByteArray(
    Tcl_Obj * objPtr)
 {
-    return TclHasInternalRep(objPtr, &properByteArrayType);
+    return TclHasIntRep(objPtr, &properByteArrayType);
 }

 /*
@@ -279,7 +301,7 @@ TclIsPureByteArray(
 *	from the given array of bytes.
 *
 * Results:
- *	The newly created object is returned. This object has no initial
+ *	The newly create object is returned. This object will have no initial
 *	string representation. The returned object has a ref count of 0.
 *
 * Side effects:
@@ -294,16 +316,16 @@ Tcl_Obj *
 Tcl_NewByteArrayObj(
    const unsigned char *bytes,	/* The array of bytes used to initialize the
 				 * new object. */
-    int numBytes)		/* Number of bytes in the array,
-				 * must be >= 0. */
+    int length)			/* Length of the array of bytes, which must be
+				 * >= 0. */
 {
 #ifdef TCL_MEM_DEBUG
-    return Tcl_DbNewByteArrayObj(bytes, numBytes, "unknown", 0);
+    return Tcl_DbNewByteArrayObj(bytes, length, "unknown", 0);
 #else /* if not TCL_MEM_DEBUG */
    Tcl_Obj *objPtr;

    TclNewObj(objPtr);
-    Tcl_SetByteArrayObj(objPtr, bytes, numBytes);
+    Tcl_SetByteArrayObj(objPtr, bytes, length);
    return objPtr;
 #endif /* TCL_MEM_DEBUG */
 }
@@ -324,7 +346,7 @@ Tcl_NewByteArrayObj(
 *	result of calling Tcl_NewByteArrayObj.
 *
 * Results:
- *	The newly created object is returned. This object has no initial
+ *	The newly create object is returned. This object will have no initial
 *	string representation. The returned object has a ref count of 0.
 *
 * Side effects:
@@ -338,8 +360,8 @@ Tcl_Obj *
 Tcl_DbNewByteArrayObj(
    const unsigned char *bytes,	/* The array of bytes used to initialize the
 				 * new object. */
-    int numBytes,		/* Number of bytes in the array,
-				 * must be >= 0. */
+    int length,			/* Length of the array of bytes, which must be
+				 * >= 0. */
    const char *file,		/* The name of the source file calling this
 				 * procedure; used for debugging. */
    int line)			/* Line number in the source file; used for
@@ -348,7 +370,7 @@ Tcl_DbNewByteArrayObj(
    Tcl_Obj *objPtr;

    TclDbNewObj(objPtr, file, line);
-    Tcl_SetByteArrayObj(objPtr, bytes, numBytes);
+    Tcl_SetByteArrayObj(objPtr, bytes, length);
    return objPtr;
 }
 #else /* if not TCL_MEM_DEBUG */
@@ -356,12 +378,12 @@ Tcl_Obj *
 Tcl_DbNewByteArrayObj(
    const unsigned char *bytes,	/* The array of bytes used to initialize the
 				 * new object. */
-    int numBytes,		/* Number of bytes in the array,
-				 * must be >= 0. */
+    int length,			/* Length of the array of bytes, which must be
+				 * >= 0. */
    TCL_UNUSED(const char *) /*file*/,
    TCL_UNUSED(int) /*line*/)
 {
-    return Tcl_NewByteArrayObj(bytes, numBytes);
+    return Tcl_NewByteArrayObj(bytes, length);
 }
 #endif /* TCL_MEM_DEBUG */

@@ -387,45 +409,47 @@ void
 Tcl_SetByteArrayObj(
    Tcl_Obj *objPtr,		/* Object to initialize as a ByteArray. */
    const unsigned char *bytes,	/* The array of bytes to use as the new value.
-				 * May be NULL even if numBytes > 0. */
-    int numBytes)		/* Number of bytes in the array,
-				 * must be >= 0. */
+				 * May be NULL even if length > 0. */
+    int length)			/* Length of the array of bytes, which must
+				 * be >= 0. */
 {
    ByteArray *byteArrayPtr;
-    Tcl_ObjInternalRep ir;
+    Tcl_ObjIntRep ir;

    if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetByteArrayObj");
    }
    TclInvalidateStringRep(objPtr);

-    assert(numBytes >= 0);
-    byteArrayPtr = (ByteArray *)ckalloc(BYTEARRAY_SIZE(numBytes));
-    byteArrayPtr->bad = numBytes;
-    byteArrayPtr->used = numBytes;
-    byteArrayPtr->allocated = numBytes;
+    if (length < 0) {
+	length = 0;
+    }
+    byteArrayPtr = (ByteArray *)ckalloc(BYTEARRAY_SIZE(length));
+    byteArrayPtr->bad = length;
+    byteArrayPtr->used = length;
+    byteArrayPtr->allocated = length;

-    if ((bytes != NULL) && (numBytes > 0)) {
-	memcpy(byteArrayPtr->bytes, bytes, numBytes);
+    if ((bytes != NULL) && (length > 0)) {
+	memcpy(byteArrayPtr->bytes, bytes, length);
    }
    SET_BYTEARRAY(&ir, byteArrayPtr);

-    Tcl_StoreInternalRep(objPtr, &properByteArrayType, &ir);
+    Tcl_StoreIntRep(objPtr, &properByteArrayType, &ir);
 }

 /*
 *----------------------------------------------------------------------
 *
- * Tcl_GetBytesFromObj/TclGetBytesFromObj --
+ * TclGetBytesFromObj --
 *
 *	Attempt to extract the value from objPtr in the representation
 *	of a byte sequence. On success return the extracted byte sequence.
- *	On failure, return NULL and record error message and code in
+ *	On failures, return NULL and record error message and code in
 *	interp (if not NULL).
 *
 * Results:
- *	NULL or pointer to array of bytes representing the ByteArray object.
- *	Writes number of bytes in array to *numBytesPtr.
+ *	Pointer to array of bytes, or NULL. representing the ByteArray object.
+ *	Writes number of bytes in array to *lengthPtr.
 *
 *----------------------------------------------------------------------
 */
@@ -434,21 +458,21 @@ unsigned char *
 TclGetBytesFromObj(
    Tcl_Interp *interp,		/* For error reporting */
    Tcl_Obj *objPtr,		/* Value to extract from */
-    int *numBytesPtr)		/* If non-NULL, write the number of bytes
-				 * in the array here */
+    int *lengthPtr)		/* If non-NULL, filled with length of the
+				 * array of bytes in the ByteArray object. */
 {
    ByteArray *baPtr;
-    const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
+    const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objPtr, &properByteArrayType);

    if (irPtr == NULL) {
 	SetByteArrayFromAny(NULL, objPtr);
-	irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
+	irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
 	if (irPtr == NULL) {
 	    if (interp) {
 		const char *nonbyte;
 		int ucs4;

-		irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
+		irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
 		baPtr = GET_BYTEARRAY(irPtr);
 		nonbyte = Tcl_UtfAtIndex(Tcl_GetString(objPtr), baPtr->bad);
 		TclUtfToUCS4(nonbyte, &ucs4);
@@ -463,47 +487,8 @@ TclGetBytesFromObj(
    }
    baPtr = GET_BYTEARRAY(irPtr);

-    if (numBytesPtr != NULL) {
-	*numBytesPtr = baPtr->used;
-    }
-    return baPtr->bytes;
-}
-#undef Tcl_GetBytesFromObj
-unsigned char *
-Tcl_GetBytesFromObj(
-    Tcl_Interp *interp,		/* For error reporting */
-    Tcl_Obj *objPtr,		/* Value to extract from */
-    size_t *numBytesPtr)	/* If non-NULL, write the number of bytes
-				 * in the array here */
-{
-    ByteArray *baPtr;
-    const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
-
-    if (irPtr == NULL) {
-	SetByteArrayFromAny(NULL, objPtr);
-	irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
-	if (irPtr == NULL) {
-	    if (interp) {
-		const char *nonbyte;
-		int ucs4;
-
-		irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
-		baPtr = GET_BYTEARRAY(irPtr);
-		nonbyte = Tcl_UtfAtIndex(Tcl_GetString(objPtr), baPtr->bad);
-		TclUtfToUCS4(nonbyte, &ucs4);
-
-		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-			"expected byte sequence but character %d "
-			"was '%1s' (U+%06X)", baPtr->bad, nonbyte, ucs4));
-		Tcl_SetErrorCode(interp, "TCL", "VALUE", "BYTES", NULL);
-	    }
-	    return NULL;
-	}
-    }
-    baPtr = GET_BYTEARRAY(irPtr);
-
-    if (numBytesPtr != NULL) {
-	*numBytesPtr = baPtr->used;
+    if (lengthPtr != NULL) {
+	*lengthPtr = baPtr->used;
    }
    return baPtr->bytes;
 }
@@ -530,24 +515,24 @@ Tcl_GetBytesFromObj(
 unsigned char *
 Tcl_GetByteArrayFromObj(
    Tcl_Obj *objPtr,		/* The ByteArray object. */
-    int *numBytesPtr)		/* If non-NULL, write the number of bytes
-				 * in the array here */
+    int *lengthPtr)		/* If non-NULL, filled with length of the
+				 * array of bytes in the ByteArray object. */
 {
    ByteArray *baPtr;
-    const Tcl_ObjInternalRep *irPtr;
-    unsigned char *result = TclGetBytesFromObj(NULL, objPtr, numBytesPtr);
+    const Tcl_ObjIntRep *irPtr;
+    unsigned char *result = TclGetBytesFromObj(NULL, objPtr, lengthPtr);

    if (result) {
 	return result;
    }

-    irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
+    irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
    assert(irPtr != NULL);

    baPtr = GET_BYTEARRAY(irPtr);

-    if (numBytesPtr != NULL) {
-	*numBytesPtr = baPtr->used;
+    if (lengthPtr != NULL) {
+	*lengthPtr = baPtr->used;
    }
    return (unsigned char *) baPtr->bytes;
 }
@@ -555,28 +540,27 @@ Tcl_GetByteArrayFromObj(
 unsigned char *
 TclGetByteArrayFromObj(
    Tcl_Obj *objPtr,		/* The ByteArray object. */
-    size_t *numBytesPtr)	/* If non-NULL, write the number of bytes
-				 * in the array here */
+    size_t *lengthPtr)		/* If non-NULL, filled with length of the
+				 * array of bytes in the ByteArray object. */
 {
    ByteArray *baPtr;
-    const Tcl_ObjInternalRep *irPtr;
-    unsigned char *result = Tcl_GetBytesFromObj(NULL, objPtr, numBytesPtr);
+    const Tcl_ObjIntRep *irPtr;
+    unsigned char *result = TclGetBytesFromObj(NULL, objPtr, (int *)NULL);

    if (result) {
 	return result;
    }

-    irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
+    irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
    assert(irPtr != NULL);

    baPtr = GET_BYTEARRAY(irPtr);

-    if (numBytesPtr != NULL) {
+    if (lengthPtr != NULL) {
 #if TCL_MAJOR_VERSION > 8
-	*numBytesPtr = baPtr->used;
+	*lengthPtr = baPtr->used;
 #else
-	/* TODO: What's going on here?  Document or eliminate. */
-	*numBytesPtr = ((size_t)(unsigned)(baPtr->used + 1)) - 1;
+	*lengthPtr = ((size_t)(unsigned)(baPtr->used + 1)) - 1;
 #endif
    }
    return baPtr->bytes;
@@ -607,34 +591,31 @@ TclGetByteArrayFromObj(
 unsigned char *
 Tcl_SetByteArrayLength(
    Tcl_Obj *objPtr,		/* The ByteArray object. */
-    int numBytes)		/* Number of bytes in resized array */
+    int length)			/* New length for internal byte array. */
 {
    ByteArray *byteArrayPtr;
    unsigned newLength;
-    Tcl_ObjInternalRep *irPtr;
+    Tcl_ObjIntRep *irPtr;

-    assert(numBytes >= 0);
-    newLength = (unsigned int)numBytes;
+    assert(length >= 0);
+    newLength = (unsigned int)length;

    if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetByteArrayLength");
    }

-    irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
+    irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
    if (irPtr == NULL) {
-	irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
+	irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
 	if (irPtr == NULL) {
 	    SetByteArrayFromAny(NULL, objPtr);
-	    irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
+	    irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
 	    if (irPtr == NULL) {
-		irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
+		irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
 	    }
 	}
    }

-    /* Note that during truncation, the implementation does not free
-     * memory that is no longer needed. */
-
    byteArrayPtr = GET_BYTEARRAY(irPtr);
    if (newLength > byteArrayPtr->allocated) {
 	byteArrayPtr = (ByteArray *)ckrealloc(byteArrayPtr, BYTEARRAY_SIZE(newLength));
@@ -674,12 +655,12 @@ SetByteArrayFromAny(
    unsigned char *dst;
    Tcl_UniChar ch = 0;
    ByteArray *byteArrayPtr;
-    Tcl_ObjInternalRep ir;
+    Tcl_ObjIntRep ir;

-    if (TclHasInternalRep(objPtr, &properByteArrayType)) {
+    if (TclHasIntRep(objPtr, &properByteArrayType)) {
 	return TCL_OK;
    }
-    if (TclHasInternalRep(objPtr, &tclByteArrayType)) {
+    if (TclHasIntRep(objPtr, &tclByteArrayType)) {
 	return TCL_OK;
    }

@@ -687,9 +668,6 @@ SetByteArrayFromAny(
    length = bad = objPtr->length;
    srcEnd = src + length;

-    /* Note the allocation is over-sized, possibly by a factor of four,
-     * or even a factor of two with a proper byte array value. */
-
    byteArrayPtr = (ByteArray *)ckalloc(BYTEARRAY_SIZE(length));
    for (dst = byteArrayPtr->bytes; src < srcEnd; ) {
 	src += TclUtfToUniChar(src, &ch);
@@ -705,10 +683,10 @@ SetByteArrayFromAny(

    if (bad == length) {
 	byteArrayPtr->bad = byteArrayPtr->used;
-	Tcl_StoreInternalRep(objPtr, &properByteArrayType, &ir);
+	Tcl_StoreIntRep(objPtr, &properByteArrayType, &ir);
    } else {
 	byteArrayPtr->bad = bad;
-	Tcl_StoreInternalRep(objPtr, &tclByteArrayType, &ir);
+	Tcl_StoreIntRep(objPtr, &tclByteArrayType, &ir);
    }

    return TCL_OK;
@@ -735,14 +713,14 @@ static void
 FreeByteArrayInternalRep(
    Tcl_Obj *objPtr)		/* Object with internal rep to free. */
 {
-    ckfree(GET_BYTEARRAY(TclFetchInternalRep(objPtr, &tclByteArrayType)));
+    ckfree(GET_BYTEARRAY(TclFetchIntRep(objPtr, &tclByteArrayType)));
 }

 static void
 FreeProperByteArrayInternalRep(
    Tcl_Obj *objPtr)		/* Object with internal rep to free. */
 {
-    ckfree(GET_BYTEARRAY(TclFetchInternalRep(objPtr, &properByteArrayType)));
+    ckfree(GET_BYTEARRAY(TclFetchIntRep(objPtr, &properByteArrayType)));
 }

 /*
@@ -769,9 +747,9 @@ DupByteArrayInternalRep(
 {
    unsigned int length;
    ByteArray *srcArrayPtr, *copyArrayPtr;
-    Tcl_ObjInternalRep ir;
+    Tcl_ObjIntRep ir;

-    srcArrayPtr = GET_BYTEARRAY(TclFetchInternalRep(srcPtr, &tclByteArrayType));
+    srcArrayPtr = GET_BYTEARRAY(TclFetchIntRep(srcPtr, &tclByteArrayType));
    length = srcArrayPtr->used;

    copyArrayPtr = (ByteArray *)ckalloc(BYTEARRAY_SIZE(length));
@@ -781,7 +759,7 @@ DupByteArrayInternalRep(
    memcpy(copyArrayPtr->bytes, srcArrayPtr->bytes, length);

    SET_BYTEARRAY(&ir, copyArrayPtr);
-    Tcl_StoreInternalRep(copyPtr, &tclByteArrayType, &ir);
+    Tcl_StoreIntRep(copyPtr, &tclByteArrayType, &ir);
 }

 static void
@@ -791,9 +769,9 @@ DupProperByteArrayInternalRep(
 {
    unsigned int length;
    ByteArray *srcArrayPtr, *copyArrayPtr;
-    Tcl_ObjInternalRep ir;
+    Tcl_ObjIntRep ir;

-    srcArrayPtr = GET_BYTEARRAY(TclFetchInternalRep(srcPtr, &properByteArrayType));
+    srcArrayPtr = GET_BYTEARRAY(TclFetchIntRep(srcPtr, &properByteArrayType));
    length = srcArrayPtr->used;

    copyArrayPtr = (ByteArray *)ckalloc(BYTEARRAY_SIZE(length));
@@ -803,7 +781,7 @@ DupProperByteArrayInternalRep(
    memcpy(copyArrayPtr->bytes, srcArrayPtr->bytes, length);

    SET_BYTEARRAY(&ir, copyArrayPtr);
-    Tcl_StoreInternalRep(copyPtr, &properByteArrayType, &ir);
+    Tcl_StoreIntRep(copyPtr, &properByteArrayType, &ir);
 }

 /*
@@ -828,7 +806,7 @@ UpdateStringOfByteArray(
    Tcl_Obj *objPtr)		/* ByteArray object whose string rep to
 				 * update. */
 {
-    const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
+    const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
    ByteArray *byteArrayPtr = GET_BYTEARRAY(irPtr);
    unsigned char *src = byteArrayPtr->bytes;
    unsigned int i, length = byteArrayPtr->used;
@@ -889,7 +867,7 @@ TclAppendBytesToByteArray(
 {
    ByteArray *byteArrayPtr;
    unsigned int length, needed;
-    Tcl_ObjInternalRep *irPtr;
+    Tcl_ObjIntRep *irPtr;

    if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object","TclAppendBytesToByteArray");
@@ -908,14 +886,14 @@ TclAppendBytesToByteArray(

    length = (unsigned int) len;

-    irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
+    irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
    if (irPtr == NULL) {
-	irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
+	irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
 	if (irPtr == NULL) {
 	    SetByteArrayFromAny(NULL, objPtr);
-	    irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
+	    irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
 	    if (irPtr == NULL) {
-		irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
+		irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
 	    }
 	}
    }
@@ -2145,7 +2123,7 @@ CopyNumber(
 *
 * FormatNumber --
 *
- *	This routine is called by BinaryFormatCmd to format a number into a
+ *	This routine is called by Tcl_BinaryObjCmd to format a number into a
 *	location pointed at by cursor.
 *
 * Results:
@@ -2180,7 +2158,7 @@ FormatNumber(
 	 */

 	if (Tcl_GetDoubleFromObj(interp, src, &dvalue) != TCL_OK) {
-	    const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(src, &tclDoubleType);
+	    const Tcl_ObjIntRep *irPtr = TclFetchIntRep(src, &tclDoubleType);
 	    if (irPtr == NULL) {
 		return TCL_ERROR;
 	    }
@@ -2200,7 +2178,7 @@ FormatNumber(
 	 */

 	if (Tcl_GetDoubleFromObj(interp, src, &dvalue) != TCL_OK) {
-	    const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(src, &tclDoubleType);
+	    const Tcl_ObjIntRep *irPtr = TclFetchIntRep(src, &tclDoubleType);

 	    if (irPtr == NULL) {
 		return TCL_ERROR;
@@ -2314,7 +2292,7 @@ FormatNumber(
 *
 * ScanNumber --
 *
- *	This routine is called by BinaryScanCmd to scan a number out of a
+ *	This routine is called by Tcl_BinaryObjCmd to scan a number out of a
 *	buffer.
 *
 * Results:
@@ -381,7 +381,7 @@ Tcl_DumpActiveMemory(
 * Tcl_DbCkalloc - debugging ckalloc
 *
 *	Allocate the requested amount of space plus some extra for guard bands
- *	at both ends of the request, plus a size, panicking if there isn't
+ *	at both ends of the request, plus a size, panicing if there isn't
 *	enough space, then write in the guard bands and return the address of
 *	the space in the middle that the user asked for.
 *
@@ -452,7 +452,7 @@ ClockGetdatefieldsObjCmd(
     * that it isn't.
     */

-    if (TclHasInternalRep(objv[1], &tclBignumType)) {
+    if (TclHasIntRep(objv[1], &tclBignumType)) {
 	Tcl_SetObjResult(interp, lit[LIT_INTEGER_VALUE_TOO_LARGE]);
 	return TCL_ERROR;
    }
@@ -613,6 +613,8 @@ EncodingConverttoObjCmd(
    int length;			/* Length of the string being converted */
    const char *stringPtr;	/* Pointer to the first byte of the string */

+    /* TODO - ADJUST OBJ INDICES WHEN ENSEMBLIFYING THIS */
+
    if (objc == 2) {
 	encoding = Tcl_GetEncoding(interp, NULL);
 	data = objv[1];
@@ -86,12 +86,14 @@ typedef struct {
 * following values.
 */

-#define SORTMODE_ASCII		0
-#define SORTMODE_INTEGER	1
-#define SORTMODE_REAL		2
-#define SORTMODE_COMMAND	3
-#define SORTMODE_DICTIONARY	4
-#define SORTMODE_ASCII_NC	8
+enum SortModeFlags {
+    SORTMODE_ASCII = 0,
+    SORTMODE_INTEGER = 1,
+    SORTMODE_REAL = 2,
+    SORTMODE_COMMAND = 3,
+    SORTMODE_DICTIONARY = 4,
+    SORTMODE_ASCII_NC = 8
+};

 /*
 * Forward declarations for procedures defined in this file:
@@ -1241,7 +1243,7 @@ TclInfoFrame(
 {
    Interp *iPtr = (Interp *) interp;
    Tcl_Obj *tmpObj;
-    Tcl_Obj *lv[20] = {NULL};		/* Keep uptodate when more keys are added to
+    Tcl_Obj *lv[20];		/* Keep uptodate when more keys are added to
 				 * the dict. */
    int lc = 0;
    /*
@@ -1533,16 +1533,16 @@ StringIsCmd(
 	"boolean",	"dict",		"digit",	"double",
 	"entier",	"false",	"graph",	"integer",
 	"list",		"lower",	"print",	"punct",
-	"space",	"true",		"upper",	"unicode",
-	"wideinteger", "wordchar",	"xdigit",	NULL
+	"space",	"true",		"upper",	"wideinteger",
+	"wordchar",	"xdigit",	NULL
    };
    enum isClassesEnum {
 	STR_IS_ALNUM,	STR_IS_ALPHA,	STR_IS_ASCII,	STR_IS_CONTROL,
 	STR_IS_BOOL,	STR_IS_DICT,	STR_IS_DIGIT,	STR_IS_DOUBLE,
 	STR_IS_ENTIER,	STR_IS_FALSE,	STR_IS_GRAPH,	STR_IS_INT,
 	STR_IS_LIST,	STR_IS_LOWER,	STR_IS_PRINT,	STR_IS_PUNCT,
-	STR_IS_SPACE,	STR_IS_TRUE,	STR_IS_UPPER,	STR_IS_UNICODE,
-	STR_IS_WIDE,	STR_IS_WORD,	STR_IS_XDIGIT
+	STR_IS_SPACE,	STR_IS_TRUE,	STR_IS_UPPER,	STR_IS_WIDE,
+	STR_IS_WORD,	STR_IS_XDIGIT
    };
    static const char *const isOptions[] = {
 	"-strict", "-failindex", NULL
@@ -1611,7 +1611,7 @@ StringIsCmd(
    case STR_IS_BOOL:
    case STR_IS_TRUE:
    case STR_IS_FALSE:
-	if (!TclHasInternalRep(objPtr, &tclBooleanType)
+	if (!TclHasIntRep(objPtr, &tclBooleanType)
 		&& (TCL_OK != TclSetBooleanFromAny(NULL, objPtr))) {
 	    if (strict) {
 		result = 0;
@@ -1681,9 +1681,9 @@ StringIsCmd(
 	chcomp = Tcl_UniCharIsDigit;
 	break;
    case STR_IS_DOUBLE: {
-	if (TclHasInternalRep(objPtr, &tclDoubleType) ||
-		TclHasInternalRep(objPtr, &tclIntType) ||
-		TclHasInternalRep(objPtr, &tclBignumType)) {
+	if (TclHasIntRep(objPtr, &tclDoubleType) ||
+		TclHasIntRep(objPtr, &tclIntType) ||
+		TclHasIntRep(objPtr, &tclBignumType)) {
 	    break;
 	}
 	string1 = TclGetStringFromObj(objPtr, &length1);
@@ -1702,7 +1702,7 @@ StringIsCmd(
 	    failat = stop - string1;
 	    if (stop < end) {
 		result = 0;
-		TclFreeInternalRep(objPtr);
+		TclFreeIntRep(objPtr);
 	    }
 	}
 	break;
@@ -1712,8 +1712,8 @@ StringIsCmd(
 	break;
    case STR_IS_INT:
    case STR_IS_ENTIER:
-	if (TclHasInternalRep(objPtr, &tclIntType) ||
-		TclHasInternalRep(objPtr, &tclBignumType)) {
+	if (TclHasIntRep(objPtr, &tclIntType) ||
+		TclHasIntRep(objPtr, &tclBignumType)) {
 	    break;
 	}
 	string1 = TclGetStringFromObj(objPtr, &length1);
@@ -1742,7 +1742,7 @@ StringIsCmd(

 		result = 0;
 		failat = stop - string1;
-		TclFreeInternalRep(objPtr);
+		TclFreeIntRep(objPtr);
 	    }
 	} else {
 	    /*
@@ -1795,7 +1795,7 @@ StringIsCmd(
 		 */

 		failat = stop - string1;
-		TclFreeInternalRep(objPtr);
+		TclFreeIntRep(objPtr);
 	    }
 	} else {
 	    /*
@@ -1872,9 +1872,6 @@ StringIsCmd(
    case STR_IS_UPPER:
 	chcomp = Tcl_UniCharIsUpper;
 	break;
-    case STR_IS_UNICODE:
-	chcomp = Tcl_UniCharIsUnicode;
-	break;
    case STR_IS_WORD:
 	chcomp = Tcl_UniCharIsWordChar;
 	break;
@@ -1990,7 +1987,7 @@ StringMapCmd(
     */

    if (!TclHasStringRep(objv[objc-2])
-	    && TclHasInternalRep(objv[objc-2], &tclDictType)) {
+	    && TclHasIntRep(objv[objc-2], &tclDictType)) {
 	int i, done;
 	Tcl_DictSearch search;

@@ -2835,7 +2832,6 @@ StringCatCmd(
 *
 *----------------------------------------------------------------------
 */
-#if TCL_MAJOR_VERSION < 9 && !defined(TCL_NO_DEPRECATED)
 static int
 StringBytesCmd(
    TCL_UNUSED(ClientData),
@@ -2854,7 +2850,6 @@ StringBytesCmd(
    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(length));
    return TCL_OK;
 }
-#endif

 /*
 *----------------------------------------------------------------------
@@ -3311,9 +3306,7 @@ TclInitStringCmd(
    Tcl_Interp *interp)		/* Current interpreter. */
 {
    static const EnsembleImplMap stringImplMap[] = {
-#if TCL_MAJOR_VERSION < 9 && !defined(TCL_NO_DEPRECATED)
 	{"bytelength",	StringBytesCmd,	TclCompileBasic1ArgCmd, NULL, NULL, 0},
-#endif
 	{"cat",		StringCatCmd,	TclCompileStringCatCmd, NULL, NULL, 0},
 	{"compare",	StringCmpCmd,	TclCompileStringCmpCmd, NULL, NULL, 0},
 	{"equal",	StringEqualCmd,	TclCompileStringEqualCmd, NULL, NULL, 0},
@@ -5120,15 +5113,15 @@ TryPostHandler(
 {
    Tcl_Obj *resultObj, *cmdObj, *options, *handlerKindObj, **objv;
    Tcl_Obj *finallyObj;
-    int finallyIndex;
+    int finally;

    objv = (Tcl_Obj **)data[0];
    options = (Tcl_Obj *)data[1];
    handlerKindObj = (Tcl_Obj *)data[2];
-    finallyIndex = PTR2INT(data[3]);
+    finally = PTR2INT(data[3]);

    cmdObj = objv[0];
-    finallyObj = finallyIndex ? objv[finallyIndex] : 0;
+    finallyObj = finally ? objv[finally] : 0;

    /*
     * Check for limits/rewinding, which override normal trapping behaviour.
@@ -5172,7 +5165,7 @@ TryPostHandler(

 	/* The 'finally' script is always the last argument word. */
 	return TclNREvalObjEx(interp, finallyObj, 0, iPtr->cmdFramePtr,
-		finallyIndex);
+		finally);
    }

    /*
@@ -2641,8 +2641,8 @@ TclCompileLmapCmd(
    Tcl_Interp *interp,		/* Used for error reporting. */
    Tcl_Parse *parsePtr,	/* Points to a parse structure for the command
 				 * created by Tcl_ParseCommand. */
-    Command *cmdPtr,		/* Points to the definition of the command
-				 *  being compiled. */
+    Command *cmdPtr,		/* Points to defintion of command being
+				 * compiled. */
    CompileEnv *envPtr)		/* Holds resulting instructions. */
 {
    return CompileEachloopCmd(interp, parsePtr, cmdPtr, envPtr,
@@ -2703,7 +2703,7 @@ CompileEachloopCmd(
    }

    /*
-     * Bail out if the body requires substitutions in order to ensure correct
+     * Bail out if the body requires substitutions in order to insure correct
     * behaviour. [Bug 219166]
     */

@@ -505,19 +505,19 @@ TclCompileStringIsCmd(
    Tcl_Token *tokenPtr = TokenAfter(parsePtr->tokenPtr);
    static const char *const isClasses[] = {
 	"alnum",	"alpha",	"ascii",	"control",
-	"boolean",	"dict",		"digit",	"double",
-	"entier",	"false",	"graph",	"integer",
-	"list",		"lower",	"print",	"punct",
-	"space",	"true",		"upper",	"unicode",
-	"wideinteger", "wordchar",	"xdigit",	NULL
+	"boolean",	"dict", "digit",	"double",	"entier",
+	"false",	"graph",	"integer",	"list",
+	"lower",	"print",	"punct",	"space",
+	"true",		"upper",	"wideinteger",	"wordchar",
+	"xdigit",	NULL
    };
    enum isClassesEnum {
 	STR_IS_ALNUM,	STR_IS_ALPHA,	STR_IS_ASCII,	STR_IS_CONTROL,
-	STR_IS_BOOL,	STR_IS_DICT,	STR_IS_DIGIT,	STR_IS_DOUBLE,
-	STR_IS_ENTIER,	STR_IS_FALSE,	STR_IS_GRAPH,	STR_IS_INT,
-	STR_IS_LIST,	STR_IS_LOWER,	STR_IS_PRINT,	STR_IS_PUNCT,
-	STR_IS_SPACE,	STR_IS_TRUE,	STR_IS_UPPER,	STR_IS_UNICODE,
-	STR_IS_WIDE,	STR_IS_WORD,	STR_IS_XDIGIT
+	STR_IS_BOOL,	STR_IS_DICT, STR_IS_DIGIT,	STR_IS_DOUBLE,	STR_IS_ENTIER,
+	STR_IS_FALSE,	STR_IS_GRAPH,	STR_IS_INT,	STR_IS_LIST,
+	STR_IS_LOWER,	STR_IS_PRINT,	STR_IS_PUNCT,	STR_IS_SPACE,
+	STR_IS_TRUE,	STR_IS_UPPER,	STR_IS_WIDE,	STR_IS_WORD,
+	STR_IS_XDIGIT
    };
    int t, range, allowEmpty = 0, end;
    InstStringClassType strClassType;
@@ -609,9 +609,6 @@ TclCompileStringIsCmd(
    case STR_IS_UPPER:
 	strClassType = STR_CLASS_UPPER;
 	goto compileStrClass;
-    case STR_IS_UNICODE:
-	strClassType = STR_CLASS_UNICODE;
-	goto compileStrClass;
    case STR_IS_WORD:
 	strClassType = STR_CLASS_WORD;
 	goto compileStrClass;
@@ -1418,7 +1415,6 @@ StringClassDesc const tclStringClassTable[] = {
    {"upper",	Tcl_UniCharIsUpper},
    {"word",	Tcl_UniCharIsWordChar},
    {"xdigit",	UniCharIsHexDigit},
-    {"unicode",	Tcl_UniCharIsUnicode},
    {"",	NULL}
 };

@@ -123,26 +123,27 @@ enum Marks {
 * store a NODE_TYPE code.
 */

-#define NODE_TYPE	0xC0
+enum NodeTypeFlags {
+    NODE_TYPE = 0xC0,

-/*
- * The four category values are LEAF, UNARY, and BINARY, explained below, and
- * "uncategorized", which is used either temporarily, until context determines
- * which of the other three categories is correct, or for lexemes like
- * INVALID, which aren't really lexemes at all, but indicators of a parsing
- * error. Note that the codes must be distinct to distinguish categories, but
- * need not take the form of a bit array.
- */
+    /*
+     * The four category values are LEAF, UNARY, and BINARY, explained below,
+     * and "uncategorized", which is used either temporarily, until context
+     * determines which of the other three categories is correct, or for
+     * lexemes like INVALID, which aren't really lexemes at all, but
+     * indicators of a parsing error. Note that the codes must be distinct to
+     * distinguish categories, but need not take the form of a bit array.
+     */

-#define BINARY		0x40	/* This lexeme is a binary operator. An OpNode
+    BINARY = 0x40,		/* This lexeme is a binary operator. An OpNode
 				 * representing it should go into the parse
 				 * tree, and two operands should be parsed for
 				 * it in the expression. */
-#define UNARY		0x80	/* This lexeme is a unary operator. An OpNode
+    UNARY = 0x80,		/* This lexeme is a unary operator. An OpNode
 				 * representing it should go into the parse
 				 * tree, and one operand should be parsed for
 				 * it in the expression. */
-#define LEAF		0xC0	/* This lexeme is a leaf operand in the parse
+    LEAF = 0xC0			/* This lexeme is a leaf operand in the parse
 				 * tree. No OpNode will be placed in the tree
 				 * for it. Either a literal value will be
 				 * appended to the list of literals in this
@@ -150,47 +151,42 @@ enum Marks {
 				 * be appended in a Tcl_Parse struct to
 				 * represent those leaves that require some
 				 * form of substitution. */
+};

-/* Uncategorized lexemes */
+enum LexemeTypes {
+    /* Uncategorized lexemes */

-#define PLUS		1	/* Ambiguous. Resolves to UNARY_PLUS or
+    PLUS = 1,			/* Ambiguous. Resolves to UNARY_PLUS or
 				 * BINARY_PLUS according to context. */
-#define MINUS		2	/* Ambiguous. Resolves to UNARY_MINUS or
+    MINUS = 2,			/* Ambiguous. Resolves to UNARY_MINUS or
 				 * BINARY_MINUS according to context. */
-#define BAREWORD	3	/* Ambigous. Resolves to BOOLEAN or to
+    BAREWORD = 3,		/* Ambigous. Resolves to BOOLEAN or to
 				 * FUNCTION or a parse error according to
 				 * context and value. */
-#define INCOMPLETE	4	/* A parse error. Used only when the single
+    INCOMPLETE = 4,		/* A parse error. Used only when the single
 				 * "=" is encountered.  */
-#define INVALID		5	/* A parse error. Used when any punctuation
+    INVALID = 5,		/* A parse error. Used when any punctuation
 				 * appears that's not a supported operator. */
-#define COMMENT		6	/* Comment. Lasts to end of line or end of
+    COMMENT = 6,		/* Comment. Lasts to end of line or end of
 				 * expression, whichever comes first. */

-/* Leaf lexemes */
+    /* Leaf lexemes */

-#define NUMBER		(LEAF | 1)
-				/* For literal numbers */
-#define SCRIPT		(LEAF | 2)
-				/* Script substitution; [foo] */
-#define BOOLEAN		(LEAF | BAREWORD)
-				/* For literal booleans */
-#define BRACED		(LEAF | 4)
-				/* Braced string; {foo bar} */
-#define VARIABLE	(LEAF | 5)
-				/* Variable substitution; $x */
-#define QUOTED		(LEAF | 6)
-				/* Quoted string; "foo $bar [soom]" */
-#define EMPTY		(LEAF | 7)
-				/* Used only for an empty argument list to a
+    NUMBER = (LEAF | 1),	/* For literal numbers */
+    SCRIPT = (LEAF | 2),	/* Script substitution; [foo] */
+    BOOLEAN = (LEAF | BAREWORD),/* For literal booleans */
+    BRACED = (LEAF | 4),	/* Braced string; {foo bar} */
+    VARIABLE = (LEAF | 5),	/* Variable substitution; $x */
+    QUOTED = (LEAF | 6),	/* Quoted string; "foo $bar [soom]" */
+    EMPTY = (LEAF | 7),		/* Used only for an empty argument list to a
 				 * function. Represents the empty string
 				 * within parens in the expression: rand() */

-/* Unary operator lexemes */
+    /* Unary operator lexemes */

-#define UNARY_PLUS	(UNARY | PLUS)
-#define UNARY_MINUS	(UNARY | MINUS)
-#define FUNCTION	(UNARY | BAREWORD)
+    UNARY_PLUS = (UNARY | PLUS),
+    UNARY_MINUS = (UNARY | MINUS),
+    FUNCTION = (UNARY | BAREWORD),
 				/* This is a bit of "creative interpretation"
 				 * on the part of the parser. A function call
 				 * is parsed into the parse tree according to
@@ -206,69 +202,62 @@ enum Marks {
 				 * include such exceptional handling in the
 				 * code against the need we would otherwise
 				 * have for more lexeme categories. */
-#define START		(UNARY | 4)
-				/* This lexeme isn't parsed from the
+    START = (UNARY | 4),	/* This lexeme isn't parsed from the
 				 * expression text at all. It represents the
 				 * start of the expression and sits at the
 				 * root of the parse tree where it serves as
 				 * the start/end point of traversals. */
-#define OPEN_PAREN	(UNARY | 5)
-				/* Another bit of creative interpretation,
+    OPEN_PAREN = (UNARY | 5),	/* Another bit of creative interpretation,
 				 * where we treat "(" as a unary operator with
 				 * the sub-expression between it and its
 				 * matching ")" as its operand. See
 				 * CLOSE_PAREN below. */
-#define NOT		(UNARY | 6)
-#define BIT_NOT		(UNARY | 7)
+    NOT = (UNARY | 6),
+    BIT_NOT = (UNARY | 7),

-/* Binary operator lexemes */
+    /* Binary operator lexemes */

-#define BINARY_PLUS	(BINARY |  PLUS)
-#define BINARY_MINUS	(BINARY |  MINUS)
-#define COMMA		(BINARY |  3)
-				/* The "," operator is a low precedence binary
+    BINARY_PLUS = (BINARY | PLUS),
+    BINARY_MINUS = (BINARY | MINUS),
+    COMMA =	(BINARY | 3),	/* The "," operator is a low precedence binary
 				 * operator that separates the arguments in a
 				 * function call. The additional constraint
 				 * that this operator can only legally appear
 				 * at the right places within a function call
 				 * argument list are hard coded within
-				 * ParseExpr().  */
-#define MULT		(BINARY |  4)
-#define DIVIDE		(BINARY |  5)
-#define MOD		(BINARY |  6)
-#define LESS		(BINARY |  7)
-#define GREATER		(BINARY |  8)
-#define BIT_AND		(BINARY |  9)
-#define BIT_XOR		(BINARY | 10)
-#define BIT_OR		(BINARY | 11)
-#define QUESTION	(BINARY | 12)
-				/* These two lexemes make up the */
-#define COLON		(BINARY | 13)
-				/* ternary conditional operator, $x ? $y : $z.
+				 * ParseExpr(). */
+    MULT =	(BINARY | 4),
+    DIVIDE =	(BINARY | 5),
+    MOD =	(BINARY | 6),
+    LESS =	(BINARY | 7),
+    GREATER =	(BINARY | 8),
+    BIT_AND =	(BINARY | 9),
+    BIT_XOR =	(BINARY | 10),
+    BIT_OR =	(BINARY | 11),
+    QUESTION =	(BINARY | 12),	/* These two lexemes make up the */
+    COLON =	(BINARY | 13),	/* ternary conditional operator, $x ? $y : $z.
 				 * We treat them as two binary operators to
 				 * avoid another lexeme category, and code the
 				 * additional constraints directly in
 				 * ParseExpr(). For instance, the right
 				 * operand of a "?" operator must be a ":"
 				 * operator. */
-#define LEFT_SHIFT	(BINARY | 14)
-#define RIGHT_SHIFT	(BINARY | 15)
-#define LEQ		(BINARY | 16)
-#define GEQ		(BINARY | 17)
-#define EQUAL		(BINARY | 18)
-#define NEQ		(BINARY | 19)
-#define AND		(BINARY | 20)
-#define OR		(BINARY | 21)
-#define STREQ		(BINARY | 22)
-#define STRNEQ		(BINARY | 23)
-#define EXPON		(BINARY | 24)
-				/* Unlike the other binary operators, EXPON is
+    LEFT_SHIFT =  (BINARY | 14),
+    RIGHT_SHIFT = (BINARY | 15),
+    LEQ	=	(BINARY | 16),
+    GEQ =	(BINARY | 17),
+    EQUAL =	(BINARY | 18),
+    NEQ =	(BINARY | 19),
+    AND =	(BINARY | 20),
+    OR =	(BINARY | 21),
+    STREQ =	(BINARY | 22),
+    STRNEQ =	(BINARY | 23),
+    EXPON =	(BINARY | 24),	/* Unlike the other binary operators, EXPON is
 				 * right associative and this distinction is
 				 * coded directly in ParseExpr(). */
-#define IN_LIST		(BINARY | 25)
-#define NOT_IN_LIST	(BINARY | 26)
-#define CLOSE_PAREN	(BINARY | 27)
-				/* By categorizing the CLOSE_PAREN lexeme as a
+    IN_LIST =	(BINARY | 25),
+    NOT_IN_LIST = (BINARY | 26),
+    CLOSE_PAREN = (BINARY | 27),/* By categorizing the CLOSE_PAREN lexeme as a
 				 * BINARY operator, the normal parsing rules
 				 * for binary operators assure that a close
 				 * paren will not directly follow another
@@ -283,17 +272,17 @@ enum Marks {
 				 * parse tree. The sub-expression between
 				 * parens becomes the single argument of the
 				 * matching OPEN_PAREN unary operator. */
-#define STR_LT		(BINARY | 28)
-#define STR_GT		(BINARY | 29)
-#define STR_LEQ		(BINARY | 30)
-#define STR_GEQ		(BINARY | 31)
-#define END		(BINARY | 32)
-				/* This lexeme represents the end of the
+    STR_LT = (BINARY | 28),
+    STR_GT = (BINARY | 29),
+    STR_LEQ = (BINARY | 30),
+    STR_GEQ = (BINARY | 31),
+    END = (BINARY | 32),	/* This lexeme represents the end of the
 				 * string being parsed. Treating it as a
 				 * binary operator follows the same logic as
 				 * the CLOSE_PAREN lexeme and END pairs with
 				 * START, in the same way that CLOSE_PAREN
 				 * pairs with OPEN_PAREN. */
+};

 /*
 * When ParseExpr() builds the parse tree it must choose which operands to
@@ -2109,7 +2098,7 @@ ParseLexeme(
 	     * Example: Inf + luence + () becomes a valid function call.
 	     * [Bug 3401704]
 	     */
-	    if (TclHasInternalRep(literal, &tclDoubleType)) {
+	    if (TclHasIntRep(literal, &tclDoubleType)) {
 		const char *p = start;

 		while (p < end) {
@@ -2520,7 +2509,7 @@ CompileExprTree(
 		     * However, the design of the "global" and "local"
 		     * LiteralTable does not permit the value of lePtr->objPtr
 		     * to change. So rather than replace lePtr->objPtr, we do
-		     * surgery to transfer our desired internalrep into it.
+		     * surgery to transfer our desired intrep into it.
 		     */

 		    objPtr->typePtr = literal->typePtr;
@@ -2533,9 +2522,9 @@ CompileExprTree(
 		 * When optimize==0, we know the expression is a one-off and
 		 * there's nothing to be gained from sharing literals when
 		 * they won't live long, and the copies we have already have
-		 * an appropriate internalrep. In this case, skip literal
+		 * an appropriate intrep. In this case, skip literal
 		 * registration that would enable sharing, and use the routine
-		 * that preserves internalreps.
+		 * that preserves intreps.
 		 */

 		TclEmitPush(TclAddLiteralObj(envPtr, literal, NULL), envPtr);
@@ -2572,7 +2561,7 @@ CompileExprTree(
 			if ((tableValue->typePtr == NULL) &&
 				(objPtr->typePtr != NULL)) {
 			    /*
-			     * Same internalrep surgery as for OT_LITERAL.
+			     * Same intrep surgery as for OT_LITERAL.
 			     */

 			    tableValue->typePtr = objPtr->typePtr;
@@ -717,8 +717,8 @@ static void		EnterCmdWordData(ExtCmdLoc *eclPtr, int srcOffset,
 static void		ReleaseCmdWordData(ExtCmdLoc *eclPtr);

 /*
- * tclByteCodeType provides the standard type management procedures for the
- * bytecode type.
+ * The structure below defines the bytecode Tcl object type by means of
+ * procedures that can be invoked by generic object code.
 */

 const Tcl_ObjType tclByteCodeType = {
@@ -730,8 +730,8 @@ const Tcl_ObjType tclByteCodeType = {
 };

 /*
- * subtCodeType provides the standard type managemnt procedures for the
- * substcode type, which represents substiution within a Tcl value.
+ * The structure below defines a bytecode Tcl object type to hold the
+ * compiled bytecode for the [subst]itution of Tcl values.
 */

 static const Tcl_ObjType substCodeType = {
@@ -756,14 +756,16 @@ static const Tcl_ObjType substCodeType = {
 * TclSetByteCodeFromAny --
 *
 *	Part of the bytecode Tcl object type implementation. Attempts to
- *	compile the string representation of the objPtr into bytecode.  Accepts
- *	a hook routine that is invoked to perform any needed post-processing on
- *	the compilation results before generating byte codes.  interp is the
+ *	generate an byte code internal form for the Tcl object "objPtr" by
+ *	compiling its string representation. This function also takes a hook
+ *	procedure that will be invoked to perform any needed post processing
+ *	on the compilation results before generating byte codes. interp is
 *	compilation context and may not be NULL.
 *
 * Results:
- *	A standard Tcl object result. If an error occurs during compilation, an
- *	error message is left in the interpreter's result.
+ *	The return value is a standard Tcl object result. If an error occurs
+ *	during compilation, an error message is left in the interpreter's
+ *	result.
 *
 * Side effects:
 *	Frees the old internal representation. If no error occurs, then the
@@ -805,7 +807,7 @@ TclSetByteCodeFromAny(
    length = objPtr->length;

    /*
-     * TIP #280: Pick up the CmdFrame in which the BC compiler was invoked, and
+     * TIP #280: Pick up the CmdFrame in which the BC compiler was invoked and
     * use to initialize the tracking in the compiler. This information was
     * stored by TclCompEvalObj and ProcCompileProc.
     */
@@ -814,14 +816,15 @@ TclSetByteCodeFromAny(
 	    iPtr->invokeCmdFramePtr, iPtr->invokeWord);

    /*
-     * Make available to the compilation environment any data about invisible
-     * continuation lines for the script.
+     * Now we check if we have data about invisible continuation lines for the
+     * script, and make it available to the compile environment, if so.
     *
     * It is not clear if the script Tcl_Obj* can be free'd while the compiler
     * is using it, leading to the release of the associated ContLineLoc
-     * structure as well. To ensure that the latter doesn't happen set a lock
-     * on it, which is released in TclFreeCompileEnv().  The "lineCLPtr"
-     * hashtable tclObj.c.
+     * structure as well. To ensure that the latter doesn't happen we set a
+     * lock on it. We release this lock in the function TclFreeCompileEnv(),
+     * found in this file. The "lineCLPtr" hashtable is managed in the file
+     * "tclObj.c".
     */

    clLocPtr = TclContinuationsGet(objPtr);
@@ -832,7 +835,7 @@ TclSetByteCodeFromAny(
    TclCompileScript(interp, stringPtr, length, &compEnv);

    /*
-     * Compilation succeeded. Add a "done" instruction at the end.
+     * Successful compilation. Add a "done" instruction at the end.
     */

    TclEmitOpcode(INST_DONE, &compEnv);
@@ -840,9 +843,9 @@ TclSetByteCodeFromAny(
    /*
     * Check for optimizations!
     *
-     * If the generated code is free of most hazards, recompile with generation
-     * of INST_START_CMD disabled to produce code that more compact in many
-     * cases, and also sometimes more performant.
+     * Test if the generated code is free of most hazards; if so, recompile
+     * but with generation of INST_START_CMD disabled. This produces somewhat
+     * faster code in some cases, and more compact code in more.
     */

    if (Tcl_GetParent(interp) == NULL &&
@@ -872,7 +875,7 @@ TclSetByteCodeFromAny(
    }

    /*
-     * Invoke the compilation hook procedure if there is one.
+     * Invoke the compilation hook procedure if one exists.
     */

    if (hookProc) {
@@ -881,7 +884,7 @@ TclSetByteCodeFromAny(

    /*
     * Change the object into a ByteCode object. Ownership of the literal
-     * objects and aux data items passes to the ByteCode object.
+     * objects and aux data items is given to the ByteCode object.
     */

 #ifdef TCL_COMPILE_DEBUG
@@ -912,12 +915,12 @@ TclSetByteCodeFromAny(
 *	compiling its string representation.
 *
 * Results:
- *	A standard Tcl object result. If an error occurs during compilation and
- *	"interp" is not null, an error message is left in the interpreter's
- *	result.
+ *	The return value is a standard Tcl object result. If an error occurs
+ *	during compilation, an error message is left in the interpreter's
+ *	result unless "interp" is NULL.
 *
 * Side effects:
- *	Frees the old internal representation. If no error occurs then the
+ *	Frees the old internal representation. If no error occurs, then the
 *	compiled code is stored as "objPtr"s bytecode representation. Also, if
 *	debugging, initializes the "tcl_traceCompile" Tcl variable used to
 *	trace compilations.
@@ -929,7 +932,7 @@ static int
 SetByteCodeFromAny(
    Tcl_Interp *interp,		/* The interpreter for which the code is being
 				 * compiled. Must not be NULL. */
-    Tcl_Obj *objPtr)		/* The object to compile to bytecode */
+    Tcl_Obj *objPtr)		/* The object to make a ByteCode object. */
 {
    if (interp == NULL) {
 	return TCL_ERROR;
@@ -943,9 +946,9 @@ SetByteCodeFromAny(
 * DupByteCodeInternalRep --
 *
 *	Part of the bytecode Tcl object type implementation. However, it does
- *	not copy the internal representation of a bytecode Tcl_Obj, instead
- *	assigning NULL to the type pointer of the new object.  Code is compiled
- *	for the new object only if necessary.
+ *	not copy the internal representation of a bytecode Tcl_Obj, but
+ *	instead leaves the new object untyped (with a NULL type pointer).
+ *	Code will be compiled for the new object only if necessary.
 *
 * Results:
 *	None.
@@ -977,9 +980,9 @@ DupByteCodeInternalRep(
 *	None.
 *
 * Side effects:
- *	The bytecode object's internal rep is invalidated and its code is freed
- *	unless the code is actively being executed, in which case cleanup is
- *	delayed until the last execution of the code completes.
+ *	The bytecode object's internal rep is marked invalid and its code gets
+ *	freed unless the code is actively being executed. In that case the
+ *	cleanup is delayed until the last execution of the code completes.
 *
 *----------------------------------------------------------------------
 */
@@ -990,7 +993,7 @@ FreeByteCodeInternalRep(
 {
    ByteCode *codePtr;

-    ByteCodeGetInternalRep(objPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetIntRep(objPtr, &tclByteCodeType, codePtr);
    assert(codePtr != NULL);

    TclReleaseByteCode(codePtr);
@@ -1001,16 +1004,16 @@ FreeByteCodeInternalRep(
 *
 * TclReleaseByteCode --
 *
- *	Does all the real work of freeing up a bytecode object's ByteCode
- *	structure. Called only when the structure's reference count
- *	is zero.
+ *	This procedure does all the real work of freeing up a bytecode
+ *	object's ByteCode structure. It's called only when the structure's
+ *	reference count becomes zero.
 *
 * Results:
 *	None.
 *
 * Side effects:
- *	Frees objPtr's bytecode internal representation and sets its type to
- *	NULL.  Also releases its literals and frees its auxiliary data items.
+ *	Frees objPtr's bytecode internal representation and sets its type NULL
+ *	Also releases its literals and frees its auxiliary data items.
 *
 *----------------------------------------------------------------------
 */
@@ -1086,8 +1089,8 @@ CleanupByteCode(
    /*
     * A single heap object holds the ByteCode structure and its code, object,
     * command location, and auxiliary data arrays. This means we only need to
-     * 1) decrement the ref counts of each LiteralEntry in the literal array,
-     * 2) call the free procedures for the auxiliary data items, 3) free the
+     * 1) decrement the ref counts of the LiteralEntry's in its literal array,
+     * 2) call the free procs for the auxiliary data items, 3) free the
     * localCache if it is unused, and finally 4) free the ByteCode
     * structure's heap object.
     *
@@ -1096,11 +1099,11 @@ CleanupByteCode(
     * the global literal table. They instead maintain private references to
     * their literals which must be decremented.
     *
-     * In order to ensure proper and efficient cleanup of the literal array
-     * when it contains non-shared literals [Bug 983660], distinguish the case
-     * of an interpreter being deleted, which is signaled by interp == NULL.
+     * In order to insure a proper and efficient cleanup of the literal array
+     * when it contains non-shared literals [Bug 983660], we also distinguish
+     * the case of an interpreter being deleted (signaled by interp == NULL).
     * Also, as the interp deletion will remove the global literal table
-     * anyway, avoid the extra cost of updating it for each literal being
+     * anyway, we avoid the extra cost of updating it for each literal being
     * released.
     */

@@ -1132,9 +1135,9 @@ CleanupByteCode(
    }

    /*
-     * TIP #280. Release the location data associated with this bytecode
-     * structure, if any. The associated interp may be gone already, and the
-     * data with it.
+     * TIP #280. Release the location data associated with this byte code
+     * structure, if any. NOTE: The interp we belong to may be gone already,
+     * and the data with it.
     *
     * See also tclBasic.c, DeleteInterpProc
     */
@@ -1162,8 +1165,8 @@ CleanupByteCode(
 *
 * IsCompactibleCompileEnv --
 *
- *	Determines whether some basic compaction optimizations may be applied
- *	to a piece of bytecode. Idempotent.
+ *	Checks to see if we may apply some basic compaction optimizations to a
+ *	piece of bytecode. Idempotent.
 *
 * ---------------------------------------------------------------------
 */
@@ -1177,7 +1180,7 @@ IsCompactibleCompileEnv(

    /*
     * Special: procedures in the '::tcl' namespace (or its children) are
-     * considered to be well-behaved, so compaction can be applied to them even
+     * considered to be well-behaved and so can have compaction applied even
     * if it would otherwise be invalid.
     */

@@ -1193,10 +1196,10 @@ IsCompactibleCompileEnv(

    /*
     * Go through and ensure that no operation involved can cause a desired
-     * change of bytecode sequence during its execution. This comes down to
-     * ensuring that there are no mapped variables (due to traces) or calls to
-     * external commands (traces, [uplevel] trickery). This is actually a very
-     * conservative check.  It turns down a lot of code that is OK in practice.
+     * change of bytecode sequence during running. This comes down to ensuring
+     * that there are no mapped variables (due to traces) or calls to external
+     * commands (traces, [uplevel] trickery). This is actually a very
+     * conservative check; it turns down a lot of code that is OK in practice.
     */

    for (pc = envPtr->codeStart ; pc < envPtr->codeNext ; pc += size) {
@@ -1232,8 +1235,8 @@ IsCompactibleCompileEnv(
 *
 * Tcl_SubstObj --
 *
- *	Performs substitutions on the given string as described in the user
- *	documentation for "subst".
+ *	This function performs the substitutions specified on the given string
+ *	as described in the user documentation for the "subst" Tcl command.
 *
 * Results:
 *	A Tcl_Obj* containing the substituted string, or NULL to indicate that
@@ -1265,14 +1268,14 @@ Tcl_SubstObj(
 *
 * Tcl_NRSubstObj --
 *
- *	Adds substitution within the value of objPtr to the NR execution stack.
+ *	Request substitution of a Tcl value by the NR stack.
 *
 * Results:
- *	TCL_OK.
+ *	Returns TCL_OK.
 *
 * Side effects:
 *	Compiles objPtr into bytecode that performs the substitutions as
- *	governed by flags, adds a callback to the NR execution stack to execute
+ *	governed by flags and places callbacks on the NR stack to execute
 *	the bytecode and store the result in the interp.
 *
 *----------------------------------------------------------------------
@@ -1296,11 +1299,11 @@ Tcl_NRSubstObj(
 *
 * CompileSubstObj --
 *
- *	Compiles a value into bytecode that performs substitution within the
- *	value, as governed by flags.
+ *	Compile a Tcl value into ByteCode implementing its substitution, as
+ *	governed by flags.
 *
 * Results:
- *	A (ByteCode *) is pointing to the resulting ByteCode.
+ *	A (ByteCode *) is returned pointing to the resulting ByteCode.
 *
 * Side effects:
 *	The Tcl_ObjType of objPtr is changed to the "substcode" type, and the
@@ -1320,7 +1323,7 @@ CompileSubstObj(
    Interp *iPtr = (Interp *) interp;
    ByteCode *codePtr = NULL;

-    ByteCodeGetInternalRep(objPtr, &substCodeType, codePtr);
+    ByteCodeGetIntRep(objPtr, &substCodeType, codePtr);

    if (codePtr != NULL) {
 	Namespace *nsPtr = iPtr->varFramePtr->nsPtr;
@@ -1332,7 +1335,7 @@ CompileSubstObj(
 		|| (codePtr->nsEpoch != nsPtr->resolverEpoch)
 		|| (codePtr->localCachePtr !=
 		iPtr->varFramePtr->localCachePtr)) {
-	    Tcl_StoreInternalRep(objPtr, &substCodeType, NULL);
+	    Tcl_StoreIntRep(objPtr, &substCodeType, NULL);
 	    codePtr = NULL;
 	}
    }
@@ -1370,9 +1373,9 @@ CompileSubstObj(
 *
 * FreeSubstCodeInternalRep --
 *
- *	Part of the "substcode" Tcl object type implementation. Frees the
- *	storage associated with the substcode internal representation of a
- *	Tcl_Obj unless its code is actively being executed.
+ *	Part of the substcode Tcl object type implementation. Frees the
+ *	storage associated with a substcode object's internal representation
+ *	unless its code is actively being executed.
 *
 * Results:
 *	None.
@@ -1391,7 +1394,7 @@ FreeSubstCodeInternalRep(
 {
    ByteCode *codePtr;

-    ByteCodeGetInternalRep(objPtr, &substCodeType, codePtr);
+    ByteCodeGetIntRep(objPtr, &substCodeType, codePtr);
    assert(codePtr != NULL);

    TclReleaseByteCode(codePtr);
@@ -1626,14 +1629,14 @@ TclInitCompileEnv(
 *
 * TclFreeCompileEnv --
 *
- *	Frees the storage allocated in a CompileEnv compilation environment
+ *	Free the storage allocated in a CompileEnv compilation environment
 *	structure.
 *
 * Results:
 *	None.
 *
 * Side effects:
- *	Allocated storage in the CompileEnv structure is freed, although its
+ *	Allocated storage in the CompileEnv structure is freed. Note that its
 *	local literal table is not deleted and its literal objects are not
 *	released. In addition, storage referenced by its auxiliary data items
 *	is not freed. This is done so that, when compilation is successful,
@@ -1704,11 +1707,10 @@ TclFreeCompileEnv(
 *
 * TclWordKnownAtCompileTime --
 *
- *	Determines whether the value of a token is completely known at compile
- *	time.
+ *	Test whether the value of a token is completely known at compile time.
 *
 * Results:
- *	True if the tokenPtr argument points to a word value that is
+ *	Returns true if the tokenPtr argument points to a word value that is
 *	completely known at compile time. Generally, values that are known at
 *	compile time can be compiled to their values, while values that cannot
 *	be known until substitution at runtime must be compiled to bytecode
@@ -1785,12 +1787,12 @@ TclWordKnownAtCompileTime(
 *
 * TclCompileScript --
 *
- *	Compiles a Tcl script in a string.
+ *	Compile a Tcl script in a string.
 *
 * Results:
- *
- *	A standard Tcl result. If an error occurs, an
- *	error message is left in the interpreter's result.
+ *	The return value is TCL_OK on a successful compilation and TCL_ERROR
+ *	on failure. If TCL_ERROR is returned, then the interpreter's result
+ *	contains an error message.
 *
 * Side effects:
 *	Adds instructions to envPtr to evaluate the script at runtime.
@@ -1927,14 +1929,14 @@ CompileExpanded(
    /*
     * The stack depth during argument expansion can only be managed at
     * runtime, as the number of elements in the expanded lists is not known
-     * at compile time.  Adjust the stack depth estimate here so that it is
+     * at compile time. We adjust here the stack depth estimate so that it is
     * correct after the command with expanded arguments returns.
     *
     * The end effect of this command's invocation is that all the words of
-     * the command are popped from the stack and the result is pushed: The
+     * the command are popped from the stack, and the result is pushed: the
     * stack top changes by (1-wordIdx).
     *
-     * The estimates are not correct while the command is being
+     * Note that the estimates are not correct while the command is being
     * prepared and run, INST_EXPAND_STKTOP is not stack-neutral in general.
     */

@@ -1954,16 +1956,16 @@ CompileCmdCompileProc(
    int depth = TclGetStackDepth(envPtr);

    /*
-     * Emission of the INST_START_CMD instruction is controlled by the value of
+     * Emit of the INST_START_CMD instruction is controlled by the value of
     * envPtr->atCmdStart:
     *
-     * atCmdStart == 2	: Don't use the INST_START_CMD instruction.
-     * atCmdStart == 1	: INST_START_CMD was the last instruction emitted,
-     *			: so no need to emit another.  Instead
-     *			: increment the number of cmds started at it, except
-     *			: for the special case at the start of a script.
-     * atCmdStart == 0	: The last instruction was something else.
-     *			: Emit INST_START_CMD here.
+     * atCmdStart == 2	: We are not using the INST_START_CMD instruction.
+     * atCmdStart == 1	: INST_START_CMD was the last instruction emitted.
+     *			: We do not need to emit another.  Instead we
+     *			: increment the number of cmds started at it (except
+     *			: for the special case at the start of a script.)
+     * atCmdStart == 0	: The last instruction was something else.  We need
+     *			: to emit INST_START_CMD here.
     */

    switch (envPtr->atCmdStart) {
@@ -1986,7 +1988,7 @@ CompileCmdCompileProc(
    if (TCL_OK == TclAttemptCompileProc(interp, parsePtr, 1, cmdPtr, envPtr)) {
 	if (incrOffset >= 0) {
 	    /*
-	     * Command compiled succesfully.  Increment the number of
+	     * We successfully compiled a command.  Increment the number of
 	     * commands that start at the currently active INST_START_CMD.
 	     */

@@ -2055,7 +2057,7 @@ CompileCommandTokens(

    /*
     * TIP #280. Scan the words and compute the extended location information.
-     * At first the map first contains full per-word line information for use by the
+     * The map first contain full per-word line information for use by the
     * compiler. This is later replaced by a reduced form which signals
     * non-literal words, stored in 'wlines'.
     */
@@ -2097,7 +2099,7 @@ CompileCommandTokens(
 	}
    }

-    /* If cmdPtr != NULL, try to call cmdPtr->compileProc */
+    /* If cmdPtr != NULL, we will try to call cmdPtr->compileProc */
    if (cmdPtr) {
 	code = CompileCmdCompileProc(interp, parsePtr, cmdPtr, envPtr);
    }
@@ -2124,8 +2126,8 @@ CompileCommandTokens(
 	    (envPtr->codeNext-envPtr->codeStart) - startCodeOffset);

    /*
-     * TIP #280: Free the full form of per-word line data and insert the
-     * reduced form now.
+     * TIP #280: Free full form of per-word line data and insert the reduced
+     * form now
     */

    envPtr->line = cmdLine;
@@ -2163,10 +2165,10 @@ TclCompileScript(
    }
    /*
     * Check depth to avoid overflow of the C execution stack by too many
-     * nested calls of TclCompileScript, considering interp recursionlimit.
-     * Use factor 5/4 (1.25) to avoid being too mistaken when recognizing the
-     * limit during "mixed" evaluation and compilation process (nested
-     * eval+compile) and is good enough for default recursionlimit (1000).
+     * nested calls of TclCompileScript (considering interp recursionlimit).
+     * Factor 5/4 (1.25) is used to avoid too mistaken limit recognition
+     * during "mixed" evaluation and compilation process (nested eval+compile)
+     * and is good enough for default recursionlimit (1000).
     */
    if (iPtr->numLevels / 5 > iPtr->maxNestingDepth / 4) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
@@ -2309,8 +2311,8 @@ TclCompileScript(
 *
 * TclCompileTokens --
 *
- *	Given an array of tokens parsed from a Tcl command, e.g. the tokens
- *	that make up a word, emits instructions to evaluate the
+ *	Given an array of tokens parsed from a Tcl command (e.g., the tokens
+ *	that make up a word) this procedure emits instructions to evaluate the
 *	tokens and concatenate their values to form a single result value on
 *	the interpreter's runtime evaluation stack.
 *
@@ -2415,16 +2417,18 @@ TclCompileTokens(
    int depth = TclGetStackDepth(envPtr);

    /*
-     * if this is actually a literal, handle continuation lines by
-     * preallocating a small table to store the locations of any continuation
-     * lines we find in this literal.  The table is extended if needed.
+     * For the handling of continuation lines in literals we first check if
+     * this is actually a literal. For if not we can forego the additional
+     * processing. Otherwise we pre-allocate a small table to store the
+     * locations of all continuation lines we find in this literal, if any.
+     * The table is extended if needed.
     *
-     * Note: In contrast with the analagous code in 'TclSubstTokens()' the
-     * 'adjust' variable seems unneeded here.  The code which merges
-     * continuation line information of multiple words which concat'd at
-     * runtime also seems unneeded. Either that or I have not managed to find a
-     * test case for these two possibilities yet.  It might be a difference
-     * between compile- versus run-time processing.
+     * Note: Different to the equivalent code in function 'TclSubstTokens()'
+     * (see file "tclParse.c") we do not seem to need the 'adjust' variable.
+     * We also do not seem to need code which merges continuation line
+     * information of multiple words which concat'd at runtime. Either that or
+     * I have not managed to find a test case for these two possibilities yet.
+     * It might be a difference between compile- versus run-time processing.
     */

    numCL = 0;
@@ -2460,17 +2464,18 @@ TclCompileTokens(
 	    Tcl_DStringAppend(&textBuffer, buffer, length);

 	    /*
-	     * If the identified backslash sequence is in a literal and
-	     * represented a continuation line, compute and store its
+	     * If the backslash sequence we found is in a literal, and
+	     * represented a continuation line, we compute and store its
 	     * location (as char offset to the beginning of the _result_
 	     * script). We may have to extend the table of locations.
 	     *
-	     * The continuation line information is relevant even if the word
-	     * being processed is not a literal, as it can affect nested
-	     * commands. See the branch below for TCL_TOKEN_COMMAND, where the
-	     * adjustment being tracked here is taken into account. The good
-	     * thing is a table of everything is not needed, just the number of
-	     * lines to to add as correction.
+	     * Note that the continuation line information is relevant even if
+	     * the word we are processing is not a literal, as it can affect
+	     * nested commands. See the branch for TCL_TOKEN_COMMAND below,
+	     * where the adjustment we are tracking here is taken into
+	     * account. The good thing is that we do not need a table of
+	     * everything, just the number of lines we have to add as
+	     * correction.
 	     */

 	    if ((length == 1) && (buffer[0] == ' ') &&
@@ -2596,13 +2601,13 @@ TclCompileTokens(
 * TclCompileCmdWord --
 *
 *	Given an array of parse tokens for a word containing one or more Tcl
- *	commands, emits inline instructions to execute them.  In contrast with
- *	TclCompileTokens, a simple word such as a loop body enclosed in braces
- *	is not just pushed as a string, but is itself parsed into tokens and
- *	compiled.
+ *	commands, emit inline instructions to execute them. This procedure
+ *	differs from TclCompileTokens in that a simple word such as a loop
+ *	body enclosed in braces is not just pushed as a string, but is itself
+ *	parsed into tokens and compiled.
 *
 * Results:
- *	A standard Tcl result. If an error occurs, an
+ *	The return value is a standard Tcl result. If an error occurs, an
 *	error message is left in the interpreter's result.
 *
 * Side effects:
@@ -2622,16 +2627,16 @@ TclCompileCmdWord(
 {
    if ((count == 1) && (tokenPtr->type == TCL_TOKEN_TEXT)) {
 	/*
-	 * The common case that there is a single text token. Compile it
+	 * Handle the common case: if there is a single text token, compile it
 	 * into an inline sequence of instructions.
 	 */

 	TclCompileScript(interp, tokenPtr->start, tokenPtr->size, envPtr);
    } else {
 	/*
-	 * Either there are multiple tokens, or the single token involves
-	 * substitutions. Emit instructions to invoke the eval command
-	 * procedure at runtime on the result of evaluating the tokens.
+	 * Multiple tokens or the single token involves substitutions. Emit
+	 * instructions to invoke the eval command procedure at runtime on the
+	 * result of evaluating the tokens.
 	 */

 	TclCompileTokens(interp, tokenPtr, count, envPtr);
@@ -2645,12 +2650,13 @@ TclCompileCmdWord(
 * TclCompileExprWords --
 *
 *	Given an array of parse tokens representing one or more words that
- *	contain a Tcl expression, emits inline instructions to execute the
- *	expression. In contrast with TclCompileExpr, supports Tcl's two-level
- *	substitution semantics for an expression that appears as command words.
+ *	contain a Tcl expression, emit inline instructions to execute the
+ *	expression. This procedure differs from TclCompileExpr in that it
+ *	supports Tcl's two-level substitution semantics for expressions that
+ *	appear as command words.
 *
 * Results:
- *	A standard Tcl result. If an error occurs, an
+ *	The return value is a standard Tcl result. If an error occurs, an
 *	error message is left in the interpreter's result.
 *
 * Side effects:
@@ -2712,10 +2718,10 @@ TclCompileExprWords(
 *
 * TclCompileNoOp --
 *
- *	Compiles no-op's
+ *	Function called to compile no-op's
 *
 * Results:
- *	TCL_OK if completion was successful.
+ *	The return value is TCL_OK, indicating successful compilation.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute a no-op at runtime. No
@@ -2754,14 +2760,14 @@ TclCompileNoOp(
 *
 * TclInitByteCodeObj --
 *
- *	Creates a ByteCode structure and initializes it from a CompileEnv
+ *	Create a ByteCode structure and initialize it from a CompileEnv
 *	compilation environment structure. The ByteCode structure is smaller
 *	and contains just that information needed to execute the bytecode
 *	instructions resulting from compiling a Tcl script. The resulting
 *	structure is placed in the specified object.
 *
 * Results:
- *	A newly-constructed ByteCode object is stored in the internal
+ *	A newly constructed ByteCode object is stored in the internal
 *	representation of the objPtr.
 *
 * Side effects:
@@ -2784,7 +2790,7 @@ PreventCycle(
    for (i = 0;  i < envPtr->literalArrayNext; i++) {
 	if (objPtr == TclFetchLiteral(envPtr, i)) {
 	    /*
-	     * Prevent circular reference where the bytecode internalrep of
+	     * Prevent circular reference where the bytecode intrep of
 	     * a value contains a literal which is that same value.
 	     * If this is allowed to happen, refcount decrements may not
 	     * reach zero, and memory may leak.  Bugs 467523, 3357771
@@ -2792,7 +2798,7 @@ PreventCycle(
 	     * NOTE:  [Bugs 3392070, 3389764] We make a copy based completely
 	     * on the string value, and do not call Tcl_DuplicateObj() so we
             * can be sure we do not have any lingering cycles hiding in
-	     * the internalrep.
+	     * the intrep.
 	     */
 	    int numBytes;
 	    const char *bytes = TclGetStringFromObj(objPtr, &numBytes);
@@ -2963,7 +2969,7 @@ TclInitByteCodeObj(
     * by making its internal rep point to the just compiled ByteCode.
     */

-    ByteCodeSetInternalRep(objPtr, typePtr, codePtr);
+    ByteCodeSetIntRep(objPtr, typePtr, codePtr);
    return codePtr;
 }

@@ -3096,15 +3102,16 @@ TclFindCompiledLocal(
 *
 * TclExpandCodeArray --
 *
- *	Uses malloc to allocate more storage for a CompileEnv's code array.
+ *	Procedure that uses malloc to allocate more storage for a CompileEnv's
+ *	code array.
 *
 * Results:
 *	None.
 *
 * Side effects:
- *	The size of the bytecode array is doubled. If envPtr->mallocedCodeArray
- *	is non-zero the old array is freed. Byte codes are copied from the old
- *	array to the new one.
+ *	The byte code array in *envPtr is reallocated to a new array of double
+ *	the size, and if envPtr->mallocedCodeArray is non-zero the old array
+ *	is freed. Byte codes are copied from the old array to the new one.
 *
 *----------------------------------------------------------------------
 */
@@ -3131,8 +3138,8 @@ TclExpandCodeArray(
 	envPtr->codeStart = (unsigned char *)ckrealloc(envPtr->codeStart, newBytes);
    } else {
 	/*
-     * envPtr->exceptArrayPtr isn't a Tcl_Alloc'd pointer, so
-     * perform the equivalent of Tcl_Realloc directly.
+	 * envPtr->codeStart isn't a ckalloc'd pointer, so we must code a
+	 * ckrealloc equivalent for ourselves.
 	 */

 	unsigned char *newPtr = (unsigned char *)ckalloc(newBytes);
@@ -3448,7 +3455,7 @@ TclCreateExceptRange(
 * TclGetInnermostExceptionRange --
 *
 *	Returns the innermost exception range that covers the current code
- *	creation point, and optionally the stack depth that is expected at
+ *	creation point, and (optionally) the stack depth that is expected at
 *	that point. Relies on the fact that the range has a numCodeBytes = -1
 *	when it is being populated and that inner ranges come after outer
 *	ranges.
@@ -3490,7 +3497,7 @@ TclGetInnermostExceptionRange(
 *
 *	Adds a place that wants to break/continue to the loop exception range
 *	tracking that will be fixed up once the loop can be finalized. These
- *	functions generate an INST_JUMP4 that is fixed up during the
+ *	functions will generate an INST_JUMP4 that will be fixed up during the
 *	loop finalization.
 *
 * ---------------------------------------------------------------------
@@ -3554,8 +3561,8 @@ TclAddLoopContinueFixup(
 *
 * TclCleanupStackForBreakContinue --
 *
- *	Removes the extra elements from the auxiliary stack and the main stack.
- *	How this is done depends on whether there are any elements on
+ *	Ditch the extra elements from the auxiliary stack and the main stack.
+ *	How to do this exactly depends on whether there are any elements on
 *	the auxiliary stack to pop.
 *
 * ---------------------------------------------------------------------
@@ -3625,7 +3632,7 @@ StartExpanding(
 	}

 	/*
-	 * Adequate condition: loops further out and exceptions further in
+	 * Adequate condition: further out loops and further in exceptions
 	 * don't actually need this information.
 	 */

@@ -3635,7 +3642,7 @@ StartExpanding(
    }

    /*
-     * One more expansion is now being processed on the auxiliary stack.
+     * There's now one more expansion being processed on the auxiliary stack.
     */

    envPtr->expandCount++;
@@ -3648,7 +3655,7 @@ StartExpanding(
 *
 *	Finalizes a loop exception range, binding the registered [break] and
 *	[continue] implementations so that they jump to the correct place.
- *	This must be called only after *all* the exception range
+ *	Note that this must only be called after *all* the exception range
 *	target offsets have been set.
 *
 * ---------------------------------------------------------------------
@@ -3719,17 +3726,21 @@ TclFinalizeLoopExceptionRange(
 *
 * TclCreateAuxData --
 *
- *	Allocates and initializes a new AuxData structure in a
+ *	Procedure that allocates and initializes a new AuxData structure in a
 *	CompileEnv's array of compilation auxiliary data records. These
 *	AuxData records hold information created during compilation by
 *	CompileProcs and used by instructions during execution.
 *
 * Results:
- *	The index of the newly-created AuxData structure in the array.
+ *	Returns the index for the newly created AuxData structure.
 *
 * Side effects:
- *	If there is not enough room in the CompileEnv's AuxData array, its size
- *	is doubled.
+ *	If there is not enough room in the CompileEnv's AuxData array, the
+ *	AuxData array in expanded: a new array of double the size is
+ *	allocated, if envPtr->mallocedAuxDataArray is non-zero the old array
+ *	is freed, and AuxData entries are copied from the old array to the new
+ *	one.
+ *
 *----------------------------------------------------------------------
 */

@@ -3817,7 +3828,8 @@ TclInitJumpFixupArray(
 *
 * TclExpandJumpFixupArray --
 *
- *	Uses malloc to allocate more storage for a jump fixup array.
+ *	Procedure that uses malloc to allocate more storage for a jump fixup
+ *	array.
 *
 * Results:
 *	None.
@@ -3896,11 +3908,10 @@ TclFreeJumpFixupArray(
 *
 * TclEmitForwardJump --
 *
- *	Emits a two-byte forward jump of kind "jumpType".  Also initializes a
- *	JumpFixup record with information about the jump.  Since may later be
- *	necessary to increase the size of the jump instruction to five bytes if
- *	the jump target is more than, say, 127 bytes away.
- *
+ *	Procedure to emit a two-byte forward jump of kind "jumpType". Since
+ *	the jump may later have to be grown to five bytes if the jump target
+ *	is more than, say, 127 bytes away, this procedure also initializes a
+ *	JumpFixup record with information about the jump.
 *
 * Results:
 *	None.
@@ -3955,17 +3966,16 @@ TclEmitForwardJump(
 *
 * TclFixupForwardJump --
 *
- *	Modifies a previously-emitted forward jump to jump a specified number
- *	of bytes, "jumpDist". If necessary, the size of the jump instruction is
- *	increased from two to five bytes.  This is done if the jump distance is
- *	greater than "distThreshold" (normally 127 bytes). The jump is
- *	described by a JumpFixup record previously initialized by
- *	TclEmitForwardJump.
+ *	Procedure that updates a previously-emitted forward jump to jump a
+ *	specified number of bytes, "jumpDist". If necessary, the jump is grown
+ *	from two to five bytes; this is done if the jump distance is greater
+ *	than "distThreshold" (normally 127 bytes). The jump is described by a
+ *	JumpFixup record previously initialized by TclEmitForwardJump.
 *
 * Results:
- *	1 if the jump was grown and subsequent instructions had to be moved, or
- *	0 otherwsie. This allows callers to update any additional code offsets
- *	they may hold.
+ *	1 if the jump was grown and subsequent instructions had to be moved;
+ *	otherwise 0. This result is returned to allow callers to update any
+ *	additional code offsets they may hold.
 *
 * Side effects:
 *	The jump may be grown and subsequent instructions moved. If this
@@ -4008,10 +4018,10 @@ TclFixupForwardJump(
    }

    /*
-     * Increase the size of the jump instruction, and then move subsequent
-     * instructions down.  Expanding the space for generated instructions means
-     * that code addresses might change.  Be careful about updating any of
-     * these addresses held in variables.
+     * We must grow the jump then move subsequent instructions down. Note that
+     * if we expand the space for generated instructions, code addresses might
+     * change; be careful about updating any of these addresses held in
+     * variables.
     */

    if ((envPtr->codeNext + 3) > envPtr->codeEnd) {
@@ -4095,7 +4105,7 @@ TclFixupForwardJump(
 *
 * TclEmitInvoke --
 *
- *	Emits one of the invoke-related instructions, wrapping it if necessary
+ *	Emit one of the invoke-related instructions, wrapping it if necessary
 *	in code that ensures that any break or continue operation passing
 *	through it gets the stack unwinding correct, converting it into an
 *	internal jump if in an appropriate context.
@@ -4105,7 +4115,7 @@ TclFixupForwardJump(
 *
 * Side effects:
 *	Issues the jump with all correct stack management. May create another
- *	loop exception range.  Pointers to ExceptionRange and ExceptionAux
+ *	loop exception range; pointers to ExceptionRange and ExceptionAux
 *	structures should not be held across this call.
 *
 *----------------------------------------------------------------------
@@ -4163,11 +4173,12 @@ TclEmitInvoke(
    va_end(argList);

    /*
-     * If the exceptions is for break or continue handle it with special
-     * handling exception range so the stack may be correctly unwound.
+     * Determine if we need to handle break and continue exceptions with a
+     * special handling exception range (so that we can correctly unwind the
+     * stack).
     *
-     * These must be done separately since they can be different, especially
-     * for calls from inside a [for] increment clause.
+     * These must be done separately; they can be different (especially for
+     * calls from inside a [for] increment clause).
     */

    rangePtr = TclGetInnermostExceptionRange(envPtr, TCL_CONTINUE,
@@ -4387,16 +4398,16 @@ GetCmdLocEncodingSize(
 *
 * EncodeCmdLocMap --
 *
- *	Encodes the command location information for some compiled code into a
+ *	Encode the command location information for some compiled code into a
 *	ByteCode structure. The encoded command location map is stored as
- *	three-adjacent-byte sequences.
+ *	three adjacent byte sequences.
 *
 * Results:
- *	A pointer to the first byte after the encoded command location
+ *	Pointer to the first byte after the encoded command location
 *	information.
 *
 * Side effects:
- *	Stores encoded information into the block of memory headed by
+ *	The encoded information is stored into the block of memory headed by
 *	codePtr. Also records pointers to the start of the four byte sequences
 *	in fields in codePtr's ByteCode header structure.
 *
@@ -4511,9 +4522,9 @@ EncodeCmdLocMap(
 *
 * RecordByteCodeStats --
 *
- *	Accumulates compilation-related statistics for each newly-compiled
- *	ByteCode. Called by the TclInitByteCodeObj when Tcl is compiled with
- *	the -DTCL_COMPILE_STATS flag
+ *	Accumulates various compilation-related statistics for each newly
+ *	compiled ByteCode. Called by the TclInitByteCodeObj when Tcl is
+ *	compiled with the -DTCL_COMPILE_STATS flag
 *
 * Results:
 *	None.
@@ -217,9 +217,9 @@ typedef struct ExtCmdLoc {
 * the AuxData structure.
 */

-typedef void      *(AuxDataDupProc)  (void *clientData);
-typedef void	   (AuxDataFreeProc) (void *clientData);
-typedef void	   (AuxDataPrintProc)(void *clientData,
+typedef ClientData (AuxDataDupProc)  (ClientData clientData);
+typedef void	   (AuxDataFreeProc) (ClientData clientData);
+typedef void	   (AuxDataPrintProc)(ClientData clientData,
 			    Tcl_Obj *appendObj, struct ByteCode *codePtr,
 			    unsigned int pcOffset);

@@ -395,21 +395,17 @@ typedef struct CompileEnv {
 * CmdLocation map, and the compilation AuxData array.
 */

-/*
- * A PRECOMPILED bytecode struct is one that was generated from a compiled
- * image rather than implicitly compiled from source
- */
-
-#define TCL_BYTECODE_PRECOMPILED		0x0001
-
-/*
- * When a bytecode is compiled, interp or namespace resolvers have not been
- * applied yet: this is indicated by the TCL_BYTECODE_RESOLVE_VARS flag.
- */
-
-#define TCL_BYTECODE_RESOLVE_VARS		0x0002
-
-#define TCL_BYTECODE_RECOMPILE			0x0004
+enum BytecodeFlags {
+    TCL_BYTECODE_PRECOMPILED = 0x0001,
+				/* A PRECOMPILED bytecode struct is one that
+				 * was generated from a compiled image rather
+				 * than implicitly compiled from source. */
+    TCL_BYTECODE_RESOLVE_VARS = 0x0002,
+				/* When a bytecode is compiled, interp or
+				 * namespace resolvers have not been applied
+				 * yet: this is indicated by the this flag. */
+    TCL_BYTECODE_RECOMPILE = 0x0004
+};

 typedef struct ByteCode {
    TclHandle interpHandle;	/* Handle for interpreter containing the
@@ -515,20 +511,20 @@ typedef struct ByteCode {
 #endif /* TCL_COMPILE_STATS */
 } ByteCode;

-#define ByteCodeSetInternalRep(objPtr, typePtr, codePtr)			\
+#define ByteCodeSetIntRep(objPtr, typePtr, codePtr)			\
    do {								\
-	Tcl_ObjInternalRep ir;						\
+	Tcl_ObjIntRep ir;						\
 	ir.twoPtrValue.ptr1 = (codePtr);				\
 	ir.twoPtrValue.ptr2 = NULL;					\
-	Tcl_StoreInternalRep((objPtr), (typePtr), &ir);			\
+	Tcl_StoreIntRep((objPtr), (typePtr), &ir);			\
    } while (0)



-#define ByteCodeGetInternalRep(objPtr, typePtr, codePtr)			\
+#define ByteCodeGetIntRep(objPtr, typePtr, codePtr)			\
    do {								\
-	const Tcl_ObjInternalRep *irPtr;					\
-	irPtr = TclFetchInternalRep((objPtr), (typePtr));			\
+	const Tcl_ObjIntRep *irPtr;					\
+	irPtr = TclFetchIntRep((objPtr), (typePtr));			\
 	(codePtr) = irPtr ? (ByteCode*)irPtr->twoPtrValue.ptr1 : NULL;		\
    } while (0)

@@ -540,316 +536,306 @@ typedef struct ByteCode {
 * tclExecute.c.
 */

-/* Opcodes 0 to 9 */
-#define INST_DONE			0
-#define INST_PUSH1			1
-#define INST_PUSH4			2
-#define INST_POP			3
-#define INST_DUP			4
-#define INST_STR_CONCAT1		5
-#define INST_INVOKE_STK1		6
-#define INST_INVOKE_STK4		7
-#define INST_EVAL_STK			8
-#define INST_EXPR_STK			9
+#ifdef _BUILD_TCL_EXECUTE
+#define IS_DEPRECATED /* nothing */
+#else
+#define IS_DEPRECATED TCL_DEPRECATED_API("no longer used")
+#endif /* _BUILD_TCL_EXECUTE*/

-/* Opcodes 10 to 23 */
-#define INST_LOAD_SCALAR1		10
-#define INST_LOAD_SCALAR4		11
-#define INST_LOAD_SCALAR_STK		12
-#define INST_LOAD_ARRAY1		13
-#define INST_LOAD_ARRAY4		14
-#define INST_LOAD_ARRAY_STK		15
-#define INST_LOAD_STK			16
-#define INST_STORE_SCALAR1		17
-#define INST_STORE_SCALAR4		18
-#define INST_STORE_SCALAR_STK		19
-#define INST_STORE_ARRAY1		20
-#define INST_STORE_ARRAY4		21
-#define INST_STORE_ARRAY_STK		22
-#define INST_STORE_STK			23
+enum TclBytecodeOpcodes {
+    /* Opcodes 0 to 9: Basic operations */
+    INST_DONE = 0,
+    INST_PUSH1 = 1,
+    INST_PUSH4 = 2,
+    INST_POP = 3,
+    INST_DUP = 4,
+    INST_STR_CONCAT1 = 5,
+    INST_INVOKE_STK1 = 6,
+    INST_INVOKE_STK4 = 7,
+    INST_EVAL_STK = 8,
+    INST_EXPR_STK = 9,

-/* Opcodes 24 to 33 */
-#define INST_INCR_SCALAR1		24
-#define INST_INCR_SCALAR_STK		25
-#define INST_INCR_ARRAY1		26
-#define INST_INCR_ARRAY_STK		27
-#define INST_INCR_STK			28
-#define INST_INCR_SCALAR1_IMM		29
-#define INST_INCR_SCALAR_STK_IMM	30
-#define INST_INCR_ARRAY1_IMM		31
-#define INST_INCR_ARRAY_STK_IMM		32
-#define INST_INCR_STK_IMM		33
+    /* Opcodes 10 to 23: LOAD and STORE */
+    INST_LOAD_SCALAR1 = 10,
+    INST_LOAD_SCALAR4 = 11,
+    INST_LOAD_SCALAR_STK = 12,
+    INST_LOAD_ARRAY1 = 13,
+    INST_LOAD_ARRAY4 = 14,
+    INST_LOAD_ARRAY_STK = 15,
+    INST_LOAD_STK = 16,
+    INST_STORE_SCALAR1 = 17,
+    INST_STORE_SCALAR4 = 18,
+    INST_STORE_SCALAR_STK = 19,
+    INST_STORE_ARRAY1 = 20,
+    INST_STORE_ARRAY4 = 21,
+    INST_STORE_ARRAY_STK = 22,
+    INST_STORE_STK = 23,

-/* Opcodes 34 to 39 */
-#define INST_JUMP1			34
-#define INST_JUMP4			35
-#define INST_JUMP_TRUE1			36
-#define INST_JUMP_TRUE4			37
-#define INST_JUMP_FALSE1		38
-#define INST_JUMP_FALSE4		39
+    /* Opcodes 24 to 33: INCR */
+    INST_INCR_SCALAR1 = 24,
+    INST_INCR_SCALAR_STK = 25,
+    INST_INCR_ARRAY1 = 26,
+    INST_INCR_ARRAY_STK = 27,
+    INST_INCR_STK = 28,
+    INST_INCR_SCALAR1_IMM = 29,
+    INST_INCR_SCALAR_STK_IMM = 30,
+    INST_INCR_ARRAY1_IMM = 31,
+    INST_INCR_ARRAY_STK_IMM = 32,
+    INST_INCR_STK_IMM = 33,

-/* Opcodes 40 to 64 */
-#define INST_LOR			40
-#define INST_LAND			41
-#define INST_BITOR			42
-#define INST_BITXOR			43
-#define INST_BITAND			44
-#define INST_EQ				45
-#define INST_NEQ			46
-#define INST_LT				47
-#define INST_GT				48
-#define INST_LE				49
-#define INST_GE				50
-#define INST_LSHIFT			51
-#define INST_RSHIFT			52
-#define INST_ADD			53
-#define INST_SUB			54
-#define INST_MULT			55
-#define INST_DIV			56
-#define INST_MOD			57
-#define INST_UPLUS			58
-#define INST_UMINUS			59
-#define INST_BITNOT			60
-#define INST_LNOT			61
-#define INST_CALL_BUILTIN_FUNC1		62
-#define INST_CALL_FUNC1			63
-#define INST_TRY_CVT_TO_NUMERIC		64
+    /* Opcodes 34 to 39: JUMP */
+    INST_JUMP1 = 34,
+    INST_JUMP4 = 35,
+    INST_JUMP_TRUE1 = 36,
+    INST_JUMP_TRUE4 = 37,
+    INST_JUMP_FALSE1 = 38,
+    INST_JUMP_FALSE4 = 39,

-/* Opcodes 65 to 66 */
-#define INST_BREAK			65
-#define INST_CONTINUE			66
+    /* Opcodes 40 to 64: Expression implementation */
+    INST_LOR = 40,
+    INST_LAND = 41,
+    INST_BITOR = 42,
+    INST_BITXOR = 43,
+    INST_BITAND = 44,
+    INST_EQ = 45,
+    INST_NEQ = 46,
+    INST_LT = 47,
+    INST_GT = 48,
+    INST_LE = 49,
+    INST_GE = 50,
+    INST_LSHIFT = 51,
+    INST_RSHIFT = 52,
+    INST_ADD = 53,
+    INST_SUB = 54,
+    INST_MULT = 55,
+    INST_DIV = 56,
+    INST_MOD = 57,
+    INST_UPLUS = 58,
+    INST_UMINUS = 59,
+    INST_BITNOT = 60,
+    INST_LNOT = 61,
+#ifndef NO_DEPRECATED_BYTECODES
+    INST_CALL_BUILTIN_FUNC1 IS_DEPRECATED = 62,
+    INST_CALL_FUNC1 IS_DEPRECATED = 63,
+#endif
+    INST_TRY_CVT_TO_NUMERIC = 64,

-/* Opcodes 67 to 68 */
-#define INST_FOREACH_START4		67 /* DEPRECATED */
-#define INST_FOREACH_STEP4		68 /* DEPRECATED */
+    /* Opcodes 65 to 66: Local exceptions */
+    INST_BREAK = 65,
+    INST_CONTINUE = 66,

-/* Opcodes 69 to 72 */
-#define INST_BEGIN_CATCH4		69
-#define INST_END_CATCH			70
-#define INST_PUSH_RESULT		71
-#define INST_PUSH_RETURN_CODE		72
+#ifndef NO_DEPRECATED_BYTECODES
+    /* Opcodes 67 to 68: Old Foreach */
+    INST_FOREACH_START4 IS_DEPRECATED = 67,
+    INST_FOREACH_STEP4 IS_DEPRECATED = 68,
+#endif

-/* Opcodes 73 to 78 */
-#define INST_STR_EQ			73
-#define INST_STR_NEQ			74
-#define INST_STR_CMP			75
-#define INST_STR_LEN			76
-#define INST_STR_INDEX			77
-#define INST_STR_MATCH			78
+    /* Opcodes 69 to 72: Catch */
+    INST_BEGIN_CATCH4 = 69,
+    INST_END_CATCH = 70,
+    INST_PUSH_RESULT = 71,
+    INST_PUSH_RETURN_CODE = 72,

-/* Opcodes 78 to 81 */
-#define INST_LIST			79
-#define INST_LIST_INDEX			80
-#define INST_LIST_LENGTH		81
+    /* Opcodes 73 to 78: misc string ops */
+    INST_STR_EQ = 73,
+    INST_STR_NEQ = 74,
+    INST_STR_CMP = 75,
+    INST_STR_LEN = 76,
+    INST_STR_INDEX = 77,
+    INST_STR_MATCH = 78,

-/* Opcodes 82 to 87 */
-#define INST_APPEND_SCALAR1		82
-#define INST_APPEND_SCALAR4		83
-#define INST_APPEND_ARRAY1		84
-#define INST_APPEND_ARRAY4		85
-#define INST_APPEND_ARRAY_STK		86
-#define INST_APPEND_STK			87
+    /* Opcodes 78 to 81: misc list ops */
+    INST_LIST = 79,
+    INST_LIST_INDEX = 80,
+    INST_LIST_LENGTH = 81,

-/* Opcodes 88 to 93 */
-#define INST_LAPPEND_SCALAR1		88
-#define INST_LAPPEND_SCALAR4		89
-#define INST_LAPPEND_ARRAY1		90
-#define INST_LAPPEND_ARRAY4		91
-#define INST_LAPPEND_ARRAY_STK		92
-#define INST_LAPPEND_STK		93
+    /* Opcodes 82 to 87: APPEND */
+    INST_APPEND_SCALAR1 = 82,
+    INST_APPEND_SCALAR4 = 83,
+    INST_APPEND_ARRAY1 = 84,
+    INST_APPEND_ARRAY4 = 85,
+    INST_APPEND_ARRAY_STK = 86,
+    INST_APPEND_STK = 87,

-/* TIP #22 - LINDEX operator with flat arg list */
+    /* Opcodes 88 to 93: LAPPEND */
+    INST_LAPPEND_SCALAR1 = 88,
+    INST_LAPPEND_SCALAR4 = 89,
+    INST_LAPPEND_ARRAY1 = 90,
+    INST_LAPPEND_ARRAY4 = 91,
+    INST_LAPPEND_ARRAY_STK = 92,
+    INST_LAPPEND_STK = 93,

-#define INST_LIST_INDEX_MULTI		94
+    /* TIP #22 - LINDEX operator with flat arg list */
+    INST_LIST_INDEX_MULTI = 94,

-/*
- * TIP #33 - 'lset' command. Code gen also required a Forth-like
- *	     OVER operation.
- */
+    /* TIP #33 - 'lset' command. Code gen also required a Forth-like OVER
+     * operation. */
+    INST_OVER = 95,
+    INST_LSET_LIST = 96,
+    INST_LSET_FLAT = 97,

-#define INST_OVER			95
-#define INST_LSET_LIST			96
-#define INST_LSET_FLAT			97
+    /* TIP#90 - 'return' command. */
+    INST_RETURN_IMM = 98,

-/* TIP#90 - 'return' command. */
+    /* TIP#123 - exponentiation operator. */
+    INST_EXPON = 99,

-#define INST_RETURN_IMM			98
+    /* TIP #157 - {*}... (word expansion) language syntax support. */
+    INST_EXPAND_START = 100,
+    INST_EXPAND_STKTOP = 101,
+    INST_INVOKE_EXPANDED = 102,

-/* TIP#123 - exponentiation operator. */
+    /* TIP #57 - 'lassign' command. Code generation requires immediate LINDEX
+     * and LRANGE operators. */
+    INST_LIST_INDEX_IMM = 103,
+    INST_LIST_RANGE_IMM = 104,

-#define INST_EXPON			99
+    INST_START_CMD = 105,

-/* TIP #157 - {*}... (word expansion) language syntax support. */
+    INST_LIST_IN = 106,
+    INST_LIST_NOT_IN = 107,

-#define INST_EXPAND_START		100
-#define INST_EXPAND_STKTOP		101
-#define INST_INVOKE_EXPANDED		102
+    INST_PUSH_RETURN_OPTIONS = 108,
+    INST_RETURN_STK = 109,

-/*
- * TIP #57 - 'lassign' command. Code generation requires immediate
- *	     LINDEX and LRANGE operators.
- */
+    /* Dictionary (TIP#111) related commands. */
+    INST_DICT_GET = 110,
+    INST_DICT_SET = 111,
+    INST_DICT_UNSET = 112,
+    INST_DICT_INCR_IMM = 113,
+    INST_DICT_APPEND = 114,
+    INST_DICT_LAPPEND = 115,
+    INST_DICT_FIRST = 116,
+    INST_DICT_NEXT = 117,
+    INST_DICT_DONE = 118,
+    INST_DICT_UPDATE_START = 119,
+    INST_DICT_UPDATE_END = 120,

-#define INST_LIST_INDEX_IMM		103
-#define INST_LIST_RANGE_IMM		104
+    /* Instruction to support jumps defined by tables (instead of the classic
+     * [switch] technique of chained comparisons). */
+    INST_JUMP_TABLE = 121,

-#define INST_START_CMD			105
+    /* Instructions to support compilation of global, variable, upvar and
+     * [namespace upvar]. */
+    INST_UPVAR = 122,
+    INST_NSUPVAR = 123,
+    INST_VARIABLE = 124,

-#define INST_LIST_IN			106
-#define INST_LIST_NOT_IN		107
+    /* Instruction to support compiling syntax error to bytecode */
+    INST_SYNTAX = 125,

-#define INST_PUSH_RETURN_OPTIONS	108
-#define INST_RETURN_STK			109
+    /* Instruction to reverse N items on top of stack */
+    INST_REVERSE = 126,

-/*
- * Dictionary (TIP#111) related commands.
- */
+    /* regexp instruction */
+    INST_REGEXP = 127,

-#define INST_DICT_GET			110
-#define INST_DICT_SET			111
-#define INST_DICT_UNSET			112
-#define INST_DICT_INCR_IMM		113
-#define INST_DICT_APPEND		114
-#define INST_DICT_LAPPEND		115
-#define INST_DICT_FIRST			116
-#define INST_DICT_NEXT			117
-#define INST_DICT_DONE			118
-#define INST_DICT_UPDATE_START		119
-#define INST_DICT_UPDATE_END		120
+    /* For [info exists] compilation */
+    INST_EXIST_SCALAR = 128,
+    INST_EXIST_ARRAY = 129,
+    INST_EXIST_ARRAY_STK = 130,
+    INST_EXIST_STK = 131,

-/*
- * Instruction to support jumps defined by tables (instead of the classic
- * [switch] technique of chained comparisons).
- */
+    /* For [subst] compilation */
+    INST_NOP = 132,
+    INST_RETURN_CODE_BRANCH = 133,

-#define INST_JUMP_TABLE			121
+    /* For [unset] compilation */
+    INST_UNSET_SCALAR = 134,
+    INST_UNSET_ARRAY = 135,
+    INST_UNSET_ARRAY_STK = 136,
+    INST_UNSET_STK = 137,

-/*
- * Instructions to support compilation of global, variable, upvar and
- * [namespace upvar].
- */
+    /* For [dict with], [dict exists], [dict create] and [dict merge] */
+    INST_DICT_EXPAND = 138,
+    INST_DICT_RECOMBINE_STK = 139,
+    INST_DICT_RECOMBINE_IMM = 140,
+    INST_DICT_EXISTS = 141,
+    INST_DICT_VERIFY = 142,

-#define INST_UPVAR			122
-#define INST_NSUPVAR			123
-#define INST_VARIABLE			124
+    /* For [string map] and [regsub] compilation */
+    INST_STR_MAP = 143,
+    INST_STR_FIND = 144,
+    INST_STR_FIND_LAST = 145,
+    INST_STR_RANGE_IMM = 146,
+    INST_STR_RANGE = 147,

-/* Instruction to support compiling syntax error to bytecode */
+    /* For operations to do with coroutines and other NRE-manipulators */
+    INST_YIELD = 148,
+    INST_COROUTINE_NAME = 149,
+    INST_TAILCALL = 150,

-#define INST_SYNTAX			125
+    /* For compilation of basic information operations */
+    INST_NS_CURRENT = 151,
+    INST_INFO_LEVEL_NUM = 152,
+    INST_INFO_LEVEL_ARGS = 153,
+    INST_RESOLVE_COMMAND = 154,

-/* Instruction to reverse N items on top of stack */
+    /* For compilation relating to TclOO */
+    INST_TCLOO_SELF = 155,
+    INST_TCLOO_CLASS = 156,
+    INST_TCLOO_NS = 157,
+    INST_TCLOO_IS_OBJECT = 158,

-#define INST_REVERSE			126
+    /* For compilation of [array] subcommands */
+    INST_ARRAY_EXISTS_STK = 159,
+    INST_ARRAY_EXISTS_IMM = 160,
+    INST_ARRAY_MAKE_STK = 161,
+    INST_ARRAY_MAKE_IMM = 162,

-/* regexp instruction */
+    INST_INVOKE_REPLACE = 163,

-#define INST_REGEXP			127
+    INST_LIST_CONCAT = 164,

-/* For [info exists] compilation */
-#define INST_EXIST_SCALAR		128
-#define INST_EXIST_ARRAY		129
-#define INST_EXIST_ARRAY_STK		130
-#define INST_EXIST_STK			131
+    INST_EXPAND_DROP = 165,

-/* For [subst] compilation */
-#define INST_NOP			132
-#define INST_RETURN_CODE_BRANCH		133
+    /* New foreach implementation */
+    INST_FOREACH_START = 166,
+    INST_FOREACH_STEP = 167,
+    INST_FOREACH_END = 168,
+    INST_LMAP_COLLECT = 169,

-/* For [unset] compilation */
-#define INST_UNSET_SCALAR		134
-#define INST_UNSET_ARRAY		135
-#define INST_UNSET_ARRAY_STK		136
-#define INST_UNSET_STK			137
+    /* For compilation of [string trim] and related */
+    INST_STR_TRIM = 170,
+    INST_STR_TRIM_LEFT = 171,
+    INST_STR_TRIM_RIGHT = 172,

-/* For [dict with], [dict exists], [dict create] and [dict merge] */
-#define INST_DICT_EXPAND		138
-#define INST_DICT_RECOMBINE_STK		139
-#define INST_DICT_RECOMBINE_IMM		140
-#define INST_DICT_EXISTS		141
-#define INST_DICT_VERIFY		142
+    INST_CONCAT_STK = 173,

-/* For [string map] and [regsub] compilation */
-#define INST_STR_MAP			143
-#define INST_STR_FIND			144
-#define INST_STR_FIND_LAST		145
-#define INST_STR_RANGE_IMM		146
-#define INST_STR_RANGE			147
+    INST_STR_UPPER = 174,
+    INST_STR_LOWER = 175,
+    INST_STR_TITLE = 176,
+    INST_STR_REPLACE = 177,

-/* For operations to do with coroutines and other NRE-manipulators */
-#define INST_YIELD			148
-#define INST_COROUTINE_NAME		149
-#define INST_TAILCALL			150
+    INST_ORIGIN_COMMAND = 178,

-/* For compilation of basic information operations */
-#define INST_NS_CURRENT			151
-#define INST_INFO_LEVEL_NUM		152
-#define INST_INFO_LEVEL_ARGS		153
-#define INST_RESOLVE_COMMAND		154
+    INST_TCLOO_NEXT = 179,
+    INST_TCLOO_NEXT_CLASS = 180,

-/* For compilation relating to TclOO */
-#define INST_TCLOO_SELF			155
-#define INST_TCLOO_CLASS		156
-#define INST_TCLOO_NS			157
-#define INST_TCLOO_IS_OBJECT		158
+    INST_YIELD_TO_INVOKE = 181,

-/* For compilation of [array] subcommands */
-#define INST_ARRAY_EXISTS_STK		159
-#define INST_ARRAY_EXISTS_IMM		160
-#define INST_ARRAY_MAKE_STK		161
-#define INST_ARRAY_MAKE_IMM		162
+    INST_NUM_TYPE = 182,
+    INST_TRY_CVT_TO_BOOLEAN = 183,
+    INST_STR_CLASS = 184,

-#define INST_INVOKE_REPLACE		163
+    INST_LAPPEND_LIST = 185,
+    INST_LAPPEND_LIST_ARRAY = 186,
+    INST_LAPPEND_LIST_ARRAY_STK = 187,
+    INST_LAPPEND_LIST_STK = 188,

-#define INST_LIST_CONCAT		164
+    INST_CLOCK_READ = 189,

-#define INST_EXPAND_DROP		165
+    INST_DICT_GET_DEF = 190,

-/* New foreach implementation */
-#define INST_FOREACH_START              166
-#define INST_FOREACH_STEP               167
-#define INST_FOREACH_END                168
-#define INST_LMAP_COLLECT               169
+    /* TIP 461 */
+    INST_STR_LT = 191,
+    INST_STR_GT = 192,
+    INST_STR_LE = 193,
+    INST_STR_GE = 194,

-/* For compilation of [string trim] and related */
-#define INST_STR_TRIM			170
-#define INST_STR_TRIM_LEFT		171
-#define INST_STR_TRIM_RIGHT		172
-
-#define INST_CONCAT_STK			173
-
-#define INST_STR_UPPER			174
-#define INST_STR_LOWER			175
-#define INST_STR_TITLE			176
-#define INST_STR_REPLACE		177
-
-#define INST_ORIGIN_COMMAND		178
-
-#define INST_TCLOO_NEXT			179
-#define INST_TCLOO_NEXT_CLASS		180
-
-#define INST_YIELD_TO_INVOKE		181
-
-#define INST_NUM_TYPE			182
-#define INST_TRY_CVT_TO_BOOLEAN		183
-#define INST_STR_CLASS			184
-
-#define INST_LAPPEND_LIST		185
-#define INST_LAPPEND_LIST_ARRAY		186
-#define INST_LAPPEND_LIST_ARRAY_STK	187
-#define INST_LAPPEND_LIST_STK		188
-
-#define INST_CLOCK_READ			189
-
-#define INST_DICT_GET_DEF		190
-
-/* TIP 461 */
-#define INST_STR_LT			191
-#define INST_STR_GT			192
-#define INST_STR_LE			193
-#define INST_STR_GE			194
-
-/* The last opcode */
-#define LAST_INST_OPCODE		194
+    /* The last opcode */
+    LAST_INST_OPCODE = 194
+};

 /*
 * Table describing the Tcl bytecode instructions: their name (for displaying
@@ -922,9 +908,8 @@ typedef enum InstStringClassType {
    STR_CLASS_UPPER,		/* Unicode upper-case alphabet characters. */
    STR_CLASS_WORD,		/* Unicode word (alphabetic, digit, connector
 				 * punctuation) characters. */
-    STR_CLASS_XDIGIT,		/* Characters that can be used as digits in
+    STR_CLASS_XDIGIT		/* Characters that can be used as digits in
 				 * hexadecimal numbers ([0-9A-Fa-f]). */
-    STR_CLASS_UNICODE		/* Unicode characters. */
 } InstStringClassType;

 typedef struct StringClassDesc {
@@ -1118,7 +1103,7 @@ MODULE_SCOPE void	TclCompileTokens(Tcl_Interp *interp,
 			    CompileEnv *envPtr);
 MODULE_SCOPE void	TclCompileVarSubst(Tcl_Interp *interp,
 			    Tcl_Token *tokenPtr, CompileEnv *envPtr);
-MODULE_SCOPE int	TclCreateAuxData(void *clientData,
+MODULE_SCOPE int	TclCreateAuxData(ClientData clientData,
 			    const AuxDataType *typePtr, CompileEnv *envPtr);
 MODULE_SCOPE int	TclCreateExceptRange(ExceptionRangeType type,
 			    CompileEnv *envPtr);
@@ -1192,16 +1177,16 @@ MODULE_SCOPE void	TclReleaseByteCode(ByteCode *codePtr);
 MODULE_SCOPE void	TclReleaseLiteral(Tcl_Interp *interp, Tcl_Obj *objPtr);
 MODULE_SCOPE void	TclInvalidateCmdLiteral(Tcl_Interp *interp,
 			    const char *name, Namespace *nsPtr);
-MODULE_SCOPE int	TclSingleOpCmd(void *clientData,
+MODULE_SCOPE int	TclSingleOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	TclSortingOpCmd(void *clientData,
+MODULE_SCOPE int	TclSortingOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	TclVariadicOpCmd(void *clientData,
+MODULE_SCOPE int	TclVariadicOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	TclNoIdentOpCmd(void *clientData,
+MODULE_SCOPE int	TclNoIdentOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 #ifdef TCL_COMPILE_DEBUG
@@ -1217,7 +1202,7 @@ MODULE_SCOPE void	TclLogCommandInfo(Tcl_Interp *interp,
 MODULE_SCOPE Tcl_Obj	*TclGetInnerContext(Tcl_Interp *interp,
 			    const unsigned char *pc, Tcl_Obj **tosPtr);
 MODULE_SCOPE Tcl_Obj	*TclNewInstNameObj(unsigned char inst);
-MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
+MODULE_SCOPE int	TclPushProcCallFrame(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[], int isLambda);

@@ -1232,15 +1217,17 @@ MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
 /*
 * Simplified form to access AuxData.
 *
- * void *TclFetchAuxData(CompileEng *envPtr, int index);
+ * ClientData TclFetchAuxData(CompileEng *envPtr, int index);
 */

 #define TclFetchAuxData(envPtr, index) \
    (envPtr)->auxDataArrayPtr[(index)].clientData

-#define LITERAL_ON_HEAP		0x01
-#define LITERAL_CMD_NAME	0x02
-#define LITERAL_UNSHARED	0x04
+enum LiteralFlags {
+    LITERAL_ON_HEAP = 0x01,
+    LITERAL_CMD_NAME = 0x02,
+    LITERAL_UNSHARED = 0x04
+};

 /*
 * Macro used to manually adjust the stack requirements; used in cases where
@@ -1557,9 +1544,9 @@ MODULE_SCOPE int	TclPushProcCallFrame(void *clientData,
 */

 #define PushLiteral(envPtr, string, length) \
-    TclEmitPush(TclRegisterLiteral((envPtr), (string), (length), 0), (envPtr))
+    TclEmitPush(TclRegisterLiteral(envPtr, string, length, 0), (envPtr))
 #define PushStringLiteral(envPtr, string) \
-    PushLiteral((envPtr), (string), (int) (sizeof(string "") - 1))
+    PushLiteral(envPtr, string, (int) (sizeof(string "") - 1))

 /*
 * Macro to advance to the next token; it is more mnemonic than the address
@@ -124,7 +124,7 @@ Tcl_Obj *		Tcl_DbNewBooleanObj(int boolValue, const char *file,
 				int line);
 /* 23 */
 EXTERN Tcl_Obj *	Tcl_DbNewByteArrayObj(const unsigned char *bytes,
-				int numBytes, const char *file, int line);
+				int length, const char *file, int line);
 /* 24 */
 EXTERN Tcl_Obj *	Tcl_DbNewDoubleObj(double doubleValue,
 				const char *file, int line);
@@ -152,7 +152,7 @@ EXTERN int		Tcl_GetBooleanFromObj(Tcl_Interp *interp,
 				Tcl_Obj *objPtr, int *boolPtr);
 /* 33 */
 EXTERN unsigned char *	Tcl_GetByteArrayFromObj(Tcl_Obj *objPtr,
-				int *numBytesPtr);
+				int *lengthPtr);
 /* 34 */
 EXTERN int		Tcl_GetDouble(Tcl_Interp *interp, const char *src,
 				double *doublePtr);
@@ -205,7 +205,7 @@ TCL_DEPRECATED("No longer in use, changed to macro")
 Tcl_Obj *		Tcl_NewBooleanObj(int boolValue);
 /* 50 */
 EXTERN Tcl_Obj *	Tcl_NewByteArrayObj(const unsigned char *bytes,
-				int numBytes);
+				int length);
 /* 51 */
 EXTERN Tcl_Obj *	Tcl_NewDoubleObj(double doubleValue);
 /* 52 */
@@ -224,10 +224,10 @@ EXTERN Tcl_Obj *	Tcl_NewStringObj(const char *bytes, int length);
 TCL_DEPRECATED("No longer in use, changed to macro")
 void			Tcl_SetBooleanObj(Tcl_Obj *objPtr, int boolValue);
 /* 58 */
-EXTERN unsigned char *	Tcl_SetByteArrayLength(Tcl_Obj *objPtr, int numBytes);
+EXTERN unsigned char *	Tcl_SetByteArrayLength(Tcl_Obj *objPtr, int length);
 /* 59 */
 EXTERN void		Tcl_SetByteArrayObj(Tcl_Obj *objPtr,
-				const unsigned char *bytes, int numBytes);
+				const unsigned char *bytes, int length);
 /* 60 */
 EXTERN void		Tcl_SetDoubleObj(Tcl_Obj *objPtr, double doubleValue);
 /* 61 */
@@ -1886,17 +1886,17 @@ EXTERN int		TclZipfs_MountBuffer(Tcl_Interp *interp,
 				const char *mountPoint, unsigned char *data,
 				size_t datalen, int copy);
 /* 636 */
-EXTERN void		Tcl_FreeInternalRep(Tcl_Obj *objPtr);
+EXTERN void		Tcl_FreeIntRep(Tcl_Obj *objPtr);
 /* 637 */
 EXTERN char *		Tcl_InitStringRep(Tcl_Obj *objPtr, const char *bytes,
 				unsigned int numBytes);
 /* 638 */
-EXTERN Tcl_ObjInternalRep * Tcl_FetchInternalRep(Tcl_Obj *objPtr,
+EXTERN Tcl_ObjIntRep *	Tcl_FetchIntRep(Tcl_Obj *objPtr,
 				const Tcl_ObjType *typePtr);
 /* 639 */
-EXTERN void		Tcl_StoreInternalRep(Tcl_Obj *objPtr,
+EXTERN void		Tcl_StoreIntRep(Tcl_Obj *objPtr,
 				const Tcl_ObjType *typePtr,
-				const Tcl_ObjInternalRep *irPtr);
+				const Tcl_ObjIntRep *irPtr);
 /* 640 */
 EXTERN int		Tcl_HasStringRep(Tcl_Obj *objPtr);
 /* 641 */
@@ -1920,12 +1920,8 @@ EXTERN char *		Tcl_UniCharToUtfDString(const int *uniStr,
 /* 648 */
 EXTERN int *		Tcl_UtfToUniCharDString(const char *src, int length,
 				Tcl_DString *dsPtr);
-/* 649 */
-EXTERN unsigned char *	TclGetBytesFromObj(Tcl_Interp *interp,
-				Tcl_Obj *objPtr, int *numBytesPtr);
-/* 650 */
-EXTERN unsigned char *	Tcl_GetBytesFromObj(Tcl_Interp *interp,
-				Tcl_Obj *objPtr, size_t *numBytesPtr);
+/* Slot 649 is reserved */
+/* Slot 650 is reserved */
 /* 651 */
 EXTERN char *		TclGetStringFromObj(Tcl_Obj *objPtr,
 				size_t *lengthPtr);
@@ -1934,20 +1930,13 @@ EXTERN Tcl_UniChar *	TclGetUnicodeFromObj(Tcl_Obj *objPtr,
 				size_t *lengthPtr);
 /* 653 */
 EXTERN unsigned char *	TclGetByteArrayFromObj(Tcl_Obj *objPtr,
-				size_t *numBytesPtr);
+				size_t *lengthPtr);
 /* 654 */
 EXTERN int		Tcl_UtfCharComplete(const char *src, int length);
 /* 655 */
 EXTERN const char *	Tcl_UtfNext(const char *src);
 /* 656 */
 EXTERN const char *	Tcl_UtfPrev(const char *src, const char *start);
-/* 657 */
-EXTERN int		Tcl_UniCharIsUnicode(int ch);
-/* Slot 658 is reserved */
-/* Slot 659 is reserved */
-/* 660 */
-EXTERN int		Tcl_AsyncMarkFromSignal(Tcl_AsyncHandler async,
-				int sigNumber);

 typedef struct {
    const struct TclPlatStubs *tclPlatStubs;
@@ -1998,7 +1987,7 @@ typedef struct TclStubs {
    void (*tcl_DbIncrRefCount) (Tcl_Obj *objPtr, const char *file, int line); /* 20 */
    int (*tcl_DbIsShared) (Tcl_Obj *objPtr, const char *file, int line); /* 21 */
    TCL_DEPRECATED_API("No longer in use, changed to macro") Tcl_Obj * (*tcl_DbNewBooleanObj) (int boolValue, const char *file, int line); /* 22 */
-    Tcl_Obj * (*tcl_DbNewByteArrayObj) (const unsigned char *bytes, int numBytes, const char *file, int line); /* 23 */
+    Tcl_Obj * (*tcl_DbNewByteArrayObj) (const unsigned char *bytes, int length, const char *file, int line); /* 23 */
    Tcl_Obj * (*tcl_DbNewDoubleObj) (double doubleValue, const char *file, int line); /* 24 */
    Tcl_Obj * (*tcl_DbNewListObj) (int objc, Tcl_Obj *const *objv, const char *file, int line); /* 25 */
    TCL_DEPRECATED_API("No longer in use, changed to macro") Tcl_Obj * (*tcl_DbNewLongObj) (long longValue, const char *file, int line); /* 26 */
@@ -2008,7 +1997,7 @@ typedef struct TclStubs {
    void (*tclFreeObj) (Tcl_Obj *objPtr); /* 30 */
    int (*tcl_GetBoolean) (Tcl_Interp *interp, const char *src, int *boolPtr); /* 31 */
    int (*tcl_GetBooleanFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int *boolPtr); /* 32 */
-    unsigned char * (*tcl_GetByteArrayFromObj) (Tcl_Obj *objPtr, int *numBytesPtr); /* 33 */
+    unsigned char * (*tcl_GetByteArrayFromObj) (Tcl_Obj *objPtr, int *lengthPtr); /* 33 */
    int (*tcl_GetDouble) (Tcl_Interp *interp, const char *src, double *doublePtr); /* 34 */
    int (*tcl_GetDoubleFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, double *doublePtr); /* 35 */
    TCL_DEPRECATED_API("No longer in use, changed to macro") int (*tcl_GetIndexFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, const char *const *tablePtr, const char *msg, int flags, int *indexPtr); /* 36 */
@@ -2025,7 +2014,7 @@ typedef struct TclStubs {
    int (*tcl_ListObjLength) (Tcl_Interp *interp, Tcl_Obj *listPtr, int *lengthPtr); /* 47 */
    int (*tcl_ListObjReplace) (Tcl_Interp *interp, Tcl_Obj *listPtr, int first, int count, int objc, Tcl_Obj *const objv[]); /* 48 */
    TCL_DEPRECATED_API("No longer in use, changed to macro") Tcl_Obj * (*tcl_NewBooleanObj) (int boolValue); /* 49 */
-    Tcl_Obj * (*tcl_NewByteArrayObj) (const unsigned char *bytes, int numBytes); /* 50 */
+    Tcl_Obj * (*tcl_NewByteArrayObj) (const unsigned char *bytes, int length); /* 50 */
    Tcl_Obj * (*tcl_NewDoubleObj) (double doubleValue); /* 51 */
    TCL_DEPRECATED_API("No longer in use, changed to macro") Tcl_Obj * (*tcl_NewIntObj) (int intValue); /* 52 */
    Tcl_Obj * (*tcl_NewListObj) (int objc, Tcl_Obj *const objv[]); /* 53 */
@@ -2033,8 +2022,8 @@ typedef struct TclStubs {
    Tcl_Obj * (*tcl_NewObj) (void); /* 55 */
    Tcl_Obj * (*tcl_NewStringObj) (const char *bytes, int length); /* 56 */
    TCL_DEPRECATED_API("No longer in use, changed to macro") void (*tcl_SetBooleanObj) (Tcl_Obj *objPtr, int boolValue); /* 57 */
-    unsigned char * (*tcl_SetByteArrayLength) (Tcl_Obj *objPtr, int numBytes); /* 58 */
-    void (*tcl_SetByteArrayObj) (Tcl_Obj *objPtr, const unsigned char *bytes, int numBytes); /* 59 */
+    unsigned char * (*tcl_SetByteArrayLength) (Tcl_Obj *objPtr, int length); /* 58 */
+    void (*tcl_SetByteArrayObj) (Tcl_Obj *objPtr, const unsigned char *bytes, int length); /* 59 */
    void (*tcl_SetDoubleObj) (Tcl_Obj *objPtr, double doubleValue); /* 60 */
    TCL_DEPRECATED_API("No longer in use, changed to macro") void (*tcl_SetIntObj) (Tcl_Obj *objPtr, int intValue); /* 61 */
    void (*tcl_SetListObj) (Tcl_Obj *objPtr, int objc, Tcl_Obj *const objv[]); /* 62 */
@@ -2619,10 +2608,10 @@ typedef struct TclStubs {
    int (*tclZipfs_Unmount) (Tcl_Interp *interp, const char *mountPoint); /* 633 */
    Tcl_Obj * (*tclZipfs_TclLibrary) (void); /* 634 */
    int (*tclZipfs_MountBuffer) (Tcl_Interp *interp, const char *mountPoint, unsigned char *data, size_t datalen, int copy); /* 635 */
-    void (*tcl_FreeInternalRep) (Tcl_Obj *objPtr); /* 636 */
+    void (*tcl_FreeIntRep) (Tcl_Obj *objPtr); /* 636 */
    char * (*tcl_InitStringRep) (Tcl_Obj *objPtr, const char *bytes, unsigned int numBytes); /* 637 */
-    Tcl_ObjInternalRep * (*tcl_FetchInternalRep) (Tcl_Obj *objPtr, const Tcl_ObjType *typePtr); /* 638 */
-    void (*tcl_StoreInternalRep) (Tcl_Obj *objPtr, const Tcl_ObjType *typePtr, const Tcl_ObjInternalRep *irPtr); /* 639 */
+    Tcl_ObjIntRep * (*tcl_FetchIntRep) (Tcl_Obj *objPtr, const Tcl_ObjType *typePtr); /* 638 */
+    void (*tcl_StoreIntRep) (Tcl_Obj *objPtr, const Tcl_ObjType *typePtr, const Tcl_ObjIntRep *irPtr); /* 639 */
    int (*tcl_HasStringRep) (Tcl_Obj *objPtr); /* 640 */
    void (*tcl_IncrRefCount) (Tcl_Obj *objPtr); /* 641 */
    void (*tcl_DecrRefCount) (Tcl_Obj *objPtr); /* 642 */
@@ -2632,18 +2621,14 @@ typedef struct TclStubs {
    int (*tcl_UtfToUniChar) (const char *src, int *chPtr); /* 646 */
    char * (*tcl_UniCharToUtfDString) (const int *uniStr, int uniLength, Tcl_DString *dsPtr); /* 647 */
    int * (*tcl_UtfToUniCharDString) (const char *src, int length, Tcl_DString *dsPtr); /* 648 */
-    unsigned char * (*tclGetBytesFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int *numBytesPtr); /* 649 */
-    unsigned char * (*tcl_GetBytesFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, size_t *numBytesPtr); /* 650 */
+    void (*reserved649)(void);
+    void (*reserved650)(void);
    char * (*tclGetStringFromObj) (Tcl_Obj *objPtr, size_t *lengthPtr); /* 651 */
    Tcl_UniChar * (*tclGetUnicodeFromObj) (Tcl_Obj *objPtr, size_t *lengthPtr); /* 652 */
-    unsigned char * (*tclGetByteArrayFromObj) (Tcl_Obj *objPtr, size_t *numBytesPtr); /* 653 */
+    unsigned char * (*tclGetByteArrayFromObj) (Tcl_Obj *objPtr, size_t *lengthPtr); /* 653 */
    int (*tcl_UtfCharComplete) (const char *src, int length); /* 654 */
    const char * (*tcl_UtfNext) (const char *src); /* 655 */
    const char * (*tcl_UtfPrev) (const char *src, const char *start); /* 656 */
-    int (*tcl_UniCharIsUnicode) (int ch); /* 657 */
-    void (*reserved658)(void);
-    void (*reserved659)(void);
-    int (*tcl_AsyncMarkFromSignal) (Tcl_AsyncHandler async, int sigNumber); /* 660 */
 } TclStubs;

 extern const TclStubs *tclStubsPtr;
@@ -3946,14 +3931,14 @@ extern const TclStubs *tclStubsPtr;
 	(tclStubsPtr->tclZipfs_TclLibrary) /* 634 */
 #define TclZipfs_MountBuffer \
 	(tclStubsPtr->tclZipfs_MountBuffer) /* 635 */
-#define Tcl_FreeInternalRep \
-	(tclStubsPtr->tcl_FreeInternalRep) /* 636 */
+#define Tcl_FreeIntRep \
+	(tclStubsPtr->tcl_FreeIntRep) /* 636 */
 #define Tcl_InitStringRep \
 	(tclStubsPtr->tcl_InitStringRep) /* 637 */
-#define Tcl_FetchInternalRep \
-	(tclStubsPtr->tcl_FetchInternalRep) /* 638 */
-#define Tcl_StoreInternalRep \
-	(tclStubsPtr->tcl_StoreInternalRep) /* 639 */
+#define Tcl_FetchIntRep \
+	(tclStubsPtr->tcl_FetchIntRep) /* 638 */
+#define Tcl_StoreIntRep \
+	(tclStubsPtr->tcl_StoreIntRep) /* 639 */
 #define Tcl_HasStringRep \
 	(tclStubsPtr->tcl_HasStringRep) /* 640 */
 #define Tcl_IncrRefCount \
@@ -3972,10 +3957,8 @@ extern const TclStubs *tclStubsPtr;
 	(tclStubsPtr->tcl_UniCharToUtfDString) /* 647 */
 #define Tcl_UtfToUniCharDString \
 	(tclStubsPtr->tcl_UtfToUniCharDString) /* 648 */
-#define TclGetBytesFromObj \
-	(tclStubsPtr->tclGetBytesFromObj) /* 649 */
-#define Tcl_GetBytesFromObj \
-	(tclStubsPtr->tcl_GetBytesFromObj) /* 650 */
+/* Slot 649 is reserved */
+/* Slot 650 is reserved */
 #define TclGetStringFromObj \
 	(tclStubsPtr->tclGetStringFromObj) /* 651 */
 #define TclGetUnicodeFromObj \
@@ -3988,12 +3971,6 @@ extern const TclStubs *tclStubsPtr;
 	(tclStubsPtr->tcl_UtfNext) /* 655 */
 #define Tcl_UtfPrev \
 	(tclStubsPtr->tcl_UtfPrev) /* 656 */
-#define Tcl_UniCharIsUnicode \
-	(tclStubsPtr->tcl_UniCharIsUnicode) /* 657 */
-/* Slot 658 is reserved */
-/* Slot 659 is reserved */
-#define Tcl_AsyncMarkFromSignal \
-	(tclStubsPtr->tcl_AsyncMarkFromSignal) /* 660 */

 #endif /* defined(USE_TCL_STUBS) */

@@ -4135,24 +4112,7 @@ extern const TclStubs *tclStubsPtr;
 	} while(0)
 #endif /* TCL_NO_DEPRECATED */

-#if defined(USE_TCL_STUBS)
-#   if defined(_WIN32) && defined(_WIN64)
-#	undef Tcl_GetTime
-/* Handle Win64 tk.dll being loaded in Cygwin64. */
-#	define Tcl_GetTime(t) \
-		do { \
-		    union { \
-			Tcl_Time now; \
-			long long reserved; \
-		    } _t; \
-		    _t.reserved = -1; \
-		    tclStubsPtr->tcl_GetTime((&_t.now)); \
-		    if (_t.reserved != -1) { \
-			_t.now.usec = _t.reserved; \
-		    } \
-		    *(t) = _t.now; \
-		} while (0)
-#   endif
+#if defined(USE_TCL_STUBS) && !defined(USE_TCL_STUB_PROCS)
 #   if defined(__CYGWIN__) && defined(TCL_WIDE_INT_IS_LONG)
 /* On Cygwin64, long is 64-bit while on Win64 long is 32-bit. Therefore
 * we have to make sure that all stub entries on Cygwin64 follow the
@@ -4200,15 +4160,12 @@ extern const TclStubs *tclStubsPtr;
 	Tcl_GetStringFromObj(objPtr, (int *)NULL)
 #define Tcl_GetUnicode(objPtr) \
 	Tcl_GetUnicodeFromObj(objPtr, (int *)NULL)
-#undef Tcl_GetBytesFromObj
 #ifdef TCL_NO_DEPRECATED
 #undef Tcl_GetStringFromObj
 #undef Tcl_GetUnicodeFromObj
 #undef Tcl_GetByteArrayFromObj
 #endif
 #if defined(USE_TCL_STUBS)
-#define Tcl_GetBytesFromObj(interp, objPtr, sizePtr) \
-	(sizeof(*sizePtr) <= sizeof(int) ? tclStubsPtr->tclGetBytesFromObj(interp, objPtr, (int *)sizePtr) : tclStubsPtr->tcl_GetBytesFromObj(interp, objPtr, (size_t *)sizePtr))
 #ifdef TCL_NO_DEPRECATED
 #define Tcl_GetStringFromObj(objPtr, sizePtr) \
 	(sizeof(*sizePtr) <= sizeof(int) ? tclStubsPtr->tcl_GetStringFromObj(objPtr, (int *)sizePtr) : tclStubsPtr->tclGetStringFromObj(objPtr, (size_t *)sizePtr))
@@ -4218,8 +4175,6 @@ extern const TclStubs *tclStubsPtr;
 	(sizeof(*sizePtr) <= sizeof(int) ? tclStubsPtr->tcl_GetUnicodeFromObj(objPtr, (int *)sizePtr) : tclStubsPtr->tclGetUnicodeFromObj(objPtr, (size_t *)sizePtr))
 #endif
 #else
-#define Tcl_GetBytesFromObj(interp, objPtr, sizePtr) \
-	(sizeof(*sizePtr) <= sizeof(int) ? (TclGetBytesFromObj)(interp, objPtr, (int *)sizePtr) : (Tcl_GetBytesFromObj)(interp, objPtr, (size_t *)sizePtr))
 #ifdef TCL_NO_DEPRECATED
 #define Tcl_GetStringFromObj(objPtr, sizePtr) \
 	(sizeof(*sizePtr) <= sizeof(int) ? (Tcl_GetStringFromObj)(objPtr, (int *)sizePtr) : (TclGetStringFromObj)(objPtr, (size_t *)sizePtr))
@@ -149,18 +149,18 @@ const Tcl_ObjType tclDictType = {
    SetDictFromAny			/* setFromAnyProc */
 };

-#define DictSetInternalRep(objPtr, dictRepPtr)				\
+#define DictSetIntRep(objPtr, dictRepPtr)				\
    do {                                                                \
-        Tcl_ObjInternalRep ir;                                               \
+        Tcl_ObjIntRep ir;                                               \
        ir.twoPtrValue.ptr1 = (dictRepPtr);                             \
        ir.twoPtrValue.ptr2 = NULL;                                     \
-        Tcl_StoreInternalRep((objPtr), &tclDictType, &ir);                   \
+        Tcl_StoreIntRep((objPtr), &tclDictType, &ir);                   \
    } while (0)

-#define DictGetInternalRep(objPtr, dictRepPtr)				\
+#define DictGetIntRep(objPtr, dictRepPtr)				\
    do {                                                                \
-        const Tcl_ObjInternalRep *irPtr;                                     \
-        irPtr = TclFetchInternalRep((objPtr), &tclDictType);                \
+        const Tcl_ObjIntRep *irPtr;                                     \
+        irPtr = TclFetchIntRep((objPtr), &tclDictType);                \
        (dictRepPtr) = irPtr ? (Dict *)irPtr->twoPtrValue.ptr1 : NULL;          \
    } while (0)

@@ -362,7 +362,7 @@ DupDictInternalRep(
    Dict *oldDict, *newDict = (Dict *)ckalloc(sizeof(Dict));
    ChainEntry *cPtr;

-    DictGetInternalRep(srcPtr, oldDict);
+    DictGetIntRep(srcPtr, oldDict);

    /*
     * Copy values across from the old hash table.
@@ -395,7 +395,7 @@ DupDictInternalRep(
     * Store in the object.
     */

-    DictSetInternalRep(copyPtr, newDict);
+    DictSetIntRep(copyPtr, newDict);
 }

 /*
@@ -422,7 +422,7 @@ FreeDictInternalRep(
 {
    Dict *dict;

-    DictGetInternalRep(dictPtr, dict);
+    DictGetIntRep(dictPtr, dict);

    if (dict->refCount-- <= 1) {
 	DeleteDict(dict);
@@ -499,7 +499,7 @@ UpdateStringOfDict(

    int numElems;

-    DictGetInternalRep(dictPtr, dict);
+    DictGetIntRep(dictPtr, dict);

    assert (dict != NULL);

@@ -610,7 +610,7 @@ SetDictFromAny(
     * the conversion from lists to dictionaries.
     */

-    if (TclHasInternalRep(objPtr, &tclListType)) {
+    if (TclHasIntRep(objPtr, &tclListType)) {
 	int objc, i;
 	Tcl_Obj **objv;

@@ -717,7 +717,7 @@ SetDictFromAny(
    dict->epoch = 1;
    dict->chain = NULL;
    dict->refCount = 1;
-    DictSetInternalRep(objPtr, dict);
+    DictSetIntRep(objPtr, dict);
    return TCL_OK;

  missingValue:
@@ -739,12 +739,12 @@ GetDictFromObj(
 {
    Dict *dict;

-    DictGetInternalRep(dictPtr, dict);
+    DictGetIntRep(dictPtr, dict);
    if (dict == NULL) {
 	if (SetDictFromAny(interp, dictPtr) != TCL_OK) {
 	    return NULL;
 	}
-	DictGetInternalRep(dictPtr, dict);
+	DictGetIntRep(dictPtr, dict);
    }
    return dict;
 }
@@ -792,12 +792,12 @@ TclTraceDictPath(
    Dict *dict, *newDict;
    int i;

-    DictGetInternalRep(dictPtr, dict);
+    DictGetIntRep(dictPtr, dict);
    if (dict == NULL) {
 	if (SetDictFromAny(interp, dictPtr) != TCL_OK) {
 	    return NULL;
 	}
-	DictGetInternalRep(dictPtr, dict);
+	DictGetIntRep(dictPtr, dict);
    }
    if (flags & DICT_PATH_UPDATE) {
 	dict->chain = NULL;
@@ -835,7 +835,7 @@ TclTraceDictPath(
 	} else {
 	    tmpObj = (Tcl_Obj *)Tcl_GetHashValue(hPtr);

-	    DictGetInternalRep(tmpObj, newDict);
+	    DictGetIntRep(tmpObj, newDict);

 	    if (newDict == NULL) {
 		if (SetDictFromAny(interp, tmpObj) != TCL_OK) {
@@ -844,7 +844,7 @@ TclTraceDictPath(
 	    }
 	}

-	DictGetInternalRep(tmpObj, newDict);
+	DictGetIntRep(tmpObj, newDict);
 	if (flags & DICT_PATH_UPDATE) {
 	    if (Tcl_IsShared(tmpObj)) {
 		TclDecrRefCount(tmpObj);
@@ -852,7 +852,7 @@ TclTraceDictPath(
 		Tcl_IncrRefCount(tmpObj);
 		Tcl_SetHashValue(hPtr, tmpObj);
 		dict->epoch++;
-		DictGetInternalRep(tmpObj, newDict);
+		DictGetIntRep(tmpObj, newDict);
 	    }

 	    newDict->chain = dictPtr;
@@ -889,14 +889,14 @@ InvalidateDictChain(
 {
    Dict *dict;

-    DictGetInternalRep(dictObj, dict);
+    DictGetIntRep(dictObj, dict);
    assert( dict != NULL);

    do {
 	dict->refCount++;
 	TclInvalidateStringRep(dictObj);
-	TclFreeInternalRep(dictObj);
-	DictSetInternalRep(dictObj, dict);
+	TclFreeIntRep(dictObj);
+	DictSetIntRep(dictObj, dict);

 	dict->epoch++;
 	dictObj = dict->chain;
@@ -904,7 +904,7 @@ InvalidateDictChain(
 	    break;
 	}
 	dict->chain = NULL;
-	DictGetInternalRep(dictObj, dict);
+	DictGetIntRep(dictObj, dict);
    } while (dict != NULL);
 }

@@ -950,8 +950,8 @@ Tcl_DictObjPut(
    TclInvalidateStringRep(dictPtr);
    hPtr = CreateChainEntry(dict, keyPtr, &isNew);
    dict->refCount++;
-    TclFreeInternalRep(dictPtr)
-    DictSetInternalRep(dictPtr, dict);
+    TclFreeIntRep(dictPtr);
+    DictSetIntRep(dictPtr, dict);
    Tcl_IncrRefCount(valuePtr);
    if (!isNew) {
 	Tcl_Obj *oldValuePtr = (Tcl_Obj *)Tcl_GetHashValue(hPtr);
@@ -1306,7 +1306,7 @@ Tcl_DictObjPutKeyList(
 	return TCL_ERROR;
    }

-    DictGetInternalRep(dictPtr, dict);
+    DictGetIntRep(dictPtr, dict);
    assert(dict != NULL);
    hPtr = CreateChainEntry(dict, keyv[keyc-1], &isNew);
    Tcl_IncrRefCount(valuePtr);
@@ -1364,7 +1364,7 @@ Tcl_DictObjRemoveKeyList(
 	return TCL_ERROR;
    }

-    DictGetInternalRep(dictPtr, dict);
+    DictGetIntRep(dictPtr, dict);
    assert(dict != NULL);
    DeleteChainEntry(dict, keyv[keyc-1]);
    InvalidateDictChain(dictPtr);
@@ -1411,7 +1411,7 @@ Tcl_NewDictObj(void)
    dict->epoch = 1;
    dict->chain = NULL;
    dict->refCount = 1;
-    DictSetInternalRep(dictPtr, dict);
+    DictSetIntRep(dictPtr, dict);
    return dictPtr;
 #endif
 }
@@ -1459,7 +1459,7 @@ Tcl_DbNewDictObj(
    dict->epoch = 1;
    dict->chain = NULL;
    dict->refCount = 1;
-    DictSetInternalRep(dictPtr, dict);
+    DictSetIntRep(dictPtr, dict);
    return dictPtr;
 }
 #else /* !TCL_MEM_DEBUG */
@@ -44,17 +44,17 @@ static const Tcl_ObjType instNameType = {
    NULL,			/* setFromAnyProc */
 };

-#define InstNameSetInternalRep(objPtr, inst)				\
+#define InstNameSetIntRep(objPtr, inst)				\
    do {							\
-	Tcl_ObjInternalRep ir;					\
+	Tcl_ObjIntRep ir;					\
 	ir.wideValue = (inst);					\
-	Tcl_StoreInternalRep((objPtr), &instNameType, &ir);		\
+	Tcl_StoreIntRep((objPtr), &instNameType, &ir);		\
    } while (0)

-#define InstNameGetInternalRep(objPtr, inst)				\
+#define InstNameGetIntRep(objPtr, inst)				\
    do {							\
-	const Tcl_ObjInternalRep *irPtr;				\
-	irPtr = TclFetchInternalRep((objPtr), &instNameType);	\
+	const Tcl_ObjIntRep *irPtr;				\
+	irPtr = TclFetchIntRep((objPtr), &instNameType);	\
 	assert(irPtr != NULL);					\
 	(inst) = (size_t)irPtr->wideValue;			\
    } while (0)
@@ -259,7 +259,7 @@ DisassembleByteCodeObj(
    Interp *iPtr;
    Tcl_Obj *bufferObj, *fileObj;

-    ByteCodeGetInternalRep(objPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetIntRep(objPtr, &tclByteCodeType, codePtr);

    iPtr = (Interp *) *codePtr->interpHandle;

@@ -761,7 +761,7 @@ TclGetInnerContext(
        int len;

        /*
-         * Reset while keeping the list internalrep as much as possible.
+         * Reset while keeping the list intrep as much as possible.
         */

 	Tcl_ListObjLength(interp, result, &len);
@@ -808,7 +808,7 @@ TclNewInstNameObj(

    TclNewObj(objPtr);
    TclInvalidateStringRep(objPtr);
-    InstNameSetInternalRep(objPtr, (long) inst);
+    InstNameSetIntRep(objPtr, (long) inst);

    return objPtr;
 }
@@ -830,7 +830,7 @@ UpdateStringOfInstName(
    size_t inst;	/* NOTE: We know this is really an unsigned char */
    char *dst;

-    InstNameGetInternalRep(objPtr, inst);
+    InstNameGetIntRep(objPtr, inst);

    if (inst > LAST_INST_OPCODE) {
 	dst = Tcl_InitStringRep(objPtr, NULL, TCL_INTEGER_SPACE + 5);
@@ -945,7 +945,7 @@ DisassembleByteCodeAsDicts(
    int codeOffset, codeLength, sourceOffset, sourceLength;
    int i, val, line;

-    ByteCodeGetInternalRep(objPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetIntRep(objPtr, &tclByteCodeType, codePtr);

    /*
     * Get the literals from the bytecode.
@@ -1368,7 +1368,7 @@ Tcl_DisassembleObjCmd(
 	    return TCL_ERROR;
 	}

-	if (!TclHasInternalRep(objv[2], &tclByteCodeType) && (TCL_OK
+	if (!TclHasIntRep(objv[2], &tclByteCodeType) && (TCL_OK
 		!= TclSetByteCodeFromAny(interp, objv[2], NULL, NULL))) {
 	    return TCL_ERROR;
 	}
@@ -1419,7 +1419,7 @@ Tcl_DisassembleObjCmd(
 	 * Compile if necessary.
 	 */

-	if (!TclHasInternalRep(procPtr->bodyPtr, &tclByteCodeType)) {
+	if (!TclHasIntRep(procPtr->bodyPtr, &tclByteCodeType)) {
 	    Command cmd;

 	    /*
@@ -1484,7 +1484,7 @@ Tcl_DisassembleObjCmd(
 	 * Compile if necessary.
 	 */

-	if (!TclHasInternalRep(procPtr->bodyPtr, &tclByteCodeType)) {
+	if (!TclHasIntRep(procPtr->bodyPtr, &tclByteCodeType)) {
 	    Command cmd;

 	    /*
@@ -1569,7 +1569,7 @@ Tcl_DisassembleObjCmd(
 		    "METHODTYPE", NULL);
 	    return TCL_ERROR;
 	}
-	if (!TclHasInternalRep(procPtr->bodyPtr, &tclByteCodeType)) {
+	if (!TclHasIntRep(procPtr->bodyPtr, &tclByteCodeType)) {
 	    Command cmd;

 	    /*
@@ -1597,7 +1597,7 @@ Tcl_DisassembleObjCmd(
     * Do the actual disassembly.
     */

-    ByteCodeGetInternalRep(codeObjPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetIntRep(codeObjPtr, &tclByteCodeType, codePtr);

    if (codePtr->flags & TCL_BYTECODE_PRECOMPILED) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
@@ -37,7 +37,7 @@ typedef struct {
 				 * end-of-string in this encoding. This number
 				 * is used to determine the source string
 				 * length when the srcLen argument is
-				 * negative. This number can be 1, 2, or 4. */
+				 * negative. This number can be 1 or 2. */
    ClientData clientData;	/* Arbitrary value associated with encoding
 				 * type. Passed to conversion functions. */
    LengthProc *lengthProc;	/* Function to compute length of
@@ -45,9 +45,7 @@ typedef struct {
 				 * If nullSize is 1, this is strlen; if
 				 * nullSize is 2, this is a function that
 				 * returns the number of bytes in a 0x0000
-				 * terminated string; if nullSize is 4, this
-				 * is a function that returns the number of
-				 * bytes in a 0x00000000 terminated string. */
+				 * terminated string. */
    size_t refCount;		/* Number of uses of this structure. */
    Tcl_HashEntry *hPtr;	/* Hash table entry that owns this encoding. */
 } Encoding;
@@ -129,10 +127,12 @@ typedef struct {
 * file.
 */

-#define ENCODING_SINGLEBYTE	0
-#define ENCODING_DOUBLEBYTE	1
-#define ENCODING_MULTIBYTE	2
-#define ENCODING_ESCAPE		3
+enum EncodingTypes {
+    ENCODING_SINGLEBYTE = 0,
+    ENCODING_DOUBLEBYTE = 1,
+    ENCODING_MULTIBYTE = 2,
+    ENCODING_ESCAPE = 3
+};

 /*
 * A list of directories in which Tcl should look for *.enc files. This list
@@ -198,13 +198,13 @@ static unsigned short emptyPage[256];
 */

 static Tcl_EncodingConvertProc	BinaryProc;
-static Tcl_DupInternalRepProc	DupEncodingInternalRep;
+static Tcl_DupInternalRepProc	DupEncodingIntRep;
 static Tcl_EncodingFreeProc	EscapeFreeProc;
 static Tcl_EncodingConvertProc	EscapeFromUtfProc;
 static Tcl_EncodingConvertProc	EscapeToUtfProc;
 static void			FillEncodingFileMap(void);
 static void			FreeEncoding(Tcl_Encoding encoding);
-static Tcl_FreeInternalRepProc	FreeEncodingInternalRep;
+static Tcl_FreeInternalRepProc	FreeEncodingIntRep;
 static Encoding *		GetTableEncoding(EscapeEncodingData *dataPtr,
 				    int state);
 static Tcl_Encoding		LoadEncodingFile(Tcl_Interp *interp,
@@ -218,10 +218,7 @@ static Tcl_Channel		OpenEncodingFileChannel(Tcl_Interp *interp,
 static Tcl_EncodingFreeProc	TableFreeProc;
 static Tcl_EncodingConvertProc	TableFromUtfProc;
 static Tcl_EncodingConvertProc	TableToUtfProc;
-static size_t		unilen(const char *src);
-static size_t		unilen4(const char *src);
-static Tcl_EncodingConvertProc	Utf32ToUtfProc;
-static Tcl_EncodingConvertProc	UtfToUtf32Proc;
+static size_t			unilen(const char *src);
 static Tcl_EncodingConvertProc	Utf16ToUtfProc;
 static Tcl_EncodingConvertProc	UtfToUtf16Proc;
 static Tcl_EncodingConvertProc	UtfToUcs2Proc;
@@ -231,25 +228,25 @@ static Tcl_EncodingConvertProc	Iso88591ToUtfProc;

 /*
 * A Tcl_ObjType for holding a cached Tcl_Encoding in the twoPtrValue.ptr1 field
- * of the internalrep. This should help the lifetime of encodings be more useful.
+ * of the intrep. This should help the lifetime of encodings be more useful.
 * See concerns raised in [Bug 1077262].
 */

 static const Tcl_ObjType encodingType = {
-    "encoding", FreeEncodingInternalRep, DupEncodingInternalRep, NULL, NULL
+    "encoding", FreeEncodingIntRep, DupEncodingIntRep, NULL, NULL
 };
-#define EncodingSetInternalRep(objPtr, encoding)				\
+#define EncodingSetIntRep(objPtr, encoding)				\
    do {								\
-	Tcl_ObjInternalRep ir;						\
+	Tcl_ObjIntRep ir;						\
 	ir.twoPtrValue.ptr1 = (encoding);				\
 	ir.twoPtrValue.ptr2 = NULL;					\
-	Tcl_StoreInternalRep((objPtr), &encodingType, &ir);			\
+	Tcl_StoreIntRep((objPtr), &encodingType, &ir);			\
    } while (0)

-#define EncodingGetInternalRep(objPtr, encoding)				\
+#define EncodingGetIntRep(objPtr, encoding)				\
    do {								\
-	const Tcl_ObjInternalRep *irPtr;					\
-	irPtr = TclFetchInternalRep ((objPtr), &encodingType);		\
+	const Tcl_ObjIntRep *irPtr;					\
+	irPtr = TclFetchIntRep ((objPtr), &encodingType);		\
 	(encoding) = irPtr ? (Tcl_Encoding)irPtr->twoPtrValue.ptr1 : NULL;		\
    } while (0)

@@ -282,13 +279,13 @@ Tcl_GetEncodingFromObj(
    Tcl_Encoding encoding;
    const char *name = TclGetString(objPtr);

-    EncodingGetInternalRep(objPtr, encoding);
+    EncodingGetIntRep(objPtr, encoding);
    if (encoding == NULL) {
 	encoding = Tcl_GetEncoding(interp, name);
 	if (encoding == NULL) {
 	    return TCL_ERROR;
 	}
-	EncodingSetInternalRep(objPtr, encoding);
+	EncodingSetIntRep(objPtr, encoding);
    }
    *encodingPtr = Tcl_GetEncoding(NULL, name);
    return TCL_OK;
@@ -297,7 +294,7 @@ Tcl_GetEncodingFromObj(
 /*
 *----------------------------------------------------------------------
 *
- * FreeEncodingInternalRep --
+ * FreeEncodingIntRep --
 *
 *	The Tcl_FreeInternalRepProc for the "encoding" Tcl_ObjType.
 *
@@ -305,19 +302,19 @@ Tcl_GetEncodingFromObj(
 */

 static void
-FreeEncodingInternalRep(
+FreeEncodingIntRep(
    Tcl_Obj *objPtr)
 {
    Tcl_Encoding encoding;

-    EncodingGetInternalRep(objPtr, encoding);
+    EncodingGetIntRep(objPtr, encoding);
    Tcl_FreeEncoding(encoding);
 }

 /*
 *----------------------------------------------------------------------
 *
- * DupEncodingInternalRep --
+ * DupEncodingIntRep --
 *
 *	The Tcl_DupInternalRepProc for the "encoding" Tcl_ObjType.
 *
@@ -325,12 +322,12 @@ FreeEncodingInternalRep(
 */

 static void
-DupEncodingInternalRep(
+DupEncodingIntRep(
    Tcl_Obj *srcPtr,
    Tcl_Obj *dupPtr)
 {
    Tcl_Encoding encoding = Tcl_GetEncoding(NULL, TclGetString(srcPtr));
-    EncodingSetInternalRep(dupPtr, encoding);
+    EncodingSetIntRep(dupPtr, encoding);
 }

 /*
@@ -515,12 +512,17 @@ FillEncodingFileMap(void)
 *---------------------------------------------------------------------------
 */

-/* Those flags must not conflict with other TCL_ENCODING_* flags in tcl.h */
-/* Since TCL_ENCODING_MODIFIED is only used for utf-8/cesu-8 and
- * TCL_ENCODING_LE is only used for  utf-16/utf-32/ucs-2. re-use the same value */
-#define TCL_ENCODING_MODIFIED	0x20	/* Converting NULL bytes to 0xC0 0x80 */
-#define TCL_ENCODING_LE		TCL_ENCODING_MODIFIED	/* Little-endian encoding */
-#define TCL_ENCODING_UTF	0x200	/* For UTF-8 encoding, allow 4-byte output sequences */
+/* These flags must not conflict with other TCL_ENCODING_* flags in tcl.h */
+enum EncodingFlags {
+    TCL_ENCODING_MODIFIED = 0x20,
+				/* Converting NULL bytes to 0xC0 0x80 */
+    /*
+     * Since TCL_ENCODING_MODIFIED is only used for utf-8 and TCL_ENCODING_LE
+     * is only used for utf-16/ucs-2, re-use the same value.
+     */
+    TCL_ENCODING_LE = TCL_ENCODING_MODIFIED
+				/* Little-endian encoding */
+};

 void
 TclInitEncodingSubsystem(void)
@@ -562,10 +564,7 @@ TclInitEncodingSubsystem(void)
    type.fromUtfProc	= UtfToUtfProc;
    type.freeProc	= NULL;
    type.nullSize	= 1;
-    type.clientData	= INT2PTR(TCL_ENCODING_UTF);
-    Tcl_CreateEncoding(&type);
-    type.clientData	= INT2PTR(0);
-    type.encodingName	= "cesu-8";
+    type.clientData	= NULL;
    Tcl_CreateEncoding(&type);

    type.toUtfProc	= Utf16ToUtfProc;
@@ -582,20 +581,6 @@ TclInitEncodingSubsystem(void)
    type.clientData	= INT2PTR(isLe.c);
    Tcl_CreateEncoding(&type);

-    type.toUtfProc	= Utf32ToUtfProc;
-    type.fromUtfProc    = UtfToUtf32Proc;
-    type.freeProc	= NULL;
-    type.nullSize	= 4;
-    type.encodingName   = "utf-32le";
-    type.clientData	= INT2PTR(TCL_ENCODING_LE);
-    Tcl_CreateEncoding(&type);
-    type.encodingName   = "utf-32be";
-    type.clientData	= INT2PTR(0);
-    Tcl_CreateEncoding(&type);
-    type.encodingName   = "utf-32";
-    type.clientData	= INT2PTR(isLe.c);
-    Tcl_CreateEncoding(&type);
-
    type.toUtfProc	= Utf16ToUtfProc;
    type.fromUtfProc    = UtfToUtf16Proc;
    type.freeProc	= NULL;
@@ -1076,12 +1061,10 @@ Tcl_CreateEncoding(
    encodingPtr->freeProc	= typePtr->freeProc;
    encodingPtr->nullSize	= typePtr->nullSize;
    encodingPtr->clientData	= typePtr->clientData;
-    if (typePtr->nullSize == 2) {
-	encodingPtr->lengthProc = (LengthProc *) unilen;
-    } else if (typePtr->nullSize == 4) {
-	encodingPtr->lengthProc = (LengthProc *) unilen4;
-    } else {
+    if (typePtr->nullSize == 1) {
 	encodingPtr->lengthProc = (LengthProc *) strlen;
+    } else {
+	encodingPtr->lengthProc = (LengthProc *) unilen;
    }
    encodingPtr->refCount	= 1;
    encodingPtr->hPtr		= NULL;
@@ -1166,7 +1149,7 @@ Tcl_ExternalToUtfDString(

    flags = TCL_ENCODING_START | TCL_ENCODING_END;
    if (encodingPtr->toUtfProc == UtfToUtfProc) {
-	flags |= TCL_ENCODING_MODIFIED | TCL_ENCODING_UTF;
+	flags |= TCL_ENCODING_MODIFIED;
    }

    while (1) {
@@ -1283,7 +1266,7 @@ Tcl_ExternalToUtf(
 	dstLen--;
    }
    if (encodingPtr->toUtfProc == UtfToUtfProc) {
-	flags |= TCL_ENCODING_MODIFIED | TCL_ENCODING_UTF;
+	flags |= TCL_ENCODING_MODIFIED;
    }
    do {
 	Tcl_EncodingState savedState = *statePtr;
@@ -1362,16 +1345,16 @@ Tcl_UtfToExternalDString(
 		&srcRead, &dstWrote, &dstChars);
 	soFar = dst + dstWrote - Tcl_DStringValue(dstPtr);

-	src += srcRead;
 	if (result != TCL_CONVERT_NOSPACE) {
-	    int i = soFar + encodingPtr->nullSize - 1;
-	    while (i >= soFar) {
-		Tcl_DStringSetLength(dstPtr, i--);
+	    if (encodingPtr->nullSize == 2) {
+		Tcl_DStringSetLength(dstPtr, soFar + 1);
 	    }
+	    Tcl_DStringSetLength(dstPtr, soFar);
 	    return Tcl_DStringValue(dstPtr);
 	}

 	flags &= ~TCL_ENCODING_START;
+	src += srcRead;
 	srcLen -= srcRead;
 	if (Tcl_DStringLength(dstPtr) == 0) {
 	    Tcl_DStringSetLength(dstPtr, dstLen);
@@ -1462,7 +1445,10 @@ Tcl_UtfToExternal(
    result = encodingPtr->fromUtfProc(encodingPtr->clientData, src, srcLen,
 	    flags, statePtr, dst, dstLen, srcReadPtr,
 	    dstWrotePtr, dstCharsPtr);
-    memset(&dst[*dstWrotePtr], '\0', encodingPtr->nullSize);
+    if (encodingPtr->nullSize == 2) {
+	dst[*dstWrotePtr + 1] = '\0';
+    }
+    dst[*dstWrotePtr] = '\0';

    return result;
 }
@@ -2237,7 +2223,7 @@ UtfToUtfProc(

    dstStart = dst;
    flags |= PTR2INT(clientData);
-    dstEnd = dst + dstLen - ((flags & TCL_ENCODING_UTF) ? TCL_UTF_MAX : 6);
+    dstEnd = dst + dstLen - TCL_UTF_MAX;

    for (numChars = 0; src < srcEnd && numChars <= charLimit; numChars++) {
 	if ((src > srcClose) && (!Tcl_UtfCharComplete(src, srcEnd - src))) {
@@ -2253,15 +2239,15 @@ UtfToUtfProc(
 	    result = TCL_CONVERT_NOSPACE;
 	    break;
 	}
-	if (UCHAR(*src) < 0x80 && !((UCHAR(*src) == 0) && (flags & TCL_ENCODING_MODIFIED))) {
+	if (UCHAR(*src) < 0x80 && !(UCHAR(*src) == 0 && (flags & TCL_ENCODING_MODIFIED))) {
 	    /*
 	     * Copy 7bit characters, but skip null-bytes when we are in input
 	     * mode, so that they get converted to 0xC080.
 	     */

 	    *dst++ = *src++;
-	} else if ((UCHAR(*src) == 0xC0) && (src + 1 < srcEnd)
-		&& (UCHAR(src[1]) == 0x80) && !(flags & TCL_ENCODING_MODIFIED)) {
+	} else if (UCHAR(*src) == 0xC0 && (src + 1 < srcEnd)
+		&& UCHAR(src[1]) == 0x80 && !(flags & TCL_ENCODING_MODIFIED)) {
 	    /*
 	     * Convert 0xC080 to real nulls when we are in output mode.
 	     */
@@ -2290,7 +2276,6 @@ UtfToUtfProc(
 	    dst += Tcl_UniCharToUtf(ch, dst);
 	} else {
 	    int low;
-	    const char *saveSrc = src;
 	    size_t len = TclUtfToUCS4(src, &ch);
 	    if ((len < 2) && (ch != 0) && (flags & TCL_ENCODING_STOPONERROR)
 		    && (flags & TCL_ENCODING_MODIFIED)) {
@@ -2298,17 +2283,7 @@ UtfToUtfProc(
 		break;
 	    }
 	    src += len;
-	    if (!(flags & TCL_ENCODING_UTF) && (ch > 0x3FF)) {
-		if (ch > 0xFFFF) {
-		    /* CESU-8 6-byte sequence for chars > U+FFFF */
-		    ch -= 0x10000;
-		    *dst++ = 0xED;
-		    *dst++ = (char) (((ch >> 16) & 0x0F) | 0xA0);
-		    *dst++ = (char) (((ch >> 10) & 0x3F) | 0x80);
-		    ch = (ch & 0x0CFF) | 0xDC00;
-		}
-		goto cesu8;
-	    } else if ((ch | 0x7FF) == 0xDFFF) {
+	    if ((ch | 0x7FF) == 0xDFFF) {
 		/*
 		 * A surrogate character is detected, handle especially.
 		 */
@@ -2317,15 +2292,6 @@ UtfToUtfProc(
 		len = (src <= srcEnd-3) ? TclUtfToUCS4(src, &low) : 0;

 		if (((low & ~0x3FF) != 0xDC00) || (ch & 0x400)) {
-		    if (flags & TCL_ENCODING_STOPONERROR) {
-			result = TCL_CONVERT_UNKNOWN;
-			src = saveSrc;
-			break;
-		    }
-		    if (!(flags & TCL_ENCODING_MODIFIED)) {
-			ch = 0xFFFD;
-		    }
-		cesu8:
 		    *dst++ = (char) (((ch >> 12) | 0xE0) & 0xEF);
 		    *dst++ = (char) (((ch >> 6) | 0x80) & 0xBF);
 		    *dst++ = (char) ((ch | 0x80) & 0xBF);
@@ -2334,15 +2300,6 @@ UtfToUtfProc(
 		src += len;
 		dst += Tcl_UniCharToUtf(ch, dst);
 		ch = low;
-	    } else if (!Tcl_UniCharIsUnicode(ch)) {
-		if (flags & TCL_ENCODING_STOPONERROR) {
-		    result = TCL_CONVERT_UNKNOWN;
-		    src = saveSrc;
-		    break;
-		}
-		if (!(flags & TCL_ENCODING_MODIFIED)) {
-		    ch = 0xFFFD;
-		}
 	    }
 	    dst += Tcl_UniCharToUtf(ch, dst);
 	}
@@ -2354,199 +2311,6 @@ UtfToUtfProc(
    return result;
 }

-/*
- *-------------------------------------------------------------------------
- *
- * Utf32ToUtfProc --
- *
- *	Convert from UTF-32 to UTF-8.
- *
- * Results:
- *	Returns TCL_OK if conversion was successful.
- *
- * Side effects:
- *	None.
- *
- *-------------------------------------------------------------------------
- */
-
-static int
-Utf32ToUtfProc(
-    ClientData clientData,	/* additional flags, e.g. TCL_ENCODING_LE */
-    const char *src,		/* Source string in Unicode. */
-    int srcLen,			/* Source string length in bytes. */
-    int flags,			/* Conversion control flags. */
-    TCL_UNUSED(Tcl_EncodingState *),
-    char *dst,			/* Output buffer in which converted string is
-				 * stored. */
-    int dstLen,			/* The maximum length of output buffer in
-				 * bytes. */
-    int *srcReadPtr,		/* Filled with the number of bytes from the
-				 * source string that were converted. This may
-				 * be less than the original source length if
-				 * there was a problem converting some source
-				 * characters. */
-    int *dstWrotePtr,		/* Filled with the number of bytes that were
-				 * stored in the output buffer as a result of
-				 * the conversion. */
-    int *dstCharsPtr)		/* Filled with the number of characters that
-				 * correspond to the bytes stored in the
-				 * output buffer. */
-{
-    const char *srcStart, *srcEnd;
-    const char *dstEnd, *dstStart;
-    int result, numChars, charLimit = INT_MAX;
-    int ch;
-
-    flags |= PTR2INT(clientData);
-    if (flags & TCL_ENCODING_CHAR_LIMIT) {
-	charLimit = *dstCharsPtr;
-    }
-    result = TCL_OK;
-
-    /*
-     * Check alignment with utf-32 (4 == sizeof(UTF-32))
-     */
-
-    if ((srcLen % 4) != 0) {
-	result = TCL_CONVERT_MULTIBYTE;
-	srcLen &= -4;
-    }
-
-    srcStart = src;
-    srcEnd = src + srcLen;
-
-    dstStart = dst;
-    dstEnd = dst + dstLen - TCL_UTF_MAX;
-
-    for (numChars = 0; src < srcEnd && numChars <= charLimit; numChars++) {
-	if (dst > dstEnd) {
-	    result = TCL_CONVERT_NOSPACE;
-	    break;
-	}
-
-	if (flags & TCL_ENCODING_LE) {
-	    ch = (src[3] & 0xFF) << 24 | (src[2] & 0xFF) << 16 | (src[1] & 0xFF) << 8 | (src[0] & 0xFF);
-	} else {
-	    ch = (src[0] & 0xFF) << 24 | (src[1] & 0xFF) << 16 | (src[2] & 0xFF) << 8 | (src[3] & 0xFF);
-	}
-
-	/*
-	 * Special case for 1-byte utf chars for speed. Make sure we work with
-	 * unsigned short-size data.
-	 */
-
-	if ((ch > 0) && (ch < 0x80)) {
-	    *dst++ = (ch & 0xFF);
-	} else {
-	    dst += Tcl_UniCharToUtf(ch, dst);
-	}
-	src += sizeof(unsigned int);
-    }
-
-    *srcReadPtr = src - srcStart;
-    *dstWrotePtr = dst - dstStart;
-    *dstCharsPtr = numChars;
-    return result;
-}
-
-/*
- *-------------------------------------------------------------------------
- *
- * UtfToUtf32Proc --
- *
- *	Convert from UTF-8 to UTF-32.
- *
- * Results:
- *	Returns TCL_OK if conversion was successful.
- *
- * Side effects:
- *	None.
- *
- *-------------------------------------------------------------------------
- */
-
-static int
-UtfToUtf32Proc(
-    ClientData clientData,	/* additional flags, e.g. TCL_ENCODING_LE */
-    const char *src,		/* Source string in UTF-8. */
-    int srcLen,			/* Source string length in bytes. */
-    int flags,			/* Conversion control flags. */
-    TCL_UNUSED(Tcl_EncodingState *),
-    char *dst,			/* Output buffer in which converted string is
-				 * stored. */
-    int dstLen,			/* The maximum length of output buffer in
-				 * bytes. */
-    int *srcReadPtr,		/* Filled with the number of bytes from the
-				 * source string that were converted. This may
-				 * be less than the original source length if
-				 * there was a problem converting some source
-				 * characters. */
-    int *dstWrotePtr,		/* Filled with the number of bytes that were
-				 * stored in the output buffer as a result of
-				 * the conversion. */
-    int *dstCharsPtr)		/* Filled with the number of characters that
-				 * correspond to the bytes stored in the
-				 * output buffer. */
-{
-    const char *srcStart, *srcEnd, *srcClose, *dstStart, *dstEnd;
-    int result, numChars;
-    int ch, len;
-
-    srcStart = src;
-    srcEnd = src + srcLen;
-    srcClose = srcEnd;
-    if ((flags & TCL_ENCODING_END) == 0) {
-	srcClose -= TCL_UTF_MAX;
-    }
-
-    dstStart = dst;
-    dstEnd = dst + dstLen - sizeof(Tcl_UniChar);
-    flags |= PTR2INT(clientData);
-
-    result = TCL_OK;
-    for (numChars = 0; src < srcEnd; numChars++) {
-	if ((src > srcClose) && (!Tcl_UtfCharComplete(src, srcEnd - src))) {
-	    /*
-	     * If there is more string to follow, this will ensure that the
-	     * last UTF-8 character in the source buffer hasn't been cut off.
-	     */
-
-	    result = TCL_CONVERT_MULTIBYTE;
-	    break;
-	}
-	if (dst > dstEnd) {
-	    result = TCL_CONVERT_NOSPACE;
-	    break;
-	}
-	len = TclUtfToUCS4(src, &ch);
-	if (!Tcl_UniCharIsUnicode(ch)) {
-	    if (flags & TCL_ENCODING_STOPONERROR) {
-		result = TCL_CONVERT_UNKNOWN;
-		break;
-	    }
-	    ch = 0xFFFD;
-	}
-	src += len;
-	if (flags & TCL_ENCODING_LE) {
-	    *dst++ = (ch & 0xFF);
-	    *dst++ = ((ch >> 8) & 0xFF);
-	    *dst++ = ((ch >> 16) & 0xFF);
-	    *dst++ = ((ch >> 24) & 0xFF);
-	} else {
-	    *dst++ = ((ch >> 24) & 0xFF);
-	    *dst++ = ((ch >> 16) & 0xFF);
-	    *dst++ = ((ch >> 8) & 0xFF);
-	    *dst++ = (ch & 0xFF);
-	}
-    }
-
-    *srcReadPtr = src - srcStart;
-    *dstWrotePtr = dst - dstStart;
-    *dstCharsPtr = numChars;
-    return result;
-}
-
 /*
 *-------------------------------------------------------------------------
 *
@@ -2694,7 +2458,7 @@ UtfToUtf16Proc(
 {
    const char *srcStart, *srcEnd, *srcClose, *dstStart, *dstEnd;
    int result, numChars;
-    int ch, len;
+    int ch;

    srcStart = src;
    srcEnd = src + srcLen;
@@ -2722,15 +2486,7 @@ UtfToUtf16Proc(
 	    result = TCL_CONVERT_NOSPACE;
 	    break;
 	}
-	len = TclUtfToUCS4(src, &ch);
-	if (!Tcl_UniCharIsUnicode(ch)) {
-	    if (flags & TCL_ENCODING_STOPONERROR) {
-		result = TCL_CONVERT_UNKNOWN;
-		break;
-	    }
-	    ch = 0xFFFD;
-	}
-	src += len;
+	src += TclUtfToUCS4(src, &ch);
 	if (flags & TCL_ENCODING_LE) {
 	    if (ch <= 0xFFFF) {
 		*dst++ = (ch & 0xFF);
@@ -2862,7 +2618,7 @@ UtfToUcs2Proc(
    *dstCharsPtr = numChars;
    return result;
 }
-
+
 /*
 *-------------------------------------------------------------------------
 *
@@ -3048,7 +2804,11 @@ TableFromUtfProc(
 	len = TclUtfToUniChar(src, &ch);

 #if TCL_UTF_MAX > 3
-	/* Unicode chars > +U0FFFF cannot be represented in any table encoding */
+	/*
+	 * This prevents a crash condition. More evaluation is required for
+	 * full support of int Tcl_UniChar. [Bug 1004065]
+	 */
+
 	if (ch & 0xFFFF0000) {
 	    word = 0;
 	} else
@@ -3300,7 +3060,7 @@ TableFreeProc(
    ClientData clientData)	/* TableEncodingData that specifies
 				 * encoding. */
 {
-    TableEncodingData *dataPtr = (TableEncodingData *)clientData;
+    TableEncodingData *dataPtr = (TableEncodingData *) clientData;

    /*
     * Make sure we aren't freeing twice on shutdown. [Bug 219314]
@@ -3358,7 +3118,7 @@ EscapeToUtfProc(
 				 * correspond to the bytes stored in the
 				 * output buffer. */
 {
-    EscapeEncodingData *dataPtr = (EscapeEncodingData *)clientData;
+    EscapeEncodingData *dataPtr = (EscapeEncodingData *) clientData;
    const char *prefixBytes, *tablePrefixBytes, *srcStart, *srcEnd;
    const unsigned short *const *tableToUnicode;
    const Encoding *encodingPtr;
@@ -3835,7 +3595,7 @@ GetTableEncoding(
 /*
 *---------------------------------------------------------------------------
 *
- * unilen, unilen4 --
+ * unilen --
 *
 *	A helper function for the Tcl_ExternalToUtf functions. This function
 *	is similar to strlen for double-byte characters: it returns the number
@@ -3862,19 +3622,6 @@ unilen(
    }
    return (char *) p - src;
 }
-
-static size_t
-unilen4(
-    const char *src)
-{
-    unsigned int *p;
-
-    p = (unsigned int *) src;
-    while (*p != 0x00000000) {
-	p++;
-    }
-    return (char *) p - src;
-}

 /*
 *-------------------------------------------------------------------------
@@ -3906,7 +3653,7 @@ InitializeEncodingSearchPath(
    Tcl_Encoding *encodingPtr)
 {
    const char *bytes;
-    int i, numDirs, numBytes;
+    int i, numDirs;
    Tcl_Obj *libPathObj, *encodingObj, *searchPathObj;

    TclNewLiteralStringObj(encodingObj, "encoding");
@@ -3936,11 +3683,11 @@ InitializeEncodingSearchPath(
    if (*encodingPtr) {
 	((Encoding *)(*encodingPtr))->refCount++;
    }
-    bytes = Tcl_GetStringFromObj(searchPathObj, &numBytes);
+    bytes = TclGetString(searchPathObj);

-    *lengthPtr = numBytes;
-    *valuePtr = (char *)ckalloc(numBytes + 1);
-    memcpy(*valuePtr, bytes, numBytes + 1);
+    *lengthPtr = searchPathObj->length;
+    *valuePtr = (char *)ckalloc(*lengthPtr + 1);
+    memcpy(*valuePtr, bytes, *lengthPtr + 1);
    Tcl_DecrRefCount(searchPathObj);
 }

@@ -84,18 +84,18 @@ static const Tcl_ObjType ensembleCmdType = {
    NULL			/* setFromAnyProc */
 };

-#define ECRSetInternalRep(objPtr, ecRepPtr)					\
+#define ECRSetIntRep(objPtr, ecRepPtr)					\
    do {								\
-	Tcl_ObjInternalRep ir;						\
+	Tcl_ObjIntRep ir;						\
 	ir.twoPtrValue.ptr1 = (ecRepPtr);				\
 	ir.twoPtrValue.ptr2 = NULL;					\
-	Tcl_StoreInternalRep((objPtr), &ensembleCmdType, &ir);		\
+	Tcl_StoreIntRep((objPtr), &ensembleCmdType, &ir);		\
    } while (0)

-#define ECRGetInternalRep(objPtr, ecRepPtr)					\
+#define ECRGetIntRep(objPtr, ecRepPtr)					\
    do {								\
-	const Tcl_ObjInternalRep *irPtr;					\
-	irPtr = TclFetchInternalRep((objPtr), &ensembleCmdType);		\
+	const Tcl_ObjIntRep *irPtr;					\
+	irPtr = TclFetchIntRep((objPtr), &ensembleCmdType);		\
 	(ecRepPtr) = irPtr ? (EnsembleCmdRep *)irPtr->twoPtrValue.ptr1 : NULL;		\
    } while (0)

@@ -165,7 +165,7 @@ TclNamespaceEnsembleCmd(
    const char *simpleName;
    int index, done;

-    if (nsPtr == NULL || nsPtr->flags & NS_DEAD) {
+    if (nsPtr == NULL || nsPtr->flags & NS_DYING) {
 	if (!Tcl_InterpDeleted(interp)) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "tried to manipulate ensemble of deleted namespace",
@@ -1730,7 +1730,7 @@ NsEnsembleImplementationCmdNR(
 	return TCL_ERROR;
    }

-    if (ensemblePtr->nsPtr->flags & NS_DEAD) {
+    if (ensemblePtr->nsPtr->flags & NS_DYING) {
 	/*
 	 * Don't know how we got here, but make things give up quickly.
 	 */
@@ -1759,7 +1759,7 @@ NsEnsembleImplementationCmdNR(
 	 */
 	EnsembleCmdRep *ensembleCmd;

-	ECRGetInternalRep(subObj, ensembleCmd);
+	ECRGetIntRep(subObj, ensembleCmd);
 	if (ensembleCmd) {
 	    if (ensembleCmd->epoch == ensemblePtr->epoch &&
 		    ensembleCmd->token == (Command *)ensemblePtr->token) {
@@ -2201,18 +2201,6 @@ TclSpellFix(
    TclNRAddCallback(interp, TclNRReleaseValues, fix, NULL, NULL, NULL);
 }

-Tcl_Obj *const *TclEnsembleGetRewriteValues(
-    Tcl_Interp *interp		/* Current interpreter. */
-)
-{
-    Interp *iPtr = (Interp *) interp;
-    Tcl_Obj *const *origObjv = iPtr->ensembleRewrite.sourceObjs;
-    if (origObjv[0] == NULL) {
-	origObjv = (Tcl_Obj *const *)origObjv[2];
-    }
-    return origObjv;
-}
-
 /*
 *----------------------------------------------------------------------
 *
@@ -2237,18 +2225,12 @@ TclFetchEnsembleRoot(
    int objc,
    int *objcPtr)
 {
-    Tcl_Obj *const *sourceObjs;
    Interp *iPtr = (Interp *) interp;

    if (iPtr->ensembleRewrite.sourceObjs) {
 	*objcPtr = objc + iPtr->ensembleRewrite.numRemovedObjs
 		- iPtr->ensembleRewrite.numInsertedObjs;
-	if (iPtr->ensembleRewrite.sourceObjs[0] == NULL) {
-	    sourceObjs = (Tcl_Obj *const *)iPtr->ensembleRewrite.sourceObjs[1];
-	} else {
-	    sourceObjs = iPtr->ensembleRewrite.sourceObjs;
-	}
-	return sourceObjs;
+	return iPtr->ensembleRewrite.sourceObjs;
    }
    *objcPtr = objc;
    return objv;
@@ -2424,7 +2406,7 @@ MakeCachedEnsembleCommand(
 {
    EnsembleCmdRep *ensembleCmd;

-    ECRGetInternalRep(objPtr, ensembleCmd);
+    ECRGetIntRep(objPtr, ensembleCmd);
    if (ensembleCmd) {
 	TclCleanupCommandMacro(ensembleCmd->token);
 	if (ensembleCmd->fix) {
@@ -2437,7 +2419,7 @@ MakeCachedEnsembleCommand(
 	 */

 	ensembleCmd = (EnsembleCmdRep *)ckalloc(sizeof(EnsembleCmdRep));
-	ECRSetInternalRep(objPtr, ensembleCmd);
+	ECRSetIntRep(objPtr, ensembleCmd);
    }

    /*
@@ -2847,7 +2829,7 @@ FreeEnsembleCmdRep(
 {
    EnsembleCmdRep *ensembleCmd;

-    ECRGetInternalRep(objPtr, ensembleCmd);
+    ECRGetIntRep(objPtr, ensembleCmd);
    TclCleanupCommandMacro(ensembleCmd->token);
    if (ensembleCmd->fix) {
 	Tcl_DecrRefCount(ensembleCmd->fix);
@@ -2881,8 +2863,8 @@ DupEnsembleCmdRep(
    EnsembleCmdRep *ensembleCmd;
    EnsembleCmdRep *ensembleCopy = (EnsembleCmdRep *)ckalloc(sizeof(EnsembleCmdRep));

-    ECRGetInternalRep(objPtr, ensembleCmd);
-    ECRSetInternalRep(copyPtr, ensembleCopy);
+    ECRGetIntRep(objPtr, ensembleCmd);
+    ECRSetIntRep(copyPtr, ensembleCopy);

    ensembleCopy->epoch = ensembleCmd->epoch;
    ensembleCopy->token = ensembleCmd->token;
@@ -420,16 +420,6 @@ Tcl_PutEnv(

    if ((value != NULL) && (value != name)) {
 	value[0] = '\0';
-#if defined(_WIN32)
-	if (tenviron == NULL) {
-	    /*
-	     * When we are started from main(), the _wenviron array could
-	     * be NULL and will be initialized by the first _wgetenv() call.
-	     */
-
-	(void) _wgetenv(L"WINDIR");
-	}
-#endif
 	TclSetEnv(name, value+1);
    }
    TclEnvEpoch++;
@@ -1618,12 +1618,6 @@ Tcl_CreateThread(
    }
    return result;
 #else
-    (void)idPtr;
-    (void)proc;
-    (void)clientData;
-    (void)stackSize;
-    (void)flags;
-
    return TCL_ERROR;
 #endif /* TCL_THREADS */
 }
@@ -15,6 +15,8 @@
 * this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

+#define _BUILD_TCL_EXECUTE 1	/* Disable some warnings */
+
 #include "tclInt.h"
 #include "tclCompile.h"
 #include "tclOOInt.h"
@@ -509,11 +511,11 @@ VarHashCreateVar(
 */

 #define GetNumberFromObj(interp, objPtr, ptrPtr, tPtr) \
-    ((TclHasInternalRep((objPtr), &tclIntType))					\
+    ((TclHasIntRep((objPtr), &tclIntType))					\
 	?	(*(tPtr) = TCL_NUMBER_INT,				\
 		*(ptrPtr) = (ClientData)				\
 		    (&((objPtr)->internalRep.wideValue)), TCL_OK) :	\
-    TclHasInternalRep((objPtr), &tclDoubleType)				\
+    TclHasIntRep((objPtr), &tclDoubleType)				\
 	?	(((TclIsNaN((objPtr)->internalRep.doubleValue))		\
 		    ?	(*(tPtr) = TCL_NUMBER_NAN)			\
 		    :	(*(tPtr) = TCL_NUMBER_DOUBLE)),			\
@@ -759,9 +761,9 @@ ReleaseDictIterator(
 {
    Tcl_DictSearch *searchPtr;
    Tcl_Obj *dictPtr;
-    const Tcl_ObjInternalRep *irPtr;
+    const Tcl_ObjIntRep *irPtr;

-    irPtr = TclFetchInternalRep(objPtr, &dictIteratorType);
+    irPtr = TclFetchIntRep(objPtr, &dictIteratorType);
    assert(irPtr != NULL);

    /*
@@ -1474,7 +1476,7 @@ CompileExprObj(
     * is valid in the current context.
     */

-    ByteCodeGetInternalRep(objPtr, &exprCodeType, codePtr);
+    ByteCodeGetIntRep(objPtr, &exprCodeType, codePtr);

    if (codePtr != NULL) {
 	Namespace *namespacePtr = iPtr->varFramePtr->nsPtr;
@@ -1484,7 +1486,7 @@ CompileExprObj(
 		|| (codePtr->nsPtr != namespacePtr)
 		|| (codePtr->nsEpoch != namespacePtr->resolverEpoch)
 		|| (codePtr->localCachePtr != iPtr->varFramePtr->localCachePtr)) {
-	    Tcl_StoreInternalRep(objPtr, &exprCodeType, NULL);
+	    Tcl_StoreIntRep(objPtr, &exprCodeType, NULL);
 	    codePtr = NULL;
 	}
    }
@@ -1538,7 +1540,7 @@ CompileExprObj(
 * DupExprCodeInternalRep --
 *
 *	Part of the Tcl object type implementation for Tcl expression
- *	bytecode. We do not copy the bytecode internalrep. Instead, we return
+ *	bytecode. We do not copy the bytecode intrep. Instead, we return
 *	without setting copyPtr->typePtr, so the copy is a plain string copy
 *	of the expression value, and if it is to be used as a compiled
 *	expression, it will just need a recompile.
@@ -1547,7 +1549,7 @@ CompileExprObj(
 *	usual (only?) time Tcl_DuplicateObj() will be called is when the copy
 *	is about to be modified, which would invalidate any copied bytecode
 *	anyway. The only reason it might make sense to copy the bytecode is if
- *	we had some modifying routines that operated directly on the internalrep,
+ *	we had some modifying routines that operated directly on the intrep,
 *	like we do for lists and dicts.
 *
 * Results:
@@ -1590,7 +1592,7 @@ FreeExprCodeInternalRep(
    Tcl_Obj *objPtr)
 {
    ByteCode *codePtr;
-    ByteCodeGetInternalRep(objPtr, &exprCodeType, codePtr);
+    ByteCodeGetIntRep(objPtr, &exprCodeType, codePtr);
    assert(codePtr != NULL);

    TclReleaseByteCode(codePtr);
@@ -1629,7 +1631,7 @@ TclCompileObj(
     * compilation). Otherwise, check that it is "fresh" enough.
     */

-    ByteCodeGetInternalRep(objPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetIntRep(objPtr, &tclByteCodeType, codePtr);
    if (codePtr != NULL) {
 	/*
 	 * Make sure the Bytecode hasn't been invalidated by, e.g., someone
@@ -1775,7 +1777,7 @@ TclCompileObj(
    iPtr->invokeWord = word;
    TclSetByteCodeFromAny(interp, objPtr, NULL, NULL);
    iPtr->invokeCmdFramePtr = NULL;
-    ByteCodeGetInternalRep(objPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetIntRep(objPtr, &tclByteCodeType, codePtr);
    if (iPtr->varFramePtr->localCachePtr) {
 	codePtr->localCachePtr = iPtr->varFramePtr->localCachePtr;
 	codePtr->localCachePtr->refCount++;
@@ -2506,7 +2508,6 @@ TEBCresume(
 	Tcl_IncrRefCount(valuePtr);
 	iPtr->execEnvPtr = corPtr->callerEEPtr;
 	TclSetTailcall(interp, valuePtr);
-	corPtr->yieldPtr = valuePtr;
 	iPtr->execEnvPtr = corPtr->eePtr;
 	yieldParameter = (PTR2INT(NULL)+1);	/*==CORO_ACTIVATE_YIELDM*/

@@ -4864,7 +4865,7 @@ TEBCresume(
 	 */

 	if ((TclListObjGetElements(interp, valuePtr, &objc, &objv) == TCL_OK)
-		&& !TclHasInternalRep(value2Ptr, &tclListType)) {
+		&& !TclHasIntRep(value2Ptr, &tclListType)) {
 	    int code;

 	    DECACHE_STACK_INFO();
@@ -5262,7 +5263,7 @@ TEBCresume(
 	} else {
 	    length = Tcl_UtfToUpper(TclGetString(valuePtr));
 	    Tcl_SetObjLength(valuePtr, length);
-	    TclFreeInternalRep(valuePtr);
+	    TclFreeIntRep(valuePtr);
 	    TRACE_APPEND(("\"%.20s\"\n", O2S(valuePtr)));
 	    NEXT_INST_F(1, 0, 0);
 	}
@@ -5279,7 +5280,7 @@ TEBCresume(
 	} else {
 	    length = Tcl_UtfToLower(TclGetString(valuePtr));
 	    Tcl_SetObjLength(valuePtr, length);
-	    TclFreeInternalRep(valuePtr);
+	    TclFreeIntRep(valuePtr);
 	    TRACE_APPEND(("\"%.20s\"\n", O2S(valuePtr)));
 	    NEXT_INST_F(1, 0, 0);
 	}
@@ -5296,7 +5297,7 @@ TEBCresume(
 	} else {
 	    length = Tcl_UtfToTitle(TclGetString(valuePtr));
 	    Tcl_SetObjLength(valuePtr, length);
-	    TclFreeInternalRep(valuePtr);
+	    TclFreeIntRep(valuePtr);
 	    TRACE_APPEND(("\"%.20s\"\n", O2S(valuePtr)));
 	    NEXT_INST_F(1, 0, 0);
 	}
@@ -5610,8 +5611,8 @@ TEBCresume(
 	 * both.
 	 */

-	if (TclHasInternalRep(valuePtr, &tclStringType)
-		|| TclHasInternalRep(value2Ptr, &tclStringType)) {
+	if (TclHasIntRep(valuePtr, &tclStringType)
+		|| TclHasIntRep(value2Ptr, &tclStringType)) {
 	    Tcl_UniChar *ustring1, *ustring2;

 	    ustring1 = Tcl_GetUnicodeFromObj(valuePtr, &length);
@@ -6400,7 +6401,7 @@ TEBCresume(
 	if (Tcl_IsShared(valuePtr)) {
 	    /*
 	     * Here we do some surgery within the Tcl_Obj internals. We want
-	     * to copy the internalrep, but not the string, so we temporarily hide
+	     * to copy the intrep, but not the string, so we temporarily hide
 	     * the string so we do not copy it.
 	     */

@@ -6425,7 +6426,7 @@ TEBCresume(

    case INST_TRY_CVT_TO_BOOLEAN:
 	valuePtr = OBJ_AT_TOS;
-	if (TclHasInternalRep(valuePtr,  &tclBooleanType)) {
+	if (TclHasIntRep(valuePtr,  &tclBooleanType)) {
 	    objResultPtr = TCONST(1);
 	} else {
 	    int res = (TclSetBooleanFromAny(NULL, valuePtr) == TCL_OK);
@@ -7260,7 +7261,7 @@ TEBCresume(

 	    /*
 	     * dictPtr is no longer on the stack, and we're not
-	     * moving it into the internalrep of an iterator.  We need
+	     * moving it into the intrep of an iterator.  We need
 	     * to drop the refcount [Tcl Bug 9b352768e6].
 	     */

@@ -7270,15 +7271,15 @@ TEBCresume(
 	    goto gotError;
 	}
 	{
-	    Tcl_ObjInternalRep ir;
+	    Tcl_ObjIntRep ir;
 	    TclNewObj(statePtr);
 	    ir.twoPtrValue.ptr1 = searchPtr;
 	    ir.twoPtrValue.ptr2 = dictPtr;
-	    Tcl_StoreInternalRep(statePtr, &dictIteratorType, &ir);
+	    Tcl_StoreIntRep(statePtr, &dictIteratorType, &ir);
 	}
 	varPtr = LOCAL(opnd);
 	if (varPtr->value.objPtr) {
-	    if (TclHasInternalRep(varPtr->value.objPtr, &dictIteratorType)) {
+	    if (TclHasIntRep(varPtr->value.objPtr, &dictIteratorType)) {
 		Tcl_Panic("mis-issued dictFirst!");
 	    }
 	    TclDecrRefCount(varPtr->value.objPtr);
@@ -7292,10 +7293,10 @@ TEBCresume(
 	TRACE(("%u => ", opnd));
 	statePtr = (*LOCAL(opnd)).value.objPtr;
 	{
-	    const Tcl_ObjInternalRep *irPtr;
+	    const Tcl_ObjIntRep *irPtr;

 	    if (statePtr &&
-		    (irPtr = TclFetchInternalRep(statePtr, &dictIteratorType))) {
+		    (irPtr = TclFetchIntRep(statePtr, &dictIteratorType))) {
 		searchPtr = (Tcl_DictSearch *)irPtr->twoPtrValue.ptr1;
 		Tcl_DictObjNext(searchPtr, &keyPtr, &valuePtr, &done);
 	    } else {
@@ -8818,7 +8819,7 @@ ExecuteExtendedUnaryMathOp(
    int opcode,			/* What operation to perform. */
    Tcl_Obj *valuePtr)		/* The operand on the stack. */
 {
-    ClientData ptr = NULL;
+    ClientData ptr;
    int type;
    Tcl_WideInt w;
    mp_int big;
@@ -9852,7 +9853,7 @@ EvalStatsCmd(
    for (i = 0;  i < globalTablePtr->numBuckets;  i++) {
 	for (entryPtr = globalTablePtr->buckets[i];  entryPtr != NULL;
 		entryPtr = entryPtr->nextPtr) {
-	    if (TclHasInternalRep(entryPtr->objPtr, &tclByteCodeType)) {
+	    if (TclHasIntRep(entryPtr->objPtr, &tclByteCodeType)) {
 		numByteCodeLits++;
 	    }
 	    (void) TclGetStringFromObj(entryPtr->objPtr, &length);
@@ -53,7 +53,7 @@ Tcl_GetInt(
    if (obj.refCount > 1) {
 	Tcl_Panic("invalid sharing of Tcl_Obj on C stack");
    }
-    TclFreeInternalRep(&obj);
+    TclFreeIntRep(&obj);
    return code;
 }

@@ -97,7 +97,7 @@ Tcl_GetDouble(
    if (obj.refCount > 1) {
 	Tcl_Panic("invalid sharing of Tcl_Obj on C stack");
    }
-    TclFreeInternalRep(&obj);
+    TclFreeIntRep(&obj);
    return code;
 }

@@ -324,30 +324,30 @@ typedef struct ResolvedChanName {
    size_t refCount;		/* Share this struct among many Tcl_Obj. */
 } ResolvedChanName;

-static void		DupChannelInternalRep(Tcl_Obj *objPtr, Tcl_Obj *copyPtr);
-static void		FreeChannelInternalRep(Tcl_Obj *objPtr);
+static void		DupChannelIntRep(Tcl_Obj *objPtr, Tcl_Obj *copyPtr);
+static void		FreeChannelIntRep(Tcl_Obj *objPtr);

 static const Tcl_ObjType chanObjType = {
    "channel",			/* name for this type */
-    FreeChannelInternalRep,		/* freeIntRepProc */
-    DupChannelInternalRep,		/* dupIntRepProc */
+    FreeChannelIntRep,		/* freeIntRepProc */
+    DupChannelIntRep,		/* dupIntRepProc */
    NULL,			/* updateStringProc */
    NULL			/* setFromAnyProc */
 };

-#define ChanSetInternalRep(objPtr, resPtr)					\
+#define ChanSetIntRep(objPtr, resPtr)					\
    do {								\
-	Tcl_ObjInternalRep ir;						\
+	Tcl_ObjIntRep ir;						\
 	(resPtr)->refCount++;						\
 	ir.twoPtrValue.ptr1 = (resPtr);					\
 	ir.twoPtrValue.ptr2 = NULL;					\
-	Tcl_StoreInternalRep((objPtr), &chanObjType, &ir);			\
+	Tcl_StoreIntRep((objPtr), &chanObjType, &ir);			\
    } while (0)

-#define ChanGetInternalRep(objPtr, resPtr)					\
+#define ChanGetIntRep(objPtr, resPtr)					\
    do {								\
-	const Tcl_ObjInternalRep *irPtr;					\
-	irPtr = TclFetchInternalRep((objPtr), &chanObjType);		\
+	const Tcl_ObjIntRep *irPtr;					\
+	irPtr = TclFetchIntRep((objPtr), &chanObjType);		\
 	(resPtr) = irPtr ? (ResolvedChanName *)irPtr->twoPtrValue.ptr1 : NULL;		\
    } while (0)

@@ -1524,7 +1524,7 @@ TclGetChannelFromObj(
 	return TCL_ERROR;
    }

-    ChanGetInternalRep(objPtr, resPtr);
+    ChanGetIntRep(objPtr, resPtr);
    if (resPtr) {
 	/*
 	 * Confirm validity of saved lookup results.
@@ -1546,7 +1546,7 @@ TclGetChannelFromObj(

    if (chan == NULL) {
 	if (resPtr) {
-	    Tcl_StoreInternalRep(objPtr, &chanObjType, NULL);
+	    Tcl_StoreIntRep(objPtr, &chanObjType, NULL);
 	}
 	return TCL_ERROR;
    }
@@ -1560,7 +1560,7 @@ TclGetChannelFromObj(
    } else {
 	resPtr = (ResolvedChanName *) ckalloc(sizeof(ResolvedChanName));
 	resPtr->refCount = 0;
-	ChanSetInternalRep(objPtr, resPtr);		/* Overwrites, if needed */
+	ChanSetIntRep(objPtr, resPtr);		/* Overwrites, if needed */
    }
    statePtr = ((Channel *)chan)->state;
    resPtr->statePtr = statePtr;
@@ -3660,7 +3660,7 @@ Tcl_CloseEx(
     * That won't do.
     */

-    if (GotFlag(statePtr, CHANNEL_INCLOSE)) {
+    if (statePtr->flags & CHANNEL_INCLOSE) {
 	if (interp) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
                    "illegal recursive call to close through close-handler"
@@ -4321,7 +4321,6 @@ Write(
 				/* State info for channel */
    char *nextNewLine = NULL;
    int endEncoding, saved = 0, total = 0, flushed = 0, needNlFlush = 0;
-    char safe[BUFFER_PADDING];

    if (srcLen) {
        WillWrite(chanPtr);
@@ -4340,7 +4339,7 @@ Write(

    while (srcLen + saved + endEncoding > 0) {
 	ChannelBuffer *bufPtr;
-	char *dst;
+	char *dst, safe[BUFFER_PADDING];
 	int result, srcRead, dstLen, dstWrote, srcLimit = srcLen;

 	if (nextNewLine) {
@@ -4385,7 +4384,7 @@ Write(

 	    ReleaseChannelBuffer(bufPtr);
 	    if (total == 0) {
-		Tcl_SetErrno(EILSEQ);
+		Tcl_SetErrno(EINVAL);
 		return -1;
 	    }
 	    break;
@@ -8606,12 +8605,9 @@ ChannelTimerProc(
    ClientData clientData)
 {
    Channel *chanPtr = (Channel *)clientData;
-
-    /* State info for channel */
    ChannelState *statePtr = chanPtr->state;
+				/* State info for channel */

-	/* Preserve chanPtr to guard against deallocation in Tcl_NotifyChannel. */
-    TclChannelPreserve((Tcl_Channel)chanPtr);
    Tcl_Preserve(statePtr);
    statePtr->timer = NULL;
    if (statePtr->interestMask & TCL_WRITABLE
@@ -8627,27 +8623,22 @@ ChannelTimerProc(
 	Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_WRITABLE);
    }

-    /* The channel may have just been closed from within Tcl_NotifyChannel */
-    if (!GotFlag(statePtr, CHANNEL_INCLOSE)) {
-	if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA)
-		&& (statePtr->interestMask & TCL_READABLE)
-		&& (statePtr->inQueueHead != NULL)
-		&& IsBufferReady(statePtr->inQueueHead)) {
-	    /*
-	     * Restart the timer in case a channel handler reenters the event loop
-	     * before UpdateInterest gets called by Tcl_NotifyChannel.
-	     */
+    if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA)
+	    && (statePtr->interestMask & TCL_READABLE)
+	    && (statePtr->inQueueHead != NULL)
+	    && IsBufferReady(statePtr->inQueueHead)) {
+	/*
+	 * Restart the timer in case a channel handler reenters the event loop
+	 * before UpdateInterest gets called by Tcl_NotifyChannel.
+	 */

-	    statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME,
-		    ChannelTimerProc,chanPtr);
-	    Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_READABLE);
-	} else {
-	    UpdateInterest(chanPtr);
-	}
+	statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME,
+                ChannelTimerProc,chanPtr);
+	Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_READABLE);
+    } else {
+	UpdateInterest(chanPtr);
    }
-
    Tcl_Release(statePtr);
-    TclChannelRelease((Tcl_Channel)chanPtr);
 }

 /*
@@ -8712,7 +8703,7 @@ Tcl_CreateChannelHandler(

    /*
     * The remainder of the initialization below is done regardless of whether
-     * this is a new record or a modification of an old one.
+     * or not this is a new record or a modification of an old one.
     */

    chPtr->mask = mask;
@@ -9436,13 +9427,13 @@ MBWrite(
    if (bufPtr) {
 	/* Split the overflowing buffer in two */
 	int extra = (int) (inBytes - csPtr->toRead);
-	/* Note that going with int for extra assumes that inBytes is not too
-	 * much over toRead to require a wide itself. If that gets violated
-	 * then the calculations involving extra must be made wide too.
-	 *
-	 * Noted with Win32/MSVC debug build treating the warning (possible of
-	 * data in long long to int conversion) as error.
-	 */
+        /* Note that going with int for extra assumes that inBytes is not too
+         * much over toRead to require a wide itself. If that gets violated
+         * then the calculations involving extra must be made wide too.
+         *
+         * Noted with Win32/MSVC debug build treating the warning (possible of
+         * data in __int64 to int conversion) as error.
+         */

 	bufPtr = AllocChannelBuffer(extra);

@@ -10975,17 +10966,15 @@ Tcl_SetChannelErrorInterp(
    Tcl_Obj *msg)		/* Error message to store. */
 {
    Interp *iPtr = (Interp *) interp;
-    Tcl_Obj *disposePtr = iPtr->chanMsg;
+
+    if (iPtr->chanMsg != NULL) {
+	TclDecrRefCount(iPtr->chanMsg);
+	iPtr->chanMsg = NULL;
+    }

    if (msg != NULL) {
 	iPtr->chanMsg = FixLevelCode(msg);
 	Tcl_IncrRefCount(iPtr->chanMsg);
-    } else {
-	iPtr->chanMsg = NULL;
-    }
-
-    if (disposePtr != NULL) {
-        TclDecrRefCount(disposePtr);
    }
    return;
 }
@@ -11013,17 +11002,15 @@ Tcl_SetChannelError(
    Tcl_Obj *msg)		/* Error message to store. */
 {
    ChannelState *statePtr = ((Channel *) chan)->state;
-    Tcl_Obj *disposePtr = statePtr->chanMsg;
+
+    if (statePtr->chanMsg != NULL) {
+	TclDecrRefCount(statePtr->chanMsg);
+	statePtr->chanMsg = NULL;
+    }

    if (msg != NULL) {
 	statePtr->chanMsg = FixLevelCode(msg);
 	Tcl_IncrRefCount(statePtr->chanMsg);
-    } else {
-	statePtr->chanMsg = NULL;
-    }
-
-    if (disposePtr != NULL) {
-        TclDecrRefCount(disposePtr);
    }
    return;
 }
@@ -11274,7 +11261,7 @@ Tcl_ChannelTruncateProc(
 /*
 *----------------------------------------------------------------------
 *
- * DupChannelInternalRep --
+ * DupChannelIntRep --
 *
 *	Initialize the internal representation of a new Tcl_Obj to a copy of
 *	the internal representation of an existing string object.
@@ -11290,7 +11277,7 @@ Tcl_ChannelTruncateProc(
 */

 static void
-DupChannelInternalRep(
+DupChannelIntRep(
    Tcl_Obj *srcPtr,	/* Object with internal rep to copy. Must have
 				 * an internal rep of type "Channel". */
    Tcl_Obj *copyPtr)	/* Object with internal rep to set. Must not
@@ -11298,15 +11285,15 @@ DupChannelInternalRep(
 {
    ResolvedChanName *resPtr;

-    ChanGetInternalRep(srcPtr, resPtr);
+    ChanGetIntRep(srcPtr, resPtr);
    assert(resPtr);
-    ChanSetInternalRep(copyPtr, resPtr);
+    ChanSetIntRep(copyPtr, resPtr);
 }

 /*
 *----------------------------------------------------------------------
 *
- * FreeChannelInternalRep --
+ * FreeChannelIntRep --
 *
 *	Release statePtr storage.
 *
@@ -11320,12 +11307,12 @@ DupChannelInternalRep(
 */

 static void
-FreeChannelInternalRep(
+FreeChannelIntRep(
    Tcl_Obj *objPtr)		/* Object with internal rep to free. */
 {
    ResolvedChanName *resPtr;

-    ChanGetInternalRep(objPtr, resPtr);
+    ChanGetIntRep(objPtr, resPtr);
    assert(resPtr);
    if (resPtr->refCount-- > 1) {
 	return;
@@ -68,18 +68,22 @@ static int		ExecuteCallback(TransformChannelData *ctrl,
 * the procedure what to do with the result of the script it calls.
 */

-#define TRANSMIT_DONT	0	/* No transfer to do. */
-#define TRANSMIT_DOWN	1	/* Transfer to the underlying channel. */
-#define TRANSMIT_SELF	2	/* Transfer into our channel. */
-#define TRANSMIT_IBUF	3	/* Transfer to internal input buffer. */
-#define TRANSMIT_NUM	4	/* Transfer number to 'maxRead'. */
+enum TransmitAction {
+    TRANSMIT_DONT = 0,		/* No transfer to do. */
+    TRANSMIT_DOWN = 1,		/* Transfer to the underlying channel. */
+    TRANSMIT_SELF = 2,		/* Transfer into our channel. */
+    TRANSMIT_IBUF = 3,		/* Transfer to internal input buffer. */
+    TRANSMIT_NUM = 4		/* Transfer number to 'maxRead'. */
+};

 /*
 * Codes for 'preserve' of 'ExecuteCallback'.
 */

-#define P_PRESERVE	1
-#define P_NO_PRESERVE	0
+enum PreserveFlags {
+    P_PRESERVE = 1,
+    P_NO_PRESERVE = 0
+};

 /*
 * Strings for the action codes delivered to the script implementing a
@@ -44,7 +44,7 @@ static void		ReflectThread(ClientData clientData, int action);
 static int		ReflectEventRun(Tcl_Event *ev, int flags);
 static int		ReflectEventDelete(Tcl_Event *ev, ClientData cd);
 #endif
-static long long ReflectSeekWide(ClientData clientData,
+static long long        ReflectSeekWide(ClientData clientData,
 			    long long offset, int mode, int *errorCodePtr);
 #ifndef TCL_NO_DEPRECATED
 static int		ReflectSeek(ClientData clientData, long offset,
@@ -58,8 +58,8 @@ static int		ReflectSetOption(ClientData clientData,
 			    const char *newValue);
 static int		ReflectTruncate(ClientData clientData,
 			    long long length);
-static void     TimerRunRead(ClientData clientData);
-static void     TimerRunWrite(ClientData clientData);
+static void             TimerRunRead(ClientData clientData);
+static void             TimerRunWrite(ClientData clientData);

 /*
 * The C layer channel type/driver definition used by the reflection.
@@ -80,7 +80,7 @@ static const Tcl_ChannelType tclRChannelType = {
    ReflectGetOption,	   /* Get options.			NULL'able */
    ReflectWatch,	   /* Initialize notifier			  */
    NULL,		   /* Get OS handle from the channel.	NULL'able */
-    ReflectClose,	   /* No close2 support.		NULL'able */
+	ReflectClose,	   /* No close2 support.		NULL'able */
    ReflectBlock,	   /* Set blocking/nonblocking.		NULL'able */
    NULL,		   /* Flush channel. Not used by core.	NULL'able */
    NULL,		   /* Handle events.			NULL'able */
@@ -104,33 +104,27 @@ typedef struct {
 				 * Tcl level part of the channel. NULL here
 				 * signals the channel is dead because the
 				 * interpreter/thread containing its Tcl
-				 * command is gone.
-				 */
+				 * command is gone. */
 #if TCL_THREADS
-    Tcl_ThreadId thread;	/* Thread the 'interp' belongs to. == Handler thread */
-    Tcl_ThreadId owner;         /* Thread owning the structure.    == Channel thread */
+    Tcl_ThreadId thread;	/* Thread the 'interp' belongs to. == Handler
+                                 * thread */
+    Tcl_ThreadId owner;         /* Thread owning the structure.  == Channel
+                                 * thread */
 #endif
    Tcl_Obj *cmd;		/* Callback command prefix */
    Tcl_Obj *methods;		/* Methods to append to command prefix */
    Tcl_Obj *name;		/* Name of the channel as created */
-
    int mode;			/* Mask of R/W mode */
    int interest;		/* Mask of events the channel is interested
 				 * in. */
-
    int dead;			/* Boolean signal that some operations
 				 * should no longer be attempted. */
-
-    Tcl_TimerToken readTimer;   /*
-				   A token for the timer that is scheduled in
-				   order to call Tcl_NotifyChannel when the
-				   channel is readable
-			        */
-    Tcl_TimerToken writeTimer;  /*
-				   A token for the timer that is scheduled in
-				   order to call Tcl_NotifyChannel when the
-				   channel is writable
-			        */
+    Tcl_TimerToken readTimer;   /* A token for the timer that is scheduled in
+                                 * order to call Tcl_NotifyChannel when the
+                                 * channel is readable */
+    Tcl_TimerToken writeTimer;  /* A token for the timer that is scheduled in
+                                 * order to call Tcl_NotifyChannel when the
+                                 * channel is writable */

    /*
     * Note regarding the usage of timers.
@@ -1156,7 +1150,7 @@ TclChanCaughtErrorBypass(
 * ReflectClose --
 *
 *	This function is invoked when the channel is closed, to delete the
- *	driver-specific instance data.
+ *	driver specific instance data.
 *
 * Results:
 *	A posix error.
@@ -1189,8 +1183,8 @@ ReflectClose(
 	/*
 	 * This call comes from TclFinalizeIOSystem. There are no
 	 * interpreters, and therefore we cannot call upon the handler command
-	 * anymore. Threading is irrelevant as well. Simply clean up all
-	 * the C level data structures and leave the Tcl level to the other
+	 * anymore. Threading is irrelevant as well. We simply clean up all
+	 * our C level data structures and leave the Tcl level to the other
 	 * finalization functions.
 	 */

@@ -2090,7 +2084,7 @@ ReflectTruncate(
     * Are we in the correct thread?
     */

-#if TCL_THREADS
+#ifdef TCL_THREADS
    if (rcPtr->thread != Tcl_GetCurrentThread()) {
 	ForwardParam p;

@@ -2766,8 +2760,6 @@ DeleteReflectedChannelMap(
 	MarkDead(rcPtr);
 	Tcl_DeleteHashEntry(hPtr);
    }
-#else
-    (void)interp;
 #endif
 }

@@ -476,8 +476,10 @@ static int		TransformLimit(ReflectedTransform *rtPtr,
 * Operation codes for TransformFlush().
 */

-#define FLUSH_WRITE	1
-#define FLUSH_DISCARD	0
+enum FlushOperations {
+    FLUSH_WRITE = 1,
+    FLUSH_DISCARD = 0
+};

 /*
 * Main methods to plug into the 'chan' ensemble'. ==================
@@ -1113,7 +1115,6 @@ ReflectInput(
 	    goto stop;
 	}

-
 	/*
 	 * The buffer is exhausted, but the caller wants even more. We now
 	 * have to go to the underlying channel, get more bytes and then
@@ -1149,12 +1150,10 @@ ReflectInput(
 	    goto stop;
 	}

-
 	readBytes = Tcl_ReadRaw(rtPtr->parent,
 		(char *) Tcl_SetByteArrayLength(bufObj, toRead), toRead);
 	if (readBytes < 0) {
 	    if (Tcl_InputBlocked(rtPtr->parent) && (gotBytes > 0)) {
-
 		/*
 		 * Down channel is blocked and offers zero additional bytes.
 		 * The nonzero gotBytes already returned makes the total
@@ -1165,11 +1164,10 @@ ReflectInput(
 	    }

 	    /*
-	     * Either the down channel is not blocked (a real error)
-	     * or it is and there are gotBytes==0 byte copied so far.
-	     * In either case, pass up the error, so we either report
-	     * any real error, or do not mistakenly signal EOF by
-	     * returning 0 to the caller.
+	     * Either the down channel is not blocked (a real error) or it is
+	     * and there are gotBytes==0 byte copied so far.  In either case,
+	     * pass up the error, so we either report any real error, or do
+	     * not mistakenly signal EOF by returning 0 to the caller.
 	     */

 	    *errorCodePtr = Tcl_GetErrno();
@@ -1177,34 +1175,33 @@ ReflectInput(
 	}

 	if (readBytes == 0) {
-
 	    /*
-	     * Zero returned from Tcl_ReadRaw() always indicates EOF
-	     * on the down channel.
+	     * Zero returned from Tcl_ReadRaw() always indicates EOF on the
+	     * down channel.
 	     */

 	    rtPtr->eofPending = 1;

+	    /*
+	     * Now this is a bit different. The partial data waiting is
+	     * converted and returned.
+	     */
+
+	    if (HAS(rtPtr->methods, METH_DRAIN)) {
+		if (!TransformDrain(rtPtr, errorCodePtr)) {
+		    goto error;
+		}
+	    }
+
+	    if (ResultLength(&rtPtr->result) == 0) {
 		/*
-		 * Now this is a bit different. The partial data waiting is
-		 * converted and returned.
+		 * The drain delivered nothing.
 		 */

-		if (HAS(rtPtr->methods, METH_DRAIN)) {
-		    if (!TransformDrain(rtPtr, errorCodePtr)) {
-			goto error;
-		    }
-		}
+		goto stop;
+	    }

-		if (ResultLength(&rtPtr->result) == 0) {
-		    /*
-		     * The drain delivered nothing.
-		     */
-
-		    goto stop;
-		}
-
-		continue; /* at: while (toRead > 0) */
+	    continue; /* at: while (toRead > 0) */
 	} /* readBytes == 0 */

 	/*
@@ -1388,16 +1385,15 @@ ReflectSeekWide(
 	    curPos = -1;
 	} else {
 	    curPos = Tcl_ChannelSeekProc(parent->typePtr)(
-	    parent->instanceData, offset, seekMode,
-	    errorCodePtr);
+		    parent->instanceData, offset, seekMode, errorCodePtr);
 	}
 #else
 	*errorCodePtr = EINVAL;
 	curPos = -1;
 #endif
    } else {
-    	curPos = Tcl_ChannelWideSeekProc(parent->typePtr)(parent->instanceData, offset,
-    		seekMode, errorCodePtr);
+    	curPos = Tcl_ChannelWideSeekProc(parent->typePtr)(parent->instanceData,
+		offset, seekMode, errorCodePtr);
    }
    if (curPos == -1) {
 	Tcl_SetErrno(*errorCodePtr);
@@ -1423,8 +1419,7 @@ ReflectSeek(
     * routine.
     */

-    return ReflectSeekWide(clientData, offset, seekMode,
-	    errorCodePtr);
+    return ReflectSeekWide(clientData, offset, seekMode, errorCodePtr);
 }
 #endif

@@ -2158,8 +2153,6 @@ DeleteReflectedTransformMap(
    ForwardingResult *resultPtr;
    ForwardingEvent *evPtr;
    ForwardParam *paramPtr;
-#else
-    (void)interp;
 #endif /* TCL_THREADS */

    /*
@@ -2646,9 +2646,8 @@ Tcl_FSGetCwd(
 		norm = TclFSNormalizeAbsolutePath(interp,retVal);
 		if (norm != NULL) {
 		    /*
-		     * Assign to global storage the pathname of the current
-		     * directory and copy it into thread-local storage as
-		     * well.
+		     * Assign to global storage the pathname of the current directory
+		     * and copy it into thread-local storage as well.
 		     *
 		     * At system startup multiple threads could in principle
 		     * call this function simultaneously, which is a little
@@ -3790,12 +3789,10 @@ Tcl_FSListVolumes(void)

 	    if (thisFsVolumes != NULL) {
 		Tcl_ListObjAppendList(NULL, resultPtr, thisFsVolumes);
-		/*
-		 * The refCount of each list returned by a `listVolumesProc`
-		 * is already incremented.  Do not hang onto the list, though.
-		 * It belongs to the filesystem.  Add its contents to the
-		 * result we are building, and then decrement the refCount.
-		 */
+		/* The refCount of each list returned by a `listVolumesProc` is
+		 * already incremented.  Do not hang onto the list, though.  It
+		 * belongs to the filesystem.  Add its contents to * the result
+		 * we are building, and then decrement the refCount.  */
 		Tcl_DecrRefCount(thisFsVolumes);
 	    }
 	}
@@ -4368,14 +4365,15 @@ Tcl_FSCreateDirectory(

 int
 Tcl_FSCopyDirectory(
-    Tcl_Obj *srcPathPtr,	/* The pathname of the directory to be
-				 * copied. */
+    Tcl_Obj *srcPathPtr,	/*
+				 * The pathname of the directory to be copied.
+				 */
    Tcl_Obj *destPathPtr,	/* The pathname of the target directory. */
    Tcl_Obj **errorPtr)		/* If not NULL, and there is an error, a place
-				 * to store a pointer to a new object, with
-				 * its refCount already incremented, and
-				 * containing the pathname name of file
-				 * causing the error. */
+				 *  to store a pointer to a new object, with
+				 *  its refCount already incremented, and
+				 *  containing the pathname name of file
+				 *  causing the error. */
 {
    int retVal = -1;
    const Tcl_Filesystem *fsPtr, *fsPtr2;
@@ -122,7 +122,7 @@ Tcl_GetIndexFromObj(
     * the common case where the result is cached).
     */

-    const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objPtr, &indexType);
+    const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objPtr, &indexType);

    if (irPtr) {
 	IndexRep *indexRep = (IndexRep *)irPtr->twoPtrValue.ptr1;
@@ -270,7 +270,7 @@ Tcl_GetIndexFromObjStruct(
    const char *const *entryPtr;
    Tcl_Obj *resultPtr;
    IndexRep *indexRep;
-    const Tcl_ObjInternalRep *irPtr;
+    const Tcl_ObjIntRep *irPtr;

    /* Protect against invalid values, like -1 or 0. */
    if (offset < (int)sizeof(char *)) {
@@ -281,7 +281,7 @@ Tcl_GetIndexFromObjStruct(
     */

    if (!(flags & TCL_INDEX_TEMP_TABLE)) {
-    irPtr = TclFetchInternalRep(objPtr, &indexType);
+    irPtr = TclFetchIntRep(objPtr, &indexType);
    if (irPtr) {
 	indexRep = (IndexRep *)irPtr->twoPtrValue.ptr1;
 	if (indexRep->tablePtr==tablePtr && indexRep->offset==offset) {
@@ -345,15 +345,15 @@ Tcl_GetIndexFromObjStruct(
     */

    if (!(flags & TCL_INDEX_TEMP_TABLE)) {
-    irPtr = TclFetchInternalRep(objPtr, &indexType);
+    irPtr = TclFetchIntRep(objPtr, &indexType);
    if (irPtr) {
 	indexRep = (IndexRep *)irPtr->twoPtrValue.ptr1;
    } else {
-	Tcl_ObjInternalRep ir;
+	Tcl_ObjIntRep ir;

 	indexRep = (IndexRep*)ckalloc(sizeof(IndexRep));
 	ir.twoPtrValue.ptr1 = indexRep;
-	Tcl_StoreInternalRep(objPtr, &indexType, &ir);
+	Tcl_StoreIntRep(objPtr, &indexType, &ir);
    }
    indexRep->tablePtr = (void *) tablePtr;
    indexRep->offset = offset;
@@ -423,7 +423,7 @@ static void
 UpdateStringOfIndex(
    Tcl_Obj *objPtr)
 {
-    IndexRep *indexRep = (IndexRep *)TclFetchInternalRep(objPtr, &indexType)->twoPtrValue.ptr1;
+    IndexRep *indexRep = (IndexRep *)TclFetchIntRep(objPtr, &indexType)->twoPtrValue.ptr1;
    const char *indexStr = EXPAND_OF(indexRep);

    Tcl_InitStringRep(objPtr, indexStr, strlen(indexStr));
@@ -452,14 +452,14 @@ DupIndex(
    Tcl_Obj *srcPtr,
    Tcl_Obj *dupPtr)
 {
-    Tcl_ObjInternalRep ir;
+    Tcl_ObjIntRep ir;
    IndexRep *dupIndexRep = (IndexRep *)ckalloc(sizeof(IndexRep));

-    memcpy(dupIndexRep, TclFetchInternalRep(srcPtr, &indexType)->twoPtrValue.ptr1,
+    memcpy(dupIndexRep, TclFetchIntRep(srcPtr, &indexType)->twoPtrValue.ptr1,
 	    sizeof(IndexRep));

    ir.twoPtrValue.ptr1 = dupIndexRep;
-    Tcl_StoreInternalRep(dupPtr, &indexType, &ir);
+    Tcl_StoreIntRep(dupPtr, &indexType, &ir);
 }

 /*
@@ -483,7 +483,7 @@ static void
 FreeIndex(
    Tcl_Obj *objPtr)
 {
-    ckfree(TclFetchInternalRep(objPtr, &indexType)->twoPtrValue.ptr1);
+    ckfree(TclFetchIntRep(objPtr, &indexType)->twoPtrValue.ptr1);
    objPtr->typePtr = NULL;
 }

@@ -887,19 +887,27 @@ Tcl_WrongNumArgs(
    }

    /*
-     * If processing an an ensemble implementation, rewrite the results in
-     * terms of how the ensemble was invoked.
+     * Check to see if we are processing an ensemble implementation, and if so
+     * rewrite the results in terms of how the ensemble was invoked.
     */

    if (iPtr->ensembleRewrite.sourceObjs != NULL) {
 	int toSkip = iPtr->ensembleRewrite.numInsertedObjs;
 	int toPrint = iPtr->ensembleRewrite.numRemovedObjs;
-	Tcl_Obj *const *origObjv = TclEnsembleGetRewriteValues(interp);
+	Tcl_Obj *const *origObjv = iPtr->ensembleRewrite.sourceObjs;

 	/*
-	 * Only do rewrite the command if all the replaced objects are
+	 * Check for spelling fixes, and substitute the fixed values.
+	 */
+
+	if (origObjv[0] == NULL) {
+	    origObjv = (Tcl_Obj *const *)origObjv[2];
+	}
+
+	/*
+	 * We only know how to do rewriting if all the replaced objects are
 	 * actually arguments (in objv) to this function. Otherwise it just
-	 * gets too complicated and it's to just give a slightly
+	 * gets too complicated and we'd be better off just giving a slightly
 	 * confusing error message...
 	 */

@@ -922,9 +930,9 @@ Tcl_WrongNumArgs(
 	    /*
 	     * Add the element, quoting it if necessary.
 	     */
-	    const Tcl_ObjInternalRep *irPtr;
+	    const Tcl_ObjIntRep *irPtr;

-	    if ((irPtr = TclFetchInternalRep(origObjv[i], &indexType))) {
+	    if ((irPtr = TclFetchIntRep(origObjv[i], &indexType))) {
 		IndexRep *indexRep = (IndexRep *)irPtr->twoPtrValue.ptr1;

 		elementStr = EXPAND_OF(indexRep);
@@ -971,9 +979,9 @@ Tcl_WrongNumArgs(
 	 * the correct error message even if the subcommand was abbreviated.
 	 * Otherwise, just use the string rep.
 	 */
-	const Tcl_ObjInternalRep *irPtr;
+	const Tcl_ObjIntRep *irPtr;

-	if ((irPtr = TclFetchInternalRep(objv[i], &indexType))) {
+	if ((irPtr = TclFetchIntRep(objv[i], &indexType))) {
 	    IndexRep *indexRep = (IndexRep *)irPtr->twoPtrValue.ptr1;

 	    Tcl_AppendStringsToObj(objPtr, EXPAND_OF(indexRep), NULL);
@@ -1418,7 +1426,7 @@ TclGetCompletionCodeFromObj(
 	"ok", "error", "return", "break", "continue", NULL
    };

-    if (!TclHasInternalRep(value, &indexType)
+    if (!TclHasIntRep(value, &indexType)
 	    && TclGetIntFromObj(NULL, value, codePtr) == TCL_OK) {
 	return TCL_OK;
    }
--- a/Show More
+++ b/Show More