Index: .fossil-settings/binary-glob
==================================================================
--- .fossil-settings/binary-glob
+++ .fossil-settings/binary-glob
@@ -1,9 +1,11 @@
-compat/zlib/win32/zdll.lib
-compat/zlib/win32/zlib1.dll
-compat/zlib/win64/zdll.lib
-compat/zlib/win64/zlib1.dll
-compat/zlib/win64/libz.dll.a
-compat/zlib/zlib.3.pdf
-*.bmp
+*.a
+*.dll
+*.exe
 *.gif
+*.gz
+*.jpg
+*.lib
+*.pdf
 *.png
+*.xlsx
+*.zip

ADDED   .gitattributes
Index: .gitattributes
==================================================================
--- /dev/null
+++ .gitattributes
@@ -0,0 +1,39 @@
+# Set the default behavior, in case people don't have core.autocrlf set.
+* eol=lf
+* text=auto
+
+# Explicitly declare text files you want to always be normalized and converted
+# to native line endings on checkout.
+*.3 text
+*.c text
+*.css text
+*.enc text
+*.h text
+*.htm text
+*.html text
+*.java text
+*.js text
+*.json text
+*.n text
+*.svg text
+*.ts text
+*.tcl text
+*.test text
+
+# Declare files that will always have CRLF line endings on checkout.
+*.bat eol=crlf
+*.sln eol=crlf
+*.vc eol=crlf
+
+# Denote all files that are truly binary and should not be modified.
+*.a binary
+*.dll binary
+*.exe binary
+*.gif binary
+*.gz binary
+*.jpg binary
+*.lib binary
+*.pdf binary
+*.png binary
+*.xlsx binary
+*.zip binary

ADDED   .gitignore
Index: .gitignore
==================================================================
--- /dev/null
+++ .gitignore
@@ -0,0 +1,50 @@
+*.a
+*.dll
+*.dylib
+*.exe
+*.exp
+*.lib
+*.o
+*.obj
+*.pdb
+*.res
+*.sl
+*.so
+*/Makefile
+*/config.cache
+*/config.log
+*/config.status
+*/tclConfig.sh
+*/tclsh*
+*/tcltest*
+*/versions.vc
+*/version.vc
+html
+libtommath/bn.ilg
+libtommath/bn.ind
+libtommath/pretty.build
+libtommath/tommath.src
+libtommath/*.log
+libtommath/*.pdf
+libtommath/*.pl
+libtommath/*.sh
+libtommath/doc/*
+libtommath/tombc/*
+libtommath/pre_gen/*
+libtommath/pics/*
+libtommath/mtest/*
+libtommath/logs/*
+libtommath/etc/*
+libtommath/demo/*
+libtommath/*.out
+libtommath/*.tex
+unix/autoMkindex.tcl
+unix/dltest.marker
+unix/tcl.pc
+unix/tclIndex
+unix/pkgs/*
+win/Debug*
+win/Release*
+win/pkgs/*
+win/tcl.hpj
+win/nmhlp-out.txt

Index: .project
==================================================================
--- .project
+++ .project
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
-	<name>tcl9</name>
+	<name>tcl8</name>
 	<comment></comment>
 	<projects>
 	</projects>
 	<buildSpec>
 	</buildSpec>

Index: .travis.yml
==================================================================
--- .travis.yml
+++ .travis.yml
@@ -1,66 +1,58 @@
 sudo: false
 language: c
 
 matrix:
   include:
-    - os: linux
-      dist: xenial
-      compiler: clang
-      env:
-        - BUILD_DIR=unix
-    - os: linux
-      dist: xenial
-      compiler: clang
-      env:
-        - CFGOPT=--disable-shared
-        - BUILD_DIR=unix
-    - os: linux
-      dist: xenial
-      compiler: gcc
-      env:
-        - BUILD_DIR=unix
-    - os: linux
-      dist: xenial
-      compiler: gcc
-      env:
-        - CFGOPT=--disable-shared
-        - BUILD_DIR=unix
-    - os: linux
-      dist: xenial
-      compiler: gcc-4.9
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-4.9
-      env:
-        - BUILD_DIR=unix
-    - os: linux
-      dist: xenial
-      compiler: gcc-5
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-5
-      env:
-        - BUILD_DIR=unix
-    - os: linux
-      dist: xenial
-      compiler: gcc-6
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-6
-      env:
-        - BUILD_DIR=unix
-    - os: linux
+# Testing on Linux with various compilers
+    - name: "Linux/GCC/Shared"
+      os: linux
+      dist: xenial
+      compiler: gcc
+      env:
+        - BUILD_DIR=unix
+    - name: "Linux/GCC/Static"
+      os: linux
+      dist: xenial
+      compiler: gcc
+      env:
+        - CFGOPT=--disable-shared
+        - BUILD_DIR=unix
+    - name: "Linux/GCC/Shared: UTF_MAX=6"
+      os: linux
+      dist: xenial
+      compiler: gcc
+      env:
+        - BUILD_DIR=unix
+        - CFGOPT=CFLAGS=-DTCL_UTF_MAX=6
+    - name: "Linux/GCC/Shared: UTF_MAX=3"
+      os: linux
+      dist: xenial
+      compiler: gcc
+      env:
+        - BUILD_DIR=unix
+        - CFGOPT=CFLAGS=-DTCL_UTF_MAX=3
+    - name: "Linux/GCC/Shared: NO_DEPRECATED"
+      os: linux
+      dist: xenial
+      compiler: gcc
+      env:
+        - BUILD_DIR=unix
+        - CFGOPT=CFLAGS=-DTCL_NO_DEPRECATED=1
+# Debug build. Running test-cases disabled, because it is currently failing.
+    - name: "Linux/GCC/Debug/no test"
+      os: linux
+      dist: xenial
+      compiler: gcc
+      env:
+        - BUILD_DIR=unix
+        - CFGOPT=--enable-symbols=all
+      script:
+        - make all tcltest
+# Older versions of GCC...
+    - name: "Linux/GCC 7/Shared"
+      os: linux
       dist: xenial
       compiler: gcc-7
       addons:
         apt:
           sources:
@@ -67,75 +59,114 @@
             - ubuntu-toolchain-r-test
           packages:
             - g++-7
       env:
         - BUILD_DIR=unix
-    - os: linux
-      dist: xenial
-      compiler: gcc-7
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-7
-      env:
-        - BUILD_DIR=unix
-        - CFGOPT=CFLAGS=-DTCL_UTF_MAX=6
-    - os: linux
-      dist: xenial
-      compiler: gcc-7
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-7
-      env:
-        - BUILD_DIR=unix
-        - CFGOPT=CFLAGS=-DTCL_UTF_MAX=3
-    - os: linux
-      dist: xenial
-      compiler: gcc-7
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-7
-      env:
-        - BUILD_DIR=unix
-        - CFGOPT=CFLAGS=-DTCL_NO_DEPRECATED=1
-    - os: osx
-      osx_image: xcode8
-      env:
-        - BUILD_DIR=unix
-    - os: osx
-      osx_image: xcode8
-      env:
-        - BUILD_DIR=macosx
-        - NO_DIRECT_CONFIGURE=1
-    - os: osx
-      osx_image: xcode9
-      env:
-        - BUILD_DIR=macosx
-        - NO_DIRECT_CONFIGURE=1
-    - os: osx
-      osx_image: xcode10.2
-      env:
-        - BUILD_DIR=macosx
-        - NO_DIRECT_CONFIGURE=1
-### C builds not currently supported on Windows instances
-#    - os: windows
-#      env:
-#        - BUILD_DIR=win
-### ... so proxy with a Mingw cross-compile
-# Test with mingw-w64 (32 bit)
-    - os: linux
-      dist: xenial
-      compiler: i686-w64-mingw32-gcc
-      addons:
+    - name: "Linux/GCC 6/Shared"
+      os: linux
+      dist: xenial
+      compiler: gcc-6
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-6
+      env:
+        - BUILD_DIR=unix
+    - name: "Linux/GCC 5/Shared"
+      os: linux
+      dist: xenial
+      compiler: gcc-5
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-5
+      env:
+        - BUILD_DIR=unix
+    - name: "Linux/GCC 4.9/Shared"
+      os: linux
+      dist: xenial
+      compiler: gcc-4.9
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-4.9
+      env:
+        - BUILD_DIR=unix
+# Clang
+    - name: "Linux/Clang/Shared"
+      os: linux
+      dist: xenial
+      compiler: clang
+      env:
+        - BUILD_DIR=unix
+    - name: "Linux/Clang/Static"
+      os: linux
+      dist: xenial
+      compiler: clang
+      env:
+        - CFGOPT=--disable-shared
+        - BUILD_DIR=unix
+# Debug build. Running test-cases disabled, because it is currently failing.
+    - name: "Linux/Clang/Debug/no test"
+      os: linux
+      dist: xenial
+      compiler: clang
+      env:
+        - BUILD_DIR=unix
+        - CFGOPT=--enable-symbols=all
+      script:
+        - make all tcltest
+# Testing on Mac, various styles
+    - name: "macOS/Xcode 11/Shared/Unix-like"
+      os: osx
+      osx_image: xcode11
+      env:
+        - BUILD_DIR=unix
+    - name: "macOS/Xcode 11/Shared"
+      os: osx
+      osx_image: xcode11
+      env:
+        - BUILD_DIR=macosx
+      install: []
+      script: &mactest
+        - make all
+        # The styles=develop avoids some weird problems on OSX
+        - make test styles=develop
+    - name: "macOS/Xcode 10/Shared"
+      os: osx
+      osx_image: xcode10.2
+      env:
+        - BUILD_DIR=macosx
+      install: []
+      script: *mactest
+    - name: "macOS/Xcode 9/Shared"
+      os: osx
+      osx_image: xcode9
+      env:
+        - BUILD_DIR=macosx
+      install: []
+      script: *mactest
+    - name: "macOS/Xcode 8/Shared"
+      os: osx
+      osx_image: xcode8
+      env:
+        - BUILD_DIR=macosx
+      install: []
+      script: *mactest
+# Test with mingw-w64 (32 bit) cross-compile
+# Doesn't run tests because wine is only an imperfect Windows emulation
+    - name: "Linux-cross-Windows-32/GCC/Shared/no test"
+      os: linux
+      dist: xenial
+      compiler: i686-w64-mingw32-gcc
+      addons: &mingw32
         apt:
           packages:
             - gcc-mingw-w64-base
             - binutils-mingw-w64-i686
             - gcc-mingw-w64-i686
@@ -143,80 +174,67 @@
             - gcc-multilib
             - wine
       env:
         - BUILD_DIR=win
         - CFGOPT=--host=i686-w64-mingw32
-        - NO_DIRECT_TEST=1
-    - os: linux
+      script: &crosstest
+        - make all tcltest
+        # Include a high visibility marker that tests are skipped outright
+        - >
+          echo "`tput setaf 3`SKIPPED TEST: CROSS COMPILING`tput sgr0`"
+    - name: "Linux-cross-Windows-32/GCC/Static/no test"
+      os: linux
       dist: xenial
       compiler: i686-w64-mingw32-gcc
-      addons:
-        apt:
-          packages:
-            - gcc-mingw-w64-base
-            - binutils-mingw-w64-i686
-            - gcc-mingw-w64-i686
-            - gcc-mingw-w64
-            - gcc-multilib
-            - wine
+      addons: *mingw32
       env:
         - BUILD_DIR=win
         - CFGOPT="--host=i686-w64-mingw32 --disable-shared"
-        - NO_DIRECT_TEST=1
-    - os: linux
+      script: *crosstest
+    - name: "Linux-cross-Windows-32/GCC/Shared/no test: UTF_MAX=6"
+      os: linux
       dist: xenial
       compiler: i686-w64-mingw32-gcc
-      addons:
-        apt:
-          packages:
-            - gcc-mingw-w64-base
-            - binutils-mingw-w64-i686
-            - gcc-mingw-w64-i686
-            - gcc-mingw-w64
-            - gcc-multilib
-            - wine
+      addons: *mingw32
       env:
         - BUILD_DIR=win
         - CFGOPT="--host=i686-w64-mingw32 CFLAGS=-DTCL_UTF_MAX=6"
-        - NO_DIRECT_TEST=1
-    - os: linux
+      script: *crosstest
+    - name: "Linux-cross-Windows-32/GCC/Shared/no test: UTF_MAX=3"
+      os: linux
       dist: xenial
       compiler: i686-w64-mingw32-gcc
-      addons:
-        apt:
-          packages:
-            - gcc-mingw-w64-base
-            - binutils-mingw-w64-i686
-            - gcc-mingw-w64-i686
-            - gcc-mingw-w64
-            - gcc-multilib
-            - wine
+      addons: *mingw32
       env:
         - BUILD_DIR=win
         - CFGOPT="--host=i686-w64-mingw32 CFLAGS=-DTCL_UTF_MAX=3"
-        - NO_DIRECT_TEST=1
-    - os: linux
+      script: *crosstest
+    - name: "Linux-cross-Windows-32/GCC/Shared/no test: NO_DEPRECATED"
+      os: linux
       dist: xenial
       compiler: i686-w64-mingw32-gcc
-      addons:
-        apt:
-          packages:
-            - gcc-mingw-w64-base
-            - binutils-mingw-w64-i686
-            - gcc-mingw-w64-i686
-            - gcc-mingw-w64
-            - gcc-multilib
-            - wine
+      addons: *mingw32
       env:
         - BUILD_DIR=win
         - CFGOPT="--host=i686-w64-mingw32 CFLAGS=-DTCL_NO_DEPRECATED=1"
-        - NO_DIRECT_TEST=1
+      script: *crosstest
+    - name: "Linux-cross-Windows-32/GCC/Debug/no test"
+      os: linux
+      dist: xenial
+      compiler: i686-w64-mingw32-gcc
+      addons: *mingw32
+      env:
+        - BUILD_DIR=win
+        - CFGOPT="--host=i686-w64-mingw32 --enable-symbols"
+      script: *crosstest
 # Test with mingw-w64 (64 bit)
-    - os: linux
+# Doesn't run tests because wine is only an imperfect Windows emulation
+    - name: "Linux-cross-Windows-64/GCC/Shared/no test"
+      os: linux
       dist: xenial
       compiler: x86_64-w64-mingw32-gcc
-      addons:
+      addons: &mingw64
         apt:
           packages:
             - gcc-mingw-w64-base
             - binutils-mingw-w64-x86-64
             - gcc-mingw-w64-x86-64
@@ -223,75 +241,165 @@
             - gcc-mingw-w64
             - wine
       env:
         - BUILD_DIR=win
         - CFGOPT="--host=x86_64-w64-mingw32 --enable-64bit"
-        - NO_DIRECT_TEST=1
-    - os: linux
+      script: *crosstest
+    - name: "Linux-cross-Windows-64/GCC/Static/no test"
+      os: linux
       dist: xenial
       compiler: x86_64-w64-mingw32-gcc
-      addons:
-        apt:
-          packages:
-            - gcc-mingw-w64-base
-            - binutils-mingw-w64-x86-64
-            - gcc-mingw-w64-x86-64
-            - gcc-mingw-w64
-            - wine
+      addons: *mingw64
       env:
         - BUILD_DIR=win
         - CFGOPT="--host=x86_64-w64-mingw32 --enable-64bit --disable-shared"
-        - NO_DIRECT_TEST=1
-    - os: linux
+      script: *crosstest
+    - name: "Linux-cross-Windows-64/GCC/Shared/no test: UTF_MAX=6"
+      os: linux
       dist: xenial
       compiler: x86_64-w64-mingw32-gcc
-      addons:
-        apt:
-          packages:
-            - gcc-mingw-w64-base
-            - binutils-mingw-w64-x86-64
-            - gcc-mingw-w64-x86-64
-            - gcc-mingw-w64
-            - wine
+      addons: *mingw64
       env:
         - BUILD_DIR=win
         - CFGOPT="--host=x86_64-w64-mingw32 --enable-64bit CFLAGS=-DTCL_UTF_MAX=6"
-        - NO_DIRECT_TEST=1
-    - os: linux
+      script: *crosstest
+    - name: "Linux-cross-Windows-64/GCC/Shared/no test: UTF_MAX=3"
+      os: linux
       dist: xenial
       compiler: x86_64-w64-mingw32-gcc
-      addons:
-        apt:
-          packages:
-            - gcc-mingw-w64-base
-            - binutils-mingw-w64-x86-64
-            - gcc-mingw-w64-x86-64
-            - gcc-mingw-w64
-            - wine
+      addons: *mingw64
       env:
         - BUILD_DIR=win
         - CFGOPT="--host=x86_64-w64-mingw32 --enable-64bit CFLAGS=-DTCL_UTF_MAX=3"
-        - NO_DIRECT_TEST=1
-    - os: linux
+      script: *crosstest
+    - name: "Linux-cross-Windows-64/GCC/Shared/no test: NO_DEPRECATED"
+      os: linux
       dist: xenial
       compiler: x86_64-w64-mingw32-gcc
-      addons:
-        apt:
-          packages:
-            - gcc-mingw-w64-base
-            - binutils-mingw-w64-x86-64
-            - gcc-mingw-w64-x86-64
-            - gcc-mingw-w64
-            - wine
+      addons: *mingw64
       env:
         - BUILD_DIR=win
         - CFGOPT="--host=x86_64-w64-mingw32 --enable-64bit CFLAGS=-DTCL_NO_DEPRECATED=1"
-        - NO_DIRECT_TEST=1
+      script: *crosstest
+    - name: "Linux-cross-Windows-64/GCC/Debug/no test"
+      os: linux
+      dist: xenial
+      compiler: x86_64-w64-mingw32-gcc
+      addons: *mingw64
+      env:
+        - BUILD_DIR=win
+        - CFGOPT="--host=x86_64-w64-mingw32 --enable-64bit --enable-symbols"
+      script: *crosstest
+# Test on Windows with MSVC native
+    - name: "Windows/MSVC/Shared"
+      os: windows
+      compiler: cl
+      env: &vcenv
+        - BUILD_DIR=win
+        - VCDIR="/C/Program Files (x86)/Microsoft Visual Studio/2017/BuildTools/VC/Auxiliary/Build"
+      before_install: &vcpreinst
+        - PATH="$PATH:$VCDIR"
+        - cd ${BUILD_DIR}
+      install: []
+      script:
+        - cmd.exe /C 'vcvarsall.bat x64 && nmake -f makefile.vc all tcltest'
+        - cmd.exe /C 'vcvarsall.bat x64 && nmake -f makefile.vc test'
+    - name: "Windows/MSVC/Shared: UTF_MAX=6"
+      os: windows
+      compiler: cl
+      env: *vcenv
+      before_install: *vcpreinst
+      install: []
+      script:
+        - cmd.exe /C 'vcvarsall.bat x64 && nmake OPTS=utfmax -f makefile.vc all tcltest'
+        - cmd.exe /C 'vcvarsall.bat x64 && nmake OPTS=utfmax -f makefile.vc test'
+    - name: "Windows/MSVC/Shared: NO_DEPRECATED"
+      os: windows
+      compiler: cl
+      env: *vcenv
+      before_install: *vcpreinst
+      install: []
+      script:
+        - cmd.exe /C 'vcvarsall.bat x64 && nmake OPTS=nodep -f makefile.vc all tcltest'
+        - cmd.exe /C 'vcvarsall.bat x64 && nmake OPTS=nodep -f makefile.vc test'
+    - name: "Windows/MSVC/Static"
+      os: windows
+      compiler: cl
+      env: *vcenv
+      before_install: *vcpreinst
+      install: []
+      script:
+        - cmd.exe /C 'vcvarsall.bat x64 && nmake OPTS=static -f makefile.vc all tcltest'
+        - cmd.exe /C 'vcvarsall.bat x64 && nmake OPTS=static -f makefile.vc test'
+    - name: "Windows/MSVC/Debug"
+      os: windows
+      compiler: cl
+      env: *vcenv
+      before_install: *vcpreinst
+      install: []
+      script:
+        - cmd.exe /C 'vcvarsall.bat x64 && nmake OPTS=symbols -f makefile.vc all tcltest'
+        - cmd.exe /C 'vcvarsall.bat x64 && nmake OPTS=symbols -f makefile.vc test'
+# Test on Windows with GCC native
+    - name: "Windows/GCC/Shared"
+      os: windows
+      compiler: gcc
+      env:
+        - BUILD_DIR=win
+        - CFGOPT="--enable-64bit"
+      before_install:
+        - choco install make
+        - cd ${BUILD_DIR}
+    - name: "Windows/GCC/Shared: UTF_MAX=6"
+      os: windows
+      compiler: gcc
+      env:
+        - BUILD_DIR=win
+        - CFGOPT="--enable-64bit CFLAGS=-DTCL_UTF_MAX=6"
+      before_install:
+        - choco install make
+        - cd ${BUILD_DIR}
+    - name: "Windows/GCC/Shared: UTF_MAX=3"
+      os: windows
+      compiler: gcc
+      env:
+        - BUILD_DIR=win
+        - CFGOPT="--enable-64bit CFLAGS=-DTCL_UTF_MAX=3"
+      before_install:
+        - choco install make
+        - cd ${BUILD_DIR}
+    - name: "Windows/GCC/Shared: NO_DEPRECATED"
+      os: windows
+      compiler: gcc
+      env:
+        - BUILD_DIR=win
+        - CFGOPT="--enable-64bit CFLAGS=-DTCL_NO_DEPRECATED=1"
+      before_install:
+        - choco install make
+        - cd ${BUILD_DIR}
+    - name: "Windows/GCC/Static"
+      os: windows
+      compiler: gcc
+      env:
+        - BUILD_DIR=win
+        - CFGOPT="--enable-64bit --disable-shared"
+      before_install:
+        - choco install make
+        - cd ${BUILD_DIR}
+    - name: "Windows/GCC/Debug"
+      os: windows
+      compiler: gcc
+      env:
+        - BUILD_DIR=win
+        - CFGOPT="--enable-64bit --enable-symbols"
+      before_install:
+        - choco install make
+        - cd ${BUILD_DIR}
 before_install:
-  - export ERROR_ON_FAILURES=1
   - cd ${BUILD_DIR}
 install:
-  - test -n "$NO_DIRECT_CONFIGURE" || ./configure ${CFGOPT}
+  - ./configure ${CFGOPT} --prefix=$HOME || (cat config.log && exit 1)
+before_script:
+  - export ERROR_ON_FAILURES=1
 script:
-  - make
-  # The styles=develop avoids some weird problems on OSX
-  - test -n "$NO_DIRECT_TEST" || make test styles=develop
+  - make all tcltest
+  - make test

Index: README.md
==================================================================
--- README.md
+++ README.md
@@ -1,13 +1,13 @@
 # README:  Tcl
 
-This is the **Tcl 9.0a0** source distribution.
+This is the **Tcl 8.7a2** source distribution.
 
 You can get any source release of Tcl from [our distribution
 site](https://sourceforge.net/projects/tcl/files/Tcl/).
 
-[![Build Status](https://travis-ci.org/tcltk/tcl.svg?branch=master)](https://travis-ci.org/tcltk/tcl)
+[![Build Status](https://travis-ci.org/tcltk/tcl.svg?branch=core-8-branch)](https://travis-ci.org/tcltk/tcl)
 
 ## Contents
  1. [Introduction](#intro)
  2. [Documentation](#doc)
  3. [Compiling and installing Tcl](#build)
@@ -41,22 +41,22 @@
 `license.terms` for complete information.
 
 ## <a id="doc">2.</a> Documentation
 Extensive documentation is available at our website.
 The home page for this release, including new features, is
-[here](https://www.tcl.tk/software/tcltk/9.0.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.
 
 Information about Tcl itself can be found at the [Developer
 Xchange](https://www.tcl-lang.org/about/).
 There have been many Tcl books on the market.  Many are mentioned in
 [the Wiki](https://wiki.tcl-lang.org/_/ref?N=25206).
 
-The complete set of reference manual entries for Tcl 9.0 is [online,
-here](https://www.tcl-lang.org/man/tcl9.0/).
+The complete set of reference manual entries for Tcl 8.7 is [online,
+here](https://www.tcl-lang.org/man/tcl8.7/).
 
 ### <a id="doc.unix">2a.</a> Unix Documentation
 The `doc` subdirectory in this release contains a complete set of
 reference manual entries for Tcl.  Files with extension "`.1`" are for
 programs (for example, `tclsh.1`); files with extension "`.3`" are for C

Index: compat/fake-rfc2553.c
==================================================================
--- compat/fake-rfc2553.c
+++ compat/fake-rfc2553.c
@@ -71,10 +71,11 @@
                 size_t hostlen, char *serv, size_t servlen, int flags)
 {
 	struct sockaddr_in *sin = (struct sockaddr_in *)sa;
 	struct hostent *hp;
 	char tmpserv[16];
+	(void)salen;
 
 	if (sa->sa_family != AF_UNSPEC && sa->sa_family != AF_INET)
 		return (EAI_FAMILY);
 	if (serv != NULL) {
 		snprintf(tmpserv, sizeof(tmpserv), "%d", ntohs(sin->sin_port));
@@ -151,11 +152,11 @@
 static struct
 addrinfo *malloc_ai(int port, u_long addr, const struct addrinfo *hints)
 {
 	struct addrinfo *ai;
 
-	ai = malloc(sizeof(*ai) + sizeof(struct sockaddr_in));
+	ai = (struct addrinfo *)malloc(sizeof(*ai) + sizeof(struct sockaddr_in));
 	if (ai == NULL)
 		return (NULL);
 
 	memset(ai, '\0', sizeof(*ai) + sizeof(struct sockaddr_in));
 

Index: compat/gettod.c
==================================================================
--- compat/gettod.c
+++ compat/gettod.c
@@ -19,12 +19,13 @@
 gettimeofday(
     struct timeval *tp,
     struct timezone *tz)
 {
     struct timeb t;
+    (void)tz;
 
     ftime(&t);
     tp->tv_sec = t.time;
-    tp->tv_usec = t. millitm * 1000;
+    tp->tv_usec = t.millitm * 1000;
     return 0;
 }
 

Index: compat/mkstemp.c
==================================================================
--- compat/mkstemp.c
+++ compat/mkstemp.c
@@ -11,10 +11,11 @@
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <string.h>
 
 /*
  *----------------------------------------------------------------------
  *
  * mkstemp --
@@ -30,23 +31,23 @@
  *----------------------------------------------------------------------
  */
 
 int
 mkstemp(
-    char *template)		/* Template for filename. */
+    char *tmpl)		/* Template for filename. */
 {
     static const char alphanumerics[] =
 	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-    register char *a, *b;
+    char *a, *b;
     int fd, count, alphanumericsLen = strlen(alphanumerics); /* == 62 */
 
-    a = template + strlen(template);
-    while (a > template && *(a-1) == 'X') {
+    a = tmpl + strlen(tmpl);
+    while (a > tmpl && *(a-1) == 'X') {
 	a--;
     }
 
-    if (a == template) {
+    if (a == tmpl) {
 	errno = ENOENT;
 	return -1;
     }
 
     /*
@@ -69,10 +70,10 @@
 
 	/*
 	 * Template is now realized; try to open (with correct options).
 	 */
 
-	fd = open(template, O_RDWR|O_CREAT|O_EXCL, 0600);
+	fd = open(tmpl, O_RDWR|O_CREAT|O_EXCL, 0600);
     } while (fd == -1 && errno == EEXIST && --count > 0);
 
     return fd;
 }

Index: compat/opendir.c
==================================================================
--- compat/opendir.c
+++ compat/opendir.c
@@ -18,19 +18,19 @@
 
 DIR *
 opendir(
     char *name)
 {
-    register DIR *dirp;
-    register int fd;
-    char *myname;
+    DIR *dirp;
+    int fd;
+    const char *myname;
 
     myname = ((*name == '\0') ? "." : name);
     if ((fd = open(myname, 0, 0)) == -1) {
 	return NULL;
     }
-    dirp = (DIR *) Tcl_Alloc(sizeof(DIR));
+    dirp = (DIR *) ckalloc(sizeof(DIR));
     if (dirp == NULL) {
 	/* unreachable? */
 	close(fd);
 	return NULL;
     }
@@ -63,13 +63,13 @@
  * get next entry in a directory.
  */
 
 struct dirent *
 readdir(
-    register DIR *dirp)
+    DIR *dirp)
 {
-    register struct olddirect *dp;
+    struct olddirect *dp;
     static struct dirent dir;
 
     for (;;) {
 	if (dirp->dd_loc == 0) {
 	    dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf, DIRBLKSIZ);
@@ -99,12 +99,12 @@
  * close a directory.
  */
 
 void
 closedir(
-    register DIR *dirp)
+    DIR *dirp)
 {
     close(dirp->dd_fd);
     dirp->dd_fd = -1;
     dirp->dd_loc = 0;
-    Tcl_Free(dirp);
+    ckfree(dirp);
 }

Index: compat/stdlib.h
==================================================================
--- compat/stdlib.h
+++ compat/stdlib.h
@@ -3,11 +3,11 @@
  *
  *	Declares facilities exported by the "stdlib" portion of the C library.
  *	This file isn't complete in the ANSI-C sense; it only declares things
  *	that are needed by Tcl. This file is needed even on many systems with
  *	their own stdlib.h (e.g. SunOS) because not all stdlib.h files declare
- *	all the procedures needed here (such as strtod).
+ *	all the procedures needed here (such as strtol/strtoul).
  *
  * Copyright (c) 1991 The Regents of the University of California.
  * Copyright (c) 1994-1998 Sun Microsystems, Inc.
  *
  * See the file "license.terms" for information on usage and redistribution of

Index: compat/strstr.c
==================================================================
--- compat/strstr.c
+++ compat/strstr.c
@@ -34,14 +34,14 @@
  *----------------------------------------------------------------------
  */
 
 char *
 strstr(
-    register char *string,	/* String to search. */
+    char *string,		/* String to search. */
     char *substring)		/* Substring to try to find in string. */
 {
-    register char *a, *b;
+    char *a, *b;
 
     /*
      * First scan quickly through the two strings looking for a
      * single-character match. When it's found, then compare the rest of the
      * substring.

Index: compat/strtol.c
==================================================================
--- compat/strtol.c
+++ compat/strtol.c
@@ -43,11 +43,11 @@
 				 * If 0, then the base is chosen from the
 				 * leading characters of string: "0x" means
 				 * hex, "0" means octal, anything else means
 				 * decimal. */
 {
-    register const char *p;
+    const char *p;
     long result;
 
     /*
      * Skip any leading blanks.
      */

Index: compat/strtoul.c
==================================================================
--- compat/strtoul.c
+++ compat/strtoul.c
@@ -60,13 +60,13 @@
 				 * If 0, then the base is chosen from the
 				 * leading characters of string: "0x" means
 				 * hex, "0" means octal, anything else means
 				 * decimal. */
 {
-    register const char *p;
-    register unsigned long int result = 0;
-    register unsigned digit;
+    const char *p;
+    unsigned long int result = 0;
+    unsigned digit;
     int anyDigits = 0;
     int negative=0;
     int overflow=0;
 
     /*

Index: compat/waitpid.c
==================================================================
--- compat/waitpid.c
+++ compat/waitpid.c
@@ -68,11 +68,11 @@
     int *statusPtr,		/* Where to store wait status for the
 				 * process. */
     int options)		/* OR'ed combination of WNOHANG and
 				 * WUNTRACED. */
 {
-    register WaitInfo *waitPtr, *prevPtr;
+    WaitInfo *waitPtr, *prevPtr;
     pid_t result;
     WAIT_STATUS_TYPE status;
 
     if ((pid < -1) || (pid == 0)) {
 	errno = EINVAL;
@@ -98,11 +98,11 @@
 	if (prevPtr == NULL) {
 	    deadList = waitPtr->nextPtr;
 	} else {
 	    prevPtr->nextPtr = waitPtr->nextPtr;
 	}
-	Tcl_Free(waitPtr);
+	ckfree(waitPtr);
 	return result;
     }
 
     /*
      * Wait for any process to stop or exit. If it's an acceptable one then
@@ -154,15 +154,15 @@
 	    if (waitPtr->pid == result) {
 		waitPtr->status = status;
 		goto waitAgain;
 	    }
 	}
-	waitPtr = (WaitInfo *) Tcl_Alloc(sizeof(WaitInfo));
+	waitPtr = (WaitInfo *) ckalloc(sizeof(WaitInfo));
 	waitPtr->pid = result;
 	waitPtr->status = status;
 	waitPtr->nextPtr = deadList;
 	deadList = waitPtr;
 
     waitAgain:
 	continue;
     }
 }

Index: compat/zlib/contrib/minizip/crypt.h
==================================================================
--- compat/zlib/contrib/minizip/crypt.h
+++ compat/zlib/contrib/minizip/crypt.h
@@ -55,11 +55,11 @@
 {
     (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
     (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
     (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
     {
-      register int keyshift = (int)((*(pkeys+1)) >> 24);
+      int keyshift = (int)((*(pkeys+1)) >> 24);
       (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
     }
     return c;
 }
 

Index: compat/zlib/contrib/minizip/minizip.c
==================================================================
--- compat/zlib/contrib/minizip/minizip.c
+++ compat/zlib/contrib/minizip/minizip.c
@@ -68,12 +68,12 @@
 #define WRITEBUFFERSIZE (16384)
 #define MAXFILENAME (256)
 
 #ifdef _WIN32
 uLong filetime(f, tmzip, dt)
-    char *f;                /* name of file to get info on */
-    tm_zip *tmzip;             /* return value: access, modific. and creation times */
+    const char *f;         /* name of file to get info on */
+    tm_zip *tmzip;         /* return value: access, modific. and creation times */
     uLong *dt;             /* dostime */
 {
   int ret = 0;
   {
       FILETIME ftLocal;
@@ -92,11 +92,11 @@
   return ret;
 }
 #else
 #if defined(unix) || defined(__APPLE__)
 uLong filetime(f, tmzip, dt)
-    char *f;               /* name of file to get info on */
+    const char *f;         /* name of file to get info on */
     tm_zip *tmzip;         /* return value: access, modific. and creation times */
     uLong *dt;             /* dostime */
 {
   int ret=0;
   struct stat s;        /* results of stat() */
@@ -134,12 +134,12 @@
 
   return ret;
 }
 #else
 uLong filetime(f, tmzip, dt)
-    char *f;                /* name of file to get info on */
-    tm_zip *tmzip;             /* return value: access, modific. and creation times */
+    const char *f;         /* name of file to get info on */
+    tm_zip *tmzip;         /* return value: access, modific. and creation times */
     uLong *dt;             /* dostime */
 {
     return 0;
 }
 #endif

Index: doc/AddErrInfo.3
==================================================================
--- doc/AddErrInfo.3
+++ doc/AddErrInfo.3
@@ -7,11 +7,11 @@
 '\"
 .TH Tcl_AddErrorInfo 3 8.5 Tcl "Tcl Library Procedures"
 .so man.macros
 .BS
 .SH NAME
-Tcl_GetReturnOptions, Tcl_SetReturnOptions, Tcl_AddErrorInfo, Tcl_AppendObjToErrorInfo, Tcl_AddObjErrorInfo, Tcl_SetObjErrorCode, Tcl_SetErrorCode, Tcl_SetErrorLine, Tcl_GetErrorLine, Tcl_PosixError, Tcl_LogCommandInfo \- retrieve or record information about errors and other return options
+Tcl_GetReturnOptions, Tcl_SetReturnOptions, Tcl_AddErrorInfo, Tcl_AppendObjToErrorInfo, Tcl_AddObjErrorInfo, Tcl_SetObjErrorCode, Tcl_SetErrorCode, Tcl_SetErrorCodeVA, Tcl_SetErrorLine, Tcl_GetErrorLine, Tcl_PosixError, Tcl_LogCommandInfo \- retrieve or record information about errors and other return options
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
 Tcl_Obj *
@@ -27,10 +27,12 @@
 \fBTcl_AddObjErrorInfo\fR(\fIinterp, message, length\fR)
 .sp
 \fBTcl_SetObjErrorCode\fR(\fIinterp, errorObjPtr\fR)
 .sp
 \fBTcl_SetErrorCode\fR(\fIinterp, element, element, ... \fB(char *) NULL\fR)
+.sp
+\fBTcl_SetErrorCodeVA\fR(\fIinterp, argList\fR)
 .sp
 \fBTcl_GetErrorLine\fR(\fIinterp\fR)
 .sp
 \fBTcl_SetErrorLine\fR(\fIinterp, lineNum\fR)
 .sp
@@ -56,14 +58,14 @@
 This byte array may contain embedded null bytes
 unless \fIlength\fR is negative.
 .AP Tcl_Obj *objPtr in
 A message to be appended to the \fB\-errorinfo\fR return option
 in the form of a Tcl_Obj value.
-.AP size_t length in
+.AP int length in
 The number of bytes to copy from \fImessage\fR when
 appending to the \fB\-errorinfo\fR return option.
-If TCL_AUTO_LENGTH, all bytes up to the first null byte are used.
+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 char *element in
 String to record as one element of the \fB\-errorcode\fR return option.
 Last \fIelement\fR argument must be NULL.
@@ -241,10 +243,13 @@
 The procedure \fBTcl_SetErrorCode\fR is also used to set the
 \fB\-errorcode\fR return option. However, it takes one or more strings to
 record instead of a value. Otherwise, it is similar to
 \fBTcl_SetObjErrorCode\fR in behavior.
 .PP
+\fBTcl_SetErrorCodeVA\fR is the same as \fBTcl_SetErrorCode\fR except that
+instead of taking a variable number of arguments it takes an argument list.
+.PP
 The procedure \fBTcl_GetErrorLine\fR is used to read the integer value
 of the \fB\-errorline\fR return option without the overhead of a full
 call to \fBTcl_GetReturnOptions\fR.  Likewise, \fBTcl_SetErrorLine\fR
 sets the \fB\-errorline\fR return option value.
 .PP

Index: doc/Alloc.3
==================================================================
--- doc/Alloc.3
+++ doc/Alloc.3
@@ -6,11 +6,11 @@
 '\"
 .TH Tcl_Alloc 3 7.5 Tcl "Tcl Library Procedures"
 .so man.macros
 .BS
 .SH NAME
-Tcl_Alloc, Tcl_Free, Tcl_Realloc, Tcl_AttemptAlloc, Tcl_AttemptRealloc \- allocate or free heap memory
+Tcl_Alloc, Tcl_Free, Tcl_Realloc, Tcl_AttemptAlloc, Tcl_AttemptRealloc, ckalloc, ckfree, ckrealloc, attemptckalloc, attemptckrealloc \- allocate or free heap memory
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
 char *
@@ -17,18 +17,33 @@
 \fBTcl_Alloc\fR(\fIsize\fR)
 .sp
 void
 \fBTcl_Free\fR(\fIptr\fR)
 .sp
-void *
+char *
 \fBTcl_Realloc\fR(\fIptr, size\fR)
 .sp
-void *
+char *
 \fBTcl_AttemptAlloc\fR(\fIsize\fR)
 .sp
-void *
+char *
 \fBTcl_AttemptRealloc\fR(\fIptr, size\fR)
+.sp
+char *
+\fBckalloc\fR(\fIsize\fR)
+.sp
+void
+\fBckfree\fR(\fIptr\fR)
+.sp
+char *
+\fBckrealloc\fR(\fIptr, size\fR)
+.sp
+char *
+\fBattemptckalloc\fR(\fIsize\fR)
+.sp
+char *
+\fBattemptckrealloc\fR(\fIptr, size\fR)
 .SH ARGUMENTS
 .AS char *size
 .AP "unsigned int" size in
 Size in bytes of the memory block to allocate.
 .AP char *ptr in
@@ -62,12 +77,16 @@
 interpreter to \fBpanic\fR if the memory allocation fails.  If the
 allocation fails, these functions will return NULL.  Note that on some
 platforms, but not all, attempting to allocate a zero-sized block of
 memory will also cause these functions to return NULL.
 .PP
-When a module or Tcl itself is compiled with \fBTCL_MEM_DEBUG\fR defined,
-the procedures \fBTcl_Alloc\fR, \fBTcl_Free\fR, \fBTcl_Realloc\fR,
-\fBTcl_AttemptAlloc\fR, and \fBTcl_AttempRealloc\fR are implemented
-as macros, redefined to be special debugging versions of these procedures.
+The procedures \fBckalloc\fR, \fBckfree\fR, \fBckrealloc\fR,
+\fBattemptckalloc\fR, and \fBattemptckrealloc\fR are implemented
+as macros.  Normally, they are synonyms for the corresponding
+procedures documented on this page.  When Tcl and all modules
+calling Tcl are compiled with \fBTCL_MEM_DEBUG\fR defined, however,
+these macros are redefined to be special debugging versions
+of these procedures.  To support Tcl's memory debugging within a
+module, use the macros rather than direct calls to \fBTcl_Alloc\fR, etc.
 
 .SH KEYWORDS
 alloc, allocation, free, malloc, memory, realloc, TCL_MEM_DEBUG

Index: doc/AllowExc.3
==================================================================
--- doc/AllowExc.3
+++ doc/AllowExc.3
@@ -28,11 +28,12 @@
 terminates with a completion code other than \fBTCL_OK\fR, \fBTCL_ERROR\fR
 or \fBTCL_RETURN\fR, then Tcl normally converts this into a \fBTCL_ERROR\fR
 return with an appropriate message.  The particular script
 evaluation procedures of Tcl that act in the manner are
 \fBTcl_EvalObjEx\fR, \fBTcl_EvalObjv\fR, \fBTcl_Eval\fR, \fBTcl_EvalEx\fR,
-\fBTcl_GlobalEval\fR, \fBTcl_GlobalEvalObj\fR and \fBTcl_VarEval\fR.
+\fBTcl_GlobalEval\fR, \fBTcl_GlobalEvalObj\fR, \fBTcl_VarEval\fR and
+\fBTcl_VarEvalVA\fR.
 .PP
 However, if \fBTcl_AllowExceptions\fR is invoked immediately before
 calling one of those a procedures, then arbitrary completion
 codes are permitted from the script, and they are returned without
 modification.

Index: doc/AssocData.3
==================================================================
--- doc/AssocData.3
+++ doc/AssocData.3
@@ -11,11 +11,11 @@
 Tcl_GetAssocData, Tcl_SetAssocData, Tcl_DeleteAssocData \- manage associations of string keys and user specified data with Tcl interpreters
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
-void *
+ClientData
 \fBTcl_GetAssocData\fR(\fIinterp, key, delProcPtr\fR)
 .sp
 \fBTcl_SetAssocData\fR(\fIinterp, key, delProc, clientData\fR)
 .sp
 \fBTcl_DeleteAssocData\fR(\fIinterp, key\fR)
@@ -29,11 +29,11 @@
 .AP Tcl_InterpDeleteProc *delProc in
 Procedure to call when \fIinterp\fR is deleted.
 .AP Tcl_InterpDeleteProc **delProcPtr in
 Pointer to location in which to store address of current deletion procedure
 for association.  Ignored if NULL.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value associated with the given key in this
 interpreter.  This data is owned by the caller.
 .BE
 
 .SH DESCRIPTION
@@ -62,11 +62,11 @@
 is deleted.  \fIDeleteProc\fR should have arguments and result that match
 the type \fBTcl_InterpDeleteProc\fR:
 .PP
 .CS
 typedef void \fBTcl_InterpDeleteProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Interp *\fIinterp\fR);
 .CE
 .PP
 When \fIdeleteProc\fR is invoked the \fIclientData\fR and \fIinterp\fR
 arguments will be the same as the corresponding arguments passed to

Index: doc/Async.3
==================================================================
--- doc/Async.3
+++ doc/Async.3
@@ -28,11 +28,11 @@
 \fBTcl_AsyncReady\fR()
 .SH ARGUMENTS
 .AS Tcl_AsyncHandler clientData
 .AP Tcl_AsyncProc *proc in
 Procedure to invoke to handle an asynchronous event.
-.AP void *clientData in
+.AP ClientData clientData in
 One-word value to pass to \fIproc\fR.
 .AP Tcl_AsyncHandler async in
 Token for asynchronous event handler.
 .AP Tcl_Interp *interp in
 Tcl interpreter in which command was being evaluated when handler was
@@ -82,11 +82,11 @@
 \fIProc\fR should have arguments and result that match the
 type \fBTcl_AsyncProc\fR:
 .PP
 .CS
 typedef int \fBTcl_AsyncProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Interp *\fIinterp\fR,
         int \fIcode\fR);
 .CE
 .PP
 The \fIclientData\fR will be the same as the \fIclientData\fR

ADDED   doc/Backslash.3
Index: doc/Backslash.3
==================================================================
--- /dev/null
+++ doc/Backslash.3
@@ -0,0 +1,47 @@
+'\"
+'\" Copyright (c) 1989-1993 The Regents of the University of California.
+'\" Copyright (c) 1994-1996 Sun Microsystems, Inc.
+'\"
+'\" See the file "license.terms" for information on usage and redistribution
+'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+'\"
+.TH Tcl_Backslash 3 "8.1" Tcl "Tcl Library Procedures"
+.so man.macros
+.BS
+.SH NAME
+Tcl_Backslash \- parse a backslash sequence
+.SH SYNOPSIS
+.nf
+\fB#include <tcl.h>\fR
+.sp
+char
+\fBTcl_Backslash\fR(\fIsrc, countPtr\fR)
+.SH ARGUMENTS
+.AS char *countPtr out
+.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
+in with number of characters in the backslash sequence, including
+the backslash character.
+.BE
+
+.SH DESCRIPTION
+.PP
+The use of \fBTcl_Backslash\fR is deprecated in favor of
+\fBTcl_UtfBackslash\fR.
+.PP
+This is a utility procedure provided for backwards compatibility with
+non-internationalized Tcl extensions.  It parses a backslash sequence and
+returns the low byte of the Unicode character corresponding to the sequence.
+\fBTcl_Backslash\fR modifies \fI*countPtr\fR to contain the number of
+characters in the backslash sequence.
+.PP
+See the Tcl manual entry for information on the valid backslash sequences.
+All of the sequences described in the Tcl manual entry are supported by
+\fBTcl_Backslash\fR.
+.SH "SEE ALSO"
+Tcl(n), Tcl_UtfBackslash(3)
+
+.SH KEYWORDS
+backslash, parse

Index: doc/ByteArrObj.3
==================================================================
--- doc/ByteArrObj.3
+++ doc/ByteArrObj.3
@@ -27,12 +27,12 @@
 .SH ARGUMENTS
 .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 \fIlength\fR is non-zero.
-.AP size_t length in
-The length of the array of bytes.
+.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 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

Index: doc/CallDel.3
==================================================================
--- doc/CallDel.3
+++ doc/CallDel.3
@@ -21,11 +21,11 @@
 .AS Tcl_InterpDeleteProc clientData
 .AP Tcl_Interp *interp in
 Interpreter with which to associated callback.
 .AP Tcl_InterpDeleteProc *proc in
 Procedure to call when \fIinterp\fR is deleted.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR.
 .BE
 .SH DESCRIPTION
 .PP
 \fBTcl_CallWhenDeleted\fR arranges for \fIproc\fR to be called by
@@ -36,11 +36,11 @@
 \fIProc\fR should have arguments and result that match the
 type \fBTcl_InterpDeleteProc\fR:
 .PP
 .CS
 typedef void \fBTcl_InterpDeleteProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Interp *\fIinterp\fR);
 .CE
 .PP
 The \fIclientData\fR and \fIinterp\fR parameters are
 copies of the \fIclientData\fR and \fIinterp\fR arguments given

Index: doc/Cancel.3
==================================================================
--- doc/Cancel.3
+++ doc/Cancel.3
@@ -28,11 +28,11 @@
 .AP int flags in
 ORed combination of flag bits that specify additional options.
 For \fBTcl_CancelEval\fR, only \fBTCL_CANCEL_UNWIND\fR is currently
 supported.  For \fBTcl_Canceled\fR, only \fBTCL_LEAVE_ERR_MSG\fR and
 \fBTCL_CANCEL_UNWIND\fR are currently supported.
-.AP void *clientData in
+.AP ClientData clientData in
 Currently reserved for future use.
 It should be set to NULL.
 .BE
 .SH DESCRIPTION
 .PP

Index: doc/ChnlStack.3
==================================================================
--- doc/ChnlStack.3
+++ doc/ChnlStack.3
@@ -30,11 +30,11 @@
 .AS Tcl_ChannelType clientData
 .AP Tcl_Interp *interp in
 Interpreter for error reporting.
 .AP "const Tcl_ChannelType" *typePtr in
 The new channel I/O procedures to use for \fIchannel\fR.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to channel I/O procedures.
 .AP int mask in
 Conditions under which \fIchannel\fR will be used: OR-ed combination of
 \fBTCL_READABLE\fR, \fBTCL_WRITABLE\fR and \fBTCL_EXCEPTION\fR.
 This can be a subset of the operations currently allowed on \fIchannel\fR.

Index: doc/Class.3
==================================================================
--- doc/Class.3
+++ doc/Class.3
@@ -39,26 +39,26 @@
 \fBTcl_CopyObjectInstance\fR(\fIinterp, object, name, nsName\fR)
 .sp
 int
 \fBTcl_ObjectDeleted\fR(\fIobject\fR)
 .sp
-void *
+ClientData
 \fBTcl_ObjectGetMetadata\fR(\fIobject, metaTypePtr\fR)
 .sp
 \fBTcl_ObjectSetMetadata\fR(\fIobject, metaTypePtr, metadata\fR)
 .sp
-void *
+ClientData
 \fBTcl_ClassGetMetadata\fR(\fIclass, metaTypePtr\fR)
 .sp
 \fBTcl_ClassSetMetadata\fR(\fIclass, metaTypePtr, metadata\fR)
 .sp
 Tcl_ObjectMapMethodNameProc
 \fBTcl_ObjectGetMethodNameMapper\fR(\fIobject\fR)
 .sp
 \fBTcl_ObjectSetMethodNameMapper\fR(\fIobject\fR, \fImethodNameMapper\fR)
 .SH ARGUMENTS
-.AS void *metadata in/out
+.AS ClientData metadata in/out
 .AP Tcl_Interp *interp in/out
 Interpreter providing the context for looking up or creating an object, and
 into whose result error messages will be written on failure.
 .AP Tcl_Obj *objPtr in
 The name of the object to look up.
@@ -77,15 +77,17 @@
 The number of elements in the \fIobjv\fR array.
 .AP "Tcl_Obj *const" *objv in
 The arguments to the command to create the instance of the class.
 .AP int skip in
 The number of arguments at the start of the argument array, \fIobjv\fR, that
-are not arguments to any constructors.
+are not arguments to any constructors. This allows the generation of correct
+error messages even when complicated calling patterns are used (e.g., via the
+\fBnext\fR command).
 .AP Tcl_ObjectMetadataType *metaTypePtr in
 The type of \fImetadata\fR being set with \fBTcl_ClassSetMetadata\fR or
 retrieved with \fBTcl_ClassGetMetadata\fR.
-.AP void *metadata in
+.AP ClientData metadata in
 An item of metadata to attach to the class, or NULL to remove the metadata
 associated with a particular \fImetaTypePtr\fR.
 .AP "Tcl_ObjectMapMethodNameProc" "methodNameMapper" in
 A pointer to a function to call to adjust the mapping of objects and method
 names to implementations, or NULL when no such mapping is required.
@@ -107,11 +109,13 @@
 Every object has its own command and namespace associated with it. The command
 may be retrieved using the \fBTcl_GetObjectCommand\fR function, the name of
 the object (and hence the name of the command) with \fBTcl_GetObjectName\fR,
 and the namespace may be retrieved using the \fBTcl_GetObjectNamespace\fR
 function. Note that the Tcl_Obj reference returned by \fBTcl_GetObjectName\fR
-is a shared reference.
+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.
 .PP
 Instances of classes are created using \fBTcl_NewObjectInstance\fR, which
 creates an object from any class (and which is internally called by both
 the \fBcreate\fR and \fBnew\fR methods of the \fBoo::class\fR class). It takes
 parameters that optionally give the name of the object and namespace to
@@ -119,10 +123,20 @@
 (if any). The result of the function will be either a reference to the newly
 created object, or NULL if the creation failed (when an error message will be
 left in the interpreter result). In addition, objects may be copied by using
 \fBTcl_CopyObjectInstance\fR which creates a copy of an object without running
 any constructors.
+.PP
+Note that the lifetime management of objects is handled internally within
+TclOO, and does not use \fBTcl_Preserve\fR. \fIIt is not safe to put a
+Tcl_Object handle in a C structure with a lifespan different to the object;\fR
+you should use the object's command name (as retrieved with
+\fBTcl_GetObjectName\fR) instead. It is safe to use a Tcl_Object handle for
+the lifespan of a call of a method on that object; handles do not become
+invalid while there is an outstanding call on their object (even if the only
+operation guaranteed to be safe on them is \fBTcl_ObjectDeleted\fR; the other
+operations are only guaranteed to work on non-deleted objects).
 .SH "OBJECT AND CLASS METADATA"
 .PP
 Every object and every class may have arbitrary amounts of metadata attached
 to it, which the object or class attaches no meaning to beyond what is
 described in a Tcl_ObjectMetadataType structure instance. Metadata to be
@@ -169,11 +183,11 @@
 Functions matching this signature are used to delete metadata associated with
 a class or object.
 .PP
 .CS
 typedef void \fBTcl_ObjectMetadataDeleteProc\fR(
-        void *\fImetadata\fR);
+        ClientData \fImetadata\fR);
 .CE
 .PP
 The \fImetadata\fR argument gives the address of the metadata to be
 deleted.
 .SS "TCL_CLONEPROC FUNCTION SIGNATURE"
@@ -182,12 +196,12 @@
 associated with a class or object.
 .PP
 .CS
 typedef int \fBTcl_CloneProc\fR(
         Tcl_Interp *\fIinterp\fR,
-        void *\fIsrcMetadata\fR,
-        void **\fIdstMetadataPtr\fR);
+        ClientData \fIsrcMetadata\fR,
+        ClientData *\fIdstMetadataPtr\fR);
 .CE
 .PP
 The \fIinterp\fR argument gives a place to write an error message when the
 attempt to clone the object is to fail, in which case the clone procedure must
 also return TCL_ERROR; it should return TCL_OK otherwise.

Index: doc/CrtChannel.3
==================================================================
--- doc/CrtChannel.3
+++ doc/CrtChannel.3
@@ -15,11 +15,11 @@
 \fB#include <tcl.h>\fR
 .sp
 Tcl_Channel
 \fBTcl_CreateChannel\fR(\fItypePtr, channelName, instanceData, mask\fR)
 .sp
-void *
+ClientData
 \fBTcl_GetChannelInstanceData\fR(\fIchannel\fR)
 .sp
 const Tcl_ChannelType *
 \fBTcl_GetChannelType\fR(\fIchannel\fR)
 .sp
@@ -126,11 +126,11 @@
 The name of this channel, such as \fBfile3\fR; must not be in use
 by any other channel. Can be NULL, in which case the channel is
 created without a name. If the created channel is assigned to one
 of the standard channels (\fBstdin\fR, \fBstdout\fR or \fBstderr\fR),
 the assigned channel name will be the name of the standard channel.
-.AP void *instanceData in
+.AP ClientData instanceData in
 Arbitrary one-word value to be associated with this channel.  This
 value is passed to procedures in \fItypePtr\fR when they are invoked.
 .AP int mask in
 OR-ed combination of \fBTCL_READABLE\fR and \fBTCL_WRITABLE\fR to indicate
 whether a channel is readable and writable.
@@ -137,11 +137,11 @@
 .AP Tcl_Channel channel in
 The channel to operate on.
 .AP int direction in
 \fBTCL_READABLE\fR means the input handle is wanted; \fBTCL_WRITABLE\fR
 means the output handle is wanted.
-.AP void **handlePtr out
+.AP ClientData *handlePtr out
 Points to the location where the desired OS-specific handle should be
 stored.
 .AP int size in
 The size, in bytes, of buffers to allocate in this channel.
 .AP int mask in
@@ -397,11 +397,11 @@
 the generic layer to set blocking and nonblocking mode on the device.
 \fIBlockModeProc\fR should match the following prototype:
 .PP
 .CS
 typedef int \fBTcl_DriverBlockModeProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         int \fImode\fR);
 .CE
 .PP
 The \fIinstanceData\fR is the same as the value passed to
 \fBTcl_CreateChannel\fR when this channel was created.  The \fImode\fR
@@ -432,11 +432,11 @@
 generic layer to clean up driver-related information when the channel is
 closed. \fICloseProc\fR must match the following prototype:
 .PP
 .CS
 typedef int \fBTcl_DriverCloseProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         Tcl_Interp *\fIinterp\fR);
 .CE
 .PP
 The \fIinstanceData\fR argument is the same as the value provided to
 \fBTcl_CreateChannel\fR when the channel was created. The function should
@@ -454,11 +454,11 @@
 \fIclose2Proc\fR to the address of a function that matches the
 following prototype:
 .PP
 .CS
 typedef int \fBTcl_DriverClose2Proc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         Tcl_Interp *\fIinterp\fR,
         int \fIflags\fR);
 .CE
 .PP
 The \fIclose2Proc\fR will be called with \fIflags\fR set to an OR'ed
@@ -485,11 +485,11 @@
 generic layer to read data from the file or device and store it in an
 internal buffer. \fIInputProc\fR must match the following prototype:
 .PP
 .CS
 typedef int \fBTcl_DriverInputProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         char *\fIbuf\fR,
         int \fIbufSize\fR,
         int *\fIerrorCodePtr\fR);
 .CE
 .PP
@@ -529,11 +529,11 @@
 generic layer to transfer data from an internal buffer to the output device.
 \fIOutputProc\fR must match the following prototype:
 .PP
 .CS
 typedef int \fBTcl_DriverOutputProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         const char *\fIbuf\fR,
         int \fItoWrite\fR,
         int *\fIerrorCodePtr\fR);
 .CE
 .PP
@@ -568,11 +568,11 @@
 operations will be applied. \fISeekProc\fR must match the following
 prototype:
 .PP
 .CS
 typedef int \fBTcl_DriverSeekProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         long \fIoffset\fR,
         int \fIseekMode\fR,
         int *\fIerrorCodePtr\fR);
 .CE
 .PP
@@ -598,11 +598,11 @@
 \fIwideSeekProc\fR is defined.  \fIWideSeekProc\fR must match the
 following prototype:
 .PP
 .CS
 typedef Tcl_WideInt \fBTcl_DriverWideSeekProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         Tcl_WideInt \fIoffset\fR,
         int \fIseekMode\fR,
         int *\fIerrorCodePtr\fR);
 .CE
 .PP
@@ -620,11 +620,11 @@
 the generic layer to set a channel type specific option on a channel.
 \fIsetOptionProc\fR must match the following prototype:
 .PP
 .CS
 typedef int \fBTcl_DriverSetOptionProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         Tcl_Interp *\fIinterp\fR,
         const char *\fIoptionName\fR,
         const char *\fInewValue\fR);
 .CE
 .PP
@@ -661,11 +661,11 @@
 the generic layer to get the value of a channel type specific option on a
 channel. \fIgetOptionProc\fR must match the following prototype:
 .PP
 .CS
 typedef int \fBTcl_DriverGetOptionProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         Tcl_Interp *\fIinterp\fR,
         const char *\fIoptionName\fR,
         Tcl_DString *\fIoptionValue\fR);
 .CE
 .PP
@@ -699,11 +699,11 @@
 notice events of interest on this channel.
 \fIWatchProc\fR should match the following prototype:
 .PP
 .CS
 typedef void \fBTcl_DriverWatchProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         int \fImask\fR);
 .CE
 .PP
 The \fIinstanceData\fR is the same as the value passed to
 \fBTcl_CreateChannel\fR when this channel was created. The \fImask\fR
@@ -730,13 +730,13 @@
 the generic layer to retrieve a device-specific handle from the channel.
 \fIGetHandleProc\fR should match the following prototype:
 .PP
 .CS
 typedef int \fBTcl_DriverGetHandleProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         int \fIdirection\fR,
-        void **\fIhandlePtr\fR);
+        ClientData *\fIhandlePtr\fR);
 .CE
 .PP
 \fIInstanceData\fR is the same as the value passed to
 \fBTcl_CreateChannel\fR when this channel was created. The \fIdirection\fR
 argument is either \fBTCL_READABLE\fR to retrieve the handle used
@@ -759,11 +759,11 @@
 It should be set to NULL.
 \fIFlushProc\fR should match the following prototype:
 .PP
 .CS
 typedef int \fBTcl_DriverFlushProc\fR(
-        void *\fIinstanceData\fR);
+        ClientData \fIinstanceData\fR);
 .CE
 .PP
 This value can be retrieved with \fBTcl_ChannelFlushProc\fR, which returns
 a pointer to the function.
 .SS HANDLERPROC
@@ -774,11 +774,11 @@
 that occur on the underlying (stacked) channel.
 \fIHandlerProc\fR should match the following prototype:
 .PP
 .CS
 typedef int \fBTcl_DriverHandlerProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         int \fIinterestMask\fR);
 .CE
 .PP
 \fIInstanceData\fR is the same as the value passed to \fBTcl_CreateChannel\fR
 when this channel was created.  The \fIinterestMask\fR is an OR-ed
@@ -803,11 +803,11 @@
 might be maintaining using the calling thread as the associate. See
 \fBTcl_CutChannel\fR and \fBTcl_SpliceChannel\fR for more detail.
 .PP
 .CS
 typedef void \fBTcl_DriverThreadActionProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         int \fIaction\fR);
 .CE
 .PP
 \fIInstanceData\fR is the same as the value passed to
 \fBTcl_CreateChannel\fR when this channel was created.
@@ -820,11 +820,11 @@
 called by the generic layer when a channel is truncated to some
 length. It can be NULL.
 .PP
 .CS
 typedef int \fBTcl_DriverTruncateProc\fR(
-        void *\fIinstanceData\fR,
+        ClientData \fIinstanceData\fR,
         Tcl_WideInt \fIlength\fR);
 .CE
 .PP
 \fIInstanceData\fR is the same as the value passed to
 \fBTcl_CreateChannel\fR when this channel was created, and

Index: doc/CrtChnlHdlr.3
==================================================================
--- doc/CrtChnlHdlr.3
+++ doc/CrtChnlHdlr.3
@@ -30,11 +30,11 @@
 \fBTCL_READABLE\fR, \fBTCL_WRITABLE\fR and \fBTCL_EXCEPTION\fR. Specify
 a zero value to temporarily disable an existing handler.
 .AP Tcl_FileProc *proc in
 Procedure to invoke whenever the channel indicated by \fIchannel\fR meets
 the conditions specified by \fImask\fR.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR.
 .BE
 .SH DESCRIPTION
 .PP
 \fBTcl_CreateChannelHandler\fR arranges for \fIproc\fR to be called in the
@@ -46,11 +46,11 @@
 what it means for a channel to be readable or writable.
 \fIProc\fR must conform to the following prototype:
 .PP
 .CS
 typedef void \fBTcl_ChannelProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         int \fImask\fR);
 .CE
 .PP
 The \fIclientData\fR argument is the same as the value passed to
 \fBTcl_CreateChannelHandler\fR when the handler was created. Typically,

Index: doc/CrtCloseHdlr.3
==================================================================
--- doc/CrtCloseHdlr.3
+++ doc/CrtCloseHdlr.3
@@ -24,11 +24,11 @@
 .AS Tcl_CloseProc clientData
 .AP Tcl_Channel channel in
 The channel for which to create or delete a close callback.
 .AP Tcl_CloseProc *proc in
 The procedure to call as the callback.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR.
 .BE
 .SH DESCRIPTION
 .PP
 \fBTcl_CreateCloseHandler\fR arranges for \fIproc\fR to be called when
@@ -36,11 +36,11 @@
 \fBTcl_UnregisterChannel\fR, or using the Tcl \fBclose\fR command.
 \fIProc\fR should match the following prototype:
 .PP
 .CS
 typedef void \fBTcl_CloseProc\fR(
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .PP
 The \fIclientData\fR is the same as the value provided in the call to
 \fBTcl_CreateCloseHandler\fR.
 .PP

Index: doc/CrtCommand.3
==================================================================
--- doc/CrtCommand.3
+++ doc/CrtCommand.3
@@ -23,11 +23,11 @@
 .AP "const char" *cmdName in
 Name of command.
 .AP Tcl_CmdProc *proc in
 Implementation of new command:  \fIproc\fR will be called whenever
 \fIcmdName\fR is invoked as a command.
-.AP voie *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR and \fIdeleteProc\fR.
 .AP Tcl_CmdDeleteProc *deleteProc in
 Procedure to call before \fIcmdName\fR is deleted from the interpreter;
 allows for command-specific cleanup.  If NULL, then no procedure is
 called before the command is deleted.
@@ -73,11 +73,11 @@
 \fIProc\fR should have arguments and result that match the type
 \fBTcl_CmdProc\fR:
 .PP
 .CS
 typedef int \fBTcl_CmdProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Interp *\fIinterp\fR,
         int \fIargc\fR,
         const char *\fIargv\fR[]);
 .CE
 .PP
@@ -129,15 +129,15 @@
 with the command.  \fIDeleteProc\fR should have arguments and
 result that match the type \fBTcl_CmdDeleteProc\fR:
 .PP
 .CS
 typedef void \fBTcl_CmdDeleteProc\fR(
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .PP
 The \fIclientData\fR argument will be the same as the \fIclientData\fR
 argument passed to \fBTcl_CreateCommand\fR.
 .SH "SEE ALSO"
 Tcl_CreateObjCommand, Tcl_DeleteCommand, Tcl_GetCommandInfo,
 Tcl_SetCommandInfo, Tcl_GetCommandName, Tcl_SetObjResult
 .SH KEYWORDS
 bind, command, create, delete, interpreter, namespace

Index: doc/CrtFileHdlr.3
==================================================================
--- doc/CrtFileHdlr.3
+++ doc/CrtFileHdlr.3
@@ -27,11 +27,11 @@
 and \fBTCL_EXCEPTION\fR.  May be set to 0 to temporarily disable
 a handler.
 .AP Tcl_FileProc *proc in
 Procedure to invoke whenever the file or device indicated
 by \fIfile\fR meets the conditions specified by \fImask\fR.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR.
 .BE
 .SH DESCRIPTION
 .PP
 \fBTcl_CreateFileHandler\fR arranges for \fIproc\fR to be
@@ -49,11 +49,11 @@
 \fIProc\fR should have arguments and result that match the
 type \fBTcl_FileProc\fR:
 .PP
 .CS
 typedef void \fBTcl_FileProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         int \fImask\fR);
 .CE
 .PP
 The \fIclientData\fR parameter to \fIproc\fR is a copy
 of the \fIclientData\fR

ADDED   doc/CrtMathFnc.3
Index: doc/CrtMathFnc.3
==================================================================
--- /dev/null
+++ doc/CrtMathFnc.3
@@ -0,0 +1,162 @@
+'\"
+'\" Copyright (c) 1989-1993 The Regents of the University of California.
+'\" Copyright (c) 1994-1996 Sun Microsystems, Inc.
+'\"
+'\" See the file "license.terms" for information on usage and redistribution
+'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+'\"
+.TH Tcl_CreateMathFunc 3 8.4 Tcl "Tcl Library Procedures"
+.so man.macros
+.BS
+.SH NAME
+Tcl_CreateMathFunc, Tcl_GetMathFuncInfo, Tcl_ListMathFuncs \- Define, query and enumerate math functions for expressions
+.SH "NOTICE OF EVENTUAL DEPRECATION"
+.PP
+The \fBTcl_CreateMathFunc\fR and \fBTcl_GetMathFuncInfo\fR functions
+are rendered somewhat obsolete by the ability to create functions for
+expressions by placing commands in the \fBtcl::mathfunc\fR namespace,
+as described in the \fBmathfunc\fR manual page; the API described on
+this page is not expected to be maintained indefinitely.
+.SH SYNOPSIS
+.nf
+\fB#include <tcl.h>\fR
+.sp
+void
+\fBTcl_CreateMathFunc\fR(\fIinterp, name, numArgs, argTypes, proc, clientData\fR)
+.sp
+int
+\fBTcl_GetMathFuncInfo\fR(\fIinterp, name, numArgsPtr, argTypesPtr, procPtr,
+                    clientDataPtr\fR)
+.sp
+Tcl_Obj *
+\fBTcl_ListMathFuncs\fR(\fIinterp, pattern\fR)
+.SH ARGUMENTS
+.AS Tcl_ValueType *clientDataPtr out
+.AP Tcl_Interp *interp in
+Interpreter in which new function will be defined.
+.AP "const char" *name in
+Name for new function.
+.AP int numArgs in
+Number of arguments to new function;  also gives size of \fIargTypes\fR array.
+.AP Tcl_ValueType *argTypes in
+Points to an array giving the permissible types for each argument to
+function.
+.AP Tcl_MathProc *proc in
+Procedure that implements the function.
+.AP ClientData clientData in
+Arbitrary one-word value to pass to \fIproc\fR when it is invoked.
+.AP int *numArgsPtr out
+Points to a variable that will be set to contain the number of
+arguments to the function.
+.AP Tcl_ValueType **argTypesPtr out
+Points to a variable that will be set to contain a pointer to an array
+giving the permissible types for each argument to the function which
+will need to be freed up using \fITcl_Free\fR.
+.AP Tcl_MathProc **procPtr out
+Points to a variable that will be set to contain a pointer to the
+implementation code for the function (or NULL if the function is
+implemented directly in bytecode).
+.AP ClientData *clientDataPtr out
+Points to a variable that will be set to contain the clientData
+argument passed to \fITcl_CreateMathFunc\fR when the function was
+created if the function is not implemented directly in bytecode.
+.AP "const char" *pattern in
+Pattern to match against function names so as to filter them (by
+passing to \fITcl_StringMatch\fR), or NULL to not apply any filter.
+.BE
+.SH DESCRIPTION
+.PP
+Tcl allows a number of mathematical functions to be used in
+expressions, such as \fBsin\fR, \fBcos\fR, and \fBhypot\fR.
+These functions are represented by commands in the namespace,
+\fBtcl::mathfunc\fR.  The \fBTcl_CreateMathFunc\fR function is
+an obsolete way for applications to add additional functions
+to those already provided by Tcl or to replace existing functions.
+It should not be used by new applications, which should create
+math functions using \fBTcl_CreateObjCommand\fR to create a command
+in the \fBtcl::mathfunc\fR namespace.
+.PP
+In the \fBTcl_CreateMathFunc\fR interface,
+\fIName\fR is the name of the function as it will appear in expressions.
+If \fIname\fR does not already exist in the \fB::tcl::mathfunc\fR
+namespace, then a new command is created in that namespace.
+If \fIname\fR does exist, then the existing function is replaced.
+\fINumArgs\fR and \fIargTypes\fR describe the arguments to the function.
+Each entry in the \fIargTypes\fR array must be
+one of \fBTCL_INT\fR, \fBTCL_DOUBLE\fR, \fBTCL_WIDE_INT\fR,
+or \fBTCL_EITHER\fR to indicate whether the corresponding argument must be an
+integer, a double-precision floating value, a wide (64-bit) integer,
+or any, respectively.
+.PP
+Whenever the function is invoked in an expression Tcl will invoke
+\fIproc\fR.  \fIProc\fR should have arguments and result that match
+the type \fBTcl_MathProc\fR:
+.PP
+.CS
+typedef int \fBTcl_MathProc\fR(
+        ClientData \fIclientData\fR,
+        Tcl_Interp *\fIinterp\fR,
+        Tcl_Value *\fIargs\fR,
+        Tcl_Value *\fIresultPtr\fR);
+.CE
+.PP
+When \fIproc\fR is invoked the \fIclientData\fR and \fIinterp\fR
+arguments will be the same as those passed to \fBTcl_CreateMathFunc\fR.
+\fIArgs\fR will point to an array of \fInumArgs\fR Tcl_Value structures,
+which describe the actual arguments to the function:
+.PP
+.CS
+typedef struct Tcl_Value {
+    Tcl_ValueType \fItype\fR;
+    long \fIintValue\fR;
+    double \fIdoubleValue\fR;
+    Tcl_WideInt \fIwideValue\fR;
+} \fBTcl_Value\fR;
+.CE
+.PP
+The \fItype\fR field indicates the type of the argument and is
+one of \fBTCL_INT\fR, \fBTCL_DOUBLE\fR or \fBTCL_WIDE_INT\fR.
+It will match the \fIargTypes\fR value specified for the function unless
+the \fIargTypes\fR value was \fBTCL_EITHER\fR. Tcl converts
+the argument supplied in the expression to the type requested in
+\fIargTypes\fR, if that is necessary.
+Depending on the value of the \fItype\fR field, the \fIintValue\fR,
+\fIdoubleValue\fR or \fIwideValue\fR
+field will contain the actual value of the argument.
+.PP
+\fIProc\fR should compute its result and store it either as an integer
+in \fIresultPtr->intValue\fR or as a floating value in
+\fIresultPtr->doubleValue\fR.
+It should set also \fIresultPtr->type\fR to one of
+\fBTCL_INT\fR, \fBTCL_DOUBLE\fR or \fBTCL_WIDE_INT\fR
+to indicate which value was set.
+Under normal circumstances \fIproc\fR should return \fBTCL_OK\fR.
+If an error occurs while executing the function, \fIproc\fR should
+return \fBTCL_ERROR\fR and leave an error message in the interpreter's result.
+.PP
+\fBTcl_GetMathFuncInfo\fR retrieves the values associated with
+function \fIname\fR that were passed to a preceding
+\fBTcl_CreateMathFunc\fR call.  Normally, the return code is
+\fBTCL_OK\fR but if the named function does not exist, \fBTCL_ERROR\fR
+is returned and an error message is placed in the interpreter's
+result.
+.PP
+If an error did not occur, the array reference placed in the variable
+pointed to by \fIargTypesPtr\fR is newly allocated, and should be
+released by passing it to \fBTcl_Free\fR.  Some functions (the
+standard set implemented in the core, and those defined by placing
+commands in the \fBtcl::mathfunc\fR namespace) do not have
+argument type information; attempting to retrieve values for
+them causes a NULL to be stored in the variable pointed to by
+\fIprocPtr\fR and the variable pointed to by \fIclientDataPtr\fR
+will not be modified.  The variable pointed to by \fInumArgsPointer\fR
+will contain -1, and no argument types will be stored in the variable
+pointed to by \fIargTypesPointer\fR.
+.PP
+\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 "SEE ALSO"
+expr(n), info(n), Tcl_CreateObjCommand(3), Tcl_Free(3), Tcl_NewListObj(3)
+.SH KEYWORDS
+expression, mathematical function

Index: doc/CrtObjCmd.3
==================================================================
--- doc/CrtObjCmd.3
+++ doc/CrtObjCmd.3
@@ -57,11 +57,11 @@
 .AP char *cmdName in
 Name of command.
 .AP Tcl_ObjCmdProc *proc in
 Implementation of the new command: \fIproc\fR will be called whenever
 \fIcmdName\fR is invoked as a command.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR and \fIdeleteProc\fR.
 .AP Tcl_CmdDeleteProc *deleteProc in
 Procedure to call before \fIcmdName\fR is deleted from the interpreter;
 allows for command-specific cleanup. If NULL, then no procedure is
 called before the command is deleted.
@@ -100,11 +100,11 @@
 \fIproc\fR should have arguments and result that match the type
 \fBTcl_ObjCmdProc\fR:
 .PP
 .CS
 typedef int \fBTcl_ObjCmdProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Interp *\fIinterp\fR,
         int \fIobjc\fR,
         Tcl_Obj *const \fIobjv\fR[]);
 .CE
 .PP
@@ -173,11 +173,11 @@
 with the command.  \fIDeleteProc\fR should have arguments and
 result that match the type \fBTcl_CmdDeleteProc\fR:
 .PP
 .CS
 typedef void \fBTcl_CmdDeleteProc\fR(
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .PP
 The \fIclientData\fR argument will be the same as the \fIclientData\fR
 argument passed to \fBTcl_CreateObjCommand\fR.
 .PP
@@ -215,15 +215,15 @@
 .PP
 .CS
 typedef struct Tcl_CmdInfo {
     int \fIisNativeObjectProc\fR;
     Tcl_ObjCmdProc *\fIobjProc\fR;
-    void *\fIobjClientData\fR;
+    ClientData \fIobjClientData\fR;
     Tcl_CmdProc *\fIproc\fR;
-    void *\fIclientData\fR;
+    ClientData \fIclientData\fR;
     Tcl_CmdDeleteProc *\fIdeleteProc\fR;
-    void *\fIdeleteData\fR;
+    ClientData \fIdeleteData\fR;
     Tcl_Namespace *\fInamespacePtr\fR;
 } \fBTcl_CmdInfo\fR;
 .CE
 .PP
 The \fIisNativeObjectProc\fR field has the value 1
@@ -245,11 +245,11 @@
 this is the procedure passed to it;
 otherwise, this is a compatibility procedure
 registered by \fBTcl_CreateObjCommand\fR
 that simply calls the command's
 value-based procedure after converting its string arguments to Tcl values.
-The field \fIdeleteData\fR is the clientData value
+The field \fIdeleteData\fR is the ClientData value
 to pass to \fIdeleteProc\fR;  it is normally the same as
 \fIclientData\fR but may be set independently using the
 \fBTcl_SetCommandInfo\fR procedure.
 The field \fInamespacePtr\fR holds a pointer to the
 Tcl_Namespace that contains the command.
@@ -259,11 +259,11 @@
 from \fBTcl_CreateObjCommand\fR in place of the command name.  If the
 \fItoken\fR parameter is NULL, it returns 0; otherwise, it returns 1
 and fills in the structure designated by \fIinfoPtr\fR.
 .PP
 \fBTcl_SetCommandInfo\fR is used to modify the procedures and
-clientData values associated with a command.
+ClientData values associated with a command.
 Its \fIcmdName\fR argument is the name of a command in \fIinterp\fR.
 \fIcmdName\fR may include \fB::\fR namespace qualifiers
 to identify a command in a particular namespace.
 If this command does not exist then \fBTcl_SetCommandInfo\fR returns 0.
 Otherwise, it copies the information from \fI*infoPtr\fR to
@@ -275,13 +275,13 @@
 If the \fItoken\fR parameter is NULL, it returns 0.  Otherwise, it
 copies the information from \fI*infoPtr\fR to Tcl's internal structure
 for the command and returns 1.
 .PP
 Note that \fBTcl_SetCommandInfo\fR and
-\fBTcl_SetCommandInfoFromToken\fR both allow the clientData for a
+\fBTcl_SetCommandInfoFromToken\fR both allow the ClientData for a
 command's deletion procedure to be given a different value than the
-clientData for its command procedure.
+ClientData for its command procedure.
 .PP
 Note that neither \fBTcl_SetCommandInfo\fR nor
 \fBTcl_SetCommandInfoFromToken\fR will change a command's namespace.
 Use \fBTcl_Eval\fR to call the \fBrename\fR command to do that.
 .PP

Index: doc/CrtTimerHdlr.3
==================================================================
--- doc/CrtTimerHdlr.3
+++ doc/CrtTimerHdlr.3
@@ -22,11 +22,11 @@
 .AS Tcl_TimerToken milliseconds
 .AP int milliseconds  in
 How many milliseconds to wait before invoking \fIproc\fR.
 .AP Tcl_TimerProc *proc in
 Procedure to invoke after \fImilliseconds\fR have elapsed.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR.
 .AP Tcl_TimerToken token in
 Token for previously created timer handler (the return value
 from some previous call to \fBTcl_CreateTimerHandler\fR).
 .BE
@@ -49,11 +49,11 @@
 \fIProc\fR should have arguments and return value that match
 the type \fBTcl_TimerProc\fR:
 .PP
 .CS
 typedef void \fBTcl_TimerProc\fR(
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .PP
 The \fIclientData\fR parameter to \fIproc\fR is a
 copy of the \fIclientData\fR argument given to
 \fBTcl_CreateTimerHandler\fR when the callback

Index: doc/CrtTrace.3
==================================================================
--- doc/CrtTrace.3
+++ doc/CrtTrace.3
@@ -39,11 +39,11 @@
 Procedure to call for each command that is executed.  See below for
 details of the calling sequence.
 .AP Tcl_CmdTraceProc *proc in
 Procedure to call for each command that is executed.  See below for
 details on the calling sequence.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIobjProc\fR or \fIproc\fR.
 .AP Tcl_CmdObjTraceDeleteProc *deleteProc in
 Procedure to call when the trace is deleted.  See below for details of
 the calling sequence.  A NULL pointer is permissible and results in no
 callback when the trace is deleted.
@@ -64,11 +64,11 @@
 \fIobjProc\fR should have arguments and result that match the type,
 \fBTcl_CmdObjTraceProc\fR:
 .PP
 .CS
 typedef int \fBTcl_CmdObjTraceProc\fR(
-        \fBvoid *\fR \fIclientData\fR,
+        \fBClientData\fR \fIclientData\fR,
         \fBTcl_Interp\fR* \fIinterp\fR,
         int \fIlevel\fR,
         const char *\fIcommand\fR,
         \fBTcl_Command\fR \fIcommandToken\fR,
         int \fIobjc\fR,
@@ -75,11 +75,11 @@
         \fBTcl_Obj\fR *const \fIobjv\fR[]);
 .CE
 .PP
 The \fIclientData\fR and \fIinterp\fR parameters are copies of the
 corresponding arguments given to \fBTcl_CreateTrace\fR.
-\fIclientData\fR typically points to an application-specific data
+\fIClientData\fR typically points to an application-specific data
 structure that describes what to do when \fIobjProc\fR is invoked.  The
 \fIlevel\fR parameter gives the nesting level of the command (1 for
 top-level commands passed to \fBTcl_Eval\fR by the application, 2 for
 the next-level commands passed to \fBTcl_Eval\fR as part of parsing or
 interpreting level-1 commands, and so on). The \fIcommand\fR parameter
@@ -142,11 +142,11 @@
 \fBTcl_CreateObjTrace\fR.  The \fIdeleteProc\fR must match the type,
 \fBTcl_CmdObjTraceDeleteProc\fR:
 .PP
 .CS
 typedef void \fBTcl_CmdObjTraceDeleteProc\fR(
-        \fBvoid *\fR \fIclientData\fR);
+        \fBClientData\fR \fIclientData\fR);
 .CE
 .PP
 The \fIclientData\fR parameter will be the same as the
 \fIclientData\fR parameter that was originally passed to
 \fBTcl_CreateObjTrace\fR.
@@ -158,16 +158,16 @@
 that its \fIproc\fR parameter should have arguments and result that
 match the type \fBTcl_CmdTraceProc\fR:
 .PP
 .CS
 typedef void \fBTcl_CmdTraceProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Interp *\fIinterp\fR,
         int \fIlevel\fR,
         char *\fIcommand\fR,
         Tcl_CmdProc *\fIcmdProc\fR,
-        void *\fIcmdClientData\fR,
+        ClientData \fIcmdClientData\fR,
         int \fIargc\fR,
         const char *\fIargv\fR[]);
 .CE
 .PP
 The parameters to the \fIproc\fR callback are similar to those of the

Index: doc/DString.3
==================================================================
--- doc/DString.3
+++ doc/DString.3
@@ -7,11 +7,11 @@
 '\"
 .TH Tcl_DString 3 7.4 Tcl "Tcl Library Procedures"
 .so man.macros
 .BS
 .SH NAME
-Tcl_DStringInit, Tcl_DStringAppend, Tcl_DStringAppendElement, Tcl_DStringStartSublist, Tcl_DStringEndSublist, Tcl_DStringLength, Tcl_DStringValue, Tcl_DStringSetLength, Tcl_DStringFree, Tcl_DStringResult, Tcl_DStringGetResult \- manipulate dynamic strings
+Tcl_DStringInit, Tcl_DStringAppend, Tcl_DStringAppendElement, Tcl_DStringStartSublist, Tcl_DStringEndSublist, Tcl_DStringLength, Tcl_DStringValue, Tcl_DStringSetLength, Tcl_DStringTrunc, Tcl_DStringFree, Tcl_DStringResult, Tcl_DStringGetResult \- manipulate dynamic strings
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
 \fBTcl_DStringInit\fR(\fIdsPtr\fR)
@@ -24,17 +24,19 @@
 .sp
 \fBTcl_DStringStartSublist\fR(\fIdsPtr\fR)
 .sp
 \fBTcl_DStringEndSublist\fR(\fIdsPtr\fR)
 .sp
-size_t
+int
 \fBTcl_DStringLength\fR(\fIdsPtr\fR)
 .sp
 char *
 \fBTcl_DStringValue\fR(\fIdsPtr\fR)
 .sp
 \fBTcl_DStringSetLength\fR(\fIdsPtr, newLength\fR)
+.sp
+\fBTcl_DStringTrunc\fR(\fIdsPtr, newLength\fR)
 .sp
 \fBTcl_DStringFree\fR(\fIdsPtr\fR)
 .sp
 \fBTcl_DStringResult\fR(\fIinterp, dsPtr\fR)
 .sp
@@ -45,14 +47,14 @@
 Pointer to structure that is used to manage a dynamic string.
 .AP "const char" *bytes in
 Pointer to characters to append to dynamic string.
 .AP "const char" *element in
 Pointer to characters to append as list element to dynamic string.
-.AP size_t length in
-Number of bytes from \fIbytes\fR to add to dynamic string.  If TCL_AUTO_LENGTH,
+.AP int length in
+Number of bytes from \fIbytes\fR to add to dynamic string.  If -1,
 add all characters up to null terminating character.
-.AP size_t newLength in
+.AP int newLength in
 New length for dynamic string, not including null terminating
 character.
 .AP Tcl_Interp *interp in/out
 Interpreter whose result is to be set from or moved to the
 dynamic string.
@@ -123,10 +125,14 @@
 space except to provide a terminating null character;  it is up to the
 caller to fill in the new space.
 \fBTcl_DStringSetLength\fR does not free up the string's storage space
 even if the string is truncated to zero length, so \fBTcl_DStringFree\fR
 will still need to be called.
+.PP
+\fBTcl_DStringTrunc\fR changes the length of a dynamic string.
+This procedure is now deprecated.  \fBTcl_DStringSetLength\fR  should
+be used instead.
 .PP
 \fBTcl_DStringFree\fR should be called when you are finished using
 the string.  It frees up any memory that was allocated for the string
 and reinitializes the string's value to an empty string.
 .PP

Index: doc/DoWhenIdle.3
==================================================================
--- doc/DoWhenIdle.3
+++ doc/DoWhenIdle.3
@@ -19,11 +19,11 @@
 \fBTcl_CancelIdleCall\fR(\fIproc, clientData\fR)
 .SH ARGUMENTS
 .AS Tcl_IdleProc clientData
 .AP Tcl_IdleProc *proc in
 Procedure to invoke.
-.AP coid *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR.
 .BE
 .SH DESCRIPTION
 .PP
 \fBTcl_DoWhenIdle\fR arranges for \fIproc\fR to be invoked
@@ -41,11 +41,11 @@
 \fIProc\fR should have arguments and result that match the
 type \fBTcl_IdleProc\fR:
 .PP
 .CS
 typedef void \fBTcl_IdleProc\fR(
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .PP
 The \fIclientData\fR parameter to \fIproc\fR is a copy of the \fIclientData\fR
 argument given to \fBTcl_DoWhenIdle\fR.  Typically, \fIclientData\fR
 points to a data structure containing application-specific information about

Index: doc/DumpActiveMemory.3
==================================================================
--- doc/DumpActiveMemory.3
+++ doc/DumpActiveMemory.3
@@ -41,11 +41,11 @@
 is not defined, these functions are all no-ops.
 .PP
 \fBTcl_DumpActiveMemory\fR will output a list of all currently
 allocated memory to the specified file.  The information output for
 each allocated block of memory is:  starting and ending addresses
-(excluding guard zone), size, source file where \fBTcl_Alloc\fR was
+(excluding guard zone), size, source file where \fBckalloc\fR was
 called to allocate the block and line number in that file.  It is
 especially useful to call \fBTcl_DumpActiveMemory\fR after the Tcl
 interpreter has been deleted.
 .PP
 \fBTcl_InitMemory\fR adds the Tcl \fBmemory\fR command to the
@@ -53,16 +53,16 @@
 by \fBTcl_Main\fR.
 .PP
 \fBTcl_ValidateAllMemory\fR forces a validation of the guard zones of
 all currently allocated blocks of memory.  Normally validation of a
 block occurs when its freed, unless full validation is enabled, in
-which case validation of all blocks occurs when \fBTcl_Alloc\fR and
-\fBTcl_Free\fR are called.  This function forces the validation to occur
+which case validation of all blocks occurs when \fBckalloc\fR and
+\fBckfree\fR are called.  This function forces the validation to occur
 at any point.
 
 .SH "SEE ALSO"
 TCL_MEM_DEBUG, memory
 
 .SH KEYWORDS
 memory, debug
 
 

Index: doc/Encoding.3
==================================================================
--- doc/Encoding.3
+++ doc/Encoding.3
@@ -6,11 +6,11 @@
 '\"
 .TH Tcl_GetEncoding 3 "8.1" Tcl "Tcl Library Procedures"
 .so man.macros
 .BS
 .SH NAME
-Tcl_GetEncoding, Tcl_FreeEncoding, Tcl_GetEncodingFromObj, Tcl_ExternalToUtfDString, Tcl_ExternalToUtf, Tcl_UtfToExternalDString, Tcl_UtfToExternal, Tcl_WinTCharToUtf, Tcl_WinUtfToTChar, Tcl_GetEncodingName, Tcl_SetSystemEncoding, Tcl_GetEncodingNameFromEnvironment, Tcl_GetEncodingNames, Tcl_CreateEncoding, Tcl_GetEncodingSearchPath, Tcl_SetEncodingSearchPath \- procedures for creating and using encodings
+Tcl_GetEncoding, Tcl_FreeEncoding, Tcl_GetEncodingFromObj, Tcl_ExternalToUtfDString, Tcl_ExternalToUtf, Tcl_UtfToExternalDString, Tcl_UtfToExternal, Tcl_WinTCharToUtf, Tcl_WinUtfToTChar, Tcl_GetEncodingName, Tcl_SetSystemEncoding, Tcl_GetEncodingNameFromEnvironment, Tcl_GetEncodingNames, Tcl_CreateEncoding, Tcl_GetEncodingSearchPath, Tcl_SetEncodingSearchPath, Tcl_GetDefaultEncodingDir, Tcl_SetDefaultEncodingDir \- procedures for creating and using encodings
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
 Tcl_Encoding
@@ -60,10 +60,16 @@
 Tcl_Obj *
 \fBTcl_GetEncodingSearchPath\fR()
 .sp
 int
 \fBTcl_SetEncodingSearchPath\fR(\fIsearchPath\fR)
+.sp
+const char *
+\fBTcl_GetDefaultEncodingDir\fR(\fIvoid\fR)
+.sp
+void
+\fBTcl_SetDefaultEncodingDir\fR(\fIpath\fR)
 .SH ARGUMENTS
 .AS "const Tcl_EncodingType" *dstWrotePtr in/out
 .AP Tcl_Interp *interp in
 Interpreter to use for error reporting, or NULL if no error reporting is
 desired.
@@ -81,11 +87,11 @@
 specified encoding that are to be converted to UTF-8.  For the
 \fBTcl_UtfToExternal\fR and \fBTcl_WinUtfToTChar\fR functions, an array of
 UTF-8 characters to be converted to the specified encoding.
 .AP "const TCHAR" *tsrc in
 An array of Windows TCHAR characters to convert to UTF-8.
-.AP size_t srcLen in
+.AP int srcLen in
 Length of \fIsrc\fR or \fItsrc\fR in bytes.  If the length is negative, the
 encoding-specific length of the string is used.
 .AP Tcl_DString *dstPtr out
 Pointer to an uninitialized or free \fBTcl_DString\fR in which the converted
 result will be stored.
@@ -279,11 +285,11 @@
 the encoding name to it.  The \fBTcl_DStringValue\fR is returned.
 .PP
 \fBTcl_GetEncodingNames\fR sets the \fIinterp\fR result to a list
 consisting of the names of all the encodings that are currently defined
 or can be dynamically loaded, searching the encoding path specified by
-\fBTcl_SetEncodingSearchPath\fR.  This procedure does not ensure that the
+\fBTcl_SetDefaultEncodingDir\fR.  This procedure does not ensure that the
 dynamically-loadable encoding files contain valid data, but merely that they
 exist.
 .PP
 \fBTcl_CreateEncoding\fR defines a new encoding and registers the C
 procedures that are called back to convert between the encoding and
@@ -306,11 +312,11 @@
 typedef struct Tcl_EncodingType {
     const char *\fIencodingName\fR;
     Tcl_EncodingConvertProc *\fItoUtfProc\fR;
     Tcl_EncodingConvertProc *\fIfromUtfProc\fR;
     Tcl_EncodingFreeProc *\fIfreeProc\fR;
-    void *\fIclientData\fR;
+    ClientData \fIclientData\fR;
     int \fInullSize\fR;
 } \fBTcl_EncodingType\fR;
 .CE
 .PP
 The \fIencodingName\fR provides a string name for the encoding, by
@@ -337,11 +343,11 @@
 The callback procedures \fItoUtfProc\fR and \fIfromUtfProc\fR should match the
 type \fBTcl_EncodingConvertProc\fR:
 .PP
 .CS
 typedef int \fBTcl_EncodingConvertProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         const char *\fIsrc\fR,
         int \fIsrcLen\fR,
         int \fIflags\fR,
         Tcl_EncodingState *\fIstatePtr\fR,
         char *\fIdst\fR,
@@ -369,11 +375,11 @@
 The callback procedure \fIfreeProc\fR, if non-NULL, should match the type
 \fBTcl_EncodingFreeProc\fR:
 .PP
 .CS
 typedef void \fBTcl_EncodingFreeProc\fR(
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .PP
 This \fIfreeProc\fR function is called when the encoding is deleted.  The
 \fIclientData\fR parameter is the same as the \fIclientData\fR field
 specified to \fBTcl_CreateEncoding\fR when the encoding was created.
@@ -394,10 +400,19 @@
 causes \fBTCL_ERROR\fR to be returned.  The elements of \fIsearchPath\fR
 are not verified as existing readable filesystem directories.  When
 searching for encoding data files takes place, and non-existent or
 non-readable filesystem directories on the \fIsearchPath\fR are silently
 ignored.
+.PP
+\fBTcl_GetDefaultEncodingDir\fR and \fBTcl_SetDefaultEncodingDir\fR
+are obsolete interfaces best replaced with calls to
+\fBTcl_GetEncodingSearchPath\fR and \fBTcl_SetEncodingSearchPath\fR.
+They are called to access and set the first element of the \fIsearchPath\fR
+list.  Since Tcl searches \fIsearchPath\fR for encoding data files in
+list order, these routines establish the
+.QW default
+directory in which to find encoding data files.
 .SH "ENCODING FILES"
 Space would prohibit precompiling into Tcl every possible encoding
 algorithm, so many encodings are stored on disk as dynamically-loadable
 encoding files.  This behavior also allows the user to create additional
 encoding files that can be loaded using the same mechanism.  These

Index: doc/Eval.3
==================================================================
--- doc/Eval.3
+++ doc/Eval.3
@@ -8,11 +8,11 @@
 '\"
 .TH Tcl_Eval 3 8.1 Tcl "Tcl Library Procedures"
 .so man.macros
 .BS
 .SH NAME
-Tcl_EvalObjEx, Tcl_EvalFile, Tcl_EvalObjv, Tcl_Eval, Tcl_EvalEx, Tcl_GlobalEval, Tcl_GlobalEvalObj, Tcl_VarEval \- execute Tcl scripts
+Tcl_EvalObjEx, Tcl_EvalFile, Tcl_EvalObjv, Tcl_Eval, Tcl_EvalEx, Tcl_GlobalEval, Tcl_GlobalEvalObj, Tcl_VarEval, Tcl_VarEvalVA \- execute Tcl scripts
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
 int
@@ -36,10 +36,13 @@
 int
 \fBTcl_GlobalEvalObj\fR(\fIinterp, objPtr\fR)
 .sp
 int
 \fBTcl_VarEval\fR(\fIinterp, part, part, ... \fB(char *) NULL\fR)
+.sp
+int
+\fBTcl_VarEvalVA\fR(\fIinterp, argList\fR)
 .SH ARGUMENTS
 .AS Tcl_Interp **termPtr
 .AP Tcl_Interp *interp in
 Interpreter in which to execute the script.  The interpreter's result is
 modified to hold the result or error message from the script.
@@ -62,10 +65,13 @@
 first null byte are used.
 .AP "const char" *script in
 Points to first byte of script to execute (null-terminated and UTF-8).
 .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
+\fBva_start\fR, and cleared using \fBva_end\fR.
 .BE
 
 .SH DESCRIPTION
 .PP
 The procedures described here are invoked to execute Tcl scripts in
@@ -120,14 +126,20 @@
 might be a UTF-8 special code.  The string is parsed and executed directly
 (using \fBTcl_EvalObjv\fR) instead of compiling it and executing the
 bytecodes.  In situations where it is known that the script will never be
 executed again, \fBTcl_Eval\fR may be faster than \fBTcl_EvalObjEx\fR.
  \fBTcl_Eval\fR returns a completion code and result just like
-\fBTcl_EvalObjEx\fR.
+\fBTcl_EvalObjEx\fR.  Note: for backward compatibility with versions before
+Tcl 8.0, \fBTcl_Eval\fR copies the value result in \fIinterp\fR to
+\fIinterp->result\fR (use is deprecated) where it can be accessed directly.
+ This makes \fBTcl_Eval\fR somewhat slower than \fBTcl_EvalEx\fR, which
+does not do the copy.
 .PP
 \fBTcl_EvalEx\fR is an extended version of \fBTcl_Eval\fR that takes
-additional arguments \fInumBytes\fR and \fIflags\fR.
+additional arguments \fInumBytes\fR and \fIflags\fR.  For the
+efficiency reason given above, \fBTcl_EvalEx\fR is generally preferred
+over \fBTcl_Eval\fR.
 .PP
 \fBTcl_GlobalEval\fR and \fBTcl_GlobalEvalObj\fR are older procedures
 that are now deprecated.  They are similar to \fBTcl_EvalEx\fR and
 \fBTcl_EvalObjEx\fR except that the script is evaluated in the global
 namespace and its variable context consists of global variables only
@@ -139,10 +151,14 @@
 then calls \fBTcl_Eval\fR to execute that string as a Tcl command.
 It returns the result of the command and also modifies
 \fIinterp->result\fR in the same way as \fBTcl_Eval\fR.
 The last argument to \fBTcl_VarEval\fR must be NULL to indicate the end
 of arguments.  \fBTcl_VarEval\fR is now deprecated.
+.PP
+\fBTcl_VarEvalVA\fR is the same as \fBTcl_VarEval\fR except that
+instead of taking a variable number of arguments it takes an argument
+list. Like \fBTcl_VarEval\fR, \fBTcl_VarEvalVA\fR is deprecated.
 
 .SH "FLAG BITS"
 .PP
 Any ORed combination of the following values may be used for the
 \fIflags\fR argument to procedures such as \fBTcl_EvalObjEx\fR:

Index: doc/Exit.3
==================================================================
--- doc/Exit.3
+++ doc/Exit.3
@@ -40,11 +40,11 @@
 usually means that an error occurred.
 .AP Tcl_ExitProc *proc in
 Procedure to invoke before exiting application, or (for
 \fBTcl_SetExitProc\fR) NULL to uninstall the current application exit
 procedure.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR.
 .BE
 
 .SH DESCRIPTION
 .PP
@@ -62,11 +62,11 @@
 \fBTcl_Exit\fR, the exit handlers will not be run.
 \fBTcl_Exit\fR internally invokes the \fBexit\fR system call, thus it never
 returns control to its caller.
 If an application exit handler has been installed (see
 \fBTcl_SetExitProc\fR), that handler is invoked with an argument
-consisting of the exit status (cast to void *); the application
+consisting of the exit status (cast to ClientData); the application
 exit handler should not return control to Tcl.
 .PP
 \fBTcl_Finalize\fR is similar to \fBTcl_Exit\fR except that it does not
 exit from the current process.
 It is useful for cleaning up when a process is finished using \fBTcl\fR but
@@ -91,11 +91,11 @@
 and freeing global memory.
 \fIProc\fR should match the type \fBTcl_ExitProc\fR:
 .PP
 .CS
 typedef void \fBTcl_ExitProc\fR(
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .PP
 The \fIclientData\fR parameter to \fIproc\fR is a
 copy of the \fIclientData\fR argument given to
 \fBTcl_CreateExitHandler\fR or \fBTcl_CreateThreadExitHandler\fR when
@@ -131,12 +131,13 @@
 application handler was installed.  If an application exit handler is
 installed, that exit handler takes over complete responsibility for
 finalization of Tcl's subsystems via \fBTcl_Finalize\fR at an
 appropriate time.  The argument passed to \fIproc\fR when it is
 invoked will be the exit status code (as passed to \fBTcl_Exit\fR)
-cast to a void *value.
+cast to a ClientData value.
 .PP
-\fBTcl_SetExitProc\fR can not be used in stub-enabled extensions.
+\fBTcl_SetExitProc\fR can not be used in stub-enabled extensions. Its symbol
+entry in the stub table is deprecated and it will be removed in Tcl 9.0.
 .SH "SEE ALSO"
 exit(n)
 .SH KEYWORDS
 abort, callback, cleanup, dynamic loading, end application, exit, unloading, thread

Index: doc/FileSystem.3
==================================================================
--- doc/FileSystem.3
+++ doc/FileSystem.3
@@ -18,11 +18,11 @@
 \fBTcl_FSRegister\fR(\fIclientData, fsPtr\fR)
 .sp
 int
 \fBTcl_FSUnregister\fR(\fIfsPtr\fR)
 .sp
-void *
+ClientData
 \fBTcl_FSData\fR(\fIfsPtr\fR)
 .sp
 void
 \fBTcl_FSMountsChanged\fR(\fIfsPtr\fR)
 .sp
@@ -123,11 +123,11 @@
 \fBTcl_FSJoinToPath\fR(\fIbasePtr, objc, objv\fR)
 .sp
 int
 \fBTcl_FSConvertToPathType\fR(\fIinterp, pathPtr\fR)
 .sp
-void *
+ClientData
 \fBTcl_FSGetInternalRep\fR(\fIpathPtr, fsPtr\fR)
 .sp
 Tcl_Obj *
 \fBTcl_FSGetTranslatedPath\fR(\fIinterp, pathPtr\fR)
 .sp
@@ -210,11 +210,11 @@
 Only files or directories matching the type descriptions contained in
 this structure will be returned. This parameter may be NULL.
 .AP Tcl_Interp *interp in
 Interpreter to use either for results, evaluation, or reporting error
 messages.
-.AP void *clientData in
+.AP ClientData clientData in
 The native description of the path value to create.
 .AP Tcl_Obj *firstPtr in
 The first of two path values to compare. The value may be converted
 to \fBpath\fR type.
 .AP Tcl_Obj *secondPtr in
@@ -247,11 +247,11 @@
 Name of a procedure to look up in the file's symbol table
 .AP Tcl_PackageInitProc **proc1Ptr out
 Filled with the init function for this code.
 .AP Tcl_PackageInitProc **proc2Ptr out
 Filled with the safe-init function for this code.
-.AP void **clientDataPtr out
+.AP ClientData *clientDataPtr out
 Filled with the clientData value to pass to this code's unload
 function when it is called.
 .AP Tcl_LoadHandle *loadHandlePtr out
 Filled with an abstract token representing the loaded file.
 .AP Tcl_FSUnloadFileProc **unloadProcPtr out
@@ -722,11 +722,11 @@
 better functions to use for most purposes.
 .PP
 \fBTcl_FSGetTranslatedStringPath\fR does the same as
 \fBTcl_FSGetTranslatedPath\fR, but returns a character string or NULL.
 The string returned is dynamically allocated and owned by the caller,
-which must store it or call \fBTcl_Free\fR to ensure it is freed. Again,
+which must store it or call \fBckfree\fR to ensure it is freed. Again,
 \fBTcl_FSGetNormalizedPath\fR or \fBTcl_FSGetNativePath\fR are usually
 better functions to use for most purposes.
 .PP
 \fBTcl_FSNewNativePath\fR performs something like the reverse of the
 usual obj->path->nativerep conversions. If some code retrieves a path
@@ -789,11 +789,11 @@
 It returns one of \fBTCL_PATH_ABSOLUTE\fR, \fBTCL_PATH_RELATIVE\fR, or
 \fBTCL_PATH_VOLUME_RELATIVE\fR
 .SS "PORTABLE STAT RESULT API"
 .PP
 \fBTcl_AllocStatBuf\fR allocates a \fITcl_StatBuf\fR on the system heap (which
-may be deallocated by being passed to \fBTcl_Free\fR). This allows extensions to
+may be deallocated by being passed to \fBckfree\fR). This allows extensions to
 invoke \fBTcl_FSStat\fR and \fBTcl_FSLstat\fR without being dependent on the
 size of the buffer. That in turn depends on the flags used to build Tcl.
 .PP
 .VS 8.6
 The portable fields of a \fITcl_StatBuf\fR may be read using the following
@@ -839,11 +839,11 @@
 .PP
 \fBTcl_FSUnregister\fR removes the given filesystem structure from
 the list of known filesystems, if it is known, and returns \fBTCL_OK\fR. If
 the filesystem is not currently registered, \fBTCL_ERROR\fR is returned.
 .PP
-\fBTcl_FSData\fR will return the clientData associated with the given
+\fBTcl_FSData\fR will return the ClientData associated with the given
 filesystem, if that filesystem is registered. Otherwise it will
 return NULL.
 .PP
 \fBTcl_FSMountsChanged\fR is used to inform the Tcl's core that
 the set of mount points for the given (already registered) filesystem
@@ -1016,31 +1016,31 @@
 Tcl's internal list of known filesystems.
 .PP
 .CS
 typedef int \fBTcl_FSPathInFilesystemProc\fR(
         Tcl_Obj *\fIpathPtr\fR,
-        void **\fIclientDataPtr\fR);
+        ClientData *\fIclientDataPtr\fR);
 .CE
 .SS DUPINTERNALREPPROC
 .PP
 This function makes a copy of a path's internal representation, and is
 called when Tcl needs to duplicate a path value. If NULL, Tcl will
 simply not copy the internal representation, which may then need to be
 regenerated later.
 .PP
 .CS
-typedef void *\fBTcl_FSDupInternalRepProc\fR(
-        void *\fIclientData\fR);
+typedef ClientData \fBTcl_FSDupInternalRepProc\fR(
+        ClientData \fIclientData\fR);
 .CE
 .SS FREEINTERNALREPPROC
 Free the internal representation. This must be implemented if internal
 representations need freeing (i.e.\ if some memory is allocated when an
 internal representation is generated), but may otherwise be NULL.
 .PP
 .CS
 typedef void \fBTcl_FSFreeInternalRepProc\fR(
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .SS INTERNALTONORMALIZEDPROC
 .PP
 Function to convert internal representation to a normalized path. Only
 required if the filesystem creates pure path values with no string/path
@@ -1047,11 +1047,11 @@
 representation. The return value is a Tcl value whose string
 representation is the normalized path.
 .PP
 .CS
 typedef Tcl_Obj *\fBTcl_FSInternalToNormalizedProc\fR(
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .SS CREATEINTERNALREPPROC
 .PP
 Function to take a path value, and calculate an internal
 representation for it, and store that native representation in the
@@ -1058,11 +1058,11 @@
 value. May be NULL if paths have no internal representation, or if
 the \fITcl_FSPathInFilesystemProc\fR for this filesystem always
 immediately creates an internal representation for paths it accepts.
 .PP
 .CS
-typedef void *\fBTcl_FSCreateInternalRepProc\fR(
+typedef ClientData \fBTcl_FSCreateInternalRepProc\fR(
         Tcl_Obj *\fIpathPtr\fR);
 .CE
 .SS NORMALIZEPATHPROC
 .PP
 Function to normalize a path. Should be implemented for all

Index: doc/FindExec.3
==================================================================
--- doc/FindExec.3
+++ doc/FindExec.3
@@ -57,8 +57,9 @@
 \fBTcl_FindExecutable\fR.  This procedure call is the C API
 equivalent to the \fBinfo nameofexecutable\fR command.  NULL
 is returned if the internal full path name has not been
 computed or unknown.
 .PP
-\fBTcl_FindExecutable\fR can not be used in stub-enabled extensions.
+\fBTcl_FindExecutable\fR can not be used in stub-enabled extensions. Its symbol
+entry in the stub table is deprecated and it will be removed in Tcl 9.0.
 .SH KEYWORDS
 binary, executable file

Index: doc/GetInt.3
==================================================================
--- doc/GetInt.3
+++ doc/GetInt.3
@@ -62,13 +62,16 @@
 if the first such characters are
 .QW \fB0o\fR
 then \fIsrc\fR is expected to be in octal form;  otherwise,
 if the first such characters are
 .QW \fB0b\fR
+then \fIsrc\fR is expected to be in binary form;  otherwise,
+if the first such character is
+.QW \fB0\fR
 then \fIsrc\fR
-is expected to be in binary form;  otherwise, \fIsrc\fR is
-expected to be in decimal form.
+is expected to be in octal form;  otherwise, \fIsrc\fR
+is expected to be in decimal form.
 .PP
 \fBTcl_GetDouble\fR expects \fIsrc\fR to consist of a floating-point
 number, which is:  white space;  a sign; a sequence of digits;  a
 decimal point
 .QW \fB.\fR ;

Index: doc/GetOpnFl.3
==================================================================
--- doc/GetOpnFl.3
+++ doc/GetOpnFl.3
@@ -26,11 +26,11 @@
 Non-zero means the file will be used for writing, zero means it will
 be used for reading.
 .AP int checkUsage in
 If non-zero, then an error will be generated if the file was not opened
 for the access indicated by \fIwrite\fR.
-.AP void **filePtr out
+.AP ClientData *filePtr out
 Points to word in which to store pointer to FILE structure for
 the file given by \fIchanID\fR.
 .BE
 
 .SH DESCRIPTION

Index: doc/GetTime.3
==================================================================
--- doc/GetTime.3
+++ doc/GetTime.3
@@ -25,17 +25,17 @@
 .AP Tcl_GetTimeProc getProc in
 Pointer to handler function replacing \fBTcl_GetTime\fR's access to the OS.
 .AP Tcl_ScaleTimeProc scaleProc in
 Pointer to handler function for the conversion of time delays in the
 virtual domain to real-time.
-.AP void *clientData in
+.AP ClientData clientData in
 Value passed through to the two handler functions.
 .AP Tcl_GetTimeProc *getProcPtr out
 Pointer to place the currently registered get handler function into.
 .AP Tcl_ScaleTimeProc *scaleProcPtr out
 Pointer to place the currently registered scale handler function into.
-.AP void **clientDataPtr out
+.AP ClientData *clientDataPtr out
 Pointer to place the currently registered pass-through value into.
 .BE
 .SH DESCRIPTION
 .PP
 The \fBTcl_GetTime\fR function retrieves the current time as a
@@ -81,14 +81,14 @@
 The signatures of the handler functions are as follows:
 .PP
 .CS
 typedef void \fBTcl_GetTimeProc\fR(
         Tcl_Time *\fItimebuf\fR,
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 typedef void \fBTcl_ScaleTimeProc\fR(
         Tcl_Time *\fItimebuf\fR,
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .PP
 The \fItimebuf\fR fields contain the time to manipulate, and the
 \fIclientData\fR fields contain a pointer supplied at the time the handler
 functions were registered.

Index: doc/Hash.3
==================================================================
--- doc/Hash.3
+++ doc/Hash.3
@@ -28,11 +28,11 @@
 \fBTcl_DeleteHashEntry\fR(\fIentryPtr\fR)
 .sp
 Tcl_HashEntry *
 \fBTcl_FindHashEntry\fR(\fItablePtr, key\fR)
 .sp
-void *
+ClientData
 \fBTcl_GetHashValue\fR(\fIentryPtr\fR)
 .sp
 \fBTcl_SetHashValue\fR(\fIentryPtr, value\fR)
 .sp
 void *
@@ -64,12 +64,13 @@
 .AP int *newPtr out
 The word at \fI*newPtr\fR is set to 1 if a new entry was created
 and 0 if there was already an entry for \fIkey\fR.
 .AP Tcl_HashEntry *entryPtr in
 Pointer to hash table entry.
-.AP void *value in
-New value to assign to hash table entry.
+.AP ClientData value in
+New value to assign to hash table entry.  Need not have type
+ClientData, but must fit in same space as ClientData.
 .AP Tcl_HashSearch *searchPtr in
 Pointer to record to use to keep track of progress in enumerating
 all the entries in a hash table.
 .BE
 .SH DESCRIPTION
@@ -183,10 +184,15 @@
 except that it does not create a new entry if the key doesn't exist;
 instead, it returns NULL as result.
 .PP
 \fBTcl_GetHashValue\fR and \fBTcl_SetHashValue\fR are used to
 read and write an entry's value, respectively.
+Values are stored and retrieved as type
+.QW ClientData ,
+which is
+large enough to hold a pointer value.  On almost all machines this is
+large enough to hold an integer value too.
 .PP
 \fBTcl_GetHashKey\fR returns the key for a given hash table entry,
 either as a pointer to a string, a one-word
 .PQ "char *"
 key, or
@@ -221,11 +227,11 @@
 \fBTcl_HashStats\fR returns a dynamically-allocated string with
 overall information about a hash table, such as the number of
 entries it contains, the number of buckets in its hash array,
 and the utilization of the buckets.
 It is the caller's responsibility to free the result string
-by passing it to \fBTcl_Free\fR.
+by passing it to \fBckfree\fR.
 .PP
 The header file \fBtcl.h\fR defines the actual data structures
 used to implement hash tables.
 This is necessary so that clients can allocate Tcl_HashTable
 structures and so that macros can be used to read and write

Index: doc/InitStubs.3
==================================================================
--- doc/InitStubs.3
+++ doc/InitStubs.3
@@ -61,13 +61,13 @@
 .IP 2) 5
 Define the \fBUSE_TCL_STUBS\fR symbol.  Typically, you would include the
 \fB\-DUSE_TCL_STUBS\fR flag when compiling the extension.
 .IP 3) 5
 Link the extension with the Tcl stubs library instead of the standard
-Tcl library.  For example, to use the Tcl 9.0 ABI on Unix platforms,
-the library name is \fIlibtclstub9.0.a\fR; on Windows platforms, the
-library name is \fItclstub90.lib\fR.
+Tcl library.  For example, to use the Tcl 8.6 ABI on Unix platforms,
+the library name is \fIlibtclstub8.6.a\fR; on Windows platforms, the
+library name is \fItclstub86.lib\fR.
 .PP
 If the extension also requires the Tk API, it must also call
 \fBTk_InitStubs\fR to initialize the Tk stubs interface and link
 with the Tk stubs libraries.  See the \fBTk_InitStubs\fR page for
 more information.

ADDED   doc/InitSubSyst.3
Index: doc/InitSubSyst.3
==================================================================
--- /dev/null
+++ doc/InitSubSyst.3
@@ -0,0 +1,31 @@
+'\"
+'\" Copyright (c) 2018 Tcl Core Team
+'\"
+'\" See the file "license.terms" for information on usage and redistribution
+'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+'\" 
+.so man.macros
+.TH Tcl_InitSubsystems 3 8.7 Tcl "Tcl Library Procedures"
+.BS
+.SH NAME
+Tcl_InitSubsystems \- initialize the Tcl library.
+.SH SYNOPSIS
+.nf
+\fB#include <tcl.h>\fR
+.sp
+void
+\fBTcl_InitSubsystems\fR(\fIvoid\fR)
+.SH DESCRIPTION
+.PP
+The \fBTcl_InitSubsystems\fR procedure initializes the Tcl
+library. This procedure is typically invoked as the very
+first thing in the application's main program.
+.PP
+\fBTcl_InitSubsystems\fR is very similar in use to
+\fBTcl_FindExecutable\fR. It can be used when Tcl is
+used as utility library, no other encodings than utf8,
+iso8859-1 or unicode are used, and no interest exists in the
+value of \fBinfo nameofexecutable\fR. The system encoding will not
+be extracted from the environment, but falls back to iso8859-1.
+.SH KEYWORDS
+binary, executable file

Index: doc/Interp.3
==================================================================
--- doc/Interp.3
+++ doc/Interp.3
@@ -31,10 +31,23 @@
 other routines in the Tcl interface.  Accessing fields directly through
 the pointer as described below is no longer supported.  The supported
 public routines \fBTcl_SetResult\fR, \fBTcl_GetResult\fR,
 \fBTcl_SetErrorLine\fR, \fBTcl_GetErrorLine\fR must be used instead.
 .PP
+For legacy programs and extensions no longer being maintained, compiles
+against the Tcl 8.6 header files are only possible with the compiler
+directives
+.CS
+#define USE_INTERP_RESULT
+.CE
+and/or
+.CS
+#define USE_INTERP_ERRORLINE
+.CE
+depending on which fields of the \fBTcl_Interp\fR struct are accessed.
+These directives may be embedded in code or supplied via compiler options.
+.PP
 The \fIresult\fR and \fIfreeProc\fR fields are used to return
 results or error messages from commands.
 This information is returned by command procedures back to \fBTcl_Eval\fR,
 and by \fBTcl_Eval\fR back to its callers.
 The \fIresult\fR field points to the string that represents the

Index: doc/Limit.3
==================================================================
--- doc/Limit.3
+++ doc/Limit.3
@@ -81,11 +81,11 @@
 the limited interpreter will be permitted to continue to process after
 the handler returns.  Many handlers may be attached to the same
 interpreter limit; their order of execution is not defined, and they
 must be identified by \fIhandlerProc\fR and \fIclientData\fR when they
 are deleted.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary pointer-sized word used to pass some context to the
 \fIhandlerProc\fR function.
 .AP Tcl_LimitHandlerDeleteProc *deleteProc in
 Function to call whenever a handler is deleted.  May be NULL if the
 \fIclientData\fR requires no deletion.
@@ -160,11 +160,11 @@
 the function that will actually be called; it should have the
 following prototype:
 .PP
 .CS
 typedef void \fBTcl_LimitHandlerProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Interp *\fIinterp\fR);
 .CE
 .PP
 The \fIclientData\fR argument to the handler will be whatever is
 passed to the \fIclientData\fR argument to \fBTcl_LimitAddHandler\fR,
@@ -177,11 +177,11 @@
 \fBTcl_Free\fR.  Otherwise, it should refer to a function with the
 following prototype:
 .PP
 .CS
 typedef void \fBTcl_LimitHandlerDeleteProc\fR(
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .PP
 A limit handler may be deleted using \fBTcl_LimitRemoveHandler\fR; the
 handler removed will be the first one found (out of the handlers added
 with \fBTcl_LimitAddHandler\fR) with exactly matching \fItype\fR,

Index: doc/LinkVar.3
==================================================================
--- doc/LinkVar.3
+++ doc/LinkVar.3
@@ -57,11 +57,11 @@
 .VE "TIP 312"
 .sp
 All the above for both functions may be
 optionally OR'ed with \fBTCL_LINK_READ_ONLY\fR to make the Tcl
 variable read-only.
-.AP size_t size in
+.AP int size in
 .VS "TIP 312"
 The number of elements in the C array. Must be greater than zero.
 .VE "TIP 312"
 .BE
 .SH DESCRIPTION
@@ -263,11 +263,11 @@
 .TP
 \fBTCL_LINK_STRING\fR
 .
 The C variable is of type \fBchar *\fR.
 If its value is not NULL then it must be a pointer to a string
-allocated with \fBTcl_Alloc\fR.
+allocated with \fBTcl_Alloc\fR or \fBckalloc\fR.
 Whenever the Tcl variable is modified the current C string will be
 freed and new memory will be allocated to hold a copy of the variable's
 new value.
 If the C variable contains a NULL pointer then the Tcl variable
 will read as

Index: doc/Method.3
==================================================================
--- doc/Method.3
+++ doc/Method.3
@@ -59,11 +59,11 @@
 \fBTcl_ObjectContextObject\fR(\fIcontext\fR)
 .sp
 int
 \fBTcl_ObjectContextSkippedArgs\fR(\fIcontext\fR)
 .SH ARGUMENTS
-.AS void *clientData in
+.AS ClientData clientData in
 .AP Tcl_Interp *interp in/out
 The interpreter holding the object or class to create or update a method in.
 .AP Tcl_Object object in
 The object to create the method in.
 .AP Tcl_Class class in
@@ -81,14 +81,14 @@
 and \fBTCL_OO_METHOD_PRIVATE\fR for a private method.
 .VE TIP500
 .AP Tcl_MethodType *methodTypePtr in
 A description of the type of the method to create, or the type of method to
 compare against.
-.AP void *clientData in
+.AP ClientData clientData in
 A piece of data that is passed to the implementation of the method without
 interpretation.
-.AP void **clientDataPtr out
+.AP ClientData *clientDataPtr out
 A pointer to a variable in which to write the \fIclientData\fR value supplied
 when the method was created. If NULL, the \fIclientData\fR value will not be
 retrieved.
 .AP Tcl_Method method in
 A reference to a method to query.
@@ -211,11 +211,11 @@
 .PP
 Functions matching this signature are called when the method is invoked.
 .PP
 .CS
 typedef int \fBTcl_MethodCallProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Interp *\fIinterp\fR,
         Tcl_ObjectContext \fIobjectContext\fR,
         int \fIobjc\fR,
         Tcl_Obj *const *\fIobjv\fR);
 .CE
@@ -232,11 +232,11 @@
 Functions matching this signature are used when a method is deleted, whether
 through a new method being created or because the object or class is deleted.
 .PP
 .CS
 typedef void \fBTcl_MethodDeleteProc\fR(
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .PP
 The \fIclientData\fR argument to a Tcl_MethodDeleteProc will be the same as
 the value passed to the \fIclientData\fR argument to \fBTcl_NewMethod\fR or
 \fBTcl_NewInstanceMethod\fR when the method was created.
@@ -246,12 +246,12 @@
 class is copied using \fBTcl_CopyObjectInstance\fR (or \fBoo::copy\fR).
 .PP
 .CS
 typedef int \fBTcl_CloneProc\fR(
         Tcl_Interp *\fIinterp\fR,
-        void *\fIoldClientData\fR,
-        void **\fInewClientDataPtr\fR);
+        ClientData \fIoldClientData\fR,
+        ClientData *\fInewClientDataPtr\fR);
 .CE
 .PP
 The \fIinterp\fR argument gives a place to write an error message when the
 attempt to clone the object is to fail, in which case the clone procedure must
 also return TCL_ERROR; it should return TCL_OK otherwise.

Index: doc/NRE.3
==================================================================
--- doc/NRE.3
+++ doc/NRE.3
@@ -47,11 +47,11 @@
 \fBTcl_NRCallObjProc\fR to call \fInreProc\fR using a new trampoline.  Behaves
 in the same way as the \fIproc\fR argument to \fBTcl_CreateObjCommand\fR(3)
 (\fIq.v.\fR).
 .AP Tcl_ObjCmdProc *nreProc in
 Called instead of \fIproc\fR when a trampoline is already in use.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value passed to \fIproc\fR, \fInreProc\fR, \fIdeleteProc\fR
 and \fIobjProc\fR.
 .AP Tcl_CmdDeleteProc *deleteProc in/out
 Called before \fIcmdName\fR is deleted from the interpreter, allowing for
 command-specific cleanup. May be NULL.
@@ -70,14 +70,14 @@
 .AP Tcl_Obj *resultPtr out
 Pointer to an unshared Tcl_Obj where the result of the evaluation is stored if
 the return code is TCL_OK.
 .AP Tcl_NRPostProc *postProcPtr in
 A function to push.
-.AP void *data0 in
-.AP void *data1 in
-.AP void *data2 in
-.AP void *data3 in
+.AP ClientData data0 in
+.AP ClientData data1 in
+.AP ClientData data2 in
+.AP ClientData data3 in
 \fIdata0\fR through \fIdata3\fR are four one-word values that will be passed
 to the function designated by \fIpostProcPtr\fR when it is invoked.
 .BE
 .SH DESCRIPTION
 .PP
@@ -128,11 +128,11 @@
 \fBTcl_NRPostProc\fR is:
 .PP
 .CS
 typedef int
 \fBTcl_NRPostProc\fR(
-        \fBvoid *\fR \fIdata\fR[],
+        \fBClientData\fR \fIdata\fR[],
         \fBTcl_Interp\fR *\fIinterp\fR,
         int \fIresult\fR);
 .CE
 .PP
 \fIdata\fR is a pointer to an array containing \fIdata0\fR through \fIdata3\fR.
@@ -144,11 +144,11 @@
 stack, to evalute a script:
 .PP
 .CS
 int
 \fITheCmdOldObjProc\fR(
-    void *clientData,
+    ClientData clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const objv[])
 {
     int result;
@@ -175,11 +175,11 @@
 call \fITheCmdNRObjProc\fR:
 .PP
 .CS
 int
 \fITheCmdOldObjProc\fR(
-    void *clientData,
+    ClientData clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const objv[])
 {
     return \fBTcl_NRCallObjProc\fR(interp, \fITheCmdNRObjProc\fR,
@@ -188,11 +188,11 @@
 .CE
 .PP
 .CS
 int
 \fITheCmdNRObjProc\fR
-    void *clientData,
+    ClientData clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const objv[])
 {
     Tcl_Obj *objPtr;
@@ -209,11 +209,11 @@
 .CE
 .PP
 .CS
 int
 \fITheCmdNRPostProc\fR(
-    void *data[],
+    ClientData data[],
     Tcl_Interp *interp,
     int result)
 {
     /* \fIdata[0] .. data[3]\fR are the four words of data
      * passed to \fBTcl_NRAddCallback\fR */

Index: doc/Namespace.3
==================================================================
--- doc/Namespace.3
+++ doc/Namespace.3
@@ -55,11 +55,11 @@
 .AP Tcl_Interp *interp in/out
 The interpreter in which the namespace exists and where name lookups
 are performed. Also where error result messages are written.
 .AP "const char" *name in
 The name of the namespace or command to be created or accessed.
-.AP void *clientData in
+.AP ClientData clientData in
 A context pointer by the creator of the namespace.  Not interpreted by
 Tcl at all.
 .AP Tcl_NamespaceDeleteProc *deleteProc in
 A pointer to function to call when the namespace is deleted, or NULL
 if no such callback is to be performed.
@@ -115,11 +115,11 @@
 \fBTcl_CreateNamespace\fR creates a new namespace.  The
 \fIdeleteProc\fR will have the following type signature:
 .PP
 .CS
 typedef void \fBTcl_NamespaceDeleteProc\fR(
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .PP
 \fBTcl_DeleteNamespace\fR deletes a namespace, calling the
 \fIdeleteProc\fR defined for the namespace (if any).
 .PP

Index: doc/Notifier.3
==================================================================
--- doc/Notifier.3
+++ doc/Notifier.3
@@ -36,11 +36,11 @@
 \fBTcl_GetCurrentThread\fR()
 .sp
 void
 \fBTcl_DeleteEvents\fR(\fIdeleteProc, clientData\fR)
 .sp
-void *
+ClientData
 \fBTcl_InitNotifier\fR()
 .sp
 void
 \fBTcl_FinalizeNotifier\fR(\fIclientData\fR)
 .sp
@@ -76,11 +76,11 @@
 Procedure to invoke to prepare for event wait in \fBTcl_DoOneEvent\fR.
 .AP Tcl_EventCheckProc *checkProc in
 Procedure for \fBTcl_DoOneEvent\fR to invoke after waiting for
 events.  Checks to see if any events have occurred and, if so,
 queues them.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIsetupProc\fR, \fIcheckProc\fR, or
 \fIdeleteProc\fR.
 .AP "const Tcl_Time" *timePtr in
 Indicates the maximum amount of time to wait for an event.  This
 is specified as an interval (how long to wait), not an absolute
@@ -87,11 +87,11 @@
 time (when to wakeup).  If the pointer passed to \fBTcl_WaitForEvent\fR
 is NULL, it means there is no maximum wait time:  wait forever if
 necessary.
 .AP Tcl_Event *evPtr in
 An event to add to the event queue.  The storage for the event must
-have been allocated by the caller using \fBTcl_Alloc\fR.
+have been allocated by the caller using \fBTcl_Alloc\fR or \fBckalloc\fR.
 .AP Tcl_QueuePosition position in
 Where to add the new event in the queue:  \fBTCL_QUEUE_TAIL\fR,
 \fBTCL_QUEUE_HEAD\fR, or \fBTCL_QUEUE_MARK\fR.
 .AP Tcl_ThreadId threadId in
 A unique identifier for a thread.
@@ -130,26 +130,21 @@
 higher-level software that they have occurred.  The procedures
 \fBTcl_CreateEventSource\fR, \fBTcl_DeleteEventSource\fR,
 and \fBTcl_SetMaxBlockTime\fR, \fBTcl_QueueEvent\fR, and
 \fBTcl_DeleteEvents\fR are used primarily by event sources.
 .IP [2]
-The event queue: for non-threaded applications,
-there is a single queue for the whole application,
-containing events that have been detected but not yet serviced.  Event
-sources place events onto the queue so that they may be processed in
-order at appropriate times during the event loop. The event queue
-guarantees a fair discipline of event handling, so that no event
-source can starve the others.  It also allows events to be saved for
-servicing at a future time.  Threaded applications work in a
-similar manner, except that there is a separate event queue for
-each thread containing a Tcl interpreter.
+The event queue: there is a single queue for each thread containing
+a Tcl interpreter, containing events that have been detected but not
+yet serviced.  Event sources place events onto the queue so that they
+may be processed in order at appropriate times during the event loop.
+The event queue guarantees a fair discipline of event handling, so that
+no event source can starve the others.  It also allows events to be
+saved for servicing at a future time.
 \fBTcl_QueueEvent\fR is used (primarily
-by event sources) to add events to the event queue and
+by event sources) to add events to the current thread's event queue and
 \fBTcl_DeleteEvents\fR is used to remove events from the queue without
-processing them.  In a threaded application, \fBTcl_QueueEvent\fR adds
-an event to the current thread's queue, and \fBTcl_ThreadQueueEvent\fR
-adds an event to a queue in a specific thread.
+processing them.
 .IP [3]
 The event loop: in order to detect and process events, the application
 enters a loop that waits for events to occur, places them on the event
 queue, and then processes them.  Most applications will do this by
 calling the procedure \fBTcl_DoOneEvent\fR, which is described in a
@@ -228,11 +223,11 @@
 the event source.
 \fISetupProc\fR should match the following prototype:
 .PP
 .CS
 typedef void \fBTcl_EventSetupProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         int \fIflags\fR);
 .CE
 .PP
 The \fIclientData\fR argument will be the same as the \fIclientData\fR
 argument to \fBTcl_CreateEventSource\fR;  it is typically used to
@@ -306,11 +301,11 @@
 \fBTcl_CreateEventSource\fR.  \fICheckProc\fR must match the
 following prototype:
 .PP
 .CS
 typedef void \fBTcl_EventCheckProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         int \fIflags\fR);
 .CE
 .PP
 The arguments to this procedure are the same as those for \fIsetupProc\fR.
 \fBCheckProc\fR is invoked by \fBTcl_DoOneEvent\fR after it has waited
@@ -397,19 +392,15 @@
 of window events.
 .PP
 When \fIproc\fR returns 1, \fBTcl_ServiceEvent\fR will remove the
 event from the event queue and free its storage.
 Note that the storage for an event must be allocated by
-the event source (using \fBTcl_Alloc\fR)
+the event source (using \fBTcl_Alloc\fR or the Tcl macro \fBckalloc\fR)
 before calling \fBTcl_QueueEvent\fR, but it
 will be freed by \fBTcl_ServiceEvent\fR, not by the event source.
 .PP
-Threaded applications work in a
-similar manner, except that there is a separate event queue for
-each thread containing a Tcl interpreter.
-Calling \fBTcl_QueueEvent\fR in a multithreaded application adds
-an event to the current thread's queue.
+Calling \fBTcl_QueueEvent\fR adds an event to the current thread's queue.
 To add an event to another thread's queue, use \fBTcl_ThreadQueueEvent\fR.
 \fBTcl_ThreadQueueEvent\fR accepts as an argument a Tcl_ThreadId argument,
 which uniquely identifies a thread in a Tcl application.  To obtain the
 Tcl_ThreadId for the current thread, use the \fBTcl_GetCurrentThread\fR
 procedure.  (A thread would then need to pass this identifier to other
@@ -426,11 +417,11 @@
 queue.  \fIProc\fR should match the following prototype:
 .PP
 .CS
 typedef int \fBTcl_EventDeleteProc\fR(
         Tcl_Event *\fIevPtr\fR,
-        void *\fIclientData\fR);
+        ClientData \fIclientData\fR);
 .CE
 .PP
 The \fIclientData\fR argument will be the same as the \fIclientData\fR
 argument to \fBTcl_DeleteEvents\fR; it is typically used to point to
 private information managed by the event source.  The \fIevPtr\fR will
@@ -496,12 +487,11 @@
 terminate.  Under Windows this happens when a WM_QUIT message is received;
 under Unix it happens when \fBTcl_WaitForEvent\fR would have waited
 forever because there were no active event sources and the timeout was
 infinite.
 .PP
-\fBTcl_AlertNotifier\fR is used in multithreaded applications to allow
-any thread to
+\fBTcl_AlertNotifier\fR is used to allow any thread to
 .QW "wake up"
 the notifier to alert it to new events on its
 queue.  \fBTcl_AlertNotifier\fR requires as an argument the notifier
 handle returned by \fBTcl_InitNotifier\fR.
 .PP

Index: doc/Object.3
==================================================================
--- doc/Object.3
+++ doc/Object.3
@@ -109,13 +109,13 @@
 Each Tcl value is represented by a \fBTcl_Obj\fR structure
 which is defined as follows.
 .PP
 .CS
 typedef struct Tcl_Obj {
-    size_t \fIrefCount\fR;
+    int \fIrefCount\fR;
     char *\fIbytes\fR;
-    size_t \fIlength\fR;
+    int \fIlength\fR;
     const Tcl_ObjType *\fItypePtr\fR;
     union {
         long \fIlongValue\fR;
         double \fIdoubleValue\fR;
         void *\fIotherValuePtr\fR;

Index: doc/ObjectType.3
==================================================================
--- doc/ObjectType.3
+++ doc/ObjectType.3
@@ -184,12 +184,12 @@
 and to have no null bytes before that; this allows string representations
 to be treated as conventional null character-terminated C strings.
 These restrictions are easily met by using Tcl's internal UTF encoding
 for the string representation, same as one would do for other
 Tcl routines accepting string values as arguments.
-Storage for the byte array must be allocated in the heap by \fBTcl_Alloc\fR.
-Note that \fIupdateStringProc\fRs must allocate
+Storage for the byte array must be allocated in the heap by \fBTcl_Alloc\fR
+or \fBckalloc\fR.  Note that \fIupdateStringProc\fRs must allocate
 enough storage for the string's bytes and the terminating null byte.
 .PP
 The \fIupdateStringProc\fR for Tcl's built-in double type, for example,
 calls Tcl_PrintDouble to write to a buffer of size TCL_DOUBLE_SPACE,
 then allocates and copies the string representation to just enough

Index: doc/OpenFileChnl.3
==================================================================
--- doc/OpenFileChnl.3
+++ doc/OpenFileChnl.3
@@ -51,32 +51,32 @@
 \fBTcl_ReadChars\fR(\fIchannel, readObjPtr, charsToRead, appendFlag\fR)
 .sp
 int
 \fBTcl_Read\fR(\fIchannel, readBuf, bytesToRead\fR)
 .sp
-size_t
+int
 \fBTcl_GetsObj\fR(\fIchannel, lineObjPtr\fR)
 .sp
-size_t
+int
 \fBTcl_Gets\fR(\fIchannel, lineRead\fR)
 .sp
-size_t
+int
 \fBTcl_Ungets\fR(\fIchannel, input, inputLen, addAtEnd\fR)
 .sp
-size_t
+int
 \fBTcl_WriteObj\fR(\fIchannel, writeObjPtr\fR)
 .sp
-size_t
+int
 \fBTcl_WriteChars\fR(\fIchannel, charBuf, bytesToWrite\fR)
 .sp
-size_t
+int
 \fBTcl_Write\fR(\fIchannel, byteBuf, bytesToWrite\fR)
 .sp
-size_t
+int
 \fBTcl_ReadRaw\fR(\fIchannel, readBuf, bytesToRead\fR)
 .sp
-size_t
+int
 \fBTcl_WriteRaw\fR(\fIchannel, byteBuf, bytesToWrite\fR)
 .sp
 int
 \fBTcl_Eof\fR(\fIchannel\fR)
 .sp
@@ -132,11 +132,11 @@
 input of the invoking process; likewise for \fBTCL_STDOUT\fR and
 \fBTCL_STDERR\fR. If \fBTCL_ENFORCE_MODE\fR is not set, then the pipe can
 redirect stdio handles to override the stdio handles for which
 \fBTCL_STDIN\fR, \fBTCL_STDOUT\fR and \fBTCL_STDERR\fR have been set.  If it
 is set, then such redirections cause an error.
-.AP void *handle in
+.AP ClientData handle in
 Operating system specific handle for I/O to a file. For Unix this is a
 file descriptor, for Windows it is a HANDLE.
 .AP int readOrWrite in
 OR-ed combination of \fBTCL_READABLE\fR and \fBTCL_WRITABLE\fR to indicate
 what operations are valid on \fIhandle\fR.
@@ -152,20 +152,20 @@
 A Tcl channel for input or output.  Must have been the return value
 from a procedure such as \fBTcl_OpenFileChannel\fR.
 .AP Tcl_Obj *readObjPtr in/out
 A pointer to a Tcl value in which to store the characters read from the
 channel.
-.AP size_t charsToRead in
+.AP int charsToRead in
 The number of characters to read from the channel.  If the channel's encoding
 is \fBbinary\fR, this is equivalent to the number of bytes to read from the
 channel.
 .AP int appendFlag in
 If non-zero, data read from the channel will be appended to the value.
 Otherwise, the data will replace the existing contents of the value.
 .AP char *readBuf out
 A buffer in which to store the bytes read from the channel.
-.AP size_t bytesToRead in
+.AP int bytesToRead in
 The number of bytes to read from the channel.  The buffer \fIreadBuf\fR must
 be large enough to hold this many bytes.
 .AP Tcl_Obj *lineObjPtr in/out
 A pointer to a Tcl value in which to store the line read from the
 channel.  The line read will be appended to the current value of the
@@ -174,11 +174,11 @@
 A pointer to a Tcl dynamic string in which to store the line read from the
 channel.  Must have been initialized by the caller.  The line read will be
 appended to any data already in the dynamic string.
 .AP "const char" *input in
 The input to add to a channel buffer.
-.AP size_t inputLen in
+.AP int inputLen in
 Length of the input
 .AP int addAtEnd in
 Flag indicating whether the input should be added to the end or
 beginning of the channel buffer.
 .AP Tcl_Obj *writeObjPtr in
@@ -185,11 +185,11 @@
 A pointer to a Tcl value whose contents will be output to the channel.
 .AP "const char" *charBuf in
 A buffer containing the characters to output to the channel.
 .AP "const char" *byteBuf in
 A buffer containing the bytes to output to the channel.
-.AP size_t bytesToWrite in
+.AP int bytesToWrite in
 The number of bytes to consume from \fIcharBuf\fR or \fIbyteBuf\fR and
 output to the channel.
 .AP Tcl_WideInt offset in
 How far to move the access point in the channel at which the next input or
 output operation will be applied, measured in bytes from the position
@@ -275,11 +275,11 @@
 .PP
 If an error occurs while opening the channel, \fBTcl_OpenCommandChannel\fR
 returns NULL and records a POSIX error code that can be retrieved with
 \fBTcl_GetErrno\fR.
 In addition, \fBTcl_OpenCommandChannel\fR leaves an error message in
-the interpreter's result if \fIinterp\fR is not NULL.
+the interpreter's result. \fIinterp\fR cannot be NULL.
 .PP
 The newly created channel is not registered in the supplied interpreter; to
 register it, use \fBTcl_RegisterChannel\fR, described below.
 If one of the standard channels, \fBstdin\fR, \fBstdout\fR or \fBstderr\fR was
 previously closed, the act of creating the new channel also assigns it as a

Index: doc/OpenTcp.3
==================================================================
--- doc/OpenTcp.3
+++ doc/OpenTcp.3
@@ -48,16 +48,16 @@
 .AP int async in
 If nonzero, the client socket is connected asynchronously to the server.
 .AP "unsigned int" flags in
 ORed combination of \fBTCL_TCPSERVER\fR flags that specify additional
 informations about the socket being created.
-.AP void *sock in
+.AP ClientData sock in
 Platform-specific handle for client TCP socket.
 .AP Tcl_TcpAcceptProc *proc in
 Pointer to a procedure to invoke each time a new connection is
 accepted via the socket.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR.
 .BE
 .SH DESCRIPTION
 .PP
 These functions are convenience procedures for creating
@@ -125,11 +125,11 @@
 for the new connection and invokes \fIproc\fR with information about
 the channel. \fIProc\fR must match the following prototype:
 .PP
 .CS
 typedef void \fBTcl_TcpAcceptProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Channel \fIchannel\fR,
         char *\fIhostName\fR,
         int \fIport\fR);
 .CE
 .PP

Index: doc/Panic.3
==================================================================
--- doc/Panic.3
+++ doc/Panic.3
@@ -5,18 +5,21 @@
 .TH Tcl_Panic 3 8.4 Tcl "Tcl Library Procedures"
 .so man.macros
 .BS
 '\"  Note:  do not modify the .SH NAME line immediately below!
 .SH NAME
-Tcl_Panic, Tcl_SetPanicProc, Tcl_ConsolePanic \- report fatal error and abort
+Tcl_Panic, Tcl_PanicVA, Tcl_SetPanicProc, Tcl_ConsolePanic \- report fatal error and abort
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
 void
 \fBTcl_Panic\fR(\fIformat\fR, \fIarg\fR, \fIarg\fR, \fI...\fR)
 .sp
+void
+\fBTcl_PanicVA\fR(\fIformat\fR, \fIargList\fR)
+.sp
 void
 \fBTcl_SetPanicProc\fR(\fIpanicProc\fR)
 .sp
 void
 \fBTcl_ConsolePanic\fR(\fIformat\fR, \fIarg\fR, \fIarg\fR, \fI...\fR)
@@ -87,10 +90,15 @@
 the Tcl library, \fBTcl_Panic\fR is a public function and may be called
 by any extension or application that wishes to abort the process and
 have a panic message displayed the same way that panic messages from Tcl
 will be displayed.
 .PP
-This function can not be used in stub-enabled extensions.
+\fBTcl_PanicVA\fR is the same as \fBTcl_Panic\fR except that instead of
+taking a variable number of arguments it takes an argument list. This
+function is deprecated and will be removed in Tcl 9.0.
+.PP
+This function can not be used in stub-enabled extensions. Its symbol
+entry in the stub table is deprecated and it will be removed in Tcl 9.0.
 .SH "SEE ALSO"
 abort(3), printf(3), exec(n), format(n)
 .SH KEYWORDS
 abort, fatal, error

Index: doc/ParseArgs.3
==================================================================
--- doc/ParseArgs.3
+++ doc/ParseArgs.3
@@ -29,11 +29,11 @@
 The array of arguments to be parsed.
 .AP Tcl_Obj ***remObjv out
 Pointer to a variable that will hold the array of unprocessed arguments.
 Should be NULL if no return of unprocessed arguments is required. If
 \fIobjcPtr\fR is updated to a non-zero value, the array returned through this
-must be deallocated using \fBTcl_Free\fR.
+must be deallocated using \fBckfree\fR.
 .BE
 .SH DESCRIPTION
 .PP
 The \fBTcl_ParseArgsObjv\fR function provides a system for parsing argument
 lists of the form
@@ -82,11 +82,11 @@
     int \fItype\fR;
     const char *\fIkeyStr\fR;
     void *\fIsrcPtr\fR;
     void *\fIdstPtr\fR;
     const char *\fIhelpStr\fR;
-    void *\fIclientData\fR;
+    ClientData \fIclientData\fR;
 } \fBTcl_ArgvInfo\fR;
 .CE
 .PP
 The \fIkeyStr\fR field contains the name of the option; by convention, this
 will normally begin with a
@@ -125,11 +125,11 @@
 have the following signature:
 .RS
 .PP
 .CS
 typedef int (\fBTcl_ArgvFuncProc\fR)(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Obj *\fIobjPtr\fR,
         void *\fIdstPtr\fR);
 .CE
 .PP
 The result is a boolean value indicating whether to consume the following
@@ -147,11 +147,11 @@
 function will have the following signature:
 .RS
 .PP
 .CS
 typedef int (\fBTcl_ArgvGenFuncProc\fR)(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Interp *\fIinterp\fR,
         int \fIobjc\fR,
         Tcl_Obj *const *\fIobjv\fR,
         void *\fIdstPtr\fR);
 .CE

Index: doc/ParseCmd.3
==================================================================
--- doc/ParseCmd.3
+++ doc/ParseCmd.3
@@ -6,11 +6,11 @@
 '\"
 .TH Tcl_ParseCommand 3 8.3 Tcl "Tcl Library Procedures"
 .so man.macros
 .BS
 .SH NAME
-Tcl_ParseCommand, Tcl_ParseExpr, Tcl_ParseBraces, Tcl_ParseQuotedString, Tcl_ParseVarName, Tcl_ParseVar, Tcl_FreeParse, Tcl_EvalTokensStandard \- parse Tcl scripts and expressions
+Tcl_ParseCommand, Tcl_ParseExpr, Tcl_ParseBraces, Tcl_ParseQuotedString, Tcl_ParseVarName, Tcl_ParseVar, Tcl_FreeParse, Tcl_EvalTokens, Tcl_EvalTokensStandard \- parse Tcl scripts and expressions
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
 int
@@ -31,20 +31,24 @@
 const char *
 \fBTcl_ParseVar\fR(\fIinterp, start, termPtr\fR)
 .sp
 \fBTcl_FreeParse\fR(\fIusedParsePtr\fR)
 .sp
+Tcl_Obj *
+\fBTcl_EvalTokens\fR(\fIinterp, tokenPtr, numTokens\fR)
+.sp
 int
 \fBTcl_EvalTokensStandard\fR(\fIinterp, tokenPtr, numTokens\fR)
 .SH ARGUMENTS
 .AS Tcl_Interp *usedParsePtr out
 .AP Tcl_Interp *interp out
-For procedures other than \fBTcl_FreeParse\fR and
-\fBTcl_EvalTokensStandard\fR, used only for error reporting;
+For procedures other than \fBTcl_FreeParse\fR, \fBTcl_EvalTokens\fR
+and \fBTcl_EvalTokensStandard\fR, used only for error reporting;
 if NULL, then no error messages are left after errors.
-For \fBTcl_EvalTokensStandard\fR, determines the context for evaluating
-the script and also is used for error reporting; must not be NULL.
+For \fBTcl_EvalTokens\fR and \fBTcl_EvalTokensStandard\fR,
+determines the context for evaluating the
+script and also is used for error reporting; must not be NULL.
 .AP "const char" *start in
 Pointer to first character in string to parse.
 .AP int numBytes in
 Number of bytes in string to parse, not including any terminating null
 character.  If less than 0 then the script consists of all characters
@@ -185,10 +189,20 @@
 code with one of the values \fBTCL_OK\fR, \fBTCL_ERROR\fR,
 \fBTCL_RETURN\fR, \fBTCL_BREAK\fR, or \fBTCL_CONTINUE\fR, or possibly
 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.
+.PP
+\fBTcl_EvalTokens\fR differs from \fBTcl_EvalTokensStandard\fR only in
+the return convention used: it returns the result in a new Tcl_Obj.
+The reference count of the value returned as result has been
+incremented, so the caller must
+invoke \fBTcl_DecrRefCount\fR when it is finished with the value.
+If an error or other exception occurs while evaluating the tokens
+(such as a reference to a non-existent variable) then the return value
+is NULL and an error message is left in \fIinterp\fR's result. The use
+of \fBTcl_EvalTokens\fR is deprecated.
 .SH "TCL_PARSE STRUCTURE"
 .PP
 \fBTcl_ParseCommand\fR, \fBTcl_ParseExpr\fR, \fBTcl_ParseBraces\fR,
 \fBTcl_ParseQuotedString\fR, and \fBTcl_ParseVarName\fR
 return parse information in two data structures, Tcl_Parse and Tcl_Token:
@@ -206,12 +220,12 @@
 } \fBTcl_Parse\fR;
 
 typedef struct Tcl_Token {
     int \fItype\fR;
     const char *\fIstart\fR;
-    size_t \fIsize\fR;
-    size_t \fInumComponents\fR;
+    int \fIsize\fR;
+    int \fInumComponents\fR;
 } \fBTcl_Token\fR;
 .CE
 .PP
 The first five fields of a Tcl_Parse structure
 are filled in only by \fBTcl_ParseCommand\fR.

Index: doc/Preserve.3
==================================================================
--- doc/Preserve.3
+++ doc/Preserve.3
@@ -19,11 +19,11 @@
 \fBTcl_Release\fR(\fIclientData\fR)
 .sp
 \fBTcl_EventuallyFree\fR(\fIclientData, freeProc\fR)
 .SH ARGUMENTS
 .AS Tcl_FreeProc clientData
-.AP void *clientData in
+.AP ClientData clientData in
 Token describing structure to be freed or reallocated.  Usually a pointer
 to memory for structure.
 .AP Tcl_FreeProc *freeProc in
 Procedure to invoke to free \fIclientData\fR.
 .BE
@@ -89,11 +89,11 @@
 \fIclientData\fR argument to \fBTcl_EventuallyFree\fR for historical
 reasons, but the value is the same.
 .PP
 When the \fIclientData\fR argument to \fBTcl_EventuallyFree\fR
 refers to storage allocated and returned by a prior call to
-\fBTcl_Alloc\fR or another function of the Tcl library,
+\fBTcl_Alloc\fR, \fBckalloc\fR, or another function of the Tcl library,
 then the \fIfreeProc\fR argument should be given the special value of
 \fBTCL_DYNAMIC\fR.
 .PP
 This mechanism can be used to solve the problem described above
 by placing \fBTcl_Preserve\fR and \fBTcl_Release\fR calls around

Index: doc/PrintDbl.3
==================================================================
--- doc/PrintDbl.3
+++ doc/PrintDbl.3
@@ -16,11 +16,14 @@
 .sp
 \fBTcl_PrintDouble\fR(\fIinterp, value, dst\fR)
 .SH ARGUMENTS
 .AS Tcl_Interp *interp out
 .AP Tcl_Interp *interp in
-This argument is ignored.
+Before Tcl 8.0, the \fBtcl_precision\fR variable in this interpreter
+controlled the conversion.  As of Tcl 8.0, this argument is ignored and
+the conversion is controlled by the \fBtcl_precision\fR variable
+that is now shared by all interpreters.
 .AP double value in
 Floating-point value to be converted.
 .AP char *dst out
 Where to store the string representing \fIvalue\fR.  Must have at
 least \fBTCL_DOUBLE_SPACE\fR characters of storage.
@@ -36,11 +39,13 @@
 .QW e
 so that it does not look like an integer.  Where \fB%g\fR would
 generate an integer with no decimal point, \fBTcl_PrintDouble\fR adds
 .QW .0 .
 .PP
-The result will have the fewest digits needed to
+If the \fBtcl_precision\fR value is non-zero, the result will have
+precisely that many digits of significance.  If the value is zero
+(the default), the result will have the fewest digits needed to
 represent the number in such a way that \fBTcl_NewDoubleObj\fR
 will generate the same number when presented with the given string.
 IEEE semantics of rounding to even apply to the conversion.
 .SH KEYWORDS
 conversion, double-precision, floating-point, string

Index: doc/RecEvalObj.3
==================================================================
--- doc/RecEvalObj.3
+++ doc/RecEvalObj.3
@@ -29,11 +29,11 @@
 .BE
 
 .SH DESCRIPTION
 .PP
 \fBTcl_RecordAndEvalObj\fR is invoked to record a command as an event
-on the history list and then execute it using \fBTcl_EvalObjEx\fR.
+on the history list and then execute it using \fBTcl_EvalObjEx\fR
 It returns a completion code such as \fBTCL_OK\fR just like \fBTcl_EvalObjEx\fR,
 as well as a result value containing additional information
 (a result value or error message)
 that can be retrieved using \fBTcl_GetObjResult\fR.
 If you do not want the command recorded on the history list then

Index: doc/RegExp.3
==================================================================
--- doc/RegExp.3
+++ doc/RegExp.3
@@ -62,11 +62,11 @@
 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
 .QW \fB^\fR
 matches will be allowed.
-.AP size_t index in
+.AP int index in
 Specifies which range is desired:  0 means the range of the entire
 match, 1 or greater means the range that matched a parenthesized
 sub-expression.
 .AP "const char" **startPtr out
 The address of the first character in the range is stored here, or
@@ -78,18 +78,18 @@
 OR-ed combination of the compilation flags \fBTCL_REG_ADVANCED\fR,
 \fBTCL_REG_EXTENDED\fR, \fBTCL_REG_BASIC\fR, \fBTCL_REG_EXPANDED\fR,
 \fBTCL_REG_QUOTE\fR, \fBTCL_REG_NOCASE\fR, \fBTCL_REG_NEWLINE\fR,
 \fBTCL_REG_NLSTOP\fR, \fBTCL_REG_NLANCH\fR, \fBTCL_REG_NOSUB\fR, and
 \fBTCL_REG_CANMATCH\fR. See below for more information.
-.AP size_t offset in
+.AP int offset in
 The character offset into the text where matching should begin.
 The value of the offset has no impact on \fB^\fR matches.  This
 behavior is controlled by \fIeflags\fR.
-.AP size_t nmatches in
+.AP int nmatches in
 The number of matching subexpressions that should be remembered for
 later use.  If this value is 0, then no subexpression match
-information will be computed.  If the value is TCL_INDEX_NONE, then
+information will be computed.  If the value is \-1, then
 all of the matching subexpressions will be remembered.  Any other
 value will be taken as the maximum number of subexpressions to
 remember.
 .AP int eflags in
 OR-ed combination of the execution flags \fBTCL_REG_NOTBOL\fR and
@@ -335,13 +335,13 @@
 \fIinfoPtr\fR argument contains a pointer to a structure that is
 defined as follows:
 .PP
 .CS
 typedef struct Tcl_RegExpInfo {
-    size_t \fInsubs\fR;
+    int \fInsubs\fR;
     Tcl_RegExpIndices *\fImatches\fR;
-    size_t \fIextendStart\fR;
+    long \fIextendStart\fR;
 } \fBTcl_RegExpInfo\fR;
 .CE
 .PP
 The \fInsubs\fR field contains a count of the number of parenthesized
 subexpressions within the regular expression.  If the \fBTCL_REG_NOSUB\fR
@@ -353,12 +353,12 @@
 appear in the pattern.  Each element is a structure that is defined as
 follows:
 .PP
 .CS
 typedef struct Tcl_RegExpIndices {
-    size_t \fIstart\fR;
-    size_t \fIend\fR;
+    long \fIstart\fR;
+    long \fIend\fR;
 } \fBTcl_RegExpIndices\fR;
 .CE
 .PP
 The \fIstart\fR and \fIend\fR values are Unicode character indices
 relative to the offset location within \fIobjPtr\fR where matching began.

Index: doc/SetRecLmt.3
==================================================================
--- doc/SetRecLmt.3
+++ doc/SetRecLmt.3
@@ -27,11 +27,11 @@
 
 .SH DESCRIPTION
 .PP
 At any given time Tcl enforces a limit on the number of recursive
 calls that may be active for \fBTcl_Eval\fR and related procedures
-such as \fBTcl_EvalEx\fR.
+such as \fBTcl_GlobalEval\fR.
 Any call to \fBTcl_Eval\fR that exceeds this depth is aborted with
 an error.
 By default the recursion limit is 1000.
 .PP
 \fBTcl_SetRecursionLimit\fR may be used to change the maximum

Index: doc/SetResult.3
==================================================================
--- doc/SetResult.3
+++ doc/SetResult.3
@@ -7,11 +7,11 @@
 '\"
 .TH Tcl_SetResult 3 8.0 Tcl "Tcl Library Procedures"
 .so man.macros
 .BS
 .SH NAME
-Tcl_SetObjResult, Tcl_GetObjResult, Tcl_SetResult, Tcl_GetStringResult, Tcl_AppendResult, Tcl_AppendElement, Tcl_ResetResult, Tcl_TransferResult, Tcl_FreeResult \- manipulate Tcl result
+Tcl_SetObjResult, Tcl_GetObjResult, Tcl_SetResult, Tcl_GetStringResult, Tcl_AppendResult, Tcl_AppendResultVA, Tcl_AppendElement, Tcl_ResetResult, Tcl_TransferResult, Tcl_FreeResult \- manipulate Tcl result
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
 \fBTcl_SetObjResult\fR(\fIinterp, objPtr\fR)
@@ -23,10 +23,12 @@
 .sp
 const char *
 \fBTcl_GetStringResult\fR(\fIinterp\fR)
 .sp
 \fBTcl_AppendResult\fR(\fIinterp, result, result, ... , \fB(char *) NULL\fR)
+.sp
+\fBTcl_AppendResultVA\fR(\fIinterp, argList\fR)
 .sp
 \fBTcl_ResetResult\fR(\fIinterp\fR)
 .sp
 .VS 8.6
 \fBTcl_TransferResult\fR(\fIsourceInterp, result, targetInterp\fR)
@@ -148,10 +150,13 @@
 \fIinterp\fR so as to handle backward-compatibility with old-style
 extensions.
 Any number of \fIresult\fR arguments may be passed in a single
 call; the last argument in the list must be a NULL pointer.
 .PP
+\fBTcl_AppendResultVA\fR is the same as \fBTcl_AppendResult\fR except that
+instead of taking a variable number of arguments it takes an argument list.
+.PP
 .VS 8.6
 \fBTcl_TransferResult\fR moves a result from one interpreter to another,
 optionally (dependent on the \fIresult\fR parameter) including the error
 information dictionary as well. The interpreters must be in the same thread.
 The source interpreter will have its result reset by this operation.
@@ -190,10 +195,23 @@
 It frees up the memory associated with \fIinterp\fR's result.
 It also sets \fIinterp->freeProc\fR to zero, but does not
 change \fIinterp->result\fR or clear error state.
 \fBTcl_FreeResult\fR is most commonly used when a procedure
 is about to replace one result value with another.
+.SS "DIRECT ACCESS TO INTERP->RESULT"
+.PP
+It used to be legal for programs to
+directly read and write \fIinterp->result\fR
+to manipulate the interpreter result.  The Tcl headers no longer
+permit this access by default, and C code still doing this must
+be updated to use supported routines \fBTcl_GetObjResult\fR,
+\fBTcl_GetStringResult\fR, \fBTcl_SetObjResult\fR, and \fBTcl_SetResult\fR.
+As a migration aid, access can be restored with the compiler directive
+.CS
+#define USE_INTERP_RESULT
+.CE
+but this is meant only to offer life support to otherwise dead code.
 .SH "THE TCL_FREEPROC ARGUMENT TO TCL_SETRESULT"
 .PP
 \fBTcl_SetResult\fR's \fIfreeProc\fR argument specifies how
 the Tcl system is to manage the storage for the \fIresult\fR argument.
 If \fBTcl_SetResult\fR or \fBTcl_SetObjResult\fR are called

Index: doc/SplitList.3
==================================================================
--- doc/SplitList.3
+++ doc/SplitList.3
@@ -18,20 +18,20 @@
 \fBTcl_SplitList\fR(\fIinterp, list, argcPtr, argvPtr\fR)
 .sp
 char *
 \fBTcl_Merge\fR(\fIargc, argv\fR)
 .sp
-size_t
+int
 \fBTcl_ScanElement\fR(\fIsrc, flagsPtr\fR)
 .sp
-size_t
+int
 \fBTcl_ScanCountedElement\fR(\fIsrc, length, flagsPtr\fR)
 .sp
-size_t
+int
 \fBTcl_ConvertElement\fR(\fIsrc, dst, flags\fR)
 .sp
-size_t
+int
 \fBTcl_ConvertCountedElement\fR(\fIsrc, length, dst, flags\fR)
 .SH ARGUMENTS
 .AS "const char *const" ***argvPtr out
 .AP Tcl_Interp *interp out
 Interpreter to use for error reporting.  If NULL, then no error message
@@ -53,11 +53,11 @@
 .AP "const char" *src in
 String that is to become an element of a list.
 .AP int *flagsPtr in
 Pointer to word to fill in with information about \fIsrc\fR.
 The value of *\fIflagsPtr\fR must be passed to \fBTcl_ConvertElement\fR.
-.AP size_t length in
+.AP int length in
 Number of bytes in string \fIsrc\fR.
 .AP char *dst in
 Place to copy converted list element.  Must contain enough characters
 to hold converted string.
 .AP int flags in

Index: doc/StaticPkg.3
==================================================================
--- doc/StaticPkg.3
+++ doc/StaticPkg.3
@@ -63,10 +63,11 @@
 the event of an error it should set the interpreter's result to point to an
 error message.  The result or error from the initialization procedure will
 be returned as the result of the \fBload\fR command that caused the
 initialization procedure to be invoked.
 .PP
-This function can not be used in stub-enabled extensions.
+This function can not be used in stub-enabled extensions. Its symbol
+entry in the stub table is deprecated and it will be removed in Tcl 9.0.
 .SH KEYWORDS
 initialization procedure, package, static linking
 .SH "SEE ALSO"
 load(n), package(n), Tcl_PkgRequire(3)

Index: doc/StringObj.3
==================================================================
--- doc/StringObj.3
+++ doc/StringObj.3
@@ -6,11 +6,11 @@
 '\"
 .TH Tcl_StringObj 3 8.1 Tcl "Tcl Library Procedures"
 .so man.macros
 .BS
 .SH NAME
-Tcl_NewStringObj, Tcl_NewUnicodeObj, Tcl_SetStringObj, Tcl_SetUnicodeObj, Tcl_GetStringFromObj, Tcl_GetString, Tcl_GetUnicodeFromObj, Tcl_GetUnicode, Tcl_GetUniChar, Tcl_GetCharLength, Tcl_GetRange, Tcl_AppendToObj, Tcl_AppendUnicodeToObj, Tcl_AppendObjToObj, Tcl_AppendStringsToObj, Tcl_AppendLimitedToObj, Tcl_Format, Tcl_AppendFormatToObj, Tcl_ObjPrintf, Tcl_AppendPrintfToObj, Tcl_SetObjLength, Tcl_AttemptSetObjLength, Tcl_ConcatObj \- manipulate Tcl values as strings
+Tcl_NewStringObj, Tcl_NewUnicodeObj, Tcl_SetStringObj, Tcl_SetUnicodeObj, Tcl_GetStringFromObj, Tcl_GetString, Tcl_GetUnicodeFromObj, Tcl_GetUnicode, Tcl_GetUniChar, Tcl_GetCharLength, Tcl_GetRange, Tcl_AppendToObj, Tcl_AppendUnicodeToObj, Tcl_AppendObjToObj, Tcl_AppendStringsToObj, Tcl_AppendStringsToObjVA, Tcl_AppendLimitedToObj, Tcl_Format, Tcl_AppendFormatToObj, Tcl_ObjPrintf, Tcl_AppendPrintfToObj, Tcl_SetObjLength, Tcl_AttemptSetObjLength, Tcl_ConcatObj \- manipulate Tcl values as strings
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
 Tcl_Obj *
@@ -56,10 +56,13 @@
 \fBTcl_AppendObjToObj\fR(\fIobjPtr, appendObjPtr\fR)
 .sp
 void
 \fBTcl_AppendStringsToObj\fR(\fIobjPtr, string, string, ... \fB(char *) NULL\fR)
 .sp
+void
+\fBTcl_AppendStringsToObjVA\fR(\fIobjPtr, argList\fR)
+.sp
 void
 \fBTcl_AppendLimitedToObj\fR(\fIobjPtr, bytes, length, limit, ellipsis\fR)
 .sp
 Tcl_Obj *
 \fBTcl_Format\fR(\fIinterp, format, objc, objv\fR)
@@ -85,33 +88,33 @@
 .AS "const Tcl_UniChar" *appendObjPtr in/out
 .AP "const char" *bytes in
 Points to the first byte of an array of UTF-8-encoded bytes
 used to set or append to a string value.
 This byte array may contain embedded null characters
-unless \fInumChars\fR is TCL_AUTO_LENGTH.  (Applications needing null bytes
-should represent them as the two-byte sequence \fI\e700\e600\fR, use
+unless \fInumChars\fR is negative.  (Applications needing null bytes
+should represent them as the two-byte sequence \fI\e300\e200\fR, use
 \fBTcl_ExternalToUtf\fR to convert, or \fBTcl_NewByteArrayObj\fR if
 the string is a collection of uninterpreted bytes.)
-.AP size_t length in
+.AP int length in
 The number of bytes to copy from \fIbytes\fR when
 initializing, setting, or appending to a string value.
-If TCL_AUTO_LENGTH, all bytes up to the first null are used.
+If negative, all bytes up to the first null are used.
 .AP "const Tcl_UniChar" *unicode in
 Points to the first byte of an array of Unicode characters
 used to set or append to a string value.
 This byte array may contain embedded null characters
 unless \fInumChars\fR is negative.
-.AP size_t numChars in
+.AP int numChars in
 The number of Unicode characters to copy from \fIunicode\fR when
 initializing, setting, or appending to a string value.
-If TCL_AUTO_LENGTH, all characters up to the first null character are used.
-.AP size_t index in
+If negative, all characters up to the first null character are used.
+.AP int index in
 The index of the Unicode character to return.
-.AP size_t first in
+.AP int first in
 The index of the first Unicode character in the Unicode range to be
 returned as a new value.
-.AP size_t last in
+.AP int last in
 The index of the last Unicode character in the Unicode range to be
 returned as a new value.
 .AP Tcl_Obj *objPtr in/out
 Points to a value to manipulate.
 .AP Tcl_Obj *appendObjPtr in
@@ -122,11 +125,11 @@
 .AP "const char" *string in
 Null-terminated string value to append to \fIobjPtr\fR.
 .AP va_list argList in
 An argument list which must have been initialized using
 \fBva_start\fR, and cleared using \fBva_end\fR.
-.AP size_t limit in
+.AP int limit in
 Maximum number of bytes to be appended.
 .AP "const char" *ellipsis in
 Suffix to append when the limit leads to string truncation.
 If NULL is passed then the suffix
 .QW "..."
@@ -135,11 +138,11 @@
 Format control string including % conversion specifiers.
 .AP int objc in
 The number of elements to format or concatenate.
 .AP Tcl_Obj *objv[] in
 The array of values to format or concatenate.
-.AP size_t newLength in
+.AP int newLength in
 New length for the string value of \fIobjPtr\fR, not including the
 final null character.
 .BE
 .SH DESCRIPTION
 .PP
@@ -241,10 +244,14 @@
 except that it can be passed more than one value to append and
 each value must be a null-terminated string (i.e. none of the
 values may contain internal null characters).  Any number of
 \fIstring\fR arguments may be provided, but the last argument
 must be a NULL pointer to indicate the end of the list.
+.PP
+\fBTcl_AppendStringsToObjVA\fR is the same as \fBTcl_AppendStringsToObj\fR
+except that instead of taking a variable number of arguments it takes an
+argument list.
 .PP
 \fBTcl_AppendLimitedToObj\fR is similar to \fBTcl_AppendToObj\fR
 except that it imposes a limit on how many bytes are appended.
 This can be handy when the string to be appended might be
 very large, but the value being constructed should not be allowed to grow

Index: doc/TCL_MEM_DEBUG.3
==================================================================
--- doc/TCL_MEM_DEBUG.3
+++ doc/TCL_MEM_DEBUG.3
@@ -32,30 +32,30 @@
 functions \fBTcl_ValidateAllMemory\fR, and \fBTcl_DumpActiveMemory\fR,
 and the Tcl \fBmemory\fR command can be used to validate and examine
 memory usage.
 .SH "GUARD ZONES"
 .PP
-When memory debugging is enabled, whenever a call to \fBTcl_Alloc\fR is
+When memory debugging is enabled, whenever a call to \fBckalloc\fR is
 made, slightly more memory than requested is allocated so the memory
 debugging code can keep track of the allocated memory, and eight-byte
 .QW "guard zones"
 are placed in front of and behind the space that will be
 returned to the caller.  (The sizes of the guard zones are defined by the
 C #define \fBLOW_GUARD_SIZE\fR and #define \fBHIGH_GUARD_SIZE\fR
 in the file \fIgeneric/tclCkalloc.c\fR \(em it can
 be extended if you suspect large overwrite problems, at some cost in
 performance.)  A known pattern is written into the guard zones and, on
-a call to \fBTcl_Free\fR, the guard zones of the space being freed are
+a call to \fBckfree\fR, the guard zones of the space being freed are
 checked to see if either zone has been modified in any way.  If one
 has been, the guard bytes and their new contents are identified, and a
 .QW "low guard failed"
 or
 .QW "high guard failed"
 message is issued.  The
 .QW "guard failed"
 message includes the address of the memory packet and
-the file name and line number of the code that called \fBTcl_Free\fR.
+the file name and line number of the code that called \fBckfree\fR.
 This allows you to detect the common sorts of one-off problems, where
 not enough space was allocated to contain the data written, for
 example.
 .SH "DEBUGGING DIFFICULT MEMORY CORRUPTION PROBLEMS"
 .PP
@@ -64,17 +64,17 @@
 the memory command can help isolate difficult problems.  If you
 suspect (or know) that corruption is occurring before the Tcl
 interpreter comes up far enough for you to issue commands, you can set
 \fBMEM_VALIDATE\fR define, recompile tclCkalloc.c and rebuild Tcl.
 This will enable memory validation from the first call to
-\fBTcl_Alloc\fR, again, at a large performance impact.
+\fBckalloc\fR, again, at a large performance impact.
 .PP
 If you are desperate and validating memory on every call to
-\fBTcl_Alloc\fR and \fBTcl_Free\fR is not enough, you can explicitly call
+\fBckalloc\fR and \fBckfree\fR is not enough, you can explicitly call
 \fBTcl_ValidateAllMemory\fR directly at any point.  It takes a \fIchar
 *\fR and an \fIint\fR which are normally the filename and line number
 of the caller, but they can actually be anything you want.  Remember
 to remove the calls after you find the problem.
 .SH "SEE ALSO"
-Tcl_Alloc, memory, Tcl_ValidateAllMemory, Tcl_DumpActiveMemory
+ckalloc, memory, Tcl_ValidateAllMemory, Tcl_DumpActiveMemory
 .SH KEYWORDS
 memory, debug

Index: doc/TclZlib.3
==================================================================
--- doc/TclZlib.3
+++ doc/TclZlib.3
@@ -86,11 +86,11 @@
 .AP "unsigned int" initValue in
 The initial value for the checksum algorithm.
 .AP "unsigned char" *bytes in
 An array of bytes to run the checksum algorithm over, or NULL to get the
 recommended initial value for the checksum algorithm.
-.AP size_t length in
+.AP int length in
 The number of bytes in the array.
 .AP int mode in
 What mode to operate the stream in. Should be either
 \fBTCL_ZLIB_STREAM_DEFLATE\fR for a compressing stream or
 \fBTCL_ZLIB_STREAM_INFLATE\fR for a decompressing stream.
@@ -105,13 +105,13 @@
 if the currently compressed data must be made available for access using
 \fBTcl_ZlibStreamGet\fR, \fBTCL_ZLIB_FULLFLUSH\fR if the stream must be put
 into a state where the decompressor can recover from on corruption, or
 \fBTCL_ZLIB_FINALIZE\fR to ensure that the stream is finished and that any
 trailer demanded by the format is written.
-.AP size_t count in
-The maximum number of bytes to get from the stream, or TCL_AUTO_LENGTH to get
-all remaining bytes from the stream's buffers.
+.AP int count in
+The maximum number of bytes to get from the stream, or -1 to get all remaining
+bytes from the stream's buffers.
 .AP Tcl_Obj *compDict in
 A byte array value that is the compression dictionary to use with the stream.
 Note that this is \fInot a Tcl dictionary\fR, and it is recommended that this
 only ever be used with streams that were created with their \fIformat\fR set
 to \fBTCL_ZLIB_FORMAT_ZLIB\fR because the other formats have no mechanism to

Index: doc/Thread.3
==================================================================
--- doc/Thread.3
+++ doc/Thread.3
@@ -65,11 +65,11 @@
 .AP Tcl_ThreadId id in
 Id of the thread waited upon.
 .AP Tcl_ThreadCreateProc *proc in
 This procedure will act as the \fBmain()\fR of the newly created
 thread. The specified \fIclientData\fR will be its sole argument.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary information. Passed as sole argument to the \fIproc\fR.
 .AP int stackSize in
 The size of the stack given to the new thread.
 .AP int flags in
 Bitmask containing flags allowing the caller to modify behavior of
@@ -206,11 +206,11 @@
 value and then finishes.
 .PP
 .CS
 static \fBTcl_ThreadCreateType\fR
 MyThreadImplFunc(
-    void *clientData)
+    ClientData clientData)
 {
     int i, limit = (int) clientData;
     for (i=0 ; i<limit ; i++) {
         /* doing nothing at all here */
     }
@@ -221,11 +221,11 @@
 To create the above thread, make it execute, and wait for it to finish, we
 would do this:
 .PP
 .CS
 int limit = 1000000000;
-void *limitData = (void*)((intptr_t) limit);
+ClientData limitData = (void*)((intptr_t) limit);
 Tcl_ThreadId id;    \fI/* holds identity of thread created */\fR
 int result;
 
 if (\fBTcl_CreateThread\fR(&id, MyThreadImplFunc, limitData,
         \fBTCL_THREAD_STACK_DEFAULT\fR,

Index: doc/TraceCmd.3
==================================================================
--- doc/TraceCmd.3
+++ doc/TraceCmd.3
@@ -11,11 +11,11 @@
 Tcl_CommandTraceInfo, Tcl_TraceCommand, Tcl_UntraceCommand \- monitor renames and deletes of a command
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
 .sp
-void *
+ClientData
 \fBTcl_CommandTraceInfo(\fIinterp, cmdName, flags, proc, prevClientData\fB)\fR
 .sp
 int
 \fBTcl_TraceCommand(\fIinterp, cmdName, flags, proc, clientData\fB)\fR
 .sp
@@ -30,13 +30,13 @@
 .AP int flags in
 OR'ed collection of the values \fBTCL_TRACE_RENAME\fR and
 \fBTCL_TRACE_DELETE\fR.
 .AP Tcl_CommandTraceProc *proc in
 Procedure to call when specified operations occur to \fIcmdName\fR.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary argument to pass to \fIproc\fR.
-.AP void *prevClientData in
+.AP ClientData prevClientData in
 If non-NULL, gives last value returned by \fBTcl_CommandTraceInfo\fR,
 so this call will return information about next trace.  If NULL, this
 call will return information about first trace.
 .BE
 .SH DESCRIPTION
@@ -63,20 +63,20 @@
 \fIproc\fR will be invoked.  It should have arguments and result that
 match the type \fBTcl_CommandTraceProc\fR:
 .PP
 .CS
 typedef void \fBTcl_CommandTraceProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Interp *\fIinterp\fR,
         const char *\fIoldName\fR,
         const char *\fInewName\fR,
         int \fIflags\fR);
 .CE
 .PP
 The \fIclientData\fR and \fIinterp\fR parameters will have the same
 values as those passed to \fBTcl_TraceCommand\fR when the trace was
-created.  \fIclientData\fR typically points to an application-specific
+created.  \fIClientData\fR typically points to an application-specific
 data structure that describes what to do when \fIproc\fR is invoked.
 \fIOldName\fR gives the name of the command being renamed, and
 \fInewName\fR gives the name that the command is being renamed to (or
 NULL when the command is being deleted.)
 \fIFlags\fR is an OR'ed combination of bits potentially providing

Index: doc/TraceVar.3
==================================================================
--- doc/TraceVar.3
+++ doc/TraceVar.3
@@ -22,17 +22,17 @@
 .sp
 \fBTcl_UntraceVar(\fIinterp, varName, flags, proc, clientData\fB)\fR
 .sp
 \fBTcl_UntraceVar2(\fIinterp, name1, name2, flags, proc, clientData\fB)\fR
 .sp
-void *
+ClientData
 \fBTcl_VarTraceInfo(\fIinterp, varName, flags, proc, prevClientData\fB)\fR
 .sp
-void *
+ClientData
 \fBTcl_VarTraceInfo2(\fIinterp, name1, name2, flags, proc, prevClientData\fB)\fR
 .SH ARGUMENTS
-.AS void *prevClientData
+.AS Tcl_VarTraceProc prevClientData
 .AP Tcl_Interp *interp in
 Interpreter containing variable.
 .AP "const char" *varName in
 Name of variable.  May refer to a scalar variable, to
 an array variable with no index, or to an array variable
@@ -44,19 +44,19 @@
 \fBTCL_TRACE_RESULT_DYNAMIC\fR and \fBTCL_TRACE_RESULT_OBJECT\fR.
 Not all flags are used by all
 procedures.  See below for more information.
 .AP Tcl_VarTraceProc *proc in
 Procedure to invoke whenever one of the traced operations occurs.
-.AP void *clientData in
+.AP ClientData clientData in
 Arbitrary one-word value to pass to \fIproc\fR.
 .AP "const char" *name1 in
 Name of scalar or array variable (without array index).
 .AP "const char" *name2 in
 For a trace on an element of an array, gives the index of the
 element.  For traces on scalar variables or on whole arrays,
 is NULL.
-.AP void *prevClientData in
+.AP ClientData prevClientData in
 If non-NULL, gives last value returned by \fBTcl_VarTraceInfo\fR or
 \fBTcl_VarTraceInfo2\fR, so this call will return information about
 next trace.  If NULL, this call will return information about first
 trace.
 .BE
@@ -105,11 +105,11 @@
 before an array set, but that will trigger write traces.
 .TP
 \fBTCL_TRACE_RESULT_DYNAMIC\fR
 The result of invoking the \fIproc\fR is a dynamically allocated
 string that will be released by the Tcl library via a call to
-\fBTcl_Free\fR.  Must not be specified at the same time as
+\fBckfree\fR.  Must not be specified at the same time as
 \fBTCL_TRACE_RESULT_OBJECT\fR.
 .TP
 \fBTCL_TRACE_RESULT_OBJECT\fR
 The result of invoking the \fIproc\fR is a Tcl_Obj* (cast to a char*)
 with a reference count of at least one.  The ownership of that
@@ -122,21 +122,21 @@
 It should have arguments and result that match the type
 \fBTcl_VarTraceProc\fR:
 .PP
 .CS
 typedef char *\fBTcl_VarTraceProc\fR(
-        void *\fIclientData\fR,
+        ClientData \fIclientData\fR,
         Tcl_Interp *\fIinterp\fR,
         char *\fIname1\fR,
         char *\fIname2\fR,
         int \fIflags\fR);
 .CE
 .PP
 The \fIclientData\fR and \fIinterp\fR parameters will
 have the same values as those passed to \fBTcl_TraceVar\fR when the
 trace was created.
-\fIclientData\fR typically points to an application-specific
+\fIClientData\fR typically points to an application-specific
 data structure that describes what to do when \fIproc\fR
 is invoked.
 \fIName1\fR and \fIname2\fR give the name of the traced variable
 in the normal two-part form (see the description of \fBTcl_TraceVar2\fR
 below for details).
@@ -310,11 +310,11 @@
 error occurred.
 The return value must be a pointer to a static character string
 containing an error message,
 unless (\fIexactly\fR one of) the \fBTCL_TRACE_RESULT_DYNAMIC\fR and
 \fBTCL_TRACE_RESULT_OBJECT\fR flags is set, which specify that the result is
-either a dynamic string (to be released with \fBTcl_Free\fR) or a
+either a dynamic string (to be released with \fBckfree\fR) or a
 Tcl_Obj* (cast to char* and to be released with
 \fBTcl_DecrRefCount\fR) containing the error message.
 If a trace procedure returns an error, no further traces are
 invoked for the access and the traced access aborts with the
 given message.

Index: doc/Utf.3
==================================================================
--- doc/Utf.3
+++ doc/Utf.3
@@ -29,23 +29,23 @@
 .sp
 int
 \fBTcl_UniCharLen\fR(\fIuniStr\fR)
 .sp
 int
-\fBTcl_UniCharNcmp\fR(\fIucs, uct, uniLength\fR)
+\fBTcl_UniCharNcmp\fR(\fIucs, uct, numChars\fR)
 .sp
 int
-\fBTcl_UniCharNcasecmp\fR(\fIucs, uct, uniLength\fR)
+\fBTcl_UniCharNcasecmp\fR(\fIucs, uct, numChars\fR)
 .sp
 int
 \fBTcl_UniCharCaseMatch\fR(\fIuniStr, uniPattern, nocase\fR)
 .sp
 int
-\fBTcl_UtfNcmp\fR(\fIcs, ct, length\fR)
+\fBTcl_UtfNcmp\fR(\fIcs, ct, numChars\fR)
 .sp
 int
-\fBTcl_UtfNcasecmp\fR(\fIcs, ct, length\fR)
+\fBTcl_UtfNcasecmp\fR(\fIcs, ct, numChars\fR)
 .sp
 int
 \fBTcl_UtfCharComplete\fR(\fIsrc, length\fR)
 .sp
 int
@@ -67,17 +67,17 @@
 \fBTcl_UniCharAtIndex\fR(\fIsrc, index\fR)
 .sp
 const char *
 \fBTcl_UtfAtIndex\fR(\fIsrc, index\fR)
 .sp
-size_t
+int
 \fBTcl_UtfBackslash\fR(\fIsrc, readPtr, dst\fR)
 .SH ARGUMENTS
 .AS "const Tcl_UniChar" *uniPattern in/out
 .AP char *buf out
 Buffer in which the UTF-8 representation of the Tcl_UniChar is stored.  At most
-\fBTCL_UTF_MAX\fR bytes are stored in the buffer.
+4 bytes are stored in the buffer.
 .AP int ch in
 The Unicode character to be converted or examined.
 .AP Tcl_UniChar *chPtr out
 Filled with the Tcl_UniChar represented by the head of the UTF-8 string.
 .AP "const char" *src in
@@ -92,27 +92,30 @@
 A null-terminated Unicode string.
 .AP "const Tcl_UniChar" *uct in
 A null-terminated Unicode string.
 .AP "const Tcl_UniChar" *uniPattern in
 A null-terminated Unicode string.
-.AP size_t length in
+.AP int length in
 The length of the UTF-8 string in bytes (not UTF-8 characters).  If
-TCL_AUTO_LENGTH, all bytes up to the first null byte are used.
-.AP size_t uniLength in
-The length of the Unicode string in characters.
+negative, all bytes up to the first null byte are used.
+.AP int uniLength in
+The length of the Unicode string in characters.  Must be greater than or
+equal to 0.
 .AP "Tcl_DString" *dsPtr in/out
 A pointer to a previously initialized \fBTcl_DString\fR.
+.AP "unsigned long" numChars in
+The number of characters to compare.
 .AP "const char" *start in
 Pointer to the beginning of a UTF-8 string.
-.AP size_t index in
+.AP int index in
 The index of a character (not byte) in the UTF-8 string.
 .AP int *readPtr out
 If non-NULL, filled with the number of bytes in the backslash sequence,
 including the backslash character.
 .AP char *dst out
 Buffer in which the bytes represented by the backslash sequence are stored.
-At most \fBTCL_UTF_MAX\fR bytes are stored in the buffer.
+At most 4 bytes are stored in the buffer.
 .AP int nocase in
 Specifies whether the match should be done case-sensitive (0) or
 case-insensitive (1).
 .BE
 
@@ -143,12 +146,12 @@
 is known to be null-terminated, this will not happen.  If the input is
 a byte in the range 0x80 - 0x9F, \fBTcl_UtfToUniChar\fR assumes the
 cp1252 encoding, stores the corresponding Tcl_UniChar in \fI*chPtr\fR
 and returns 1. If the input is otherwise
 not in proper UTF-8 format, \fBTcl_UtfToUniChar\fR will store the first
-byte of \fIsrc\fR in \fI*chPtr\fR as a Tcl_UniChar between 0x0000 and
-0x00ff and return 1.
+byte of \fIsrc\fR in \fI*chPtr\fR as a Tcl_UniChar between 0x00A0 and
+0x00FF and return 1.
 .PP
 \fBTcl_UniCharToUtfDString\fR converts the given Unicode string
 to UTF-8, storing the result in a previously initialized \fBTcl_DString\fR.
 You must specify \fIuniLength\fR, the length of the given Unicode string.
 The return value is a pointer to the UTF-8 representation of the
@@ -171,11 +174,11 @@
 the number of Unicode characters (not bytes) in that string.
 .PP
 \fBTcl_UniCharNcmp\fR and \fBTcl_UniCharNcasecmp\fR correspond to
 \fBstrncmp\fR and \fBstrncasecmp\fR, respectively, for Unicode characters.
 They accept two null-terminated Unicode strings and the number of characters
-to compare.  Both strings are assumed to be at least \fIuniLength\fR characters
+to compare.  Both strings are assumed to be at least \fInumChars\fR characters
 long. \fBTcl_UniCharNcmp\fR  compares the two strings character-by-character
 according to the Unicode character ordering.  It returns an integer greater
 than, equal to, or less than 0 if the first string is greater than, equal
 to, or less than the second string respectively.  \fBTcl_UniCharNcasecmp\fR
 is the Unicode case insensitive version.
@@ -185,11 +188,11 @@
 a Unicode pattern, and a boolean value specifying whether the match should
 be case sensitive and returns whether the string matches the pattern.
 .PP
 \fBTcl_UtfNcmp\fR corresponds to \fBstrncmp\fR for UTF-8 strings. It
 accepts two null-terminated UTF-8 strings and the number of characters
-to compare.  (Both strings are assumed to be at least \fIlength\fR
+to compare.  (Both strings are assumed to be at least \fInumChars\fR
 characters long.)  \fBTcl_UtfNcmp\fR compares the two strings
 character-by-character according to the Unicode character ordering.
 It returns an integer greater than, equal to, or less than 0 if the
 first string is greater than, equal to, or less than the second string
 respectively.
@@ -237,22 +240,22 @@
 .PP
 \fBTcl_UniCharAtIndex\fR corresponds to a C string array dereference or the
 Pascal Ord() function.  It returns the Tcl_UniChar represented at the
 specified character (not byte) \fIindex\fR in the UTF-8 string
 \fIsrc\fR.  The source string must contain at least \fIindex\fR
-characters.
+characters.  Behavior is undefined if a negative \fIindex\fR is given.
 .PP
 \fBTcl_UtfAtIndex\fR returns a pointer to the specified character (not
 byte) \fIindex\fR in the UTF-8 string \fIsrc\fR.  The source string must
 contain at least \fIindex\fR characters.  This is equivalent to calling
-\fBTcl_UtfNext\fR \fIindex\fR times.  If \fIindex\fR is TCL_INDEX_NONE,
+\fBTcl_UtfNext\fR \fIindex\fR times.  If a negative \fIindex\fR is given,
 the return pointer points to the first character in the source string.
 .PP
 \fBTcl_UtfBackslash\fR is a utility procedure used by several of the Tcl
 commands.  It parses a backslash sequence and stores the properly formed
 UTF-8 character represented by the backslash sequence in the output
-buffer \fIdst\fR.  At most \fBTCL_UTF_MAX\fR bytes are stored in the buffer.
+buffer \fIdst\fR.  At most 4 bytes are stored in the buffer.
 \fBTcl_UtfBackslash\fR modifies \fI*readPtr\fR to contain the number
 of bytes in the backslash sequence, including the backslash character.
 The return value is the number of bytes stored in the output buffer.
 .PP
 See the \fBTcl\fR manual entry for information on the valid backslash

ADDED   doc/case.n
Index: doc/case.n
==================================================================
--- /dev/null
+++ doc/case.n
@@ -0,0 +1,60 @@
+'\"
+'\" Copyright (c) 1993 The Regents of the University of California.
+'\" Copyright (c) 1994-1996 Sun Microsystems, Inc.
+'\"
+'\" See the file "license.terms" for information on usage and redistribution
+'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+'\"
+.TH case n 7.0 Tcl "Tcl Built-In Commands"
+.so man.macros
+.BS
+'\" Note:  do not modify the .SH NAME line immediately below!
+.SH NAME
+case \- Evaluate one of several scripts, depending on a given value
+.SH SYNOPSIS
+\fBcase\fI string \fR?\fBin\fR? \fIpatList body \fR?\fIpatList body \fR...?
+.sp
+\fBcase\fI string \fR?\fBin\fR? {\fIpatList body \fR?\fIpatList body \fR...?}
+.BE
+
+.SH DESCRIPTION
+.PP
+\fINote: the \fBcase\fI command is obsolete and is supported only
+for backward compatibility.  At some point in the future it may be
+removed entirely.  You should use the \fBswitch\fI command instead.\fR
+.PP
+The \fBcase\fR command matches \fIstring\fR against each of
+the \fIpatList\fR arguments in order.
+Each \fIpatList\fR argument is a list of one or
+more patterns.  If any of these patterns matches \fIstring\fR then
+\fBcase\fR evaluates the following \fIbody\fR argument
+by passing it recursively to the Tcl interpreter and returns the result
+of that evaluation.
+Each \fIpatList\fR argument consists of a single
+pattern or list of patterns.  Each pattern may contain any of the wild-cards
+described under \fBstring match\fR.  If a \fIpatList\fR
+argument is \fBdefault\fR, the corresponding body will be evaluated
+if no \fIpatList\fR matches \fIstring\fR.  If no \fIpatList\fR argument
+matches \fIstring\fR and no default is given, then the \fBcase\fR
+command returns an empty string.
+.PP
+Two syntaxes are provided for the \fIpatList\fR and \fIbody\fR arguments.
+The first uses a separate argument for each of the patterns and commands;
+this form is convenient if substitutions are desired on some of the
+patterns or commands.
+The second form places all of the patterns and commands together into
+a single argument; the argument must have proper list structure, with
+the elements of the list being the patterns and commands.
+The second form makes it easy to construct multi-line case commands,
+since the braces around the whole list make it unnecessary to include a
+backslash at the end of each line.
+Since the \fIpatList\fR arguments are in braces in the second form,
+no command or variable substitutions are performed on them;  this makes
+the behavior of the second form different than the first form in some
+cases.
+
+.SH "SEE ALSO"
+switch(n)
+
+.SH KEYWORDS
+case, match, regular expression

Index: doc/cd.n
==================================================================
--- doc/cd.n
+++ doc/cd.n
@@ -20,11 +20,11 @@
 home directory (as specified in the HOME environment variable) if
 \fIdirName\fR is not given.
 Returns an empty string.
 Note that the current working directory is a per-process resource; the
 \fBcd\fR command changes the working directory for all interpreters
-and (in a threaded environment) all threads.
+and all threads.
 .SH EXAMPLES
 .PP
 Change to the home directory of the user \fBfred\fR:
 .PP
 .CS

Index: doc/define.n
==================================================================
--- doc/define.n
+++ doc/define.n
@@ -586,11 +586,11 @@
 for reading from slots is via \fBinfo class\fR and \fBinfo object\fR).
 .VE TIP516
 .SH EXAMPLES
 This example demonstrates how to use both forms of the \fBoo::define\fR and
 \fBoo::objdefine\fR commands (they work in the same way), as well as
-illustrating four of their subcommands.
+illustrating four of the subcommands of them.
 .PP
 .CS
 oo::class create c
 c create o
 \fBoo::define\fR c \fBmethod\fR foo {} {

Index: doc/expr.n
==================================================================
--- doc/expr.n
+++ doc/expr.n
@@ -48,11 +48,13 @@
 ignored.
 An integer operand may be specified in decimal (the normal case, the optional
 first two characters are \fB0d\fR), binary
 (the first two characters are \fB0b\fR), octal
 (the first two characters are \fB0o\fR), or hexadecimal
-(the first two characters are \fB0x\fR) form.
+(the first two characters are \fB0x\fR) form.  For
+compatibility with older Tcl releases, an operand that begins with \fB0\fR is
+interpreted as an octal integer even if the second character is not \fBo\fR.
 A floating-point number may be specified in any of several
 common decimal formats, and may use the decimal point \fB.\fR,
 \fBe\fR or \fBE\fR for scientific notation, and
 the sign characters \fB+\fR and \fB\-\fR.  The
 following are all valid floating-point numbers:  2.1, 3., 6e4, 7.91e+16.

Index: doc/load.n
==================================================================
--- doc/load.n
+++ doc/load.n
@@ -152,11 +152,11 @@
 The following is a minimal extension:
 .PP
 .CS
 #include <tcl.h>
 #include <stdio.h>
-static int fooCmd(void *clientData,
+static int fooCmd(ClientData clientData,
         Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]) {
     printf("called with %d arguments\en", objc);
     return TCL_OK;
 }
 int Foo_Init(Tcl_Interp *interp) {

Index: doc/mathfunc.n
==================================================================
--- doc/mathfunc.n
+++ doc/mathfunc.n
@@ -122,11 +122,14 @@
 .DE
 .PP
 In addition to these predefined functions, applications may
 define additional functions by using \fBproc\fR (or any other method,
 such as \fBinterp alias\fR or \fBTcl_CreateObjCommand\fR) to define
-new commands in the \fBtcl::mathfunc\fR namespace.
+new commands in the \fBtcl::mathfunc\fR namespace.  In addition, an
+obsolete interface named \fBTcl_CreateMathFunc\fR() is available to
+extensions that are written in C. The latter interface is not recommended
+for new implementations.
 .SS "DETAILED DEFINITIONS"
 .TP
 \fBabs \fIarg\fR
 .
 Returns the absolute value of \fIarg\fR.  \fIArg\fR may be either

Index: doc/memory.n
==================================================================
--- doc/memory.n
+++ doc/memory.n
@@ -23,22 +23,22 @@
 .
 Write a list of all currently allocated memory to the specified \fIfile\fR.
 .TP
 \fBmemory break_on_malloc\fR \fIcount\fR
 .
-After the \fIcount\fR allocations have been performed, \fBTcl_Alloc\fR
+After the \fIcount\fR allocations have been performed, \fBckalloc\fR
 outputs a message to this effect and that it is now attempting to enter
 the C debugger.  Tcl will then issue a \fISIGINT\fR signal against itself.
 If you are running Tcl under a C debugger, it should then enter the debugger
 command mode.
 .TP
 \fBmemory info\fR
 .
 Returns a report containing the total allocations and frees since
 Tcl began, the current packets allocated (the current
-number of calls to \fBTcl_Alloc\fR not met by a corresponding call
-to \fBTcl_Free\fR), the current bytes allocated, and the maximum number
+number of calls to \fBckalloc\fR not met by a corresponding call
+to \fBckfree\fR), the current bytes allocated, and the maximum number
 of packets and bytes allocated.
 .TP
 \fBmemory init \fR[\fBon\fR|\fBoff\fR]
 .
 Turn on or off the pre-initialization of all allocated memory
@@ -57,38 +57,38 @@
 during the finalization of Tcl's memory subsystem.  Useful for checking
 that memory is properly cleaned up during process exit.
 .TP
 \fBmemory tag\fR \fIstring\fR
 .
-Each packet of memory allocated by \fBTcl_Alloc\fR can have associated
+Each packet of memory allocated by \fBckalloc\fR can have associated
 with it a string-valued tag.  In the lists of allocated memory generated
 by \fBmemory active\fR and \fBmemory onexit\fR, the tag for each packet
 is printed along with other information about the packet.  The
 \fBmemory tag\fR command sets the tag value for subsequent calls
-to \fBTcl_Alloc\fR to be \fIstring\fR.
+to \fBckalloc\fR to be \fIstring\fR.
 .TP
 \fBmemory trace \fR[\fBon\fR|\fBoff\fR]
 .
 Turns memory tracing on or off.  When memory tracing is on, every call
-to \fBTcl_Alloc\fR causes a line of trace information to be written to
-\fIstderr\fR, consisting of the word \fITcl_Alloc\fR, followed by the
+to \fBckalloc\fR causes a line of trace information to be written to
+\fIstderr\fR, consisting of the word \fIckalloc\fR, followed by the
 address returned, the amount of memory allocated, and the C filename
 and line number of the code performing the allocation.  For example:
 .RS
 .PP
 .CS
-Tcl_Alloc 40e478 98 tclProc.c 1406
+ckalloc 40e478 98 tclProc.c 1406
 .CE
 .PP
-Calls to \fBTcl_Free\fR are traced in the same manner.
+Calls to \fBckfree\fR are traced in the same manner.
 .RE
 .TP
 \fBmemory trace_on_at_malloc\fR \fIcount\fR
 .
-Enable memory tracing after \fIcount\fR \fBTcl_Alloc\fRs have been performed.
+Enable memory tracing after \fIcount\fR \fBckalloc\fRs have been performed.
 For example, if you enter \fBmemory trace_on_at_malloc 100\fR,
-after the 100th call to \fBTcl_Alloc\fR, memory trace information will begin
+after the 100th call to \fBckalloc\fR, memory trace information will begin
 being displayed for all allocations and frees.  Since there can be a lot
 of memory activity before a problem occurs, judicious use of this option
 can reduce the slowdown caused by tracing (and the amount of trace information
 produced), if you can identify a number of allocations that occur before
 the problem sets in.  The current number of memory allocations that have
@@ -95,21 +95,21 @@
 occurred since Tcl started is printed on a guard zone failure.
 .TP
 \fBmemory validate \fR[\fBon\fR|\fBoff\fR]
 .
 Turns memory validation on or off. When memory validation is enabled,
-on every call to \fBTcl_Alloc\fR or \fBTcl_Free\fR, the guard zones are
+on every call to \fBckalloc\fR or \fBckfree\fR, the guard zones are
 checked for every piece of memory currently in existence that was
-allocated by \fBTcl_Alloc\fR.  This has a large performance impact and
+allocated by \fBckalloc\fR.  This has a large performance impact and
 should only be used when overwrite problems are strongly suspected.
 The advantage of enabling memory validation is that a guard zone
-overwrite can be detected on the first call to \fBTcl_Alloc\fR or
-\fBTcl_Free\fR after the overwrite occurred, rather than when the
+overwrite can be detected on the first call to \fBckalloc\fR or
+\fBckfree\fR after the overwrite occurred, rather than when the
 specific memory with the overwritten guard zone(s) is freed, which may
 occur long after the overwrite occurred.
 .SH "SEE ALSO"
-Tcl_Alloc, Tcl_Free, Tcl_ValidateAllMemory, Tcl_DumpActiveMemory, TCL_MEM_DEBUG
+ckalloc, ckfree, Tcl_ValidateAllMemory, Tcl_DumpActiveMemory, TCL_MEM_DEBUG
 .SH KEYWORDS
 memory, debug
 '\"Local Variables:
 '\"mode: nroff
 '\"End:

Index: doc/re_syntax.n
==================================================================
--- doc/re_syntax.n
+++ doc/re_syntax.n
@@ -373,11 +373,11 @@
 hexadecimal digits are reached, or an overflow would occur in the maximum
 value of \fBU+\fI10ffff\fR.
 .TP
 \fB\ev\fR
 .
-vertical tab, as in C
+vertical tab, as in C are all available.
 .TP
 \fB\ex\fIhh\fR
 .
 (where \fIhh\fR is one or two hexadecimal digits) the character
 whose hexadecimal value is \fB0x\fIhh\fR.

Index: doc/scan.n
==================================================================
--- doc/scan.n
+++ doc/scan.n
@@ -222,14 +222,16 @@
 .CS
 set string "#08D03F"
 \fBscan\fR $string "#%2x%2x%2x" r g b
 .CE
 .PP
-Parse a \fIHH:MM\fR time string:
+Parse a \fIHH:MM\fR time string, noting that this avoids problems with
+octal numbers by forcing interpretation as decimals (if we did not
+care, we would use the \fB%i\fR conversion instead):
 .PP
 .CS
-set string "08:08"
+set string "08:08"   ;# *Not* octal!
 if {[\fBscan\fR $string "%d:%d" hours minutes] != 2} {
     error "not a valid time string"
 }
 # We have to understand numeric ranges ourselves...
 if {$minutes < 0 || $minutes > 59} {

Index: doc/source.n
==================================================================
--- doc/source.n
+++ doc/source.n
@@ -41,11 +41,11 @@
 or
 .QW \eu001a ,
 which will be safely substituted by the Tcl interpreter into
 .QW ^Z .
 .PP
-A leading BOM (Byte order mark) contained in the file is ignored for unicode encodings (utf-8, unicode).
+A leading BOM (Byte order mark) contained in the file is ignored for unicode encodings (utf-8, utf-16, ucs-2).
 .PP
 The \fB\-encoding\fR option is used to specify the encoding of
 the data stored in \fIfileName\fR.  When the \fB\-encoding\fR option
 is omitted, the system encoding is assumed.
 .SH EXAMPLE

Index: doc/string.n
==================================================================
--- doc/string.n
+++ doc/string.n
@@ -360,25 +360,25 @@
 \fBstring trim \fIstring\fR ?\fIchars\fR?
 .
 Returns a value equal to \fIstring\fR except that any leading or
 trailing characters present in the string given by \fIchars\fR are removed.  If
 \fIchars\fR is not specified then white space is removed (any character
-for which \fBstring is space\fR returns 1, and "\0").
+for which \fBstring is space\fR returns 1, and "\e0").
 .TP
 \fBstring trimleft \fIstring\fR ?\fIchars\fR?
 .
 Returns a value equal to \fIstring\fR except that any leading
 characters present in the string given by \fIchars\fR are removed.  If
 \fIchars\fR is not specified then white space is removed (any character
-for which \fBstring is space\fR returns 1, and "\0").
+for which \fBstring is space\fR returns 1, and "\e0").
 .TP
 \fBstring trimright \fIstring\fR ?\fIchars\fR?
 .
 Returns a value equal to \fIstring\fR except that any trailing
 characters present in the string given by \fIchars\fR are removed.  If
 \fIchars\fR is not specified then white space is removed (any character
-for which \fBstring is space\fR returns 1, and "\0").
+for which \fBstring is space\fR returns 1, and "\e0").
 .SS "OBSOLETE SUBCOMMANDS"
 .PP
 These subcommands are currently supported, but are likely to go away in a
 future release as their functionality is either virtually never used or highly
 misleading.

Index: doc/tclvars.n
==================================================================
--- doc/tclvars.n
+++ doc/tclvars.n
@@ -8,11 +8,11 @@
 .TH tclvars n 8.0 Tcl "Tcl Built-In Commands"
 .so man.macros
 .BS
 '\" Note:  do not modify the .SH NAME line immediately below!
 .SH NAME
-argc, argv, argv0, auto_path, env, errorCode, errorInfo, tcl_interactive, tcl_library, tcl_nonwordchars, tcl_patchLevel, tcl_pkgPath, tcl_platform, tcl_rcFileName, tcl_traceCompile, tcl_traceExec, tcl_wordchars, tcl_version \- Variables used by Tcl
+argc, argv, argv0, auto_path, env, errorCode, errorInfo, tcl_interactive, tcl_library, tcl_nonwordchars, tcl_patchLevel, tcl_pkgPath, tcl_platform, tcl_precision, tcl_rcFileName, tcl_traceCompile, tcl_traceExec, tcl_wordchars, tcl_version \- Variables used by Tcl
 .BE
 .SH DESCRIPTION
 .PP
 The following global variables are created and managed automatically
 by the Tcl library.  Except where noted below, these variables should
@@ -353,10 +353,74 @@
 \fBwordSize\fR
 .
 This gives the size of the native-machine word in bytes (strictly, it
 is same as the result of evaluating \fIsizeof(long)\fR in C.)
 .RE
+.TP
+\fBtcl_precision\fR
+.
+This variable controls the number of digits to generate
+when converting floating-point values to strings.  It defaults
+to 0.  \fIApplications should not change this value;\fR it is
+provided for compatibility with legacy code.
+.PP
+.RS
+The default value of 0 is special, meaning that Tcl should
+convert numbers using as few digits as possible while still
+distinguishing any floating point number from its nearest
+neighbours.  It differs from using an arbitrarily high value
+for \fItcl_precision\fR in that an inexact number like \fI1.4\fR
+will convert as \fI1.4\fR rather than \fI1.3999999999999999\fR
+even though the latter is nearer to the exact value of the
+binary number.
+.RE
+.PP
+.RS
+If \fBtcl_precision\fR is not zero, then when Tcl converts a floating
+point number, it creates a decimal representation of at most
+\fBtcl_precision\fR significant digits; the result may be shorter if
+the shorter result represents the original number exactly. If no
+result of at most \fBtcl_precision\fR digits is an exact representation
+of the original number, the one that is closest to the original
+number is chosen.
+If the original number lies precisely between two equally accurate
+decimal representations, then the one with an even value for the least
+significant digit is chosen; for instance, if \fBtcl_precision\fR is 3, then
+0.3125 will convert to 0.312, not 0.313, while 0.6875 will convert to
+0.688, not 0.687. Any string of trailing zeroes that remains is trimmed.
+.RE
+.PP
+.RS
+a \fBtcl_precision\fR value of 17 digits is
+.QW perfect
+for IEEE floating-point in that it allows
+double-precision values to be converted to strings and back to
+binary with no loss of information. For this reason, you will often
+see it as a value in legacy code that must run on Tcl versions before
+8.5. It is no longer recommended; as noted above, a zero value is the
+preferred method.
+.RE
+.PP
+.RS
+All interpreters in a thread share a single \fBtcl_precision\fR value:
+changing it in one interpreter will affect all other interpreters as
+well.  Safe interpreters are not allowed to modify the
+variable.
+.RE
+.PP
+.RS
+Valid values for \fBtcl_precision\fR range from 0 to 17.
+.RE
+.TP
+\fBtcl_rcFileName\fR
+.
+This variable is used during initialization to indicate the name of a
+user-specific startup file.  If it is set by application-specific
+initialization, then the Tcl startup code will check for the existence
+of this file and \fBsource\fR it if it exists.  For example, for \fBwish\fR
+the variable is set to \fB~/.wishrc\fR for Unix and \fB~/wishrc.tcl\fR
+for Windows.
 .TP
 \fBtcl_traceCompile\fR
 .
 The value of this variable can be set to control
 how much tracing information

Index: generic/regc_lex.c
==================================================================
--- generic/regc_lex.c
+++ generic/regc_lex.c
@@ -903,13 +903,11 @@
 	 * Oops, doesn't look like it's a backref after all...
 	 */
 
 	v->now = save;
 
-	/*
-	 * And fall through into octal number.
-	 */
+	/* FALLTHRU */
 
     case CHR('0'):
 	NOTE(REG_UUNPORT);
 	v->now--;		/* put first digit back */
 	c = (uchr) lexdigits(v, 8, 1, 3);

Index: generic/regc_locale.c
==================================================================
--- generic/regc_locale.c
+++ generic/regc_locale.c
@@ -796,10 +796,12 @@
 #define NUM_GRAPH_CHAR (sizeof(graphCharTable)/sizeof(chr))
 
 /*
  *	End of auto-generated Unicode character ranges declarations.
  */
+
+#define	CH	NOCELT
 
 /*
  - element - map collating-element name to celt
  ^ static celt element(struct vars *, const chr *, const chr *);
  */
@@ -888,13 +890,13 @@
     cv = getcvec(v, nchrs, 0);
     NOERRN();
 
     for (c=a; c<=b; c++) {
 	addchr(cv, c);
-	lc = Tcl_UniCharToLower(c);
-	uc = Tcl_UniCharToUpper(c);
-	tc = Tcl_UniCharToTitle(c);
+	lc = Tcl_UniCharToLower((chr)c);
+	uc = Tcl_UniCharToUpper((chr)c);
+	tc = Tcl_UniCharToTitle((chr)c);
 	if (c != lc) {
 	    addchr(cv, lc);
 	}
 	if (c != uc) {
 	    addchr(cv, uc);
@@ -939,15 +941,15 @@
      * Crude fake equivalence class for testing.
      */
 
     if ((v->cflags&REG_FAKE) && c == 'x') {
 	cv = getcvec(v, 4, 0);
-	addchr(cv, 'x');
-	addchr(cv, 'y');
+	addchr(cv, (chr)'x');
+	addchr(cv, (chr)'y');
 	if (cases) {
-	    addchr(cv, 'X');
-	    addchr(cv, 'Y');
+	    addchr(cv, (chr)'X');
+	    addchr(cv, (chr)'Y');
 	}
 	return cv;
     }
 
     /*
@@ -957,11 +959,11 @@
     if (cases) {
 	return allcases(v, c);
     }
     cv = getcvec(v, 1, 0);
     assert(cv != NULL);
-    addchr(cv, c);
+    addchr(cv, (chr)c);
     return cv;
 }
 
 /*
  - cclass - supply cvec for a character class
@@ -978,12 +980,11 @@
     size_t len;
     struct cvec *cv = NULL;
     Tcl_DString ds;
     const char *np;
     const char *const *namePtr;
-    size_t i;
-    int index;
+    int i, index;
 
     /*
      * The following arrays define the valid character class names.
      */
 
@@ -1002,11 +1003,11 @@
      * Extract the class name
      */
 
     len = endp - startp;
     Tcl_DStringInit(&ds);
-    np = Tcl_UniCharToUtfDString(startp, len, &ds);
+    np = Tcl_UniCharToUtfDString(startp, (int)len, &ds);
 
     /*
      * Map the name to the corresponding enumerated value.
      */
 
@@ -1037,31 +1038,31 @@
 
     switch((enum classes) index) {
     case CC_ALNUM:
 	cv = getcvec(v, NUM_ALPHA_CHAR, NUM_DIGIT_RANGE + NUM_ALPHA_RANGE);
 	if (cv) {
-	    for (i=0 ; i<NUM_ALPHA_CHAR ; i++) {
+	    for (i=0 ; (size_t)i<NUM_ALPHA_CHAR ; i++) {
 		addchr(cv, alphaCharTable[i]);
 	    }
-	    for (i=0 ; i<NUM_ALPHA_RANGE ; i++) {
+	    for (i=0 ; (size_t)i<NUM_ALPHA_RANGE ; i++) {
 		addrange(cv, alphaRangeTable[i].start,
 			alphaRangeTable[i].end);
 	    }
-	    for (i=0 ; i<NUM_DIGIT_RANGE ; i++) {
+	    for (i=0 ; (size_t)i<NUM_DIGIT_RANGE ; i++) {
 		addrange(cv, digitRangeTable[i].start,
 			digitRangeTable[i].end);
 	    }
 	}
 	break;
     case CC_ALPHA:
 	cv = getcvec(v, NUM_ALPHA_CHAR, NUM_ALPHA_RANGE);
 	if (cv) {
-	    for (i=0 ; i<NUM_ALPHA_RANGE ; i++) {
+	    for (i=0 ; (size_t)i<NUM_ALPHA_RANGE ; i++) {
 		addrange(cv, alphaRangeTable[i].start,
 			alphaRangeTable[i].end);
 	    }
-	    for (i=0 ; i<NUM_ALPHA_CHAR ; i++) {
+	    for (i=0 ; (size_t)i<NUM_ALPHA_CHAR ; i++) {
 		addchr(cv, alphaCharTable[i]);
 	    }
 	}
 	break;
     case CC_ASCII:
@@ -1076,36 +1077,36 @@
 	addchr(cv, ' ');
 	break;
     case CC_CNTRL:
 	cv = getcvec(v, NUM_CONTROL_CHAR, NUM_CONTROL_RANGE);
 	if (cv) {
-	    for (i=0 ; i<NUM_CONTROL_RANGE ; i++) {
+	    for (i=0 ; (size_t)i<NUM_CONTROL_RANGE ; i++) {
 		addrange(cv, controlRangeTable[i].start,
 			controlRangeTable[i].end);
 	    }
-	    for (i=0 ; i<NUM_CONTROL_CHAR ; i++) {
+	    for (i=0 ; (size_t)i<NUM_CONTROL_CHAR ; i++) {
 		addchr(cv, controlCharTable[i]);
 	    }
 	}
 	break;
     case CC_DIGIT:
 	cv = getcvec(v, 0, NUM_DIGIT_RANGE);
 	if (cv) {
-	    for (i=0 ; i<NUM_DIGIT_RANGE ; i++) {
+	    for (i=0 ; (size_t)i<NUM_DIGIT_RANGE ; i++) {
 		addrange(cv, digitRangeTable[i].start,
 			digitRangeTable[i].end);
 	    }
 	}
 	break;
     case CC_PUNCT:
 	cv = getcvec(v, NUM_PUNCT_CHAR, NUM_PUNCT_RANGE);
 	if (cv) {
-	    for (i=0 ; i<NUM_PUNCT_RANGE ; i++) {
+	    for (i=0 ; (size_t)i<NUM_PUNCT_RANGE ; i++) {
 		addrange(cv, punctRangeTable[i].start,
 			punctRangeTable[i].end);
 	    }
-	    for (i=0 ; i<NUM_PUNCT_CHAR ; i++) {
+	    for (i=0 ; (size_t)i<NUM_PUNCT_CHAR ; i++) {
 		addchr(cv, punctCharTable[i]);
 	    }
 	}
 	break;
     case CC_XDIGIT:
@@ -1126,70 +1127,70 @@
 	}
 	break;
     case CC_SPACE:
 	cv = getcvec(v, NUM_SPACE_CHAR, NUM_SPACE_RANGE);
 	if (cv) {
-	    for (i=0 ; i<NUM_SPACE_RANGE ; i++) {
+	    for (i=0 ; (size_t)i<NUM_SPACE_RANGE ; i++) {
 		addrange(cv, spaceRangeTable[i].start,
 			spaceRangeTable[i].end);
 	    }
-	    for (i=0 ; i<NUM_SPACE_CHAR ; i++) {
+	    for (i=0 ; (size_t)i<NUM_SPACE_CHAR ; i++) {
 		addchr(cv, spaceCharTable[i]);
 	    }
 	}
 	break;
     case CC_LOWER:
 	cv  = getcvec(v, NUM_LOWER_CHAR, NUM_LOWER_RANGE);
 	if (cv) {
-	    for (i=0 ; i<NUM_LOWER_RANGE ; i++) {
+	    for (i=0 ; (size_t)i<NUM_LOWER_RANGE ; i++) {
 		addrange(cv, lowerRangeTable[i].start,
 			lowerRangeTable[i].end);
 	    }
-	    for (i=0 ; i<NUM_LOWER_CHAR ; i++) {
+	    for (i=0 ; (size_t)i<NUM_LOWER_CHAR ; i++) {
 		addchr(cv, lowerCharTable[i]);
 	    }
 	}
 	break;
     case CC_UPPER:
 	cv  = getcvec(v, NUM_UPPER_CHAR, NUM_UPPER_RANGE);
 	if (cv) {
-	    for (i=0 ; i<NUM_UPPER_RANGE ; i++) {
+	    for (i=0 ; (size_t)i<NUM_UPPER_RANGE ; i++) {
 		addrange(cv, upperRangeTable[i].start,
 			upperRangeTable[i].end);
 	    }
-	    for (i=0 ; i<NUM_UPPER_CHAR ; i++) {
+	    for (i=0 ; (size_t)i<NUM_UPPER_CHAR ; i++) {
 		addchr(cv, upperCharTable[i]);
 	    }
 	}
 	break;
     case CC_PRINT:
     	cv  = getcvec(v, NUM_SPACE_CHAR + NUM_GRAPH_CHAR, NUM_SPACE_RANGE + NUM_GRAPH_RANGE  - 1);
     	if (cv) {
-    	    for (i=1 ; i<NUM_SPACE_RANGE ; i++) {
+    	    for (i=1 ; (size_t)i<NUM_SPACE_RANGE ; i++) {
     		addrange(cv, spaceRangeTable[i].start,
     				spaceRangeTable[i].end);
     	    }
-    	    for (i=0 ; i<NUM_SPACE_CHAR ; i++) {
+    	    for (i=0 ; (size_t)i<NUM_SPACE_CHAR ; i++) {
     		addchr(cv, spaceCharTable[i]);
     	    }
-    	    for (i=0 ; i<NUM_GRAPH_RANGE ; i++) {
+    	    for (i=0 ; (size_t)i<NUM_GRAPH_RANGE ; i++) {
     		addrange(cv, graphRangeTable[i].start,
     				graphRangeTable[i].end);
     	    }
-    	    for (i=0 ; i<NUM_GRAPH_CHAR ; i++) {
+    	    for (i=0 ; (size_t)i<NUM_GRAPH_CHAR ; i++) {
     		addchr(cv, graphCharTable[i]);
     	    }
     	}
     	break;
     case CC_GRAPH:
 	cv  = getcvec(v, NUM_GRAPH_CHAR, NUM_GRAPH_RANGE);
 	if (cv) {
-	    for (i=0 ; i<NUM_GRAPH_RANGE ; i++) {
+	    for (i=0 ; (size_t)i<NUM_GRAPH_RANGE ; i++) {
 		addrange(cv, graphRangeTable[i].start,
 			graphRangeTable[i].end);
 	    }
-	    for (i=0 ; i<NUM_GRAPH_CHAR ; i++) {
+	    for (i=0 ; (size_t)i<NUM_GRAPH_CHAR ; i++) {
 		addchr(cv, graphCharTable[i]);
 	    }
 	}
 	break;
     }
@@ -1212,13 +1213,13 @@
 {
     struct cvec *cv;
     chr c = (chr)pc;
     chr lc, uc, tc;
 
-    lc = Tcl_UniCharToLower(c);
-    uc = Tcl_UniCharToUpper(c);
-    tc = Tcl_UniCharToTitle(c);
+    lc = Tcl_UniCharToLower((chr)c);
+    uc = Tcl_UniCharToUpper((chr)c);
+    tc = Tcl_UniCharToTitle((chr)c);
 
     if (tc != uc) {
 	cv = getcvec(v, 3, 0);
 	addchr(cv, tc);
     } else {

Index: generic/regc_nfa.c
==================================================================
--- generic/regc_nfa.c
+++ generic/regc_nfa.c
@@ -2976,10 +2976,13 @@
     fprintf(f, "total of %d states, %d arcs\n", nstates, narcs);
     if (nfa->parent == NULL) {
 	dumpcolors(nfa->cm, f);
     }
     fflush(f);
+#else
+    (void)nfa;
+    (void)f;
 #endif
 }
 
 #ifdef REG_DEBUG		/* subordinates of dumpnfa */
 /*
@@ -3155,10 +3158,13 @@
     fprintf(f, "\n");
     for (st = 0; st < cnfa->nstates; st++) {
 	dumpcstate(st, cnfa, f);
     }
     fflush(f);
+#else
+    (void)cnfa;
+    (void)f;
 #endif
 }
 
 #ifdef REG_DEBUG		/* subordinates of dumpcnfa */
 /*

Index: generic/regcomp.c
==================================================================
--- generic/regcomp.c
+++ generic/regcomp.c
@@ -37,11 +37,11 @@
  */
 /* =====^!^===== begin forwards =====^!^===== */
 /* automatically gathered by fwd; do not hand-edit */
 /* === regcomp.c === */
 int compile(regex_t *, const chr *, size_t, int);
-static void moresubs(struct vars *, size_t);
+static void moresubs(struct vars *, int);
 static int freev(struct vars *, int);
 static void makesearch(struct vars *, struct nfa *);
 static struct subre *parse(struct vars *, int, int, struct state *, struct state *);
 static struct subre *parsebranch(struct vars *, int, int, struct state *, struct state *, int);
 static void parseqatom(struct vars *, int, int, struct state *, struct state *, struct subre *);
@@ -57,11 +57,10 @@
 static void dovec(struct vars *, struct cvec *, struct state *, struct state *);
 static void wordchrs(struct vars *);
 static struct subre *subre(struct vars *, int, int, struct state *, struct state *);
 static void freesubre(struct vars *, struct subre *);
 static void freesrnode(struct vars *, struct subre *);
-static void optst(struct vars *, struct subre *);
 static int numst(struct subre *, int);
 static void markst(struct subre *);
 static void cleanst(struct vars *);
 static long nfatree(struct vars *, struct subre *, FILE *);
 static long nfanode(struct vars *, struct subre *, FILE *);
@@ -336,10 +335,11 @@
     v->lacons = NULL;
     v->nlacons = 0;
     v->spaceused = 0;
     re->re_magic = REMAGIC;
     re->re_info = 0;		/* bits get set during parse */
+    re->re_csize = sizeof(chr);
     re->re_guts = NULL;
     re->re_fns = (void*)(&functions);
 
     /*
      * More complex setup, malloced things.
@@ -391,11 +391,10 @@
     if (debug != NULL) {
 	fprintf(debug, "\n\n\n========= RAW ==========\n");
 	dumpnfa(v->nfa, debug);
 	dumpst(v->tree, debug, 1);
     }
-    optst(v, v->tree);
     v->ntree = numst(v->tree, 1);
     markst(v->tree);
     cleanst(v);
     if (debug != NULL) {
 	fprintf(debug, "\n\n\n========= TREE FIXED ==========\n");
@@ -465,16 +464,16 @@
     return freev(v, 0);
 }
 
 /*
  - moresubs - enlarge subRE vector
- ^ static void moresubs(struct vars *, size_t);
+ ^ static void moresubs(struct vars *, int);
  */
 static void
 moresubs(
     struct vars *v,
-    size_t wanted)			/* want enough room for this one */
+    int wanted)			/* want enough room for this one */
 {
     struct subre **p;
     int n;
 
     assert(wanted > 0 && wanted >= v->nsubs);
@@ -509,11 +508,11 @@
 static int
 freev(
     struct vars *v,
     int err)
 {
-    register int ret;
+    int ret;
 
     if (v->re != NULL) {
 	rfree(v->re);
     }
     if (v->subs != v->sub10) {
@@ -919,11 +918,11 @@
 	/*
 	 * Legal in EREs due to specification botch.
 	 */
 
 	NOTE(REG_UPBOTCH);
-	/* fallthrough into case PLAIN */
+	/* FALLTHRU */
     case PLAIN:
 	onechr(v, v->nextvalue, lp, rp);
 	okcolors(v->nfa, v->cm);
 	NOERR();
 	NEXT();
@@ -1806,29 +1805,10 @@
 	v->treefree = sr;
     } else {
 	FREE(sr);
     }
 }
-
-/*
- - optst - optimize a subRE subtree
- ^ static void optst(struct vars *, struct subre *);
- */
-static void
-optst(
-    struct vars *v,
-    struct subre *t)
-{
-    /*
-     * DGP (2007-11-13): I assume it was the programmer's intent to eventually
-     * come back and add code to optimize subRE trees, but the routine coded
-     * just spends effort traversing the tree and doing nothing. We can do
-     * nothing with less effort.
-     */
-
-    return;
-}
 
 /*
  - numst - number tree nodes (assigning "id" indexes)
  ^ static int numst(struct subre *, int);
  */
@@ -2082,12 +2062,12 @@
 	fprintf(f, "bad guts magic number (0x%x not 0x%x)\n",
 		g->magic, GUTSMAGIC);
     }
 
     fprintf(f, "\n\n\n========= DUMP ==========\n");
-    fprintf(f, "nsub %" TCL_Z_MODIFIER "d, info 0%lo, ntree %d\n",
-	    re->re_nsub, re->re_info, g->ntree);
+    fprintf(f, "nsub %d, info 0%lo, csize %d, ntree %d\n",
+	    (int) re->re_nsub, re->re_info, re->re_csize, g->ntree);
 
     dumpcolors(&g->cmap, f);
     if (!NULLCNFA(g->search)) {
 	fprintf(f, "\nsearch:\n");
 	dumpcnfa(&g->search, f);
@@ -2097,10 +2077,13 @@
 		(g->lacons[i].subno) ? "positive" : "negative");
 	dumpcnfa(&g->lacons[i].cnfa, f);
     }
     fprintf(f, "\n");
     dumpst(g->tree, f, 0);
+#else
+    (void)re;
+    (void)f;
 #endif
 }
 
 /*
  - dumpst - dump a subRE tree

Index: generic/regcustom.h
==================================================================
--- generic/regcustom.h
+++ generic/regcustom.h
@@ -34,13 +34,13 @@
 
 /*
  * Overrides for regguts.h definitions, if any.
  */
 
-#define	MALLOC(n)		Tcl_AttemptAlloc(n)
-#define	FREE(p)			Tcl_Free(p)
-#define	REALLOC(p,n)		Tcl_AttemptRealloc(p,n)
+#define	MALLOC(n)		(void*)(attemptckalloc(n))
+#define	FREE(p)			ckfree((void*)(p))
+#define	REALLOC(p,n)		(void*)(attemptckrealloc((void*)(p),n))
 
 /*
  * Do not insert extras between the "begin" and "end" lines - this chunk is
  * automatically extracted to be fitted into regex.h.
  */
@@ -54,18 +54,22 @@
 #undef __REG_WIDE_COMPILE
 #endif
 #ifdef __REG_WIDE_EXEC
 #undef __REG_WIDE_EXEC
 #endif
+#ifdef __REG_REGOFF_T
+#undef __REG_REGOFF_T
+#endif
 #ifdef __REG_NOFRONT
 #undef __REG_NOFRONT
 #endif
 #ifdef __REG_NOCHAR
 #undef __REG_NOCHAR
 #endif
 /* Interface types */
 #define	__REG_WIDE_T	Tcl_UniChar
+#define	__REG_REGOFF_T	long	/* Not really right, but good enough... */
 /* Names and declarations */
 #define	__REG_WIDE_COMPILE	TclReComp
 #define	__REG_WIDE_EXEC		TclReExec
 #define	__REG_NOFRONT		/* Don't want regcomp() and regexec() */
 #define	__REG_NOCHAR		/* Or the char versions */
@@ -125,20 +129,20 @@
  */
 
 #if 1
 #define AllocVars(vPtr) \
     static Tcl_ThreadDataKey varsKey; \
-    register struct vars *vPtr = (struct vars *) \
+    struct vars *vPtr = (struct vars *) \
 	    Tcl_GetThreadData(&varsKey, sizeof(struct vars))
 #else
 /*
  * This strategy for allocating workspace is "more proper" in some sense, but
  * quite a bit slower. Using TSD (as above) leads to code that is quite a bit
  * faster in practice (measured!)
  */
 #define AllocVars(vPtr) \
-    register struct vars *vPtr = (struct vars *) MALLOC(sizeof(struct vars))
+    struct vars *vPtr = (struct vars *) MALLOC(sizeof(struct vars))
 #define FreeVars(vPtr) \
     FREE(vPtr)
 #endif
 
 /*

Index: generic/regerror.c
==================================================================
--- generic/regerror.c
+++ generic/regerror.c
@@ -56,11 +56,10 @@
  */
 /* ARGSUSED */
 size_t				/* Actual space needed (including NUL) */
 regerror(
     int code,			/* Error code, or REG_ATOI or REG_ITOA */
-    const regex_t *preg,	/* Associated regex_t (unused at present) */
     char *errbuf,		/* Result buffer (unless errbuf_size==0) */
     size_t errbuf_size)		/* Available space in errbuf, can be 0 */
 {
     const struct rerr *r;
     const char *msg;
@@ -86,11 +85,11 @@
 	    }
 	}
 	if (r->code >= 0) {
 	    msg = r->name;
 	} else {		/* Unknown; tell him the number */
-	    sprintf(convbuf, "REG_%u", icode);
+	    sprintf(convbuf, "REG_%u", (unsigned)icode);
 	    msg = convbuf;
 	}
 	break;
     default:			/* A real, normal error code */
 	for (r = rerrs; r->code >= 0; r++) {

Index: generic/regex.h
==================================================================
--- generic/regex.h
+++ generic/regex.h
@@ -87,18 +87,22 @@
 #undef __REG_WIDE_COMPILE
 #endif
 #ifdef __REG_WIDE_EXEC
 #undef __REG_WIDE_EXEC
 #endif
+#ifdef __REG_REGOFF_T
+#undef __REG_REGOFF_T
+#endif
 #ifdef __REG_NOFRONT
 #undef __REG_NOFRONT
 #endif
 #ifdef __REG_NOCHAR
 #undef __REG_NOCHAR
 #endif
 /* interface types */
 #define	__REG_WIDE_T	Tcl_UniChar
+#define	__REG_REGOFF_T	long	/* not really right, but good enough... */
 /* names and declarations */
 #define	__REG_WIDE_COMPILE	TclReComp
 #define	__REG_WIDE_EXEC		TclReExec
 #define	__REG_NOFRONT		/* don't want regcomp() and regexec() */
 #define	__REG_NOCHAR		/* or the char versions */
@@ -108,19 +112,30 @@
 
 /*
  * interface types etc.
  */
 
+/*
+ * regoff_t has to be large enough to hold either off_t or ssize_t, and must
+ * be signed; it's only a guess that long is suitable, so we offer
+ * <sys/types.h> an override.
+ */
+#ifdef __REG_REGOFF_T
+typedef __REG_REGOFF_T regoff_t;
+#else
+typedef long regoff_t;
+#endif
+
 /*
  * other interface types
  */
 
 /* the biggie, a compiled RE (or rather, a front end to same) */
 typedef struct {
     int re_magic;		/* magic number */
-    long re_info;		/* information about RE */
     size_t re_nsub;		/* number of subexpressions */
+    long re_info;		/* information about RE */
 #define	REG_UBACKREF		000001
 #define	REG_ULOOKAHEAD		000002
 #define	REG_UBOUNDS		000004
 #define	REG_UBRACES		000010
 #define	REG_UBSALNUM		000020
@@ -131,20 +146,21 @@
 #define	REG_UUNPORT		001000
 #define	REG_ULOCALE		002000
 #define	REG_UEMPTYMATCH		004000
 #define	REG_UIMPOSSIBLE		010000
 #define	REG_USHORTEST		020000
+    int re_csize;		/* sizeof(character) */
     char *re_endp;		/* backward compatibility kludge */
     /* the rest is opaque pointers to hidden innards */
-    char *re_guts;		/* `char *' is more portable than `void *' */
-    char *re_fns;
+    void *re_guts;
+    void *re_fns;
 } regex_t;
 
 /* result reporting (may acquire more fields later) */
 typedef struct {
-    size_t rm_so;		/* start of substring */
-    size_t rm_eo;		/* end of substring */
+    regoff_t rm_so;		/* start of substring */
+    regoff_t rm_eo;		/* end of substring */
 } regmatch_t;
 
 /* supplementary control and reporting */
 typedef struct {
     regmatch_t rm_extend;	/* see REG_EXPECT */
@@ -214,11 +230,11 @@
  *
  * Note that there is no wide-char variant of regerror at this time; what kind
  * of character is used for error reports is independent of what kind is used
  * in matching.
  *
- ^ extern size_t regerror(int, const regex_t *, char *, size_t);
+ ^ extern size_t regerror(int, char *, size_t);
  */
 #define	REG_OKAY	 0	/* no errors detected */
 #define	REG_NOMATCH	 1	/* failed to match */
 #define	REG_BADPAT	 2	/* invalid regexp */
 #define	REG_ECOLLATE	 3	/* invalid collating element */
@@ -265,11 +281,11 @@
 #endif
 #ifdef __REG_WIDE_T
 MODULE_SCOPE int __REG_WIDE_EXEC(regex_t *, const __REG_WIDE_T *, size_t, rm_detail_t *, size_t, regmatch_t [], int);
 #endif
 MODULE_SCOPE void regfree(regex_t *);
-MODULE_SCOPE size_t regerror(int, const regex_t *, char *, size_t);
+MODULE_SCOPE size_t regerror(int, char *, size_t);
 /* automatically gathered by fwd; do not hand-edit */
 /* =====^!^===== end forwards =====^!^===== */
 
 /*
  * more C++ voodoo

Index: generic/regexec.c
==================================================================
--- generic/regexec.c
+++ generic/regexec.c
@@ -89,11 +89,10 @@
     struct sset ssets[FEWSTATES*2];
     unsigned statesarea[FEWSTATES*2 + WORK];
     struct sset *outsarea[FEWSTATES*2 * FEWCOLORS];
     struct arcp incarea[FEWSTATES*2 * FEWCOLORS];
 };
-#define	DOMALLOC	((struct smalldfa *)NULL)	/* force malloc */
 
 /*
  * Internal variables, bundled for easy passing around.
  */
 
@@ -127,11 +126,11 @@
 /* === regexec.c === */
 int exec(regex_t *, const chr *, size_t, rm_detail_t *, size_t, regmatch_t [], int);
 static struct dfa *getsubdfa(struct vars *, struct subre *);
 static int simpleFind(struct vars *const, struct cnfa *const, struct colormap *const);
 static int complicatedFind(struct vars *const, struct cnfa *const, struct colormap *const);
-static int complicatedFindLoop(struct vars *const, struct cnfa *const, struct colormap *const, struct dfa *const, struct dfa *const, chr **const);
+static int complicatedFindLoop(struct vars *const, struct dfa *const, struct dfa *const, chr **const);
 static void zapallsubs(regmatch_t *const, const size_t);
 static void zaptreesubs(struct vars *const, struct subre *const);
 static void subset(struct vars *const, struct subre *const, chr *const, chr *const);
 static int cdissect(struct vars *, struct subre *, chr *, chr *);
 static int ccondissect(struct vars *, struct subre *, chr *, chr *);
@@ -184,10 +183,14 @@
      */
 
     if (re == NULL || string == NULL || re->re_magic != REMAGIC) {
 	FreeVars(v);
 	return REG_INVARG;
+    }
+    if (re->re_csize != sizeof(chr)) {
+	FreeVars(v);
+	return REG_MIXED;
     }
 
     /*
      * Setup.
      */
@@ -293,11 +296,11 @@
 static struct dfa *
 getsubdfa(struct vars * v,
 	  struct subre * t)
 {
     if (v->subdfas[t->id] == NULL) {
-	v->subdfas[t->id] = newDFA(v, &t->cnfa, &v->g->cmap, DOMALLOC);
+	v->subdfas[t->id] = newDFA(v, &t->cnfa, &v->g->cmap, NULL);
 	if (ISERR())
 	    return NULL;
     }
     return v->subdfas[t->id];
 }
@@ -428,11 +431,11 @@
 	assert(d == NULL);
 	freeDFA(s);
 	return v->err;
     }
 
-    ret = complicatedFindLoop(v, cnfa, cm, d, s, &cold);
+    ret = complicatedFindLoop(v, d, s, &cold);
 
     freeDFA(d);
     freeDFA(s);
     NOERR();
     if (v->g->cflags&REG_EXPECT) {
@@ -447,18 +450,16 @@
     return ret;
 }
 
 /*
  - complicatedFindLoop - the heart of complicatedFind
- ^ static int complicatedFindLoop(struct vars *, struct cnfa *, struct colormap *,
+ ^ static int complicatedFindLoop(struct vars *,
  ^	struct dfa *, struct dfa *, chr **);
  */
 static int
 complicatedFindLoop(
     struct vars *const v,
-    struct cnfa *const cnfa,
-    struct colormap *const cm,
     struct dfa *const d,
     struct dfa *const s,
     chr **const coldp)		/* where to put coldstart pointer */
 {
     chr *begin, *end;

Index: generic/regguts.h
==================================================================
--- generic/regguts.h
+++ generic/regguts.h
@@ -409,11 +409,11 @@
  */
 
 #ifndef AllocVars
 #define AllocVars(vPtr) \
     struct vars var; \
-    register struct vars *vPtr = &var
+    struct vars *vPtr = &var
 #endif
 #ifndef FreeVars
 #define FreeVars(vPtr) ((void) 0)
 #endif
 

Index: generic/tcl.decls
==================================================================
--- generic/tcl.decls
+++ generic/tcl.decls
@@ -38,36 +38,36 @@
 }
 declare 2 {
     TCL_NORETURN void Tcl_Panic(const char *format, ...)
 }
 declare 3 {
-    void *Tcl_Alloc(size_t size)
+    char *Tcl_Alloc(unsigned int size)
 }
 declare 4 {
-    void Tcl_Free(void *ptr)
+    void Tcl_Free(char *ptr)
 }
 declare 5 {
-    void *Tcl_Realloc(void *ptr, size_t size)
+    char *Tcl_Realloc(char *ptr, unsigned int size)
 }
 declare 6 {
-    void *Tcl_DbCkalloc(size_t size, const char *file, int line)
+    char *Tcl_DbCkalloc(unsigned int size, const char *file, int line)
 }
 declare 7 {
-    void Tcl_DbCkfree(void *ptr, const char *file, int line)
+    void Tcl_DbCkfree(char *ptr, const char *file, int line)
 }
 declare 8 {
-    void *Tcl_DbCkrealloc(void *ptr, size_t size,
+    char *Tcl_DbCkrealloc(char *ptr, unsigned int size,
 	    const char *file, int line)
 }
 
 # Tcl_CreateFileHandler and Tcl_DeleteFileHandler are only available on unix,
 # but they are part of the old generic interface, so we include them here for
 # compatibility reasons.
 
 declare 9 unix {
     void Tcl_CreateFileHandler(int fd, int mask, Tcl_FileProc *proc,
-	    void *clientData)
+	    ClientData clientData)
 }
 declare 10 unix {
     void Tcl_DeleteFileHandler(int fd)
 }
 declare 11 {
@@ -84,11 +84,11 @@
 }
 declare 15 {
     void Tcl_AppendStringsToObj(Tcl_Obj *objPtr, ...)
 }
 declare 16 {
-    void Tcl_AppendToObj(Tcl_Obj *objPtr, const char *bytes, size_t length)
+    void Tcl_AppendToObj(Tcl_Obj *objPtr, const char *bytes, int length)
 }
 declare 17 {
     Tcl_Obj *Tcl_ConcatObj(int objc, Tcl_Obj *const objv[])
 }
 declare 18 {
@@ -102,16 +102,15 @@
     void Tcl_DbIncrRefCount(Tcl_Obj *objPtr, const char *file, int line)
 }
 declare 21 {
     int Tcl_DbIsShared(Tcl_Obj *objPtr, const char *file, int line)
 }
-# Removed in 9.0 (changed to macro):
-#declare 22 {
-#    Tcl_Obj *Tcl_DbNewBooleanObj(int boolValue, const char *file, int line)
-#}
+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, size_t length,
+    Tcl_Obj *Tcl_DbNewByteArrayObj(const unsigned char *bytes, int length,
 	    const char *file, int line)
 }
 declare 24 {
     Tcl_Obj *Tcl_DbNewDoubleObj(double doubleValue, const char *file,
 	    int line)
@@ -118,28 +117,27 @@
 }
 declare 25 {
     Tcl_Obj *Tcl_DbNewListObj(int objc, Tcl_Obj *const *objv,
 	    const char *file, int line)
 }
-# Removed in 9.0 (changed to macro):
-#declare 26 {
-#    Tcl_Obj *Tcl_DbNewLongObj(long longValue, const char *file, int line)
-#}
+declare 26 {deprecated {No longer in use, changed to macro}} {
+    Tcl_Obj *Tcl_DbNewLongObj(long longValue, const char *file, int line)
+}
 declare 27 {
     Tcl_Obj *Tcl_DbNewObj(const char *file, int line)
 }
 declare 28 {
-    Tcl_Obj *Tcl_DbNewStringObj(const char *bytes, size_t length,
+    Tcl_Obj *Tcl_DbNewStringObj(const char *bytes, int length,
 	    const char *file, int line)
 }
 declare 29 {
     Tcl_Obj *Tcl_DuplicateObj(Tcl_Obj *objPtr)
 }
-# Removed in 9.0
-#declare 30 {
-#    void TclFreeObj(Tcl_Obj *objPtr)
-#}
+# Only available as stub-entry, for backwards-compatible stub-enabled extensions
+declare 30 {
+    void TclOldFreeObj(Tcl_Obj *objPtr)
+}
 declare 31 {
     int Tcl_GetBoolean(Tcl_Interp *interp, const char *src, int *boolPtr)
 }
 declare 32 {
     int Tcl_GetBooleanFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
@@ -153,15 +151,14 @@
 }
 declare 35 {
     int Tcl_GetDoubleFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    double *doublePtr)
 }
-# Removed in 9.0, replaced by macro.
-#declare 36 {deprecated {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)
-#}
+declare 36 {deprecated {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)
+}
 declare 37 {
     int Tcl_GetInt(Tcl_Interp *interp, const char *src, int *intPtr)
 }
 declare 38 {
     int Tcl_GetIntFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *intPtr)
@@ -168,11 +165,11 @@
 }
 declare 39 {
     int Tcl_GetLongFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, long *longPtr)
 }
 declare 40 {
-    const Tcl_ObjType *Tcl_GetObjType(const char *typeName)
+    CONST86 Tcl_ObjType *Tcl_GetObjType(const char *typeName)
 }
 declare 41 {
     char *Tcl_GetStringFromObj(Tcl_Obj *objPtr, int *lengthPtr)
 }
 declare 42 {
@@ -200,77 +197,69 @@
 }
 declare 48 {
     int Tcl_ListObjReplace(Tcl_Interp *interp, Tcl_Obj *listPtr, int first,
 	    int count, int objc, Tcl_Obj *const objv[])
 }
-# Removed in 9.0 (changed to macro):
-#declare 49 {
-#    Tcl_Obj *Tcl_NewBooleanObj(int boolValue)
-#}
+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, size_t length)
+    Tcl_Obj *Tcl_NewByteArrayObj(const unsigned char *bytes, int length)
 }
 declare 51 {
     Tcl_Obj *Tcl_NewDoubleObj(double doubleValue)
 }
-# Removed in 9.0 (changed to macro):
-#declare 52 {
-#    Tcl_Obj *Tcl_NewIntObj(int intValue)
-#}
+declare 52 {deprecated {No longer in use, changed to macro}} {
+    Tcl_Obj *Tcl_NewIntObj(int intValue)
+}
 declare 53 {
     Tcl_Obj *Tcl_NewListObj(int objc, Tcl_Obj *const objv[])
 }
-# Removed in 9.0 (changed to macro):
-#declare 54 {
-#    Tcl_Obj *Tcl_NewLongObj(long longValue)
-#}
+declare 54 {deprecated {No longer in use, changed to macro}} {
+    Tcl_Obj *Tcl_NewLongObj(long longValue)
+}
 declare 55 {
     Tcl_Obj *Tcl_NewObj(void)
 }
 declare 56 {
-    Tcl_Obj *Tcl_NewStringObj(const char *bytes, size_t length)
+    Tcl_Obj *Tcl_NewStringObj(const char *bytes, int length)
 }
-# Removed in 9.0 (changed to macro):
-#declare 57 {
-#    void Tcl_SetBooleanObj(Tcl_Obj *objPtr, int boolValue)
-#}
+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, size_t length)
+    unsigned char *Tcl_SetByteArrayLength(Tcl_Obj *objPtr, int length)
 }
 declare 59 {
     void Tcl_SetByteArrayObj(Tcl_Obj *objPtr, const unsigned char *bytes,
-	    size_t length)
+	    int length)
 }
 declare 60 {
     void Tcl_SetDoubleObj(Tcl_Obj *objPtr, double doubleValue)
 }
-# Removed in 9.0 (changed to macro):
-#declare 61 {
-#    void Tcl_SetIntObj(Tcl_Obj *objPtr, int intValue)
-#}
+declare 61 {deprecated {No longer in use, changed to macro}} {
+    void Tcl_SetIntObj(Tcl_Obj *objPtr, int intValue)
+}
 declare 62 {
     void Tcl_SetListObj(Tcl_Obj *objPtr, int objc, Tcl_Obj *const objv[])
 }
-# Removed in 9.0 (changed to macro):
-#declare 63 {
-#    void Tcl_SetLongObj(Tcl_Obj *objPtr, long longValue)
-#}
+declare 63 {deprecated {No longer in use, changed to macro}} {
+    void Tcl_SetLongObj(Tcl_Obj *objPtr, long longValue)
+}
 declare 64 {
-    void Tcl_SetObjLength(Tcl_Obj *objPtr, size_t length)
+    void Tcl_SetObjLength(Tcl_Obj *objPtr, int length)
 }
 declare 65 {
-    void Tcl_SetStringObj(Tcl_Obj *objPtr, const char *bytes, size_t length)
-}
-# Removed in 9.0, replaced by macro.
-#declare 66 {deprecated {No longer in use, changed to macro}} {
-#    void Tcl_AddErrorInfo(Tcl_Interp *interp, const char *message)
-#}
-# Removed in 9.0, replaced by macro.
-#declare 67 {deprecated {No longer in use, changed to macro}} {
-#    void Tcl_AddObjErrorInfo(Tcl_Interp *interp, const char *message,
-#	    int length)
-#}
+    void Tcl_SetStringObj(Tcl_Obj *objPtr, const char *bytes, int length)
+}
+declare 66 {deprecated {No longer in use, changed to macro}} {
+    void Tcl_AddErrorInfo(Tcl_Interp *interp, const char *message)
+}
+declare 67 {deprecated {No longer in use, changed to macro}} {
+    void Tcl_AddObjErrorInfo(Tcl_Interp *interp, const char *message,
+	    int length)
+}
 declare 68 {
     void Tcl_AllowExceptions(Tcl_Interp *interp)
 }
 declare 69 {
     void Tcl_AppendElement(Tcl_Interp *interp, const char *element)
@@ -278,11 +267,11 @@
 declare 70 {
     void Tcl_AppendResult(Tcl_Interp *interp, ...)
 }
 declare 71 {
     Tcl_AsyncHandler Tcl_AsyncCreate(Tcl_AsyncProc *proc,
-	    void *clientData)
+	    ClientData clientData)
 }
 declare 72 {
     void Tcl_AsyncDelete(Tcl_AsyncHandler async)
 }
 declare 73 {
@@ -292,28 +281,26 @@
     void Tcl_AsyncMark(Tcl_AsyncHandler async)
 }
 declare 75 {
     int Tcl_AsyncReady(void)
 }
-# Removed in 9.0
-#declare 76 {deprecated {No longer in use, changed to macro}} {
-#    void Tcl_BackgroundError(Tcl_Interp *interp)
-#}
-# Removed in 9.0:
-#declare 77 {deprecated {Use Tcl_UtfBackslash}} {
-#    char Tcl_Backslash(const char *src, int *readPtr)
-#}
+declare 76 {deprecated {No longer in use, changed to macro}} {
+    void Tcl_BackgroundError(Tcl_Interp *interp)
+}
+declare 77 {deprecated {Use Tcl_UtfBackslash}} {
+    char Tcl_Backslash(const char *src, int *readPtr)
+}
 declare 78 {
     int Tcl_BadChannelOption(Tcl_Interp *interp, const char *optionName,
 	    const char *optionList)
 }
 declare 79 {
     void Tcl_CallWhenDeleted(Tcl_Interp *interp, Tcl_InterpDeleteProc *proc,
-	    void *clientData)
+	    ClientData clientData)
 }
 declare 80 {
-    void Tcl_CancelIdleCall(Tcl_IdleProc *idleProc, void *clientData)
+    void Tcl_CancelIdleCall(Tcl_IdleProc *idleProc, ClientData clientData)
 }
 declare 81 {
     int Tcl_Close(Tcl_Interp *interp, Tcl_Channel chan)
 }
 declare 82 {
@@ -321,14 +308,14 @@
 }
 declare 83 {
     char *Tcl_Concat(int argc, const char *const *argv)
 }
 declare 84 {
-    size_t Tcl_ConvertElement(const char *src, char *dst, int flags)
+    int Tcl_ConvertElement(const char *src, char *dst, int flags)
 }
 declare 85 {
-    size_t Tcl_ConvertCountedElement(const char *src, size_t length, char *dst,
+    int Tcl_ConvertCountedElement(const char *src, int length, char *dst,
 	    int flags)
 }
 declare 86 {
     int Tcl_CreateAlias(Tcl_Interp *slave, const char *slaveCmd,
 	    Tcl_Interp *target, const char *targetCmd, int argc,
@@ -339,85 +326,84 @@
 	    Tcl_Interp *target, const char *targetCmd, int objc,
 	    Tcl_Obj *const objv[])
 }
 declare 88 {
     Tcl_Channel Tcl_CreateChannel(const Tcl_ChannelType *typePtr,
-	    const char *chanName, void *instanceData, int mask)
+	    const char *chanName, ClientData instanceData, int mask)
 }
 declare 89 {
     void Tcl_CreateChannelHandler(Tcl_Channel chan, int mask,
-	    Tcl_ChannelProc *proc, void *clientData)
+	    Tcl_ChannelProc *proc, ClientData clientData)
 }
 declare 90 {
     void Tcl_CreateCloseHandler(Tcl_Channel chan, Tcl_CloseProc *proc,
-	    void *clientData)
+	    ClientData clientData)
 }
 declare 91 {
     Tcl_Command Tcl_CreateCommand(Tcl_Interp *interp, const char *cmdName,
-	    Tcl_CmdProc *proc, void *clientData,
+	    Tcl_CmdProc *proc, ClientData clientData,
 	    Tcl_CmdDeleteProc *deleteProc)
 }
 declare 92 {
     void Tcl_CreateEventSource(Tcl_EventSetupProc *setupProc,
-	    Tcl_EventCheckProc *checkProc, void *clientData)
+	    Tcl_EventCheckProc *checkProc, ClientData clientData)
 }
 declare 93 {
-    void Tcl_CreateExitHandler(Tcl_ExitProc *proc, void *clientData)
+    void Tcl_CreateExitHandler(Tcl_ExitProc *proc, ClientData clientData)
 }
 declare 94 {
     Tcl_Interp *Tcl_CreateInterp(void)
 }
-# Removed in 9.0:
-#declare 95 {deprecated {}} {
-#    void Tcl_CreateMathFunc(Tcl_Interp *interp, const char *name,
-#	    int numArgs, Tcl_ValueType *argTypes,
-#	    Tcl_MathProc *proc, void *clientData)
-#}
+declare 95 {deprecated {}} {
+    void Tcl_CreateMathFunc(Tcl_Interp *interp, const char *name,
+	    int numArgs, Tcl_ValueType *argTypes,
+	    Tcl_MathProc *proc, ClientData clientData)
+}
 declare 96 {
     Tcl_Command Tcl_CreateObjCommand(Tcl_Interp *interp,
 	    const char *cmdName,
-	    Tcl_ObjCmdProc *proc, void *clientData,
+	    Tcl_ObjCmdProc *proc, ClientData clientData,
 	    Tcl_CmdDeleteProc *deleteProc)
 }
 declare 97 {
     Tcl_Interp *Tcl_CreateSlave(Tcl_Interp *interp, const char *slaveName,
 	    int isSafe)
 }
 declare 98 {
     Tcl_TimerToken Tcl_CreateTimerHandler(int milliseconds,
-	    Tcl_TimerProc *proc, void *clientData)
+	    Tcl_TimerProc *proc, ClientData clientData)
 }
 declare 99 {
     Tcl_Trace Tcl_CreateTrace(Tcl_Interp *interp, int level,
-	    Tcl_CmdTraceProc *proc, void *clientData)
+	    Tcl_CmdTraceProc *proc, ClientData clientData)
 }
 declare 100 {
     void Tcl_DeleteAssocData(Tcl_Interp *interp, const char *name)
 }
 declare 101 {
     void Tcl_DeleteChannelHandler(Tcl_Channel chan, Tcl_ChannelProc *proc,
-	    void *clientData)
+	    ClientData clientData)
 }
 declare 102 {
     void Tcl_DeleteCloseHandler(Tcl_Channel chan, Tcl_CloseProc *proc,
-	    void *clientData)
+	    ClientData clientData)
 }
 declare 103 {
     int Tcl_DeleteCommand(Tcl_Interp *interp, const char *cmdName)
 }
 declare 104 {
     int Tcl_DeleteCommandFromToken(Tcl_Interp *interp, Tcl_Command command)
 }
 declare 105 {
-    void Tcl_DeleteEvents(Tcl_EventDeleteProc *proc, void *clientData)
+    void Tcl_DeleteEvents(Tcl_EventDeleteProc *proc, ClientData clientData)
 }
 declare 106 {
     void Tcl_DeleteEventSource(Tcl_EventSetupProc *setupProc,
-	    Tcl_EventCheckProc *checkProc, void *clientData)
+	    Tcl_EventCheckProc *checkProc, ClientData clientData)
 }
 declare 107 {
-    void Tcl_DeleteExitHandler(Tcl_ExitProc *proc, void *clientData)
+    void Tcl_DeleteExitHandler(Tcl_ExitProc *proc, ClientData clientData)
 }
 declare 108 {
     void Tcl_DeleteHashEntry(Tcl_HashEntry *entryPtr)
 }
 declare 109 {
@@ -435,20 +421,20 @@
 declare 113 {
     void Tcl_DeleteTrace(Tcl_Interp *interp, Tcl_Trace trace)
 }
 declare 114 {
     void Tcl_DontCallWhenDeleted(Tcl_Interp *interp,
-	    Tcl_InterpDeleteProc *proc, void *clientData)
+	    Tcl_InterpDeleteProc *proc, ClientData clientData)
 }
 declare 115 {
     int Tcl_DoOneEvent(int flags)
 }
 declare 116 {
-    void Tcl_DoWhenIdle(Tcl_IdleProc *proc, void *clientData)
+    void Tcl_DoWhenIdle(Tcl_IdleProc *proc, ClientData clientData)
 }
 declare 117 {
-    char *Tcl_DStringAppend(Tcl_DString *dsPtr, const char *bytes, size_t length)
+    char *Tcl_DStringAppend(Tcl_DString *dsPtr, const char *bytes, int length)
 }
 declare 118 {
     char *Tcl_DStringAppendElement(Tcl_DString *dsPtr, const char *element)
 }
 declare 119 {
@@ -465,11 +451,11 @@
 }
 declare 123 {
     void Tcl_DStringResult(Tcl_Interp *interp, Tcl_DString *dsPtr)
 }
 declare 124 {
-    void Tcl_DStringSetLength(Tcl_DString *dsPtr, size_t length)
+    void Tcl_DStringSetLength(Tcl_DString *dsPtr, int length)
 }
 declare 125 {
     void Tcl_DStringStartSublist(Tcl_DString *dsPtr)
 }
 declare 126 {
@@ -479,23 +465,21 @@
     const char *Tcl_ErrnoId(void)
 }
 declare 128 {
     const char *Tcl_ErrnoMsg(int err)
 }
-# Removed in 9.0, replaced by macro.
-#declare 129 {
-#    int Tcl_Eval(Tcl_Interp *interp, const char *script)
-#}
+declare 129 {
+    int Tcl_Eval(Tcl_Interp *interp, const char *script)
+}
 declare 130 {
     int Tcl_EvalFile(Tcl_Interp *interp, const char *fileName)
 }
-# Removed in 9.0, replaced by macro.
-#declare 131 {
-#    int Tcl_EvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr)
-#}
+declare 131 {deprecated {No longer in use, changed to macro}} {
+    int Tcl_EvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr)
+}
 declare 132 {
-    void Tcl_EventuallyFree(void *clientData, Tcl_FreeProc *freeProc)
+    void Tcl_EventuallyFree(ClientData clientData, Tcl_FreeProc *freeProc)
 }
 declare 133 {
     TCL_NORETURN void Tcl_Exit(int status)
 }
 declare 134 {
@@ -528,14 +512,13 @@
     int Tcl_ExprString(Tcl_Interp *interp, const char *expr)
 }
 declare 143 {
     void Tcl_Finalize(void)
 }
-# Removed in 9.0 (stub entry only)
-#declare 144 {
-#    void Tcl_FindExecutable(const char *argv0)
-#}
+declare 144 {nostub {Don't use this function in a stub-enabled extension}} {
+    void Tcl_FindExecutable(const char *argv0)
+}
 declare 145 {
     Tcl_HashEntry *Tcl_FirstHashEntry(Tcl_HashTable *tablePtr,
 	    Tcl_HashSearch *searchPtr)
 }
 declare 146 {
@@ -553,11 +536,11 @@
     int Tcl_GetAliasObj(Tcl_Interp *interp, const char *slaveCmd,
 	    Tcl_Interp **targetInterpPtr, const char **targetCmdPtr,
 	    int *objcPtr, Tcl_Obj ***objv)
 }
 declare 150 {
-    void *Tcl_GetAssocData(Tcl_Interp *interp, const char *name,
+    ClientData Tcl_GetAssocData(Tcl_Interp *interp, const char *name,
 	    Tcl_InterpDeleteProc **procPtr)
 }
 declare 151 {
     Tcl_Channel Tcl_GetChannel(Tcl_Interp *interp, const char *chanName,
 	    int *modePtr)
@@ -565,14 +548,14 @@
 declare 152 {
     int Tcl_GetChannelBufferSize(Tcl_Channel chan)
 }
 declare 153 {
     int Tcl_GetChannelHandle(Tcl_Channel chan, int direction,
-	    void **handlePtr)
+	    ClientData *handlePtr)
 }
 declare 154 {
-    void *Tcl_GetChannelInstanceData(Tcl_Channel chan)
+    ClientData Tcl_GetChannelInstanceData(Tcl_Channel chan)
 }
 declare 155 {
     int Tcl_GetChannelMode(Tcl_Channel chan)
 }
 declare 156 {
@@ -581,11 +564,11 @@
 declare 157 {
     int Tcl_GetChannelOption(Tcl_Interp *interp, Tcl_Channel chan,
 	    const char *optionName, Tcl_DString *dsPtr)
 }
 declare 158 {
-    const Tcl_ChannelType *Tcl_GetChannelType(Tcl_Channel chan)
+    CONST86 Tcl_ChannelType *Tcl_GetChannelType(Tcl_Channel chan)
 }
 declare 159 {
     int Tcl_GetCommandInfo(Tcl_Interp *interp, const char *cmdName,
 	    Tcl_CmdInfo *infoPtr)
 }
@@ -615,22 +598,22 @@
 # Tcl_GetOpenFile is only available on unix, but it is a part of the old
 # generic interface, so we inlcude it here for compatibility reasons.
 
 declare 167 unix {
     int Tcl_GetOpenFile(Tcl_Interp *interp, const char *chanID, int forWriting,
-	    int checkUsage, void **filePtr)
+	    int checkUsage, ClientData *filePtr)
 }
 # Obsolete.  Should now use Tcl_FSGetPathType which is objectified
 # and therefore usually faster.
 declare 168 {
     Tcl_PathType Tcl_GetPathType(const char *path)
 }
 declare 169 {
-    size_t Tcl_Gets(Tcl_Channel chan, Tcl_DString *dsPtr)
+    int Tcl_Gets(Tcl_Channel chan, Tcl_DString *dsPtr)
 }
 declare 170 {
-    size_t Tcl_GetsObj(Tcl_Channel chan, Tcl_Obj *objPtr)
+    int Tcl_GetsObj(Tcl_Channel chan, Tcl_Obj *objPtr)
 }
 declare 171 {
     int Tcl_GetServiceMode(void)
 }
 declare 172 {
@@ -637,31 +620,27 @@
     Tcl_Interp *Tcl_GetSlave(Tcl_Interp *interp, const char *slaveName)
 }
 declare 173 {
     Tcl_Channel Tcl_GetStdChannel(int type)
 }
-# Removed in 9.0, replaced by macro.
-#declare 174 {
-#    const char *Tcl_GetStringResult(Tcl_Interp *interp)
-#}
-# Removed in 9.0, replaced by macro.
-#declare 175 {deprecated {No longer in use, changed to macro}} {
-#    const char *Tcl_GetVar(Tcl_Interp *interp, const char *varName,
-#	    int flags)
-#}
+declare 174 {
+    const char *Tcl_GetStringResult(Tcl_Interp *interp)
+}
+declare 175 {deprecated {No longer in use, changed to macro}} {
+    const char *Tcl_GetVar(Tcl_Interp *interp, const char *varName,
+	    int flags)
+}
 declare 176 {
     const char *Tcl_GetVar2(Tcl_Interp *interp, const char *part1,
 	    const char *part2, int flags)
 }
-# Removed in 9.0, replaced by macro.
-#declare 177 {
-#    int Tcl_GlobalEval(Tcl_Interp *interp, const char *command)
-#}
-# Removed in 9.0, replaced by macro.
-#declare 178 {
-#    int Tcl_GlobalEvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr)
-#}
+declare 177 {
+    int Tcl_GlobalEval(Tcl_Interp *interp, const char *command)
+}
+declare 178 {deprecated {No longer in use, changed to macro}} {
+    int Tcl_GlobalEvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr)
+}
 declare 179 {
     int Tcl_HideCommand(Tcl_Interp *interp, const char *cmdName,
 	    const char *hiddenCmdToken)
 }
 declare 180 {
@@ -696,17 +675,17 @@
 #  declare 188 {
 #	Tcl_MainLoop
 #  }
 
 declare 189 {
-    Tcl_Channel Tcl_MakeFileChannel(void *handle, int mode)
+    Tcl_Channel Tcl_MakeFileChannel(ClientData handle, int mode)
 }
 declare 190 {
     int Tcl_MakeSafe(Tcl_Interp *interp)
 }
 declare 191 {
-    Tcl_Channel Tcl_MakeTcpClientChannel(void *tcpSocket)
+    Tcl_Channel Tcl_MakeTcpClientChannel(ClientData tcpSocket)
 }
 declare 192 {
     char *Tcl_Merge(int argc, const char *const *argv)
 }
 declare 193 {
@@ -737,14 +716,14 @@
 	    const char *address, const char *myaddr, int myport, int async)
 }
 declare 200 {
     Tcl_Channel Tcl_OpenTcpServer(Tcl_Interp *interp, int port,
 	    const char *host, Tcl_TcpAcceptProc *acceptProc,
-	    void *callbackData)
+	    ClientData callbackData)
 }
 declare 201 {
-    void Tcl_Preserve(void *data)
+    void Tcl_Preserve(ClientData data)
 }
 declare 202 {
     void Tcl_PrintDouble(Tcl_Interp *interp, double value, char *dst)
 }
 declare 203 {
@@ -755,11 +734,11 @@
 }
 declare 205 {
     void Tcl_QueueEvent(Tcl_Event *evPtr, Tcl_QueuePosition position)
 }
 declare 206 {
-    size_t Tcl_Read(Tcl_Channel chan, char *bufPtr, size_t toRead)
+    int Tcl_Read(Tcl_Channel chan, char *bufPtr, int toRead)
 }
 declare 207 {
     void Tcl_ReapDetachedProcs(void)
 }
 declare 208 {
@@ -784,38 +763,37 @@
 declare 214 {
     int Tcl_RegExpMatch(Tcl_Interp *interp, const char *text,
 	    const char *pattern)
 }
 declare 215 {
-    void Tcl_RegExpRange(Tcl_RegExp regexp, size_t index,
+    void Tcl_RegExpRange(Tcl_RegExp regexp, int index,
 	    const char **startPtr, const char **endPtr)
 }
 declare 216 {
-    void Tcl_Release(void *clientData)
+    void Tcl_Release(ClientData clientData)
 }
 declare 217 {
     void Tcl_ResetResult(Tcl_Interp *interp)
 }
 declare 218 {
-    size_t Tcl_ScanElement(const char *src, int *flagPtr)
+    int Tcl_ScanElement(const char *src, int *flagPtr)
 }
 declare 219 {
-    size_t Tcl_ScanCountedElement(const char *src, size_t length, int *flagPtr)
+    int Tcl_ScanCountedElement(const char *src, int length, int *flagPtr)
 }
-# Removed in 9.0:
-#declare 220 {
-#    int Tcl_SeekOld(Tcl_Channel chan, int offset, int mode)
-#}
+declare 220 {deprecated {}} {
+    int Tcl_SeekOld(Tcl_Channel chan, int offset, int mode)
+}
 declare 221 {
     int Tcl_ServiceAll(void)
 }
 declare 222 {
     int Tcl_ServiceEvent(int flags)
 }
 declare 223 {
     void Tcl_SetAssocData(Tcl_Interp *interp, const char *name,
-	    Tcl_InterpDeleteProc *proc, void *clientData)
+	    Tcl_InterpDeleteProc *proc, ClientData clientData)
 }
 declare 224 {
     void Tcl_SetChannelBufferSize(Tcl_Channel chan, int sz)
 }
 declare 225 {
@@ -833,22 +811,20 @@
     void Tcl_SetErrorCode(Tcl_Interp *interp, ...)
 }
 declare 229 {
     void Tcl_SetMaxBlockTime(const Tcl_Time *timePtr)
 }
-# Removed in 9.0 (stub entry only)
-#declare 230 {
-#    void Tcl_SetPanicProc(TCL_NORETURN1 Tcl_PanicProc *panicProc)
-#}
+declare 230 {nostub {Don't use this function in a stub-enabled extension}} {
+    void Tcl_SetPanicProc(TCL_NORETURN1 Tcl_PanicProc *panicProc)
+}
 declare 231 {
     int Tcl_SetRecursionLimit(Tcl_Interp *interp, int depth)
 }
-# Removed in 9.0, replaced by macro.
-#declare 232 {
-#    void Tcl_SetResult(Tcl_Interp *interp, char *result,
-#	    Tcl_FreeProc *freeProc)
-#}
+declare 232 {
+    void Tcl_SetResult(Tcl_Interp *interp, char *result,
+	    Tcl_FreeProc *freeProc)
+}
 declare 233 {
     int Tcl_SetServiceMode(int mode)
 }
 declare 234 {
     void Tcl_SetObjErrorCode(Tcl_Interp *interp, Tcl_Obj *errorObjPtr)
@@ -857,15 +833,14 @@
     void Tcl_SetObjResult(Tcl_Interp *interp, Tcl_Obj *resultObjPtr)
 }
 declare 236 {
     void Tcl_SetStdChannel(Tcl_Channel channel, int type)
 }
-# Removed in 9.0, replaced by macro.
-#declare 237 {deprecated {No longer in use, changed to macro}} {
-#    const char *Tcl_SetVar(Tcl_Interp *interp, const char *varName,
-#	    const char *newValue, int flags)
-#}
+declare 237 {deprecated {No longer in use, changed to macro}} {
+    const char *Tcl_SetVar(Tcl_Interp *interp, const char *varName,
+	    const char *newValue, int flags)
+}
 declare 238 {
     const char *Tcl_SetVar2(Tcl_Interp *interp, const char *part1,
 	    const char *part2, const char *newValue, int flags)
 }
 declare 239 {
@@ -883,90 +858,82 @@
 }
 # Obsolete, use Tcl_FSSplitPath
 declare 243 {
     void Tcl_SplitPath(const char *path, int *argcPtr, const char ***argvPtr)
 }
-# Removed in 9.0 (stub entry only)
-#declare 244  {
-#    void Tcl_StaticPackage(Tcl_Interp *interp, const char *pkgName,
-#	    Tcl_PackageInitProc *initProc, Tcl_PackageInitProc *safeInitProc)
-#}
-# Removed in 9.0 (stub entry only)
-#declare 245 {
-#    int Tcl_StringMatch(const char *str, const char *pattern)
-#}
-# Removed in 9.0:
-#declare 246 {
-#    int Tcl_TellOld(Tcl_Channel chan)
-#}
-# Removed in 9.0, replaced by macro.
-#declare 247 {deprecated {No longer in use, changed to macro}} {
-#    int Tcl_TraceVar(Tcl_Interp *interp, const char *varName, int flags,
-#	    Tcl_VarTraceProc *proc, ClientData clientData)
-#}
+declare 244 {nostub {Don't use this function in a stub-enabled extension}} {
+    void Tcl_StaticPackage(Tcl_Interp *interp, const char *pkgName,
+	    Tcl_PackageInitProc *initProc, Tcl_PackageInitProc *safeInitProc)
+}
+declare 245 {deprecated {No longer in use, changed to macro}} {
+    int Tcl_StringMatch(const char *str, const char *pattern)
+}
+declare 246 {deprecated {}} {
+    int Tcl_TellOld(Tcl_Channel chan)
+}
+declare 247 {deprecated {No longer in use, changed to macro}} {
+    int Tcl_TraceVar(Tcl_Interp *interp, const char *varName, int flags,
+	    Tcl_VarTraceProc *proc, ClientData clientData)
+}
 declare 248 {
     int Tcl_TraceVar2(Tcl_Interp *interp, const char *part1, const char *part2,
-	    int flags, Tcl_VarTraceProc *proc, void *clientData)
+	    int flags, Tcl_VarTraceProc *proc, ClientData clientData)
 }
 declare 249 {
     char *Tcl_TranslateFileName(Tcl_Interp *interp, const char *name,
 	    Tcl_DString *bufferPtr)
 }
 declare 250 {
-    size_t Tcl_Ungets(Tcl_Channel chan, const char *str, size_t len, int atHead)
+    int Tcl_Ungets(Tcl_Channel chan, const char *str, int len, int atHead)
 }
 declare 251 {
     void Tcl_UnlinkVar(Tcl_Interp *interp, const char *varName)
 }
 declare 252 {
     int Tcl_UnregisterChannel(Tcl_Interp *interp, Tcl_Channel chan)
 }
-# Removed in 9.0, replaced by macro.
-#declare 253 {deprecated {No longer in use, changed to macro}} {
-#    int Tcl_UnsetVar(Tcl_Interp *interp, const char *varName, int flags)
-#}
+declare 253 {deprecated {No longer in use, changed to macro}} {
+    int Tcl_UnsetVar(Tcl_Interp *interp, const char *varName, int flags)
+}
 declare 254 {
     int Tcl_UnsetVar2(Tcl_Interp *interp, const char *part1, const char *part2,
 	    int flags)
 }
-# Removed in 9.0, replaced by macro.
-#declare 255 {deprecated {No longer in use, changed to macro}} {
-#    void Tcl_UntraceVar(Tcl_Interp *interp, const char *varName, int flags,
-#	    Tcl_VarTraceProc *proc, ClientData clientData)
-#}
+declare 255 {deprecated {No longer in use, changed to macro}} {
+    void Tcl_UntraceVar(Tcl_Interp *interp, const char *varName, int flags,
+	    Tcl_VarTraceProc *proc, ClientData clientData)
+}
 declare 256 {
     void Tcl_UntraceVar2(Tcl_Interp *interp, const char *part1,
 	    const char *part2, int flags, Tcl_VarTraceProc *proc,
-	    void *clientData)
+	    ClientData clientData)
 }
 declare 257 {
     void Tcl_UpdateLinkedVar(Tcl_Interp *interp, const char *varName)
 }
-# Removed in 9.0, replaced by macro.
-#declare 258 {deprecated {No longer in use, changed to macro}} {
-#    int Tcl_UpVar(Tcl_Interp *interp, const char *frameName,
-#	    const char *varName, const char *localName, int flags)
-#}
+declare 258 {deprecated {No longer in use, changed to macro}} {
+    int Tcl_UpVar(Tcl_Interp *interp, const char *frameName,
+	    const char *varName, const char *localName, int flags)
+}
 declare 259 {
     int Tcl_UpVar2(Tcl_Interp *interp, const char *frameName, const char *part1,
 	    const char *part2, const char *localName, int flags)
 }
 declare 260 {
     int Tcl_VarEval(Tcl_Interp *interp, ...)
 }
-# Removed in 9.0, replaced by macro.
-#declare 261 {deprecated {No longer in use, changed to macro}} {
-#    ClientData Tcl_VarTraceInfo(Tcl_Interp *interp, const char *varName,
-#	    int flags, Tcl_VarTraceProc *procPtr, ClientData prevClientData)
-#}
+declare 261 {deprecated {No longer in use, changed to macro}} {
+    ClientData Tcl_VarTraceInfo(Tcl_Interp *interp, const char *varName,
+	    int flags, Tcl_VarTraceProc *procPtr, ClientData prevClientData)
+}
 declare 262 {
-    void *Tcl_VarTraceInfo2(Tcl_Interp *interp, const char *part1,
+    ClientData Tcl_VarTraceInfo2(Tcl_Interp *interp, const char *part1,
 	    const char *part2, int flags, Tcl_VarTraceProc *procPtr,
-	    void *prevClientData)
+	    ClientData prevClientData)
 }
 declare 263 {
-    size_t Tcl_Write(Tcl_Channel chan, const char *s, size_t slen)
+    int Tcl_Write(Tcl_Channel chan, const char *s, int slen)
 }
 declare 264 {
     void Tcl_WrongNumArgs(Tcl_Interp *interp, int objc,
 	    Tcl_Obj *const objv[], const char *message)
 }
@@ -974,61 +941,53 @@
     int Tcl_DumpActiveMemory(const char *fileName)
 }
 declare 266 {
     void Tcl_ValidateAllMemory(const char *file, int line)
 }
-# Removed in 9.0:
-#declare 267 {
-#    void Tcl_AppendResultVA(Tcl_Interp *interp, va_list argList)
-#}
-# Removed in 9.0:
-#declare 268 {
-#    void Tcl_AppendStringsToObjVA(Tcl_Obj *objPtr, va_list argList)
-#}
+declare 267 {deprecated {see TIP #422}} {
+    void Tcl_AppendResultVA(Tcl_Interp *interp, va_list argList)
+}
+declare 268 {deprecated {see TIP #422}} {
+    void Tcl_AppendStringsToObjVA(Tcl_Obj *objPtr, va_list argList)
+}
 declare 269 {
     char *Tcl_HashStats(Tcl_HashTable *tablePtr)
 }
 declare 270 {
     const char *Tcl_ParseVar(Tcl_Interp *interp, const char *start,
 	    const char **termPtr)
 }
-# Removed in 9.0, replaced by macro.
-#declare 271 {deprecated {No longer in use, changed to macro}} {
-#    const char *Tcl_PkgPresent(Tcl_Interp *interp, const char *name,
-#	    const char *version, int exact)
-#}
+declare 271 {deprecated {No longer in use, changed to macro}} {
+    const char *Tcl_PkgPresent(Tcl_Interp *interp, const char *name,
+	    const char *version, int exact)
+}
 declare 272 {
     const char *Tcl_PkgPresentEx(Tcl_Interp *interp,
 	    const char *name, const char *version, int exact,
 	    void *clientDataPtr)
 }
-# Removed in 9.0, replaced by macro.
-#declare 273 {deprecated {No longer in use, changed to macro}} {
-#    int Tcl_PkgProvide(Tcl_Interp *interp, const char *name,
-#	    const char *version)
-#}
+declare 273 {deprecated {No longer in use, changed to macro}} {
+    int Tcl_PkgProvide(Tcl_Interp *interp, const char *name,
+	    const char *version)
+}
 # TIP #268: The internally used new Require function is in slot 573.
-# Removed in 9.0, replaced by macro.
-#declare 274 {deprecated {No longer in use, changed to macro}} {
-#    const char *Tcl_PkgRequire(Tcl_Interp *interp, const char *name,
-#	    const char *version, int exact)
-#}
-# Removed in 9.0:
-#declare 275 {
-#    void Tcl_SetErrorCodeVA(Tcl_Interp *interp, va_list argList)
-#}
-# Removed in 9.0:
-#declare 276 {
-#    int  Tcl_VarEvalVA(Tcl_Interp *interp, va_list argList)
-#}
+declare 274 {deprecated {No longer in use, changed to macro}} {
+    const char *Tcl_PkgRequire(Tcl_Interp *interp, const char *name,
+	    const char *version, int exact)
+}
+declare 275 {deprecated {see TIP #422}} {
+    void Tcl_SetErrorCodeVA(Tcl_Interp *interp, va_list argList)
+}
+declare 276 {deprecated {see TIP #422}} {
+    int  Tcl_VarEvalVA(Tcl_Interp *interp, va_list argList)
+}
 declare 277 {
     Tcl_Pid Tcl_WaitPid(Tcl_Pid pid, int *statPtr, int options)
 }
-# Removed in 9.0:
-#declare 278 {
-#    TCL_NORETURN void Tcl_PanicVA(const char *format, va_list argList)
-#}
+declare 278 {deprecated {see TIP #422}} {
+    TCL_NORETURN void Tcl_PanicVA(const char *format, va_list argList)
+}
 declare 279 {
     void Tcl_GetVersion(int *major, int *minor, int *patchLevel, int *type)
 }
 declare 280 {
     void Tcl_InitMemory(Tcl_Interp *interp)
@@ -1048,11 +1007,11 @@
 # (patch usually has no problems to integrate the patch file for the last
 # version into the new one).
 
 declare 281 {
     Tcl_Channel Tcl_StackChannel(Tcl_Interp *interp,
-	    const Tcl_ChannelType *typePtr, void *instanceData,
+	    const Tcl_ChannelType *typePtr, ClientData instanceData,
 	    int mask, Tcl_Channel prevChan)
 }
 declare 282 {
     int Tcl_UnstackChannel(Tcl_Interp *interp, Tcl_Channel chan)
 }
@@ -1076,21 +1035,20 @@
 }
 declare 287 {
     Tcl_Encoding Tcl_CreateEncoding(const Tcl_EncodingType *typePtr)
 }
 declare 288 {
-    void Tcl_CreateThreadExitHandler(Tcl_ExitProc *proc, void *clientData)
+    void Tcl_CreateThreadExitHandler(Tcl_ExitProc *proc, ClientData clientData)
 }
 declare 289 {
-    void Tcl_DeleteThreadExitHandler(Tcl_ExitProc *proc, void *clientData)
+    void Tcl_DeleteThreadExitHandler(Tcl_ExitProc *proc, ClientData clientData)
 }
-# Removed in 9.0, replaced by macro.
-#declare 290 {
-#    void Tcl_DiscardResult(Tcl_SavedResult *statePtr)
-#}
+declare 290 {
+    void Tcl_DiscardResult(Tcl_SavedResult *statePtr)
+}
 declare 291 {
-    int Tcl_EvalEx(Tcl_Interp *interp, const char *script, size_t numBytes,
+    int Tcl_EvalEx(Tcl_Interp *interp, const char *script, int numBytes,
 	    int flags)
 }
 declare 292 {
     int Tcl_EvalObjv(Tcl_Interp *interp, int objc, Tcl_Obj *const objv[],
 	    int flags)
@@ -1101,23 +1059,23 @@
 declare 294 {
     TCL_NORETURN void Tcl_ExitThread(int status)
 }
 declare 295 {
     int Tcl_ExternalToUtf(Tcl_Interp *interp, Tcl_Encoding encoding,
-	    const char *src, size_t srcLen, int flags,
-	    Tcl_EncodingState *statePtr, char *dst, size_t dstLen,
+	    const char *src, int srcLen, int flags,
+	    Tcl_EncodingState *statePtr, char *dst, int dstLen,
 	    int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr)
 }
 declare 296 {
     char *Tcl_ExternalToUtfDString(Tcl_Encoding encoding,
-	    const char *src, size_t srcLen, Tcl_DString *dsPtr)
+	    const char *src, int srcLen, Tcl_DString *dsPtr)
 }
 declare 297 {
     void Tcl_FinalizeThread(void)
 }
 declare 298 {
-    void Tcl_FinalizeNotifier(void *clientData)
+    void Tcl_FinalizeNotifier(ClientData clientData)
 }
 declare 299 {
     void Tcl_FreeEncoding(Tcl_Encoding encoding)
 }
 declare 300 {
@@ -1132,22 +1090,22 @@
 declare 303 {
     void Tcl_GetEncodingNames(Tcl_Interp *interp)
 }
 declare 304 {
     int Tcl_GetIndexFromObjStruct(Tcl_Interp *interp, Tcl_Obj *objPtr,
-	    const void *tablePtr, size_t offset, const char *msg, int flags,
+	    const void *tablePtr, int offset, const char *msg, int flags,
 	    int *indexPtr)
 }
 declare 305 {
-    void *Tcl_GetThreadData(Tcl_ThreadDataKey *keyPtr, size_t size)
+    void *Tcl_GetThreadData(Tcl_ThreadDataKey *keyPtr, int size)
 }
 declare 306 {
     Tcl_Obj *Tcl_GetVar2Ex(Tcl_Interp *interp, const char *part1,
 	    const char *part2, int flags)
 }
 declare 307 {
-    void *Tcl_InitNotifier(void)
+    ClientData Tcl_InitNotifier(void)
 }
 declare 308 {
     void Tcl_MutexLock(Tcl_Mutex *mutexPtr)
 }
 declare 309 {
@@ -1159,24 +1117,22 @@
 declare 311 {
     void Tcl_ConditionWait(Tcl_Condition *condPtr, Tcl_Mutex *mutexPtr,
 	    const Tcl_Time *timePtr)
 }
 declare 312 {
-    size_t Tcl_NumUtfChars(const char *src, size_t length)
+    int Tcl_NumUtfChars(const char *src, int length)
 }
 declare 313 {
-    size_t Tcl_ReadChars(Tcl_Channel channel, Tcl_Obj *objPtr,
-	    size_t charsToRead, int appendFlag)
-}
-# Removed in 9.0, replaced by macro.
-#declare 314 {deprecated {No longer in use, changed to macro}} {
-#    void Tcl_RestoreResult(Tcl_Interp *interp, Tcl_SavedResult *statePtr)
-#}
-# Removed in 9.0, replaced by macro.
-#declare 315 {deprecated {No longer in use, changed to macro}} {
-#    void Tcl_SaveResult(Tcl_Interp *interp, Tcl_SavedResult *statePtr)
-#}
+    int Tcl_ReadChars(Tcl_Channel channel, Tcl_Obj *objPtr, int charsToRead,
+	    int appendFlag)
+}
+declare 314 {
+    void Tcl_RestoreResult(Tcl_Interp *interp, Tcl_SavedResult *statePtr)
+}
+declare 315 {
+    void Tcl_SaveResult(Tcl_Interp *interp, Tcl_SavedResult *statePtr)
+}
 declare 316 {
     int Tcl_SetSystemEncoding(Tcl_Interp *interp, const char *name)
 }
 declare 317 {
     Tcl_Obj *Tcl_SetVar2Ex(Tcl_Interp *interp, const char *part1,
@@ -1188,11 +1144,11 @@
 declare 319 {
     void Tcl_ThreadQueueEvent(Tcl_ThreadId threadId, Tcl_Event *evPtr,
 	    Tcl_QueuePosition position)
 }
 declare 320 {
-    int Tcl_UniCharAtIndex(const char *src, size_t index)
+    int Tcl_UniCharAtIndex(const char *src, int index)
 }
 declare 321 {
     int Tcl_UniCharToLower(int ch)
 }
 declare 322 {
@@ -1203,17 +1159,17 @@
 }
 declare 324 {
     int Tcl_UniCharToUtf(int ch, char *buf)
 }
 declare 325 {
-    const char *Tcl_UtfAtIndex(const char *src, size_t index)
+    const char *Tcl_UtfAtIndex(const char *src, int index)
 }
 declare 326 {
-    int Tcl_UtfCharComplete(const char *src, size_t length)
+    int Tcl_UtfCharComplete(const char *src, int length)
 }
 declare 327 {
-    size_t Tcl_UtfBackslash(const char *src, int *readPtr, char *dst)
+    int Tcl_UtfBackslash(const char *src, int *readPtr, char *dst)
 }
 declare 328 {
     const char *Tcl_UtfFindFirst(const char *src, int ch)
 }
 declare 329 {
@@ -1225,17 +1181,17 @@
 declare 331 {
     const char *Tcl_UtfPrev(const char *src, const char *start)
 }
 declare 332 {
     int Tcl_UtfToExternal(Tcl_Interp *interp, Tcl_Encoding encoding,
-	    const char *src, size_t srcLen, int flags,
-	    Tcl_EncodingState *statePtr, char *dst, size_t dstLen,
+	    const char *src, int srcLen, int flags,
+	    Tcl_EncodingState *statePtr, char *dst, int dstLen,
 	    int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr)
 }
 declare 333 {
     char *Tcl_UtfToExternalDString(Tcl_Encoding encoding,
-	    const char *src, size_t srcLen, Tcl_DString *dsPtr)
+	    const char *src, int srcLen, Tcl_DString *dsPtr)
 }
 declare 334 {
     int Tcl_UtfToLower(char *src)
 }
 declare 335 {
@@ -1246,28 +1202,26 @@
 }
 declare 337 {
     int Tcl_UtfToUpper(char *src)
 }
 declare 338 {
-    size_t Tcl_WriteChars(Tcl_Channel chan, const char *src, size_t srcLen)
+    int Tcl_WriteChars(Tcl_Channel chan, const char *src, int srcLen)
 }
 declare 339 {
-    size_t Tcl_WriteObj(Tcl_Channel chan, Tcl_Obj *objPtr)
+    int Tcl_WriteObj(Tcl_Channel chan, Tcl_Obj *objPtr)
 }
 declare 340 {
     char *Tcl_GetString(Tcl_Obj *objPtr)
 }
-# Removed in 9.0:
-#declare 341 {deprecated {Use Tcl_GetEncodingSearchPath}} {
-#    const char *Tcl_GetDefaultEncodingDir(void)
-#}
-# Removed in 9.0:
-#declare 342 {deprecated {Use Tcl_SetEncodingSearchPath}} {
-#    void Tcl_SetDefaultEncodingDir(const char *path)
-#}
+declare 341 {deprecated {Use Tcl_GetEncodingSearchPath}} {
+    const char *Tcl_GetDefaultEncodingDir(void)
+}
+declare 342 {deprecated {Use Tcl_SetEncodingSearchPath}} {
+    void Tcl_SetDefaultEncodingDir(const char *path)
+}
 declare 343 {
-    void Tcl_AlertNotifier(void *clientData)
+    void Tcl_AlertNotifier(ClientData clientData)
 }
 declare 344 {
     void Tcl_ServiceModeHook(int mode)
 }
 declare 345 {
@@ -1290,61 +1244,59 @@
 }
 declare 351 {
     int Tcl_UniCharIsWordChar(int ch)
 }
 declare 352 {
-    size_t Tcl_UniCharLen(const Tcl_UniChar *uniStr)
+    int Tcl_UniCharLen(const Tcl_UniChar *uniStr)
 }
 declare 353 {
     int Tcl_UniCharNcmp(const Tcl_UniChar *ucs, const Tcl_UniChar *uct,
-	    size_t numChars)
+	    unsigned long numChars)
 }
 declare 354 {
     char *Tcl_UniCharToUtfDString(const Tcl_UniChar *uniStr,
-	    size_t uniLength, Tcl_DString *dsPtr)
+	    int uniLength, Tcl_DString *dsPtr)
 }
 declare 355 {
     Tcl_UniChar *Tcl_UtfToUniCharDString(const char *src,
-	    size_t length, Tcl_DString *dsPtr)
+	    int length, Tcl_DString *dsPtr)
 }
 declare 356 {
     Tcl_RegExp Tcl_GetRegExpFromObj(Tcl_Interp *interp, Tcl_Obj *patObj,
 	    int flags)
 }
-# Removed in 9.0:
-#declare 357 {deprecated {Use Tcl_EvalTokensStandard}} {
-#    Tcl_Obj *Tcl_EvalTokens(Tcl_Interp *interp, Tcl_Token *tokenPtr,
-#	    int count)
-#}
+declare 357 {deprecated {Use Tcl_EvalTokensStandard}} {
+    Tcl_Obj *Tcl_EvalTokens(Tcl_Interp *interp, Tcl_Token *tokenPtr,
+	    int count)
+}
 declare 358 {
     void Tcl_FreeParse(Tcl_Parse *parsePtr)
 }
 declare 359 {
     void Tcl_LogCommandInfo(Tcl_Interp *interp, const char *script,
-	    const char *command, size_t length)
+	    const char *command, int length)
 }
 declare 360 {
-    int Tcl_ParseBraces(Tcl_Interp *interp, const char *start,
-	    size_t numBytes, Tcl_Parse *parsePtr, int append,
-	    const char **termPtr)
+    int Tcl_ParseBraces(Tcl_Interp *interp, const char *start, int numBytes,
+	    Tcl_Parse *parsePtr, int append, const char **termPtr)
 }
 declare 361 {
-    int Tcl_ParseCommand(Tcl_Interp *interp, const char *start,
-	    size_t numBytes, int nested, Tcl_Parse *parsePtr)
+    int Tcl_ParseCommand(Tcl_Interp *interp, const char *start, int numBytes,
+	    int nested, Tcl_Parse *parsePtr)
 }
 declare 362 {
-    int Tcl_ParseExpr(Tcl_Interp *interp, const char *start, size_t numBytes,
+    int Tcl_ParseExpr(Tcl_Interp *interp, const char *start, int numBytes,
 	    Tcl_Parse *parsePtr)
 }
 declare 363 {
     int Tcl_ParseQuotedString(Tcl_Interp *interp, const char *start,
-	    size_t numBytes, Tcl_Parse *parsePtr, int append,
+	    int numBytes, Tcl_Parse *parsePtr, int append,
 	    const char **termPtr)
 }
 declare 364 {
-    int Tcl_ParseVarName(Tcl_Interp *interp, const char *start,
-	    size_t numBytes, Tcl_Parse *parsePtr, int append)
+    int Tcl_ParseVarName(Tcl_Interp *interp, const char *start, int numBytes,
+	    Tcl_Parse *parsePtr, int append)
 }
 # These 4 functions are obsolete, use Tcl_FSGetCwd, Tcl_FSChdir,
 # Tcl_FSAccess and Tcl_FSStat
 declare 365 {
     char *Tcl_GetCwd(Tcl_Interp *interp, Tcl_DString *cwdPtr)
@@ -1357,14 +1309,14 @@
 }
 declare 368 {
     int Tcl_Stat(const char *path, struct stat *bufPtr)
 }
 declare 369 {
-    int Tcl_UtfNcmp(const char *s1, const char *s2, size_t n)
+    int Tcl_UtfNcmp(const char *s1, const char *s2, unsigned long n)
 }
 declare 370 {
-    int Tcl_UtfNcasecmp(const char *s1, const char *s2, size_t n)
+    int Tcl_UtfNcasecmp(const char *s1, const char *s2, unsigned long n)
 }
 declare 371 {
     int Tcl_StringCaseMatch(const char *str, const char *pattern, int nocase)
 }
 declare 372 {
@@ -1379,38 +1331,37 @@
 declare 375 {
     int Tcl_UniCharIsPunct(int ch)
 }
 declare 376 {
     int Tcl_RegExpExecObj(Tcl_Interp *interp, Tcl_RegExp regexp,
-	    Tcl_Obj *textObj, size_t offset, size_t nmatches, int flags)
+	    Tcl_Obj *textObj, int offset, int nmatches, int flags)
 }
 declare 377 {
     void Tcl_RegExpGetInfo(Tcl_RegExp regexp, Tcl_RegExpInfo *infoPtr)
 }
 declare 378 {
-    Tcl_Obj *Tcl_NewUnicodeObj(const Tcl_UniChar *unicode, size_t numChars)
+    Tcl_Obj *Tcl_NewUnicodeObj(const Tcl_UniChar *unicode, int numChars)
 }
 declare 379 {
     void Tcl_SetUnicodeObj(Tcl_Obj *objPtr, const Tcl_UniChar *unicode,
-	    size_t numChars)
+	    int numChars)
 }
 declare 380 {
-    size_t Tcl_GetCharLength(Tcl_Obj *objPtr)
+    int Tcl_GetCharLength(Tcl_Obj *objPtr)
 }
 declare 381 {
-    int Tcl_GetUniChar(Tcl_Obj *objPtr, size_t index)
+    int Tcl_GetUniChar(Tcl_Obj *objPtr, int index)
 }
-# Removed in 9.0, replaced by macro.
-#declare 382 {deprecated {No longer in use, changed to macro}} {
-#    Tcl_UniChar *Tcl_GetUnicode(Tcl_Obj *objPtr)
-#}
+declare 382 {deprecated {No longer in use, changed to macro}} {
+    Tcl_UniChar *Tcl_GetUnicode(Tcl_Obj *objPtr)
+}
 declare 383 {
-    Tcl_Obj *Tcl_GetRange(Tcl_Obj *objPtr, size_t first, size_t last)
+    Tcl_Obj *Tcl_GetRange(Tcl_Obj *objPtr, int first, int last)
 }
 declare 384 {
     void Tcl_AppendUnicodeToObj(Tcl_Obj *objPtr, const Tcl_UniChar *unicode,
-	    size_t length)
+	    int length)
 }
 declare 385 {
     int Tcl_RegExpMatchObj(Tcl_Interp *interp, Tcl_Obj *textObj,
 	    Tcl_Obj *patternObj)
 }
@@ -1425,11 +1376,11 @@
 }
 declare 389 {
     int Tcl_GetChannelNamesEx(Tcl_Interp *interp, const char *pattern)
 }
 declare 390 {
-    int Tcl_ProcObjCmd(void *clientData, Tcl_Interp *interp,
+    int Tcl_ProcObjCmd(ClientData clientData, Tcl_Interp *interp,
 	    int objc, Tcl_Obj *const objv[])
 }
 declare 391 {
     void Tcl_ConditionFinalize(Tcl_Condition *condPtr)
 }
@@ -1436,19 +1387,19 @@
 declare 392 {
     void Tcl_MutexFinalize(Tcl_Mutex *mutex)
 }
 declare 393 {
     int Tcl_CreateThread(Tcl_ThreadId *idPtr, Tcl_ThreadCreateProc *proc,
-	    void *clientData, size_t stackSize, int flags)
+	    ClientData clientData, int stackSize, int flags)
 }
 
 # Introduced in 8.3.2
 declare 394 {
-    size_t Tcl_ReadRaw(Tcl_Channel chan, char *dst, size_t bytesToRead)
+    int Tcl_ReadRaw(Tcl_Channel chan, char *dst, int bytesToRead)
 }
 declare 395 {
-    size_t Tcl_WriteRaw(Tcl_Channel chan, const char *src, size_t srcLen)
+    int Tcl_WriteRaw(Tcl_Channel chan, const char *src, int srcLen)
 }
 declare 396 {
     Tcl_Channel Tcl_GetTopChannel(Tcl_Channel chan)
 }
 declare 397 {
@@ -1532,60 +1483,58 @@
 declare 418 {
     int Tcl_IsChannelExisting(const char *channelName)
 }
 declare 419 {
     int Tcl_UniCharNcasecmp(const Tcl_UniChar *ucs, const Tcl_UniChar *uct,
-	    size_t numChars)
+	    unsigned long numChars)
 }
 declare 420 {
     int Tcl_UniCharCaseMatch(const Tcl_UniChar *uniStr,
 	    const Tcl_UniChar *uniPattern, int nocase)
 }
-# Removed in 9.0, as it is actually a macro:
-#declare 421 {
-#    Tcl_HashEntry *Tcl_FindHashEntry(Tcl_HashTable *tablePtr, const void *key)
-#}
-# Removed in 9.0, as it is actually a macro:
-#declare 422 {
-#    Tcl_HashEntry *Tcl_CreateHashEntry(Tcl_HashTable *tablePtr,
-#	    const void *key, int *newPtr)
-#}
+declare 421 {
+    Tcl_HashEntry *Tcl_FindHashEntry(Tcl_HashTable *tablePtr, const void *key)
+}
+declare 422 {
+    Tcl_HashEntry *Tcl_CreateHashEntry(Tcl_HashTable *tablePtr,
+	    const void *key, int *newPtr)
+}
 declare 423 {
     void Tcl_InitCustomHashTable(Tcl_HashTable *tablePtr, int keyType,
 	    const Tcl_HashKeyType *typePtr)
 }
 declare 424 {
     void Tcl_InitObjHashTable(Tcl_HashTable *tablePtr)
 }
 declare 425 {
-    void *Tcl_CommandTraceInfo(Tcl_Interp *interp, const char *varName,
+    ClientData Tcl_CommandTraceInfo(Tcl_Interp *interp, const char *varName,
 	    int flags, Tcl_CommandTraceProc *procPtr,
-	    void *prevClientData)
+	    ClientData prevClientData)
 }
 declare 426 {
     int Tcl_TraceCommand(Tcl_Interp *interp, const char *varName, int flags,
-	    Tcl_CommandTraceProc *proc, void *clientData)
+	    Tcl_CommandTraceProc *proc, ClientData clientData)
 }
 declare 427 {
     void Tcl_UntraceCommand(Tcl_Interp *interp, const char *varName,
-	    int flags, Tcl_CommandTraceProc *proc, void *clientData)
+	    int flags, Tcl_CommandTraceProc *proc, ClientData clientData)
 }
 declare 428 {
-    void *Tcl_AttemptAlloc(size_t size)
+    char *Tcl_AttemptAlloc(unsigned int size)
 }
 declare 429 {
-    void *Tcl_AttemptDbCkalloc(size_t size, const char *file, int line)
+    char *Tcl_AttemptDbCkalloc(unsigned int size, const char *file, int line)
 }
 declare 430 {
-    void *Tcl_AttemptRealloc(void *ptr, size_t size)
+    char *Tcl_AttemptRealloc(char *ptr, unsigned int size)
 }
 declare 431 {
-    void *Tcl_AttemptDbCkrealloc(void *ptr, size_t size,
+    char *Tcl_AttemptDbCkrealloc(char *ptr, unsigned int size,
 	    const char *file, int line)
 }
 declare 432 {
-    int Tcl_AttemptSetObjLength(Tcl_Obj *objPtr, size_t length)
+    int Tcl_AttemptSetObjLength(Tcl_Obj *objPtr, int length)
 }
 
 # TIP#10 (thread-aware channels) akupries
 declare 433 {
     Tcl_ThreadId Tcl_GetChannelThread(Tcl_Channel channel)
@@ -1595,20 +1544,18 @@
 declare 434 {
     Tcl_UniChar *Tcl_GetUnicodeFromObj(Tcl_Obj *objPtr, int *lengthPtr)
 }
 
 # TIP#15 (math function introspection) dkf
-# Removed in 9.0:
-#declare 435 {deprecated {}} {
-#    int Tcl_GetMathFuncInfo(Tcl_Interp *interp, const char *name,
-#	    int *numArgsPtr, Tcl_ValueType **argTypesPtr,
-#	    Tcl_MathProc **procPtr, void **clientDataPtr)
-#}
-# Removed in 9.0:
-#declare 436 {deprecated {}} {
-#    Tcl_Obj *Tcl_ListMathFuncs(Tcl_Interp *interp, const char *pattern)
-#}
+declare 435 {deprecated {}} {
+    int Tcl_GetMathFuncInfo(Tcl_Interp *interp, const char *name,
+	    int *numArgsPtr, Tcl_ValueType **argTypesPtr,
+	    Tcl_MathProc **procPtr, ClientData *clientDataPtr)
+}
+declare 436 {deprecated {}} {
+    Tcl_Obj *Tcl_ListMathFuncs(Tcl_Interp *interp, const char *pattern)
+}
 
 # TIP#36 (better access to 'subst') dkf
 declare 437 {
     Tcl_Obj *Tcl_SubstObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags)
 }
@@ -1666,11 +1613,11 @@
 declare 452 {
     int Tcl_FSFileAttrsSet(Tcl_Interp *interp,
 	    int index, Tcl_Obj *pathPtr, Tcl_Obj *objPtr)
 }
 declare 453 {
-    const char *const *Tcl_FSFileAttrStrings(Tcl_Obj *pathPtr,
+    const char *CONST86 *Tcl_FSFileAttrStrings(Tcl_Obj *pathPtr,
 	    Tcl_Obj **objPtrRef)
 }
 declare 454 {
     int Tcl_FSStat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf)
 }
@@ -1705,11 +1652,11 @@
 declare 464 {
     Tcl_Obj *Tcl_FSJoinToPath(Tcl_Obj *pathPtr, int objc,
 	    Tcl_Obj *const objv[])
 }
 declare 465 {
-    void *Tcl_FSGetInternalRep(Tcl_Obj *pathPtr,
+    ClientData Tcl_FSGetInternalRep(Tcl_Obj *pathPtr,
 	    const Tcl_Filesystem *fsPtr)
 }
 declare 466 {
     Tcl_Obj *Tcl_FSGetTranslatedPath(Tcl_Interp *interp, Tcl_Obj *pathPtr)
 }
@@ -1716,11 +1663,11 @@
 declare 467 {
     int Tcl_FSEvalFile(Tcl_Interp *interp, Tcl_Obj *fileName)
 }
 declare 468 {
     Tcl_Obj *Tcl_FSNewNativePath(const Tcl_Filesystem *fromFilesystem,
-	    void *clientData)
+	    ClientData clientData)
 }
 declare 469 {
     const void *Tcl_FSGetNativePath(Tcl_Obj *pathPtr)
 }
 declare 470 {
@@ -1731,24 +1678,24 @@
 }
 declare 472 {
     Tcl_Obj *Tcl_FSListVolumes(void)
 }
 declare 473 {
-    int Tcl_FSRegister(void *clientData, const Tcl_Filesystem *fsPtr)
+    int Tcl_FSRegister(ClientData clientData, const Tcl_Filesystem *fsPtr)
 }
 declare 474 {
     int Tcl_FSUnregister(const Tcl_Filesystem *fsPtr)
 }
 declare 475 {
-    void *Tcl_FSData(const Tcl_Filesystem *fsPtr)
+    ClientData Tcl_FSData(const Tcl_Filesystem *fsPtr)
 }
 declare 476 {
     const char *Tcl_FSGetTranslatedStringPath(Tcl_Interp *interp,
 	    Tcl_Obj *pathPtr)
 }
 declare 477 {
-    const Tcl_Filesystem *Tcl_FSGetFileSystemForPath(Tcl_Obj *pathPtr)
+    CONST86 Tcl_Filesystem *Tcl_FSGetFileSystemForPath(Tcl_Obj *pathPtr)
 }
 declare 478 {
     Tcl_PathType Tcl_FSGetPathType(Tcl_Obj *pathPtr)
 }
 
@@ -1761,11 +1708,11 @@
 }
 
 # TIP#56 (evaluate a parsed script) msofer
 declare 481 {
     int Tcl_EvalTokensStandard(Tcl_Interp *interp, Tcl_Token *tokenPtr,
-	    size_t count)
+	    int count)
 }
 
 # TIP#73 (access to current time) kbk
 declare 482 {
     void Tcl_GetTime(Tcl_Time *timeBuf)
@@ -1772,11 +1719,11 @@
 }
 
 # TIP#32 (object-enabled traces) kbk
 declare 483 {
     Tcl_Trace Tcl_CreateObjTrace(Tcl_Interp *interp, int level, int flags,
-	    Tcl_CmdObjTraceProc *objProc, void *clientData,
+	    Tcl_CmdObjTraceProc *objProc, ClientData clientData,
 	    Tcl_CmdObjTraceDeleteProc *delProc)
 }
 declare 484 {
     int Tcl_GetCommandInfoFromToken(Tcl_Command token, Tcl_CmdInfo *infoPtr)
 }
@@ -1870,11 +1817,11 @@
 
 # TIP #139 (partial exposure of namespace API - transferred from tclInt.decls)
 # dkf, API by Brent Welch?
 declare 506 {
     Tcl_Namespace *Tcl_CreateNamespace(Tcl_Interp *interp, const char *name,
-	    void *clientData, Tcl_NamespaceDeleteProc *deleteProc)
+	    ClientData clientData, Tcl_NamespaceDeleteProc *deleteProc)
 }
 declare 507 {
     void Tcl_DeleteNamespace(Tcl_Namespace *nsPtr)
 }
 declare 508 {
@@ -1919,24 +1866,24 @@
 declare 518 {
     int Tcl_FSEvalFileEx(Tcl_Interp *interp, Tcl_Obj *fileName,
 	    const char *encodingName)
 }
 
-# Removed in 9.0 (stub entry only)
-#declare 519 {nostub {Don't use this function in a stub-enabled extension}} {
-#    Tcl_ExitProc *Tcl_SetExitProc(TCL_NORETURN1 Tcl_ExitProc *proc)
-#}
+# TIP#121 (exit handler) dkf for Joe Mistachkin
+declare 519 {nostub {Don't use this function in a stub-enabled extension}} {
+    Tcl_ExitProc *Tcl_SetExitProc(TCL_NORETURN1 Tcl_ExitProc *proc)
+}
 
 # TIP#143 (resource limits) dkf
 declare 520 {
     void Tcl_LimitAddHandler(Tcl_Interp *interp, int type,
-	    Tcl_LimitHandlerProc *handlerProc, void *clientData,
+	    Tcl_LimitHandlerProc *handlerProc, ClientData clientData,
 	    Tcl_LimitHandlerDeleteProc *deleteProc)
 }
 declare 521 {
     void Tcl_LimitRemoveHandler(Tcl_Interp *interp, int type,
-	    Tcl_LimitHandlerProc *handlerProc, void *clientData)
+	    Tcl_LimitHandlerProc *handlerProc, ClientData clientData)
 }
 declare 522 {
     int Tcl_LimitReady(Tcl_Interp *interp)
 }
 declare 523 {
@@ -2045,16 +1992,16 @@
 
 # TIP#233 (virtualized time) akupries
 declare 552 {
     void Tcl_SetTimeProc(Tcl_GetTimeProc *getProc,
 	    Tcl_ScaleTimeProc *scaleProc,
-	    void *clientData)
+	    ClientData clientData)
 }
 declare 553 {
     void Tcl_QueryTimeProc(Tcl_GetTimeProc **getProc,
 	    Tcl_ScaleTimeProc **scaleProc,
-	    void **clientData)
+	    ClientData *clientData)
 }
 
 # TIP#218 (driver thread actions) davygrvy/akupries ChannelType ver 4
 declare 554 {
     Tcl_DriverThreadActionProc *Tcl_ChannelThreadActionProc(
@@ -2141,12 +2088,12 @@
 # TIP#270 (utility C routines for string formatting) dgp
 declare 574 {
     void Tcl_AppendObjToErrorInfo(Tcl_Interp *interp, Tcl_Obj *objPtr)
 }
 declare 575 {
-    void Tcl_AppendLimitedToObj(Tcl_Obj *objPtr, const char *bytes,
-	    size_t length, size_t limit, const char *ellipsis)
+    void Tcl_AppendLimitedToObj(Tcl_Obj *objPtr, const char *bytes, int length,
+	    int limit, const char *ellipsis)
 }
 declare 576 {
     Tcl_Obj *Tcl_Format(Tcl_Interp *interp, const char *format, int objc,
 	    Tcl_Obj *const objv[])
 }
@@ -2164,11 +2111,11 @@
 # ----- BASELINE -- FOR -- 8.5.0 ----- #
 
 # TIP #285 (script cancellation support) jmistachkin
 declare 580 {
     int Tcl_CancelEval(Tcl_Interp *interp, Tcl_Obj *resultObjPtr,
-	    void *clientData, int flags)
+	    ClientData clientData, int flags)
 }
 declare 581 {
     int Tcl_Canceled(Tcl_Interp *interp, int flags)
 }
 
@@ -2180,34 +2127,34 @@
 
 # TIP #322 (NRE public interface) msofer
 declare 583 {
     Tcl_Command Tcl_NRCreateCommand(Tcl_Interp *interp,
 	    const char *cmdName, Tcl_ObjCmdProc *proc,
-	    Tcl_ObjCmdProc *nreProc, void *clientData,
+	    Tcl_ObjCmdProc *nreProc, ClientData clientData,
 	    Tcl_CmdDeleteProc *deleteProc)
 }
 declare 584 {
     int Tcl_NREvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags)
 }
 declare 585 {
-    int Tcl_NREvalObjv(Tcl_Interp *interp, int objc,
-	    Tcl_Obj *const objv[], int flags)
+    int Tcl_NREvalObjv(Tcl_Interp *interp, int objc, Tcl_Obj *const objv[],
+	    int flags)
 }
 declare 586 {
     int Tcl_NRCmdSwap(Tcl_Interp *interp, Tcl_Command cmd, int objc,
 	    Tcl_Obj *const objv[], int flags)
 }
 declare 587 {
     void Tcl_NRAddCallback(Tcl_Interp *interp, Tcl_NRPostProc *postProcPtr,
-	    void *data0, void *data1, void *data2,
-	    void *data3)
+	    ClientData data0, ClientData data1, ClientData data2,
+	    ClientData data3)
 }
 # For use by NR extenders, to have a simple way to also provide a (required!)
 # classic objProc
 declare 588 {
     int Tcl_NRCallObjProc(Tcl_Interp *interp, Tcl_ObjCmdProc *objProc,
-	    void *clientData, int objc, Tcl_Obj *const objv[])
+	    ClientData clientData, int objc, Tcl_Obj *const objv[])
 }
 
 # TIP#316 (Tcl_StatBuf reader functions) dkf
 declare 589 {
     unsigned Tcl_GetFSDeviceFromStat(const Tcl_StatBuf *statPtr)
@@ -2294,19 +2241,19 @@
     int Tcl_ZlibDeflate(Tcl_Interp *interp, int format, Tcl_Obj *data,
 	    int level, Tcl_Obj *gzipHeaderDictObj)
 }
 declare 611 {
     int Tcl_ZlibInflate(Tcl_Interp *interp, int format, Tcl_Obj *data,
-	    size_t buffersize, Tcl_Obj *gzipHeaderDictObj)
+	    int buffersize, Tcl_Obj *gzipHeaderDictObj)
 }
 declare 612 {
     unsigned int Tcl_ZlibCRC32(unsigned int crc, const unsigned char *buf,
-	    size_t len)
+	    int len)
 }
 declare 613 {
     unsigned int Tcl_ZlibAdler32(unsigned int adler, const unsigned char *buf,
-	    size_t len)
+	    int len)
 }
 declare 614 {
     int Tcl_ZlibStreamInit(Tcl_Interp *interp, int mode, int format,
 	    int level, Tcl_Obj *dictObj, Tcl_ZlibStream *zshandle)
 }
@@ -2321,12 +2268,11 @@
 }
 declare 618 {
     int Tcl_ZlibStreamPut(Tcl_ZlibStream zshandle, Tcl_Obj *data, int flush)
 }
 declare 619 {
-    int Tcl_ZlibStreamGet(Tcl_ZlibStream zshandle, Tcl_Obj *data,
-	    size_t count)
+    int Tcl_ZlibStreamGet(Tcl_ZlibStream zshandle, Tcl_Obj *data, int count)
 }
 declare 620 {
     int Tcl_ZlibStreamClose(Tcl_ZlibStream zshandle)
 }
 declare 621 {
@@ -2380,11 +2326,11 @@
 
 # TIP #456
 declare 631 {
     Tcl_Channel Tcl_OpenTcpServerEx(Tcl_Interp *interp, const char *service,
 	    const char *host, unsigned int flags, Tcl_TcpAcceptProc *acceptProc,
-	    void *callbackData)
+	    ClientData callbackData)
 }
 
 # TIP #430
 declare 632 {
     int TclZipfs_Mount(Tcl_Interp *interp, const char *mountPoint,
@@ -2405,11 +2351,11 @@
 declare 636 {
     void Tcl_FreeIntRep(Tcl_Obj *objPtr)
 }
 declare 637 {
     char *Tcl_InitStringRep(Tcl_Obj *objPtr, const char *bytes,
-	    size_t numBytes)
+	    unsigned int numBytes)
 }
 declare 638 {
     Tcl_ObjIntRep *Tcl_FetchIntRep(Tcl_Obj *objPtr, const Tcl_ObjType *typePtr)
 }
 declare 639 {
@@ -2434,16 +2380,16 @@
 }
 
 # TIP#312 New Tcl_LinkArray() function
 declare 644 {
     int Tcl_LinkArray(Tcl_Interp *interp, const char *varName, void *addr,
-	    int type, size_t size)
+	    int type, int size)
 }
 
 declare 645 {
     int Tcl_GetIntForIndex(Tcl_Interp *interp, Tcl_Obj *objPtr,
-	    size_t endValue, size_t *indexPtr)
+	    int endValue, int *indexPtr)
 }
 
 # ----- BASELINE -- FOR -- 8.7.0 ----- #
 
 ##############################################################################
@@ -2461,34 +2407,37 @@
 # Windows specific functions
 
 # Added in Tcl 8.1
 
 declare 0 win {
-    TCHAR *Tcl_WinUtfToTChar(const char *str, size_t len, Tcl_DString *dsPtr)
+    TCHAR *Tcl_WinUtfToTChar(const char *str, int len, Tcl_DString *dsPtr)
 }
 declare 1 win {
-    char *Tcl_WinTCharToUtf(const TCHAR *str, size_t len, Tcl_DString *dsPtr)
+    char *Tcl_WinTCharToUtf(const TCHAR *str, int len, Tcl_DString *dsPtr)
 }
 
 ################################
 # Mac OS X specific functions
 
 declare 0 macosx {
     int Tcl_MacOSXOpenBundleResources(Tcl_Interp *interp,
 	    const char *bundleName, int hasResourceFile,
-	    size_t maxPathLen, char *libraryPath)
+	    int maxPathLen, char *libraryPath)
 }
 declare 1 macosx {
     int Tcl_MacOSXOpenVersionedBundleResources(Tcl_Interp *interp,
 	    const char *bundleName, const char *bundleVersion,
-	    int hasResourceFile, size_t maxPathLen, char *libraryPath)
+	    int hasResourceFile, int maxPathLen, char *libraryPath)
 }
 
 ##############################################################################
 
 # Public functions that are not accessible via the stubs table.
 
+export {
+    void Tcl_Main(int argc, char **argv, Tcl_AppInitProc *appInitProc)
+}
 export {
     void Tcl_MainEx(int argc, char **argv, Tcl_AppInitProc *appInitProc,
     Tcl_Interp *interp)
 }
 export {
@@ -2517,9 +2466,12 @@
 	int exact)
 }
 export {
     void Tcl_GetMemoryInfo(Tcl_DString *dsPtr)
 }
+export {
+    void Tcl_InitSubsystems(void)
+}
 
 # Local Variables:
 # mode: tcl
 # End:

Index: generic/tcl.h
==================================================================
--- generic/tcl.h
+++ generic/tcl.h
@@ -46,19 +46,34 @@
  * win/README		(not patchlevel) (sections 0 and 2)
  * unix/tcl.spec	(1 LOC patch)
  * tools/tcl.hpj.in	(not patchlevel, for windows installer)
  */
 
-#define TCL_MAJOR_VERSION   9
-#define TCL_MINOR_VERSION   0
+#define TCL_MAJOR_VERSION   8
+#define TCL_MINOR_VERSION   7
 #define TCL_RELEASE_LEVEL   TCL_ALPHA_RELEASE
-#define TCL_RELEASE_SERIAL  0
+#define TCL_RELEASE_SERIAL  2
 
-#define TCL_VERSION	    "9.0"
-#define TCL_PATCH_LEVEL	    "9.0a0"
+#define TCL_VERSION	    "8.7"
+#define TCL_PATCH_LEVEL	    "8.7a2"
 
-#if defined(RC_INVOKED)
+#if !defined(TCL_NO_DEPRECATED) || defined(RC_INVOKED)
+/*
+ *----------------------------------------------------------------------------
+ * The following definitions set up the proper options for Windows compilers.
+ * We use this method because there is no autoconf equivalent.
+ */
+
+#ifdef _WIN32
+#   ifndef __WIN32__
+#	define __WIN32__
+#   endif
+#   ifndef WIN32
+#	define WIN32
+#   endif
+#endif
+
 /*
  * Utility macros: STRINGIFY takes an argument and wraps it in "" (double
  * quotation marks), JOIN joins two arguments.
  */
 
@@ -68,11 +83,15 @@
 #endif
 #ifndef JOIN
 #  define JOIN(a,b) JOIN1(a,b)
 #  define JOIN1(a,b) a##b
 #endif
-#endif /* RC_INVOKED */
+
+#ifndef TCL_THREADS
+#   define TCL_THREADS 1
+#endif
+#endif /* !TCL_NO_DEPRECATED */
 
 /*
  * A special definition used to allow this header file to be included from
  * windows resource files so that they can obtain version information.
  * RC_INVOKED is defined by default by the windows RC tool.
@@ -99,15 +118,36 @@
  * prior Tcl releases.
  */
 
 #include <stdio.h>
 
+/*
+ *----------------------------------------------------------------------------
+ * Support for functions with a variable number of arguments.
+ *
+ * The following TCL_VARARGS* macros are to support old extensions
+ * written for older versions of Tcl where the macros permitted
+ * support for the varargs.h system as well as stdarg.h .
+ *
+ * New code should just directly be written to use stdarg.h conventions.
+ */
+
+#include <stdarg.h>
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+#    define TCL_VARARGS(type, name) (type name, ...)
+#    define TCL_VARARGS_DEF(type, name) (type name, ...)
+#    define TCL_VARARGS_START(type, name, list) (va_start(list, name), name)
+#endif /* !TCL_NO_DEPRECATED */
 #if defined(__GNUC__) && (__GNUC__ > 2)
 #   define TCL_FORMAT_PRINTF(a,b) __attribute__ ((__format__ (__printf__, a, b)))
 #   define TCL_NORETURN __attribute__ ((noreturn))
 #   define TCL_NOINLINE __attribute__ ((noinline))
-#   define TCL_NORETURN1 __attribute__ ((noreturn))
+#   if defined(BUILD_tcl) || defined(BUILD_tk)
+#	define TCL_NORETURN1 __attribute__ ((noreturn))
+#   else
+#	define TCL_NORETURN1 /* nothing */
+#   endif
 #else
 #   define TCL_FORMAT_PRINTF(a,b)
 #   if defined(_MSC_VER) && (_MSC_VER >= 1310)
 #	define TCL_NORETURN _declspec(noreturn)
 #	define TCL_NOINLINE __declspec(noinline)
@@ -199,11 +239,37 @@
 #   else
 #      define TCL_STORAGE_CLASS DLLIMPORT
 #   endif
 #endif
 
-#if !defined(CONST86) && !defined(TCL_NO_DEPRECATED)
+/*
+ * The following _ANSI_ARGS_ macro is to support old extensions
+ * written for older versions of Tcl where it permitted support
+ * for compilers written in the pre-prototype era of C.
+ *
+ * New code should use prototypes.
+ */
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+#   undef _ANSI_ARGS_
+#   define _ANSI_ARGS_(x)	x
+
+/*
+ * Definitions that allow this header file to be used either with or without
+ * ANSI C features.
+ */
+
+#ifndef INLINE
+#   define INLINE
+#endif
+#ifndef CONST
+#   define CONST const
+#endif
+
+#endif /* !TCL_NO_DEPRECATED */
+
+#ifndef CONST86
 #      define CONST86 const
 #endif
 
 /*
  * Make sure EXTERN isn't defined elsewhere.
@@ -217,15 +283,45 @@
 #   define EXTERN extern "C" TCL_STORAGE_CLASS
 #else
 #   define EXTERN extern TCL_STORAGE_CLASS
 #endif
 
+/*
+ *----------------------------------------------------------------------------
+ * The following code is copied from winnt.h. If we don't replicate it here,
+ * then <windows.h> can't be included after tcl.h, since tcl.h also defines
+ * VOID. This block is skipped under Cygwin and Mingw.
+ */
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+#if defined(_WIN32) && !defined(HAVE_WINNT_IGNORE_VOID)
+#ifndef VOID
+#define VOID void
+typedef char CHAR;
+typedef short SHORT;
+typedef long LONG;
+#endif
+#endif /* _WIN32 && !HAVE_WINNT_IGNORE_VOID */
+
+/*
+ * Macro to use instead of "void" for arguments that must have type "void *"
+ * in ANSI C; maps them to type "char *" in non-ANSI systems.
+ */
+
+#ifndef __VXWORKS__
+#   define VOID void
+#endif
+#endif /* !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9 */
+
 /*
  * Miscellaneous declarations.
  */
 
-typedef void *ClientData;
+#ifndef _CLIENTDATA
+    typedef void *ClientData;
+#   define _CLIENTDATA
+#endif
 
 /*
  * Darwin specific configure overrides (to support fat compiles, where
  * configure runs only once for multiple architectures):
  */
@@ -308,11 +404,11 @@
 #define Tcl_DoubleAsWide(val)	((Tcl_WideInt)((double)(val)))
 
 #if defined(_WIN32)
 #   ifdef __BORLANDC__
 	typedef struct stati64 Tcl_StatBuf;
-#   elif defined(_WIN64)
+#   elif defined(_WIN64) || defined(__MINGW_USE_VC2005_COMPAT) || defined(_USE_64BIT_TIME_T)
 	typedef struct __stat64 Tcl_StatBuf;
 #   elif (defined(_MSC_VER) && (_MSC_VER < 1400)) || defined(_USE_32BIT_TIME_T)
 	typedef struct _stati64	Tcl_StatBuf;
 #   else
 	typedef struct _stat32i64 Tcl_StatBuf;
@@ -358,11 +454,21 @@
  * Note: Tcl_ObjCmdProc functions do not directly set result and freeProc.
  * Instead, they set a Tcl_Obj member in the "real" structure that can be
  * accessed with Tcl_GetObjResult() and Tcl_SetObjResult().
  */
 
-typedef struct Tcl_Interp Tcl_Interp;
+typedef struct Tcl_Interp
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+{
+    /* TIP #330: Strongly discourage extensions from using the string
+     * result. */
+    char *resultDontUse; /* Don't use in extensions! */
+    void (*freeProcDontUse) (char *); /* Don't use in extensions! */
+    int errorLineDontUse; /* Don't use in extensions! */
+}
+#endif /* !TCL_NO_DEPRECATED */
+Tcl_Interp;
 
 typedef struct Tcl_AsyncHandler_ *Tcl_AsyncHandler;
 typedef struct Tcl_Channel_ *Tcl_Channel;
 typedef struct Tcl_ChannelTypeVersion_ *Tcl_ChannelTypeVersion;
 typedef struct Tcl_Command_ *Tcl_Command;
@@ -389,13 +495,13 @@
  * following this definition is given to each call of 'Tcl_CreateThread' and
  * will be called as the main fuction of the new thread created by that call.
  */
 
 #if defined _WIN32
-typedef unsigned (__stdcall Tcl_ThreadCreateProc) (void *clientData);
+typedef unsigned (__stdcall Tcl_ThreadCreateProc) (ClientData clientData);
 #else
-typedef void (Tcl_ThreadCreateProc) (void *clientData);
+typedef void (Tcl_ThreadCreateProc) (ClientData clientData);
 #endif
 
 /*
  * Threading function return types used for abstracting away platform
  * differences when writing a Tcl_ThreadCreateProc. See the NewThread function
@@ -457,22 +563,23 @@
  * relative to the start of the match string, not the beginning of the entire
  * string.
  */
 
 typedef struct Tcl_RegExpIndices {
-    size_t start;			/* Character offset of first character in
+    long start;			/* Character offset of first character in
 				 * match. */
-    size_t end;			/* Character offset of first character after
+    long end;			/* Character offset of first character after
 				 * the match. */
 } Tcl_RegExpIndices;
 
 typedef struct Tcl_RegExpInfo {
-    size_t nsubs;			/* Number of subexpressions in the compiled
+    int nsubs;			/* Number of subexpressions in the compiled
 				 * expression. */
     Tcl_RegExpIndices *matches;	/* Array of nsubs match offset pairs. */
-    size_t extendStart;		/* The offset at which a subsequent match
+    long extendStart;		/* The offset at which a subsequent match
 				 * might begin. */
+    long reserved;		/* Reserved for later use. */
 } Tcl_RegExpInfo;
 
 /*
  * Picky compilers complain if this typdef doesn't appear before the struct's
  * reference in tclDecls.h.
@@ -506,10 +613,14 @@
 #define TCL_ERROR		1
 #define TCL_RETURN		2
 #define TCL_BREAK		3
 #define TCL_CONTINUE		4
 
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+#define TCL_RESULT_SIZE		200
+#endif
+
 /*
  *----------------------------------------------------------------------------
  * Flags to control what substitutions are performed by Tcl_SubstObj():
  */
 
@@ -516,10 +627,31 @@
 #define TCL_SUBST_COMMANDS	001
 #define TCL_SUBST_VARIABLES	002
 #define TCL_SUBST_BACKSLASHES	004
 #define TCL_SUBST_ALL		007
 
+/*
+ * Argument descriptors for math function callbacks in expressions:
+ */
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+typedef enum {
+    TCL_INT, TCL_DOUBLE, TCL_EITHER, TCL_WIDE_INT
+} Tcl_ValueType;
+
+typedef struct Tcl_Value {
+    Tcl_ValueType type;		/* Indicates intValue or doubleValue is valid,
+				 * or both. */
+    long intValue;		/* Integer value. */
+    double doubleValue;		/* Double-precision floating value. */
+    Tcl_WideInt wideValue;	/* Wide (min. 64-bit) integer value. */
+} Tcl_Value;
+#else
+#define Tcl_ValueType void /* Just enough to prevent compilation error in Tcl */
+#define Tcl_Value void /* Just enough to prevent compilation error in Tcl */
+#endif
+
 /*
  * Forward declaration of Tcl_Obj to prevent an error when the forward
  * reference to Tcl_Obj is encountered in the function types declared below.
  */
 
@@ -529,64 +661,66 @@
  *----------------------------------------------------------------------------
  * Function types defined by Tcl:
  */
 
 typedef int (Tcl_AppInitProc) (Tcl_Interp *interp);
-typedef int (Tcl_AsyncProc) (void *clientData, Tcl_Interp *interp,
+typedef int (Tcl_AsyncProc) (ClientData clientData, Tcl_Interp *interp,
 	int code);
-typedef void (Tcl_ChannelProc) (void *clientData, int mask);
-typedef void (Tcl_CloseProc) (void *data);
-typedef void (Tcl_CmdDeleteProc) (void *clientData);
-typedef int (Tcl_CmdProc) (void *clientData, Tcl_Interp *interp,
+typedef void (Tcl_ChannelProc) (ClientData clientData, int mask);
+typedef void (Tcl_CloseProc) (ClientData data);
+typedef void (Tcl_CmdDeleteProc) (ClientData clientData);
+typedef int (Tcl_CmdProc) (ClientData clientData, Tcl_Interp *interp,
 	int argc, const char *argv[]);
-typedef void (Tcl_CmdTraceProc) (void *clientData, Tcl_Interp *interp,
+typedef void (Tcl_CmdTraceProc) (ClientData clientData, Tcl_Interp *interp,
 	int level, char *command, Tcl_CmdProc *proc,
-	void *cmdClientData, int argc, const char *argv[]);
-typedef int (Tcl_CmdObjTraceProc) (void *clientData, Tcl_Interp *interp,
+	ClientData cmdClientData, int argc, const char *argv[]);
+typedef int (Tcl_CmdObjTraceProc) (ClientData clientData, Tcl_Interp *interp,
 	int level, const char *command, Tcl_Command commandInfo, int objc,
 	struct Tcl_Obj *const *objv);
-typedef void (Tcl_CmdObjTraceDeleteProc) (void *clientData);
+typedef void (Tcl_CmdObjTraceDeleteProc) (ClientData clientData);
 typedef void (Tcl_DupInternalRepProc) (struct Tcl_Obj *srcPtr,
 	struct Tcl_Obj *dupPtr);
-typedef int (Tcl_EncodingConvertProc) (void *clientData, const char *src,
+typedef int (Tcl_EncodingConvertProc) (ClientData clientData, const char *src,
 	int srcLen, int flags, Tcl_EncodingState *statePtr, char *dst,
 	int dstLen, int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr);
-#define Tcl_EncodingFreeProc Tcl_FreeProc
+typedef void (Tcl_EncodingFreeProc) (ClientData clientData);
 typedef int (Tcl_EventProc) (Tcl_Event *evPtr, int flags);
-typedef void (Tcl_EventCheckProc) (void *clientData, int flags);
-typedef int (Tcl_EventDeleteProc) (Tcl_Event *evPtr, void *clientData);
-typedef void (Tcl_EventSetupProc) (void *clientData, int flags);
-#define Tcl_ExitProc Tcl_FreeProc
-typedef void (Tcl_FileProc) (void *clientData, int mask);
-#define Tcl_FileFreeProc Tcl_FreeProc
+typedef void (Tcl_EventCheckProc) (ClientData clientData, int flags);
+typedef int (Tcl_EventDeleteProc) (Tcl_Event *evPtr, ClientData clientData);
+typedef void (Tcl_EventSetupProc) (ClientData clientData, int flags);
+typedef void (Tcl_ExitProc) (ClientData clientData);
+typedef void (Tcl_FileProc) (ClientData clientData, int mask);
+typedef void (Tcl_FileFreeProc) (ClientData clientData);
 typedef void (Tcl_FreeInternalRepProc) (struct Tcl_Obj *objPtr);
-typedef void (Tcl_FreeProc) (void *blockPtr);
-typedef void (Tcl_IdleProc) (void *clientData);
-typedef void (Tcl_InterpDeleteProc) (void *clientData,
+typedef void (Tcl_FreeProc) (char *blockPtr);
+typedef void (Tcl_IdleProc) (ClientData clientData);
+typedef void (Tcl_InterpDeleteProc) (ClientData clientData,
 	Tcl_Interp *interp);
-typedef void (Tcl_NamespaceDeleteProc) (void *clientData);
-typedef int (Tcl_ObjCmdProc) (void *clientData, Tcl_Interp *interp,
+typedef int (Tcl_MathProc) (ClientData clientData, Tcl_Interp *interp,
+	Tcl_Value *args, Tcl_Value *resultPtr);
+typedef void (Tcl_NamespaceDeleteProc) (ClientData clientData);
+typedef int (Tcl_ObjCmdProc) (ClientData clientData, Tcl_Interp *interp,
 	int objc, struct Tcl_Obj *const *objv);
 typedef int (Tcl_PackageInitProc) (Tcl_Interp *interp);
 typedef int (Tcl_PackageUnloadProc) (Tcl_Interp *interp, int flags);
 typedef void (Tcl_PanicProc) (const char *format, ...);
-typedef void (Tcl_TcpAcceptProc) (void *callbackData, Tcl_Channel chan,
+typedef void (Tcl_TcpAcceptProc) (ClientData callbackData, Tcl_Channel chan,
 	char *address, int port);
-typedef void (Tcl_TimerProc) (void *clientData);
+typedef void (Tcl_TimerProc) (ClientData clientData);
 typedef int (Tcl_SetFromAnyProc) (Tcl_Interp *interp, struct Tcl_Obj *objPtr);
 typedef void (Tcl_UpdateStringProc) (struct Tcl_Obj *objPtr);
-typedef char * (Tcl_VarTraceProc) (void *clientData, Tcl_Interp *interp,
+typedef char * (Tcl_VarTraceProc) (ClientData clientData, Tcl_Interp *interp,
 	const char *part1, const char *part2, int flags);
-typedef void (Tcl_CommandTraceProc) (void *clientData, Tcl_Interp *interp,
+typedef void (Tcl_CommandTraceProc) (ClientData clientData, Tcl_Interp *interp,
 	const char *oldName, const char *newName, int flags);
 typedef void (Tcl_CreateFileHandlerProc) (int fd, int mask, Tcl_FileProc *proc,
-	void *clientData);
+	ClientData clientData);
 typedef void (Tcl_DeleteFileHandlerProc) (int fd);
-typedef void (Tcl_AlertNotifierProc) (void *clientData);
+typedef void (Tcl_AlertNotifierProc) (ClientData clientData);
 typedef void (Tcl_ServiceModeHookProc) (int mode);
-typedef void *(Tcl_InitNotifierProc) (void);
-typedef void (Tcl_FinalizeNotifierProc) (void *clientData);
+typedef ClientData (Tcl_InitNotifierProc) (void);
+typedef void (Tcl_FinalizeNotifierProc) (ClientData clientData);
 typedef void (Tcl_MainLoopProc) (void);
 
 /*
  *----------------------------------------------------------------------------
  * The following structure represents a type of object, which is a particular
@@ -640,23 +774,23 @@
  * An object stores a value as either a string, some internal representation,
  * or both.
  */
 
 typedef struct Tcl_Obj {
-    size_t refCount;		/* When 0 the object will be freed. */
+    int refCount;		/* When 0 the object will be freed. */
     char *bytes;		/* This points to the first byte of the
 				 * object's string representation. The array
 				 * must be followed by a null byte (i.e., at
 				 * offset length) but may also contain
 				 * embedded null characters. The array's
-				 * storage is allocated by Tcl_Alloc. NULL means
+				 * storage is allocated by ckalloc. NULL means
 				 * the string rep is invalid and must be
 				 * regenerated from the internal rep.  Clients
 				 * should use Tcl_GetStringFromObj or
 				 * Tcl_GetString to get a pointer to the byte
 				 * array as a readonly value. */
-    size_t length;		/* The number of bytes at *bytes, not
+    int length;			/* The number of bytes at *bytes, not
 				 * including the terminating null. */
     const Tcl_ObjType *typePtr;	/* Denotes the object's type. Always
 				 * corresponds to the type of the object's
 				 * internal rep. NULL indicates the object has
 				 * no internal rep (has no type). */
@@ -664,15 +798,24 @@
 } Tcl_Obj;
 
 
 /*
  *----------------------------------------------------------------------------
- * The following type contains the state needed by Tcl_SaveResult. It
- * is typically allocated on the stack.
+ * The following structure contains the state needed by Tcl_SaveResult. No-one
+ * outside of Tcl should access any of these fields. This structure is
+ * typically allocated on the stack.
  */
 
-typedef Tcl_Obj *Tcl_SavedResult;
+typedef struct Tcl_SavedResult {
+    char *result;
+    Tcl_FreeProc *freeProc;
+    Tcl_Obj *objResultPtr;
+    char *appendResult;
+    int appendAvl;
+    int appendUsed;
+    char resultSpace[200+1];
+} Tcl_SavedResult;
 
 /*
  *----------------------------------------------------------------------------
  * The following definitions support Tcl's namespace facility. Note: the first
  * five fields must match exactly the fields in a Namespace structure (see
@@ -684,11 +827,11 @@
 				 * namespace. This contains no ::'s. The name
 				 * of the global namespace is "" although "::"
 				 * is an synonym. */
     char *fullName;		/* The namespace's fully qualified name. This
 				 * starts with ::. */
-    void *clientData;	/* Arbitrary value associated with this
+    ClientData clientData;	/* Arbitrary value associated with this
 				 * namespace. */
     Tcl_NamespaceDeleteProc *deleteProc;
 				/* Function invoked when deleting the
 				 * namespace to, e.g., free clientData. */
     struct Tcl_Namespace *parentPtr;
@@ -756,17 +899,17 @@
     int isNativeObjectProc;	/* 1 if objProc was registered by a call to
 				 * Tcl_CreateObjCommand; 0 otherwise.
 				 * Tcl_SetCmdInfo does not modify this
 				 * field. */
     Tcl_ObjCmdProc *objProc;	/* Command's object-based function. */
-    void *objClientData;	/* ClientData for object proc. */
+    ClientData objClientData;	/* ClientData for object proc. */
     Tcl_CmdProc *proc;		/* Command's string-based function. */
-    void *clientData;	/* ClientData for string proc. */
+    ClientData clientData;	/* ClientData for string proc. */
     Tcl_CmdDeleteProc *deleteProc;
 				/* Function to call when command is
 				 * deleted. */
-    void *deleteData;	/* Value to pass to deleteProc (usually the
+    ClientData deleteData;	/* Value to pass to deleteProc (usually the
 				 * same as clientData). */
     Tcl_Namespace *namespacePtr;/* Points to the namespace that contains this
 				 * command. Note that Tcl_SetCmdInfo will not
 				 * change a command's namespace; use
 				 * TclRenameCommand or Tcl_Eval (of 'rename')
@@ -782,26 +925,29 @@
 
 #define TCL_DSTRING_STATIC_SIZE 200
 typedef struct Tcl_DString {
     char *string;		/* Points to beginning of string: either
 				 * staticSpace below or a malloced array. */
-    size_t length;		/* Number of non-NULL characters in the
+    int length;			/* Number of non-NULL characters in the
 				 * string. */
-    size_t spaceAvl;		/* Total number of bytes available for the
+    int spaceAvl;		/* Total number of bytes available for the
 				 * string and its terminating NULL char. */
     char staticSpace[TCL_DSTRING_STATIC_SIZE];
 				/* Space to use in common case where string is
 				 * small. */
 } Tcl_DString;
 
 #define Tcl_DStringLength(dsPtr) ((dsPtr)->length)
 #define Tcl_DStringValue(dsPtr) ((dsPtr)->string)
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+#   define Tcl_DStringTrunc Tcl_DStringSetLength
+#endif /* !TCL_NO_DEPRECATED */
 
 /*
  * Definitions for the maximum number of digits of precision that may be
- * produced by Tcl_PrintDouble, and the number of bytes of buffer space
- * required by Tcl_PrintDouble.
+ * specified in the "tcl_precision" variable, and the number of bytes of
+ * buffer space required by Tcl_PrintDouble.
  */
 
 #define TCL_MAX_PREC		17
 #define TCL_DOUBLE_SPACE	(TCL_MAX_PREC+10)
 
@@ -911,10 +1057,21 @@
 #define TCL_TRACE_RENAME	0x2000
 #define TCL_TRACE_DELETE	0x4000
 
 #define TCL_ALLOW_INLINE_COMPILATION 0x20000
 
+/*
+ * The TCL_PARSE_PART1 flag is deprecated and has no effect. The part1 is now
+ * always parsed whenever the part2 is NULL. (This is to avoid a common error
+ * when converting code to use the new object based APIs and forgetting to
+ * give the flag)
+ */
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+#   define TCL_PARSE_PART1	0x400
+#endif /* !TCL_NO_DEPRECATED */
+
 /*
  * Types for linked variables:
  */
 
 #define TCL_LINK_INT		1
@@ -944,11 +1101,11 @@
  *----------------------------------------------------------------------------
  * Forward declarations of Tcl_HashTable and related types.
  */
 
 #ifndef TCL_HASH_TYPE
-#  define TCL_HASH_TYPE size_t
+#  define TCL_HASH_TYPE unsigned
 #endif
 
 typedef struct Tcl_HashKeyType Tcl_HashKeyType;
 typedef struct Tcl_HashTable Tcl_HashTable;
 typedef struct Tcl_HashEntry Tcl_HashEntry;
@@ -966,12 +1123,14 @@
 
 struct Tcl_HashEntry {
     Tcl_HashEntry *nextPtr;	/* Pointer to next entry in this hash bucket,
 				 * or NULL for end of chain. */
     Tcl_HashTable *tablePtr;	/* Pointer to table containing entry. */
-    size_t hash;		/* Hash value. */
-    void *clientData;		/* Application stores something here with
+    void *hash;			/* Hash value, stored as pointer to ensure
+				 * that the offsets of the fields in this
+				 * structure are not changed. */
+    ClientData clientData;	/* Application stores something here with
 				 * Tcl_SetHashValue. */
     union {			/* Key has one of these forms: */
 	char *oneWordValue;	/* One-word value for key. */
 	Tcl_Obj *objPtr;	/* Tcl_Obj * key value. */
 	int words[1];		/* Multiple integer words for key. The actual
@@ -1055,20 +1214,20 @@
 				 * points to first entry in bucket's hash
 				 * chain, or NULL. */
     Tcl_HashEntry *staticBuckets[TCL_SMALL_HASH_TABLE];
 				/* Bucket array used for small tables (to
 				 * avoid mallocs and frees). */
-    size_t numBuckets;		/* Total number of buckets allocated at
+    int numBuckets;		/* Total number of buckets allocated at
 				 * **bucketPtr. */
-    size_t numEntries;		/* Total number of entries present in
+    int numEntries;		/* Total number of entries present in
 				 * table. */
-    size_t rebuildSize;		/* Enlarge table when numEntries gets to be
+    int rebuildSize;		/* Enlarge table when numEntries gets to be
 				 * this large. */
-    size_t mask;		/* Mask value used in hashing function. */
     int downShift;		/* Shift count used in hashing function.
 				 * Designed to use high-order bits of
 				 * randomized keys. */
+    int mask;			/* Mask value used in hashing function. */
     int keyType;		/* Type of keys used in this table. It's
 				 * either TCL_CUSTOM_KEYS, TCL_STRING_KEYS,
 				 * TCL_ONE_WORD_KEYS, or an integer giving the
 				 * number of ints that is the size of the
 				 * key. */
@@ -1085,11 +1244,11 @@
  * hash tables:
  */
 
 typedef struct Tcl_HashSearch {
     Tcl_HashTable *tablePtr;	/* Table being searched. */
-    size_t nextIndex;		/* Index of next bucket to be enumerated after
+    int nextIndex;		/* Index of next bucket to be enumerated after
 				 * present one. */
     Tcl_HashEntry *nextEntryPtr;/* Next entry to be enumerated in the current
 				 * bucket. */
 } Tcl_HashSearch;
 
@@ -1126,11 +1285,11 @@
  */
 
 typedef struct {
     void *next;			/* Search position for underlying hash
 				 * table. */
-    size_t epoch;		/* Epoch marker for dictionary being searched,
+    unsigned int epoch; 	/* Epoch marker for dictionary being searched,
 				 * or 0 if search has terminated. */
     Tcl_Dict dictionaryPtr;	/* Reference to dictionary being searched. */
 } Tcl_DictSearch;
 
 /*
@@ -1185,19 +1344,19 @@
 typedef struct Tcl_Time {
     long sec;			/* Seconds. */
     long usec;			/* Microseconds. */
 } Tcl_Time;
 
-typedef void (Tcl_SetTimerProc) (const Tcl_Time *timePtr);
-typedef int (Tcl_WaitForEventProc) (const Tcl_Time *timePtr);
+typedef void (Tcl_SetTimerProc) (CONST86 Tcl_Time *timePtr);
+typedef int (Tcl_WaitForEventProc) (CONST86 Tcl_Time *timePtr);
 
 /*
  * TIP #233 (Virtualized Time)
  */
 
-typedef void (Tcl_GetTimeProc)   (Tcl_Time *timebuf, void *clientData);
-typedef void (Tcl_ScaleTimeProc) (Tcl_Time *timebuf, void *clientData);
+typedef void (Tcl_GetTimeProc)   (Tcl_Time *timebuf, ClientData clientData);
+typedef void (Tcl_ScaleTimeProc) (Tcl_Time *timebuf, ClientData clientData);
 
 /*
  *----------------------------------------------------------------------------
  * Bits to pass to Tcl_CreateFileHandler and Tcl_CreateChannelHandler to
  * indicate what sorts of events are of interest:
@@ -1252,44 +1411,44 @@
 
 /*
  * Typedefs for the various operations in a channel type:
  */
 
-typedef int	(Tcl_DriverBlockModeProc) (void *instanceData, int mode);
-typedef int	(Tcl_DriverCloseProc) (void *instanceData,
+typedef int	(Tcl_DriverBlockModeProc) (ClientData instanceData, int mode);
+typedef int	(Tcl_DriverCloseProc) (ClientData instanceData,
 			Tcl_Interp *interp);
-typedef int	(Tcl_DriverClose2Proc) (void *instanceData,
+typedef int	(Tcl_DriverClose2Proc) (ClientData instanceData,
 			Tcl_Interp *interp, int flags);
-typedef int	(Tcl_DriverInputProc) (void *instanceData, char *buf,
+typedef int	(Tcl_DriverInputProc) (ClientData instanceData, char *buf,
 			int toRead, int *errorCodePtr);
-typedef int	(Tcl_DriverOutputProc) (void *instanceData,
+typedef int	(Tcl_DriverOutputProc) (ClientData instanceData,
 			const char *buf, int toWrite, int *errorCodePtr);
-typedef int	(Tcl_DriverSeekProc) (void *instanceData, long offset,
+typedef int	(Tcl_DriverSeekProc) (ClientData instanceData, long offset,
 			int mode, int *errorCodePtr);
-typedef int	(Tcl_DriverSetOptionProc) (void *instanceData,
+typedef int	(Tcl_DriverSetOptionProc) (ClientData instanceData,
 			Tcl_Interp *interp, const char *optionName,
 			const char *value);
-typedef int	(Tcl_DriverGetOptionProc) (void *instanceData,
+typedef int	(Tcl_DriverGetOptionProc) (ClientData instanceData,
 			Tcl_Interp *interp, const char *optionName,
 			Tcl_DString *dsPtr);
-typedef void	(Tcl_DriverWatchProc) (void *instanceData, int mask);
-typedef int	(Tcl_DriverGetHandleProc) (void *instanceData,
-			int direction, void **handlePtr);
-typedef int	(Tcl_DriverFlushProc) (void *instanceData);
-typedef int	(Tcl_DriverHandlerProc) (void *instanceData,
+typedef void	(Tcl_DriverWatchProc) (ClientData instanceData, int mask);
+typedef int	(Tcl_DriverGetHandleProc) (ClientData instanceData,
+			int direction, ClientData *handlePtr);
+typedef int	(Tcl_DriverFlushProc) (ClientData instanceData);
+typedef int	(Tcl_DriverHandlerProc) (ClientData instanceData,
 			int interestMask);
-typedef Tcl_WideInt (Tcl_DriverWideSeekProc) (void *instanceData,
+typedef Tcl_WideInt (Tcl_DriverWideSeekProc) (ClientData instanceData,
 			Tcl_WideInt offset, int mode, int *errorCodePtr);
 /*
  * TIP #218, Channel Thread Actions
  */
-typedef void	(Tcl_DriverThreadActionProc) (void *instanceData,
+typedef void	(Tcl_DriverThreadActionProc) (ClientData instanceData,
 			int action);
 /*
  * TIP #208, File Truncation (etc.)
  */
-typedef int	(Tcl_DriverTruncateProc) (void *instanceData,
+typedef int	(Tcl_DriverTruncateProc) (ClientData instanceData,
 			Tcl_WideInt length);
 
 /*
  * struct Tcl_ChannelType:
  *
@@ -1458,26 +1617,26 @@
 typedef int (Tcl_FSUtimeProc) (Tcl_Obj *pathPtr, struct utimbuf *tval);
 typedef int (Tcl_FSNormalizePathProc) (Tcl_Interp *interp, Tcl_Obj *pathPtr,
 	int nextCheckpoint);
 typedef int (Tcl_FSFileAttrsGetProc) (Tcl_Interp *interp, int index,
 	Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef);
-typedef const char *const * (Tcl_FSFileAttrStringsProc) (Tcl_Obj *pathPtr,
+typedef const char *CONST86 * (Tcl_FSFileAttrStringsProc) (Tcl_Obj *pathPtr,
 	Tcl_Obj **objPtrRef);
 typedef int (Tcl_FSFileAttrsSetProc) (Tcl_Interp *interp, int index,
 	Tcl_Obj *pathPtr, Tcl_Obj *objPtr);
 typedef Tcl_Obj * (Tcl_FSLinkProc) (Tcl_Obj *pathPtr, Tcl_Obj *toPtr,
 	int linkType);
 typedef int (Tcl_FSLoadFileProc) (Tcl_Interp *interp, Tcl_Obj *pathPtr,
 	Tcl_LoadHandle *handlePtr, Tcl_FSUnloadFileProc **unloadProcPtr);
 typedef int (Tcl_FSPathInFilesystemProc) (Tcl_Obj *pathPtr,
-	void **clientDataPtr);
+	ClientData *clientDataPtr);
 typedef Tcl_Obj * (Tcl_FSFilesystemPathTypeProc) (Tcl_Obj *pathPtr);
 typedef Tcl_Obj * (Tcl_FSFilesystemSeparatorProc) (Tcl_Obj *pathPtr);
-#define Tcl_FSFreeInternalRepProc Tcl_FreeProc
-typedef void *(Tcl_FSDupInternalRepProc) (void *clientData);
-typedef Tcl_Obj * (Tcl_FSInternalToNormalizedProc) (void *clientData);
-typedef void *(Tcl_FSCreateInternalRepProc) (Tcl_Obj *pathPtr);
+typedef void (Tcl_FSFreeInternalRepProc) (ClientData clientData);
+typedef ClientData (Tcl_FSDupInternalRepProc) (ClientData clientData);
+typedef Tcl_Obj * (Tcl_FSInternalToNormalizedProc) (ClientData clientData);
+typedef ClientData (Tcl_FSCreateInternalRepProc) (Tcl_Obj *pathPtr);
 
 typedef struct Tcl_FSVersion_ *Tcl_FSVersion;
 
 /*
  *----------------------------------------------------------------------------
@@ -1503,11 +1662,11 @@
  * explanations in the structure show the importance of each function.
  */
 
 typedef struct Tcl_Filesystem {
     const char *typeName;	/* The name of the filesystem. */
-    size_t structureLength;	/* Length of this structure, so future binary
+    int structureLength;	/* Length of this structure, so future binary
 				 * compatibility can be assured. */
     Tcl_FSVersion version;	/* Version of the filesystem type. */
     Tcl_FSPathInFilesystemProc *pathInFilesystemProc;
 				/* Function to check whether a path is in this
 				 * filesystem. This is the most important
@@ -1693,12 +1852,12 @@
 
 typedef struct Tcl_Token {
     int type;			/* Type of token, such as TCL_TOKEN_WORD; see
 				 * below for valid types. */
     const char *start;		/* First character in token. */
-    size_t size;			/* Number of bytes in token. */
-    size_t numComponents;		/* If this token is composed of other tokens,
+    int size;			/* Number of bytes in token. */
+    int numComponents;		/* If this token is composed of other tokens,
 				 * this field tells how many of them there are
 				 * (including components of components, etc.).
 				 * The component tokens immediately follow
 				 * this one. */
 } Tcl_Token;
@@ -1760,11 +1919,11 @@
  *				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 preceeded by one
+ *				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
@@ -1808,11 +1967,11 @@
 #define NUM_STATIC_TOKENS 20
 
 typedef struct Tcl_Parse {
     const char *commentStart;	/* Pointer to # that begins the first of one
 				 * or more comments preceding the command. */
-    size_t commentSize;		/* Number of bytes in comments (up through
+    int commentSize;		/* Number of bytes in comments (up through
 				 * newline character that terminates the last
 				 * comment). If there were no comments, this
 				 * field is 0. */
     const char *commandStart;	/* First character in first word of
 				 * command. */
@@ -1876,14 +2035,14 @@
 				/* Function to convert from external encoding
 				 * into UTF-8. */
     Tcl_EncodingConvertProc *fromUtfProc;
 				/* Function to convert from UTF-8 into
 				 * external encoding. */
-    Tcl_FreeProc *freeProc;
+    Tcl_EncodingFreeProc *freeProc;
 				/* If non-NULL, function to call when this
 				 * encoding is deleted. */
-    void *clientData;	/* Arbitrary value associated with encoding
+    ClientData clientData;	/* Arbitrary value associated with encoding
 				 * type. Passed to conversion functions. */
     int nullSize;		/* Number of zero bytes that signify
 				 * end-of-string in this encoding. This number
 				 * is used to determine the source string
 				 * length when the srcLen argument is
@@ -2033,12 +2192,12 @@
 /*
  * Structure containing information about a limit handler to be called when a
  * command- or time-limit is exceeded by an interpreter.
  */
 
-typedef void (Tcl_LimitHandlerProc) (void *clientData, Tcl_Interp *interp);
-typedef void (Tcl_LimitHandlerDeleteProc) (void *clientData);
+typedef void (Tcl_LimitHandlerProc) (ClientData clientData, Tcl_Interp *interp);
+typedef void (Tcl_LimitHandlerDeleteProc) (ClientData clientData);
 
 /*
  *----------------------------------------------------------------------------
  * Override definitions for libtommath.
  */
@@ -2065,11 +2224,11 @@
 				 * depends on type.*/
     void *dstPtr;		/* Address of value to be modified; usage
 				 * depends on type.*/
     const char *helpStr;	/* Documentation message describing this
 				 * option. */
-    void *clientData;	/* Word to pass to function callbacks. */
+    ClientData clientData;	/* Word to pass to function callbacks. */
 } Tcl_ArgvInfo;
 
 /*
  * Legal values for the type field of a Tcl_ArgInfo: see the user
  * documentation for details.
@@ -2088,13 +2247,13 @@
 /*
  * Types of callback functions for the TCL_ARGV_FUNC and TCL_ARGV_GENFUNC
  * argument types:
  */
 
-typedef int (Tcl_ArgvFuncProc)(void *clientData, Tcl_Obj *objPtr,
+typedef int (Tcl_ArgvFuncProc)(ClientData clientData, Tcl_Obj *objPtr,
 	void *dstPtr);
-typedef int (Tcl_ArgvGenFuncProc)(void *clientData, Tcl_Interp *interp,
+typedef int (Tcl_ArgvGenFuncProc)(ClientData clientData, Tcl_Interp *interp,
 	int objc, Tcl_Obj *const *objv, void *dstPtr);
 
 /*
  * Shorthand for commonly used argTable entries.
  */
@@ -2163,32 +2322,32 @@
  */
 #define TCL_TCPSERVER_REUSEADDR (1<<0)
 #define TCL_TCPSERVER_REUSEPORT (1<<1)
 
 /*
- * Constants for special size_t-typed values, see TIP #494
+ * Constants for special int-typed values, see TIP #494
  */
 
-#define TCL_IO_FAILURE	((size_t)-1)
-#define TCL_AUTO_LENGTH	((size_t)-1)
-#define TCL_INDEX_NONE  ((size_t)-1)
+#define TCL_IO_FAILURE	(-1)
+#define TCL_AUTO_LENGTH	(-1)
+#define TCL_INDEX_NONE	(-1)
 
 /*
  *----------------------------------------------------------------------------
  * Single public declaration for NRE.
  */
 
-typedef int (Tcl_NRPostProc) (void *data[], Tcl_Interp *interp,
+typedef int (Tcl_NRPostProc) (ClientData data[], Tcl_Interp *interp,
 				int result);
 
 /*
  *----------------------------------------------------------------------------
  * The following constant is used to test for older versions of Tcl in the
  * stubs tables. If TCL_UTF_MAX>4 use a different value.
  */
 
-#define TCL_STUB_MAGIC		((int) 0xFCA3BACB + (int) sizeof(void *) + (TCL_UTF_MAX>4))
+#define TCL_STUB_MAGIC		((int) 0xFCA3BACF + (TCL_UTF_MAX>4))
 
 /*
  * The following function is required to be defined in all stubs aware
  * extensions. The function is actually implemented in the stub library, not
  * the main Tcl library, although there is a trivial implementation in the
@@ -2198,13 +2357,13 @@
 const char *		Tcl_InitStubs(Tcl_Interp *interp, const char *version,
 			    int exact, int magic);
 const char *		TclTomMathInitializeStubs(Tcl_Interp *interp,
 			    const char *version, int epoch, int revision);
 #if defined(_WIN32)
-    TCL_NORETURN1 void Tcl_ConsolePanic(const char *format, ...);
+    TCL_NORETURN void Tcl_ConsolePanic(const char *format, ...);
 #else
-#   define Tcl_ConsolePanic NULL
+#   define Tcl_ConsolePanic ((Tcl_PanicProc *)0)
 #endif
 
 #ifdef USE_TCL_STUBS
 #if TCL_RELEASE_LEVEL == TCL_FINAL_RELEASE
 #   define Tcl_InitStubs(interp, version, exact) \
@@ -2234,23 +2393,16 @@
  * Tcl_GetMemoryInfo is needed for AOLserver. [Bug 1868171]
  */
 
 #define Tcl_Main(argc, argv, proc) Tcl_MainEx(argc, argv, proc, \
 	    ((Tcl_SetPanicProc(Tcl_ConsolePanic), Tcl_CreateInterp)()))
-EXTERN TCL_NORETURN void Tcl_MainEx(int argc, char **argv,
+EXTERN void		Tcl_MainEx(int argc, char **argv,
 			    Tcl_AppInitProc *appInitProc, Tcl_Interp *interp);
 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 void		Tcl_FindExecutable(const char *argv0);
-EXTERN void		Tcl_SetPanicProc(
-			    TCL_NORETURN1 Tcl_PanicProc *panicProc);
-EXTERN void		Tcl_StaticPackage(Tcl_Interp *interp,
-			    const char *pkgName,
-			    Tcl_PackageInitProc *initProc,
-			    Tcl_PackageInitProc *safeInitProc);
-EXTERN Tcl_ExitProc *Tcl_SetExitProc(TCL_NORETURN1 Tcl_ExitProc *proc);
 #ifndef _WIN32
 EXTERN int		TclZipfs_AppHook(int *argc, char ***argv);
 #endif
 
 /*
@@ -2274,28 +2426,46 @@
 
 #include "tclPlatDecls.h"
 
 /*
  *----------------------------------------------------------------------------
- * The following declarations map ckalloc and ckfree to Tcl_Alloc and
- * Tcl_Free.
+ * The following declarations either map ckalloc and ckfree to malloc and
+ * free, or they map them to functions with all sorts of debugging hooks
+ * defined in tclCkalloc.c.
  */
 
-#define ckalloc Tcl_Alloc
-#define ckfree Tcl_Free
-#define ckrealloc Tcl_Realloc
-#define attemptckalloc Tcl_AttemptAlloc
-#define attemptckrealloc Tcl_AttemptRealloc
+#ifdef TCL_MEM_DEBUG
+
+#   define ckalloc(x) \
+    ((void *) Tcl_DbCkalloc((unsigned)(x), __FILE__, __LINE__))
+#   define ckfree(x) \
+    Tcl_DbCkfree((char *)(x), __FILE__, __LINE__)
+#   define ckrealloc(x,y) \
+    ((void *) Tcl_DbCkrealloc((char *)(x), (unsigned)(y), __FILE__, __LINE__))
+#   define attemptckalloc(x) \
+    ((void *) Tcl_AttemptDbCkalloc((unsigned)(x), __FILE__, __LINE__))
+#   define attemptckrealloc(x,y) \
+    ((void *) Tcl_AttemptDbCkrealloc((char *)(x), (unsigned)(y), __FILE__, __LINE__))
 
-#ifndef TCL_MEM_DEBUG
+#else /* !TCL_MEM_DEBUG */
 
 /*
  * If we are not using the debugging allocator, we should call the Tcl_Alloc,
  * et al. routines in order to guarantee that every module is using the same
  * memory allocator both inside and outside of the Tcl library.
  */
 
+#   define ckalloc(x) \
+    ((void *) Tcl_Alloc((unsigned)(x)))
+#   define ckfree(x) \
+    Tcl_Free((char *)(x))
+#   define ckrealloc(x,y) \
+    ((void *) Tcl_Realloc((char *)(x), (unsigned)(y)))
+#   define attemptckalloc(x) \
+    ((void *) Tcl_AttemptAlloc((unsigned)(x)))
+#   define attemptckrealloc(x,y) \
+    ((void *) Tcl_AttemptRealloc((char *)(x), (unsigned)(y)))
 #   undef  Tcl_InitMemory
 #   define Tcl_InitMemory(x)
 #   undef  Tcl_DumpActiveMemory
 #   define Tcl_DumpActiveMemory(x)
 #   undef  Tcl_ValidateAllMemory
@@ -2311,10 +2481,36 @@
 #   define Tcl_DecrRefCount(objPtr) \
 	Tcl_DbDecrRefCount(objPtr, __FILE__, __LINE__)
 #   undef Tcl_IsShared
 #   define Tcl_IsShared(objPtr) \
 	Tcl_DbIsShared(objPtr, __FILE__, __LINE__)
+#elif (!defined(TCL_NO_DEPRECATED) && defined(USE_TCL_STUBS))
+/*
+ * When compiling stub-enabled extensions without -DTCL_NO_DEPRECATED,
+ * those extensions are expected to run fine with Tcl 8.6 as well.
+ * This means we must continue to use macro's for the above 3 functions,
+ * and the old stub entry for TclFreeObj. All other usage of TclFreeObj()
+ * is forbidden now, therefore it is changed to be MODULE_SCOPE internal.
+ */
+#   undef Tcl_IncrRefCount
+#   define Tcl_IncrRefCount(objPtr) \
+	++(objPtr)->refCount
+    /*
+     * Use do/while0 idiom for optimum correctness without compiler warnings.
+     * http://c2.com/cgi/wiki?TrivialDoWhileLoop
+     */
+#   undef Tcl_DecrRefCount
+#   define Tcl_DecrRefCount(objPtr) \
+	do { \
+	    Tcl_Obj *_objPtr = (objPtr); \
+	    if ((_objPtr)->refCount-- <= 1) { \
+		TclOldFreeObj(_objPtr); \
+	    } \
+	} while(0)
+#   undef Tcl_IsShared
+#   define Tcl_IsShared(objPtr) \
+	((objPtr)->refCount > 1)
 #endif
 
 /*
  * Macros and definitions that help to debug the use of Tcl objects. When
  * TCL_MEM_DEBUG is defined, the Tcl_New declarations are overridden to call
@@ -2352,11 +2548,11 @@
  *----------------------------------------------------------------------------
  * Macros for clients to use to access fields of hash entries:
  */
 
 #define Tcl_GetHashValue(h) ((h)->clientData)
-#define Tcl_SetHashValue(h, value) ((h)->clientData = (void *) (value))
+#define Tcl_SetHashValue(h, value) ((h)->clientData = (ClientData) (value))
 #define Tcl_GetHashKey(tablePtr, h) \
 	((void *) (((tablePtr)->keyType == TCL_ONE_WORD_KEYS || \
 		    (tablePtr)->keyType == TCL_CUSTOM_PTR_KEYS) \
 		   ? (h)->key.oneWordValue \
 		   : (h)->key.string))
@@ -2364,15 +2560,49 @@
 /*
  * Macros to use for clients to use to invoke find and create functions for
  * hash tables:
  */
 
+#undef  Tcl_FindHashEntry
 #define Tcl_FindHashEntry(tablePtr, key) \
 	(*((tablePtr)->findProc))(tablePtr, (const char *)(key))
+#undef  Tcl_CreateHashEntry
 #define Tcl_CreateHashEntry(tablePtr, key, newPtr) \
 	(*((tablePtr)->createProc))(tablePtr, (const char *)(key), newPtr)
 
+/*
+ *----------------------------------------------------------------------------
+ * Deprecated Tcl functions:
+ */
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+/*
+ * These function have been renamed. The old names are deprecated, but we
+ * define these macros for backwards compatibility.
+ */
+
+#   define Tcl_Ckalloc		Tcl_Alloc
+#   define Tcl_Ckfree		Tcl_Free
+#   define Tcl_Ckrealloc	Tcl_Realloc
+#   define Tcl_Return		Tcl_SetResult
+#   define Tcl_TildeSubst	Tcl_TranslateFileName
+#if !defined(__APPLE__) /* On OSX, there is a conflict with "mach/mach.h" */
+#   define panic		Tcl_Panic
+#endif
+#   define panicVA		Tcl_PanicVA
+
+/*
+ *----------------------------------------------------------------------------
+ * Convenience declaration of Tcl_AppInit for backwards compatibility. This
+ * function is not *implemented* by the tcl library, so the storage class is
+ * neither DLLEXPORT nor DLLIMPORT.
+ */
+
+extern Tcl_AppInitProc Tcl_AppInit;
+
+#endif /* !TCL_NO_DEPRECATED */
+
 #endif /* RC_INVOKED */
 
 /*
  * end block for C++
  */

Index: generic/tclAlloc.c
==================================================================
--- generic/tclAlloc.c
+++ generic/tclAlloc.c
@@ -247,17 +247,17 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-void *
+char *
 TclpAlloc(
-    size_t numBytes)	/* Number of bytes to allocate. */
+    unsigned int numBytes)	/* Number of bytes to allocate. */
 {
-    register union overhead *overPtr;
-    register size_t bucket;
-    register size_t amount;
+    union overhead *overPtr;
+    size_t bucket;
+    unsigned amount;
     struct block *bigBlockPtr = NULL;
 
     if (!allocInit) {
 	/*
 	 * We have to make the "self initializing" because Tcl_Alloc may be
@@ -272,12 +272,12 @@
      * First the simple case: we simple allocate big blocks directly.
      */
 
     if (numBytes >= MAXMALLOC - OVERHEAD) {
 	if (numBytes <= UINT_MAX - OVERHEAD -sizeof(struct block)) {
-	    bigBlockPtr = TclpSysAlloc(
-		    sizeof(struct block) + OVERHEAD + numBytes);
+	    bigBlockPtr = (struct block *) TclpSysAlloc(
+		    sizeof(struct block) + OVERHEAD + numBytes, 0);
 	}
 	if (bigBlockPtr == NULL) {
 	    Tcl_MutexUnlock(allocMutexPtr);
 	    return NULL;
 	}
@@ -302,11 +302,11 @@
 	overPtr->rangeCheckMagic = RMAGIC;
 	BLOCK_END(overPtr) = RMAGIC;
 #endif
 
 	Tcl_MutexUnlock(allocMutexPtr);
-	return (void *)(overPtr+1);
+	return (char *)(overPtr+1);
     }
 
     /*
      * Convert amount of memory requested into closest block size stored in
      * hash buckets which satisfies request. Account for space used per block
@@ -385,12 +385,12 @@
 
 static void
 MoreCore(
     size_t bucket)	/* What bucket to allocate to. */
 {
-    register union overhead *overPtr;
-    register size_t size;	/* size of desired block */
+    union overhead *overPtr;
+    size_t size;	/* size of desired block */
     size_t amount;		/* amount to allocate */
     size_t numBlocks;		/* how many blocks we get */
     struct block *blockPtr;
 
     /*
@@ -403,11 +403,12 @@
 
     amount = MAXMALLOC;
     numBlocks = amount / size;
     ASSERT(numBlocks*size == amount);
 
-    blockPtr = TclpSysAlloc(sizeof(struct block) + amount);
+    blockPtr = (struct block *) TclpSysAlloc(
+	    (sizeof(struct block) + amount), 1);
     /* no more room! */
     if (blockPtr == NULL) {
 	return;
     }
     blockPtr->nextPtr = blockList;
@@ -443,14 +444,14 @@
  *----------------------------------------------------------------------
  */
 
 void
 TclpFree(
-    void *oldPtr)		/* Pointer to memory to free. */
+    char *oldPtr)		/* Pointer to memory to free. */
 {
-    register size_t size;
-    register union overhead *overPtr;
+    size_t size;
+    union overhead *overPtr;
     struct block *bigBlockPtr;
 
     if (oldPtr == NULL) {
 	return;
     }
@@ -506,14 +507,14 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-void *
+char *
 TclpRealloc(
-    void *oldPtr,		/* Pointer to alloced block. */
-    size_t numBytes)	/* New size of memory. */
+    char *oldPtr,		/* Pointer to alloced block. */
+    unsigned int numBytes)	/* New size of memory. */
 {
     int i;
     union overhead *overPtr;
     struct block *bigBlockPtr;
     int expensive;
@@ -589,11 +590,11 @@
     } else if (i>0 && numBytes+OVERHEAD < maxSize/2) {
 	expensive = 1;
     }
 
     if (expensive) {
-	void *newPtr;
+	char *newPtr;
 
 	Tcl_MutexUnlock(allocMutexPtr);
 
 	newPtr = TclpAlloc(numBytes);
 	if (newPtr == NULL) {
@@ -642,12 +643,12 @@
 #ifdef MSTATS
 void
 mstats(
     char *s)			/* Where to write info. */
 {
-    register unsigned int i, j;
-    register union overhead *overPtr;
+    unsigned int i, j;
+    union overhead *overPtr;
     size_t totalFree = 0, totalUsed = 0;
 
     Tcl_MutexLock(allocMutexPtr);
 
     fprintf(stderr, "Memory allocation statistics %s\nTclpFree:\t", s);
@@ -689,16 +690,15 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-#undef TclpAlloc
-void *
+char *
 TclpAlloc(
-    size_t numBytes)	/* Number of bytes to allocate. */
+    unsigned int numBytes)	/* Number of bytes to allocate. */
 {
-    return malloc(numBytes);
+    return (char *) malloc(numBytes);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -713,14 +713,13 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-#undef TclpFree
 void
 TclpFree(
-    void *oldPtr)		/* Pointer to memory to free. */
+    char *oldPtr)		/* Pointer to memory to free. */
 {
     free(oldPtr);
     return;
 }
 
@@ -738,16 +737,16 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-void *
+char *
 TclpRealloc(
-    void *oldPtr,		/* Pointer to alloced block. */
-    size_t numBytes)	/* New size of memory. */
+    char *oldPtr,		/* Pointer to alloced block. */
+    unsigned int numBytes)	/* New size of memory. */
 {
-    return realloc(oldPtr, numBytes);
+    return (char *) realloc(oldPtr, numBytes);
 }
 
 #endif /* !USE_TCLALLOC */
 #endif /* !TCL_THREADS */
 

Index: generic/tclAssembly.c
==================================================================
--- generic/tclAssembly.c
+++ generic/tclAssembly.c
@@ -285,12 +285,11 @@
 static int		GetListIndexOperand(AssemblyEnv*, Tcl_Token**, int*);
 static int		GetIntegerOperand(AssemblyEnv*, Tcl_Token**, int*);
 static int		GetNextOperand(AssemblyEnv*, Tcl_Token**, Tcl_Obj**);
 static void		LookForFreshCatches(BasicBlock*, BasicBlock**);
 static void		MoveCodeForJumps(AssemblyEnv*, int);
-static void		MoveExceptionRangesToBasicBlock(AssemblyEnv*, int,
-			    int);
+static void		MoveExceptionRangesToBasicBlock(AssemblyEnv*, int);
 static AssemblyEnv*	NewAssemblyEnv(CompileEnv*, int);
 static int		ProcessCatches(AssemblyEnv*);
 static int		ProcessCatchesInBasicBlock(AssemblyEnv*, BasicBlock*,
 			    BasicBlock*, enum BasicBlockCatchState, int);
 static void		ResetVisitedBasicBlocks(AssemblyEnv*);
@@ -408,10 +407,11 @@
     {"jumpFalse4",	ASSEM_JUMP4,	INST_JUMP_FALSE4,	1,	0},
     {"jumpTable",	ASSEM_JUMPTABLE,INST_JUMP_TABLE,	1,	0},
     {"jumpTrue",	ASSEM_JUMP,	INST_JUMP_TRUE1,	1,	0},
     {"jumpTrue4",	ASSEM_JUMP4,	INST_JUMP_TRUE4,	1,	0},
     {"label",		ASSEM_LABEL,	0,			0,	0},
+    {"land",		ASSEM_1BYTE,	INST_LAND,		2,	1},
     {"lappend",		ASSEM_LVT,	(INST_LAPPEND_SCALAR1<<8
 					 | INST_LAPPEND_SCALAR4),
 								1,	1},
     {"lappendArray",	ASSEM_LVT,	(INST_LAPPEND_ARRAY1<<8
 					 | INST_LAPPEND_ARRAY4),2,	1},
@@ -435,10 +435,11 @@
 					 | INST_LOAD_SCALAR4),	0,	1},
     {"loadArray",	ASSEM_LVT,	(INST_LOAD_ARRAY1<<8
 					 | INST_LOAD_ARRAY4),	1,	1},
     {"loadArrayStk",	ASSEM_1BYTE,	INST_LOAD_ARRAY_STK,	2,	1},
     {"loadStk",		ASSEM_1BYTE,	INST_LOAD_STK,		1,	1},
+    {"lor",		ASSEM_1BYTE,	INST_LOR,		2,	1},
     {"lsetFlat",	ASSEM_LSET_FLAT,INST_LSET_FLAT,		INT_MIN,1},
     {"lsetList",	ASSEM_1BYTE,	INST_LSET_LIST,		3,	1},
     {"lshift",		ASSEM_1BYTE,	INST_LSHIFT,		2,	1},
     {"lt",		ASSEM_1BYTE,	INST_LT,		2,	1},
     {"mod",		ASSEM_1BYTE,	INST_MOD,		2,	1},
@@ -502,11 +503,11 @@
     {"uplus",		ASSEM_1BYTE,	INST_UPLUS,		1,	1},
     {"upvar",		ASSEM_LVT4,	INST_UPVAR,		2,	1},
     {"variable",	ASSEM_LVT4,	INST_VARIABLE,		1,	0},
     {"verifyDict",	ASSEM_1BYTE,	INST_DICT_VERIFY,	1,	0},
     {"yield",		ASSEM_1BYTE,	INST_YIELD,		1,	1},
-    {NULL,		0,		0,			0,	0}
+    {NULL,		ASSEM_1BYTE,		0,			0,	0}
 };
 
 /*
  * List of instructions that cannot throw an exception under any
  * circumstances.  These instructions are the ones that are permissible after
@@ -793,10 +794,11 @@
 {
     ByteCode *codePtr;		/* Pointer to the bytecode to execute */
     Tcl_Obj* backtrace;		/* Object where extra error information is
 				 * constructed. */
 
+    (void)dummy;
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "bytecodeList");
 	return TCL_ERROR;
     }
 
@@ -849,17 +851,17 @@
     Tcl_Obj *objPtr)		/* Source code to assemble */
 {
     Interp *iPtr = (Interp *) interp;
 				/* Internals of the interpreter */
     CompileEnv compEnv;		/* Compilation environment structure */
-    register ByteCode *codePtr = NULL;
+    ByteCode *codePtr = NULL;
 				/* Bytecode resulting from the assembly */
     Namespace* namespacePtr;	/* Namespace in which variable and command
 				 * names in the bytecode resolve */
     int status;			/* Status return from Tcl_AssembleCode */
     const char* source;		/* String representation of the source code */
-    size_t sourceLen;		/* Length of the source code in bytes */
+    int sourceLen;		/* Length of the source code in bytes */
 
     /*
      * Get the expression ByteCode from the object. If it exists, make sure it
      * is valid in the current context.
      */
@@ -966,11 +968,11 @@
     Tcl_Token *tokenPtr;	/* Token in the input script */
 
     int numCommands = envPtr->numCommands;
     int offset = envPtr->codeNext - envPtr->codeStart;
     int depth = envPtr->currStackDepth;
-
+    (void)cmdPtr;
     /*
      * Make sure that the command has a single arg that is a simple word.
      */
 
     if (parsePtr->numWords != 2) {
@@ -989,11 +991,11 @@
     if (TCL_ERROR == TclAssembleCode(envPtr, tokenPtr[1].start,
 	    tokenPtr[1].size, TCL_EVAL_DIRECT)) {
 
 	Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 		"\n    (\"%.*s\" body, line %d)",
-		(int)parsePtr->tokenPtr->size, parsePtr->tokenPtr->start,
+		parsePtr->tokenPtr->size, parsePtr->tokenPtr->start,
 		Tcl_GetErrorLine(interp)));
 	envPtr->numCommands = numCommands;
 	envPtr->codeNext = envPtr->codeStart + offset;
 	envPtr->currStackDepth = depth;
 	TclCompileSyntaxError(interp, envPtr);
@@ -1076,11 +1078,11 @@
 	/*
 	 * Process the line of code.
 	 */
 
 	if (parsePtr->numWords > 0) {
-	    size_t instLen = parsePtr->commandSize;
+	    int instLen = parsePtr->commandSize;
 		    /* Length in bytes of the current command */
 
 	    if (parsePtr->term == parsePtr->commandStart + instLen - 1) {
 		--instLen;
 	    }
@@ -1089,12 +1091,12 @@
 	     * If tracing, show each line assembled as it happens.
 	     */
 
 #ifdef TCL_COMPILE_DEBUG
 	    if ((tclTraceCompile >= 2) && (envPtr->procPtr == NULL)) {
-		printf("  %4" TCL_Z_MODIFIER "d Assembling: ",
-			envPtr->codeNext - envPtr->codeStart);
+		printf("  %4ld Assembling: ",
+			(long)(envPtr->codeNext - envPtr->codeStart));
 		TclPrintSource(stdout, parsePtr->commandStart,
 			TclMin(instLen, 55));
 		printf("\n");
 	    }
 #endif
@@ -1151,13 +1153,13 @@
 				 * generation*/
     int flags)			/* Compilation flags (TCL_EVAL_DIRECT) */
 {
     Tcl_Interp* interp = (Tcl_Interp*) envPtr->iPtr;
 				/* Tcl interpreter */
-    AssemblyEnv* assemEnvPtr = TclStackAlloc(interp, sizeof(AssemblyEnv));
+    AssemblyEnv* assemEnvPtr = (AssemblyEnv*)TclStackAlloc(interp, sizeof(AssemblyEnv));
 				/* Assembler environment under construction */
-    Tcl_Parse* parsePtr = TclStackAlloc(interp, sizeof(Tcl_Parse));
+    Tcl_Parse* parsePtr = (Tcl_Parse*)TclStackAlloc(interp, sizeof(Tcl_Parse));
 				/* Parse of one line of assembly code */
 
     assemEnvPtr->envPtr = envPtr;
     assemEnvPtr->parsePtr = parsePtr;
     assemEnvPtr->cmdLine = 1;
@@ -1216,18 +1218,18 @@
     for (thisBB = assemEnvPtr->head_bb; thisBB != NULL; thisBB = nextBB) {
 	if (thisBB->jumpTarget != NULL) {
 	    Tcl_DecrRefCount(thisBB->jumpTarget);
 	}
 	if (thisBB->foreignExceptions != NULL) {
-	    Tcl_Free(thisBB->foreignExceptions);
+	    ckfree(thisBB->foreignExceptions);
 	}
 	nextBB = thisBB->successor1;
 	if (thisBB->jtPtr != NULL) {
 	    DeleteMirrorJumpTable(thisBB->jtPtr);
 	    thisBB->jtPtr = NULL;
 	}
-	Tcl_Free(thisBB);
+	ckfree(thisBB);
     }
 
     /*
      * Dispose what's left.
      */
@@ -1269,11 +1271,11 @@
 				 * instruction */
     enum TalInstType instType;	/* Type of the instruction */
     Tcl_Obj* operand1Obj = NULL;
 				/* First operand to the instruction */
     const char* operand1;	/* String rep of the operand */
-    size_t operand1Len;		/* String length of the operand */
+    int operand1Len;		/* String length of the operand */
     int opnd;			/* Integer representation of an operand */
     int litIndex;		/* Literal pool index of a constant */
     int localVar;		/* LVT index of a local variable */
     int flags;			/* Flags for a basic block */
     JumptableInfo* jtPtr;	/* Pointer to a jumptable */
@@ -1542,11 +1544,11 @@
 	}
 	if (GetNextOperand(assemEnvPtr, &tokenPtr, &operand1Obj) != TCL_OK) {
 	    goto cleanup;
 	}
 
-	jtPtr = Tcl_Alloc(sizeof(JumptableInfo));
+	jtPtr = (JumptableInfo*)ckalloc(sizeof(JumptableInfo));
 
 	Tcl_InitHashTable(&jtPtr->hashTable, TCL_STRING_KEYS);
 	assemEnvPtr->curr_bb->jumpLine = assemEnvPtr->cmdLine;
 	assemEnvPtr->curr_bb->jumpOffset = envPtr->codeNext-envPtr->codeStart;
 	DEBUG_PRINT("bb %p jumpLine %d jumpOffset %d\n",
@@ -1816,11 +1818,10 @@
      * code.
      */
 
     int savedStackDepth = envPtr->currStackDepth;
     int savedMaxStackDepth = envPtr->maxStackDepth;
-    int savedCodeIndex = envPtr->codeNext - envPtr->codeStart;
     int savedExceptArrayNext = envPtr->exceptArrayNext;
 
     envPtr->currStackDepth = 0;
     envPtr->maxStackDepth = 0;
 
@@ -1849,12 +1850,11 @@
     /*
      * Save any exception ranges that were pushed by the compiler; they will
      * need to be fixed up once the stack depth is known.
      */
 
-    MoveExceptionRangesToBasicBlock(assemEnvPtr, savedCodeIndex,
-	    savedExceptArrayNext);
+    MoveExceptionRangesToBasicBlock(assemEnvPtr, savedExceptArrayNext);
 
     /*
      * Flush the current basic block.
      */
 
@@ -1909,11 +1909,10 @@
  */
 
 static void
 MoveExceptionRangesToBasicBlock(
     AssemblyEnv* assemEnvPtr,	/* Assembly environment */
-    int savedCodeIndex,		/* Start of the embedded code */
     int savedExceptArrayNext)	/* Saved index of the end of the exception
 				 * range array */
 {
     CompileEnv* envPtr = assemEnvPtr->envPtr;
 				/* Compilation environment */
@@ -1941,11 +1940,11 @@
     DEBUG_PRINT("basic block %p has %d exceptions starting at %d\n",
 	    curr_bb, exceptionCount, savedExceptArrayNext);
     curr_bb->foreignExceptionBase = savedExceptArrayNext;
     curr_bb->foreignExceptionCount = exceptionCount;
     curr_bb->foreignExceptions =
-	    Tcl_Alloc(exceptionCount * sizeof(ExceptionRange));
+    		(ExceptionRange*)ckalloc(exceptionCount * sizeof(ExceptionRange));
     memcpy(curr_bb->foreignExceptions,
 	    envPtr->exceptArrayPtr + savedExceptArrayNext,
 	    exceptionCount * sizeof(ExceptionRange));
     for (i = 0; i < exceptionCount; ++i) {
 	curr_bb->foreignExceptions[i].nestingLevel -= envPtr->exceptDepth;
@@ -2006,11 +2005,11 @@
 
     /*
      * Allocate the jumptable.
      */
 
-    jtPtr = Tcl_Alloc(sizeof(JumptableInfo));
+    jtPtr = (JumptableInfo*)ckalloc(sizeof(JumptableInfo));
     jtHashPtr = &jtPtr->hashTable;
     Tcl_InitHashTable(jtHashPtr, TCL_STRING_KEYS);
 
     /*
      * Fill the keys and labels into the table.
@@ -2066,16 +2065,16 @@
     Tcl_Obj* label;		/* Jump label from the hash table */
 
     for (entry = Tcl_FirstHashEntry(jtHashPtr, &search);
 	    entry != NULL;
 	    entry = Tcl_NextHashEntry(&search)) {
-	label = Tcl_GetHashValue(entry);
+	label = (Tcl_Obj*)Tcl_GetHashValue(entry);
 	Tcl_DecrRefCount(label);
 	Tcl_SetHashValue(entry, NULL);
     }
     Tcl_DeleteHashTable(jtHashPtr);
-    Tcl_Free(jtPtr);
+    ckfree(jtPtr);
 }
 
 /*
  *-----------------------------------------------------------------------------
  *
@@ -2314,11 +2313,11 @@
     Tcl_Token* tokenPtr = *tokenPtrPtr;
 				/* INOUT: Pointer to the next token in the
 				 * source code. */
     Tcl_Obj* varNameObj;	/* Name of the variable */
     const char* varNameStr;
-    size_t varNameLen;
+    int varNameLen;
     int localVar;		/* Index of the variable in the LVT */
 
     if (GetNextOperand(assemEnvPtr, tokenPtrPtr, &varNameObj) != TCL_OK) {
 	return -1;
     }
@@ -2654,11 +2653,11 @@
 static BasicBlock *
 AllocBB(
     AssemblyEnv* assemEnvPtr)	/* Assembly environment */
 {
     CompileEnv* envPtr = assemEnvPtr->envPtr;
-    BasicBlock *bb = Tcl_Alloc(sizeof(BasicBlock));
+    BasicBlock *bb = (BasicBlock*)ckalloc(sizeof(BasicBlock));
 
     bb->originalStartOffset =
 	    bb->startOffset = envPtr->codeNext - envPtr->codeStart;
     bb->startLine = assemEnvPtr->cmdLine + 1;
     bb->jumpOffset = -1;
@@ -2845,11 +2844,11 @@
 		/*
 		 * If the instruction is a JUMP1, turn it into a JUMP4 if its
 		 * target is out of range.
 		 */
 
-		jumpTarget = Tcl_GetHashValue(entry);
+		jumpTarget = (BasicBlock*)Tcl_GetHashValue(entry);
 		if (bbPtr->flags & BB_JUMP1) {
 		    offset = jumpTarget->startOffset
 			    - (bbPtr->jumpOffset + motion);
 		    if (offset < -0x80 || offset > 0x7f) {
 			opcode = TclGetUInt1AtPtr(envPtr->codeStart
@@ -2912,11 +2911,11 @@
 
     DEBUG_PRINT("check jump table labels %p {\n", bbPtr);
     for (symEntryPtr = Tcl_FirstHashEntry(symHash, &search);
 	    symEntryPtr != NULL;
 	    symEntryPtr = Tcl_NextHashEntry(&search)) {
-	symbolObj = Tcl_GetHashValue(symEntryPtr);
+	symbolObj = (Tcl_Obj*)Tcl_GetHashValue(symEntryPtr);
 	valEntryPtr = Tcl_FindHashEntry(&assemEnvPtr->labelHash,
 		TclGetString(symbolObj));
 	DEBUG_PRINT("  %s -> %s (%d)\n",
 		(char*) Tcl_GetHashKey(symHash, symEntryPtr),
 		TclGetString(symbolObj), (valEntryPtr != NULL));
@@ -3041,11 +3040,11 @@
 	    bbPtr != NULL;
 	    bbPtr = bbPtr->successor1) {
 	if (bbPtr->jumpTarget != NULL) {
 	    entry = Tcl_FindHashEntry(&assemEnvPtr->labelHash,
 		    TclGetString(bbPtr->jumpTarget));
-	    jumpTarget = Tcl_GetHashValue(entry);
+	    jumpTarget = (BasicBlock*)Tcl_GetHashValue(entry);
 	    fromOffset = bbPtr->jumpOffset;
 	    targetOffset = jumpTarget->startOffset;
 	    if (bbPtr->flags & BB_JUMP1) {
 		TclStoreInt1AtPtr(targetOffset - fromOffset,
 			envPtr->codeStart + fromOffset + 1);
@@ -3100,11 +3099,11 @@
     int junk;
 
     auxDataIndex = TclGetInt4AtPtr(envPtr->codeStart + bbPtr->jumpOffset + 1);
     DEBUG_PRINT("bbPtr = %p jumpOffset = %d auxDataIndex = %d\n",
 	    bbPtr, bbPtr->jumpOffset, auxDataIndex);
-    realJumpTablePtr = TclFetchAuxData(envPtr, auxDataIndex);
+    realJumpTablePtr = (JumptableInfo*)TclFetchAuxData(envPtr, auxDataIndex);
     realJumpHashPtr = &realJumpTablePtr->hashTable;
 
     /*
      * Look up every jump target in the jump hash.
      */
@@ -3111,16 +3110,16 @@
 
     DEBUG_PRINT("resolve jump table {\n");
     for (symEntryPtr = Tcl_FirstHashEntry(symHash, &search);
 	    symEntryPtr != NULL;
 	    symEntryPtr = Tcl_NextHashEntry(&search)) {
-	symbolObj = Tcl_GetHashValue(symEntryPtr);
+	symbolObj = (Tcl_Obj*)Tcl_GetHashValue(symEntryPtr);
 	DEBUG_PRINT("     symbol %s\n", TclGetString(symbolObj));
 
 	valEntryPtr = Tcl_FindHashEntry(&assemEnvPtr->labelHash,
 		TclGetString(symbolObj));
-	jumpTargetBBPtr = Tcl_GetHashValue(valEntryPtr);
+	jumpTargetBBPtr = (BasicBlock*)Tcl_GetHashValue(valEntryPtr);
 
 	realJumpEntryPtr = Tcl_CreateHashEntry(realJumpHashPtr,
 		Tcl_GetHashKey(symHash, symEntryPtr), &junk);
 	DEBUG_PRINT("  %s -> %s -> bb %p (pc %d)    hash entry %p\n",
 		(char*) Tcl_GetHashKey(symHash, symEntryPtr),
@@ -3495,11 +3494,11 @@
     }
 
     if (result == TCL_OK && blockPtr->jumpTarget != NULL) {
 	entry = Tcl_FindHashEntry(&assemEnvPtr->labelHash,
 		TclGetString(blockPtr->jumpTarget));
-	jumpTarget = Tcl_GetHashValue(entry);
+	jumpTarget = (BasicBlock*)Tcl_GetHashValue(entry);
 	result = StackCheckBasicBlock(assemEnvPtr, jumpTarget, blockPtr,
 		stackDepth);
     }
 
     /*
@@ -3509,14 +3508,14 @@
     if (blockPtr->flags & BB_JUMPTABLE) {
 	for (jtEntry = Tcl_FirstHashEntry(&blockPtr->jtPtr->hashTable,
 		    &jtSearch);
 		result == TCL_OK && jtEntry != NULL;
 		jtEntry = Tcl_NextHashEntry(&jtSearch)) {
-	    targetLabel = Tcl_GetHashValue(jtEntry);
+	    targetLabel = (Tcl_Obj*)Tcl_GetHashValue(jtEntry);
 	    entry = Tcl_FindHashEntry(&assemEnvPtr->labelHash,
 		    TclGetString(targetLabel));
-	    jumpTarget = Tcl_GetHashValue(entry);
+	    jumpTarget = (BasicBlock*)Tcl_GetHashValue(entry);
 	    result = StackCheckBasicBlock(assemEnvPtr, jumpTarget,
 		    blockPtr, stackDepth);
 	}
     }
 
@@ -3817,11 +3816,11 @@
 		fallThruEnclosing, fallThruState, catchDepth);
     }
     if (result == TCL_OK && bbPtr->jumpTarget != NULL) {
 	entry = Tcl_FindHashEntry(&assemEnvPtr->labelHash,
 		TclGetString(bbPtr->jumpTarget));
-	jumpTarget = Tcl_GetHashValue(entry);
+	jumpTarget = (BasicBlock*)Tcl_GetHashValue(entry);
 	result = ProcessCatchesInBasicBlock(assemEnvPtr, jumpTarget,
 		jumpEnclosing, jumpState, catchDepth);
     }
 
     /*
@@ -3830,14 +3829,14 @@
 
     if (bbPtr->flags & BB_JUMPTABLE) {
 	for (jtEntry = Tcl_FirstHashEntry(&bbPtr->jtPtr->hashTable,&jtSearch);
 		result == TCL_OK && jtEntry != NULL;
 		jtEntry = Tcl_NextHashEntry(&jtSearch)) {
-	    targetLabel = Tcl_GetHashValue(jtEntry);
+	    targetLabel = (Tcl_Obj*)Tcl_GetHashValue(jtEntry);
 	    entry = Tcl_FindHashEntry(&assemEnvPtr->labelHash,
 		    TclGetString(targetLabel));
-	    jumpTarget = Tcl_GetHashValue(entry);
+	    jumpTarget = (BasicBlock*)Tcl_GetHashValue(entry);
 	    result = ProcessCatchesInBasicBlock(assemEnvPtr, jumpTarget,
 		    jumpEnclosing, jumpState, catchDepth);
 	}
     }
 
@@ -3932,12 +3931,12 @@
 
     /*
      * Allocate memory for a stack of active catches.
      */
 
-    catches = Tcl_Alloc(maxCatchDepth * sizeof(BasicBlock*));
-    catchIndices = Tcl_Alloc(maxCatchDepth * sizeof(int));
+    catches = (BasicBlock**)ckalloc(maxCatchDepth * sizeof(BasicBlock*));
+    catchIndices = (int *)ckalloc(maxCatchDepth * sizeof(int));
     for (i = 0; i < maxCatchDepth; ++i) {
 	catches[i] = NULL;
 	catchIndices[i] = -1;
     }
 
@@ -3972,12 +3971,12 @@
 		"tclAssembly.c:BuildExceptionRanges, can't happen");
     }
 
     /* Free temp storage */
 
-    Tcl_Free(catchIndices);
-    Tcl_Free(catches);
+    ckfree(catchIndices);
+    ckfree(catches);
 
     return TCL_OK;
 }
 
 /*
@@ -4001,11 +4000,11 @@
     BasicBlock** catches,	/* Array of catch contexts */
     int* catchIndices)		/* Indices of the exception ranges
 				 * corresponding to the catch contexts */
 {
     ExceptionRange* range;	/* Exception range for a specific catch */
-    BasicBlock* catch;		/* Catch block being examined */
+    BasicBlock* block;		/* Catch block being examined */
     BasicBlockCatchState catchState;
 				/* State of the code relative to the catch
 				 * block being examined ("in catch" or
 				 * "caught"). */
 
@@ -4029,22 +4028,22 @@
      * either because they are no longer part of the context, or because the
      * context has changed from INCATCH to CAUGHT.
      */
 
     catchState = bbPtr->catchState;
-    catch = bbPtr->enclosingCatch;
+    block = bbPtr->enclosingCatch;
     while (catchDepth > 0) {
 	--catchDepth;
 	if (catches[catchDepth] != NULL) {
-	    if (catches[catchDepth] != catch || catchState >= BBCS_CAUGHT) {
+	    if (catches[catchDepth] != block || catchState >= BBCS_CAUGHT) {
 		range = envPtr->exceptArrayPtr + catchIndices[catchDepth];
 		range->numCodeBytes = bbPtr->startOffset - range->codeOffset;
 		catches[catchDepth] = NULL;
 		catchIndices[catchDepth] = -1;
 	    }
-	    catchState = catch->catchState;
-	    catch = catch->enclosingCatch;
+	    catchState = block->catchState;
+	    block = block->enclosingCatch;
 	}
     }
 }
 
 /*
@@ -4069,23 +4068,23 @@
 				 * entered */
 {
     BasicBlockCatchState catchState;
 				/* State ("in catch" or "caught") of the
 				 * current catch. */
-    BasicBlock* catch;		/* Current enclosing catch */
+    BasicBlock* block;		/* Current enclosing catch */
     int catchDepth;		/* Nesting depth of the current catch */
 
     catchState = bbPtr->catchState;
-    catch = bbPtr->enclosingCatch;
+    block = bbPtr->enclosingCatch;
     catchDepth = bbPtr->catchDepth;
     while (catchDepth > 0) {
 	--catchDepth;
-	if (catches[catchDepth] != catch && catchState < BBCS_CAUGHT) {
-	    catches[catchDepth] = catch;
+	if (catches[catchDepth] != block && catchState < BBCS_CAUGHT) {
+	    catches[catchDepth] = block;
 	}
-	catchState = catch->catchState;
-	catch = catch->enclosingCatch;
+	catchState = block->catchState;
+	block = block->enclosingCatch;
     }
 }
 
 /*
  *-----------------------------------------------------------------------------
@@ -4109,11 +4108,11 @@
 				 * corresponding to the catch contexts */
 {
     CompileEnv* envPtr = assemEnvPtr->envPtr;
 				/* Compilation environment */
     ExceptionRange* range;	/* Exception range for a specific catch */
-    BasicBlock* catch;		/* Catch block being examined */
+    BasicBlock* block;		/* Catch block being examined */
     BasicBlock* errorExit;	/* Error exit from the catch block */
     Tcl_HashEntry* entryPtr;
 
     catchDepth = 0;
 
@@ -4126,27 +4125,27 @@
 	if (catchIndices[catchDepth] == -1 && catches[catchDepth] != NULL) {
 	    /*
 	     * Create an exception range for a block that needs one.
 	     */
 
-	    catch = catches[catchDepth];
+	    block = catches[catchDepth];
 	    catchIndices[catchDepth] =
 		    TclCreateExceptRange(CATCH_EXCEPTION_RANGE, envPtr);
 	    range = envPtr->exceptArrayPtr + catchIndices[catchDepth];
 	    range->nestingLevel = envPtr->exceptDepth + catchDepth;
 	    envPtr->maxExceptDepth =
 		    TclMax(range->nestingLevel + 1, envPtr->maxExceptDepth);
 	    range->codeOffset = bbPtr->startOffset;
 
 	    entryPtr = Tcl_FindHashEntry(&assemEnvPtr->labelHash,
-		    TclGetString(catch->jumpTarget));
+		    TclGetString(block->jumpTarget));
 	    if (entryPtr == NULL) {
 		Tcl_Panic("undefined label in tclAssembly.c:"
 			"BuildExceptionRanges, can't happen");
 	    }
 
-	    errorExit = Tcl_GetHashValue(entryPtr);
+	    errorExit = (BasicBlock*)Tcl_GetHashValue(entryPtr);
 	    range->catchOffset = errorExit->startOffset;
 	}
     }
 }
 
@@ -4318,10 +4317,12 @@
 static void
 DupAssembleCodeInternalRep(
     Tcl_Obj *srcPtr,
     Tcl_Obj *copyPtr)
 {
+    (void)srcPtr;
+    (void)copyPtr;
     return;
 }
 
 /*
  *-----------------------------------------------------------------------------

Index: generic/tclAsync.c
==================================================================
--- generic/tclAsync.c
+++ generic/tclAsync.c
@@ -116,11 +116,11 @@
     ClientData clientData)	/* Argument to pass to handler. */
 {
     AsyncHandler *asyncPtr;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
-    asyncPtr = Tcl_Alloc(sizeof(AsyncHandler));
+    asyncPtr = (AsyncHandler*)ckalloc(sizeof(AsyncHandler));
     asyncPtr->ready = 0;
     asyncPtr->nextPtr = NULL;
     asyncPtr->proc = proc;
     asyncPtr->clientData = clientData;
     asyncPtr->originTsd = tsdPtr;
@@ -308,11 +308,11 @@
 	if (asyncPtr == tsdPtr->lastHandler) {
 	    tsdPtr->lastHandler = prevPtr;
 	}
     }
     Tcl_MutexUnlock(&tsdPtr->asyncMutex);
-    Tcl_Free(asyncPtr);
+    ckfree(asyncPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *

Index: generic/tclBasic.c
==================================================================
--- generic/tclBasic.c
+++ generic/tclBasic.c
@@ -31,24 +31,37 @@
  *	2  - simulate
  *	3  - __builtin_fpclassify
  */
 
 #ifndef TCL_FPCLASSIFY_MODE
+#if defined(__MINGW32__) && defined(_X86_) /* mingw 32-bit */
 /*
  * MINGW x86 (tested up to gcc 8.1) seems to have a bug in fpclassify,
- * [fpclassify 1e-314], x86 => normal, x64 => subnormal, so switch to _fpclass
+ * [fpclassify 1e-314], x86 => normal, x64 => subnormal, so switch to using a
+ * version using a compiler built-in.
  */
-# if ( defined(__MINGW32__) && defined(_X86_) ) /* mingw 32-bit */
-#   define TCL_FPCLASSIFY_MODE 1
-# elif defined(fpclassify)		/* fpclassify */
-#   include <float.h>
-#   define TCL_FPCLASSIFY_MODE 0
-# elif defined(_FPCLASS_NN)		/* _fpclass */
-#   define TCL_FPCLASSIFY_MODE 1
-# else	/* !fpclassify && !_fpclass (older MSVC), simulate */
-#   define TCL_FPCLASSIFY_MODE 2
-# endif /* !fpclassify */
+#define TCL_FPCLASSIFY_MODE 1
+#elif defined(fpclassify)		/* fpclassify */
+/*
+ * This is the C99 standard.
+ */
+#include <float.h>
+#define TCL_FPCLASSIFY_MODE 0
+#elif defined(_FPCLASS_NN)		/* _fpclass */
+/*
+ * This case handles newer MSVC on Windows, which doesn't have the standard
+ * operation but does have something that can tell us the same thing.
+ */
+#define TCL_FPCLASSIFY_MODE 1
+#else	/* !fpclassify && !_fpclass (older MSVC), simulate */
+/*
+ * Older MSVC on Windows. So broken that we just have to do it our way. This
+ * assumes that we're on x86 (or at least a system with classic little-endian
+ * double layout and a 32-bit 'int' type).
+ */
+#define TCL_FPCLASSIFY_MODE 2
+#endif /* !fpclassify */
 /* actually there is no fallback to builtin fpclassify */
 #endif /* !TCL_FPCLASSIFY_MODE */
 
 
 #define INTERP_STACK_INITIAL_SIZE 2000
@@ -62,10 +75,22 @@
 #   define IEEE_FLOATING_POINT
 /* Largest odd integer that can be represented exactly in a double */
 #   define MAX_EXACT 9007199254740991.0
 #endif
 
+/*
+ * The following structure defines the client data for a math function
+ * registered with Tcl_CreateMathFunc
+ */
+
+typedef struct OldMathFuncData {
+    Tcl_MathProc *proc;		/* Handler function */
+    int numArgs;		/* Number of args expected */
+    Tcl_ValueType *argTypes;	/* Types of the args */
+    ClientData clientData;	/* Client data for the handler function */
+} OldMathFuncData;
+
 /*
  * This is the script cancellation struct and hash table. The hash table is
  * used to keep track of the information necessary to process script
  * cancellation requests, including the original interp, asynchronous handler
  * tokens (created by Tcl_AsyncCreate), and the clientData and flags arguments
@@ -78,11 +103,11 @@
     Tcl_Interp *interp;		/* Interp this struct belongs to. */
     Tcl_AsyncHandler async;	/* Async handler token for script
 				 * cancellation. */
     char *result;		/* The script cancellation result or NULL for
 				 * a default result. */
-    size_t length;		/* Length of the above error message. */
+    int length;			/* Length of the above error message. */
     ClientData clientData;	/* Ignored */
     int flags;			/* Additional flags */
 } CancelInfo;
 static Tcl_HashTable cancelTable;
 static int cancelTableInitialized = 0;	/* 0 means not yet initialized. */
@@ -163,10 +188,14 @@
 			    int actual, Tcl_Obj *const *objv);
 static Tcl_NRPostProc	NRCoroutineCallerCallback;
 static Tcl_NRPostProc	NRCoroutineExitCallback;
 static Tcl_NRPostProc	NRCommand;
 
+#if !defined(TCL_NO_DEPRECATED)
+static Tcl_ObjCmdProc	OldMathFuncProc;
+static void		OldMathFuncDeleteProc(ClientData clientData);
+#endif /* !defined(TCL_NO_DEPRECATED) */
 static void		ProcessUnexpectedResult(Tcl_Interp *interp,
 			    int returnCode);
 static int		RewindCoroutine(CoroutineData *corPtr, int result);
 static void		TEOV_SwitchVarFrame(Tcl_Interp *interp);
 static void		TEOV_PushExceptionHandlers(Tcl_Interp *interp,
@@ -257,10 +286,13 @@
      */
 
     {"append",		Tcl_AppendObjCmd,	TclCompileAppendCmd,	NULL,	CMD_IS_SAFE},
     {"apply",		Tcl_ApplyObjCmd,	NULL,			TclNRApplyObjCmd,	CMD_IS_SAFE},
     {"break",		Tcl_BreakObjCmd,	TclCompileBreakCmd,	NULL,	CMD_IS_SAFE},
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+    {"case",		Tcl_CaseObjCmd,		NULL,			NULL,	CMD_IS_SAFE},
+#endif
     {"catch",		Tcl_CatchObjCmd,	TclCompileCatchCmd,	TclNRCatchObjCmd,	CMD_IS_SAFE},
     {"concat",		Tcl_ConcatObjCmd,	TclCompileConcatCmd,	NULL,	CMD_IS_SAFE},
     {"continue",	Tcl_ContinueObjCmd,	TclCompileContinueCmd,	NULL,	CMD_IS_SAFE},
     {"coroinject",	NULL,			NULL,                   TclNRCoroInjectObjCmd,	CMD_IS_SAFE},
     {"coroprobe",	NULL,			NULL,                   TclNRCoroProbeObjCmd,	CMD_IS_SAFE},
@@ -611,11 +643,11 @@
     ByteCodeStats *statsPtr;
 #endif /* TCL_COMPILE_STATS */
     char mathFuncName[32];
     CallFrame *framePtr;
 
-    TclInitSubsystems();
+    Tcl_InitSubsystems();
 
     /*
      * Panic if someone updated the CallFrame structure without also updating
      * the Tcl_CallFrame structure (or vice versa).
      */
@@ -623,11 +655,19 @@
     if (sizeof(Tcl_CallFrame) < sizeof(CallFrame)) {
 	/*NOTREACHED*/
 	Tcl_Panic("Tcl_CallFrame must not be smaller than CallFrame");
     }
 
-#if defined(_WIN32) && !defined(_WIN64)
+#if defined(_WIN32) && !defined(_WIN64) && !defined(_USE_64BIT_TIME_T) \
+	    && !defined(__MINGW_USE_VC2005_COMPAT)
+    /* If Tcl is compiled on Win32 using -D_USE_64BIT_TIME_T or
+     * -D__MINGW_USE_VC2005_COMPAT, the result is a binary incompatible
+     * with the 'standard' build of Tcl: All extensions using Tcl_StatBuf
+     * or interal functions like TclpGetDate() need to be recompiled in
+     * the same way. Therefore, this is not officially supported.
+     * In stead, it is recommended to use Win64 or Tcl 9.0 (not released yet)
+     */
     if (sizeof(time_t) != 4) {
 	/*NOTREACHED*/
 	Tcl_Panic("<time.h> is not compatible with MSVC");
     }
     if ((offsetof(Tcl_StatBuf,st_atime) != 32)
@@ -664,27 +704,29 @@
      * Initialize support for namespaces and create the global namespace
      * (whose name is ""; an alias is "::"). This also initializes the Tcl
      * object type table and other object management code.
      */
 
-    iPtr = Tcl_Alloc(sizeof(Interp));
+    iPtr = ckalloc(sizeof(Interp));
     interp = (Tcl_Interp *) iPtr;
 
-    iPtr->legacyResult = NULL;
-    /* Special invalid value: Any attempt to free the legacy result
-     * will cause a crash. */
-    iPtr->legacyFreeProc = (void (*) (void))-1;
+#ifdef TCL_NO_DEPRECATED
+    iPtr->result = &tclEmptyString;
+#else
+    iPtr->result = iPtr->resultSpace;
+#endif
+    iPtr->freeProc = NULL;
     iPtr->errorLine = 0;
-    iPtr->stubTable = &tclStubs;
     iPtr->objResultPtr = Tcl_NewObj();
     Tcl_IncrRefCount(iPtr->objResultPtr);
     iPtr->handle = TclHandleCreate(iPtr);
     iPtr->globalNsPtr = NULL;
     iPtr->hiddenCmdTablePtr = NULL;
     iPtr->interpInfo = NULL;
 
-    iPtr->optimizer = TclOptimizeBytecode;
+    TCL_CT_ASSERT(sizeof(iPtr->extra) <= sizeof(Tcl_HashTable));
+    iPtr->extra.optimizer = TclOptimizeBytecode;
 
     iPtr->numLevels = 0;
     iPtr->maxNestingDepth = MAX_NESTING_DEPTH;
     iPtr->framePtr = NULL;	/* Initialise as soon as :: is available */
     iPtr->varFramePtr = NULL;	/* Initialise as soon as :: is available */
@@ -693,14 +735,14 @@
      * TIP #280 - Initialize the arrays used to extend the ByteCode and Proc
      * structures.
      */
 
     iPtr->cmdFramePtr = NULL;
-    iPtr->linePBodyPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
-    iPtr->lineBCPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
-    iPtr->lineLAPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
-    iPtr->lineLABCPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+    iPtr->linePBodyPtr = ckalloc(sizeof(Tcl_HashTable));
+    iPtr->lineBCPtr = ckalloc(sizeof(Tcl_HashTable));
+    iPtr->lineLAPtr = ckalloc(sizeof(Tcl_HashTable));
+    iPtr->lineLABCPtr = ckalloc(sizeof(Tcl_HashTable));
     Tcl_InitHashTable(iPtr->linePBodyPtr, TCL_ONE_WORD_KEYS);
     Tcl_InitHashTable(iPtr->lineBCPtr, TCL_ONE_WORD_KEYS);
     Tcl_InitHashTable(iPtr->lineLAPtr, TCL_ONE_WORD_KEYS);
     Tcl_InitHashTable(iPtr->lineLABCPtr, TCL_ONE_WORD_KEYS);
     iPtr->scriptCLLocPtr = NULL;
@@ -728,10 +770,16 @@
     iPtr->returnLevel = 1;
     iPtr->returnCode = TCL_OK;
 
     iPtr->rootFramePtr = NULL;	/* Initialise as soon as :: is available */
     iPtr->lookupNsPtr = NULL;
+
+#ifndef TCL_NO_DEPRECATED
+    iPtr->appendResult = NULL;
+    iPtr->appendAvl = 0;
+    iPtr->appendUsed = 0;
+#endif
 
     Tcl_InitHashTable(&iPtr->packageTable, TCL_STRING_KEYS);
     iPtr->packageUnknown = NULL;
 
     /* TIP #268 */
@@ -757,10 +805,13 @@
     iPtr->assocData = NULL;
     iPtr->execEnvPtr = NULL;	/* Set after namespaces initialized. */
     iPtr->emptyObjPtr = Tcl_NewObj();
 				/* Another empty object. */
     Tcl_IncrRefCount(iPtr->emptyObjPtr);
+#ifndef TCL_NO_DEPRECATED
+    iPtr->resultSpace[0] = 0;
+#endif
     iPtr->threadId = Tcl_GetCurrentThread();
 
     /* TIP #378 */
 #ifdef TCL_INTERP_DEBUG_FRAME
     iPtr->flags |= INTERP_DEBUG_FRAME;
@@ -790,11 +841,11 @@
      * Initialise the rootCallframe. It cannot be allocated on the stack, as
      * it has to be in place before TclCreateExecEnv tries to use a variable.
      */
 
     /* This is needed to satisfy GCC 3.3's strict aliasing rules */
-    framePtr = Tcl_Alloc(sizeof(CallFrame));
+    framePtr = ckalloc(sizeof(CallFrame));
     (void) Tcl_PushCallFrame(interp, (Tcl_CallFrame *) framePtr,
 	    (Tcl_Namespace *) iPtr->globalNsPtr, /*isProcCallFrame*/ 0);
     framePtr->objc = 0;
 
     iPtr->framePtr = framePtr;
@@ -820,11 +871,11 @@
      * TIP #285, Script cancellation support.
      */
 
     iPtr->asyncCancelMsg = Tcl_NewObj();
 
-    cancelInfo = Tcl_Alloc(sizeof(CancelInfo));
+    cancelInfo = ckalloc(sizeof(CancelInfo));
     cancelInfo->interp = interp;
 
     iPtr->asyncCancel = Tcl_AsyncCreate(CancelEvalProc, cancelInfo);
     cancelInfo->async = iPtr->asyncCancel;
     cancelInfo->result = NULL;
@@ -866,10 +917,16 @@
     statsPtr->totalLitStringBytes = 0.0;
     statsPtr->currentLitStringBytes = 0.0;
     memset(statsPtr->literalCount, 0, sizeof(statsPtr->literalCount));
 #endif /* TCL_COMPILE_STATS */
 
+    /*
+     * Initialise the stub table pointer.
+     */
+
+    iPtr->stubTable = &tclStubs;
+
     /*
      * Initialize the ensemble error message rewriting support.
      */
 
     TclResetRewriteEnsemble(interp, 1);
@@ -913,11 +970,11 @@
 	}
 
 	hPtr = Tcl_CreateHashEntry(&iPtr->globalNsPtr->cmdTable,
 		cmdInfoPtr->name, &isNew);
 	if (isNew) {
-	    cmdPtr = Tcl_Alloc(sizeof(Command));
+	    cmdPtr = ckalloc(sizeof(Command));
 	    cmdPtr->hPtr = hPtr;
 	    cmdPtr->nsPtr = iPtr->globalNsPtr;
 	    cmdPtr->refCount = 1;
 	    cmdPtr->cmdEpoch = 0;
 	    cmdPtr->compileProc = cmdInfoPtr->compileProc;
@@ -1043,11 +1100,11 @@
     }
     Tcl_Export(interp, nsPtr, "*", 1);
 #define MATH_OP_PREFIX_LEN 15 /* == strlen("::tcl::mathop::") */
     memcpy(mathFuncName, "::tcl::mathop::", MATH_OP_PREFIX_LEN);
     for (opcmdInfoPtr=mathOpCmds ; opcmdInfoPtr->name!=NULL ; opcmdInfoPtr++){
-	TclOpCmdClientData *occdPtr = Tcl_Alloc(sizeof(TclOpCmdClientData));
+	TclOpCmdClientData *occdPtr = ckalloc(sizeof(TclOpCmdClientData));
 
 	occdPtr->op = opcmdInfoPtr->name;
 	occdPtr->i.numArgs = opcmdInfoPtr->i.numArgs;
 	occdPtr->expected = opcmdInfoPtr->expected;
 	strcpy(mathFuncName + MATH_OP_PREFIX_LEN, opcmdInfoPtr->name);
@@ -1101,10 +1158,15 @@
      * Set up other variables such as tcl_version and tcl_library
      */
 
     Tcl_SetVar2(interp, "tcl_patchLevel", NULL, TCL_PATCH_LEVEL, TCL_GLOBAL_ONLY);
     Tcl_SetVar2(interp, "tcl_version", NULL, TCL_VERSION, TCL_GLOBAL_ONLY);
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+    Tcl_TraceVar2(interp, "tcl_precision", NULL,
+	    TCL_GLOBAL_ONLY|TCL_TRACE_READS|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
+	    TclPrecTraceProc, NULL);
+#endif /* !TCL_NO_DEPRECATED */
     TclpSetVariables(interp);
 
 #if TCL_THREADS
     /*
      * The existence of the "threaded" element of the tcl_platform array
@@ -1122,28 +1184,28 @@
      */
 
     Tcl_PkgProvideEx(interp, "Tcl", TCL_PATCH_LEVEL, &tclStubs);
 
     if (TclTommath_Init(interp) != TCL_OK) {
-	Tcl_Panic("%s", Tcl_GetStringResult(interp));
+	Tcl_Panic("%s", TclGetString(Tcl_GetObjResult(interp)));
     }
 
     if (TclOOInit(interp) != TCL_OK) {
-	Tcl_Panic("%s", Tcl_GetStringResult(interp));
+	Tcl_Panic("%s", TclGetString(Tcl_GetObjResult(interp)));
     }
 
     /*
      * Only build in zlib support if we've successfully detected a library to
      * compile and link against.
      */
 
 #ifdef HAVE_ZLIB
     if (TclZlibInit(interp) != TCL_OK) {
-	Tcl_Panic("%s", Tcl_GetStringResult(interp));
+	Tcl_Panic("%s", TclGetString(Tcl_GetObjResult(interp)));
     }
     if (TclZipfs_Init(interp) != TCL_OK) {
-	Tcl_Panic("%s", Tcl_GetStringResult(interp));
+	Tcl_Panic("%s", Tcl_GetString(Tcl_GetObjResult(interp)));
     }
 #endif
 
     TOP_CB(iPtr) = NULL;
     return interp;
@@ -1153,11 +1215,11 @@
 DeleteOpCmdClientData(
     ClientData clientData)
 {
     TclOpCmdClientData *occdPtr = clientData;
 
-    Tcl_Free(occdPtr);
+    ckfree(occdPtr);
 }
 
 /*
  * ---------------------------------------------------------------------
  *
@@ -1241,12 +1303,12 @@
 
 int
 TclHideUnsafeCommands(
     Tcl_Interp *interp)		/* Hide commands in this interpreter. */
 {
-    register const CmdInfo *cmdInfoPtr;
-    register const UnsafeEnsembleInfo *unsafePtr;
+    const CmdInfo *cmdInfoPtr;
+    const UnsafeEnsembleInfo *unsafePtr;
 
     if (interp == NULL) {
 	return TCL_ERROR;
     }
     for (cmdInfoPtr = builtInCmds; cmdInfoPtr->name != NULL; cmdInfoPtr++) {
@@ -1271,11 +1333,11 @@
                         "___tmp") != TCL_OK
                     || Tcl_HideCommand(interp, "___tmp",
                             TclGetString(hideName)) != TCL_OK) {
                 Tcl_Panic("problem making '%s %s' safe: %s",
                         unsafePtr->ensembleNsName, unsafePtr->commandName,
-                        Tcl_GetStringResult(interp));
+                        Tcl_GetString(Tcl_GetObjResult(interp)));
             }
             Tcl_CreateObjCommand(interp, TclGetString(cmdName),
                     BadEnsembleSubcommand, (ClientData) unsafePtr, NULL);
             TclDecrRefCount(cmdName);
             TclDecrRefCount(hideName);
@@ -1286,11 +1348,11 @@
 
             if (Tcl_HideCommand(interp, unsafePtr->ensembleNsName,
                     unsafePtr->ensembleNsName) != TCL_OK) {
                 Tcl_Panic("problem making '%s' safe: %s",
                         unsafePtr->ensembleNsName,
-                        Tcl_GetStringResult(interp));
+                        Tcl_GetString(Tcl_GetObjResult(interp)));
             }
         }
     }
 
     return TCL_OK;
@@ -1362,18 +1424,18 @@
     static Tcl_ThreadDataKey assocDataCounterKey;
     int *assocDataCounterPtr =
 	    Tcl_GetThreadData(&assocDataCounterKey, sizeof(int));
     int isNew;
     char buffer[32 + TCL_INTEGER_SPACE];
-    AssocData *dPtr = Tcl_Alloc(sizeof(AssocData));
+    AssocData *dPtr = ckalloc(sizeof(AssocData));
     Tcl_HashEntry *hPtr;
 
     sprintf(buffer, "Assoc Data Key #%d", *assocDataCounterPtr);
     (*assocDataCounterPtr)++;
 
     if (iPtr->assocData == NULL) {
-	iPtr->assocData = Tcl_Alloc(sizeof(Tcl_HashTable));
+	iPtr->assocData = ckalloc(sizeof(Tcl_HashTable));
 	Tcl_InitHashTable(iPtr->assocData, TCL_STRING_KEYS);
     }
     hPtr = Tcl_CreateHashEntry(iPtr->assocData, buffer, &isNew);
     dPtr->proc = proc;
     dPtr->clientData = clientData;
@@ -1418,11 +1480,11 @@
     }
     for (hPtr = Tcl_FirstHashEntry(hTablePtr, &hSearch); hPtr != NULL;
 	    hPtr = Tcl_NextHashEntry(&hSearch)) {
 	dPtr = Tcl_GetHashValue(hPtr);
 	if ((dPtr->proc == proc) && (dPtr->clientData == clientData)) {
-	    Tcl_Free(dPtr);
+	    ckfree(dPtr);
 	    Tcl_DeleteHashEntry(hPtr);
 	    return;
 	}
     }
 }
@@ -1458,18 +1520,18 @@
     AssocData *dPtr;
     Tcl_HashEntry *hPtr;
     int isNew;
 
     if (iPtr->assocData == NULL) {
-	iPtr->assocData = Tcl_Alloc(sizeof(Tcl_HashTable));
+	iPtr->assocData = ckalloc(sizeof(Tcl_HashTable));
 	Tcl_InitHashTable(iPtr->assocData, TCL_STRING_KEYS);
     }
     hPtr = Tcl_CreateHashEntry(iPtr->assocData, name, &isNew);
     if (isNew == 0) {
 	dPtr = Tcl_GetHashValue(hPtr);
     } else {
-	dPtr = Tcl_Alloc(sizeof(AssocData));
+	dPtr = ckalloc(sizeof(AssocData));
     }
     dPtr->proc = proc;
     dPtr->clientData = clientData;
 
     Tcl_SetHashValue(hPtr, dPtr);
@@ -1510,11 +1572,11 @@
     }
     dPtr = Tcl_GetHashValue(hPtr);
     if (dPtr->proc != NULL) {
 	dPtr->proc(dPtr->clientData, interp);
     }
-    Tcl_Free(dPtr);
+    ckfree(dPtr);
     Tcl_DeleteHashEntry(hPtr);
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1706,13 +1768,13 @@
     if (hPtr != NULL) {
 	CancelInfo *cancelInfo = Tcl_GetHashValue(hPtr);
 
 	if (cancelInfo != NULL) {
 	    if (cancelInfo->result != NULL) {
-		Tcl_Free(cancelInfo->result);
+		ckfree(cancelInfo->result);
 	    }
-	    Tcl_Free(cancelInfo);
+	    ckfree(cancelInfo);
 	}
 
 	Tcl_DeleteHashEntry(hPtr);
     }
 
@@ -1763,11 +1825,11 @@
 	hPtr = Tcl_FirstHashEntry(hTablePtr, &search);
 	for (; hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
 	    Tcl_DeleteCommandFromToken(interp, Tcl_GetHashValue(hPtr));
 	}
 	Tcl_DeleteHashTable(hTablePtr);
-	Tcl_Free(hTablePtr);
+	ckfree(hTablePtr);
     }
 
     /*
      * Invoke deletion callbacks; note that a callback can create new
      * callbacks, so we iterate.
@@ -1784,14 +1846,14 @@
 	    dPtr = Tcl_GetHashValue(hPtr);
 	    Tcl_DeleteHashEntry(hPtr);
 	    if (dPtr->proc != NULL) {
 		dPtr->proc(dPtr->clientData, interp);
 	    }
-	    Tcl_Free(dPtr);
+	    ckfree(dPtr);
 	}
 	Tcl_DeleteHashTable(hTablePtr);
-	Tcl_Free(hTablePtr);
+	ckfree(hTablePtr);
     }
 
     /*
      * Pop the root frame pointer and finish deleting the global
      * namespace. The order is important [Bug 1658572].
@@ -1799,20 +1861,21 @@
 
     if ((iPtr->framePtr != iPtr->rootFramePtr) && !TclInExit()) {
 	Tcl_Panic("DeleteInterpProc: popping rootCallFrame with other frames on top");
     }
     Tcl_PopCallFrame(interp);
-    Tcl_Free(iPtr->rootFramePtr);
+    ckfree(iPtr->rootFramePtr);
     iPtr->rootFramePtr = NULL;
     Tcl_DeleteNamespace((Tcl_Namespace *) iPtr->globalNsPtr);
 
     /*
      * Free up the result *after* deleting variables, since variable deletion
      * could have transferred ownership of the result string to Tcl.
      */
 
     Tcl_FreeResult(interp);
+    iPtr->result = NULL;
     Tcl_DecrRefCount(iPtr->objResultPtr);
     iPtr->objResultPtr = NULL;
     Tcl_DecrRefCount(iPtr->ecVar);
     if (iPtr->errorCode) {
 	Tcl_DecrRefCount(iPtr->errorCode);
@@ -1830,10 +1893,16 @@
     Tcl_DecrRefCount(iPtr->innerLiteral);
     Tcl_DecrRefCount(iPtr->innerContext);
     if (iPtr->returnOpts) {
 	Tcl_DecrRefCount(iPtr->returnOpts);
     }
+#ifndef TCL_NO_DEPRECATED
+    if (iPtr->appendResult != NULL) {
+	ckfree(iPtr->appendResult);
+	iPtr->appendResult = NULL;
+    }
+#endif
     TclFreePackageInfo(iPtr);
     while (iPtr->tracePtr != NULL) {
 	Tcl_DeleteTrace((Tcl_Interp *) iPtr, (Tcl_Trace) iPtr->tracePtr);
     }
     if (iPtr->execEnvPtr != NULL) {
@@ -1847,12 +1916,12 @@
     iPtr->emptyObjPtr = NULL;
 
     resPtr = iPtr->resolverPtr;
     while (resPtr) {
 	nextResPtr = resPtr->nextPtr;
-	Tcl_Free(resPtr->name);
-	Tcl_Free(resPtr);
+	ckfree(resPtr->name);
+	ckfree(resPtr);
 	resPtr = nextResPtr;
     }
 
     /*
      * Free up literal objects created for scripts compiled by the
@@ -1875,17 +1944,17 @@
 	procPtr->iPtr = NULL;
 	if (cfPtr) {
 	    if (cfPtr->type == TCL_LOCATION_SOURCE) {
 		Tcl_DecrRefCount(cfPtr->data.eval.path);
 	    }
-	    Tcl_Free(cfPtr->line);
-	    Tcl_Free(cfPtr);
+	    ckfree(cfPtr->line);
+	    ckfree(cfPtr);
 	}
 	Tcl_DeleteHashEntry(hPtr);
     }
     Tcl_DeleteHashTable(iPtr->linePBodyPtr);
-    Tcl_Free(iPtr->linePBodyPtr);
+    ckfree(iPtr->linePBodyPtr);
     iPtr->linePBodyPtr = NULL;
 
     /*
      * See also tclCompile.c, TclCleanupByteCode
      */
@@ -1897,22 +1966,22 @@
 
 	if (eclPtr->type == TCL_LOCATION_SOURCE) {
 	    Tcl_DecrRefCount(eclPtr->path);
 	}
 	for (i=0; i< eclPtr->nuloc; i++) {
-	    Tcl_Free(eclPtr->loc[i].line);
+	    ckfree(eclPtr->loc[i].line);
 	}
 
 	if (eclPtr->loc != NULL) {
-	    Tcl_Free(eclPtr->loc);
+	    ckfree(eclPtr->loc);
 	}
 
-	Tcl_Free(eclPtr);
+	ckfree(eclPtr);
 	Tcl_DeleteHashEntry(hPtr);
     }
     Tcl_DeleteHashTable(iPtr->lineBCPtr);
-    Tcl_Free(iPtr->lineBCPtr);
+    ckfree(iPtr->lineBCPtr);
     iPtr->lineBCPtr = NULL;
 
     /*
      * Location stack for uplevel/eval/... scripts which were passed through
      * proc arguments. Actually we track all arguments as we do not and cannot
@@ -1927,11 +1996,11 @@
 
 	Tcl_Panic("Argument location tracking table not empty");
     }
 
     Tcl_DeleteHashTable(iPtr->lineLAPtr);
-    Tcl_Free(iPtr->lineLAPtr);
+    ckfree(iPtr->lineLAPtr);
     iPtr->lineLAPtr = NULL;
 
     if (iPtr->lineLABCPtr->numEntries && !TclInExit()) {
 	/*
 	 * When the interp goes away we have nothing on the stack, so there
@@ -1940,11 +2009,11 @@
 
 	Tcl_Panic("Argument location tracking table not empty");
     }
 
     Tcl_DeleteHashTable(iPtr->lineLABCPtr);
-    Tcl_Free(iPtr->lineLABCPtr);
+    ckfree(iPtr->lineLABCPtr);
     iPtr->lineLABCPtr = NULL;
 
     /*
      * Squelch the tables of traces on variables and searches over arrays in
      * the in the interpreter.
@@ -1951,11 +2020,11 @@
      */
 
     Tcl_DeleteHashTable(&iPtr->varTraces);
     Tcl_DeleteHashTable(&iPtr->varSearches);
 
-    Tcl_Free(iPtr);
+    ckfree(iPtr);
 }
 
 /*
  *---------------------------------------------------------------------------
  *
@@ -2055,11 +2124,11 @@
      * Initialize the hidden command table if necessary.
      */
 
     hiddenCmdTablePtr = iPtr->hiddenCmdTablePtr;
     if (hiddenCmdTablePtr == NULL) {
-	hiddenCmdTablePtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+	hiddenCmdTablePtr = ckalloc(sizeof(Tcl_HashTable));
 	Tcl_InitHashTable(hiddenCmdTablePtr, TCL_STRING_KEYS);
 	iPtr->hiddenCmdTablePtr = hiddenCmdTablePtr;
     }
 
     /*
@@ -2421,11 +2490,11 @@
 	 * If the deletion callback recreated the command, just throw away the
 	 * new command (if we try to delete it again, we could get stuck in an
 	 * infinite loop).
 	 */
 
-	Tcl_Free(Tcl_GetHashValue(hPtr));
+	ckfree(Tcl_GetHashValue(hPtr));
     }
 
     if (!deleted) {
 	/*
 	 * Command resolvers (per-interp, per-namespace) might have resolved
@@ -2446,11 +2515,11 @@
 	 */
 
 	TclInvalidateNsCmdLookup(nsPtr);
 	TclInvalidateNsPath(nsPtr);
     }
-    cmdPtr = Tcl_Alloc(sizeof(Command));
+    cmdPtr = ckalloc(sizeof(Command));
     Tcl_SetHashValue(hPtr, cmdPtr);
     cmdPtr->hPtr = hPtr;
     cmdPtr->nsPtr = nsPtr;
     cmdPtr->refCount = 1;
     cmdPtr->cmdEpoch = 0;
@@ -2504,10 +2573,11 @@
  *	future calls to Tcl_GetCommandName.
  *
  * Side effects:
  *	If a command named "cmdName" already exists for interp, it is
  *	first deleted.  Then the new command is created from the arguments.
+ *	[***] (See below for exception).
  *
  *	In the future, during bytecode evaluation when "cmdName" is seen as
  *	the name of a command by Tcl_EvalObj or Tcl_Eval, the object-based
  *	Tcl_ObjCmdProc proc will be called. When the command is deleted from
  *	the table, deleteProc will be called. See the manual entry for details
@@ -2571,11 +2641,11 @@
 Tcl_Command
 TclCreateObjCommandInNs(
     Tcl_Interp *interp,
     const char *cmdName,	/* Name of command, without any namespace
                                  * components. */
-    Tcl_Namespace *namespace,   /* The namespace to create the command in */
+    Tcl_Namespace *namesp,   /* The namespace to create the command in */
     Tcl_ObjCmdProc *proc,	/* Object-based function to associate with
 				 * name. */
     ClientData clientData,	/* Arbitrary value to pass to object
 				 * function. */
     Tcl_CmdDeleteProc *deleteProc)
@@ -2585,11 +2655,11 @@
     int deleted = 0, isNew = 0;
     Command *cmdPtr;
     ImportRef *oldRefPtr = NULL;
     ImportedCmdData *dataPtr;
     Tcl_HashEntry *hPtr;
-    Namespace *nsPtr = (Namespace *) namespace;
+    Namespace *nsPtr = (Namespace *) namesp;
 
     /*
      * If the command name we seek to create already exists, we need to delete
      * that first. That can be tricky in the presence of traces. Loop until we
      * no longer find an existing command in the way, or until we've deleted
@@ -2612,11 +2682,28 @@
          */
 
 	cmdPtr = Tcl_GetHashValue(hPtr);
 
 	/*
-	 * Command already exists; delete it. Be careful to preserve any
+	 * [***] This is wrong.  See Tcl Bug a16752c252.
+	 * However, this buggy behavior is kept under particular circumstances
+	 * to accommodate deployed binaries of the "tclcompiler" program
+	 * <http://sourceforge.net/projects/tclpro/> that crash if the bug is
+	 * fixed.
+	 */
+
+	if (cmdPtr->objProc == TclInvokeStringCommand
+		&& cmdPtr->clientData == clientData
+		&& cmdPtr->deleteData == clientData
+		&& cmdPtr->deleteProc == deleteProc) {
+	    cmdPtr->objProc = proc;
+	    cmdPtr->objClientData = clientData;
+	    return (Tcl_Command) cmdPtr;
+	}
+
+	/*
+	 * Otherwise, we delete the old command. Be careful to preserve any
 	 * existing import links so we can restore them down below. That way,
 	 * you can redefine a command and its import status will remain
 	 * intact.
 	 */
 
@@ -2648,11 +2735,11 @@
 	 * If the deletion callback recreated the command, just throw away the
 	 * new command (if we try to delete it again, we could get stuck in an
 	 * infinite loop).
 	 */
 
-	Tcl_Free(Tcl_GetHashValue(hPtr));
+	ckfree(Tcl_GetHashValue(hPtr));
     }
 
     if (!deleted) {
 	/*
 	 * Command resolvers (per-interp, per-namespace) might have resolved
@@ -2673,11 +2760,11 @@
 	 */
 
 	TclInvalidateNsCmdLookup(nsPtr);
 	TclInvalidateNsPath(nsPtr);
     }
-    cmdPtr = Tcl_Alloc(sizeof(Command));
+    cmdPtr = ckalloc(sizeof(Command));
     Tcl_SetHashValue(hPtr, cmdPtr);
     cmdPtr->hPtr = hPtr;
     cmdPtr->nsPtr = nsPtr;
     cmdPtr->refCount = 1;
     cmdPtr->cmdEpoch = 0;
@@ -2743,11 +2830,11 @@
 
 int
 TclInvokeStringCommand(
     ClientData clientData,	/* Points to command's Command structure. */
     Tcl_Interp *interp,		/* Current interpreter. */
-    register int objc,		/* Number of arguments. */
+    int objc,		/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Command *cmdPtr = clientData;
     int i, result;
     const char **argv =
@@ -2792,11 +2879,11 @@
 int
 TclInvokeObjectCommand(
     ClientData clientData,	/* Points to command's Command structure. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int argc,			/* Number of arguments. */
-    register const char **argv)	/* Argument strings. */
+    const char **argv)	/* Argument strings. */
 {
     Command *cmdPtr = clientData;
     Tcl_Obj *objPtr;
     int i, length, result;
     Tcl_Obj **objv =
@@ -2818,10 +2905,17 @@
     } else {
 	result = Tcl_NRCallObjProc(interp, cmdPtr->nreProc,
 		cmdPtr->objClientData, argc, objv);
     }
 
+    /*
+     * Move the interpreter's object result to the string result, then reset
+     * the object result.
+     */
+
+    (void) Tcl_GetStringResult(interp);
+
     /*
      * Decrement the ref counts for the argument objects created above, then
      * free the objv array if malloc'ed storage was used.
      */
 
@@ -3276,11 +3370,11 @@
     Tcl_Obj *objPtr)		/* Points to the object onto which the
 				 * command's full name is appended. */
 
 {
     Interp *iPtr = (Interp *) interp;
-    register Command *cmdPtr = (Command *) command;
+    Command *cmdPtr = (Command *) command;
     char *name;
 
     /*
      * Add the full name of the containing namespace, followed by the "::"
      * separator, and the command name.
@@ -3428,11 +3522,11 @@
 	tracePtr = cmdPtr->tracePtr;
 	while (tracePtr != NULL) {
 	    CommandTrace *nextPtr = tracePtr->nextPtr;
 
 	    if (tracePtr->refCount-- <= 1) {
-		Tcl_Free(tracePtr);
+		ckfree(tracePtr);
 	    }
 	    tracePtr = nextPtr;
 	}
 	cmdPtr->tracePtr = NULL;
     }
@@ -3467,14 +3561,14 @@
 	 * the "real" command that this imported command refers to.
 	 *
 	 * If you are getting a crash during the call to deleteProc and
 	 * cmdPtr->deleteProc is a pointer to the function free(), the most
 	 * likely cause is that your extension allocated memory for the
-	 * clientData argument to Tcl_CreateObjCommand with the Tcl_Alloc()
+	 * clientData argument to Tcl_CreateObjCommand with the ckalloc()
 	 * macro and you are now trying to deallocate this memory with free()
-	 * instead of Tcl_Free(). You should pass a pointer to your own method
-	 * that calls Tcl_Free().
+	 * instead of ckfree(). You should pass a pointer to your own method
+	 * that calls ckfree().
 	 */
 
 	cmdPtr->deleteProc(cmdPtr->deleteData);
     }
 
@@ -3560,11 +3654,11 @@
 				 * is not being renamed */
     int flags)			/* Flags indicating the type of traces to
 				 * trigger, either TCL_TRACE_DELETE or
 				 * TCL_TRACE_RENAME. */
 {
-    register CommandTrace *tracePtr;
+    CommandTrace *tracePtr;
     ActiveCommandTrace active;
     char *result;
     Tcl_Obj *oldNamePtr = NULL;
     Tcl_InterpState state = NULL;
 
@@ -3622,11 +3716,11 @@
 	}
 	tracePtr->traceProc(tracePtr->clientData, (Tcl_Interp *) iPtr,
 		oldName, newName, flags);
 	cmdPtr->flags &= ~tracePtr->flags;
 	if (tracePtr->refCount-- <= 1) {
-	    Tcl_Free(tracePtr);
+	    ckfree(tracePtr);
 	}
     }
 
     if (state) {
 	Tcl_RestoreInterpState((Tcl_Interp *) iPtr, state);
@@ -3750,18 +3844,379 @@
  *----------------------------------------------------------------------
  */
 
 void
 TclCleanupCommand(
-    register Command *cmdPtr)	/* Points to the Command structure to
+    Command *cmdPtr)	/* Points to the Command structure to
 				 * be freed. */
 {
     if (cmdPtr->refCount-- <= 1) {
-	Tcl_Free(cmdPtr);
+	ckfree(cmdPtr);
     }
 }
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_CreateMathFunc --
+ *
+ *	Creates a new math function for expressions in a given interpreter.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The Tcl function defined by "name" is created or redefined. If the
+ *	function already exists then its definition is replaced; this includes
+ *	the builtin functions. Redefining a builtin function forces all
+ *	existing code to be invalidated since that code may be compiled using
+ *	an instruction specific to the replaced function. In addition,
+ *	redefioning a non-builtin function will force existing code to be
+ *	invalidated if the number of arguments has changed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#if !defined(TCL_NO_DEPRECATED)
+void
+Tcl_CreateMathFunc(
+    Tcl_Interp *interp,		/* Interpreter in which function is to be
+				 * available. */
+    const char *name,		/* Name of function (e.g. "sin"). */
+    int numArgs,		/* Nnumber of arguments required by
+				 * function. */
+    Tcl_ValueType *argTypes,	/* Array of types acceptable for each
+				 * argument. */
+    Tcl_MathProc *proc,		/* C function that implements the math
+				 * function. */
+    ClientData clientData)	/* Additional value to pass to the
+				 * function. */
+{
+    Tcl_DString bigName;
+    OldMathFuncData *data = ckalloc(sizeof(OldMathFuncData));
+
+    data->proc = proc;
+    data->numArgs = numArgs;
+    data->argTypes = ckalloc(numArgs * sizeof(Tcl_ValueType));
+    memcpy(data->argTypes, argTypes, numArgs * sizeof(Tcl_ValueType));
+    data->clientData = clientData;
+
+    Tcl_DStringInit(&bigName);
+    TclDStringAppendLiteral(&bigName, "::tcl::mathfunc::");
+    Tcl_DStringAppend(&bigName, name, -1);
+
+    Tcl_CreateObjCommand(interp, Tcl_DStringValue(&bigName),
+	    OldMathFuncProc, data, OldMathFuncDeleteProc);
+    Tcl_DStringFree(&bigName);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * OldMathFuncProc --
+ *
+ *	Dispatch to a math function created with Tcl_CreateMathFunc
+ *
+ * Results:
+ *	Returns a standard Tcl result.
+ *
+ * Side effects:
+ *	Whatever the math function does.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static int
+OldMathFuncProc(
+    ClientData clientData,	/* Pointer to OldMathFuncData describing the
+				 * function being called */
+    Tcl_Interp *interp,		/* Tcl interpreter */
+    int objc,			/* Actual parameter count */
+    Tcl_Obj *const *objv)	/* Parameter vector */
+{
+    Tcl_Obj *valuePtr;
+    OldMathFuncData *dataPtr = clientData;
+    Tcl_Value funcResult, *args;
+    int result;
+    int j, k;
+    double d;
+
+    /*
+     * Check argument count.
+     */
+
+    if (objc != dataPtr->numArgs + 1) {
+	MathFuncWrongNumArgs(interp, dataPtr->numArgs+1, objc, objv);
+	return TCL_ERROR;
+    }
+
+    /*
+     * Convert arguments from Tcl_Obj's to Tcl_Value's.
+     */
+
+    args = ckalloc(dataPtr->numArgs * sizeof(Tcl_Value));
+    for (j = 1, k = 0; j < objc; ++j, ++k) {
+	/* TODO: Convert to TclGetNumberFromObj? */
+	valuePtr = objv[j];
+	result = Tcl_GetDoubleFromObj(NULL, valuePtr, &d);
+#ifdef ACCEPT_NAN
+	if (result != TCL_OK) {
+	    const Tcl_ObjIntRep *irPtr
+		    = TclFetchIntRep(valuePtr, &tclDoubleType);
+
+	    if (irPtr) {
+		d = irPtr->doubleValue;
+		result = TCL_OK;
+	    }
+	}
+#endif
+	if (result != TCL_OK) {
+	    /*
+	     * We have a non-numeric argument.
+	     */
+
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		    "argument to math function didn't have numeric value",
+		    -1));
+	    TclCheckBadOctal(interp, TclGetString(valuePtr));
+	    ckfree(args);
+	    return TCL_ERROR;
+	}
+
+	/*
+	 * Copy the object's numeric value to the argument record, converting
+	 * it if necessary.
+	 *
+	 * NOTE: no bignum support; use the new mathfunc interface for that.
+	 */
+
+	args[k].type = dataPtr->argTypes[k];
+	switch (args[k].type) {
+	case TCL_EITHER:
+	    if (Tcl_GetLongFromObj(NULL, valuePtr, &args[k].intValue)
+		    == TCL_OK) {
+		args[k].type = TCL_INT;
+		break;
+	    }
+	    if (TclGetWideIntFromObj(interp, valuePtr, &args[k].wideValue)
+		    == TCL_OK) {
+		args[k].type = TCL_WIDE_INT;
+		break;
+	    }
+	    args[k].type = TCL_DOUBLE;
+	    /* FALLTHROUGH */
+
+	case TCL_DOUBLE:
+	    args[k].doubleValue = d;
+	    break;
+	case TCL_INT:
+	    if (ExprIntFunc(NULL, interp, 2, &objv[j-1]) != TCL_OK) {
+		ckfree(args);
+		return TCL_ERROR;
+	    }
+	    valuePtr = Tcl_GetObjResult(interp);
+	    Tcl_GetLongFromObj(NULL, valuePtr, &args[k].intValue);
+	    Tcl_ResetResult(interp);
+	    break;
+	case TCL_WIDE_INT:
+	    if (ExprWideFunc(NULL, interp, 2, &objv[j-1]) != TCL_OK) {
+		ckfree(args);
+		return TCL_ERROR;
+	    }
+	    valuePtr = Tcl_GetObjResult(interp);
+	    TclGetWideIntFromObj(NULL, valuePtr, &args[k].wideValue);
+	    Tcl_ResetResult(interp);
+	    break;
+	}
+    }
+
+    /*
+     * Call the function.
+     */
+
+    errno = 0;
+    result = dataPtr->proc(dataPtr->clientData, interp, args, &funcResult);
+    ckfree(args);
+    if (result != TCL_OK) {
+	return result;
+    }
+
+    /*
+     * Return the result of the call.
+     */
+
+    if (funcResult.type == TCL_INT) {
+	TclNewIntObj(valuePtr, funcResult.intValue);
+    } else if (funcResult.type == TCL_WIDE_INT) {
+	valuePtr = Tcl_NewWideIntObj(funcResult.wideValue);
+    } else {
+	return CheckDoubleResult(interp, funcResult.doubleValue);
+    }
+    Tcl_SetObjResult(interp, valuePtr);
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * OldMathFuncDeleteProc --
+ *
+ *	Cleans up after deleting a math function registered with
+ *	Tcl_CreateMathFunc
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Frees allocated memory.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+OldMathFuncDeleteProc(
+    ClientData clientData)
+{
+    OldMathFuncData *dataPtr = clientData;
+
+    ckfree(dataPtr->argTypes);
+    ckfree(dataPtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetMathFuncInfo --
+ *
+ *	Discovers how a particular math function was created in a given
+ *	interpreter.
+ *
+ * Results:
+ *	TCL_OK if it succeeds, TCL_ERROR else (leaving an error message in the
+ *	interpreter result if that happens.)
+ *
+ * Side effects:
+ *	If this function succeeds, the variables pointed to by the numArgsPtr
+ *	and argTypePtr arguments will be updated to detail the arguments
+ *	allowed by the function. The variable pointed to by the procPtr
+ *	argument will be set to NULL if the function is a builtin function,
+ *	and will be set to the address of the C function used to implement the
+ *	math function otherwise (in which case the variable pointed to by the
+ *	clientDataPtr argument will also be updated.)
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_GetMathFuncInfo(
+    Tcl_Interp *interp,
+    const char *name,
+    int *numArgsPtr,
+    Tcl_ValueType **argTypesPtr,
+    Tcl_MathProc **procPtr,
+    ClientData *clientDataPtr)
+{
+    Tcl_Obj *cmdNameObj;
+    Command *cmdPtr;
+
+    /*
+     * Get the command that implements the math function.
+     */
+
+    TclNewLiteralStringObj(cmdNameObj, "tcl::mathfunc::");
+    Tcl_AppendToObj(cmdNameObj, name, -1);
+    Tcl_IncrRefCount(cmdNameObj);
+    cmdPtr = (Command *) Tcl_GetCommandFromObj(interp, cmdNameObj);
+    Tcl_DecrRefCount(cmdNameObj);
+
+    /*
+     * Report unknown functions.
+     */
+
+    if (cmdPtr == NULL) {
+        Tcl_SetObjResult(interp, Tcl_ObjPrintf(
+                "unknown math function \"%s\"", name));
+	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "MATHFUNC", name, NULL);
+	*numArgsPtr = -1;
+	*argTypesPtr = NULL;
+	*procPtr = NULL;
+	*clientDataPtr = NULL;
+	return TCL_ERROR;
+    }
+
+    /*
+     * Retrieve function info for user defined functions; return dummy
+     * information for builtins.
+     */
+
+    if (cmdPtr->objProc == &OldMathFuncProc) {
+	OldMathFuncData *dataPtr = cmdPtr->clientData;
+
+	*procPtr = dataPtr->proc;
+	*numArgsPtr = dataPtr->numArgs;
+	*argTypesPtr = dataPtr->argTypes;
+	*clientDataPtr = dataPtr->clientData;
+    } else {
+	*procPtr = NULL;
+	*numArgsPtr = -1;
+	*argTypesPtr = NULL;
+	*procPtr = NULL;
+	*clientDataPtr = NULL;
+    }
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_ListMathFuncs --
+ *
+ *	Produces a list of all the math functions defined in a given
+ *	interpreter.
+ *
+ * Results:
+ *	A pointer to a Tcl_Obj structure with a reference count of zero, or
+ *	NULL in the case of an error (in which case a suitable error message
+ *	will be left in the interpreter result.)
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_Obj *
+Tcl_ListMathFuncs(
+    Tcl_Interp *interp,
+    const char *pattern)
+{
+    Tcl_Obj *script = Tcl_NewStringObj("::info functions ", -1);
+    Tcl_Obj *result;
+    Tcl_InterpState state;
+
+    if (pattern) {
+	Tcl_Obj *patternObj = Tcl_NewStringObj(pattern, -1);
+	Tcl_Obj *arg = Tcl_NewListObj(1, &patternObj);
+
+	Tcl_AppendObjToObj(script, arg);
+	Tcl_DecrRefCount(arg);	/* Should tear down patternObj too */
+    }
+
+    state = Tcl_SaveInterpState(interp, TCL_OK);
+    Tcl_IncrRefCount(script);
+    if (TCL_OK == Tcl_EvalObjEx(interp, script, 0)) {
+	result = Tcl_DuplicateObj(Tcl_GetObjResult(interp));
+    } else {
+	result = Tcl_NewObj();
+    }
+    Tcl_DecrRefCount(script);
+    Tcl_RestoreInterpState(interp, state);
+
+    return result;
+}
+#endif /* !defined(TCL_NO_DEPRECATED) */
+
 /*
  *----------------------------------------------------------------------
  *
  * TclInterpReady --
  *
@@ -3771,24 +4226,24 @@
  * Results:
  *	The return value is TCL_OK if it the interpreter is ready, TCL_ERROR
  *	otherwise.
  *
  * Side effects:
- *	The interpreter's result is cleared.
+ *	The interpreters object and string results are cleared.
  *
  *----------------------------------------------------------------------
  */
 
 int
 TclInterpReady(
     Tcl_Interp *interp)
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
 
     /*
-     * Reset the interpreter's result and clear out any previous error
-     * information.
+     * Reset both the interpreter's string and object results and clear out
+     * any previous error information.
      */
 
     Tcl_ResetResult(interp);
 
     /*
@@ -3852,11 +4307,11 @@
 int
 TclResetCancellation(
     Tcl_Interp *interp,
     int force)
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
 
     if (iPtr == NULL) {
 	return TCL_ERROR;
     }
 
@@ -3894,11 +4349,11 @@
 int
 Tcl_Canceled(
     Tcl_Interp *interp,
     int flags)
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
 
     /*
      * Has the current script in progress for this interpreter been canceled
      * or is the stack being unwound due to the previous script cancellation?
      */
@@ -3933,11 +4388,11 @@
      * interp's result; otherwise, we leave it alone.
      */
 
     if (flags & TCL_LEAVE_ERR_MSG) {
         const char *id, *message = NULL;
-        size_t length;
+        int length;
 
         /*
          * Setup errorCode variables so that we can differentiate between
          * being canceled and unwound.
          */
@@ -4041,11 +4496,11 @@
      * for the interp is completely unwound.
      */
 
     if (resultObjPtr != NULL) {
 	result = TclGetStringFromObj(resultObjPtr, &cancelInfo->length);
-	cancelInfo->result = Tcl_Realloc(cancelInfo->result,cancelInfo->length);
+	cancelInfo->result = ckrealloc(cancelInfo->result,cancelInfo->length);
 	memcpy(cancelInfo->result, result, cancelInfo->length);
 	TclDecrRefCount(resultObjPtr);	/* Discard their result object. */
     } else {
 	cancelInfo->result = NULL;
 	cancelInfo->length = 0;
@@ -4368,10 +4823,34 @@
     int result,
     struct NRE_callback *rootPtr)
 				/* All callbacks down to rootPtr not inclusive
 				 * are to be run. */
 {
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+    Interp *iPtr = (Interp *) interp;
+#endif /* !defined(TCL_NO_DEPRECATED) */
+
+    /*
+     * If the interpreter has a non-empty string result, the result object is
+     * either empty or stale because some function set interp->result
+     * directly. If so, move the string result to the result object, then
+     * reset the string result.
+     *
+     * This only needs to be done for the first item in the list: all other
+     * are for NR function calls, and those are Tcl_Obj based.
+     */
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+    if (*(iPtr->result) != 0) {
+	(void) Tcl_GetObjResult(interp);
+    }
+#endif /* !defined(TCL_NO_DEPRECATED) */
+
+    /*
+     * This is the trampoline.
+     */
+
     while (TOP_CB(interp) != rootPtr) {
         NRE_callback *callbackPtr = TOP_CB(interp);
         Tcl_NRPostProc *procPtr = callbackPtr->procPtr;
 
 	TOP_CB(interp) = callbackPtr->nextPtr;
@@ -4527,11 +5006,11 @@
     int result)
 {
     Interp *iPtr = (Interp *) interp;
     Tcl_Obj *listPtr;
     const char *cmdString;
-    size_t cmdLen;
+    int cmdLen;
     int objc = PTR2INT(data[0]);
     Tcl_Obj **objv = data[1];
 
     if ((result == TCL_ERROR) && !(iPtr->flags & ERR_ALREADY_LOGGED)) {
 	/*
@@ -4683,12 +5162,12 @@
     int objc,
     Tcl_Obj *const objv[])
 {
     Interp *iPtr = (Interp *) interp;
     Command *cmdPtr = *cmdPtrPtr;
-    size_t length, newEpoch, cmdEpoch = cmdPtr->cmdEpoch;
-    int traceCode = TCL_OK;
+    unsigned int newEpoch, cmdEpoch = cmdPtr->cmdEpoch;
+    int length, traceCode = TCL_OK;
     const char *command = TclGetStringFromObj(commandPtr, &length);
 
     /*
      * Call trace functions.
      * Execute any command or execution traces. Note that we bump up the
@@ -4736,11 +5215,11 @@
     int traceCode = TCL_OK;
     int objc = PTR2INT(data[0]);
     Tcl_Obj *commandPtr = data[1];
     Command *cmdPtr = data[2];
     Tcl_Obj **objv = data[3];
-    size_t length;
+    int length;
     const char *command = TclGetStringFromObj(commandPtr, &length);
 
     if (!(cmdPtr->flags & CMD_IS_DELETED)) {
 	if (cmdPtr->flags & CMD_HAS_EXEC_TRACES) {
 	    traceCode = TclCheckExecutionTraces(interp, command, length,
@@ -4819,16 +5298,66 @@
     Tcl_Interp *interp,		/* Interpreter in which to lookup variables,
 				 * execute nested commands, and report
 				 * errors. */
     Tcl_Token *tokenPtr,	/* Pointer to first in an array of tokens to
 				 * evaluate and concatenate. */
-    size_t count)			/* Number of tokens to consider at tokenPtr.
+    int count)			/* Number of tokens to consider at tokenPtr.
 				 * Must be at least 1. */
 {
     return TclSubstTokens(interp, tokenPtr, count, /* numLeftPtr */ NULL, 1,
 	    NULL, NULL);
 }
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_EvalTokens --
+ *
+ *	Given an array of tokens parsed from a Tcl command (e.g., the tokens
+ *	that make up a word or the index for an array variable) this function
+ *	evaluates the tokens and concatenates their values to form a single
+ *	result value.
+ *
+ * Results:
+ *	The return value is a pointer to a newly allocated Tcl_Obj containing
+ *	the value of the array of tokens. The reference count of the returned
+ *	object has been incremented. If an error occurs in evaluating the
+ *	tokens then a NULL value is returned and an error message is left in
+ *	interp's result.
+ *
+ * Side effects:
+ *	A new object is allocated to hold the result.
+ *
+ *----------------------------------------------------------------------
+ *
+ * This uses a non-standard return convention; its use is now deprecated. It
+ * is a wrapper for the new function Tcl_EvalTokensStandard, and is not used
+ * in the core any longer. It is only kept for backward compatibility.
+ */
+
+Tcl_Obj *
+Tcl_EvalTokens(
+    Tcl_Interp *interp,		/* Interpreter in which to lookup variables,
+				 * execute nested commands, and report
+				 * errors. */
+    Tcl_Token *tokenPtr,	/* Pointer to first in an array of tokens to
+				 * evaluate and concatenate. */
+    int count)			/* Number of tokens to consider at tokenPtr.
+				 * Must be at least 1. */
+{
+    Tcl_Obj *resPtr;
+
+    if (Tcl_EvalTokensStandard(interp, tokenPtr, count) != TCL_OK) {
+	return NULL;
+    }
+    resPtr = Tcl_GetObjResult(interp);
+    Tcl_IncrRefCount(resPtr);
+    Tcl_ResetResult(interp);
+    return resPtr;
+}
+#endif /* !TCL_NO_DEPRECATED */
 
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_EvalEx, TclEvalEx --
@@ -4852,11 +5381,11 @@
 int
 Tcl_EvalEx(
     Tcl_Interp *interp,		/* Interpreter in which to evaluate the
 				 * script. Also used for error reporting. */
     const char *script,		/* First character of script to evaluate. */
-    size_t numBytes,		/* Number of bytes in script. If -1, the
+    int numBytes,		/* Number of bytes in script. If < 0, the
 				 * script consists of all bytes up to the
 				 * first null character. */
     int flags)			/* Collection of OR-ed bits that control the
 				 * evaluation of the script. Only
 				 * TCL_EVAL_GLOBAL is currently supported. */
@@ -4867,11 +5396,11 @@
 int
 TclEvalEx(
     Tcl_Interp *interp,		/* Interpreter in which to evaluate the
 				 * script. Also used for error reporting. */
     const char *script,		/* First character of script to evaluate. */
-    size_t numBytes,		/* Number of bytes in script. If -1, the
+    int numBytes,		/* Number of bytes in script. If < 0, the
 				 * script consists of all bytes up to the
 				 * first NUL character. */
     int flags,			/* Collection of OR-ed bits that control the
 				 * evaluation of the script. Only
 				 * TCL_EVAL_GLOBAL is currently supported. */
@@ -4898,12 +5427,11 @@
     const char *p, *next;
     const unsigned int minObjs = 20;
     Tcl_Obj **objv, **objvSpace;
     int *expand, *lines, *lineSpace;
     Tcl_Token *tokenPtr;
-    int bytesLeft, expandRequested, code = TCL_OK;
-    size_t commandLength;
+    int commandLength, bytesLeft, expandRequested, code = TCL_OK;
     CallFrame *savedVarFramePtr;/* Saves old copy of iPtr->varFramePtr in case
 				 * TCL_EVAL_GLOBAL was set. */
     int allowExceptions = (iPtr->evalFlags & TCL_ALLOW_EXCEPTIONS);
     int gotParse = 0;
     unsigned int i, objectsUsed = 0;
@@ -4933,11 +5461,11 @@
 	} else {
 	    clNext = &iPtr->scriptCLLocPtr->loc[0];
 	}
     }
 
-    if (numBytes == TCL_AUTO_LENGTH) {
+    if (numBytes < 0) {
 	numBytes = strlen(script);
     }
     Tcl_ResetResult(interp);
 
     savedVarFramePtr = iPtr->varFramePtr;
@@ -5050,13 +5578,13 @@
 	    /*
 	     * Generate an array of objects for the words of the command.
 	     */
 
 	    if (numWords > minObjs) {
-		expand =    Tcl_Alloc(numWords * sizeof(int));
-		objvSpace = Tcl_Alloc(numWords * sizeof(Tcl_Obj *));
-		lineSpace = Tcl_Alloc(numWords * sizeof(int));
+		expand =    ckalloc(numWords * sizeof(int));
+		objvSpace = ckalloc(numWords * sizeof(Tcl_Obj *));
+		lineSpace = ckalloc(numWords * sizeof(int));
 	    }
 	    expandRequested = 0;
 	    objv = objvSpace;
 	    lines = lineSpace;
 
@@ -5138,12 +5666,12 @@
 		int wordIdx = numWords;
 		int objIdx = objectsNeeded - 1;
 
 		if ((numWords > minObjs) || (objectsNeeded > minObjs)) {
 		    objv = objvSpace =
-			    Tcl_Alloc(objectsNeeded * sizeof(Tcl_Obj *));
-		    lines = lineSpace = Tcl_Alloc(objectsNeeded * sizeof(int));
+			    ckalloc(objectsNeeded * sizeof(Tcl_Obj *));
+		    lines = lineSpace = ckalloc(objectsNeeded * sizeof(int));
 		}
 
 		objectsUsed = 0;
 		while (wordIdx--) {
 		    if (expand[wordIdx]) {
@@ -5166,14 +5694,14 @@
 		    }
 		}
 		objv += objIdx+1;
 
 		if (copy != stackObjArray) {
-		    Tcl_Free(copy);
+		    ckfree(copy);
 		}
 		if (lcopy != linesStack) {
-		    Tcl_Free(lcopy);
+		    ckfree(lcopy);
 		}
 	    }
 
 	    /*
 	     * Execute the command and free the objects for its words.
@@ -5214,23 +5742,23 @@
 	    for (i = 0; i < objectsUsed; i++) {
 		Tcl_DecrRefCount(objv[i]);
 	    }
 	    objectsUsed = 0;
 	    if (objvSpace != stackObjArray) {
-		Tcl_Free(objvSpace);
+		ckfree(objvSpace);
 		objvSpace = stackObjArray;
-		Tcl_Free(lineSpace);
+		ckfree(lineSpace);
 		lineSpace = linesStack;
 	    }
 
 	    /*
 	     * Free expand separately since objvSpace could have been
 	     * reallocated above.
 	     */
 
 	    if (expand != expandStack) {
-		Tcl_Free(expand);
+		ckfree(expand);
 		expand = expandStack;
 	    }
 	}
 
 	/*
@@ -5292,15 +5820,15 @@
     }
     if (gotParse) {
 	Tcl_FreeParse(parsePtr);
     }
     if (objvSpace != stackObjArray) {
-	Tcl_Free(objvSpace);
-	Tcl_Free(lineSpace);
+	ckfree(objvSpace);
+	ckfree(lineSpace);
     }
     if (expand != expandStack) {
-	Tcl_Free(expand);
+	ckfree(expand);
     }
     iPtr->varFramePtr = savedVarFramePtr;
 
  cleanup_return:
     /*
@@ -5342,11 +5870,11 @@
 TclAdvanceLines(
     int *line,
     const char *start,
     const char *end)
 {
-    register const char *p;
+    const char *p;
 
     for (p = start; p < end; p++) {
 	if (*p == '\n') {
 	    (*line)++;
 	}
@@ -5437,11 +5965,11 @@
     Tcl_Obj **objv,
     int objc,
     CmdFrame *cfPtr)
 {
     Interp *iPtr = (Interp *) interp;
-    int new, i;
+    int isNew, i;
     Tcl_HashEntry *hPtr;
     CFWord *cfwPtr;
 
     for (i = 1; i < objc; i++) {
 	/*
@@ -5453,18 +5981,18 @@
 	 */
 
 	if (cfPtr->line[i] < 0) {
 	    continue;
 	}
-	hPtr = Tcl_CreateHashEntry(iPtr->lineLAPtr, objv[i], &new);
-	if (new) {
+	hPtr = Tcl_CreateHashEntry(iPtr->lineLAPtr, objv[i], &isNew);
+	if (isNew) {
 	    /*
 	     * The word is not on the stack yet, remember the current location
 	     * and initialize references.
 	     */
 
-	    cfwPtr = Tcl_Alloc(sizeof(CFWord));
+	    cfwPtr = ckalloc(sizeof(CFWord));
 	    cfwPtr->framePtr = cfPtr;
 	    cfwPtr->word = i;
 	    cfwPtr->refCount = 1;
 	    Tcl_SetHashValue(hPtr, cfwPtr);
 	} else {
@@ -5520,11 +6048,11 @@
 
 	if (cfwPtr->refCount-- > 1) {
 	    continue;
 	}
 
-	Tcl_Free(cfwPtr);
+	ckfree(cfwPtr);
 	Tcl_DeleteHashEntry(hPtr);
     }
 }
 
 /*
@@ -5553,11 +6081,11 @@
     Tcl_Obj *objv[],
     int objc,
     void *codePtr,
     CmdFrame *cfPtr,
     int cmd,
-    size_t pc)
+    int pc)
 {
     ExtCmdLoc *eclPtr;
     int word;
     ECL *ePtr;
     CFWordBC *lastPtr = NULL;
@@ -5602,11 +6130,11 @@
     for (word = 1; word < objc; word++) {
 	if (ePtr->line[word] >= 0) {
 	    int isnew;
 	    Tcl_HashEntry *hPtr = Tcl_CreateHashEntry(iPtr->lineLABCPtr,
 		objv[word], &isnew);
-	    CFWordBC *cfwPtr = Tcl_Alloc(sizeof(CFWordBC));
+	    CFWordBC *cfwPtr = ckalloc(sizeof(CFWordBC));
 
 	    cfwPtr->framePtr = cfPtr;
 	    cfwPtr->obj = objv[word];
 	    cfwPtr->pc = pc;
 	    cfwPtr->word = word;
@@ -5680,11 +6208,11 @@
 	    Tcl_SetHashValue(hPtr, cfwPtr->prevPtr);
 	} else {
 	    Tcl_DeleteHashEntry(hPtr);
 	}
 
-	Tcl_Free(cfwPtr);
+	ckfree(cfwPtr);
 	cfwPtr = nextPtr;
     }
 
     cfPtr->litarg = NULL;
 }
@@ -5762,10 +6290,87 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
+ * Tcl_Eval --
+ *
+ *	Execute a Tcl command in a string. This function executes the script
+ *	directly, rather than compiling it to bytecodes. Before the arrival of
+ *	the bytecode compiler in Tcl 8.0 Tcl_Eval was the main function used
+ *	for executing Tcl commands, but nowadays it isn't used much.
+ *
+ * Results:
+ *	The return value is one of the return codes defined in tcl.h (such as
+ *	TCL_OK), and interp's result contains a value to supplement the return
+ *	code. The value of the result will persist only until the next call to
+ *	Tcl_Eval or Tcl_EvalObj: you must copy it or lose it!
+ *
+ * Side effects:
+ *	Can be almost arbitrary, depending on the commands in the script.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_Eval
+int
+Tcl_Eval(
+    Tcl_Interp *interp,		/* Token for command interpreter (returned by
+				 * previous call to Tcl_CreateInterp). */
+    const char *script)		/* Pointer to TCL command to execute. */
+{
+    int code = Tcl_EvalEx(interp, script, -1, 0);
+
+    /*
+     * For backwards compatibility with old C code that predates the object
+     * system in Tcl 8.0, we have to mirror the object result back into the
+     * string result (some callers may expect it there).
+     */
+
+    (void) Tcl_GetStringResult(interp);
+    return code;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_EvalObj, Tcl_GlobalEvalObj --
+ *
+ *	These functions are deprecated but we keep them around for backwards
+ *	compatibility reasons.
+ *
+ * Results:
+ *	See the functions they call.
+ *
+ * Side effects:
+ *	See the functions they call.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#undef Tcl_EvalObj
+int
+Tcl_EvalObj(
+    Tcl_Interp *interp,
+    Tcl_Obj *objPtr)
+{
+    return Tcl_EvalObjEx(interp, objPtr, 0);
+}
+#undef Tcl_GlobalEvalObj
+int
+Tcl_GlobalEvalObj(
+    Tcl_Interp *interp,
+    Tcl_Obj *objPtr)
+{
+    return Tcl_EvalObjEx(interp, objPtr, TCL_EVAL_GLOBAL);
+}
+#endif /* TCL_NO_DEPRECATED */
+
+/*
+ *----------------------------------------------------------------------
+ *
  * Tcl_EvalObjEx, TclEvalObjEx --
  *
  *	Execute Tcl commands stored in a Tcl object. These commands are
  *	compiled into bytecodes if necessary, unless TCL_EVAL_DIRECT is
  *	specified.
@@ -5791,11 +6396,11 @@
 
 int
 Tcl_EvalObjEx(
     Tcl_Interp *interp,		/* Token for command interpreter (returned by
 				 * a previous call to Tcl_CreateInterp). */
-    register Tcl_Obj *objPtr,	/* Pointer to object containing commands to
+    Tcl_Obj *objPtr,	/* Pointer to object containing commands to
 				 * execute. */
     int flags)			/* Collection of OR-ed bits that control the
 				 * evaluation of the script. Supported values
 				 * are TCL_EVAL_GLOBAL and TCL_EVAL_DIRECT. */
 {
@@ -5804,11 +6409,11 @@
 
 int
 TclEvalObjEx(
     Tcl_Interp *interp,		/* Token for command interpreter (returned by
 				 * a previous call to Tcl_CreateInterp). */
-    register Tcl_Obj *objPtr,	/* Pointer to object containing commands to
+    Tcl_Obj *objPtr,	/* Pointer to object containing commands to
 				 * execute. */
     int flags,			/* Collection of OR-ed bits that control the
 				 * evaluation of the script. Supported values
 				 * are TCL_EVAL_GLOBAL and TCL_EVAL_DIRECT. */
     const CmdFrame *invoker,	/* Frame of the command doing the eval. */
@@ -5823,11 +6428,11 @@
 
 int
 TclNREvalObjEx(
     Tcl_Interp *interp,		/* Token for command interpreter (returned by
 				 * a previous call to Tcl_CreateInterp). */
-    register Tcl_Obj *objPtr,	/* Pointer to object containing commands to
+    Tcl_Obj *objPtr,	/* Pointer to object containing commands to
 				 * execute. */
     int flags,			/* Collection of OR-ed bits that control the
 				 * evaluation of the script. Supported values
 				 * are TCL_EVAL_GLOBAL and TCL_EVAL_DIRECT. */
     const CmdFrame *invoker,	/* Frame of the command doing the eval. */
@@ -5952,11 +6557,11 @@
 	 * interpreter. Let Tcl_EvalEx evaluate the command directly (and
 	 * probably more slowly).
 	 */
 
 	const char *script;
-	size_t numSrcBytes;
+	int numSrcBytes;
 
 	/*
 	 * Now we check if we have data about invisible continuation lines for
 	 * the script, and make it available to the direct script parser and
 	 * evaluator we are about to call, if so.
@@ -6006,11 +6611,11 @@
 	if (result == TCL_RETURN) {
 	    result = TclUpdateReturnInfo(iPtr);
 	}
 	if ((result != TCL_OK) && (result != TCL_ERROR) && !allowExceptions) {
 	    const char *script;
-	    size_t numSrcBytes;
+	    int numSrcBytes;
 
 	    ProcessUnexpectedResult(interp, result);
 	    result = TCL_ERROR;
 	    script = TclGetStringFromObj(objPtr, &numSrcBytes);
 	    Tcl_LogCommandInfo(interp, script, script, numSrcBytes);
@@ -6131,11 +6736,11 @@
     Tcl_Interp *interp,		/* Context in which to evaluate the
 				 * expression. */
     const char *exprstring,	/* Expression to evaluate. */
     long *ptr)			/* Where to store result. */
 {
-    register Tcl_Obj *exprPtr;
+    Tcl_Obj *exprPtr;
     int result = TCL_OK;
     if (*exprstring == '\0') {
 	/*
 	 * Legacy compatibility - return 0 for the zero-length string.
 	 */
@@ -6144,10 +6749,13 @@
     } else {
 	exprPtr = Tcl_NewStringObj(exprstring, -1);
 	Tcl_IncrRefCount(exprPtr);
 	result = Tcl_ExprLongObj(interp, exprPtr, ptr);
 	Tcl_DecrRefCount(exprPtr);
+	if (result != TCL_OK) {
+	    (void) Tcl_GetStringResult(interp);
+	}
     }
     return result;
 }
 
 int
@@ -6155,11 +6763,11 @@
     Tcl_Interp *interp,		/* Context in which to evaluate the
 				 * expression. */
     const char *exprstring,	/* Expression to evaluate. */
     double *ptr)		/* Where to store result. */
 {
-    register Tcl_Obj *exprPtr;
+    Tcl_Obj *exprPtr;
     int result = TCL_OK;
 
     if (*exprstring == '\0') {
 	/*
 	 * Legacy compatibility - return 0 for the zero-length string.
@@ -6170,10 +6778,13 @@
 	exprPtr = Tcl_NewStringObj(exprstring, -1);
 	Tcl_IncrRefCount(exprPtr);
 	result = Tcl_ExprDoubleObj(interp, exprPtr, ptr);
 	Tcl_DecrRefCount(exprPtr);
 				/* Discard the expression object. */
+	if (result != TCL_OK) {
+	    (void) Tcl_GetStringResult(interp);
+	}
     }
     return result;
 }
 
 int
@@ -6195,10 +6806,18 @@
 	Tcl_Obj *exprPtr = Tcl_NewStringObj(exprstring, -1);
 
 	Tcl_IncrRefCount(exprPtr);
 	result = Tcl_ExprBooleanObj(interp, exprPtr, ptr);
 	Tcl_DecrRefCount(exprPtr);
+	if (result != TCL_OK) {
+	    /*
+	     * Move the interpreter's object result to the string result, then
+	     * reset the object result.
+	     */
+
+	    (void) Tcl_GetStringResult(interp);
+	}
 	return result;
     }
 }
 
 /*
@@ -6224,11 +6843,11 @@
 
 int
 Tcl_ExprLongObj(
     Tcl_Interp *interp,		/* Context in which to evaluate the
 				 * expression. */
-    register Tcl_Obj *objPtr,	/* Expression to evaluate. */
+    Tcl_Obj *objPtr,	/* Expression to evaluate. */
     long *ptr)			/* Where to store long result. */
 {
     Tcl_Obj *resultPtr;
     int result, type;
     double d;
@@ -6251,12 +6870,12 @@
 	Tcl_DecrRefCount(resultPtr);
 	if (Tcl_InitBignumFromDouble(interp, d, &big) != TCL_OK) {
 	    return TCL_ERROR;
 	}
 	resultPtr = Tcl_NewBignumObj(&big);
-	/* FALLTHROUGH */
     }
+    /* FALLTHRU */
     case TCL_NUMBER_INT:
     case TCL_NUMBER_BIG:
 	result = TclGetLongFromObj(interp, resultPtr, ptr);
 	break;
 
@@ -6271,11 +6890,11 @@
 
 int
 Tcl_ExprDoubleObj(
     Tcl_Interp *interp,		/* Context in which to evaluate the
 				 * expression. */
-    register Tcl_Obj *objPtr,	/* Expression to evaluate. */
+    Tcl_Obj *objPtr,	/* Expression to evaluate. */
     double *ptr)		/* Where to store double result. */
 {
     Tcl_Obj *resultPtr;
     int result, type;
     ClientData internalPtr;
@@ -6307,11 +6926,11 @@
 
 int
 Tcl_ExprBooleanObj(
     Tcl_Interp *interp,		/* Context in which to evaluate the
 				 * expression. */
-    register Tcl_Obj *objPtr,	/* Expression to evaluate. */
+    Tcl_Obj *objPtr,	/* Expression to evaluate. */
     int *ptr)			/* Where to store 0/1 result. */
 {
     Tcl_Obj *resultPtr;
     int result;
 
@@ -6419,11 +7038,11 @@
     ClientData clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const objv[])
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
     Tcl_HashTable *hTblPtr;	/* Table of hidden commands. */
     const char *cmdName;	/* Name of the command from objv[0]. */
     Tcl_HashEntry *hPtr = NULL;
     Command *cmdPtr;
 
@@ -6511,10 +7130,16 @@
 	if (code == TCL_OK) {
 	    Tcl_SetObjResult(interp, resultPtr);
 	    Tcl_DecrRefCount(resultPtr);
 	}
     }
+
+    /*
+     * Force the string rep of the interp result.
+     */
+
+    (void) Tcl_GetStringResult(interp);
     return code;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -6533,30 +7158,108 @@
  *	message in the interpreter's result.
  *
  *----------------------------------------------------------------------
  */
 
+#undef Tcl_AddObjErrorInfo
 void
 Tcl_AppendObjToErrorInfo(
     Tcl_Interp *interp,		/* Interpreter to which error information
 				 * pertains. */
     Tcl_Obj *objPtr)		/* Message to record. */
 {
-    size_t length;
-    const char *message = TclGetStringFromObj(objPtr, &length);
-    register Interp *iPtr = (Interp *) interp;
+    const char *message = TclGetString(objPtr);
 
     Tcl_IncrRefCount(objPtr);
+    Tcl_AddObjErrorInfo(interp, message, objPtr->length);
+    Tcl_DecrRefCount(objPtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_AddErrorInfo --
+ *
+ *	Add information to the errorInfo field that describes the current
+ *	error.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The contents of message are appended to the errorInfo field. If we are
+ *	just starting to log an error, errorInfo is initialized from the error
+ *	message in the interpreter's result.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_AddErrorInfo
+void
+Tcl_AddErrorInfo(
+    Tcl_Interp *interp,		/* Interpreter to which error information
+				 * pertains. */
+    const char *message)	/* Message to record. */
+{
+    Tcl_AddObjErrorInfo(interp, message, -1);
+}
+#endif /* TCL_NO_DEPRECATED */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_AddObjErrorInfo --
+ *
+ *	Add information to the errorInfo field that describes the current
+ *	error. This routine differs from Tcl_AddErrorInfo by taking a byte
+ *	pointer and length.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	"length" bytes from "message" are appended to the errorInfo field. If
+ *	"length" is negative, use bytes up to the first NULL byte. If we are
+ *	just starting to log an error, errorInfo is initialized from the error
+ *	message in the interpreter's result.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_AddObjErrorInfo(
+    Tcl_Interp *interp,		/* Interpreter to which error information
+				 * pertains. */
+    const char *message,	/* Points to the first byte of an array of
+				 * bytes of the message. */
+    int length)			/* The number of bytes in the message. If < 0,
+				 * then append all bytes up to a NULL byte. */
+{
+    Interp *iPtr = (Interp *) interp;
 
     /*
      * If we are just starting to log an error, errorInfo is initialized from
      * the error message in the interpreter's result.
      */
 
     iPtr->flags |= ERR_LEGACY_COPY;
     if (iPtr->errorInfo == NULL) {
-	iPtr->errorInfo = iPtr->objResultPtr;
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+	if (*(iPtr->result) != 0) {
+	    /*
+	     * The interp's string result is set, apparently by some extension
+	     * making a deprecated direct write to it. That extension may
+	     * expect interp->result to continue to be set, so we'll take
+	     * special pains to avoid clearing it, until we drop support for
+	     * interp->result completely.
+	     */
+
+	    iPtr->errorInfo = Tcl_NewStringObj(iPtr->result, -1);
+	} else
+#endif /* !defined(TCL_NO_DEPRECATED) */
+	    iPtr->errorInfo = iPtr->objResultPtr;
 	Tcl_IncrRefCount(iPtr->errorInfo);
 	if (!iPtr->errorCode) {
 	    Tcl_SetErrorCode(interp, "NONE", NULL);
 	}
     }
@@ -6571,46 +7274,43 @@
 	    iPtr->errorInfo = Tcl_DuplicateObj(iPtr->errorInfo);
 	    Tcl_IncrRefCount(iPtr->errorInfo);
 	}
 	Tcl_AppendToObj(iPtr->errorInfo, message, length);
     }
-    Tcl_DecrRefCount(objPtr);
 }
 
 /*
- *----------------------------------------------------------------------
+ *---------------------------------------------------------------------------
  *
- * Tcl_VarEval --
+ * Tcl_VarEvalVA --
  *
  *	Given a variable number of string arguments, concatenate them all
  *	together and execute the result as a Tcl command.
  *
  * Results:
  *	A standard Tcl return result. An error message or other result may be
- *	left in the interp.
+ *	left in the interp's result.
  *
  * Side effects:
  *	Depends on what was done by the command.
  *
- *----------------------------------------------------------------------
+ *---------------------------------------------------------------------------
  */
-	/* ARGSUSED */
+
 int
-Tcl_VarEval(
-    Tcl_Interp *interp,
-    ...)
+Tcl_VarEvalVA(
+    Tcl_Interp *interp,		/* Interpreter in which to evaluate command */
+    va_list argList)		/* Variable argument list. */
 {
-    va_list argList;
-    int result;
     Tcl_DString buf;
     char *string;
+    int result;
 
-    va_start(argList, interp);
     /*
      * Copy the strings one after the other into a single larger string. Use
      * stack-allocated space for small commands, but if the command gets too
-     * large than call Tcl_Alloc to create the space.
+     * large than call ckalloc to create the space.
      */
 
     Tcl_DStringInit(&buf);
     while (1) {
 	string = va_arg(argList, char *);
@@ -6623,10 +7323,82 @@
     result = Tcl_EvalEx(interp, Tcl_DStringValue(&buf), -1, 0);
     Tcl_DStringFree(&buf);
     return result;
 }
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_VarEval --
+ *
+ *	Given a variable number of string arguments, concatenate them all
+ *	together and execute the result as a Tcl command.
+ *
+ * Results:
+ *	A standard Tcl return result. An error message or other result may be
+ *	left in interp->result.
+ *
+ * Side effects:
+ *	Depends on what was done by the command.
+ *
+ *----------------------------------------------------------------------
+ */
+	/* ARGSUSED */
+int
+Tcl_VarEval(
+    Tcl_Interp *interp,
+    ...)
+{
+    va_list argList;
+    int result;
+
+    va_start(argList, interp);
+    result = Tcl_VarEvalVA(interp, argList);
+    va_end(argList);
+
+    return result;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GlobalEval --
+ *
+ *	Evaluate a command at global level in an interpreter.
+ *
+ * Results:
+ *	A standard Tcl result is returned, and the interp's result is modified
+ *	accordingly.
+ *
+ * Side effects:
+ *	The command string is executed in interp, and the execution is carried
+ *	out in the variable context of global level (no functions active),
+ *	just as if an "uplevel #0" command were being executed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_GlobalEval
+int
+Tcl_GlobalEval(
+    Tcl_Interp *interp,		/* Interpreter in which to evaluate
+				 * command. */
+    const char *command)	/* Command to evaluate. */
+{
+    Interp *iPtr = (Interp *) interp;
+    int result;
+    CallFrame *savedVarFramePtr;
+
+    savedVarFramePtr = iPtr->varFramePtr;
+    iPtr->varFramePtr = iPtr->rootFramePtr;
+    result = Tcl_EvalEx(interp, command, -1, 0);
+    iPtr->varFramePtr = savedVarFramePtr;
+    return result;
+}
+#endif /* TCL_NO_DEPRECATED */
+
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_SetRecursionLimit --
  *
@@ -7110,11 +7882,11 @@
 
 	if (l > 0) {
 	    goto unChanged;
 	} else if (l == 0) {
 	    if (TclHasStringRep(objv[1])) {
-		size_t numBytes;
+		int numBytes;
 		const char *bytes = TclGetStringFromObj(objv[1], &numBytes);
 
 		while (numBytes) {
 		    if (*bytes == '-') {
 			Tcl_SetObjResult(interp, Tcl_NewWideIntObj(0));
@@ -7613,26 +8385,27 @@
 ClassifyDouble(
     double d)
 {
 #if TCL_FPCLASSIFY_MODE == 0
     return fpclassify(d);
-#else /* !fpclassify */
+#else /* TCL_FPCLASSIFY_MODE != 0 */
     /*
      * If we don't have fpclassify(), we also don't have the values it returns.
      * Hence we define those here.
      */
-# ifndef FP_NAN
+#ifndef FP_NAN
 #   define FP_NAN          1	/* Value is NaN */
 #   define FP_INFINITE     2	/* Value is an infinity */
 #   define FP_ZERO         3	/* Value is a zero */
 #   define FP_NORMAL       4	/* Value is a normal float */
 #   define FP_SUBNORMAL    5	/* Value has lost accuracy */
-#endif
+#endif /* !FP_NAN */
 
-# if TCL_FPCLASSIFY_MODE == 3
-    return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, d);
-# elif TCL_FPCLASSIFY_MODE == 2
+#if TCL_FPCLASSIFY_MODE == 3
+    return __builtin_fpclassify(
+            FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, d);
+#elif TCL_FPCLASSIFY_MODE == 2
     /*
      * We assume this hack is only needed on little-endian systems.
      * Specifically, x86 running Windows.  It's fairly easy to enable for
      * others if they need it (because their libc/libm is broken) but we'll
      * jump that hurdle when requred.  We can solve the word ordering then.
@@ -7655,13 +8428,13 @@
 
     /*
      * Shifts and masks to use with the doubleMeaning variable above.
      */
 
-#   define EXPONENT_MASK   0x7ff   /* 11 bits (after shifting) */
-#   define EXPONENT_SHIFT  20      /* Moves exponent to bottom of word */
-#   define MANTISSA_MASK   0xfffff /* 20 bits (plus 32 from other word) */
+#define EXPONENT_MASK   0x7ff   /* 11 bits (after shifting) */
+#define EXPONENT_SHIFT  20      /* Moves exponent to bottom of word */
+#define MANTISSA_MASK   0xfffff /* 20 bits (plus 32 from other word) */
 
     /*
      * Extract the exponent (11 bits) and mantissa (52 bits).  Note that we
      * totally ignore the sign bit.
      */
@@ -7694,11 +8467,11 @@
          * Everything else is a NORMAL double precision float.
          */
 
         return FP_NORMAL;
     }
-# elif TCL_FPCLASSIFY_MODE == 1
+#elif TCL_FPCLASSIFY_MODE == 1
     switch (_fpclass(d)) {
     case _FPCLASS_NZ:
     case _FPCLASS_PZ:
         return FP_ZERO;
     case _FPCLASS_NN:
@@ -7714,13 +8487,13 @@
         Tcl_Panic("result of _fpclass() outside documented range!");
     case _FPCLASS_QNAN:
     case _FPCLASS_SNAN:
         return FP_NAN;
     }
-# else /* unknown TCL_FPCLASSIFY_MODE */
-#   error "unknown or unexpected TCL_FPCLASSIFY_MODE"
-# endif /* TCL_FPCLASSIFY_MODE */
+#else /* TCL_FPCLASSIFY_MODE not in (0..3) */
+#error "unknown or unexpected TCL_FPCLASSIFY_MODE"
+#endif /* TCL_FPCLASSIFY_MODE */
 #endif /* !fpclassify */
 }
 
 static int
 ExprIsFiniteFunc(
@@ -8714,11 +9487,11 @@
 	 */
 
 	NRE_ASSERT(iPtr->varFramePtr == corPtr->caller.varFramePtr);
 	NRE_ASSERT(iPtr->framePtr == corPtr->caller.framePtr);
 	NRE_ASSERT(iPtr->cmdFramePtr == corPtr->caller.cmdFramePtr);
-	Tcl_Free(corPtr);
+	ckfree(corPtr);
 	return result;
     }
 
     NRE_ASSERT(COR_IS_SUSPENDED(corPtr));
     SAVE_CONTEXT(corPtr->running);
@@ -8773,11 +9546,11 @@
      * Drop the coroutine-owned copy of the lineLABCPtr hashtable for literal
      * command arguments in bytecode.
      */
 
     Tcl_DeleteHashTable(corPtr->lineLABCPtr);
-    Tcl_Free(corPtr->lineLABCPtr);
+    ckfree(corPtr->lineLABCPtr);
     corPtr->lineLABCPtr = NULL;
 
     RESTORE_CONTEXT(corPtr->caller);
     iPtr->execEnvPtr = corPtr->callerEEPtr;
     iPtr->numLevels++;
@@ -9387,11 +10160,11 @@
     /*
      * We ARE creating the coroutine command: allocate the corresponding
      * struct and create the corresponding command.
      */
 
-    corPtr = Tcl_Alloc(sizeof(CoroutineData));
+    corPtr = ckalloc(sizeof(CoroutineData));
 
     cmdPtr = (Command *) TclNRCreateCommandInNs(interp, simpleName,
 	    (Tcl_Namespace *)nsPtr, /*objProc*/ NULL, TclNRInterpCoroutine,
 	    corPtr, DeleteCoroutine);
 
@@ -9409,11 +10182,11 @@
 
     {
 	Tcl_HashSearch hSearch;
 	Tcl_HashEntry *hePtr;
 
-	corPtr->lineLABCPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+	corPtr->lineLABCPtr = ckalloc(sizeof(Tcl_HashTable));
 	Tcl_InitHashTable(corPtr->lineLABCPtr, TCL_ONE_WORD_KEYS);
 
 	for (hePtr = Tcl_FirstHashEntry(iPtr->lineLABCPtr,&hSearch);
 		hePtr; hePtr = Tcl_NextHashEntry(&hSearch)) {
 	    int isNew;

Index: generic/tclBinary.c
==================================================================
--- generic/tclBinary.c
+++ generic/tclBinary.c
@@ -20,12 +20,12 @@
 /*
  * The following constants are used by GetFormatSpec to indicate various
  * special conditions in the parsing of a format specifier.
  */
 
-#define BINARY_ALL ((size_t)-1)		/* Use all elements in the argument. */
-#define BINARY_NOCOUNT ((size_t)-2)	/* No count was specified in format. */
+#define BINARY_ALL -1		/* Use all elements in the argument. */
+#define BINARY_NOCOUNT -2	/* No count was specified in format. */
 
 /*
  * The following flags may be ORed together and returned by GetFormatSpec
  */
 
@@ -62,20 +62,20 @@
 static int		FormatNumber(Tcl_Interp *interp, int type,
 			    Tcl_Obj *src, unsigned char **cursorPtr);
 static void		FreeByteArrayInternalRep(Tcl_Obj *objPtr);
 static void		FreeProperByteArrayInternalRep(Tcl_Obj *objPtr);
 static int		GetFormatSpec(const char **formatPtr, char *cmdPtr,
-			    size_t *countPtr, int *flagsPtr);
+			    int *countPtr, int *flagsPtr);
 static Tcl_Obj *	ScanNumber(unsigned char *buffer, int type,
 			    int flags, Tcl_HashTable **numberCachePtr);
 static int		SetByteArrayFromAny(Tcl_Interp *interp,
 			    Tcl_Obj *objPtr);
 static void		UpdateStringOfByteArray(Tcl_Obj *listPtr);
 static void		DeleteScanNumberCache(Tcl_HashTable *numberCachePtr);
 static int		NeedReversing(int format);
 static void		CopyNumber(const void *from, void *to,
-			    size_t length, int type);
+			    unsigned length, int type);
 /* Binary ensemble commands */
 static int		BinaryFormatCmd(ClientData clientData,
 			    Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
 static int		BinaryScanCmd(ClientData clientData,
@@ -264,14 +264,14 @@
  * track of how much memory has been used and how much has been allocated for
  * the byte array to enable growing and shrinking of the ByteArray object with
  * fewer mallocs.
  */
 
-typedef struct {
-    size_t used;		/* The number of bytes used in the byte
+typedef struct ByteArray {
+    unsigned int used;		/* The number of bytes used in the byte
 				 * array. */
-    size_t allocated;		/* The amount of space actually allocated
+    unsigned int allocated;	/* The amount of space actually allocated
 				 * minus 1 byte. */
     unsigned char bytes[1];	/* The array of bytes. The actual size of this
 				 * field depends on the 'allocated' field
 				 * above. */
 } ByteArray;
@@ -278,12 +278,12 @@
 
 #define BYTEARRAY_SIZE(len) \
 		(offsetof(ByteArray, bytes) + (len))
 #define GET_BYTEARRAY(irPtr) ((ByteArray *) (irPtr)->twoPtrValue.ptr1)
 #define SET_BYTEARRAY(irPtr, baPtr) \
-		(irPtr)->twoPtrValue.ptr1 = (baPtr)
-
+		(irPtr)->twoPtrValue.ptr1 = (void *) (baPtr)
+
 int
 TclIsPureByteArray(
     Tcl_Obj * objPtr)
 {
     return TclHasIntRep(objPtr, &properByteArrayType);
@@ -311,11 +311,12 @@
 
 Tcl_Obj *
 Tcl_NewByteArrayObj(
     const unsigned char *bytes,	/* The array of bytes used to initialize the
 				 * new object. */
-    size_t length)		/* Length of the array of bytes */
+    int length)			/* Length of the array of bytes, which must be
+				 * >= 0. */
 {
 #ifdef TCL_MEM_DEBUG
     return Tcl_DbNewByteArrayObj(bytes, length, "unknown", 0);
 #else /* if not TCL_MEM_DEBUG */
     Tcl_Obj *objPtr;
@@ -353,11 +354,12 @@
 
 Tcl_Obj *
 Tcl_DbNewByteArrayObj(
     const unsigned char *bytes,	/* The array of bytes used to initialize the
 				 * new object. */
-    size_t length,		/* Length of the array of bytes. */
+    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
 				 * debugging. */
 {
@@ -393,11 +395,11 @@
 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 length > 0. */
-    size_t length)			/* Length of the array of bytes, which must
+    int length)			/* Length of the array of bytes, which must
 				 * be >= 0. */
 {
     ByteArray *byteArrayPtr;
     Tcl_ObjIntRep ir;
 
@@ -404,11 +406,14 @@
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetByteArrayObj");
     }
     TclInvalidateStringRep(objPtr);
 
-    byteArrayPtr = Tcl_Alloc(BYTEARRAY_SIZE(length));
+    if (length < 0) {
+	length = 0;
+    }
+    byteArrayPtr = ckalloc(BYTEARRAY_SIZE(length));
     byteArrayPtr->used = length;
     byteArrayPtr->allocated = length;
 
     if ((bytes != NULL) && (length > 0)) {
 	memcpy(byteArrayPtr->bytes, bytes, length);
@@ -486,15 +491,19 @@
  */
 
 unsigned char *
 Tcl_SetByteArrayLength(
     Tcl_Obj *objPtr,		/* The ByteArray object. */
-    size_t length)			/* New length for internal byte array. */
+    int length)			/* New length for internal byte array. */
 {
     ByteArray *byteArrayPtr;
+    unsigned newLength;
     Tcl_ObjIntRep *irPtr;
 
+    assert(length >= 0);
+    newLength = (unsigned int)length;
+
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetByteArrayLength");
     }
 
     irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
@@ -508,17 +517,17 @@
 	    }
 	}
     }
 
     byteArrayPtr = GET_BYTEARRAY(irPtr);
-    if (length > byteArrayPtr->allocated) {
-	byteArrayPtr = Tcl_Realloc(byteArrayPtr, BYTEARRAY_SIZE(length));
-	byteArrayPtr->allocated = length;
+    if (newLength > byteArrayPtr->allocated) {
+	byteArrayPtr = ckrealloc(byteArrayPtr, BYTEARRAY_SIZE(newLength));
+	byteArrayPtr->allocated = newLength;
 	SET_BYTEARRAY(irPtr, byteArrayPtr);
     }
     TclInvalidateStringRep(objPtr);
-    byteArrayPtr->used = length;
+    byteArrayPtr->used = newLength;
     return byteArrayPtr->bytes;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -554,14 +563,15 @@
     }
     if (TclHasIntRep(objPtr, &tclByteArrayType)) {
 	return TCL_OK;
     }
 
-    src = TclGetStringFromObj(objPtr, &length);
+    src = TclGetString(objPtr);
+    length = objPtr->length;
     srcEnd = src + length;
 
-    byteArrayPtr = Tcl_Alloc(BYTEARRAY_SIZE(length));
+    byteArrayPtr = ckalloc(BYTEARRAY_SIZE(length));
     for (dst = byteArrayPtr->bytes; src < srcEnd; ) {
 	src += TclUtfToUniChar(src, &ch);
 	improper = improper || (ch > 255);
 	*dst++ = UCHAR(ch);
     }
@@ -594,18 +604,18 @@
 
 static void
 FreeByteArrayInternalRep(
     Tcl_Obj *objPtr)		/* Object with internal rep to free. */
 {
-    Tcl_Free(GET_BYTEARRAY(TclFetchIntRep(objPtr, &tclByteArrayType)));
+    ckfree(GET_BYTEARRAY(TclFetchIntRep(objPtr, &tclByteArrayType)));
 }
 
 static void
 FreeProperByteArrayInternalRep(
     Tcl_Obj *objPtr)		/* Object with internal rep to free. */
 {
-    Tcl_Free(GET_BYTEARRAY(TclFetchIntRep(objPtr, &properByteArrayType)));
+    ckfree(GET_BYTEARRAY(TclFetchIntRep(objPtr, &properByteArrayType)));
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -626,18 +636,18 @@
 static void
 DupByteArrayInternalRep(
     Tcl_Obj *srcPtr,		/* Object with internal rep to copy. */
     Tcl_Obj *copyPtr)		/* Object with internal rep to set. */
 {
-    size_t length;
+    unsigned int length;
     ByteArray *srcArrayPtr, *copyArrayPtr;
     Tcl_ObjIntRep ir;
 
     srcArrayPtr = GET_BYTEARRAY(TclFetchIntRep(srcPtr, &tclByteArrayType));
     length = srcArrayPtr->used;
 
-    copyArrayPtr = Tcl_Alloc(BYTEARRAY_SIZE(length));
+    copyArrayPtr = ckalloc(BYTEARRAY_SIZE(length));
     copyArrayPtr->used = length;
     copyArrayPtr->allocated = length;
     memcpy(copyArrayPtr->bytes, srcArrayPtr->bytes, length);
 
     SET_BYTEARRAY(&ir, copyArrayPtr);
@@ -654,11 +664,11 @@
     Tcl_ObjIntRep ir;
 
     srcArrayPtr = GET_BYTEARRAY(TclFetchIntRep(srcPtr, &properByteArrayType));
     length = srcArrayPtr->used;
 
-    copyArrayPtr = Tcl_Alloc(BYTEARRAY_SIZE(length));
+    copyArrayPtr = ckalloc(BYTEARRAY_SIZE(length));
     copyArrayPtr->used = length;
     copyArrayPtr->allocated = length;
     memcpy(copyArrayPtr->bytes, srcArrayPtr->bytes, length);
 
     SET_BYTEARRAY(&ir, copyArrayPtr);
@@ -688,22 +698,25 @@
 				 * update. */
 {
     const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
     ByteArray *byteArrayPtr = GET_BYTEARRAY(irPtr);
     unsigned char *src = byteArrayPtr->bytes;
-    size_t i, length = byteArrayPtr->used;
-    size_t size = length;
+    unsigned int i, length = byteArrayPtr->used;
+    unsigned int size = length;
 
     /*
      * How much space will string rep need?
      */
 
-    for (i = 0; i < length; i++) {
+    for (i = 0; i < length && size <= INT_MAX; i++) {
 	if ((src[i] == 0) || (src[i] > 127)) {
 	    size++;
 	}
     }
+    if (size > INT_MAX) {
+	Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
+    }
 
     if (size == length) {
 	char *dst = Tcl_InitStringRep(objPtr, (char *)src, size);
 
 	TclOOM(dst, size);
@@ -739,20 +752,20 @@
 
 void
 TclAppendBytesToByteArray(
     Tcl_Obj *objPtr,
     const unsigned char *bytes,
-    size_t len)
+    int len)
 {
     ByteArray *byteArrayPtr;
-    size_t needed;
+    unsigned int length, needed;
     Tcl_ObjIntRep *irPtr;
 
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object","TclAppendBytesToByteArray");
     }
-    if (len == TCL_AUTO_LENGTH) {
+    if (len < 0) {
 	Tcl_Panic("%s must be called with definite number of bytes to append",
 		"TclAppendBytesToByteArray");
     }
     if (len == 0) {
 	/*
@@ -759,10 +772,12 @@
 	 * Append zero bytes is a no-op.
 	 */
 
 	return;
     }
+
+    length = (unsigned int) len;
 
     irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
     if (irPtr == NULL) {
 	irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
 	if (irPtr == NULL) {
@@ -773,60 +788,60 @@
 	    }
 	}
     }
     byteArrayPtr = GET_BYTEARRAY(irPtr);
 
-    if (len > UINT_MAX - byteArrayPtr->used) {
-	Tcl_Panic("max size for a Tcl value (%u bytes) exceeded", UINT_MAX);
+    if (length > INT_MAX - byteArrayPtr->used) {
+	Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
     }
 
-    needed = byteArrayPtr->used + len;
+    needed = byteArrayPtr->used + length;
     /*
      * If we need to, resize the allocated space in the byte array.
      */
 
     if (needed > byteArrayPtr->allocated) {
 	ByteArray *ptr = NULL;
-	size_t attempt;
+	unsigned int attempt;
 
 	if (needed <= INT_MAX/2) {
 	    /*
 	     * Try to allocate double the total space that is needed.
 	     */
 
 	    attempt = 2 * needed;
-	    ptr = Tcl_AttemptRealloc(byteArrayPtr, BYTEARRAY_SIZE(attempt));
+	    ptr = attemptckrealloc(byteArrayPtr, BYTEARRAY_SIZE(attempt));
 	}
 	if (ptr == NULL) {
 	    /*
 	     * Try to allocate double the increment that is needed (plus).
 	     */
 
-	    size_t limit = UINT_MAX - needed;
-	    size_t extra = len + TCL_MIN_GROWTH;
-	    size_t growth = (extra > limit) ? limit : extra;
+	    unsigned int limit = INT_MAX - needed;
+	    unsigned int extra = length + TCL_MIN_GROWTH;
+	    int growth = (int) ((extra > limit) ? limit : extra);
 
 	    attempt = needed + growth;
-	    ptr = Tcl_AttemptRealloc(byteArrayPtr, BYTEARRAY_SIZE(attempt));
+	    ptr = attemptckrealloc(byteArrayPtr, BYTEARRAY_SIZE(attempt));
 	}
 	if (ptr == NULL) {
 	    /*
 	     * Last chance: Try to allocate exactly what is needed.
 	     */
 
 	    attempt = needed;
-	    ptr = Tcl_Realloc(byteArrayPtr, BYTEARRAY_SIZE(attempt));
+	    ptr = ckrealloc(byteArrayPtr, BYTEARRAY_SIZE(attempt));
 	}
 	byteArrayPtr = ptr;
 	byteArrayPtr->allocated = attempt;
 	SET_BYTEARRAY(irPtr, byteArrayPtr);
     }
 
     if (bytes) {
-	memcpy(byteArrayPtr->bytes + byteArrayPtr->used, bytes, len);
+	memcpy(byteArrayPtr->bytes + byteArrayPtr->used, bytes, length);
     }
-    byteArrayPtr->used += len;
+    byteArrayPtr->used += length;
     TclInvalidateStringRep(objPtr);
 }
 
 /*
  *----------------------------------------------------------------------
@@ -882,11 +897,11 @@
 {
     int arg;			/* Index of next argument to consume. */
     int value = 0;		/* Current integer value to be packed.
 				 * Initialized to avoid compiler warning. */
     char cmd;			/* Current format character. */
-    size_t count;			/* Count associated with current format
+    int count;			/* Count associated with current format
 				 * character. */
     int flags;			/* Format field flags */
     const char *format;		/* Pointer to current position in format
 				 * string. */
     Tcl_Obj *resultPtr = NULL;	/* Object holding result buffer. */
@@ -894,12 +909,11 @@
     unsigned char *cursor;	/* Current position within result buffer. */
     unsigned char *maxPos;	/* Greatest position within result buffer that
 				 * cursor has visited.*/
     const char *errorString;
     const char *errorValue, *str;
-    int offset, size;
-    size_t length;
+    int offset, size, length;
 
     if (objc < 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "formatString ?arg ...?");
 	return TCL_ERROR;
     }
@@ -934,11 +948,11 @@
 
 	    if (arg >= objc) {
 		goto badIndex;
 	    }
 	    if (count == BINARY_ALL) {
-		(void)TclGetByteArrayFromObj(objv[arg], &count);
+		Tcl_GetByteArrayFromObj(objv[arg], &count);
 	    } else if (count == BINARY_NOCOUNT) {
 		count = 1;
 	    }
 	    arg++;
 	    if (cmd == 'a' || cmd == 'A') {
@@ -1006,11 +1020,11 @@
 		}
 		arg++;
 
 		if (count == BINARY_ALL) {
 		    count = listc;
-		} else if (count > (size_t)listc) {
+		} else if (count > listc) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			    "number of elements in list does not match count",
 			    -1));
 		    return TCL_ERROR;
 		}
@@ -1030,20 +1044,20 @@
 	    break;
 	case 'X':
 	    if (count == BINARY_NOCOUNT) {
 		count = 1;
 	    }
-	    if ((count > (size_t)offset) || (count == BINARY_ALL)) {
+	    if ((count > offset) || (count == BINARY_ALL)) {
 		count = offset;
 	    }
-	    if (offset > (int)length) {
+	    if (offset > length) {
 		length = offset;
 	    }
 	    offset -= count;
 	    break;
 	case '@':
-	    if (offset > (int)length) {
+	    if (offset > length) {
 		length = offset;
 	    }
 	    if (count == BINARY_ALL) {
 		offset = length;
 	    } else if (count == BINARY_NOCOUNT) {
@@ -1055,11 +1069,11 @@
 	default:
 	    errorString = str;
 	    goto badField;
 	}
     }
-    if (offset > (int)length) {
+    if (offset > length) {
 	length = offset;
     }
     if (length == 0) {
 	return TCL_OK;
     }
@@ -1098,12 +1112,12 @@
 	case 'a':
 	case 'A': {
 	    char pad = (char) (cmd == 'a' ? '\0' : ' ');
 	    unsigned char *bytes;
 
-	    bytes = TclGetByteArrayFromObj(objv[arg], &length);
-	    arg++;
+	    bytes = Tcl_GetByteArrayFromObj(objv[arg++], &length);
+
 	    if (count == BINARY_ALL) {
 		count = length;
 	    } else if (count == BINARY_NOCOUNT) {
 		count = 1;
 	    }
@@ -1132,11 +1146,11 @@
 		count = length;
 	    }
 	    value = 0;
 	    errorString = "binary";
 	    if (cmd == 'B') {
-		for (offset = 0; (size_t)offset < count; offset++) {
+		for (offset = 0; offset < count; offset++) {
 		    value <<= 1;
 		    if (str[offset] == '1') {
 			value |= 1;
 		    } else if (str[offset] != '0') {
 			errorValue = str;
@@ -1147,11 +1161,11 @@
 			*cursor++ = UCHAR(value);
 			value = 0;
 		    }
 		}
 	    } else {
-		for (offset = 0; (size_t)offset < count; offset++) {
+		for (offset = 0; offset < count; offset++) {
 		    value >>= 1;
 		    if (str[offset] == '1') {
 			value |= 128;
 		    } else if (str[offset] != '0') {
 			errorValue = str;
@@ -1194,11 +1208,11 @@
 		count = length;
 	    }
 	    value = 0;
 	    errorString = "hexadecimal";
 	    if (cmd == 'H') {
-		for (offset = 0; (size_t)offset < count; offset++) {
+		for (offset = 0; offset < count; offset++) {
 		    value <<= 4;
 		    if (!isxdigit(UCHAR(str[offset]))) {     /* INTL: digit */
 			errorValue = str;
 			Tcl_DecrRefCount(resultPtr);
 			goto badValue;
@@ -1215,11 +1229,11 @@
 			*cursor++ = (char) value;
 			value = 0;
 		    }
 		}
 	    } else {
-		for (offset = 0; (size_t)offset < count; offset++) {
+		for (offset = 0; offset < count; offset++) {
 		    value >>= 4;
 
 		    if (!isxdigit(UCHAR(str[offset]))) {     /* INTL: digit */
 			errorValue = str;
 			Tcl_DecrRefCount(resultPtr);
@@ -1286,11 +1300,11 @@
 		if (count == BINARY_ALL) {
 		    count = listc;
 		}
 	    }
 	    arg++;
-	    for (i = 0; (size_t)i < count; i++) {
+	    for (i = 0; i < count; i++) {
 		if (FormatNumber(interp, cmd, listv[i], &cursor) != TCL_OK) {
 		    Tcl_DecrRefCount(resultPtr);
 		    return TCL_ERROR;
 		}
 	    }
@@ -1308,11 +1322,11 @@
 		maxPos = cursor;
 	    }
 	    if (count == BINARY_NOCOUNT) {
 		count = 1;
 	    }
-	    if ((count == BINARY_ALL) || (count > (size_t)(cursor - buffer))) {
+	    if ((count == BINARY_ALL) || (count > (cursor - buffer))) {
 		cursor = buffer;
 	    } else {
 		cursor -= count;
 	    }
 	    break;
@@ -1388,21 +1402,20 @@
 {
     int arg;			/* Index of next argument to consume. */
     int value = 0;		/* Current integer value to be packed.
 				 * Initialized to avoid compiler warning. */
     char cmd;			/* Current format character. */
-    size_t count;			/* Count associated with current format
+    int count;			/* Count associated with current format
 				 * character. */
     int flags;			/* Format field flags */
     const char *format;		/* Pointer to current position in format
 				 * string. */
     Tcl_Obj *resultPtr = NULL;	/* Object holding result buffer. */
     unsigned char *buffer;	/* Start of result buffer. */
     const char *errorString;
     const char *str;
-    int offset, size;
-    size_t length = 0;
+    int offset, size, length;
 
     int i;
     Tcl_Obj *valuePtr, *elementPtr;
     Tcl_HashTable numberCacheHash;
     Tcl_HashTable *numberCachePtr;
@@ -1412,11 +1425,11 @@
 		"value formatString ?varName ...?");
 	return TCL_ERROR;
     }
     numberCachePtr = &numberCacheHash;
     Tcl_InitHashTable(numberCachePtr, TCL_ONE_WORD_KEYS);
-    buffer = TclGetByteArrayFromObj(objv[1], &length);
+    buffer = Tcl_GetByteArrayFromObj(objv[1], &length);
     format = TclGetString(objv[2]);
     arg = 3;
     offset = 0;
     while (*format != '\0') {
 	str = format;
@@ -1437,11 +1450,11 @@
 		count = length - offset;
 	    } else {
 		if (count == BINARY_NOCOUNT) {
 		    count = 1;
 		}
-		if (count > length - offset) {
+		if (count > (length - offset)) {
 		    goto done;
 		}
 	    }
 
 	    src = buffer + offset;
@@ -1496,30 +1509,30 @@
 		count = (length - offset) * 8;
 	    } else {
 		if (count == BINARY_NOCOUNT) {
 		    count = 1;
 		}
-		if (count > (size_t)(length - offset) * 8) {
+		if (count > (length - offset) * 8) {
 		    goto done;
 		}
 	    }
 	    src = buffer + offset;
 	    valuePtr = Tcl_NewObj();
 	    Tcl_SetObjLength(valuePtr, count);
 	    dest = TclGetString(valuePtr);
 
 	    if (cmd == 'b') {
-		for (i = 0; (size_t)i < count; i++) {
+		for (i = 0; i < count; i++) {
 		    if (i % 8) {
 			value >>= 1;
 		    } else {
 			value = *src++;
 		    }
 		    *dest++ = (char) ((value & 1) ? '1' : '0');
 		}
 	    } else {
-		for (i = 0; (size_t)i < count; i++) {
+		for (i = 0; i < count; i++) {
 		    if (i % 8) {
 			value <<= 1;
 		    } else {
 			value = *src++;
 		    }
@@ -1561,20 +1574,20 @@
 	    valuePtr = Tcl_NewObj();
 	    Tcl_SetObjLength(valuePtr, count);
 	    dest = TclGetString(valuePtr);
 
 	    if (cmd == 'h') {
-		for (i = 0; (size_t)i < count; i++) {
+		for (i = 0; i < count; i++) {
 		    if (i % 2) {
 			value >>= 4;
 		    } else {
 			value = *src++;
 		    }
 		    *dest++ = hexdigit[value & 0xf];
 		}
 	    } else {
-		for (i = 0; (size_t)i < count; i++) {
+		for (i = 0; i < count; i++) {
 		    if (i % 2) {
 			value <<= 4;
 		    } else {
 			value = *src++;
 		    }
@@ -1627,11 +1640,11 @@
 	    if (arg >= objc) {
 		DeleteScanNumberCache(numberCachePtr);
 		goto badIndex;
 	    }
 	    if (count == BINARY_NOCOUNT) {
-		if ((length - offset) < (size_t)size) {
+		if ((length - offset) < size) {
 		    goto done;
 		}
 		valuePtr = ScanNumber(buffer+offset, cmd, flags,
 			&numberCachePtr);
 		offset += size;
@@ -1642,11 +1655,11 @@
 		if ((length - offset) < (count * size)) {
 		    goto done;
 		}
 		valuePtr = Tcl_NewObj();
 		src = buffer + offset;
-		for (i = 0; (size_t)i < count; i++) {
+		for (i = 0; i < count; i++) {
 		    elementPtr = ScanNumber(src, cmd, flags, &numberCachePtr);
 		    src += size;
 		    Tcl_ListObjAppendElement(NULL, valuePtr, elementPtr);
 		}
 		offset += count * size;
@@ -1663,21 +1676,21 @@
 	}
 	case 'x':
 	    if (count == BINARY_NOCOUNT) {
 		count = 1;
 	    }
-	    if ((count == BINARY_ALL) || (count > length - offset)) {
+	    if ((count == BINARY_ALL) || (count > (length - offset))) {
 		offset = length;
 	    } else {
 		offset += count;
 	    }
 	    break;
 	case 'X':
 	    if (count == BINARY_NOCOUNT) {
 		count = 1;
 	    }
-	    if ((count == BINARY_ALL) || (count > (size_t)offset)) {
+	    if ((count == BINARY_ALL) || (count > offset)) {
 		offset = 0;
 	    } else {
 		offset -= count;
 	    }
 	    break;
@@ -1757,11 +1770,11 @@
 
 static int
 GetFormatSpec(
     const char **formatPtr,	/* Pointer to format string. */
     char *cmdPtr,		/* Pointer to location of command char. */
-    size_t *countPtr,		/* Pointer to repeat count value. */
+    int *countPtr,		/* Pointer to repeat count value. */
     int *flagsPtr)		/* Pointer to field flags */
 {
     /*
      * Skip any leading blanks.
      */
@@ -1923,11 +1936,11 @@
 
 static void
 CopyNumber(
     const void *from,		/* source */
     void *to,			/* destination */
-    size_t length,		/* Number of bytes to copy */
+    unsigned length,		/* Number of bytes to copy */
     int type)			/* What type of thing are we copying? */
 {
     switch (NeedReversing(type)) {
     case 0:
 	memcpy(to, from, length);
@@ -2273,20 +2286,20 @@
 
     returnNumericObject:
 	if (*numberCachePtrPtr == NULL) {
 	    return Tcl_NewWideIntObj(value);
 	} else {
-	    register Tcl_HashTable *tablePtr = *numberCachePtrPtr;
-	    register Tcl_HashEntry *hPtr;
+	    Tcl_HashTable *tablePtr = *numberCachePtrPtr;
+	    Tcl_HashEntry *hPtr;
 	    int isNew;
 
 	    hPtr = Tcl_CreateHashEntry(tablePtr, INT2PTR(value), &isNew);
 	    if (!isNew) {
 		return Tcl_GetHashValue(hPtr);
 	    }
 	    if (tablePtr->numEntries <= BINARY_SCAN_MAX_CACHE) {
-		register Tcl_Obj *objPtr = Tcl_NewWideIntObj(value);
+		Tcl_Obj *objPtr = Tcl_NewWideIntObj(value);
 
 		Tcl_IncrRefCount(objPtr);
 		Tcl_SetHashValue(hPtr, objPtr);
 		return objPtr;
 	    }
@@ -2401,11 +2414,11 @@
 	return;
     }
 
     hEntry = Tcl_FirstHashEntry(numberCachePtr, &search);
     while (hEntry != NULL) {
-	register Tcl_Obj *value = Tcl_GetHashValue(hEntry);
+	Tcl_Obj *value = Tcl_GetHashValue(hEntry);
 
 	if (value != NULL) {
 	    Tcl_DecrRefCount(value);
 	}
 	hEntry = Tcl_NextHashEntry(&search);
@@ -2455,19 +2468,19 @@
     Tcl_Obj *const objv[])
 {
     Tcl_Obj *resultObj = NULL;
     unsigned char *data = NULL;
     unsigned char *cursor = NULL;
-    size_t offset = 0, count = 0;
+    int offset = 0, count = 0;
 
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "data");
 	return TCL_ERROR;
     }
 
     TclNewObj(resultObj);
-    data = TclGetByteArrayFromObj(objv[1], &count);
+    data = Tcl_GetByteArrayFromObj(objv[1], &count);
     cursor = Tcl_SetByteArrayLength(resultObj, count * 2);
     for (offset = 0; offset < count; ++offset) {
 	*cursor++ = HexDigits[(data[offset] >> 4) & 0x0f];
 	*cursor++ = HexDigits[data[offset] & 0x0f];
     }
@@ -2499,12 +2512,11 @@
     Tcl_Obj *const objv[])
 {
     Tcl_Obj *resultObj = NULL;
     unsigned char *data, *datastart, *dataend;
     unsigned char *begin, *cursor, c;
-    int i, index, value, size, cut = 0, strict = 0;
-    size_t count = 0;
+    int i, index, value, size, count = 0, cut = 0, strict = 0;
     enum {OPT_STRICT };
     static const char *const optStrings[] = { "-strict", NULL };
 
     if (objc < 2 || objc > 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "?options? data");
@@ -2569,12 +2581,12 @@
     return TCL_OK;
 
   badChar:
     TclDecrRefCount(resultObj);
     Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-	    "invalid hexadecimal digit \"%c\" at position %" TCL_Z_MODIFIER "u",
-	    c, data - datastart - 1));
+	    "invalid hexadecimal digit \"%c\" at position %d",
+	    c, (int) (data - datastart - 1)));
     return TCL_ERROR;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -2620,13 +2632,12 @@
 {
     Tcl_Obj *resultObj;
     unsigned char *data, *cursor, *limit;
     int maxlen = 0;
     const char *wrapchar = "\n";
-    size_t wrapcharlen = 1;
-    int i, index, size, outindex = 0;
-    size_t offset, count = 0;
+    int wrapcharlen = 1;
+    int offset, i, index, size, outindex = 0, count = 0;
     enum { OPT_MAXLEN, OPT_WRAPCHAR };
     static const char *const optStrings[] = { "-maxlen", "-wrapchar", NULL };
 
     if (objc < 2 || objc % 2 != 0) {
 	Tcl_WrongNumArgs(interp, 1, objv,
@@ -2659,11 +2670,11 @@
 	    break;
 	}
     }
 
     resultObj = Tcl_NewObj();
-    data = TclGetByteArrayFromObj(objv[objc - 1], &count);
+    data = Tcl_GetByteArrayFromObj(objv[objc - 1], &count);
     if (count > 0) {
 	size = (((count * 4) / 3) + 3) & ~3;	/* ensure 4 byte chunks */
 	if (maxlen > 0 && size > maxlen) {
 	    int adjusted = size + (wrapcharlen * (size / maxlen));
 
@@ -2725,15 +2736,15 @@
     int objc,
     Tcl_Obj *const objv[])
 {
     Tcl_Obj *resultObj;
     unsigned char *data, *start, *cursor;
-    int rawLength, n, i, bits, index;
+    int offset, count, rawLength, n, i, j, bits, index;
     int lineLength = 61;
     const unsigned char SingleNewline[] = { (unsigned char) '\n' };
     const unsigned char *wrapchar = SingleNewline;
-    size_t j, offset, count = 0, wrapcharlen = sizeof(SingleNewline);
+    int wrapcharlen = sizeof(SingleNewline);
     enum { OPT_MAXLEN, OPT_WRAPCHAR };
     static const char *const optStrings[] = { "-maxlen", "-wrapchar", NULL };
 
     if (objc < 2 || objc % 2 != 0) {
 	Tcl_WrongNumArgs(interp, 1, objv,
@@ -2758,11 +2769,11 @@
 			"LINE_LENGTH", NULL);
 		return TCL_ERROR;
 	    }
 	    break;
 	case OPT_WRAPCHAR:
-	    wrapchar = TclGetByteArrayFromObj(objv[i + 1], &wrapcharlen);
+	    wrapchar = Tcl_GetByteArrayFromObj(objv[i + 1], &wrapcharlen);
 	    break;
 	}
     }
 
     /*
@@ -2770,11 +2781,11 @@
      * enough".
      */
 
     resultObj = Tcl_NewObj();
     offset = 0;
-    data = TclGetByteArrayFromObj(objv[objc - 1], &count);
+    data = Tcl_GetByteArrayFromObj(objv[objc - 1], &count);
     rawLength = (lineLength - 1) * 3 / 4;
     start = cursor = Tcl_SetByteArrayLength(resultObj,
 	    (lineLength + wrapcharlen) *
 	    ((count + (rawLength - 1)) / rawLength));
     n = bits = 0;
@@ -2843,12 +2854,11 @@
     Tcl_Obj *const objv[])
 {
     Tcl_Obj *resultObj = NULL;
     unsigned char *data, *datastart, *dataend;
     unsigned char *begin, *cursor;
-    int i, index, size, strict = 0, lineLen;
-    size_t count = 0;
+    int i, index, size, count = 0, strict = 0, lineLen;
     unsigned char c;
     enum { OPT_STRICT };
     static const char *const optStrings[] = { "-strict", NULL };
 
     if (objc < 2 || objc > 3) {
@@ -2974,12 +2984,12 @@
     TclDecrRefCount(resultObj);
     return TCL_ERROR;
 
   badUu:
     Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-	    "invalid uuencode character \"%c\" at position %" TCL_Z_MODIFIER "u",
-	    c, data - datastart - 1));
+	    "invalid uuencode character \"%c\" at position %d",
+	    c, (int) (data - datastart - 1)));
     Tcl_SetErrorCode(interp, "TCL", "BINARY", "DECODE", "INVALID", NULL);
     TclDecrRefCount(resultObj);
     return TCL_ERROR;
 }
 
@@ -3009,12 +3019,11 @@
     Tcl_Obj *resultObj = NULL;
     unsigned char *data, *datastart, *dataend, c = '\0';
     unsigned char *begin = NULL;
     unsigned char *cursor = NULL;
     int strict = 0;
-    int i, index, size, cut = 0;
-    size_t count = 0;
+    int i, index, size, cut = 0, count = 0;
     enum { OPT_STRICT };
     static const char *const optStrings[] = { "-strict", NULL };
 
     if (objc < 2 || objc > 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "?options? data");
@@ -3139,12 +3148,12 @@
     Tcl_SetObjResult(interp, resultObj);
     return TCL_OK;
 
   bad64:
     Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-	    "invalid base64 character \"%c\" at position %" TCL_Z_MODIFIER "u",
-	    (char) c, data - datastart - 1));
+	    "invalid base64 character \"%c\" at position %d",
+	    (char) c, (int) (data - datastart - 1)));
     TclDecrRefCount(resultObj);
     return TCL_ERROR;
 }
 
 /*

Index: generic/tclCkalloc.c
==================================================================
--- generic/tclCkalloc.c
+++ generic/tclCkalloc.c
@@ -18,11 +18,13 @@
 #include "tclInt.h"
 
 #define FALSE	0
 #define TRUE	1
 
+#undef Tcl_Alloc
 #undef Tcl_Free
+#undef Tcl_Realloc
 #undef Tcl_AttemptAlloc
 #undef Tcl_AttemptRealloc
 
 #ifdef TCL_MEM_DEBUG
 
@@ -29,11 +31,11 @@
 /*
  * One of the following structures is allocated each time the
  * "memory tag" command is invoked, to hold the current tag.
  */
 
-typedef struct {
+typedef struct MemTag {
     size_t refCount;		/* Number of mem_headers referencing this
 				 * tag. */
     char string[1];		/* Actual size of string will be as large as
 				 * needed for actual tag. This must be the
 				 * last field in the structure. */
@@ -117,11 +119,11 @@
 				 * information. */
 
 /*
  * Mutex to serialize allocations. This is a low-level mutex that must be
  * explicitly initialized. This is necessary because the self initializing
- * mutexes use Tcl_Alloc...
+ * mutexes use ckalloc...
  */
 
 static Tcl_Mutex *ckallocMutexPtr;
 static int ckallocInit = 0;
 
@@ -141,11 +143,11 @@
  *
  * TclInitDbCkalloc --
  *
  *	Initialize the locks used by the allocator. This is only appropriate
  *	to call in a single threaded environment, such as during
- *	TclInitSubsystems.
+ *	Tcl_InitSubsystems.
  *
  *----------------------------------------------------------------------
  */
 
 void
@@ -241,16 +243,16 @@
 	byte = *(memHeaderP->low_guard + idx);
 	if (byte != GUARD_VALUE) {
 	    guard_failed = TRUE;
 	    fflush(stdout);
 	    byte &= 0xff;
-	    fprintf(stderr, "low guard byte %" TCL_Z_MODIFIER "u is 0x%x  \t%c\n", idx, byte,
+	    fprintf(stderr, "low guard byte %d is 0x%x  \t%c\n", (int)idx, byte,
 		    (isprint(UCHAR(byte)) ? byte : ' ')); /* INTL: bytes */
 	}
     }
     if (guard_failed) {
-	TclDumpMemoryInfo(stderr, 0);
+	TclDumpMemoryInfo((ClientData) stderr, 0);
 	fprintf(stderr, "low guard failed at %p, %s %d\n",
 		memHeaderP->body, file, line);
 	fflush(stderr);			/* In case name pointer is bad. */
 	fprintf(stderr, "%" TCL_Z_MODIFIER "u bytes allocated at (%s %d)\n", memHeaderP->length,
 		memHeaderP->file, memHeaderP->line);
@@ -262,17 +264,17 @@
 	byte = *(hiPtr + idx);
 	if (byte != GUARD_VALUE) {
 	    guard_failed = TRUE;
 	    fflush(stdout);
 	    byte &= 0xff;
-	    fprintf(stderr, "hi guard byte %" TCL_Z_MODIFIER "u is 0x%x  \t%c\n", idx, byte,
+	    fprintf(stderr, "hi guard byte %d is 0x%x  \t%c\n", (int)idx, byte,
 		    (isprint(UCHAR(byte)) ? byte : ' ')); /* INTL: bytes */
 	}
     }
 
     if (guard_failed) {
-	TclDumpMemoryInfo(stderr, 0);
+	TclDumpMemoryInfo((ClientData) stderr, 0);
 	fprintf(stderr, "high guard failed at %p, %s %d\n",
 		memHeaderP->body, file, line);
 	fflush(stderr);			/* In case name pointer is bad. */
 	fprintf(stderr, "%" TCL_Z_MODIFIER "u bytes allocated at (%s %d)\n",
 		memHeaderP->length, memHeaderP->file,
@@ -372,28 +374,28 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_DbCkalloc - debugging Tcl_Alloc
+ * 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, 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.
  *
  *	The second and third arguments are file and line, these contain the
  *	filename and line number corresponding to the caller. These are sent
- *	by the Tcl_Alloc macro; it uses the preprocessor autodefines __FILE__
+ *	by the ckalloc macro; it uses the preprocessor autodefines __FILE__
  *	and __LINE__.
  *
  *----------------------------------------------------------------------
  */
 
-void *
+char *
 Tcl_DbCkalloc(
-    size_t size,
+    unsigned int size,
     const char *file,
     int line)
 {
     struct mem_header *result = NULL;
 
@@ -406,12 +408,12 @@
 	result = (struct mem_header *) TclpAlloc(size +
 		sizeof(struct mem_header) + HIGH_GUARD_SIZE);
     }
     if (result == NULL) {
 	fflush(stdout);
-	TclDumpMemoryInfo(stderr, 0);
-	Tcl_Panic("unable to alloc %" TCL_Z_MODIFIER "u bytes, %s line %d", size, file, line);
+	TclDumpMemoryInfo((ClientData) stderr, 0);
+	Tcl_Panic("unable to alloc %u bytes, %s line %d", size, file, line);
     }
 
     /*
      * Fill in guard zones and size. Also initialize the contents of the block
      * with bogus bytes to detect uses of initialized data. Link into
@@ -453,11 +455,11 @@
 	alloc_tracing = TRUE;
 	trace_on_at_malloc = 0;
     }
 
     if (alloc_tracing) {
-	fprintf(stderr,"Tcl_Alloc %p %" TCL_Z_MODIFIER "u %s %d\n",
+	fprintf(stderr,"ckalloc %p %u %s %d\n",
 		result->body, size, file, line);
     }
 
     if (break_on_malloc && (total_mallocs >= break_on_malloc)) {
 	break_on_malloc = 0;
@@ -477,13 +479,13 @@
     Tcl_MutexUnlock(ckallocMutexPtr);
 
     return result->body;
 }
 
-void *
+char *
 Tcl_AttemptDbCkalloc(
-    size_t size,
+    unsigned int size,
     const char *file,
     int line)
 {
     struct mem_header *result = NULL;
 
@@ -496,11 +498,11 @@
 	result = (struct mem_header *) TclpAlloc(size +
 		sizeof(struct mem_header) + HIGH_GUARD_SIZE);
     }
     if (result == NULL) {
 	fflush(stdout);
-	TclDumpMemoryInfo(stderr, 0);
+	TclDumpMemoryInfo((ClientData) stderr, 0);
 	return NULL;
     }
 
     /*
      * Fill in guard zones and size. Also initialize the contents of the block
@@ -542,11 +544,11 @@
 	alloc_tracing = TRUE;
 	trace_on_at_malloc = 0;
     }
 
     if (alloc_tracing) {
-	fprintf(stderr,"Tcl_Alloc %p %" TCL_Z_MODIFIER "u %s %d\n",
+	fprintf(stderr,"ckalloc %p %u %s %d\n",
 		result->body, size, file, line);
     }
 
     if (break_on_malloc && (total_mallocs >= break_on_malloc)) {
 	break_on_malloc = 0;
@@ -569,28 +571,28 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_DbCkfree - debugging Tcl_Free
+ * Tcl_DbCkfree - debugging ckfree
  *
  *	Verify that the low and high guards are intact, and if so then free
  *	the buffer else Tcl_Panic.
  *
  *	The guards are erased after being checked to catch duplicate frees.
  *
  *	The second and third arguments are file and line, these contain the
  *	filename and line number corresponding to the caller. These are sent
- *	by the Tcl_Free macro; it uses the preprocessor autodefines __FILE__ and
+ *	by the ckfree macro; it uses the preprocessor autodefines __FILE__ and
  *	__LINE__.
  *
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_DbCkfree(
-    void *ptr,
+    char *ptr,
     const char *file,
     int line)
 {
     struct mem_header *memp;
 
@@ -607,11 +609,11 @@
      */
 
     memp = (struct mem_header *) (((size_t) ptr) - BODY_OFFSET);
 
     if (alloc_tracing) {
-	fprintf(stderr, "Tcl_Free %p %" TCL_Z_MODIFIER "u %s %d\n",
+	fprintf(stderr, "ckfree %p %" TCL_Z_MODIFIER "u %s %d\n",
 		memp->body, memp->length, file, line);
     }
 
     if (validate_memory) {
 	Tcl_ValidateAllMemory(file, line);
@@ -651,24 +653,24 @@
 }
 
 /*
  *--------------------------------------------------------------------
  *
- * Tcl_DbCkrealloc - debugging Tcl_Realloc
+ * Tcl_DbCkrealloc - debugging ckrealloc
  *
  *	Reallocate a chunk of memory by allocating a new one of the right
  *	size, copying the old data to the new location, and then freeing the
  *	old memory space, using all the memory checking features of this
  *	package.
  *
  *--------------------------------------------------------------------
  */
 
-void *
+char *
 Tcl_DbCkrealloc(
-    void *ptr,
-    size_t size,
+    char *ptr,
+    unsigned int size,
     const char *file,
     int line)
 {
     char *newPtr;
     size_t copySize;
@@ -692,14 +694,14 @@
     memcpy(newPtr, ptr, copySize);
     Tcl_DbCkfree(ptr, file, line);
     return newPtr;
 }
 
-void *
+char *
 Tcl_AttemptDbCkrealloc(
-    void *ptr,
-    size_t size,
+    char *ptr,
+    unsigned int size,
     const char *file,
     int line)
 {
     char *newPtr;
     size_t copySize;
@@ -726,10 +728,63 @@
     memcpy(newPtr, ptr, copySize);
     Tcl_DbCkfree(ptr, file, line);
     return newPtr;
 }
 
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_Alloc, et al. --
+ *
+ *	These functions are defined in terms of the debugging versions when
+ *	TCL_MEM_DEBUG is set.
+ *
+ * Results:
+ *	Same as the debug versions.
+ *
+ * Side effects:
+ *	Same as the debug versions.
+ *
+ *----------------------------------------------------------------------
+ */
+
+char *
+Tcl_Alloc(
+    unsigned int size)
+{
+    return Tcl_DbCkalloc(size, "unknown", 0);
+}
+
+char *
+Tcl_AttemptAlloc(
+    unsigned int size)
+{
+    return Tcl_AttemptDbCkalloc(size, "unknown", 0);
+}
+
+void
+Tcl_Free(
+    char *ptr)
+{
+    Tcl_DbCkfree(ptr, "unknown", 0);
+}
+
+char *
+Tcl_Realloc(
+    char *ptr,
+    unsigned int size)
+{
+    return Tcl_DbCkrealloc(ptr, size, "unknown", 0);
+}
+char *
+Tcl_AttemptRealloc(
+    char *ptr,
+    unsigned int size)
+{
+    return Tcl_AttemptDbCkrealloc(ptr, size, "unknown", 0);
+}
 
 /*
  *----------------------------------------------------------------------
  *
  * MemoryCmd --
@@ -995,16 +1050,15 @@
  *	that memory was actually allocated.
  *
  *----------------------------------------------------------------------
  */
 
-#undef Tcl_Alloc
-void *
+char *
 Tcl_Alloc(
-    size_t size)
+    unsigned int size)
 {
-    void *result;
+    char *result;
 
     result = TclpAlloc(size);
 
     /*
      * Most systems will not alloc(0), instead bumping it to one so that NULL
@@ -1015,29 +1069,28 @@
      * The ANSI spec actually says that systems either return NULL *or* a
      * special pointer on failure, but we only check for NULL
      */
 
     if ((result == NULL) && size) {
-	Tcl_Panic("unable to alloc %" TCL_Z_MODIFIER "u bytes", size);
+	Tcl_Panic("unable to alloc %u bytes", size);
     }
     return result;
 }
 
-void *
+char *
 Tcl_DbCkalloc(
-    size_t size,
+    unsigned int size,
     const char *file,
     int line)
 {
-    void *result;
+    char *result;
 
-    result = TclpAlloc(size);
+    result = (char *) TclpAlloc(size);
 
     if ((result == NULL) && size) {
 	fflush(stdout);
-	Tcl_Panic("unable to alloc %" TCL_Z_MODIFIER "u bytes, %s line %d",
-		size, file, line);
+	Tcl_Panic("unable to alloc %u bytes, %s line %d", size, file, line);
     }
     return result;
 }
 
 /*
@@ -1049,29 +1102,31 @@
  *	check that memory was actually allocated.
  *
  *----------------------------------------------------------------------
  */
 
-void *
+char *
 Tcl_AttemptAlloc(
-    size_t size)
+    unsigned int size)
 {
-    void *result;
+    char *result;
 
     result = TclpAlloc(size);
     return result;
 }
 
-void *
+char *
 Tcl_AttemptDbCkalloc(
-    size_t size,
+    unsigned int size,
     const char *file,
     int line)
 {
-    void *result;
+    char *result;
+    (void)file;
+    (void)line;
 
-    result = TclpAlloc(size);
+    result = (char *) TclpAlloc(size);
     return result;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1082,41 +1137,39 @@
  *	that memory was actually allocated.
  *
  *----------------------------------------------------------------------
  */
 
-#undef Tcl_Realloc
-void *
+char *
 Tcl_Realloc(
-    void *ptr,
-    size_t size)
+    char *ptr,
+    unsigned int size)
 {
     char *result;
 
     result = TclpRealloc(ptr, size);
 
     if ((result == NULL) && size) {
-	Tcl_Panic("unable to realloc %" TCL_Z_MODIFIER "u bytes", size);
+	Tcl_Panic("unable to realloc %u bytes", size);
     }
     return result;
 }
 
-void *
+char *
 Tcl_DbCkrealloc(
-    void *ptr,
-    size_t size,
+    char *ptr,
+    unsigned int size,
     const char *file,
     int line)
 {
-    void *result;
+    char *result;
 
-    result = TclpRealloc(ptr, size);
+    result = (char *) TclpRealloc(ptr, size);
 
     if ((result == NULL) && size) {
 	fflush(stdout);
-	Tcl_Panic("unable to realloc %" TCL_Z_MODIFIER "u bytes, %s line %d",
-		size, file, line);
+	Tcl_Panic("unable to realloc %u bytes, %s line %d", size, file, line);
     }
     return result;
 }
 
 /*
@@ -1128,31 +1181,33 @@
  *	check that memory was actually allocated.
  *
  *----------------------------------------------------------------------
  */
 
-void *
+char *
 Tcl_AttemptRealloc(
-    void *ptr,
-    size_t size)
+    char *ptr,
+    unsigned int size)
 {
-    void *result;
+    char *result;
 
     result = TclpRealloc(ptr, size);
     return result;
 }
 
-void *
+char *
 Tcl_AttemptDbCkrealloc(
-    void *ptr,
-    size_t size,
+    char *ptr,
+    unsigned int size,
     const char *file,
     int line)
 {
-    void *result;
+    char *result;
+    (void)file;
+    (void)line;
 
-    result = TclpRealloc(ptr, size);
+    result = (char *) TclpRealloc(ptr, size);
     return result;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1164,24 +1219,25 @@
  *	TCL_MEM_DEBUG enabled and some with it disabled.
  *
  *----------------------------------------------------------------------
  */
 
-#undef Tcl_Free
 void
 Tcl_Free(
-    void *ptr)
+    char *ptr)
 {
     TclpFree(ptr);
 }
 
 void
 Tcl_DbCkfree(
-    void *ptr,
+    char *ptr,
     const char *file,
     int line)
 {
+    (void)file;
+    (void)line;
     TclpFree(ptr);
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1196,31 +1252,37 @@
 	/* ARGSUSED */
 void
 Tcl_InitMemory(
     Tcl_Interp *interp)
 {
+    (void)interp;
 }
 
 int
 Tcl_DumpActiveMemory(
     const char *fileName)
 {
+    (void)fileName;
     return TCL_OK;
 }
 
 void
 Tcl_ValidateAllMemory(
     const char *file,
     int line)
 {
+    (void)file;
+    (void)line;
 }
 
 int
 TclDumpMemoryInfo(
     ClientData clientData,
     int flags)
 {
+    (void)clientData;
+    (void)flags;
     return 1;
 }
 
 #endif	/* TCL_MEM_DEBUG */
 

Index: generic/tclClock.c
==================================================================
--- generic/tclClock.c
+++ generic/tclClock.c
@@ -98,11 +98,11 @@
 
 /*
  * Structure containing the fields used in [clock format] and [clock scan]
  */
 
-typedef struct {
+typedef struct TclDateFields {
     Tcl_WideInt seconds;	/* Time expressed in seconds from the Posix
 				 * epoch */
     Tcl_WideInt localSeconds;	/* Local time expressed in nominal seconds
 				 * from the Posix epoch */
     int tzOffset;		/* Time zone offset in seconds east of
@@ -273,13 +273,13 @@
 
     /*
      * Create the client data, which is a refcounted literal pool.
      */
 
-    data = Tcl_Alloc(sizeof(ClockClientData));
+    data = ckalloc(sizeof(ClockClientData));
     data->refCount = 0;
-    data->literals = Tcl_Alloc(LIT__END * sizeof(Tcl_Obj*));
+    data->literals = ckalloc(LIT__END * sizeof(Tcl_Obj*));
     for (i = 0; i < LIT__END; ++i) {
 	data->literals[i] = Tcl_NewStringObj(literals[i], -1);
 	Tcl_IncrRefCount(data->literals[i]);
     }
 
@@ -1650,10 +1650,11 @@
     int objc,
     Tcl_Obj *const objv[])
 {
     const char *varName;
     const char *varValue;
+    (void)clientData;
 
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "name");
 	return TCL_ERROR;
     }
@@ -1742,10 +1743,11 @@
 	CLICKS_MILLIS, CLICKS_MICROS, CLICKS_NATIVE
     };
     int index = CLICKS_NATIVE;
     Tcl_Time now;
     Tcl_WideInt clicks = 0;
+    (void)clientData;
 
     switch (objc) {
     case 1:
 	break;
     case 2:
@@ -1804,10 +1806,11 @@
     Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const *objv)	/* Parameter values */
 {
     Tcl_Time now;
+    (void)clientData;
 
     if (objc != 1) {
 	Tcl_WrongNumArgs(interp, 1, objv, NULL);
 	return TCL_ERROR;
     }
@@ -1840,10 +1843,11 @@
     ClientData clientData,	/* Client data is unused */
     Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const *objv)	/* Parameter values */
 {
+    (void)clientData;
     if (objc != 1) {
 	Tcl_WrongNumArgs(interp, 1, objv, NULL);
 	return TCL_ERROR;
     }
     Tcl_SetObjResult(interp, Tcl_NewWideIntObj(TclpGetMicroseconds()));
@@ -1915,11 +1919,11 @@
     timezoneObj = litPtr[LIT__NIL];
     for (i = 2; i < objc; i+=2) {
 	if (Tcl_GetIndexFromObj(interp, objv[i], options, "option", 0,
 		&optionIndex) != TCL_OK) {
 	    Tcl_SetErrorCode(interp, "CLOCK", "badOption",
-		    TclGetString(objv[i]), NULL);
+		    Tcl_GetString(objv[i]), NULL);
 	    return TCL_ERROR;
 	}
 	switch (optionIndex) {
 	case CLOCK_FORMAT_FORMAT:
 	    formatObj = objv[i+1];
@@ -1992,10 +1996,11 @@
     Tcl_Interp *interp,		/* Tcl interpreter */
     int objc,			/* Parameter count */
     Tcl_Obj *const *objv)	/* Parameter values */
 {
     Tcl_Time now;
+    (void)clientData;
 
     if (objc != 1) {
 	Tcl_WrongNumArgs(interp, 1, objv, NULL);
 	return TCL_ERROR;
     }
@@ -2032,17 +2037,17 @@
     tzIsNow = getenv("TZ");
     if (tzIsNow != NULL && (tzWas == NULL || tzWas == INT2PTR(-1)
 	    || strcmp(tzIsNow, tzWas) != 0)) {
 	tzset();
 	if (tzWas != NULL && tzWas != INT2PTR(-1)) {
-	    Tcl_Free(tzWas);
+	    ckfree(tzWas);
 	}
-	tzWas = Tcl_Alloc(strlen(tzIsNow) + 1);
+	tzWas = ckalloc(strlen(tzIsNow) + 1);
 	strcpy(tzWas, tzIsNow);
     } else if (tzIsNow == NULL && tzWas != NULL) {
 	tzset();
-	if (tzWas != INT2PTR(-1)) Tcl_Free(tzWas);
+	if (tzWas != INT2PTR(-1)) ckfree(tzWas);
 	tzWas = NULL;
     }
     Tcl_MutexUnlock(&clockMutex);
 }
 
@@ -2069,12 +2074,12 @@
 
     if (data->refCount-- <= 1) {
 	for (i = 0; i < LIT__END; ++i) {
 	    Tcl_DecrRefCount(data->literals[i]);
 	}
-	Tcl_Free(data->literals);
-	Tcl_Free(data);
+	ckfree(data->literals);
+	ckfree(data);
     }
 }
 
 /*
  * Local Variables:

Index: generic/tclCmdAH.c
==================================================================
--- generic/tclCmdAH.c
+++ generic/tclCmdAH.c
@@ -13,11 +13,10 @@
 
 #include "tclInt.h"
 #ifdef _WIN32
 #   include "tclWinInt.h"
 #endif
-#include <locale.h>
 
 /*
  * The state structure used by [foreach]. Note that the actual structure has
  * all its working arrays appended afterwards so they can be allocated and
  * freed in a single step.
@@ -141,10 +140,147 @@
 	return TCL_ERROR;
     }
     return TCL_BREAK;
 }
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_CaseObjCmd --
+ *
+ *	This procedure is invoked to process the "case" Tcl command. See the
+ *	user documentation for details on what it does. THIS COMMAND IS
+ *	OBSOLETE AND DEPRECATED. SLATED FOR REMOVAL IN TCL 9.0.
+ *
+ * Results:
+ *	A standard Tcl object result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+	/* ARGSUSED */
+int
+Tcl_CaseObjCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    int i;
+    int body, result, caseObjc;
+    const char *stringPtr, *arg;
+    Tcl_Obj *const *caseObjv;
+    Tcl_Obj *armPtr;
+
+    if (objc < 3) {
+	Tcl_WrongNumArgs(interp, 1, objv,
+		"string ?in? ?pattern body ...? ?default body?");
+	return TCL_ERROR;
+    }
+
+    stringPtr = TclGetString(objv[1]);
+    body = -1;
+
+    arg = TclGetString(objv[2]);
+    if (strcmp(arg, "in") == 0) {
+	i = 3;
+    } else {
+	i = 2;
+    }
+    caseObjc = objc - i;
+    caseObjv = objv + i;
+
+    /*
+     * If all of the pattern/command pairs are lumped into a single argument,
+     * split them out again.
+     */
+
+    if (caseObjc == 1) {
+	Tcl_Obj **newObjv;
+
+	TclListObjGetElements(interp, caseObjv[0], &caseObjc, &newObjv);
+	caseObjv = newObjv;
+    }
+
+    for (i = 0;  i < caseObjc;  i += 2) {
+	int patObjc, j;
+	const char **patObjv;
+	const char *pat, *p;
+
+	if (i == caseObjc-1) {
+	    Tcl_ResetResult(interp);
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
+		    "extra case pattern with no body", -1));
+	    return TCL_ERROR;
+	}
+
+	/*
+	 * Check for special case of single pattern (no list) with no
+	 * backslash sequences.
+	 */
+
+	pat = TclGetString(caseObjv[i]);
+	for (p = pat; *p != '\0'; p++) {
+	    if (TclIsSpaceProc(*p) || (*p == '\\')) {
+		break;
+	    }
+	}
+	if (*p == '\0') {
+	    if ((*pat == 'd') && (strcmp(pat, "default") == 0)) {
+		body = i + 1;
+	    }
+	    if (Tcl_StringMatch(stringPtr, pat)) {
+		body = i + 1;
+		goto match;
+	    }
+	    continue;
+	}
+
+	/*
+	 * Break up pattern lists, then check each of the patterns in the
+	 * list.
+	 */
+
+	result = Tcl_SplitList(interp, pat, &patObjc, &patObjv);
+	if (result != TCL_OK) {
+	    return result;
+	}
+	for (j = 0; j < patObjc; j++) {
+	    if (Tcl_StringMatch(stringPtr, patObjv[j])) {
+		body = i + 1;
+		break;
+	    }
+	}
+	ckfree(patObjv);
+	if (j < patObjc) {
+	    break;
+	}
+    }
+
+  match:
+    if (body != -1) {
+	armPtr = caseObjv[body - 1];
+	result = Tcl_EvalObjEx(interp, caseObjv[body], 0);
+	if (result == TCL_ERROR) {
+	    Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
+		    "\n    (\"%.50s\" arm line %d)",
+		    TclGetString(armPtr), Tcl_GetErrorLine(interp)));
+	}
+	return result;
+    }
+
+    /*
+     * Nothing matched: return nothing.
+     */
+
+    return TCL_OK;
+}
+#endif /* !TCL_NO_DEPRECATED */
+
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_CatchObjCmd --
  *
@@ -426,11 +562,11 @@
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Tcl_Obj *data;		/* Byte array to convert */
     Tcl_DString ds;		/* Buffer to hold the string */
     Tcl_Encoding encoding;	/* Encoding to use */
-    size_t length = 0;			/* Length of the byte array being converted */
+    int length;			/* Length of the byte array being converted */
     const char *bytesPtr;	/* Pointer to the first byte of the array */
 
     if (objc == 2) {
 	encoding = Tcl_GetEncoding(interp, NULL);
 	data = objv[1];
@@ -445,11 +581,11 @@
     }
 
     /*
      * Convert the string into a byte array in 'ds'
      */
-    bytesPtr = (char *) TclGetByteArrayFromObj(data, &length);
+    bytesPtr = (char *) Tcl_GetByteArrayFromObj(data, &length);
     Tcl_ExternalToUtfDString(encoding, bytesPtr, length, &ds);
 
     /*
      * Note that we cannot use Tcl_DStringResult here because it will
      * truncate the string at the first null byte.
@@ -488,11 +624,11 @@
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Tcl_Obj *data;		/* String to convert */
     Tcl_DString ds;		/* Buffer to hold the byte array */
     Tcl_Encoding encoding;	/* Encoding to use */
-    size_t length;			/* Length of the string being converted */
+    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) {
@@ -733,11 +869,11 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    register Tcl_Obj *objPtr;
+    Tcl_Obj *objPtr;
     Interp *iPtr = (Interp *) interp;
     CmdFrame *invoker = NULL;
     int word = 0;
 
     if (objc < 2) {
@@ -1000,11 +1136,11 @@
     if (GetStatBuf(interp, objv[1], Tcl_FSStat, &buf) != TCL_OK) {
 	return TCL_ERROR;
     }
 #if defined(_WIN32)
     /* We use a value of 0 to indicate the access time not available */
-    if (buf.st_atime == 0) {
+    if (Tcl_GetAccessTimeFromStat(&buf) == 0) {
         Tcl_SetObjResult(interp, Tcl_ObjPrintf(
                              "could not get access time for file \"%s\"",
                              TclGetString(objv[1])));
         return TCL_ERROR;
     }
@@ -1021,11 +1157,11 @@
 	if (TclGetWideIntFromObj(interp, objv[2], &newTime) != TCL_OK) {
 	    return TCL_ERROR;
 	}
 
 	tval.actime = newTime;
-	tval.modtime = buf.st_mtime;
+	tval.modtime = Tcl_GetModificationTimeFromStat(&buf);
 
 	if (Tcl_FSUtime(objv[1], &tval) != 0) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "could not set access time for file \"%s\": %s",
 		    TclGetString(objv[1]), Tcl_PosixError(interp)));
@@ -1041,11 +1177,11 @@
 	if (GetStatBuf(interp, objv[1], Tcl_FSStat, &buf) != TCL_OK) {
 	    return TCL_ERROR;
 	}
     }
 
-    Tcl_SetObjResult(interp, Tcl_NewWideIntObj((long) buf.st_atime));
+    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(Tcl_GetAccessTimeFromStat(&buf)));
     return TCL_OK;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1082,11 +1218,11 @@
     if (GetStatBuf(interp, objv[1], Tcl_FSStat, &buf) != TCL_OK) {
 	return TCL_ERROR;
     }
 #if defined(_WIN32)
     /* We use a value of 0 to indicate the modification time not available */
-    if (buf.st_mtime == 0) {
+    if (Tcl_GetModificationTimeFromStat(&buf) == 0) {
         Tcl_SetObjResult(interp, Tcl_ObjPrintf(
                              "could not get modification time for file \"%s\"",
                              TclGetString(objv[1])));
         return TCL_ERROR;
     }
@@ -1101,11 +1237,11 @@
 
 	if (TclGetWideIntFromObj(interp, objv[2], &newTime) != TCL_OK) {
 	    return TCL_ERROR;
 	}
 
-	tval.actime = buf.st_atime;
+	tval.actime = Tcl_GetAccessTimeFromStat(&buf);
 	tval.modtime = newTime;
 
 	if (Tcl_FSUtime(objv[1], &tval) != 0) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "could not set modification time for file \"%s\": %s",
@@ -1121,11 +1257,11 @@
 	if (GetStatBuf(interp, objv[1], Tcl_FSStat, &buf) != TCL_OK) {
 	    return TCL_ERROR;
 	}
     }
 
-    Tcl_SetObjResult(interp, Tcl_NewWideIntObj((long) buf.st_mtime));
+    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(Tcl_GetModificationTimeFromStat(&buf)));
     return TCL_OK;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1709,11 +1845,11 @@
     }
     fsInfo = Tcl_FSFileSystemInfo(objv[1]);
     if (fsInfo == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj("unrecognised path", -1));
 	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "FILESYSTEM",
-		TclGetString(objv[1]), NULL);
+		Tcl_GetString(objv[1]), NULL);
 	return TCL_ERROR;
     }
     Tcl_SetObjResult(interp, fsInfo);
     return TCL_OK;
 }
@@ -1961,11 +2097,11 @@
 
 	if (separatorObj == NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "unrecognised path", -1));
 	    Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "FILESYSTEM",
-		    TclGetString(objv[1]), NULL);
+		    Tcl_GetString(objv[1]), NULL);
 	    return TCL_ERROR;
 	}
 	Tcl_SetObjResult(interp, separatorObj);
     }
     return TCL_OK;
@@ -2115,11 +2251,11 @@
 				 * to store stat results. */
     Tcl_StatBuf *statPtr)	/* Pointer to buffer containing stat data to
 				 * store in varName. */
 {
     Tcl_Obj *field, *value;
-    register unsigned short mode;
+    unsigned short mode;
 
     /*
      * Assume Tcl_ObjSetVar2() does not keep a copy of the field name!
      *
      * Might be a better idea to call Tcl_SetVar2Ex() instead, except we want
@@ -2152,13 +2288,13 @@
     STORE_ARY("blocks",	Tcl_NewWideIntObj((Tcl_WideInt)statPtr->st_blocks));
 #endif
 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
     STORE_ARY("blksize", Tcl_NewWideIntObj((long)statPtr->st_blksize));
 #endif
-    STORE_ARY("atime",	Tcl_NewWideIntObj((long)statPtr->st_atime));
-    STORE_ARY("mtime",	Tcl_NewWideIntObj((long)statPtr->st_mtime));
-    STORE_ARY("ctime",	Tcl_NewWideIntObj((long)statPtr->st_ctime));
+    STORE_ARY("atime",	Tcl_NewWideIntObj(Tcl_GetAccessTimeFromStat(statPtr)));
+    STORE_ARY("mtime",	Tcl_NewWideIntObj(Tcl_GetModificationTimeFromStat(statPtr)));
+    STORE_ARY("ctime",	Tcl_NewWideIntObj(Tcl_GetChangeTimeFromStat(statPtr)));
     mode = (unsigned short) statPtr->st_mode;
     STORE_ARY("mode",	Tcl_NewWideIntObj(mode));
     STORE_ARY("type",	Tcl_NewStringObj(GetTypeFromMode(mode), -1));
 #undef STORE_ARY
 
@@ -2492,11 +2628,11 @@
 				 * (TCL_EACH_*) */
     int objc,			/* The arguments being passed in... */
     Tcl_Obj *const objv[])
 {
     int numLists = (objc-2) / 2;
-    register struct ForeachState *statePtr;
+    struct ForeachState *statePtr;
     int i, j, result;
 
     if (objc < 4 || (objc%2 != 0)) {
 	Tcl_WrongNumArgs(interp, 1, objv,
 		"varList list ?varList list ...? command");
@@ -2617,11 +2753,11 @@
 ForeachLoopStep(
     ClientData data[],
     Tcl_Interp *interp,
     int result)
 {
-    register struct ForeachState *statePtr = data[0];
+    struct ForeachState *statePtr = data[0];
 
     /*
      * Process the result code from this run of the [foreach] body. Note that
      * this switch uses fallthroughs in several places. Maintainer aware!
      */

Index: generic/tclCmdIL.c
==================================================================
--- generic/tclCmdIL.c
+++ generic/tclCmdIL.c
@@ -33,11 +33,11 @@
 	double doubleValue;
 	Tcl_Obj *objValuePtr;
     } collationKey;
     union {			/* Object being sorted, or its index. */
 	Tcl_Obj *objPtr;
-	size_t index;
+	int index;
     } payload;
     struct SortElement *nextPtr;/* Next element in the list, or NULL for end
 				 * of list. */
 } SortElement;
 
@@ -473,11 +473,11 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
     const char *name;
     Proc *procPtr;
     CompiledLocal *localPtr;
     Tcl_Obj *listObjPtr;
 
@@ -536,14 +536,14 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
     const char *name, *bytes;
     Proc *procPtr;
-    size_t numBytes;
+    int numBytes;
 
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "procname");
 	return TCL_ERROR;
     }
@@ -641,19 +641,19 @@
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     const char *cmdName, *pattern;
     const char *simplePattern;
-    register Tcl_HashEntry *entryPtr;
+    Tcl_HashEntry *entryPtr;
     Tcl_HashSearch search;
     Namespace *nsPtr;
     Namespace *globalNsPtr = (Namespace *) Tcl_GetGlobalNamespace(interp);
     Namespace *currNsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
     Tcl_Obj *listPtr, *elemObjPtr;
     int specificNsInPattern = 0;/* Init. to avoid compiler warning. */
     Tcl_Command cmd;
-    size_t i;
+    int i;
 
     /*
      * Get the pattern and find the "effective namespace" in which to list
      * commands.
      */
@@ -1394,11 +1394,11 @@
 	    Tcl_GetCommandFullName(interp, (Tcl_Command) procPtr->cmdPtr,
 		    procNameObj);
 	    ADD_PAIR("proc", procNameObj);
 	} else if (procPtr->cmdPtr->clientData) {
 	    ExtraFrameInfo *efiPtr = procPtr->cmdPtr->clientData;
-	    size_t i;
+	    int i;
 
 	    /*
 	     * This is a non-standard command. Luckily, it's told us how to
 	     * render extra information about its frame.
 	     */
@@ -1841,11 +1841,11 @@
     Namespace *globalNsPtr = (Namespace *) Tcl_GetGlobalNamespace(interp);
 #endif
     Namespace *currNsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
     Tcl_Obj *listPtr, *elemObjPtr;
     int specificNsInPattern = 0;/* Init. to avoid compiler warning. */
-    register Tcl_HashEntry *entryPtr;
+    Tcl_HashEntry *entryPtr;
     Tcl_HashSearch search;
     Command *cmdPtr, *realCmdPtr;
 
     /*
      * Get the pattern and find the "effective namespace" in which to list
@@ -1956,11 +1956,11 @@
 
 #ifdef INFO_PROCS_SEARCH_GLOBAL_NS
 	/*
 	 * If "info procs" worked like "info commands", returning the commands
 	 * also seen in the global namespace, then you would include this
-	 * code. As this could break backwards compatibilty with 8.0-8.2, we
+	 * code. As this could break backwards compatibility with 8.0-8.2, we
 	 * decided not to "fix" it in 8.3, leaving the behavior slightly
 	 * different.
 	 */
 
 	if ((nsPtr != globalNsPtr) && !specificNsInPattern) {
@@ -2198,12 +2198,11 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* The argument objects. */
 {
-    size_t length;
-    int listLen;
+    int length, listLen;
     Tcl_Obj *resObjPtr = NULL, *joinObjPtr, **elemPtrs;
 
     if ((objc < 2) || (objc > 3)) {
 	Tcl_WrongNumArgs(interp, 1, objv, "list ?joinString?");
 	return TCL_ERROR;
@@ -2414,16 +2413,15 @@
 
 int
 Tcl_LinsertObjCmd(
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
-    register int objc,		/* Number of arguments. */
+    int objc,		/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Tcl_Obj *listPtr;
-    size_t index;
-    int len, result;
+    int index, len, result;
 
     if (objc < 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "list index ?element ...?");
 	return TCL_ERROR;
     }
@@ -2441,11 +2439,11 @@
 
     result = TclGetIntForIndexM(interp, objv[2], /*end*/ len, &index);
     if (result != TCL_OK) {
 	return result;
     }
-    if (index + 1 > (size_t)len + 1) {
+    if (index > len) {
 	index = len;
     }
 
     /*
      * If the list object is unshared we can modify it directly. Otherwise we
@@ -2455,11 +2453,11 @@
     listPtr = objv[1];
     if (Tcl_IsShared(listPtr)) {
 	listPtr = TclListObjCopy(NULL, listPtr);
     }
 
-    if ((objc == 4) && (index == (size_t)len)) {
+    if ((objc == 4) && (index == len)) {
 	/*
 	 * Special case: insert one element at the end of the list.
 	 */
 
 	Tcl_ListObjAppendElement(NULL, listPtr, objv[3]);
@@ -2497,12 +2495,12 @@
 
 int
 Tcl_ListObjCmd(
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
-    register int objc,		/* Number of arguments. */
-    register Tcl_Obj *const objv[])
+    int objc,		/* Number of arguments. */
+    Tcl_Obj *const objv[])
 				/* The argument objects. */
 {
     /*
      * If there are no list elements, the result is an empty object.
      * Otherwise set the interpreter's result object to be a list object.
@@ -2534,11 +2532,11 @@
 int
 Tcl_LlengthObjCmd(
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
-    register Tcl_Obj *const objv[])
+    Tcl_Obj *const objv[])
 				/* Argument objects. */
 {
     int listLen, result;
 
     if (objc != 2) {
@@ -2580,11 +2578,11 @@
 int
 Tcl_LpopObjCmd(
     ClientData notUsed,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
-    register Tcl_Obj *const objv[])
+    Tcl_Obj *const objv[])
 				/* Argument objects. */
 {
     int listLen, result;
     Tcl_Obj *elemPtr, *stored;
     Tcl_Obj *listPtr, **elemPtrs;
@@ -2673,15 +2671,14 @@
 int
 Tcl_LrangeObjCmd(
     ClientData notUsed,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
-    register Tcl_Obj *const objv[])
+    Tcl_Obj *const objv[])
 				/* Argument objects. */
 {
-    int listLen, result;
-    size_t first, last;
+    int listLen, first, last, result;
 
     if (objc != 4) {
 	Tcl_WrongNumArgs(interp, 1, objv, "list first last");
 	return TCL_ERROR;
     }
@@ -2727,12 +2724,12 @@
 static int
 LremoveIndexCompare(
     const void *el1Ptr,
     const void *el2Ptr)
 {
-    size_t idx1 = *((const size_t *) el1Ptr);
-    size_t idx2 = *((const size_t *) el2Ptr);
+    int idx1 = *((const int *) el1Ptr);
+    int idx2 = *((const int *) el2Ptr);
 
     /*
      * This will put the larger element first.
      */
 
@@ -2744,12 +2741,12 @@
     ClientData notUsed,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    int i, idxc, listLen, prevIdx, first, num;
-    size_t *idxv;
+    int i, idxc;
+    int listLen, *idxv, prevIdx, first, num;
     Tcl_Obj *listObj;
 
     /*
      * Parse the arguments.
      */
@@ -2767,15 +2764,15 @@
     idxc = objc - 2;
     if (idxc == 0) {
 	Tcl_SetObjResult(interp, listObj);
 	return TCL_OK;
     }
-    idxv = Tcl_Alloc((objc - 2) * sizeof(size_t));
+    idxv = ckalloc((objc - 2) * sizeof(int));
     for (i = 2; i < objc; i++) {
 	if (TclGetIntForIndexM(interp, objv[i], /*endValue*/ listLen - 1,
 		&idxv[i - 2]) != TCL_OK) {
-	    Tcl_Free(idxv);
+	    ckfree(idxv);
 	    return TCL_ERROR;
 	}
     }
 
     /*
@@ -2782,11 +2779,11 @@
      * Sort the indices, large to small so that when we remove an index we
      * don't change the indices still to be processed.
      */
 
     if (idxc > 1) {
-	qsort(idxv, idxc, sizeof(size_t), LremoveIndexCompare);
+	qsort(idxv, idxc, sizeof(int), LremoveIndexCompare);
     }
 
     /*
      * Make our working copy, then do the actual removes piecemeal.
      */
@@ -2834,11 +2831,11 @@
 	}
     }
     if (num != 0) {
 	(void) Tcl_ListObjReplace(interp, listObj, first, num, 0, NULL);
     }
-    Tcl_Free(idxv);
+    ckfree(idxv);
     Tcl_SetObjResult(interp, listObj);
     return TCL_OK;
 }
 
 /*
@@ -2860,12 +2857,12 @@
 
 int
 Tcl_LrepeatObjCmd(
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
-    register int objc,		/* Number of arguments. */
-    register Tcl_Obj *const objv[])
+    int objc,		/* Number of arguments. */
+    Tcl_Obj *const objv[])
 				/* The argument objects. */
 {
     int elementCount, i, totalElems;
     Tcl_Obj *listPtr, **dataArray = NULL;
 
@@ -2926,11 +2923,11 @@
      * number of times.
      */
 
     CLANG_ASSERT(dataArray || totalElems == 0 );
     if (objc == 1) {
-	register Tcl_Obj *tmpPtr = objv[0];
+	Tcl_Obj *tmpPtr = objv[0];
 
 	tmpPtr->refCount += elementCount;
 	for (i=0 ; i<elementCount ; i++) {
 	    dataArray[i] = tmpPtr;
 	}
@@ -2972,13 +2969,12 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    register Tcl_Obj *listPtr;
-    size_t first, last;
-    int listLen, numToDelete, result;
+    Tcl_Obj *listPtr;
+    int first, last, listLen, numToDelete, result;
 
     if (objc < 4) {
 	Tcl_WrongNumArgs(interp, 1, objv,
 		"list first last ?element ...?");
 	return TCL_ERROR;
@@ -3005,18 +3001,19 @@
 	return result;
     }
 
     if (first == TCL_INDEX_NONE) {
 	first = 0;
-    } else if (first > (size_t)listLen) {
+    }
+    if (first > listLen) {
 	first = listLen;
     }
 
-    if (last + 1 > (size_t)listLen) {
+    if (last >= listLen) {
 	last = listLen - 1;
     }
-    if (first + 1 <= last + 1) {
+    if (first <= last) {
 	numToDelete = last - first + 1;
     } else {
 	numToDelete = 0;
     }
 
@@ -3153,15 +3150,14 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument values. */
 {
     const char *bytes, *patternBytes;
-    int i, match, index, result=TCL_OK, listc, bisect;
-    size_t length = 0, elemLen, start, groupSize, groupOffset, lower, upper;
+    int i, match, index, result=TCL_OK, listc, length, elemLen, bisect;
     int allocatedIndexVector = 0;
-    int dataType, isIncreasing;
-    Tcl_WideInt patWide, objWide, wide;
+    int dataType, isIncreasing, lower, upper, start, groupSize, groupOffset;
+    Tcl_WideInt patWide, objWide;
     int allMatches, inlineReturn, negatedMatch, returnSubindices, noCase;
     double patDouble, objDouble;
     SortInfo sortInfo;
     Tcl_Obj *patObj, **listv, *listPtr, *startPtr, *itemPtr;
     SortStrCmpFn_t strCmpFn = TclUtfCmp;
@@ -3313,23 +3309,22 @@
 			"followed by stride length", -1));
 		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING", NULL);
 		result = TCL_ERROR;
 		goto done;
 	    }
-	    if (Tcl_GetWideIntFromObj(interp, objv[i+1], &wide) != TCL_OK) {
+	    if (Tcl_GetIntFromObj(interp, objv[i+1], &groupSize) != TCL_OK) {
 		result = TCL_ERROR;
 		goto done;
 	    }
-	    if (wide < 1) {
+	    if (groupSize < 1) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"stride length must be at least 1", -1));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "LSORT",
 			"BADSTRIDE", NULL);
 		result = TCL_ERROR;
 		goto done;
 	    }
-	    groupSize = wide;
 	    i++;
 	    break;
 	case LSEARCH_INDEX: {		/* -index */
 	    Tcl_Obj **indices;
 	    int j;
@@ -3485,11 +3480,11 @@
 	     * Use the first value in the list supplied to -index as the
 	     * offset of the element within each group by which to sort.
 	     */
 
 	    groupOffset = TclIndexDecode(sortInfo.indexv[0], groupSize - 1);
-	    if (groupOffset >= groupSize) {
+	    if (groupOffset < 0 || groupOffset >= groupSize) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"when used with \"-stride\", the leading \"-index\""
 			" value must be within the group", -1));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "LSEARCH",
 			"BADINDEX", NULL);
@@ -3525,11 +3520,11 @@
 	/*
 	 * If the search started past the end of the list, we just return a
 	 * "did not match anything at all" result straight away. [Bug 1374778]
 	 */
 
-	if (start >= (size_t)listc) {
+	if (start > listc-1) {
 	    if (allMatches || inlineReturn) {
 		Tcl_ResetResult(interp);
 	    } else {
 		Tcl_SetObjResult(interp, Tcl_NewWideIntObj(-1));
 	    }
@@ -3733,11 +3728,12 @@
 			 */
 
 			if (noCase) {
 			    match = (TclUtfCasecmp(bytes, patternBytes) == 0);
 			} else {
-			    match = (memcmp(bytes, patternBytes, length) == 0);
+			    match = (memcmp(bytes, patternBytes,
+				    (size_t) length) == 0);
 			}
 		    }
 		    break;
 
 		case DICTIONARY:
@@ -3817,13 +3813,13 @@
 		    Tcl_ListObjAppendElement(interp, listPtr, itemPtr);
 		}
 	    } else if (returnSubindices) {
 		int j;
 
-		itemPtr = TclNewWideIntObjFromSize(i+groupOffset);
+		itemPtr = Tcl_NewWideIntObj(i+groupOffset);
 		for (j=0 ; j<sortInfo.indexc ; j++) {
-		    Tcl_ListObjAppendElement(interp, itemPtr, TclNewWideIntObjFromSize(
+		    Tcl_ListObjAppendElement(interp, itemPtr, Tcl_NewWideIntObj(
 			    TclIndexDecode(sortInfo.indexv[j], listc)));
 		}
 		Tcl_ListObjAppendElement(interp, listPtr, itemPtr);
 	    } else {
 		Tcl_ListObjAppendElement(interp, listPtr, Tcl_NewWideIntObj(i));
@@ -3839,13 +3835,13 @@
 	Tcl_SetObjResult(interp, listPtr);
     } else if (!inlineReturn) {
 	if (returnSubindices) {
 	    int j;
 
-	    itemPtr = TclNewWideIntObjFromSize(index+groupOffset);
+	    itemPtr = Tcl_NewWideIntObj(index+groupOffset);
 	    for (j=0 ; j<sortInfo.indexc ; j++) {
-		Tcl_ListObjAppendElement(interp, itemPtr, TclNewWideIntObjFromSize(
+		Tcl_ListObjAppendElement(interp, itemPtr, Tcl_NewWideIntObj(
 			TclIndexDecode(sortInfo.indexv[j], listc)));
 	    }
 	    Tcl_SetObjResult(interp, itemPtr);
 	} else {
 	    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(index));
@@ -3990,15 +3986,13 @@
     ClientData clientData,	/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument values. */
 {
-    int i, index, indices, length, nocase = 0, indexc;
+    int i, j, index, indices, length, nocase = 0, indexc;
     int sortMode = SORTMODE_ASCII;
-    int group, allocatedIndexVector = 0;
-    size_t j, idx, groupSize, groupOffset;
-    Tcl_WideInt wide;
+    int group, groupSize, groupOffset, idx, allocatedIndexVector = 0;
     Tcl_Obj *resultPtr, *cmdPtr, **listObjPtrs, *listObj, *indexPtr;
     SortElement *elementArray = NULL, *elementPtr;
     SortInfo sortInfo;		/* Information about this sort that needs to
 				 * be passed to the comparison function. */
 #   define NUM_LISTS 30
@@ -4096,11 +4090,11 @@
 	     * know if this is the only -index option yet and so we can't
 	     * allocate any space; that happens after the scan through all the
 	     * options is done.
 	     */
 
-	    for (j=0 ; j<(size_t)indexc ; j++) {
+	    for (j=0 ; j<indexc ; j++) {
 		int encoded = 0;
 		int result = TclIndexEncode(interp, indexv[j],
 			TCL_INDEX_NONE, TCL_INDEX_NONE, &encoded);
 
 		if ((result == TCL_OK) && (encoded == (int)TCL_INDEX_NONE)) {
@@ -4111,11 +4105,11 @@
 			    "OUTOFRANGE", NULL);
 		    result = TCL_ERROR;
 		}
 		if (result == TCL_ERROR) {
 		    Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
-			    "\n    (-index option item number %" TCL_Z_MODIFIER "d)", j));
+			    "\n    (-index option item number %d)", j));
 		    sortInfo.resultCode = TCL_ERROR;
 		    goto done;
 		}
 	    }
 	    indexPtr = objv[i+1];
@@ -4144,23 +4138,22 @@
 			"followed by stride length", -1));
 		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING", NULL);
 		sortInfo.resultCode = TCL_ERROR;
 		goto done;
 	    }
-	    if (Tcl_GetWideIntFromObj(interp, objv[i+1], &wide) != TCL_OK) {
+	    if (Tcl_GetIntFromObj(interp, objv[i+1], &groupSize) != TCL_OK) {
 		sortInfo.resultCode = TCL_ERROR;
 		goto done;
 	    }
-	    if (wide < 2) {
+	    if (groupSize < 2) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"stride length must be at least 2", -1));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "LSORT",
 			"BADSTRIDE", NULL);
 		sortInfo.resultCode = TCL_ERROR;
 		goto done;
 	    }
-	    groupSize = wide;
 	    group = 1;
 	    i++;
 	    break;
 	}
     }
@@ -4189,11 +4182,11 @@
 	    sortInfo.indexv =
 		    TclStackAlloc(interp, sizeof(int) * sortInfo.indexc);
 	    allocatedIndexVector = 1;	/* Cannot use indexc field, as it
 					 * might be decreased by 1 later. */
 	}
-	for (j=0 ; j<(size_t)sortInfo.indexc ; j++) {
+	for (j=0 ; j<sortInfo.indexc ; j++) {
 	    /* Prescreened values, no errors or out of range possible */
 	    TclIndexEncode(NULL, indexv[j], TCL_INDEX_NONE,
 		    TCL_INDEX_NONE, &sortInfo.indexv[j]);
 	}
     }
@@ -4264,11 +4257,11 @@
 	     * Use the first value in the list supplied to -index as the
 	     * offset of the element within each group by which to sort.
 	     */
 
 	    groupOffset = TclIndexDecode(sortInfo.indexv[0], groupSize - 1);
-	    if (groupOffset >= groupSize) {
+	    if (groupOffset < 0 || groupOffset >= groupSize) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"when used with \"-stride\", the leading \"-index\""
 			" value must be within the group", -1));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "LSORT",
 			"BADINDEX", NULL);
@@ -4322,11 +4315,11 @@
     /*
      * The following loop creates a SortElement for each list element and
      * begins sorting it into the sublists as it appears.
      */
 
-    elementArray = Tcl_Alloc(length * sizeof(SortElement));
+    elementArray = ckalloc(length * sizeof(SortElement));
 
     for (i=0; i < length; i++) {
 	idx = groupSize * i + groupOffset;
 	if (indexc) {
 	    /*
@@ -4418,11 +4411,11 @@
 	if (group) {
 	    for (i=0; elementPtr!=NULL ; elementPtr=elementPtr->nextPtr) {
 		idx = elementPtr->payload.index;
 		for (j = 0; j < groupSize; j++) {
 		    if (indices) {
-			objPtr = TclNewWideIntObjFromSize(idx + j - groupOffset);
+			objPtr = Tcl_NewWideIntObj(idx + j - groupOffset);
 			newArray[i++] = objPtr;
 			Tcl_IncrRefCount(objPtr);
 		    } else {
 			objPtr = listObjPtrs[idx + j - groupOffset];
 			newArray[i++] = objPtr;
@@ -4430,11 +4423,11 @@
 		    }
 		}
 	    }
 	} else if (indices) {
 	    for (i=0; elementPtr != NULL ; elementPtr = elementPtr->nextPtr) {
-		objPtr = TclNewWideIntObjFromSize(elementPtr->payload.index);
+		objPtr = Tcl_NewWideIntObj(elementPtr->payload.index);
 		newArray[i++] = objPtr;
 		Tcl_IncrRefCount(objPtr);
 	    }
 	} else {
 	    for (i=0; elementPtr != NULL ; elementPtr = elementPtr->nextPtr) {
@@ -4455,11 +4448,11 @@
     }
     if (allocatedIndexVector) {
 	TclStackFree(interp, sortInfo.indexv);
     }
     if (elementArray) {
-	Tcl_Free(elementArray);
+	ckfree(elementArray);
     }
     return sortInfo.resultCode;
 }
 
 /*

Index: generic/tclCmdMZ.c
==================================================================
--- generic/tclCmdMZ.c
+++ generic/tclCmdMZ.c
@@ -125,12 +125,12 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t offset, stringLength, matchLength, cflags, eflags;
-    int i, indices, match, about, all, doinline, numMatchesSaved;
+    int i, indices, match, about, offset, all, doinline, numMatchesSaved;
+    int cflags, eflags, stringLength, matchLength;
     Tcl_RegExp regExpr;
     Tcl_Obj *objPtr, *startIndex = NULL, *resultPtr = NULL;
     Tcl_RegExpInfo info;
     static const char *const options[] = {
 	"-all",		"-about",	"-indices",	"-inline",
@@ -144,11 +144,11 @@
     };
 
     indices = 0;
     about = 0;
     cflags = TCL_REG_ADVANCED;
-    offset = TCL_INDEX_START;
+    offset = 0;
     all = 0;
     doinline = 0;
 
     for (i = 1; i < objc; i++) {
 	const char *name;
@@ -189,15 +189,15 @@
 	    break;
 	case REGEXP_LINEANCHOR:
 	    cflags |= TCL_REG_NLANCH;
 	    break;
 	case REGEXP_START: {
-	    size_t temp;
+	    int temp;
 	    if (++i >= objc) {
 		goto endOfForLoop;
 	    }
-	    if (TclGetIntForIndexM(interp, objv[i], TCL_INDEX_START, &temp) != TCL_OK) {
+	    if (TclGetIntForIndexM(interp, objv[i], 0, &temp) != TCL_OK) {
 		goto optionError;
 	    }
 	    if (startIndex) {
 		Tcl_DecrRefCount(startIndex);
 	    }
@@ -259,12 +259,12 @@
     stringLength = Tcl_GetCharLength(objPtr);
 
     if (startIndex) {
 	TclGetIntForIndexM(interp, startIndex, stringLength, &offset);
 	Tcl_DecrRefCount(startIndex);
-	if (offset == TCL_INDEX_NONE) {
-	    offset = TCL_INDEX_START;
+	if (offset < 0) {
+	    offset = 0;
 	}
     }
 
     regExpr = Tcl_GetRegExpFromObj(interp, objv[0], cflags);
     if (regExpr == NULL) {
@@ -304,13 +304,13 @@
 	 * considered the start of the line. If for example the pattern {^} is
 	 * passed and -start is positive, then the pattern will not match the
 	 * start of the string unless the previous character is a newline.
 	 */
 
-	if (offset == TCL_INDEX_START) {
+	if (offset == 0) {
 	    eflags = 0;
-	} else if (offset + 1 > stringLength + 1) {
+	} else if (offset > stringLength) {
 	    eflags = TCL_REG_NOTBOL;
 	} else if (Tcl_GetUniChar(objPtr, offset-1) == '\n') {
 	    eflags = 0;
 	} else {
 	    eflags = TCL_REG_NOTBOL;
@@ -362,41 +362,41 @@
 	}
 	for (i = 0; i < objc; i++) {
 	    Tcl_Obj *newPtr;
 
 	    if (indices) {
-		size_t start, end;
+		int start, end;
 		Tcl_Obj *objs[2];
 
 		/*
 		 * Only adjust the match area if there was a match for that
 		 * area. (Scriptics Bug 4391/SF Bug #219232)
 		 */
 
-		if (i <= (int)info.nsubs && info.matches[i].start != TCL_INDEX_NONE) {
+		if (i <= info.nsubs && info.matches[i].start >= 0) {
 		    start = offset + info.matches[i].start;
 		    end = offset + info.matches[i].end;
 
 		    /*
 		     * Adjust index so it refers to the last character in the
 		     * match instead of the first character after the match.
 		     */
 
-		    if (end + 1 >= offset + 1) {
+		    if (end >= offset) {
 			end--;
 		    }
 		} else {
-		    start = TCL_INDEX_NONE;
-		    end = TCL_INDEX_NONE;
+		    start = -1;
+		    end = -1;
 		}
 
-		objs[0] = TclNewWideIntObjFromSize(start);
-		objs[1] = TclNewWideIntObjFromSize(end);
+		objs[0] = Tcl_NewWideIntObj(start);
+		objs[1] = Tcl_NewWideIntObj(end);
 
 		newPtr = Tcl_NewListObj(2, objs);
 	    } else {
-		if (i <= (int)info.nsubs) {
+		if (i <= info.nsubs) {
 		    newPtr = Tcl_GetRange(objPtr,
 			    offset + info.matches[i].start,
 			    offset + info.matches[i].end - 1);
 		} else {
 		    newPtr = Tcl_NewObj();
@@ -442,11 +442,11 @@
 
 	if (matchLength == 0) {
 	    offset++;
 	}
 	all++;
-	if (offset + 1 >= stringLength + 1) {
+	if (offset >= stringLength) {
 	    break;
 	}
     }
 
     /*
@@ -485,13 +485,12 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    int result, cflags, all, match, command, numParts;
-    size_t idx, wlen, wsublen = 0, offset, numMatches;
-    size_t start, end, subStart, subEnd;
+    int idx, result, cflags, all, wlen, wsublen, numMatches, offset;
+    int start, end, subStart, subEnd, match, command, numParts;
     Tcl_RegExp regExpr;
     Tcl_RegExpInfo info;
     Tcl_Obj *resultPtr, *subPtr, *objPtr, *startIndex = NULL;
     Tcl_UniChar ch, *wsrc, *wfirstChar, *wstring, *wsubspec = 0, *wend;
 
@@ -506,15 +505,15 @@
 	REGSUB_LAST
     };
 
     cflags = TCL_REG_ADVANCED;
     all = 0;
-    offset = TCL_INDEX_START;
+    offset = 0;
     command = 0;
     resultPtr = NULL;
 
-    for (idx = 1; idx < (size_t)objc; idx++) {
+    for (idx = 1; idx < objc; idx++) {
 	const char *name;
 	int index;
 
 	name = TclGetString(objv[idx]);
 	if (name[0] != '-') {
@@ -545,15 +544,15 @@
 	    break;
 	case REGSUB_LINEANCHOR:
 	    cflags |= TCL_REG_NLANCH;
 	    break;
 	case REGSUB_START: {
-	    size_t temp;
-	    if (++idx >= (size_t)objc) {
+	    int temp;
+	    if (++idx >= objc) {
 		goto endOfForLoop;
 	    }
-	    if (TclGetIntForIndexM(interp, objv[idx], TCL_INDEX_START, &temp) != TCL_OK) {
+	    if (TclGetIntForIndexM(interp, objv[idx], 0, &temp) != TCL_OK) {
 		goto optionError;
 	    }
 	    if (startIndex) {
 		Tcl_DecrRefCount(startIndex);
 	    }
@@ -566,11 +565,11 @@
 	    goto endOfForLoop;
 	}
     }
 
   endOfForLoop:
-    if ((size_t)objc < idx + 3 || (size_t)objc > idx + 4) {
+    if (objc-idx < 3 || objc-idx > 4) {
 	Tcl_WrongNumArgs(interp, 1, objv,
 		"?-option ...? exp string subSpec ?varName?");
     optionError:
 	if (startIndex) {
 	    Tcl_DecrRefCount(startIndex);
@@ -580,39 +579,38 @@
 
     objc -= idx;
     objv += idx;
 
     if (startIndex) {
-	size_t stringLength = Tcl_GetCharLength(objv[1]);
+	int stringLength = Tcl_GetCharLength(objv[1]);
 
 	TclGetIntForIndexM(interp, startIndex, stringLength, &offset);
 	Tcl_DecrRefCount(startIndex);
-	if (offset == TCL_INDEX_NONE) {
-	    offset = TCL_INDEX_START;
+	if (offset < 0) {
+	    offset = 0;
 	}
     }
 
-    if (all && (offset == TCL_INDEX_START) && (command == 0)
+    if (all && (offset == 0) && (command == 0)
 	    && (strpbrk(TclGetString(objv[2]), "&\\") == NULL)
 	    && (strpbrk(TclGetString(objv[0]), "*+?{}()[].\\|^$") == NULL)) {
 	/*
 	 * This is a simple one pair string map situation. We make use of a
 	 * slightly modified version of the one pair STR_MAP code.
 	 */
 
-	size_t slen;
-	int nocase, wsrclc;
-	int (*strCmpFn)(const Tcl_UniChar*,const Tcl_UniChar*,size_t);
+	int slen, nocase, wsrclc;
+	int (*strCmpFn)(const Tcl_UniChar*,const Tcl_UniChar*,unsigned long);
 	Tcl_UniChar *p;
 
 	numMatches = 0;
 	nocase = (cflags & TCL_REG_NOCASE);
 	strCmpFn = nocase ? Tcl_UniCharNcasecmp : Tcl_UniCharNcmp;
 
-	wsrc = TclGetUnicodeFromObj(objv[0], &slen);
-	wstring = TclGetUnicodeFromObj(objv[1], &wlen);
-	wsubspec = TclGetUnicodeFromObj(objv[2], &wsublen);
+	wsrc = Tcl_GetUnicodeFromObj(objv[0], &slen);
+	wstring = Tcl_GetUnicodeFromObj(objv[1], &wlen);
+	wsubspec = Tcl_GetUnicodeFromObj(objv[2], &wsublen);
 	wend = wstring + wlen - (slen ? slen - 1 : 0);
 	result = TCL_OK;
 
 	if (slen == 0) {
 	    /*
@@ -633,11 +631,12 @@
 	} else {
 	    wsrclc = Tcl_UniCharToLower(*wsrc);
 	    for (p = wfirstChar = wstring; wstring < wend; wstring++) {
 		if ((*wstring == *wsrc ||
 			(nocase && Tcl_UniCharToLower(*wstring)==wsrclc)) &&
-			(slen==1 || (strCmpFn(wstring, wsrc, slen) == 0))) {
+			(slen==1 || (strCmpFn(wstring, wsrc,
+				(unsigned long) slen) == 0))) {
 		    if (numMatches == 0) {
 			resultPtr = Tcl_NewUnicodeObj(wstring, 0);
 			Tcl_IncrRefCount(resultPtr);
 		    }
 		    if (p != wstring) {
@@ -698,18 +697,18 @@
     if (objv[1] == objv[0]) {
 	objPtr = Tcl_DuplicateObj(objv[1]);
     } else {
 	objPtr = objv[1];
     }
-    wstring = TclGetUnicodeFromObj(objPtr, &wlen);
+    wstring = Tcl_GetUnicodeFromObj(objPtr, &wlen);
     if (objv[2] == objv[0]) {
 	subPtr = Tcl_DuplicateObj(objv[2]);
     } else {
 	subPtr = objv[2];
     }
     if (!command) {
-	wsubspec = TclGetUnicodeFromObj(subPtr, &wsublen);
+	wsubspec = Tcl_GetUnicodeFromObj(subPtr, &wsublen);
     }
 
     result = TCL_OK;
 
     /*
@@ -743,11 +742,11 @@
 	    break;
 	}
 	if (numMatches == 0) {
 	    resultPtr = Tcl_NewUnicodeObj(wstring, 0);
 	    Tcl_IncrRefCount(resultPtr);
-	    if (offset > TCL_INDEX_START) {
+	    if (offset > 0) {
 		/*
 		 * Copy the initial portion of the string in if an offset was
 		 * specified.
 		 */
 
@@ -777,11 +776,11 @@
 	    Tcl_Obj **args = NULL, **parts;
 	    int numArgs;
 
 	    Tcl_ListObjGetElements(interp, subPtr, &numParts, &parts);
 	    numArgs = numParts + info.nsubs + 1;
-	    args = Tcl_Alloc(sizeof(Tcl_Obj*) * numArgs);
+	    args = ckalloc(sizeof(Tcl_Obj*) * numArgs);
 	    memcpy(args, parts, sizeof(Tcl_Obj*) * numParts);
 
 	    for (idx = 0 ; idx <= info.nsubs ; idx++) {
 		subStart = info.matches[idx].start;
 		subEnd = info.matches[idx].end;
@@ -807,11 +806,11 @@
 
 	    result = Tcl_EvalObjv(interp, numArgs, args, 0);
 	    for (idx = 0 ; idx <= info.nsubs ; idx++) {
 		TclDecrRefCount(args[idx + numParts]);
 	    }
-	    Tcl_Free(args);
+	    ckfree(args);
 	    if (result != TCL_OK) {
 		if (result == TCL_ERROR) {
 		    Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 			    "\n    (%s substitution computation script)",
 			    options[REGSUB_COMMAND]));
@@ -825,11 +824,11 @@
 	    /*
 	     * Refetch the unicode, in case the representation was smashed by
 	     * the user code.
 	     */
 
-	    wstring = TclGetUnicodeFromObj(objPtr, &wlen);
+	    wstring = Tcl_GetUnicodeFromObj(objPtr, &wlen);
 
 	    offset += end;
 	    if (end == 0 || start == end) {
 		/*
 		 * Always consume at least one character of the input string
@@ -1178,11 +1177,11 @@
     Tcl_UniChar ch = 0;
     int len;
     const char *splitChars;
     const char *stringPtr;
     const char *end;
-    size_t splitCharLen, stringLen;
+    int splitCharLen, stringLen;
     Tcl_Obj *listPtr, *objPtr;
 
     if (objc == 2) {
 	splitChars = " \n\t\r";
 	splitCharLen = 4;
@@ -1257,20 +1256,20 @@
 	 * Handle the special case of splitting on a single character. This is
 	 * only true for the one-char ASCII case, as one unicode char is > 1
 	 * byte in length.
 	 */
 
-	while (*stringPtr && (p=strchr(stringPtr,*splitChars)) != NULL) {
+	while (*stringPtr && (p=strchr(stringPtr,(int)*splitChars)) != NULL) {
 	    objPtr = Tcl_NewStringObj(stringPtr, p - stringPtr);
 	    Tcl_ListObjAppendElement(NULL, listPtr, objPtr);
 	    stringPtr = p + 1;
 	}
 	TclNewStringObj(objPtr, stringPtr, end - stringPtr);
 	Tcl_ListObjAppendElement(NULL, listPtr, objPtr);
     } else {
 	const char *element, *p, *splitEnd;
-	size_t splitLen;
+	int splitLen;
 	Tcl_UniChar splitChar = 0;
 
 	/*
 	 * Normal case: split on any of a given set of characters. Discard
 	 * instances of the split characters.
@@ -1321,26 +1320,26 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t start = TCL_INDEX_START;
+    int start = 0;
 
     if (objc < 3 || objc > 4) {
 	Tcl_WrongNumArgs(interp, 1, objv,
 		"needleString haystackString ?startIndex?");
 	return TCL_ERROR;
     }
 
     if (objc == 4) {
-	size_t end = Tcl_GetCharLength(objv[2]) - 1;
+	int size = Tcl_GetCharLength(objv[2]);
 
-	if (TCL_OK != TclGetIntForIndexM(interp, objv[3], end, &start)) {
+	if (TCL_OK != TclGetIntForIndexM(interp, objv[3], size - 1, &start)) {
 	    return TCL_ERROR;
 	}
     }
-    Tcl_SetObjResult(interp, TclNewWideIntObjFromSize(TclStringFirst(objv[1],
+    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(TclStringFirst(objv[1],
 	    objv[2], start)));
     return TCL_OK;
 }
 
 /*
@@ -1366,26 +1365,26 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t last = TCL_INDEX_END;
+    int last = INT_MAX - 1;
 
     if (objc < 3 || objc > 4) {
 	Tcl_WrongNumArgs(interp, 1, objv,
 		"needleString haystackString ?lastIndex?");
 	return TCL_ERROR;
     }
 
     if (objc == 4) {
-	size_t end = Tcl_GetCharLength(objv[2]) - 1;
+	int size = Tcl_GetCharLength(objv[2]);
 
-	if (TCL_OK != TclGetIntForIndexM(interp, objv[3], end, &last)) {
+	if (TCL_OK != TclGetIntForIndexM(interp, objv[3], size - 1, &last)) {
 	    return TCL_ERROR;
 	}
     }
-    Tcl_SetObjResult(interp, TclNewWideIntObjFromSize(TclStringLast(objv[1],
+    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(TclStringLast(objv[1],
 	    objv[2], last)));
     return TCL_OK;
 }
 
 /*
@@ -1411,11 +1410,11 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t index, end;
+    int length, index;
 
     if (objc != 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "string charIndex");
 	return TCL_ERROR;
     }
@@ -1422,16 +1421,16 @@
 
     /*
      * Get the char length to calculate what 'end' means.
      */
 
-    end = Tcl_GetCharLength(objv[1]) - 1;
-    if (TclGetIntForIndexM(interp, objv[2], end, &index) != TCL_OK) {
+    length = Tcl_GetCharLength(objv[1]);
+    if (TclGetIntForIndexM(interp, objv[2], length-1, &index) != TCL_OK) {
 	return TCL_ERROR;
     }
 
-    if ((index != TCL_INDEX_NONE) && (index + 1 <= end + 1)) {
+    if ((index >= 0) && (index < length)) {
 	int ch = Tcl_GetUniChar(objv[1], index);
 
 	if (ch == -1) {
 	    return TCL_OK;
 	}
@@ -1446,15 +1445,15 @@
 
 	    Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(&uch, 1));
 	} else {
 	    char buf[4] = "";
 
-	    end = Tcl_UniCharToUtf(ch, buf);
-	    if ((ch >= 0xD800) && (end < 3)) {
-		end += Tcl_UniCharToUtf(-1, buf + end);
+	    length = Tcl_UniCharToUtf(ch, buf);
+	    if ((ch >= 0xD800) && (length < 3)) {
+		length += Tcl_UniCharToUtf(-1, buf + length);
 	    }
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, end));
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, length));
 	}
     }
     return TCL_OK;
 }
 
@@ -1481,12 +1480,12 @@
     ClientData dummy,		/* Not used */
     Tcl_Interp *interp,		/* Current interpreter */
     int objc,			/* Number of arguments */
     Tcl_Obj *const objv[])	/* Argument objects */
 {
-    size_t length;		/* String length */
-    size_t index;		/* Insert index */
+    int length;			/* String length */
+    int index;			/* Insert index */
     Tcl_Obj *outObj;		/* Output object */
 
     if (objc != 4) {
 	Tcl_WrongNumArgs(interp, 1, objv, "string index insertString");
 	return TCL_ERROR;
@@ -1495,12 +1494,12 @@
     length = Tcl_GetCharLength(objv[1]);
     if (TclGetIntForIndexM(interp, objv[2], length, &index) != TCL_OK) {
 	return TCL_ERROR;
     }
 
-    if (index == TCL_INDEX_NONE) {
-	index = TCL_INDEX_START;
+    if (index < 0) {
+	index = 0;
     }
     if (index > length) {
 	index = length;
     }
 
@@ -1541,13 +1540,11 @@
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     const char *string1, *end, *stop;
     Tcl_UniChar ch = 0;
     int (*chcomp)(int) = NULL;	/* The UniChar comparison function. */
-    int i, result = 1, strict = 0, index, length3;
-    size_t failat = 0;
-    size_t length1, length2;
+    int i, failat = 0, result = 1, strict = 0, index, length1, length2;
     Tcl_Obj *objPtr, *failVarObj = NULL;
     Tcl_WideInt w;
 
     static const char *const isClasses[] = {
 	"alnum",	"alpha",	"ascii",	"control",
@@ -1638,13 +1635,15 @@
 		result = 0;
 	    } else {
 		string1 = TclGetStringFromObj(objPtr, &length1);
 		result = length1 == 0;
 	    }
-	} else if ((objPtr->internalRep.wideValue != 0)
-		? (index == STR_IS_FALSE) : (index == STR_IS_TRUE)) {
-	    result = 0;
+	} else if (index != STR_IS_BOOL) {
+	    TclGetBooleanFromObj(NULL, objPtr, &i);
+	    if ((index == STR_IS_TRUE) ^ i) {
+		result = 0;
+	    }
 	}
 	break;
     case STR_IS_CONTROL:
 	chcomp = Tcl_UniCharIsControl;
 	break;
@@ -1660,13 +1659,12 @@
 	     * fairly expensive. This is adapted from the core of
 	     * SetDictFromAny().
 	     */
 
 	    const char *elemStart, *nextElem;
-	    int lenRemain;
-	    size_t elemSize;
-	    register const char *p;
+	    int lenRemain, elemSize;
+	    const char *p;
 
 	    string1 = TclGetStringFromObj(objPtr, &length1);
 	    end = string1 + length1;
 	    failat = -1;
 	    for (p=string1, lenRemain=length1; lenRemain > 0;
@@ -1829,11 +1827,11 @@
 	/*
 	 * We ignore the strictness here, since empty strings are always
 	 * well-formed lists.
 	 */
 
-	if (TCL_OK == TclListObjLength(NULL, objPtr, &length3)) {
+	if (TCL_OK == TclListObjLength(NULL, objPtr, &length2)) {
 	    break;
 	}
 
 	if (failVarObj != NULL) {
 	    /*
@@ -1841,13 +1839,12 @@
 	     * fairly expensive. This is adapted from the core of
 	     * SetListFromAny().
 	     */
 
 	    const char *elemStart, *nextElem;
-	    size_t lenRemain;
-	    size_t elemSize;
-	    register const char *p;
+	    int lenRemain, elemSize;
+	    const char *p;
 
 	    string1 = TclGetStringFromObj(objPtr, &length1);
 	    end = string1 + length1;
 	    failat = -1;
 	    for (p=string1, lenRemain=length1; lenRemain > 0;
@@ -1932,11 +1929,11 @@
      * valid fail index (>= 0).
      */
 
  str_is_done:
     if ((result == 0) && (failVarObj != NULL) &&
-	Tcl_ObjSetVar2(interp, failVarObj, NULL, TclNewWideIntObjFromSize(failat),
+	Tcl_ObjSetVar2(interp, failVarObj, NULL, Tcl_NewWideIntObj(failat),
 		TCL_LEAVE_ERR_MSG) == NULL) {
 	return TCL_ERROR;
     }
     Tcl_SetObjResult(interp, Tcl_NewBooleanObj(result));
     return TCL_OK;
@@ -1979,15 +1976,15 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t length1, length2,  mapElemc, index;
+    int length1, length2, mapElemc, index;
     int nocase = 0, mapWithDict = 0, copySource = 0;
     Tcl_Obj **mapElemv, *sourceObj, *resultPtr;
     Tcl_UniChar *ustring1, *ustring2, *p, *end;
-    int (*strCmpFn)(const Tcl_UniChar*, const Tcl_UniChar*, size_t);
+    int (*strCmpFn)(const Tcl_UniChar*, const Tcl_UniChar*, unsigned long);
 
     if (objc < 3 || objc > 4) {
 	Tcl_WrongNumArgs(interp, 1, objv, "?-nocase? charMap string");
 	return TCL_ERROR;
     }
@@ -2020,21 +2017,21 @@
 	/*
 	 * We know the type exactly, so all dict operations will succeed for
 	 * sure. This shortens this code quite a bit.
 	 */
 
-	Tcl_DictObjSize(interp, objv[objc-2], &i);
-	if (i == 0) {
+	Tcl_DictObjSize(interp, objv[objc-2], &mapElemc);
+	if (mapElemc == 0) {
 	    /*
 	     * Empty charMap, just return whatever string was given.
 	     */
 
 	    Tcl_SetObjResult(interp, objv[objc-1]);
 	    return TCL_OK;
 	}
 
-	mapElemc = 2 * i;
+	mapElemc *= 2;
 	mapWithDict = 1;
 
 	/*
 	 * Copy the dictionary out into an array; that's the easiest way to
 	 * adapt this code...
@@ -2041,21 +2038,19 @@
 	 */
 
 	mapElemv = TclStackAlloc(interp, sizeof(Tcl_Obj *) * mapElemc);
 	Tcl_DictObjFirst(interp, objv[objc-2], &search, mapElemv+0,
 		mapElemv+1, &done);
-	for (index=2 ; index<mapElemc ; index+=2) {
-	    Tcl_DictObjNext(&search, mapElemv+index, mapElemv+index+1, &done);
+	for (i=2 ; i<mapElemc ; i+=2) {
+	    Tcl_DictObjNext(&search, mapElemv+i, mapElemv+i+1, &done);
 	}
 	Tcl_DictObjDone(&search);
     } else {
-	int i;
-	if (TclListObjGetElements(interp, objv[objc-2], &i,
+	if (TclListObjGetElements(interp, objv[objc-2], &mapElemc,
 		&mapElemv) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	mapElemc = i;
 	if (mapElemc == 0) {
 	    /*
 	     * empty charMap, just return whatever string was given.
 	     */
 
@@ -2083,11 +2078,11 @@
 	sourceObj = Tcl_DuplicateObj(objv[objc-1]);
 	copySource = 1;
     } else {
 	sourceObj = objv[objc-1];
     }
-    ustring1 = TclGetUnicodeFromObj(sourceObj, &length1);
+    ustring1 = Tcl_GetUnicodeFromObj(sourceObj, &length1);
     if (length1 == 0) {
 	/*
 	 * Empty input string, just stop now.
 	 */
 
@@ -2109,30 +2104,29 @@
 	 * extra calls to get Unicode data. The algorithm is otherwise
 	 * identical to the multi-pair case. This will be >30% faster on
 	 * larger strings.
 	 */
 
-	size_t mapLen;
-	int u2lc;
+	int mapLen, u2lc;
 	Tcl_UniChar *mapString;
 
-	ustring2 = TclGetUnicodeFromObj(mapElemv[0], &length2);
+	ustring2 = Tcl_GetUnicodeFromObj(mapElemv[0], &length2);
 	p = ustring1;
 	if ((length2 > length1) || (length2 == 0)) {
 	    /*
 	     * Match string is either longer than input or empty.
 	     */
 
 	    ustring1 = end;
 	} else {
-	    mapString = TclGetUnicodeFromObj(mapElemv[1], &mapLen);
+	    mapString = Tcl_GetUnicodeFromObj(mapElemv[1], &mapLen);
 	    u2lc = (nocase ? Tcl_UniCharToLower(*ustring2) : 0);
 	    for (; ustring1 < end; ustring1++) {
 		if (((*ustring1 == *ustring2) ||
 			(nocase&&Tcl_UniCharToLower(*ustring1)==u2lc)) &&
 			(length2==1 || strCmpFn(ustring1, ustring2,
-				length2) == 0)) {
+				(unsigned long) length2) == 0)) {
 		    if (p != ustring1) {
 			Tcl_AppendUnicodeToObj(resultPtr, p, ustring1-p);
 			p = ustring1 + length2;
 		    } else {
 			p += length2;
@@ -2143,27 +2137,26 @@
 		}
 	    }
 	}
     } else {
 	Tcl_UniChar **mapStrings;
-	size_t *mapLens;
-	int *u2lc = 0;
+	int *mapLens, *u2lc = NULL;
 
 	/*
 	 * Precompute pointers to the unicode string and length. This saves us
 	 * repeated function calls later, significantly speeding up the
 	 * algorithm. We only need the lowercase first char in the nocase
 	 * case.
 	 */
 
-	mapStrings = TclStackAlloc(interp, mapElemc*sizeof(Tcl_UniChar *)*2);
-	mapLens = TclStackAlloc(interp, mapElemc * sizeof(size_t) * 2);
+	mapStrings = TclStackAlloc(interp, mapElemc*2*sizeof(Tcl_UniChar *));
+	mapLens = TclStackAlloc(interp, mapElemc * 2 * sizeof(int));
 	if (nocase) {
 	    u2lc = TclStackAlloc(interp, mapElemc * sizeof(int));
 	}
 	for (index = 0; index < mapElemc; index++) {
-	    mapStrings[index] = TclGetUnicodeFromObj(mapElemv[index],
+	    mapStrings[index] = Tcl_GetUnicodeFromObj(mapElemv[index],
 		    mapLens+index);
 	    if (nocase && ((index % 2) == 0)) {
 		u2lc[index/2] = Tcl_UniCharToLower(*mapStrings[index]);
 	    }
 	}
@@ -2176,11 +2169,11 @@
 		ustring2 = mapStrings[index];
 		length2 = mapLens[index];
 		if ((length2 > 0) && ((*ustring1 == *ustring2) || (nocase &&
 			(Tcl_UniCharToLower(*ustring1) == u2lc[index/2]))) &&
 			/* Restrict max compare length. */
-			((size_t)(end-ustring1) >= length2) && ((length2 == 1) ||
+			(end-ustring1 >= length2) && ((length2 == 1) ||
 			!strCmpFn(ustring2, ustring1, length2))) {
 		    if (p != ustring1) {
 			/*
 			 * Put the skipped chars onto the result first.
 			 */
@@ -2262,11 +2255,11 @@
 	Tcl_WrongNumArgs(interp, 1, objv, "?-nocase? pattern string");
 	return TCL_ERROR;
     }
 
     if (objc == 4) {
-	size_t length;
+	int length;
 	const char *string = TclGetStringFromObj(objv[1], &length);
 
 	if ((length > 1) &&
 	    strncmp(string, "-nocase", length) == 0) {
 	    nocase = TCL_MATCH_NOCASE;
@@ -2306,11 +2299,11 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t first, last, end;
+    int length, first, last;
 
     if (objc != 4) {
 	Tcl_WrongNumArgs(interp, 1, objv, "string first last");
 	return TCL_ERROR;
     }
@@ -2318,24 +2311,24 @@
     /*
      * Get the length in actual characters; Then reduce it by one because
      * 'end' refers to the last character, not one past it.
      */
 
-    end = Tcl_GetCharLength(objv[1]) - 1;
+    length = Tcl_GetCharLength(objv[1]) - 1;
 
-    if (TclGetIntForIndexM(interp, objv[2], end, &first) != TCL_OK ||
-	    TclGetIntForIndexM(interp, objv[3], end, &last) != TCL_OK) {
+    if (TclGetIntForIndexM(interp, objv[2], length, &first) != TCL_OK ||
+	    TclGetIntForIndexM(interp, objv[3], length, &last) != TCL_OK) {
 	return TCL_ERROR;
     }
 
-    if (first == TCL_INDEX_NONE) {
-	first = TCL_INDEX_START;
+    if (first < 0) {
+	first = 0;
     }
-    if (last + 1 >= end + 1) {
-	last = end;
+    if (last >= length) {
+	last = length;
     }
-    if (last + 1 >= first + 1) {
+    if (last >= first) {
 	Tcl_SetObjResult(interp, Tcl_GetRange(objv[1], first, last));
     }
     return TCL_OK;
 }
 
@@ -2418,18 +2411,19 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-	size_t first, last, end;
+    int first, last, length, end;
 
     if (objc < 4 || objc > 5) {
 	Tcl_WrongNumArgs(interp, 1, objv, "string first last ?string?");
 	return TCL_ERROR;
     }
 
-    end = Tcl_GetCharLength(objv[1]) - 1;
+    length = Tcl_GetCharLength(objv[1]);
+    end = length - 1;
 
     if (TclGetIntForIndexM(interp, objv[2], end, &first) != TCL_OK ||
 	    TclGetIntForIndexM(interp, objv[3], end, &last) != TCL_OK) {
 	return TCL_ERROR;
     }
@@ -2438,13 +2432,14 @@
      * The following test screens out most empty substrings as candidates for
      * replacement. When they are detected, no replacement is done, and the
      * result is the original string.
      */
 
-    if ((last == TCL_INDEX_NONE) ||	/* Range ends before start of string */
-	    (first + 1 > end + 1) ||	/* Range begins after end of string */
-	    (last + 1 < first + 1)) {	/* Range begins after it starts */
+    if ((last < 0) ||		/* Range ends before start of string */
+	    (first > end) ||	/* Range begins after end of string */
+	    (last < first)) {	/* Range begins after it starts */
+
 	/*
 	 * BUT!!! when (end < 0) -- an empty original string -- we can
 	 * have (first <= end < 0 <= last) and an empty string is permitted
 	 * to be replaced.
 	 */
@@ -2451,14 +2446,14 @@
 
 	Tcl_SetObjResult(interp, objv[1]);
     } else {
 	Tcl_Obj *resultPtr;
 
-	if (first == TCL_INDEX_NONE) {
-	    first = TCL_INDEX_START;
+	if (first < 0) {
+	    first = 0;
 	}
-	if (last + 1 > end + 1) {
+	if (last > end) {
 	    last = end;
 	}
 
 	resultPtr = TclStringReplace(interp, objv[1], first,
 		last + 1 - first, (objc == 5) ? objv[4] : NULL,
@@ -2529,30 +2524,30 @@
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Tcl_UniChar ch = 0;
     const char *p, *string;
-    size_t numChars, length, cur, index;
+    int cur, index, length, numChars;
 
     if (objc != 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "string index");
 	return TCL_ERROR;
     }
 
     string = TclGetStringFromObj(objv[1], &length);
-    numChars = Tcl_NumUtfChars(string, length) - 1;
-    if (TclGetIntForIndexM(interp, objv[2], numChars, &index) != TCL_OK) {
+    numChars = Tcl_NumUtfChars(string, length);
+    if (TclGetIntForIndexM(interp, objv[2], numChars-1, &index) != TCL_OK) {
 	return TCL_ERROR;
     }
-    string = TclGetString(objv[1]);
-    if (index + 1 > numChars + 1) {
-	index = numChars;
+    string = TclGetStringFromObj(objv[1], &length);
+    if (index >= numChars) {
+	index = numChars - 1;
     }
     cur = 0;
-    if (index + 1 > 1) {
+    if (index > 0) {
 	p = Tcl_UtfAtIndex(string, index);
-	for (cur = index; cur != TCL_INDEX_NONE; cur--) {
+	for (cur = index; cur >= 0; cur--) {
 	    TclUtfToUniChar(p, &ch);
 	    if (!Tcl_UniCharIsWordChar(ch)) {
 		break;
 	    }
 	    p = Tcl_UtfPrev(p, string);
@@ -2559,11 +2554,11 @@
 	}
 	if (cur != index) {
 	    cur += 1;
 	}
     }
-    Tcl_SetObjResult(interp, TclNewWideIntObjFromSize(cur));
+    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(cur));
     return TCL_OK;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -2590,27 +2585,27 @@
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Tcl_UniChar ch = 0;
     const char *p, *end, *string;
-    size_t length, numChars, cur, index;
+    int cur, index, length, numChars;
 
     if (objc != 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "string index");
 	return TCL_ERROR;
     }
 
     string = TclGetStringFromObj(objv[1], &length);
-    numChars = Tcl_NumUtfChars(string, length) - 1;
-    if (TclGetIntForIndexM(interp, objv[2], numChars, &index) != TCL_OK) {
+    numChars = Tcl_NumUtfChars(string, length);
+    if (TclGetIntForIndexM(interp, objv[2], numChars-1, &index) != TCL_OK) {
 	return TCL_ERROR;
     }
     string = TclGetStringFromObj(objv[1], &length);
-    if (index == TCL_INDEX_NONE) {
-	index = TCL_INDEX_START;
+    if (index < 0) {
+	index = 0;
     }
-    if (index + 1 <= numChars + 1) {
+    if (index < numChars) {
 	p = Tcl_UtfAtIndex(string, index);
 	end = string+length;
 	for (cur = index; p < end; cur++) {
 	    p += TclUtfToUniChar(p, &ch);
 	    if (!Tcl_UniCharIsWordChar(ch)) {
@@ -2619,13 +2614,13 @@
 	}
 	if (cur == index) {
 	    cur++;
 	}
     } else {
-	cur = numChars + 1;
+	cur = numChars;
     }
-    Tcl_SetObjResult(interp, TclNewWideIntObjFromSize(cur));
+    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(cur));
     return TCL_OK;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -2657,12 +2652,11 @@
      * in tclExecute.c (INST_STR_EQ, INST_STR_NEQ and INST_STR_CMP as well as
      * the expr string comparison in INST_EQ/INST_NEQ/INST_LT/...).
      */
 
     const char *string2;
-    int i, match, nocase = 0, reqlength = -1;
-    size_t length;
+    int length, i, match, nocase = 0, reqlength = -1;
 
     if (objc < 3 || objc > 6) {
     str_cmp_args:
 	Tcl_WrongNumArgs(interp, 1, objv,
 		"?-nocase? ?-length int? string1 string2");
@@ -2753,12 +2747,11 @@
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[],	/* Argument objects. */
     int *nocase,
     int *reqlength)
 {
-    int i;
-    size_t length;
+    int i, length;
     const char *string;
 
     *reqlength = -1;
     *nocase = 0;
     if (objc < 3 || objc > 6) {
@@ -2853,19 +2846,18 @@
  * Side effects:
  *	See the user documentation.
  *
  *----------------------------------------------------------------------
  */
-
 static int
 StringBytesCmd(
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t length;
+    int length;
 
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "string");
 	return TCL_ERROR;
     }
@@ -2932,11 +2924,11 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t length1, length2;
+    int length1, length2;
     const char *string1;
     char *string2;
 
     if (objc < 2 || objc > 4) {
 	Tcl_WrongNumArgs(interp, 1, objv, "string ?first? ?last?");
@@ -2950,32 +2942,32 @@
 
 	length1 = Tcl_UtfToLower(TclGetString(resultPtr));
 	Tcl_SetObjLength(resultPtr, length1);
 	Tcl_SetObjResult(interp, resultPtr);
     } else {
-	size_t first, last;
+	int first, last;
 	const char *start, *end;
 	Tcl_Obj *resultPtr;
 
 	length1 = Tcl_NumUtfChars(string1, length1) - 1;
 	if (TclGetIntForIndexM(interp,objv[2],length1, &first) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	if (first == TCL_INDEX_NONE) {
+	if (first < 0) {
 	    first = 0;
 	}
 	last = first;
 
 	if ((objc == 4) && (TclGetIntForIndexM(interp, objv[3], length1,
 		&last) != TCL_OK)) {
 	    return TCL_ERROR;
 	}
 
-	if (last + 1 >= length1 + 1) {
+	if (last >= length1) {
 	    last = length1;
 	}
-	if (last + 1 < first + 1) {
+	if (last < first) {
 	    Tcl_SetObjResult(interp, objv[1]);
 	    return TCL_OK;
 	}
 
 	string1 = TclGetStringFromObj(objv[1], &length1);
@@ -3017,11 +3009,11 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t length1, length2;
+    int length1, length2;
     const char *string1;
     char *string2;
 
     if (objc < 2 || objc > 4) {
 	Tcl_WrongNumArgs(interp, 1, objv, "string ?first? ?last?");
@@ -3035,32 +3027,32 @@
 
 	length1 = Tcl_UtfToUpper(TclGetString(resultPtr));
 	Tcl_SetObjLength(resultPtr, length1);
 	Tcl_SetObjResult(interp, resultPtr);
     } else {
-	size_t first, last;
+	int first, last;
 	const char *start, *end;
 	Tcl_Obj *resultPtr;
 
 	length1 = Tcl_NumUtfChars(string1, length1) - 1;
 	if (TclGetIntForIndexM(interp,objv[2],length1, &first) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	if (first == TCL_INDEX_NONE) {
-	    first = TCL_INDEX_START;
+	if (first < 0) {
+	    first = 0;
 	}
 	last = first;
 
 	if ((objc == 4) && (TclGetIntForIndexM(interp, objv[3], length1,
 		&last) != TCL_OK)) {
 	    return TCL_ERROR;
 	}
 
-	if (last + 1 >= length1 + 1) {
+	if (last >= length1) {
 	    last = length1;
 	}
-	if (last + 1 < first + 1) {
+	if (last < first) {
 	    Tcl_SetObjResult(interp, objv[1]);
 	    return TCL_OK;
 	}
 
 	string1 = TclGetStringFromObj(objv[1], &length1);
@@ -3102,11 +3094,11 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t length1, length2;
+    int length1, length2;
     const char *string1;
     char *string2;
 
     if (objc < 2 || objc > 4) {
 	Tcl_WrongNumArgs(interp, 1, objv, "string ?first? ?last?");
@@ -3120,32 +3112,32 @@
 
 	length1 = Tcl_UtfToTitle(TclGetString(resultPtr));
 	Tcl_SetObjLength(resultPtr, length1);
 	Tcl_SetObjResult(interp, resultPtr);
     } else {
-	size_t first, last;
+	int first, last;
 	const char *start, *end;
 	Tcl_Obj *resultPtr;
 
 	length1 = Tcl_NumUtfChars(string1, length1) - 1;
 	if (TclGetIntForIndexM(interp,objv[2],length1, &first) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	if (first == TCL_INDEX_NONE) {
-	    first = TCL_INDEX_START;
+	if (first < 0) {
+	    first = 0;
 	}
 	last = first;
 
 	if ((objc == 4) && (TclGetIntForIndexM(interp, objv[3], length1,
 		&last) != TCL_OK)) {
 	    return TCL_ERROR;
 	}
 
-	if (last + 1 >= length1 + 1) {
+	if (last >= length1) {
 	    last = length1;
 	}
-	if (last + 1 < first + 1) {
+	if (last < first) {
 	    Tcl_SetObjResult(interp, objv[1]);
 	    return TCL_OK;
 	}
 
 	string1 = TclGetStringFromObj(objv[1], &length1);
@@ -3188,11 +3180,11 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     const char *string1, *string2;
-    size_t triml, trimr, length1, length2;
+    int triml, trimr, length1, length2;
 
     if (objc == 3) {
 	string2 = TclGetStringFromObj(objv[2], &length2);
     } else if (objc == 2) {
 	string2 = tclDefaultTrimSet;
@@ -3235,12 +3227,11 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     const char *string1, *string2;
-    int trim;
-    size_t length1, length2;
+    int trim, length1, length2;
 
     if (objc == 3) {
 	string2 = TclGetStringFromObj(objv[2], &length2);
     } else if (objc == 2) {
 	string2 = tclDefaultTrimSet;
@@ -3282,12 +3273,11 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     const char *string1, *string2;
-    int trim;
-    size_t length1, length2;
+    int trim, length1, length2;
 
     if (objc == 3) {
 	string2 = TclGetStringFromObj(objv[2], &length2);
     } else if (objc == 2) {
 	string2 = tclDefaultTrimSet;
@@ -3482,13 +3472,12 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    int i, index, mode, foundmode, splitObjs, numMatchesSaved;
-    int noCase;
-    size_t patternLength, j;
+    int i,j, index, mode, foundmode, splitObjs, numMatchesSaved;
+    int noCase, patternLength;
     const char *pattern;
     Tcl_Obj *stringObj, *indexVarObj, *matchVarObj;
     Tcl_Obj *const *savedObjv = objv;
     Tcl_RegExp regExpr = NULL;
     Interp *iPtr = (Interp *) interp;
@@ -3795,13 +3784,13 @@
 
 	for (j=0 ; j<=info.nsubs ; j++) {
 	    if (indexVarObj != NULL) {
 		Tcl_Obj *rangeObjAry[2];
 
-		if (info.matches[j].end + 1 > 1) {
-		    rangeObjAry[0] = TclNewWideIntObjFromSize(info.matches[j].start);
-		    rangeObjAry[1] = TclNewWideIntObjFromSize(info.matches[j].end-1);
+		if (info.matches[j].end > 0) {
+		    rangeObjAry[0] = Tcl_NewWideIntObj(info.matches[j].start);
+		    rangeObjAry[1] = Tcl_NewWideIntObj(info.matches[j].end-1);
 		} else {
 		    rangeObjAry[0] = rangeObjAry[1] = Tcl_NewWideIntObj(-1);
 		}
 
 		/*
@@ -3891,11 +3880,11 @@
 	}
 
 	if (ctxPtr->type == TCL_LOCATION_SOURCE && ctxPtr->line[bidx] >= 0) {
 	    int bline = ctxPtr->line[bidx];
 
-	    ctxPtr->line = Tcl_Alloc(objc * sizeof(int));
+	    ctxPtr->line = ckalloc(objc * sizeof(int));
 	    ctxPtr->nline = objc;
 	    TclListLines(blist, bline, objc, ctxPtr->line, objv);
 	} else {
 	    /*
 	     * This is either a dynamic code word, when all elements are
@@ -3905,20 +3894,20 @@
 	     * which triggers reversion to the old behavior.
 	     */
 
 	    int k;
 
-	    ctxPtr->line = Tcl_Alloc(objc * sizeof(int));
+	    ctxPtr->line = ckalloc(objc * sizeof(int));
 	    ctxPtr->nline = objc;
 	    for (k=0; k < objc; k++) {
 		ctxPtr->line[k] = -1;
 	    }
 	}
     }
 
     for (j = i + 1; ; j += 2) {
-	if (j >= (size_t)objc) {
+	if (j >= objc) {
 	    /*
 	     * This shouldn't happen since we've checked that the last body is
 	     * not a continuation...
 	     */
 
@@ -3948,18 +3937,18 @@
 
     int splitObjs = PTR2INT(data[0]);
     CmdFrame *ctxPtr = data[1];
     int pc = PTR2INT(data[2]);
     const char *pattern = data[3];
-    size_t patternLength = strlen(pattern);
+    int patternLength = strlen(pattern);
 
     /*
      * Clean up TIP 280 context information
      */
 
     if (splitObjs) {
-	Tcl_Free(ctxPtr->line);
+	ckfree(ctxPtr->line);
 	if (pc && (ctxPtr->type == TCL_LOCATION_SOURCE)) {
 	    /*
 	     * Death of SrcInfo reference.
 	     */
 
@@ -3970,16 +3959,16 @@
     /*
      * Generate an error message if necessary.
      */
 
     if (result == TCL_ERROR) {
-	unsigned limit = 50;
+	int limit = 50;
 	int overflow = (patternLength > limit);
 
 	Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 		"\n    (\"%.*s%s\" arm line %d)",
-		(overflow ? limit : (unsigned)patternLength), pattern,
+		(overflow ? limit : patternLength), pattern,
 		(overflow ? "..." : ""), Tcl_GetErrorLine(interp)));
     }
     TclStackFree(interp, ctxPtr);
     return result;
 }
@@ -4069,13 +4058,13 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    register Tcl_Obj *objPtr;
+    Tcl_Obj *objPtr;
     Tcl_Obj *objs[4];
-    register int i, result;
+    int i, result;
     int count;
     double totalMicroSec;
 #ifndef TCL_WIDE_CLICKS
     Tcl_Time start, stop;
 #else
@@ -4170,26 +4159,26 @@
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     static double measureOverhead = 0;
 				/* global measure-overhead */
     double overhead = -1;	/* given measure-overhead */
-    register Tcl_Obj *objPtr;
-    register int result, i;
+    Tcl_Obj *objPtr;
+    int result, i;
     Tcl_Obj *calibrate = NULL, *direct = NULL;
-    Tcl_WideUInt count = 0;	/* Holds repetition count */
+    TclWideMUInt count = 0;	/* Holds repetition count */
     Tcl_WideInt maxms = WIDE_MIN;
 				/* Maximal running time (in milliseconds) */
-    Tcl_WideUInt maxcnt = WIDE_MAX;
+    TclWideMUInt maxcnt = WIDE_MAX;
 				/* Maximal count of iterations. */
-    Tcl_WideUInt threshold = 1;	/* Current threshold for check time (faster
+    TclWideMUInt threshold = 1;	/* Current threshold for check time (faster
 				 * repeat count without time check) */
-    Tcl_WideUInt maxIterTm = 1;	/* Max time of some iteration as max
+    TclWideMUInt maxIterTm = 1;	/* Max time of some iteration as max
 				 * threshold, additionally avoiding divide to
 				 * zero (i.e., never < 1) */
     unsigned short factor = 50;	/* Factor (4..50) limiting threshold to avoid
 				 * growth of execution time. */
-    register Tcl_WideInt start, middle, stop;
+    Tcl_WideInt start, middle, stop;
 #ifndef TCL_WIDE_CLICKS
     Tcl_Time now;
 #endif /* !TCL_WIDE_CLICKS */
     static const char *const options[] = {
 	"-direct",	"-overhead",	"-calibrate",	"--",	NULL
@@ -4197,11 +4186,10 @@
     enum options {
 	TMRT_EV_DIRECT,	TMRT_OVERHEAD,	TMRT_CALIBRATE,	TMRT_LAST
     };
     NRE_callback *rootPtr;
     ByteCode *codePtr = NULL;
-    int codeOptimized = 0;
 
     for (i = 1; i < objc - 1; i++) {
 	int index;
 
 	if (Tcl_GetIndexFromObj(NULL, objv[i], options, "option", TCL_EXACT,
@@ -4382,19 +4370,10 @@
 	if (TclInterpReady(interp) != TCL_OK) {
 	    return TCL_ERROR;
 	}
 	codePtr = TclCompileObj(interp, objPtr, NULL, 0);
 	TclPreserveByteCode(codePtr);
-	/*
-	 * Replace last compiled done instruction with continue: it's a part of
-	 * iteration, this way evaluation will be more similar to a cycle (also
-	 * avoids extra overhead to set result to interp, etc.)
-	 */
-	if (codePtr->codeStart[codePtr->numCodeBytes-1] == INST_DONE) {
-	    codePtr->codeStart[codePtr->numCodeBytes-1] = INST_CONTINUE;
-	    codeOptimized = 1;
-	}
     }
 
     /*
      * Get start and stop time.
      */
@@ -4432,10 +4411,16 @@
 	     */
 
 	    count++;
 	    if (!direct) {		/* precompiled */
 		rootPtr = TOP_CB(interp);
+		/*
+		 * Use loop optimized TEBC call (TCL_EVAL_DISCARD_RESULT): it's a part of
+		 * iteration, this way evaluation will be more similar to a cycle (also
+		 * avoids extra overhead to set result to interp, etc.)
+		 */
+		((Interp *)interp)->evalFlags |= TCL_EVAL_DISCARD_RESULT;
 		result = TclNRExecuteByteCode(interp, codePtr);
 		result = TclNRRunCallbacks(interp, result, rootPtr);
 	    } else {			/* eval */
 		result = TclEvalObjEx(interp, objPtr, 0, NULL, 0);
 	    }
@@ -4451,10 +4436,11 @@
 		    /*
 		     * Force stop immediately.
 		     */
 		    threshold = 1;
 		    maxcnt = 0;
+		    /* FALLTHRU */
 		case TCL_CONTINUE:
 		    result = TCL_OK;
 		    break;
 		default:
 		    goto done;
@@ -4555,17 +4541,17 @@
 	}
     }
 
     {
 	Tcl_Obj *objarr[8], **objs = objarr;
-	Tcl_WideUInt usec, val;
+	TclWideMUInt usec, val;
 	int digits;
 
 	/*
 	 * Absolute execution time in microseconds or in wide clicks.
 	 */
-	usec = (Tcl_WideUInt)(middle - start);
+	usec = (TclWideMUInt)(middle - start);
 
 #ifdef TCL_WIDE_CLICKS
 	/*
 	 * convert execution time (in wide clicks) to microsecs.
 	 */
@@ -4590,11 +4576,11 @@
 	    if (overhead > 0) {
 		/*
 		 * Estimate the time of overhead (microsecs).
 		 */
 
-		Tcl_WideUInt curOverhead = overhead * count;
+		TclWideMUInt curOverhead = overhead * count;
 
 		if (usec > curOverhead) {
 		    usec -= curOverhead;
 		} else {
 		    usec = 0;
@@ -4684,15 +4670,10 @@
 	Tcl_SetObjResult(interp, Tcl_NewListObj(8, objarr));
     }
 
   done:
     if (codePtr != NULL) {
-	if ( codeOptimized
-	  && codePtr->codeStart[codePtr->numCodeBytes-1] == INST_CONTINUE
-	) {
-	    codePtr->codeStart[codePtr->numCodeBytes-1] = INST_DONE;
-	}
 	TclReleaseByteCode(codePtr);
     }
     return result;
 }
 
@@ -4815,11 +4796,11 @@
 	    }
 	    code = 1;
 	    if (Tcl_ListObjLength(NULL, objv[i+1], &dummy) != TCL_OK) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"bad prefix '%s': must be a list",
-			TclGetString(objv[i+1])));
+			Tcl_GetString(objv[i+1])));
 		Tcl_DecrRefCount(handlersObj);
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "TRY", "TRAP",
 			"EXNFORMAT", NULL);
 		return TCL_ERROR;
 	    }
@@ -5354,11 +5335,11 @@
     int n,			/* #elements in lines */
     int *lines,			/* Array of line numbers, to fill. */
     Tcl_Obj *const *elems)      /* The list elems as Tcl_Obj*, in need of
 				 * derived continuation data */
 {
-    const char *listStr = TclGetString(listObj);
+    const char *listStr = Tcl_GetString(listObj);
     const char *listHead = listStr;
     int i, length = strlen(listStr);
     const char *element = NULL, *next = NULL;
     ContLineLoc *clLocPtr = TclContinuationsGet(listObj);
     int *clNext = (clLocPtr ? &clLocPtr->loc[0] : NULL);

Index: generic/tclCompCmds.c
==================================================================
--- generic/tclCompCmds.c
+++ generic/tclCompCmds.c
@@ -401,13 +401,13 @@
      */
 
     keyVar = AnonymousLocal(envPtr);
     valVar = AnonymousLocal(envPtr);
 
-    infoPtr = Tcl_Alloc(sizeof(ForeachInfo));
+    infoPtr = ckalloc(sizeof(ForeachInfo));
     infoPtr->numLists = 1;
-    infoPtr->varLists[0] = Tcl_Alloc(sizeof(ForeachVarList) + sizeof(int));
+    infoPtr->varLists[0] = ckalloc(sizeof(ForeachVarList) + sizeof(int));
     infoPtr->varLists[0]->numVars = 2;
     infoPtr->varLists[0]->varIndexes[0] = keyVar;
     infoPtr->varLists[0]->varIndexes[1] = valVar;
     infoIndex = TclCreateAuxData(infoPtr, &newForeachInfoType, envPtr);
 
@@ -699,12 +699,12 @@
     TclEmitOpcode(		INST_PUSH_RETURN_CODE,		envPtr);
 
     /* Stack at this point on both branches: result returnCode */
 
     if (TclFixupForwardJumpToHere(envPtr, &jumpFixup, 127)) {
-	Tcl_Panic("TclCompileCatchCmd: bad jump distance %" TCL_Z_MODIFIER "d",
-		(CurrentOffset(envPtr) - jumpFixup.codeOffset));
+	Tcl_Panic("TclCompileCatchCmd: bad jump distance %d",
+		(int)(CurrentOffset(envPtr) - jumpFixup.codeOffset));
     }
 
     /*
      * Push the return options if the caller wants them. This needs to happen
      * before INST_END_CATCH
@@ -906,17 +906,16 @@
     }
     if (listObj != NULL) {
 	Tcl_Obj **objs;
 	const char *bytes;
 	int len;
-	size_t slen;
 
 	Tcl_ListObjGetElements(NULL, listObj, &len, &objs);
 	objPtr = Tcl_ConcatObj(len, objs);
 	Tcl_DecrRefCount(listObj);
-	bytes = TclGetStringFromObj(objPtr, &slen);
-	PushLiteral(envPtr, bytes, slen);
+	bytes = TclGetStringFromObj(objPtr, &len);
+	PushLiteral(envPtr, bytes, len);
 	Tcl_DecrRefCount(objPtr);
 	return TCL_OK;
     }
 
     /*
@@ -1095,12 +1094,11 @@
      * Parse the increment amount, if present.
      */
 
     if (parsePtr->numWords == 4) {
 	const char *word;
-	size_t numBytes;
-	int code;
+	int numBytes, code;
 	Tcl_Token *incrTokenPtr;
 	Tcl_Obj *intObj;
 
 	incrTokenPtr = TokenAfter(keyTokenPtr);
 	if (incrTokenPtr->type != TCL_TOKEN_SIMPLE_WORD) {
@@ -1312,12 +1310,11 @@
     DefineLineInformation;	/* TIP #280 */
     int worker;			/* Temp var for building the value in. */
     Tcl_Token *tokenPtr;
     Tcl_Obj *keyObj, *valueObj, *dictObj;
     const char *bytes;
-    int i;
-    size_t len;
+    int i, len;
 
     if ((parsePtr->numWords & 1) == 0) {
 	return TCL_ERROR;
     }
 
@@ -1596,19 +1593,19 @@
 	Tcl_DStringFree(&buffer);
 	return TclCompileBasic3ArgCmd(interp, parsePtr, cmdPtr, envPtr);
     }
     Tcl_DStringFree(&buffer);
     if (numVars != 2) {
-	Tcl_Free((void *)argv);
+	ckfree(argv);
 	return TclCompileBasic3ArgCmd(interp, parsePtr, cmdPtr, envPtr);
     }
 
     nameChars = strlen(argv[0]);
     keyVarIndex = LocalScalar(argv[0], nameChars, envPtr);
     nameChars = strlen(argv[1]);
     valueVarIndex = LocalScalar(argv[1], nameChars, envPtr);
-    Tcl_Free((void *)argv);
+    ckfree(argv);
 
     if ((keyVarIndex < 0) || (valueVarIndex < 0)) {
 	return TclCompileBasic3ArgCmd(interp, parsePtr, cmdPtr, envPtr);
     }
 
@@ -1812,11 +1809,11 @@
      * Assemble the instruction metadata. This is complex enough that it is
      * represented as auxData; it holds an ordered list of variable indices
      * that are to be used.
      */
 
-    duiPtr = Tcl_Alloc(sizeof(DictUpdateInfo) + sizeof(int) * (numVars - 1));
+    duiPtr = ckalloc(sizeof(DictUpdateInfo) + sizeof(int) * (numVars - 1));
     duiPtr->length = numVars;
     keyTokenPtrs = TclStackAlloc(interp, sizeof(Tcl_Token *) * numVars);
     tokenPtr = TokenAfter(dictVarTokenPtr);
 
     for (i=0 ; i<numVars ; i++) {
@@ -1895,22 +1892,22 @@
     TclEmitInstInt4(	INST_DICT_UPDATE_END, dictIndex,	envPtr);
     TclEmitInt4(		infoIndex,			envPtr);
     TclEmitInvoke(envPtr,INST_RETURN_STK);
 
     if (TclFixupForwardJumpToHere(envPtr, &jumpFixup, 127)) {
-	Tcl_Panic("TclCompileDictCmd(update): bad jump distance %" TCL_Z_MODIFIER "d",
-		CurrentOffset(envPtr) - jumpFixup.codeOffset);
+	Tcl_Panic("TclCompileDictCmd(update): bad jump distance %d",
+		(int) (CurrentOffset(envPtr) - jumpFixup.codeOffset));
     }
     TclStackFree(interp, keyTokenPtrs);
     return TCL_OK;
 
     /*
      * Clean up after a failure to create the DictUpdateInfo structure.
      */
 
   failedUpdateInfoAssembly:
-    Tcl_Free(duiPtr);
+    ckfree(duiPtr);
     TclStackFree(interp, keyTokenPtrs);
   issueFallback:
     return TclCompileBasicMin2ArgCmd(interp, parsePtr, cmdPtr, envPtr);
 }
 
@@ -2257,12 +2254,12 @@
     /*
      * Prepare for the start of the next command.
      */
 
     if (TclFixupForwardJumpToHere(envPtr, &jumpFixup, 127)) {
-	Tcl_Panic("TclCompileDictCmd(update): bad jump distance %" TCL_Z_MODIFIER "d",
-		CurrentOffset(envPtr) - jumpFixup.codeOffset);
+	Tcl_Panic("TclCompileDictCmd(update): bad jump distance %d",
+		(int) (CurrentOffset(envPtr) - jumpFixup.codeOffset));
     }
     return TCL_OK;
 }
 
 /*
@@ -2295,20 +2292,20 @@
     DictUpdateInfo *dui1Ptr, *dui2Ptr;
     unsigned len;
 
     dui1Ptr = clientData;
     len = sizeof(DictUpdateInfo) + sizeof(int) * (dui1Ptr->length - 1);
-    dui2Ptr = Tcl_Alloc(len);
+    dui2Ptr = ckalloc(len);
     memcpy(dui2Ptr, dui1Ptr, len);
     return dui2Ptr;
 }
 
 static void
 FreeDictUpdateInfo(
     ClientData clientData)
 {
-    Tcl_Free(clientData);
+    ckfree(clientData);
 }
 
 static void
 PrintDictUpdateInfo(
     ClientData clientData,
@@ -2315,11 +2312,11 @@
     Tcl_Obj *appendObj,
     ByteCode *codePtr,
     unsigned int pcOffset)
 {
     DictUpdateInfo *duiPtr = clientData;
-    size_t i;
+    int i;
 
     for (i=0 ; i<duiPtr->length ; i++) {
 	if (i) {
 	    Tcl_AppendToObj(appendObj, ", ", -1);
 	}
@@ -2333,11 +2330,11 @@
     Tcl_Obj *dictObj,
     ByteCode *codePtr,
     unsigned int pcOffset)
 {
     DictUpdateInfo *duiPtr = clientData;
-    size_t i;
+    int i;
     Tcl_Obj *variables = Tcl_NewObj();
 
     for (i=0 ; i<duiPtr->length ; i++) {
 	Tcl_ListObjAppendElement(NULL, variables,
 		Tcl_NewIntObj(duiPtr->varIndices[i]));
@@ -2748,11 +2745,11 @@
      * structures describing this command. Then create a AuxData record
      * pointing to the ForeachInfo structure.
      */
 
     numLists = (numWords - 2)/2;
-    infoPtr = Tcl_Alloc(sizeof(ForeachInfo)
+    infoPtr = ckalloc(sizeof(ForeachInfo)
 	    + (numLists - 1) * sizeof(ForeachVarList *));
     infoPtr->numLists = 0;	/* Count this up as we go */
 
     /*
      * Parse each var list into sequence of var names.  Don't
@@ -2782,26 +2779,24 @@
 		numVars == 0) {
 	    code = TCL_ERROR;
 	    goto done;
 	}
 
-	varListPtr = Tcl_Alloc(sizeof(ForeachVarList)
+	varListPtr = ckalloc(sizeof(ForeachVarList)
 		+ (numVars - 1) * sizeof(int));
 	varListPtr->numVars = numVars;
 	infoPtr->varLists[i/2] = varListPtr;
 	infoPtr->numLists++;
 
 	for (j = 0;  j < numVars;  j++) {
 	    Tcl_Obj *varNameObj;
 	    const char *bytes;
-	    int varIndex;
-	    size_t length;
-
+	    int numBytes, varIndex;
 
 	    Tcl_ListObjIndex(NULL, varListObj, j, &varNameObj);
-	    bytes = TclGetStringFromObj(varNameObj, &length);
-	    varIndex = LocalScalar(bytes, length, envPtr);
+	    bytes = TclGetStringFromObj(varNameObj, &numBytes);
+	    varIndex = LocalScalar(bytes, numBytes, envPtr);
 	    if (varIndex < 0) {
 		code = TCL_ERROR;
 		goto done;
 	    }
 	    varListPtr->varIndexes[j] = varIndex;
@@ -2915,25 +2910,25 @@
 static ClientData
 DupForeachInfo(
     ClientData clientData)	/* The foreach command's compilation auxiliary
 				 * data to duplicate. */
 {
-    register ForeachInfo *srcPtr = clientData;
+    ForeachInfo *srcPtr = clientData;
     ForeachInfo *dupPtr;
-    register ForeachVarList *srcListPtr, *dupListPtr;
+    ForeachVarList *srcListPtr, *dupListPtr;
     int numVars, i, j, numLists = srcPtr->numLists;
 
-    dupPtr = Tcl_Alloc(sizeof(ForeachInfo)
+    dupPtr = ckalloc(sizeof(ForeachInfo)
 	    + numLists * sizeof(ForeachVarList *));
     dupPtr->numLists = numLists;
     dupPtr->firstValueTemp = srcPtr->firstValueTemp;
     dupPtr->loopCtTemp = srcPtr->loopCtTemp;
 
     for (i = 0;  i < numLists;  i++) {
 	srcListPtr = srcPtr->varLists[i];
 	numVars = srcListPtr->numVars;
-	dupListPtr = Tcl_Alloc(sizeof(ForeachVarList)
+	dupListPtr = ckalloc(sizeof(ForeachVarList)
 		+ numVars * sizeof(int));
 	dupListPtr->numVars = numVars;
 	for (j = 0;  j < numVars;  j++) {
 	    dupListPtr->varIndexes[j] =	srcListPtr->varIndexes[j];
 	}
@@ -2964,20 +2959,20 @@
 static void
 FreeForeachInfo(
     ClientData clientData)	/* The foreach command's compilation auxiliary
 				 * data to free. */
 {
-    register ForeachInfo *infoPtr = clientData;
-    register ForeachVarList *listPtr;
+    ForeachInfo *infoPtr = clientData;
+    ForeachVarList *listPtr;
     int numLists = infoPtr->numLists;
-    register int i;
+    int i;
 
     for (i = 0;  i < numLists;  i++) {
 	listPtr = infoPtr->varLists[i];
-	Tcl_Free(listPtr);
+	ckfree(listPtr);
     }
-    Tcl_Free(infoPtr);
+    ckfree(infoPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -3000,12 +2995,12 @@
     ClientData clientData,
     Tcl_Obj *appendObj,
     ByteCode *codePtr,
     unsigned int pcOffset)
 {
-    register ForeachInfo *infoPtr = clientData;
-    register ForeachVarList *varsPtr;
+    ForeachInfo *infoPtr = clientData;
+    ForeachVarList *varsPtr;
     int i, j;
 
     Tcl_AppendToObj(appendObj, "data=[", -1);
 
     for (i=0 ; i<infoPtr->numLists ; i++) {
@@ -3040,12 +3035,12 @@
     ClientData clientData,
     Tcl_Obj *appendObj,
     ByteCode *codePtr,
     unsigned int pcOffset)
 {
-    register ForeachInfo *infoPtr = clientData;
-    register ForeachVarList *varsPtr;
+    ForeachInfo *infoPtr = clientData;
+    ForeachVarList *varsPtr;
     int i, j;
 
     Tcl_AppendPrintfToObj(appendObj, "jumpOffset=%+d, vars=",
 	    infoPtr->loopCtTemp);
     for (i=0 ; i<infoPtr->numLists ; i++) {
@@ -3070,12 +3065,12 @@
     ClientData clientData,
     Tcl_Obj *dictObj,
     ByteCode *codePtr,
     unsigned int pcOffset)
 {
-    register ForeachInfo *infoPtr = clientData;
-    register ForeachVarList *varsPtr;
+    ForeachInfo *infoPtr = clientData;
+    ForeachVarList *varsPtr;
     int i, j;
     Tcl_Obj *objPtr, *innerPtr;
 
     /*
      * Data stores.
@@ -3117,12 +3112,12 @@
     ClientData clientData,
     Tcl_Obj *dictObj,
     ByteCode *codePtr,
     unsigned int pcOffset)
 {
-    register ForeachInfo *infoPtr = clientData;
-    register ForeachVarList *varsPtr;
+    ForeachInfo *infoPtr = clientData;
+    ForeachVarList *varsPtr;
     int i, j;
     Tcl_Obj *objPtr, *innerPtr;
 
     /*
      * Jump offset.
@@ -3177,13 +3172,12 @@
     CompileEnv *envPtr)		/* Holds resulting instructions. */
 {
     DefineLineInformation;	/* TIP #280 */
     Tcl_Token *tokenPtr = parsePtr->tokenPtr;
     Tcl_Obj **objv, *formatObj, *tmpObj;
-    char *bytes, *start;
-    int i, j;
-    size_t len;
+    const char *bytes, *start;
+    int i, j, len;
 
     /*
      * Don't handle any guaranteed-error cases.
      */
 
@@ -3202,11 +3196,11 @@
     if (!TclWordKnownAtCompileTime(tokenPtr, formatObj)) {
 	Tcl_DecrRefCount(formatObj);
 	return TCL_ERROR;
     }
 
-    objv = Tcl_Alloc((parsePtr->numWords-2) * sizeof(Tcl_Obj *));
+    objv = ckalloc((parsePtr->numWords-2) * sizeof(Tcl_Obj *));
     for (i=0 ; i+2 < parsePtr->numWords ; i++) {
 	tokenPtr = TokenAfter(tokenPtr);
 	objv[i] = Tcl_NewObj();
 	Tcl_IncrRefCount(objv[i]);
 	if (!TclWordKnownAtCompileTime(tokenPtr, objv[i])) {
@@ -3217,16 +3211,16 @@
     /*
      * Everything is a literal, so the result is constant too (or an error if
      * the format is broken). Do the format now.
      */
 
-    tmpObj = Tcl_Format(interp, TclGetString(formatObj),
+    tmpObj = Tcl_Format(interp, Tcl_GetString(formatObj),
 	    parsePtr->numWords-2, objv);
     for (; --i>=0 ;) {
 	Tcl_DecrRefCount(objv[i]);
     }
-    Tcl_Free(objv);
+    ckfree(objv);
     Tcl_DecrRefCount(formatObj);
     if (tmpObj == NULL) {
 	TclCompileSyntaxError(interp, envPtr);
 	return TCL_OK;
     }
@@ -3252,20 +3246,20 @@
      */
 
     for (; i>=0 ; i--) {
 	Tcl_DecrRefCount(objv[i]);
     }
-    Tcl_Free(objv);
+    ckfree(objv);
     tokenPtr = TokenAfter(parsePtr->tokenPtr);
     tokenPtr = TokenAfter(tokenPtr);
     i = 0;
 
     /*
      * Now scan through and check for non-%s and non-%% substitutions.
      */
 
-    for (bytes = TclGetString(formatObj) ; *bytes ; bytes++) {
+    for (bytes = Tcl_GetString(formatObj) ; *bytes ; bytes++) {
 	if (*bytes == '%') {
 	    bytes++;
 	    if (*bytes == 's') {
 		i++;
 		continue;
@@ -3294,11 +3288,11 @@
      */
 
     i = 0;			/* The count of things to concat. */
     j = 2;			/* The index into the argument tokens, for
 				 * TIP#280 handling. */
-    start = TclGetString(formatObj);
+    start = Tcl_GetString(formatObj);
 				/* The start of the currently-scanned literal
 				 * in the format string. */
     tmpObj = Tcl_NewObj();	/* The buffer used to accumulate the literal
 				 * being built. */
     for (bytes = start ; *bytes ; bytes++) {
@@ -3305,11 +3299,11 @@
 	if (*bytes == '%') {
 	    Tcl_AppendToObj(tmpObj, start, bytes - start);
 	    if (*++bytes == '%') {
 		Tcl_AppendToObj(tmpObj, "%", 1);
 	    } else {
-		char *b = TclGetStringFromObj(tmpObj, &len);
+		const char *b = TclGetStringFromObj(tmpObj, &len);
 
 		/*
 		 * If there is a non-empty literal from the format string,
 		 * push it and reset.
 		 */
@@ -3394,11 +3388,11 @@
 }
 
 int
 TclLocalScalar(
     const char *bytes,
-    size_t numBytes,
+    int numBytes,
     CompileEnv *envPtr)
 {
     Tcl_Token token[2] =        {{TCL_TOKEN_SIMPLE_WORD, NULL, 0, 1},
                                  {TCL_TOKEN_TEXT, NULL, 0, 0}};
 
@@ -3443,16 +3437,15 @@
     CompileEnv *envPtr,		/* Holds resulting instructions. */
     int flags,			/* TCL_NO_LARGE_INDEX | TCL_NO_ELEMENT. */
     int *localIndexPtr,		/* Must not be NULL. */
     int *isScalarPtr)		/* Must not be NULL. */
 {
-    register const char *p;
+    const char *p;
     const char *last, *name, *elName;
-    register size_t n;
+    int n;
     Tcl_Token *elemTokenPtr = NULL;
-	size_t nameLen, elNameLen;
-    int simpleVarName, localIndex;
+    int nameLen, elNameLen, simpleVarName, localIndex;
     int elemTokenCount = 0, allocedTokens = 0, removedParen = 0;
 
     /*
      * Decide if we can use a frame slot for the var/array name or if we need
      * to emit code to compute and push the name at runtime. We use a frame
@@ -3524,11 +3517,11 @@
 		simpleVarName = 1;
 		break;
 	    }
 	}
 	if (simpleVarName) {
-	    size_t remainingLen;
+	    int remainingLen;
 
 	    /*
 	     * Check the last token: if it is just ')', do not count it.
 	     * Otherwise, remove the ')' and flag so that it is restored at
 	     * the end.

Index: generic/tclCompCmdsGR.c
==================================================================
--- generic/tclCompCmdsGR.c
+++ generic/tclCompCmdsGR.c
@@ -47,12 +47,12 @@
  */
 
 int
 TclGetIndexFromToken(
     Tcl_Token *tokenPtr,
-    size_t before,
-    size_t after,
+    int before,
+    int after,
     int *indexPtr)
 {
     Tcl_Obj *tmpObj = Tcl_NewObj();
     int result = TCL_ERROR;
 
@@ -179,12 +179,11 @@
 				/* Used to fix the jump after each "then" body
 				 * to the end of the "if" when that PC is
 				 * determined. */
     Tcl_Token *tokenPtr, *testTokenPtr;
     int jumpIndex = 0;		/* Avoid compiler warning. */
-	size_t numBytes;
-    int jumpFalseDist, numWords, wordIdx, j, code;
+    int jumpFalseDist, numWords, wordIdx, numBytes, j, code;
     const char *word;
     int realCond = 1;		/* Set to 0 for static conditions:
 				 * "if 0 {..}" */
     int boolVal;		/* Value of static condition. */
     int compileScripts = 1;
@@ -498,11 +497,11 @@
     immValue = 1;
     if (parsePtr->numWords == 3) {
 	incrTokenPtr = TokenAfter(varTokenPtr);
 	if (incrTokenPtr->type == TCL_TOKEN_SIMPLE_WORD) {
 	    const char *word = incrTokenPtr[1].start;
-	    size_t numBytes = incrTokenPtr[1].size;
+	    int numBytes = incrTokenPtr[1].size;
 	    int code;
 	    Tcl_Obj *intObj = Tcl_NewStringObj(word, numBytes);
 
 	    Tcl_IncrRefCount(intObj);
 	    code = TclGetIntFromObj(NULL, intObj, &immValue);
@@ -588,11 +587,11 @@
     CompileEnv *envPtr)
 {
     DefineLineInformation;	/* TIP #280 */
     Tcl_Token *tokenPtr;
     Tcl_Obj *objPtr;
-    char *bytes;
+    const char *bytes;
 
     /*
      * We require one compile-time known argument for the case we can compile.
      */
 
@@ -2079,12 +2078,11 @@
 				 * compiled. */
     CompileEnv *envPtr)		/* Holds the resulting instructions. */
 {
     Tcl_Token *varTokenPtr;	/* Pointer to the Tcl_Token representing the
 				 * parse of the RE or string. */
-    size_t len;
-    int i, nocase, exact, sawLast, simple;
+    int i, len, nocase, exact, sawLast, simple;
     const char *str;
     DefineLineInformation;	/* TIP #280 */
 
     /*
      * We are only interested in compiling simple regexp cases. Currently
@@ -2121,11 +2119,11 @@
 	len = varTokenPtr[1].size;
 	if ((len == 2) && (str[0] == '-') && (str[1] == '-')) {
 	    sawLast++;
 	    i++;
 	    break;
-	} else if ((len > 1) && (strncmp(str,"-nocase", len) == 0)) {
+	} else if ((len > 1) && (strncmp(str, "-nocase", len) == 0)) {
 	    nocase = 1;
 	} else {
 	    /*
 	     * Not an option we recognize.
 	     */
@@ -2268,12 +2266,11 @@
     DefineLineInformation;	/* TIP #280 */
     Tcl_Token *tokenPtr, *stringTokenPtr;
     Tcl_Obj *patternObj = NULL, *replacementObj = NULL;
     Tcl_DString pattern;
     const char *bytes;
-    int exact, quantified, result = TCL_ERROR;
-    size_t len;
+    int len, exact, quantified, result = TCL_ERROR;
 
     if (parsePtr->numWords < 5 || parsePtr->numWords > 6) {
 	return TCL_ERROR;
     }
 
@@ -2347,11 +2344,11 @@
 		 * OK, we've proved there are no metacharacters except for the
 		 * '*' at each end.
 		 */
 
 		len = Tcl_DStringLength(&pattern) - 2;
-		if (len + 2 > 2) {
+		if (len > 0) {
 		    goto isSimpleGlob;
 		}
 
 		/*
 		 * The pattern is "**"! I believe that should be impossible,
@@ -2634,11 +2631,11 @@
 TclCompileSyntaxError(
     Tcl_Interp *interp,
     CompileEnv *envPtr)
 {
     Tcl_Obj *msg = Tcl_GetObjResult(interp);
-    size_t numBytes;
+    int numBytes;
     const char *bytes = TclGetStringFromObj(msg, &numBytes);
 
     TclErrorStackResetIf(interp, bytes, numBytes);
     TclEmitPush(TclRegisterLiteral(envPtr, bytes, numBytes, 0), envPtr);
     CompileReturnInternal(envPtr, INST_SYNTAX, TCL_ERROR, 0,
@@ -2862,12 +2859,11 @@
     Tcl_Token *varTokenPtr,	/* Token representing the variable name */
     CompileEnv *envPtr)		/* Holds resulting instructions. */
 {
     Tcl_Obj *tailPtr;
     const char *tailName, *p;
-    int n = varTokenPtr->numComponents;
-    size_t len;
+    int len, n = varTokenPtr->numComponents;
     Tcl_Token *lastTokenPtr;
     int full, localIndex;
 
     /*
      * Determine if the tail is (a) known at compile time, and (b) not an

Index: generic/tclCompCmdsSZ.c
==================================================================
--- generic/tclCompCmdsSZ.c
+++ generic/tclCompCmdsSZ.c
@@ -257,11 +257,11 @@
 		folded = obj;
 	    }
 	} else {
 	    Tcl_DecrRefCount(obj);
 	    if (folded) {
-		size_t len;
+		int len;
 		const char *bytes = TclGetStringFromObj(folded, &len);
 
 		PushLiteral(envPtr, bytes, len);
 		Tcl_DecrRefCount(folded);
 		folded = NULL;
@@ -275,11 +275,11 @@
 	    }
 	}
 	wordTokenPtr = TokenAfter(wordTokenPtr);
     }
     if (folded) {
-	size_t len;
+	int len;
 	const char *bytes = TclGetStringFromObj(folded, &len);
 
 	PushLiteral(envPtr, bytes, len);
 	Tcl_DecrRefCount(folded);
 	folded = NULL;
@@ -801,12 +801,11 @@
 				 * compiled. */
     CompileEnv *envPtr)		/* Holds resulting instructions. */
 {
     DefineLineInformation;	/* TIP #280 */
     Tcl_Token *tokenPtr;
-	size_t length;
-    int i, exactMatch = 0, nocase = 0;
+    int i, length, exactMatch = 0, nocase = 0;
     const char *str;
 
     if (parsePtr->numWords < 3 || parsePtr->numWords > 4) {
 	return TCL_ERROR;
     }
@@ -899,13 +898,13 @@
 	 * something with backslashes). Just push the actual character (not
 	 * byte) length.
 	 */
 
 	char buf[TCL_INTEGER_SPACE];
-	size_t len = Tcl_GetCharLength(objPtr);
+	int len = Tcl_GetCharLength(objPtr);
 
-	len = sprintf(buf, "%" TCL_Z_MODIFIER "d", len);
+	len = sprintf(buf, "%d", len);
 	PushLiteral(envPtr, buf, len);
     } else {
 	SetLineInformation(1);
 	CompileTokens(envPtr, tokenPtr, interp);
 	TclEmitOpcode(INST_STR_LEN, envPtr);
@@ -924,13 +923,12 @@
     CompileEnv *envPtr)		/* Holds resulting instructions. */
 {
     DefineLineInformation;	/* TIP #280 */
     Tcl_Token *mapTokenPtr, *stringTokenPtr;
     Tcl_Obj *mapObj, **objv;
-    char *bytes;
+    const char *bytes;
     int len;
-    size_t slen;
 
     /*
      * We only handle the case:
      *
      *    string map {foo bar} $thing
@@ -962,17 +960,17 @@
      * Now issue the opcodes. Note that in the case that we know that the
      * first word is an empty word, we don't issue the map at all. That is the
      * correct semantics for mapping.
      */
 
-    bytes = TclGetStringFromObj(objv[0], &slen);
-    if (slen == 0) {
+    bytes = TclGetStringFromObj(objv[0], &len);
+    if (len == 0) {
 	CompileWord(envPtr, stringTokenPtr, interp, 2);
     } else {
-	PushLiteral(envPtr, bytes, slen);
-	bytes = TclGetStringFromObj(objv[1], &slen);
-	PushLiteral(envPtr, bytes, slen);
+	PushLiteral(envPtr, bytes, len);
+	bytes = TclGetStringFromObj(objv[1], &len);
+	PushLiteral(envPtr, bytes, len);
 	CompileWord(envPtr, stringTokenPtr, interp, 2);
 	OP(STR_MAP);
     }
     Tcl_DecrRefCount(mapObj);
     return TCL_OK;
@@ -1527,11 +1525,11 @@
 
 void
 TclSubstCompile(
     Tcl_Interp *interp,
     const char *bytes,
-    size_t numBytes,
+    int numBytes,
     int flags,
     int line,
     CompileEnv *envPtr)
 {
     Tcl_Token *endTokenPtr, *tokenPtr;
@@ -1558,12 +1556,11 @@
 	count++;
     }
 
     for (endTokenPtr = tokenPtr + parse.numTokens;
 	    tokenPtr < endTokenPtr; tokenPtr = TokenAfter(tokenPtr)) {
-	size_t length;
-	int literal, catchRange, breakJump;
+	int length, literal, catchRange, breakJump;
 	char buf[4] = "";
 	JumpFixup startFixup, okFixup, returnFixup, breakFixup;
 	JumpFixup continueFixup, otherFixup, endFixup;
 
 	switch (tokenPtr->type) {
@@ -1590,12 +1587,11 @@
 	     * code. Note that the first component of TCL_TOKEN_VARIABLE is
 	     * always TCL_TOKEN_TEXT...
 	     */
 
 	    if (tokenPtr->numComponents > 1) {
-		size_t i;
-		int foundCommand = 0;
+		int i, foundCommand = 0;
 
 		for (i=2 ; i<=tokenPtr->numComponents ; i++) {
 		    if (tokenPtr[i].type == TCL_TOKEN_COMMAND) {
 			foundCommand = 1;
 			break;
@@ -1630,12 +1626,12 @@
 	    breakOffset = CurrentOffset(envPtr);
 	    TclEmitInstInt4(INST_JUMP4, 0, envPtr);
 
 	    /* Start */
 	    if (TclFixupForwardJumpToHere(envPtr, &startFixup, 127)) {
-		Tcl_Panic("TclCompileSubstCmd: bad start jump distance %" TCL_Z_MODIFIER "d",
-			CurrentOffset(envPtr) - startFixup.codeOffset);
+		Tcl_Panic("TclCompileSubstCmd: bad start jump distance %d",
+			(int) (CurrentOffset(envPtr) - startFixup.codeOffset));
 	    }
 	}
 
 	envPtr->line = bline;
 	catchRange = TclCreateExceptRange(CATCH_EXCEPTION_RANGE, envPtr);
@@ -1689,12 +1685,12 @@
 	TclEmitForwardJump(envPtr, TCL_UNCONDITIONAL_JUMP, &otherFixup);
 
 	TclAdjustStackDepth(1, envPtr);
 	/* BREAK destination */
 	if (TclFixupForwardJumpToHere(envPtr, &breakFixup, 127)) {
-	    Tcl_Panic("TclCompileSubstCmd: bad break jump distance %" TCL_Z_MODIFIER "d",
-		    CurrentOffset(envPtr) - breakFixup.codeOffset);
+	    Tcl_Panic("TclCompileSubstCmd: bad break jump distance %d",
+		    (int) (CurrentOffset(envPtr) - breakFixup.codeOffset));
 	}
 	OP(	POP);
 	OP(	POP);
 
 	breakJump = CurrentOffset(envPtr) - breakOffset;
@@ -1705,26 +1701,26 @@
 	}
 
 	TclAdjustStackDepth(2, envPtr);
 	/* CONTINUE destination */
 	if (TclFixupForwardJumpToHere(envPtr, &continueFixup, 127)) {
-	    Tcl_Panic("TclCompileSubstCmd: bad continue jump distance %" TCL_Z_MODIFIER "d",
-		    CurrentOffset(envPtr) - continueFixup.codeOffset);
+	    Tcl_Panic("TclCompileSubstCmd: bad continue jump distance %d",
+		    (int) (CurrentOffset(envPtr) - continueFixup.codeOffset));
 	}
 	OP(	POP);
 	OP(	POP);
 	TclEmitForwardJump(envPtr, TCL_UNCONDITIONAL_JUMP, &endFixup);
 
 	TclAdjustStackDepth(2, envPtr);
 	/* RETURN + other destination */
 	if (TclFixupForwardJumpToHere(envPtr, &returnFixup, 127)) {
-	    Tcl_Panic("TclCompileSubstCmd: bad return jump distance %" TCL_Z_MODIFIER "d",
-		    CurrentOffset(envPtr) - returnFixup.codeOffset);
+	    Tcl_Panic("TclCompileSubstCmd: bad return jump distance %d",
+		    (int) (CurrentOffset(envPtr) - returnFixup.codeOffset));
 	}
 	if (TclFixupForwardJumpToHere(envPtr, &otherFixup, 127)) {
-	    Tcl_Panic("TclCompileSubstCmd: bad other jump distance %" TCL_Z_MODIFIER "d",
-		    CurrentOffset(envPtr) - otherFixup.codeOffset);
+	    Tcl_Panic("TclCompileSubstCmd: bad other jump distance %d",
+		    (int) (CurrentOffset(envPtr) - otherFixup.codeOffset));
 	}
 
 	/*
 	 * Pull the result to top of stack, discard options dict.
 	 */
@@ -1732,22 +1728,22 @@
 	OP4(	REVERSE, 2);
 	OP(	POP);
 
 	/* OK destination */
 	if (TclFixupForwardJumpToHere(envPtr, &okFixup, 127)) {
-	    Tcl_Panic("TclCompileSubstCmd: bad ok jump distance %" TCL_Z_MODIFIER "d",
-		    CurrentOffset(envPtr) - okFixup.codeOffset);
+	    Tcl_Panic("TclCompileSubstCmd: bad ok jump distance %d",
+		    (int) (CurrentOffset(envPtr) - okFixup.codeOffset));
 	}
 	if (count > 1) {
 	    OP1(STR_CONCAT1, count);
 	    count = 1;
 	}
 
 	/* CONTINUE jump to here */
 	if (TclFixupForwardJumpToHere(envPtr, &endFixup, 127)) {
-	    Tcl_Panic("TclCompileSubstCmd: bad end jump distance %" TCL_Z_MODIFIER "d",
-		    CurrentOffset(envPtr) - endFixup.codeOffset);
+	    Tcl_Panic("TclCompileSubstCmd: bad end jump distance %d",
+		    (int) (CurrentOffset(envPtr) - endFixup.codeOffset));
 	}
 	bline = envPtr->line;
     }
 
     while (count > 255) {
@@ -1864,12 +1860,12 @@
      * them, so we punt if we *might* encounter them as that is the easiest
      * way of emulating the behaviour).
      */
 
     for (; numWords>=3 ; tokenPtr=TokenAfter(tokenPtr),numWords--) {
-	register size_t size = tokenPtr[1].size;
-	register const char *chrs = tokenPtr[1].start;
+	unsigned size = tokenPtr[1].size;
+	const char *chrs = tokenPtr[1].start;
 
 	/*
 	 * We only process literal options, and we assume that -e, -g and -n
 	 * are unique prefixes of -exact, -glob and -nocase respectively (true
 	 * at time of writing). Note that -exact and -glob may only be given
@@ -1955,11 +1951,11 @@
      * available at this point, this is pretty easy.
      */
 
     if (numWords == 1) {
 	const char *bytes;
-	size_t maxLen, numBytes;
+	int maxLen, numBytes;
 	int bline;		/* TIP #280: line of the pattern/action list,
 				 * and start of list for when tracking the
 				 * location. This list comes immediately after
 				 * the value we switch on. */
 
@@ -1972,14 +1968,14 @@
 	/* Allocate enough space to work in. */
 	maxLen = TclMaxListLength(bytes, numBytes, NULL);
 	if (maxLen < 2)  {
 	    return TCL_ERROR;
 	}
-	bodyTokenArray = Tcl_Alloc(sizeof(Tcl_Token) * maxLen);
-	bodyToken = Tcl_Alloc(sizeof(Tcl_Token *) * maxLen);
-	bodyLines = Tcl_Alloc(sizeof(int) * maxLen);
-	bodyContLines = Tcl_Alloc(sizeof(int*) * maxLen);
+	bodyTokenArray = ckalloc(sizeof(Tcl_Token) * maxLen);
+	bodyToken = ckalloc(sizeof(Tcl_Token *) * maxLen);
+	bodyLines = ckalloc(sizeof(int) * maxLen);
+	bodyContLines = ckalloc(sizeof(int*) * maxLen);
 
 	bline = mapPtr->loc[eclIndex].line[valueIndex+1];
 	numWords = 0;
 
 	while (numBytes > 0) {
@@ -2013,14 +2009,14 @@
 	    numBytes -= (bytes - prevBytes);
 	    numWords++;
 	}
 	if (numWords % 2) {
 	abort:
-	    Tcl_Free(bodyToken);
-	    Tcl_Free(bodyTokenArray);
-	    Tcl_Free(bodyLines);
-	    Tcl_Free(bodyContLines);
+	    ckfree(bodyToken);
+	    ckfree(bodyTokenArray);
+	    ckfree(bodyLines);
+	    ckfree(bodyContLines);
 	    return TCL_ERROR;
 	}
     } else if (numWords % 2 || numWords == 0) {
 	/*
 	 * Odd number of words (>1) available, or no words at all available.
@@ -2034,13 +2030,13 @@
     } else {
 	/*
 	 * Multi-word definition of patterns & actions.
 	 */
 
-	bodyToken = Tcl_Alloc(sizeof(Tcl_Token *) * numWords);
-	bodyLines = Tcl_Alloc(sizeof(int) * numWords);
-	bodyContLines = Tcl_Alloc(sizeof(int*) * numWords);
+	bodyToken = ckalloc(sizeof(Tcl_Token *) * numWords);
+	bodyLines = ckalloc(sizeof(int) * numWords);
+	bodyContLines = ckalloc(sizeof(int*) * numWords);
 	bodyTokenArray = NULL;
 	for (i=0 ; i<numWords ; i++) {
 	    /*
 	     * We only handle the very simplest case. Anything more complex is
 	     * a good reason to go to the interpreted case anyway due to
@@ -2095,15 +2091,15 @@
     /*
      * Clean up all our temporary space and return.
      */
 
   freeTemporaries:
-    Tcl_Free(bodyToken);
-    Tcl_Free(bodyLines);
-    Tcl_Free(bodyContLines);
+    ckfree(bodyToken);
+    ckfree(bodyLines);
+    ckfree(bodyContLines);
     if (bodyTokenArray != NULL) {
-	Tcl_Free(bodyTokenArray);
+	ckfree(bodyTokenArray);
     }
     return result;
 }
 
 /*
@@ -2400,11 +2396,11 @@
      * such is stored in an auxData block.
      *
      * Start by allocating the jump table itself, plus some workspace.
      */
 
-    jtPtr = Tcl_Alloc(sizeof(JumptableInfo));
+    jtPtr = ckalloc(sizeof(JumptableInfo));
     Tcl_InitHashTable(&jtPtr->hashTable, TCL_STRING_KEYS);
     infoIndex = TclCreateAuxData(jtPtr, &tclJumptableInfoType, envPtr);
     finalFixups = TclStackAlloc(interp, sizeof(int) * (numBodyTokens/2));
     foundDefault = 0;
     mustGenerate = 1;
@@ -2572,11 +2568,11 @@
 static ClientData
 DupJumptableInfo(
     ClientData clientData)
 {
     JumptableInfo *jtPtr = clientData;
-    JumptableInfo *newJtPtr = Tcl_Alloc(sizeof(JumptableInfo));
+    JumptableInfo *newJtPtr = ckalloc(sizeof(JumptableInfo));
     Tcl_HashEntry *hPtr, *newHPtr;
     Tcl_HashSearch search;
     int isNew;
 
     Tcl_InitHashTable(&newJtPtr->hashTable, TCL_STRING_KEYS);
@@ -2594,21 +2590,21 @@
     ClientData clientData)
 {
     JumptableInfo *jtPtr = clientData;
 
     Tcl_DeleteHashTable(&jtPtr->hashTable);
-    Tcl_Free(jtPtr);
+    ckfree(jtPtr);
 }
 
 static void
 PrintJumptableInfo(
     ClientData clientData,
     Tcl_Obj *appendObj,
     ByteCode *codePtr,
     unsigned int pcOffset)
 {
-    register JumptableInfo *jtPtr = clientData;
+    JumptableInfo *jtPtr = clientData;
     Tcl_HashEntry *hPtr;
     Tcl_HashSearch search;
     const char *keyPtr;
     int offset, i = 0;
 
@@ -2633,11 +2629,11 @@
     ClientData clientData,
     Tcl_Obj *dictObj,
     ByteCode *codePtr,
     unsigned int pcOffset)
 {
-    register JumptableInfo *jtPtr = clientData;
+    JumptableInfo *jtPtr = clientData;
     Tcl_Obj *mapping = Tcl_NewObj();
     Tcl_HashEntry *hPtr;
     Tcl_HashSearch search;
     const char *keyPtr;
     int offset;
@@ -2935,11 +2931,11 @@
 		    || (objc > 2)) {
 		TclDecrRefCount(tmpObj);
 		goto failedToCompile;
 	    }
 	    if (objc > 0) {
-		size_t len;
+		int len;
 		const char *varname = TclGetStringFromObj(objv[0], &len);
 
 		resultVarIndices[i] = LocalScalar(varname, len, envPtr);
 		if (resultVarIndices[i] < 0) {
 		    TclDecrRefCount(tmpObj);
@@ -2947,11 +2943,11 @@
 		}
 	    } else {
 		resultVarIndices[i] = -1;
 	    }
 	    if (objc == 2) {
-		size_t len;
+		int len;
 		const char *varname = TclGetStringFromObj(objv[1], &len);
 
 		optionVarIndices[i] = LocalScalar(varname, len, envPtr);
 		if (optionVarIndices[i] < 0) {
 		    TclDecrRefCount(tmpObj);
@@ -3066,11 +3062,10 @@
     Tcl_Token **handlerTokens)
 {
     DefineLineInformation;	/* TIP #280 */
     int range, resultVar, optionsVar;
     int i, j, len, forwardsNeedFixing = 0, trapZero = 0, afterBody = 0;
-    size_t slen;
     int *addrsToFix, *forwardsToFix, notCodeJumpSource, notECJumpSource;
     int *noError;
     char buf[TCL_INTEGER_SPACE];
 
     resultVar = AnonymousLocal(envPtr);
@@ -3152,12 +3147,12 @@
 	    LOAD(			optionsVar);
 	    PUSH(			"-errorcode");
 	    OP4(			DICT_GET, 1);
 	    TclAdjustStackDepth(-1, envPtr);
 	    OP44(			LIST_RANGE_IMM, 0, len-1);
-	    p = TclGetStringFromObj(matchClauses[i], &slen);
-	    PushLiteral(envPtr, p, slen);
+	    p = TclGetStringFromObj(matchClauses[i], &len);
+	    PushLiteral(envPtr, p, len);
 	    OP(				STR_EQ);
 	    JUMP4(			JUMP_FALSE, notECJumpSource);
 	} else {
 	    notECJumpSource = -1; /* LINT */
 	}
@@ -3280,11 +3275,10 @@
     DefineLineInformation;	/* TIP #280 */
     int range, resultVar, optionsVar, i, j, len, forwardsNeedFixing = 0;
     int trapZero = 0, afterBody = 0, finalOK, finalError, noFinalError;
     int *addrsToFix, *forwardsToFix, notCodeJumpSource, notECJumpSource;
     char buf[TCL_INTEGER_SPACE];
-    size_t slen;
 
     resultVar = AnonymousLocal(envPtr);
     optionsVar = AnonymousLocal(envPtr);
     if (resultVar < 0 || optionsVar < 0) {
 	return TCL_ERROR;
@@ -3364,12 +3358,12 @@
 	    LOAD(			optionsVar);
 	    PUSH(			"-errorcode");
 	    OP4(			DICT_GET, 1);
 	    TclAdjustStackDepth(-1, envPtr);
 	    OP44(			LIST_RANGE_IMM, 0, len-1);
-	    p = TclGetStringFromObj(matchClauses[i], &slen);
-	    PushLiteral(envPtr, p, slen);
+	    p = TclGetStringFromObj(matchClauses[i], &len);
+	    PushLiteral(envPtr, p, len);
 	    OP(				STR_EQ);
 	    JUMP4(			JUMP_FALSE, notECJumpSource);
 	} else {
 	    notECJumpSource = -1; /* LINT */
 	}
@@ -3690,11 +3684,11 @@
 	    }
 	    return TCL_ERROR;
 	}
 	if (varCount == 0) {
 	    const char *bytes;
-	    size_t len;
+	    int len;
 
 	    bytes = TclGetStringFromObj(leadingWord, &len);
 	    if (i == 1 && len == 11 && !strncmp("-nocomplain", bytes, 11)) {
 		flags = 0;
 		haveFlags++;

Index: generic/tclCompExpr.c
==================================================================
--- generic/tclCompExpr.c
+++ generic/tclCompExpr.c
@@ -20,11 +20,11 @@
  * expression in the form of a tree of operators, a list of literals, a list
  * of function names, and an array of Tcl_Token's within a Tcl_Parse struct.
  * The tree is composed of OpNodes.
  */
 
-typedef struct {
+typedef struct OpNode {
     int left;			/* "Pointer" to the left operand. */
     int right;			/* "Pointer" to the right operand. */
     union {
 	int parent;		/* "Pointer" to the parent operand. */
 	int prev;		/* "Pointer" joining incomplete tree stack */
@@ -507,20 +507,20 @@
 
 static void		CompileExprTree(Tcl_Interp *interp, OpNode *nodes,
 			    int index, Tcl_Obj *const **litObjvPtr,
 			    Tcl_Obj *const *funcObjv, Tcl_Token *tokenPtr,
 			    CompileEnv *envPtr, int optimize);
-static void		ConvertTreeToTokens(const char *start, size_t numBytes,
+static void		ConvertTreeToTokens(const char *start, int numBytes,
 			    OpNode *nodes, Tcl_Token *tokenPtr,
 			    Tcl_Parse *parsePtr);
 static int		ExecConstantExprTree(Tcl_Interp *interp, OpNode *nodes,
 			    int index, Tcl_Obj * const **litObjvPtr);
 static int		ParseExpr(Tcl_Interp *interp, const char *start,
-			    size_t numBytes, OpNode **opTreePtr,
+			    int numBytes, OpNode **opTreePtr,
 			    Tcl_Obj *litList, Tcl_Obj *funcList,
 			    Tcl_Parse *parsePtr, int parseOnly);
-static size_t		ParseLexeme(const char *start, size_t numBytes,
+static int		ParseLexeme(const char *start, int numBytes,
 			    unsigned char *lexemePtr, Tcl_Obj **literalPtr);
 
 /*
  *----------------------------------------------------------------------
  *
@@ -542,11 +542,11 @@
  *	message is written to interp.
  *
  * Side effects:
  *	Memory will be allocated. If TCL_OK is returned, the caller must clean
  *	up the returned data structures. The (OpNode *) value written to
- *	opTreePtr should be passed to Tcl_Free() and the parsePtr argument
+ *	opTreePtr should be passed to ckfree() and the parsePtr argument
  *	should be passed to Tcl_FreeParse(). The elements appended to the
  *	litList and funcList will automatically be freed whenever the refcount
  *	on those lists indicates they can be freed.
  *
  *----------------------------------------------------------------------
@@ -554,11 +554,11 @@
 
 static int
 ParseExpr(
     Tcl_Interp *interp,		/* Used for error reporting. */
     const char *start,		/* Start of source string to parse. */
-    size_t numBytes,		/* Number of bytes in string. */
+    int numBytes,		/* Number of bytes in string. */
     OpNode **opTreePtr,		/* Points to space where a pointer to the
 				 * allocated OpNode tree should go. */
     Tcl_Obj *litList,		/* List to append literals to. */
     Tcl_Obj *funcList,		/* List to append function names to. */
     Tcl_Parse *parsePtr,	/* Structure to fill with tokens representing
@@ -577,11 +577,11 @@
 				 * cost of only about 1 kibyte, and is large
 				 * enough for most expressions to parse with
 				 * no need for array growth and
 				 * reallocation. */
     unsigned int nodesUsed = 0;	/* Number of OpNodes filled. */
-    size_t scanned = 0;		/* Capture number of byte scanned by parsing
+    int scanned = 0;		/* Capture number of byte scanned by parsing
 				 * routines. */
     int lastParsed;		/* Stores info about what the lexeme parsed
 				 * the previous pass through the parsing loop
 				 * was. If it was an operator, lastParsed is
 				 * the index of the OpNode for that operator.
@@ -621,19 +621,19 @@
 				 * into the string being parsed to aid in
 				 * pinpointing the location of the syntax
 				 * error in the expression. */
     int insertMark = 0;		/* A boolean controlling whether the "mark"
 				 * should be inserted. */
-    const unsigned limit = 25;	/* Portions of the error message are
+    const int limit = 25;	/* Portions of the error message are
 				 * constructed out of substrings of the
 				 * original expression. In order to keep the
 				 * error message readable, we impose this
 				 * limit on the substring size we extract. */
 
     TclParseInit(interp, start, numBytes, parsePtr);
 
-    nodes = Tcl_AttemptAlloc(nodesAvailable * sizeof(OpNode));
+    nodes = attemptckalloc(nodesAvailable * sizeof(OpNode));
     if (nodes == NULL) {
 	TclNewLiteralStringObj(msg, "not enough memory to parse expression");
 	errCode = "NOMEM";
 	goto error;
     }
@@ -673,11 +673,11 @@
 	    unsigned int size = nodesUsed * 2;
 	    OpNode *newPtr = NULL;
 
 	    do {
 	      if (size <= UINT_MAX/sizeof(OpNode)) {
-		newPtr = Tcl_AttemptRealloc(nodes, size * sizeof(OpNode));
+		newPtr = attemptckrealloc(nodes, size * sizeof(OpNode));
 	      }
 	    } while ((newPtr == NULL)
 		    && ((size -= (size - nodesUsed) / 2) > nodesUsed));
 	    if (newPtr == NULL) {
 		TclNewLiteralStringObj(msg,
@@ -708,16 +708,16 @@
 	    int b;
 
 	    switch (lexeme) {
 	    case INVALID:
 		msg = Tcl_ObjPrintf("invalid character \"%.*s\"",
-			(int)scanned, start);
+			scanned, start);
 		errCode = "BADCHAR";
 		goto error;
 	    case INCOMPLETE:
 		msg = Tcl_ObjPrintf("incomplete operator \"%.*s\"",
-			(int)scanned, start);
+			scanned, start);
 		errCode = "PARTOP";
 		goto error;
 	    case BAREWORD:
 
 		/*
@@ -742,20 +742,20 @@
 		} else if (Tcl_GetBooleanFromObj(NULL,literal,&b) == TCL_OK) {
 		    lexeme = BOOLEAN;
 		} else {
 		    Tcl_DecrRefCount(literal);
 		    msg = Tcl_ObjPrintf("invalid bareword \"%.*s%s\"",
-			    (scanned < limit) ? (int)scanned : (int)limit - 3, start,
+			    (scanned < limit) ? scanned : limit - 3, start,
 			    (scanned < limit) ? "" : "...");
 		    post = Tcl_ObjPrintf(
 			    "should be \"$%.*s%s\" or \"{%.*s%s}\"",
-			    (scanned < limit) ? (int)scanned : (int)limit - 3,
+			    (scanned < limit) ? scanned : limit - 3,
 			    start, (scanned < limit) ? "" : "...",
-			    (scanned < limit) ? (int)scanned : (int)limit - 3,
+			    (scanned < limit) ? scanned : limit - 3,
 			    start, (scanned < limit) ? "" : "...");
 		    Tcl_AppendPrintfToObj(post, " or \"%.*s%s(...)\" or ...",
-			    (scanned < limit) ? (int)scanned : (int)limit - 3,
+			    (scanned < limit) ? scanned : limit - 3,
 			    start, (scanned < limit) ? "" : "...");
 		    errCode = "BAREWORD";
 		    if (start[0] == '0') {
 			const char *stop;
 			TclParseNumber(NULL, NULL, NULL, start, scanned,
@@ -1383,11 +1383,11 @@
     /*
      * Free any partial parse tree we've built.
      */
 
     if (nodes != NULL) {
-	Tcl_Free(nodes);
+	ckfree(nodes);
     }
 
     if (interp == NULL) {
 	/*
 	 * Nowhere to report an error message, so just free it.
@@ -1412,17 +1412,17 @@
 	 */
 
 	Tcl_AppendPrintfToObj(msg, "\nin expression \"%s%.*s%.*s%s%s%.*s%s\"",
 		((start - limit) < parsePtr->string) ? "" : "...",
 		((start - limit) < parsePtr->string)
-			? (int) (start - parsePtr->string) : (int)limit - 3,
+			? (int) (start - parsePtr->string) : limit - 3,
 		((start - limit) < parsePtr->string)
 			? parsePtr->string : start - limit + 3,
-		(scanned < limit) ? (int)scanned : (int)limit - 3, start,
+		(scanned < limit) ? scanned : limit - 3, start,
 		(scanned < limit) ? "" : "...", insertMark ? mark : "",
 		(start + scanned + limit > parsePtr->end)
-			? (int) (parsePtr->end - start) - (int)scanned : (int)limit-3,
+			? (int) (parsePtr->end - start) - scanned : limit-3,
 		start + scanned,
 		(start + scanned + limit > parsePtr->end) ? "" : "...");
 
 	/*
 	 * Next, append any postscript message.
@@ -1440,11 +1440,11 @@
 	 */
 
 	numBytes = parsePtr->end - parsePtr->string;
 	Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 		"\n    (parsing expression \"%.*s%s\")",
-		(numBytes < limit) ? (int)numBytes : (int)limit - 3,
+		(numBytes < limit) ? numBytes : limit - 3,
 		parsePtr->string, (numBytes < limit) ? "" : "..."));
 	if (errCode) {
 	    Tcl_SetErrorCode(interp, "TCL", "PARSE", "EXPR", errCode,
 		    subErrCode, NULL);
 	}
@@ -1477,11 +1477,11 @@
  */
 
 static void
 ConvertTreeToTokens(
     const char *start,
-    size_t numBytes,
+    int numBytes,
     OpNode *nodes,
     Tcl_Token *tokenPtr,
     Tcl_Parse *parsePtr)
 {
     int subExprTokenIdx = 0;
@@ -1566,11 +1566,11 @@
 		 */
 
 		TclGrowParseTokenArray(parsePtr, toCopy);
 		subExprTokenPtr = parsePtr->tokenPtr + parsePtr->numTokens;
 		memcpy(subExprTokenPtr, tokenPtr,
-			toCopy * sizeof(Tcl_Token));
+			(size_t) toCopy * sizeof(Tcl_Token));
 		subExprTokenPtr->type = TCL_TOKEN_SUB_EXPR;
 		parsePtr->numTokens += toCopy;
 	    } else {
 		/*
 		 * Multiple element word. Create a TCL_TOKEN_SUB_EXPR token to
@@ -1583,11 +1583,11 @@
 		*subExprTokenPtr = *tokenPtr;
 		subExprTokenPtr->type = TCL_TOKEN_SUB_EXPR;
 		subExprTokenPtr->numComponents++;
 		subExprTokenPtr++;
 		memcpy(subExprTokenPtr, tokenPtr,
-			toCopy * sizeof(Tcl_Token));
+			(size_t) toCopy * sizeof(Tcl_Token));
 		parsePtr->numTokens += toCopy + 1;
 	    }
 
 	    scanned = tokenPtr->start + tokenPtr->size - start;
 	    start += scanned;
@@ -1825,11 +1825,11 @@
 
 int
 Tcl_ParseExpr(
     Tcl_Interp *interp,		/* Used for error reporting. */
     const char *start,		/* Start of source string to parse. */
-    size_t numBytes,		/* Number of bytes in string. If -1, the
+    int numBytes,		/* Number of bytes in string. If < 0, the
 				 * string consists of all bytes up to the
 				 * first null character. */
     Tcl_Parse *parsePtr)	/* Structure to fill with information about
 				 * the parsed expression; any previous
 				 * information in the structure is ignored. */
@@ -1839,11 +1839,11 @@
     Tcl_Obj *litList = Tcl_NewObj();	/* List to hold the literals. */
     Tcl_Obj *funcList = Tcl_NewObj();	/* List to hold the functon names. */
     Tcl_Parse *exprParsePtr = TclStackAlloc(interp, sizeof(Tcl_Parse));
 				/* Holds the Tcl_Tokens of substitutions. */
 
-    if (numBytes == TCL_AUTO_LENGTH) {
+    if (numBytes < 0) {
 	numBytes = (start ? strlen(start) : 0);
     }
 
     code = ParseExpr(interp, start, numBytes, &opTree, litList, funcList,
 	    exprParsePtr, 1 /* parseOnly */);
@@ -1859,11 +1859,11 @@
 	parsePtr->errorType = exprParsePtr->errorType;
     }
 
     Tcl_FreeParse(exprParsePtr);
     TclStackFree(interp, exprParsePtr);
-    Tcl_Free(opTree);
+    ckfree(opTree);
     return code;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1880,20 +1880,21 @@
  *	Code identifying lexeme parsed is writen to *lexemePtr.
  *
  *----------------------------------------------------------------------
  */
 
-static size_t
+static int
 ParseLexeme(
     const char *start,		/* Start of lexeme to parse. */
-    size_t numBytes,		/* Number of bytes in string. */
+    int numBytes,		/* Number of bytes in string. */
     unsigned char *lexemePtr,	/* Write code of parsed lexeme to this
 				 * storage. */
     Tcl_Obj **literalPtr)	/* Write corresponding literal value to this
 				   storage, if non-NULL. */
 {
     const char *end;
+    int scanned;
     Tcl_UniChar ch = 0;
     Tcl_Obj *literal = NULL;
     unsigned char byte;
 
     if (numBytes == 0) {
@@ -2097,11 +2098,10 @@
      * Might be inspired by reserved identifier rules in C, which of course
      * have no direct relevance here.
      */
 
     if (!TclIsBareword(*start) || *start == '_') {
-	size_t scanned;
 	if (Tcl_UtfCharComplete(start, numBytes)) {
 	    scanned = TclUtfToUniChar(start, &ch);
 	} else {
 	    char utfBytes[4];
 
@@ -2147,11 +2147,11 @@
 
 void
 TclCompileExpr(
     Tcl_Interp *interp,		/* Used for error reporting. */
     const char *script,		/* The source script to compile. */
-    size_t numBytes,		/* Number of bytes in script. */
+    int numBytes,		/* Number of bytes in script. */
     CompileEnv *envPtr,		/* Holds resulting instructions. */
     int optimize)		/* 0 for one-off expressions. */
 {
     OpNode *opTree = NULL;	/* Will point to the tree of operators */
     Tcl_Obj *litList = Tcl_NewObj();	/* List to hold the literals */
@@ -2185,11 +2185,11 @@
 
     Tcl_FreeParse(parsePtr);
     TclStackFree(interp, parsePtr);
     Tcl_DecrRefCount(funcList);
     Tcl_DecrRefCount(litList);
-    Tcl_Free(opTree);
+    ckfree(opTree);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -2295,11 +2295,11 @@
 
 	    switch (nodePtr->lexeme) {
 	    case FUNCTION: {
 		Tcl_DString cmdName;
 		const char *p;
-		size_t length;
+		int length;
 
 		Tcl_DStringInit(&cmdName);
 		TclDStringAppendLiteral(&cmdName, "tcl::mathfunc::");
 		p = TclGetStringFromObj(*funcObjv, &length);
 		funcObjv++;
@@ -2454,11 +2454,11 @@
 	case OT_LITERAL: {
 	    Tcl_Obj *const *litObjv = *litObjvPtr;
 	    Tcl_Obj *literal = *litObjv;
 
 	    if (optimize) {
-		size_t length;
+		int length;
 		const char *bytes = TclGetStringFromObj(literal, &length);
 		int index = TclRegisterLiteral(envPtr, bytes, length, 0);
 		Tcl_Obj *objPtr = TclFetchLiteral(envPtr, index);
 
 		if ((objPtr->typePtr == NULL) && (literal->typePtr != NULL)) {
@@ -2513,13 +2513,13 @@
 		     * already, then use it to share via the literal table.
 		     */
 
 		    if (TclHasStringRep(objPtr)) {
 			Tcl_Obj *tableValue;
-			size_t numBytes;
+			int numBytes;
 			const char *bytes
-				= TclGetStringFromObj(objPtr, &numBytes);
+				= Tcl_GetStringFromObj(objPtr, &numBytes);
 
 			index = TclRegisterLiteral(envPtr, bytes, numBytes, 0);
 			tableValue = TclFetchLiteral(envPtr, index);
 			if ((tableValue->typePtr == NULL) &&
 				(objPtr->typePtr != NULL)) {

Index: generic/tclCompile.c
==================================================================
--- generic/tclCompile.c
+++ generic/tclCompile.c
@@ -127,10 +127,14 @@
     {"jumpFalse1",	  2,   -1,         1,	{OPERAND_OFFSET1}},
 	/* Jump relative to (pc + op1) if stktop expr object is false */
     {"jumpFalse4",	  5,   -1,         1,	{OPERAND_OFFSET4}},
 	/* Jump relative to (pc + op4) if stktop expr object is false */
 
+    {"lor",		  1,   -1,         0,	{OPERAND_NONE}},
+	/* Logical or:	push (stknext || stktop) */
+    {"land",		  1,   -1,         0,	{OPERAND_NONE}},
+	/* Logical and:	push (stknext && stktop) */
     {"bitor",		  1,   -1,         0,	{OPERAND_NONE}},
 	/* Bitwise or:	push (stknext | stktop) */
     {"bitxor",		  1,   -1,         0,	{OPERAND_NONE}},
 	/* Bitwise xor	push (stknext ^ stktop) */
     {"bitand",		  1,   -1,         0,	{OPERAND_NONE}},
@@ -167,18 +171,29 @@
 	/* Unary minus:	push -stktop */
     {"bitnot",		  1,   0,          0,	{OPERAND_NONE}},
 	/* Bitwise not:	push ~stktop */
     {"not",		  1,   0,          0,	{OPERAND_NONE}},
 	/* Logical not:	push !stktop */
+    {"callBuiltinFunc1",  2,   1,          1,	{OPERAND_UINT1}},
+	/* Call builtin math function with index op1; any args are on stk */
+    {"callFunc1",	  2,   INT_MIN,    1,	{OPERAND_UINT1}},
+	/* Call non-builtin func objv[0]; <objc,objv>=<op1,top op1> */
     {"tryCvtToNumeric",	  1,   0,          0,	{OPERAND_NONE}},
 	/* Try converting stktop to first int then double if possible. */
 
     {"break",		  1,   0,          0,	{OPERAND_NONE}},
 	/* Abort closest enclosing loop; if none, return TCL_BREAK code. */
     {"continue",	  1,   0,          0,	{OPERAND_NONE}},
 	/* Skip to next iteration of closest enclosing loop; if none, return
 	 * TCL_CONTINUE code. */
+
+    {"foreach_start4",	  5,   0,          1,	{OPERAND_AUX4}},
+	/* Initialize execution of a foreach loop. Operand is aux data index
+	 * of the ForeachInfo structure for the foreach command. */
+    {"foreach_step4",	  5,   +1,         1,	{OPERAND_AUX4}},
+	/* "Step" or begin next iteration of foreach loop. Push 0 if to
+	 * terminate loop, else push 1. */
 
     {"beginCatch4",	  5,   0,          1,	{OPERAND_UINT4}},
 	/* Record start of catch with the operand's exception index. Push the
 	 * current stack depth onto a special catch stack. */
     {"endCatch",	  1,   0,          0,	{OPERAND_NONE}},
@@ -323,10 +338,13 @@
 	 * managed correctly.
 	 * Stack:  ... dict => ... value key doneBool */
     {"dictNext",	  5,	+3,	   1,	{OPERAND_LVT4}},
 	/* Get the next iteration from the iterator in op4's local scalar.
 	 * Stack:  ... => ... value key doneBool */
+    {"dictDone",	  5,	0,	   1,	{OPERAND_LVT4}},
+	/* Terminate the iterator in op4's local scalar. Use unsetScalar
+	 * instead (with 0 for flags). */
     {"dictUpdateStart",   9,    0,	   2,	{OPERAND_LVT4, OPERAND_AUX4}},
 	/* Create the variables (described in the aux data referred to by the
 	 * second immediate argument) to mirror the state of the dictionary in
 	 * the variable referred to by the first immediate argument. The list
 	 * of keys (top of the stack, not popped) must be the same length as
@@ -692,11 +710,11 @@
 /*
  * TIP #280: Helper for building the per-word line information of all compiled
  * commands.
  */
 static void		EnterCmdWordData(ExtCmdLoc *eclPtr, int srcOffset,
-			    Tcl_Token *tokenPtr, const char *cmd,
+			    Tcl_Token *tokenPtr, const char *cmd, int len,
 			    int numWords, int line, int *clNext, int **lines,
 			    CompileEnv *envPtr);
 static void		ReleaseCmdWordData(ExtCmdLoc *eclPtr);
 
 /*
@@ -784,11 +802,12 @@
 	}
 	traceInitialized = 1;
     }
 #endif
 
-    stringPtr = TclGetStringFromObj(objPtr, &length);
+    stringPtr = TclGetString(objPtr);
+    length = objPtr->length;
 
     /*
      * 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.
@@ -850,12 +869,12 @@
     /*
      * Apply some peephole optimizations that can cross specific/generic
      * instruction generator boundaries.
      */
 
-    if (iPtr->optimizer) {
-	(iPtr->optimizer)(&compEnv);
+    if (iPtr->extra.optimizer) {
+	(iPtr->extra.optimizer)(&compEnv);
     }
 
     /*
      * Invoke the compilation hook procedure if one exists.
      */
@@ -969,11 +988,11 @@
  *----------------------------------------------------------------------
  */
 
 static void
 FreeByteCodeInternalRep(
-    register Tcl_Obj *objPtr)	/* Object whose internal rep to free. */
+    Tcl_Obj *objPtr)	/* Object whose internal rep to free. */
 {
     ByteCode *codePtr;
 
     ByteCodeGetIntRep(objPtr, &tclByteCodeType, codePtr);
     assert(codePtr != NULL);
@@ -1000,18 +1019,18 @@
  *----------------------------------------------------------------------
  */
 
 void
 TclPreserveByteCode(
-    register ByteCode *codePtr)
+    ByteCode *codePtr)
 {
     codePtr->refCount++;
 }
 
 void
 TclReleaseByteCode(
-    register ByteCode *codePtr)
+    ByteCode *codePtr)
 {
     if (codePtr->refCount-- > 1) {
 	return;
     }
 
@@ -1019,18 +1038,18 @@
     CleanupByteCode(codePtr);
 }
 
 static void
 CleanupByteCode(
-    register ByteCode *codePtr)	/* Points to the ByteCode to free. */
+    ByteCode *codePtr)	/* Points to the ByteCode to free. */
 {
     Tcl_Interp *interp = (Tcl_Interp *) *codePtr->interpHandle;
     Interp *iPtr = (Interp *) interp;
     int numLitObjects = codePtr->numLitObjects;
     int numAuxDataItems = codePtr->numAuxDataItems;
-    register Tcl_Obj **objArrayPtr, *objPtr;
-    register const AuxData *auxDataPtr;
+    Tcl_Obj **objArrayPtr, *objPtr;
+    const AuxData *auxDataPtr;
     int i;
 #ifdef TCL_COMPILE_STATS
 
     if (interp != NULL) {
 	ByteCodeStats *statsPtr;
@@ -1132,16 +1151,16 @@
 	    ReleaseCmdWordData(Tcl_GetHashValue(hePtr));
 	    Tcl_DeleteHashEntry(hePtr);
 	}
     }
 
-    if (codePtr->localCachePtr && (codePtr->localCachePtr->refCount-- <= 1)) {
+    if (codePtr->localCachePtr && (--codePtr->localCachePtr->refCount == 0)) {
 	TclFreeLocalCache(interp, codePtr->localCachePtr);
     }
 
     TclHandleRelease(codePtr->interpHandle);
-    Tcl_Free(codePtr);
+    ckfree(codePtr);
 }
 
 /*
  * ---------------------------------------------------------------------
  *
@@ -1322,11 +1341,11 @@
 	    codePtr = NULL;
 	}
     }
     if (codePtr == NULL) {
 	CompileEnv compEnv;
-	size_t numBytes;
+	int numBytes;
 	const char *bytes = TclGetStringFromObj(objPtr, &numBytes);
 
 	/* TODO: Check for more TIP 280 */
 	TclInitCompileEnv(interp, &compEnv, bytes, numBytes, NULL, 0);
 
@@ -1371,13 +1390,13 @@
  *----------------------------------------------------------------------
  */
 
 static void
 FreeSubstCodeInternalRep(
-    register Tcl_Obj *objPtr)	/* Object whose internal rep to free. */
+    Tcl_Obj *objPtr)	/* Object whose internal rep to free. */
 {
-    register ByteCode *codePtr;
+    ByteCode *codePtr;
 
     ByteCodeGetIntRep(objPtr, &substCodeType, codePtr);
     assert(codePtr != NULL);
 
     TclReleaseByteCode(codePtr);
@@ -1391,18 +1410,18 @@
 
     if (eclPtr->type == TCL_LOCATION_SOURCE) {
 	Tcl_DecrRefCount(eclPtr->path);
     }
     for (i=0 ; i<eclPtr->nuloc ; i++) {
-	Tcl_Free(eclPtr->loc[i].line);
+	ckfree(eclPtr->loc[i].line);
     }
 
     if (eclPtr->loc != NULL) {
-	Tcl_Free(eclPtr->loc);
+	ckfree(eclPtr->loc);
     }
 
-    Tcl_Free(eclPtr);
+    ckfree(eclPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1422,21 +1441,21 @@
 
 void
 TclInitCompileEnv(
     Tcl_Interp *interp,		/* The interpreter for which a CompileEnv
 				 * structure is initialized. */
-    register CompileEnv *envPtr,/* Points to the CompileEnv structure to
+    CompileEnv *envPtr,/* Points to the CompileEnv structure to
 				 * initialize. */
     const char *stringPtr,	/* The source string to be compiled. */
-    size_t numBytes,		/* Number of bytes in source string. */
+    int numBytes,		/* Number of bytes in source string. */
     const CmdFrame *invoker,	/* Location context invoking the bcc */
     int word)			/* Index of the word in that context getting
 				 * compiled */
 {
     Interp *iPtr = (Interp *) interp;
 
-    assert(tclInstructionTable[LAST_INST_OPCODE].name == NULL);
+    assert(tclInstructionTable[LAST_INST_OPCODE+1].name == NULL);
 
     envPtr->iPtr = iPtr;
     envPtr->source = stringPtr;
     envPtr->numSrcBytes = numBytes;
     envPtr->procPtr = iPtr->compiledProcPtr;
@@ -1477,11 +1496,11 @@
      *
      * See also tclBasic.c, TclEvalObjEx, for the equivalent code in the
      * non-compiling evaluator
      */
 
-    envPtr->extCmdMapPtr = Tcl_Alloc(sizeof(ExtCmdLoc));
+    envPtr->extCmdMapPtr = ckalloc(sizeof(ExtCmdLoc));
     envPtr->extCmdMapPtr->loc = NULL;
     envPtr->extCmdMapPtr->nloc = 0;
     envPtr->extCmdMapPtr->nuloc = 0;
     envPtr->extCmdMapPtr->path = NULL;
 
@@ -1629,14 +1648,14 @@
  *----------------------------------------------------------------------
  */
 
 void
 TclFreeCompileEnv(
-    register CompileEnv *envPtr)/* Points to the CompileEnv structure. */
+    CompileEnv *envPtr)/* Points to the CompileEnv structure. */
 {
     if (envPtr->localLitTable.buckets != envPtr->localLitTable.staticBuckets){
-	Tcl_Free(envPtr->localLitTable.buckets);
+	ckfree(envPtr->localLitTable.buckets);
 	envPtr->localLitTable.buckets = envPtr->localLitTable.staticBuckets;
     }
     if (envPtr->iPtr) {
 	/*
 	 * We never converted to Bytecode, so free the things we would
@@ -1662,24 +1681,24 @@
 	    }
 	    auxDataPtr++;
 	}
     }
     if (envPtr->mallocedCodeArray) {
-	Tcl_Free(envPtr->codeStart);
+	ckfree(envPtr->codeStart);
     }
     if (envPtr->mallocedLiteralArray) {
-	Tcl_Free(envPtr->literalArrayPtr);
+	ckfree(envPtr->literalArrayPtr);
     }
     if (envPtr->mallocedExceptArray) {
-	Tcl_Free(envPtr->exceptArrayPtr);
-	Tcl_Free(envPtr->exceptAuxArrayPtr);
+	ckfree(envPtr->exceptArrayPtr);
+	ckfree(envPtr->exceptAuxArrayPtr);
     }
     if (envPtr->mallocedCmdMap) {
-	Tcl_Free(envPtr->cmdMapPtr);
+	ckfree(envPtr->cmdMapPtr);
     }
     if (envPtr->mallocedAuxDataArray) {
-	Tcl_Free(envPtr->auxDataArrayPtr);
+	ckfree(envPtr->auxDataArrayPtr);
     }
     if (envPtr->extCmdMapPtr) {
 	ReleaseCmdWordData(envPtr->extCmdMapPtr);
 	envPtr->extCmdMapPtr = NULL;
     }
@@ -1741,11 +1760,11 @@
 	    break;
 
 	case TCL_TOKEN_BS:
 	    if (tempPtr != NULL) {
 		char utfBuf[4] = "";
-		size_t length = TclParseBackslash(tokenPtr->start,
+		int length = TclParseBackslash(tokenPtr->start,
 			tokenPtr->size, NULL, utfBuf);
 
 		Tcl_AppendToObj(tempPtr, utfBuf, length);
 	    }
 	    break;
@@ -1784,11 +1803,11 @@
  */
 
 static int
 ExpandRequested(
     Tcl_Token *tokenPtr,
-    size_t numWords)
+    int numWords)
 {
     /* Determine whether any words of the command require expansion */
     while (numWords--) {
 	if (tokenPtr->type == TCL_TOKEN_EXPAND_WORD) {
 	    return 1;
@@ -1802,22 +1821,22 @@
 CompileCmdLiteral(
     Tcl_Interp *interp,
     Tcl_Obj *cmdObj,
     CompileEnv *envPtr)
 {
+    int numBytes;
     const char *bytes;
     Command *cmdPtr;
     int cmdLitIdx, extraLiteralFlags = LITERAL_CMD_NAME;
-    size_t length;
 
     cmdPtr = (Command *) Tcl_GetCommandFromObj(interp, cmdObj);
     if ((cmdPtr != NULL) && (cmdPtr->flags & CMD_VIA_RESOLVER)) {
 	extraLiteralFlags |= LITERAL_UNSHARED;
     }
 
-    bytes = TclGetStringFromObj(cmdObj, &length);
-    cmdLitIdx = TclRegisterLiteral(envPtr, bytes, length, extraLiteralFlags);
+    bytes = TclGetStringFromObj(cmdObj, &numBytes);
+    cmdLitIdx = TclRegisterLiteral(envPtr, bytes, numBytes, extraLiteralFlags);
 
     if (cmdPtr) {
 	TclSetCmdNameObj(interp, TclFetchLiteral(envPtr, cmdLitIdx), cmdPtr);
     }
     TclEmitPush(cmdLitIdx, envPtr);
@@ -1826,15 +1845,14 @@
 void
 TclCompileInvocation(
     Tcl_Interp *interp,
     Tcl_Token *tokenPtr,
     Tcl_Obj *cmdObj,
-    size_t numWords,
+    int numWords,
     CompileEnv *envPtr)
 {
-    size_t wordIdx = 0;
-    int depth = TclGetStackDepth(envPtr);
+    int wordIdx = 0, depth = TclGetStackDepth(envPtr);
     DefineLineInformation;
 
     if (cmdObj) {
 	CompileCmdLiteral(interp, cmdObj, envPtr);
 	wordIdx = 1;
@@ -1995,11 +2013,11 @@
      * Throw out any line information generated by the failed compile attempt.
      */
 
     while (mapPtr->nuloc - 1 > eclIndex) {
 	mapPtr->nuloc--;
-	Tcl_Free(mapPtr->loc[mapPtr->nuloc].line);
+	ckfree(mapPtr->loc[mapPtr->nuloc].line);
 	mapPtr->loc[mapPtr->nuloc].line = NULL;
     }
 
     /*
      * Reset the index of next command.  Toss out any from failed nested
@@ -2045,11 +2063,11 @@
      * non-literal words, stored in 'wlines'.
      */
 
     EnterCmdWordData(eclPtr, parsePtr->commandStart - envPtr->source,
 	    parsePtr->tokenPtr, parsePtr->commandStart,
-	    parsePtr->numWords, cmdLine,
+	    parsePtr->commandSize, parsePtr->numWords, cmdLine,
 	    clNext, &wlines, envPtr);
     wlineat = eclPtr->nuloc - 1;
 
     envPtr->line = eclPtr->loc[wlineat].line[0];
     envPtr->clNext = eclPtr->loc[wlineat].next[0];
@@ -2113,12 +2131,12 @@
      * form now
      */
 
     envPtr->line = cmdLine;
     envPtr->clNext = clNext;
-    Tcl_Free(eclPtr->loc[wlineat].line);
-    Tcl_Free(eclPtr->loc[wlineat].next);
+    ckfree(eclPtr->loc[wlineat].line);
+    ckfree(eclPtr->loc[wlineat].next);
     eclPtr->loc[wlineat].line = wlines;
     eclPtr->loc[wlineat].next = NULL;
 
     TclCheckStackDepth(depth, envPtr);
     return cmdIdx;
@@ -2128,11 +2146,11 @@
 TclCompileScript(
     Tcl_Interp *interp,		/* Used for error and status reporting. Also
 				 * serves as context for finding and compiling
 				 * commands. May not be NULL. */
     const char *script,		/* The source script to compile. */
-    size_t numBytes,		/* Number of bytes in script. If -1, the
+    int numBytes,		/* Number of bytes in script. If < 0, the
 				 * script consists of all bytes up to the
 				 * first null character. */
     CompileEnv *envPtr)		/* Holds resulting instructions. */
 {
     int lastCmdIdx = -1;	/* Index into envPtr->cmdMapPtr of the last
@@ -2146,22 +2164,30 @@
 	Tcl_Panic("TclCompileScript() called on uninitialized CompileEnv");
     }
 
     /* Each iteration compiles one command from the script. */
 
-    while (numBytes + 1 > 1) {
-	Tcl_Parse parse;
+    if (numBytes > 0) {
+      /*
+       * Don't use system stack (size of Tcl_Parse is ca. 400 bytes), so
+       * many nested compilations (body enclosed in body) can cause abnormal
+       * program termination with a stack overflow exception, bug [fec0c17d39].
+       */
+      Tcl_Parse *parsePtr = ckalloc(sizeof(Tcl_Parse));
+
+      do {
 	const char *next;
 
-	if (TCL_OK != Tcl_ParseCommand(interp, p, numBytes, 0, &parse)) {
+	if (TCL_OK != Tcl_ParseCommand(interp, p, numBytes, 0, parsePtr)) {
 	    /*
-	     * Compile bytecodes to report the parse error at runtime.
+	     * Compile bytecodes to report the parsePtr error at runtime.
 	     */
 
-	    Tcl_LogCommandInfo(interp, script, parse.commandStart,
-		    parse.term + 1 - parse.commandStart);
+	    Tcl_LogCommandInfo(interp, script, parsePtr->commandStart,
+		    parsePtr->term + 1 - parsePtr->commandStart);
 	    TclCompileSyntaxError(interp, envPtr);
+	    ckfree(parsePtr);
 	    return;
 	}
 
 #ifdef TCL_COMPILE_DEBUG
 	/*
@@ -2168,13 +2194,13 @@
 	 * If tracing, print a line for each top level command compiled.
 	 * TODO: Suppress when numWords == 0 ?
 	 */
 
 	if ((tclTraceCompile >= 1) && (envPtr->procPtr == NULL)) {
-	    int commandLength = parse.term - parse.commandStart;
+	    int commandLength = parsePtr->term - parsePtr->commandStart;
 	    fprintf(stdout, "  Compiling: ");
-	    TclPrintSource(stdout, parse.commandStart,
+	    TclPrintSource(stdout, parsePtr->commandStart,
 		    TclMin(commandLength, 55));
 	    fprintf(stdout, "\n");
 	}
 #endif
 
@@ -2181,52 +2207,55 @@
 	/*
 	 * TIP #280: Count newlines before the command start.
 	 * (See test info-30.33).
 	 */
 
-	TclAdvanceLines(&envPtr->line, p, parse.commandStart);
+	TclAdvanceLines(&envPtr->line, p, parsePtr->commandStart);
 	TclAdvanceContinuations(&envPtr->line, &envPtr->clNext,
-		parse.commandStart - envPtr->source);
+		parsePtr->commandStart - envPtr->source);
 
 	/*
 	 * Advance parser to the next command in the script.
 	 */
 
-	next = parse.commandStart + parse.commandSize;
+	next = parsePtr->commandStart + parsePtr->commandSize;
 	numBytes -= next - p;
 	p = next;
 
-	if (parse.numWords == 0) {
+	if (parsePtr->numWords == 0) {
 	    /*
 	     * The "command" parsed has no words.  In this case we can skip
 	     * the rest of the loop body.  With no words, clearly
 	     * CompileCommandTokens() has nothing to do.  Since the parser
 	     * aggressively sucks up leading comment and white space,
-	     * including newlines, parse.commandStart must be pointing at
+	     * including newlines, parsePtr->commandStart must be pointing at
 	     * either the end of script, or a command-terminating semi-colon.
 	     * In either case, the TclAdvance*() calls have nothing to do.
 	     * Finally, when no words are parsed, no tokens have been
-	     * allocated at parse.tokenPtr so there's also nothing for
+	     * allocated at parsePtr->tokenPtr so there's also nothing for
 	     * Tcl_FreeParse() to do.
 	     *
 	     * The advantage of this shortcut is that CompileCommandTokens()
-	     * can be written with an assumption that parse.numWords > 0, with
+	     * can be written with an assumption that parsePtr->numWords > 0, with
 	     * the implication the CCT() always generates bytecode.
 	     */
 	    continue;
 	}
 
-	lastCmdIdx = CompileCommandTokens(interp, &parse, envPtr);
+	lastCmdIdx = CompileCommandTokens(interp, parsePtr, envPtr);
 
 	/*
 	 * TIP #280: Track lines in the just compiled command.
 	 */
 
-	TclAdvanceLines(&envPtr->line, parse.commandStart, p);
+	TclAdvanceLines(&envPtr->line, parsePtr->commandStart, p);
 	TclAdvanceContinuations(&envPtr->line, &envPtr->clNext,
 		p - envPtr->source);
-	Tcl_FreeParse(&parse);
+	Tcl_FreeParse(parsePtr);
+      } while (numBytes > 0);
+
+      ckfree(parsePtr);
     }
 
     if (lastCmdIdx == -1) {
 	/*
 	 * Compiling the script yielded no bytecode.  The script must be all
@@ -2281,12 +2310,12 @@
     Tcl_Interp *interp,
     Tcl_Token *tokenPtr,
     CompileEnv *envPtr)
 {
     const char *p, *name = tokenPtr[1].start;
-    size_t i, nameBytes = tokenPtr[1].size;
-    int localVar, localVarName = 1;
+    int nameBytes = tokenPtr[1].size;
+    int i, localVar, localVarName = 1;
 
     /*
      * Determine how the variable name should be handled: if it contains any
      * namespace qualifiers it is not a local variable (localVarName=-1); if
      * it looks like an array element and the token has a single component, it
@@ -2356,12 +2385,11 @@
     CompileEnv *envPtr)		/* Holds the resulting instructions. */
 {
     Tcl_DString textBuffer;	/* Holds concatenated chars from adjacent
 				 * TCL_TOKEN_TEXT, TCL_TOKEN_BS tokens. */
     char buffer[4] = "";
-    int i, numObjsToConcat, adjust;
-    size_t length;
+    int i, numObjsToConcat, length, adjust;
     unsigned char *entryCodeNext = envPtr->codeNext;
 #define NUM_STATIC_POS 20
     int isLiteral, maxNumCL, numCL;
     int *clPosition = NULL;
     int depth = TclGetStackDepth(envPtr);
@@ -2392,11 +2420,11 @@
 	}
     }
 
     if (isLiteral) {
 	maxNumCL = NUM_STATIC_POS;
-	clPosition = Tcl_Alloc(maxNumCL * sizeof(int));
+	clPosition = ckalloc(maxNumCL * sizeof(int));
     }
 
     adjust = 0;
     Tcl_DStringInit(&textBuffer);
     numObjsToConcat = 0;
@@ -2433,11 +2461,11 @@
 		if (isLiteral) {
 		    int clPos = Tcl_DStringLength(&textBuffer);
 
 		    if (numCL >= maxNumCL) {
 			maxNumCL *= 2;
-			clPosition = Tcl_Realloc(clPosition,
+			clPosition = ckrealloc(clPosition,
                                 maxNumCL * sizeof(int));
 		    }
 		    clPosition[numCL] = clPos;
 		    numCL ++;
 		}
@@ -2491,11 +2519,11 @@
 	    tokenPtr += tokenPtr->numComponents;
 	    break;
 
 	default:
 	    Tcl_Panic("Unexpected token type in TclCompileTokens: %d; %.*s",
-		    tokenPtr->type, (int)tokenPtr->size, tokenPtr->start);
+		    tokenPtr->type, tokenPtr->size, tokenPtr->start);
 	}
     }
 
     /*
      * Push any accumulated characters appearing at the end.
@@ -2538,11 +2566,11 @@
      * Release the temp table we used to collect the locations of continuation
      * lines, if any.
      */
 
     if (maxNumCL) {
-	Tcl_Free(clPosition);
+	ckfree(clPosition);
     }
     TclCheckStackDepth(depth+1, envPtr);
 }
 
 /*
@@ -2749,11 +2777,11 @@
 	     * 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 intrep.
 	     */
-	    size_t numBytes;
+	    int numBytes;
 	    const char *bytes = TclGetStringFromObj(objPtr, &numBytes);
 	    Tcl_Obj *copyPtr = Tcl_NewStringObj(bytes, numBytes);
 
 	    Tcl_IncrRefCount(copyPtr);
 	    TclReleaseLiteral((Tcl_Interp *)envPtr->iPtr, objPtr);
@@ -2763,17 +2791,17 @@
     }
 }
 
 ByteCode *
 TclInitByteCode(
-    register CompileEnv *envPtr)/* Points to the CompileEnv structure from
+    CompileEnv *envPtr)/* Points to the CompileEnv structure from
 				 * which to create a ByteCode structure. */
 {
-    register ByteCode *codePtr;
+    ByteCode *codePtr;
     size_t codeBytes, objArrayBytes, exceptArrayBytes, cmdLocBytes;
     size_t auxDataArrayBytes, structureSize;
-    register unsigned char *p;
+    unsigned char *p;
 #ifdef TCL_COMPILE_DEBUG
     unsigned char *nextPtr;
 #endif
     int numLitObjects = envPtr->literalArrayNext;
     Namespace *namespacePtr;
@@ -2807,11 +2835,11 @@
 	namespacePtr = envPtr->iPtr->varFramePtr->nsPtr;
     } else {
 	namespacePtr = envPtr->iPtr->globalNsPtr;
     }
 
-    p = Tcl_Alloc(structureSize);
+    p = ckalloc(structureSize);
     codePtr = (ByteCode *) p;
     codePtr->interpHandle = TclHandlePreserve(iPtr->handle);
     codePtr->compileEpoch = iPtr->compileEpoch;
     codePtr->nsPtr = namespacePtr;
     codePtr->nsEpoch = namespacePtr->resolverEpoch;
@@ -2904,11 +2932,11 @@
 TclInitByteCodeObj(
     Tcl_Obj *objPtr,		/* Points object that should be initialized,
 				 * and whose string rep contains the source
 				 * code. */
     const Tcl_ObjType *typePtr,
-    register CompileEnv *envPtr)/* Points to the CompileEnv structure from
+    CompileEnv *envPtr)/* Points to the CompileEnv structure from
 				 * which to create a ByteCode structure. */
 {
     ByteCode *codePtr;
 
     PreventCycle(objPtr, envPtr);
@@ -2949,21 +2977,21 @@
  *----------------------------------------------------------------------
  */
 
 int
 TclFindCompiledLocal(
-    register const char *name,	/* Points to first character of the name of a
+    const char *name,	/* Points to first character of the name of a
 				 * scalar or array variable. If NULL, a
 				 * temporary var should be created. */
-    size_t nameBytes,		/* Number of bytes in the name. */
+    int nameBytes,		/* Number of bytes in the name. */
     int create,			/* If 1, allocate a local frame entry for the
 				 * variable if it is new. */
     CompileEnv *envPtr)		/* Points to the current compile environment*/
 {
-    register CompiledLocal *localPtr;
+    CompiledLocal *localPtr;
     int localVar = -1;
-    register int i;
+    int i;
     Proc *procPtr;
 
     /*
      * If not creating a temporary, does a local variable of the specified
      * name already exist?
@@ -2978,20 +3006,21 @@
 	 */
 
 	LocalCache *cachePtr = envPtr->iPtr->varFramePtr->localCachePtr;
 	const char *localName;
 	Tcl_Obj **varNamePtr;
-	size_t len;
+	int len;
 
 	if (!cachePtr || !name) {
 	    return -1;
 	}
 
 	varNamePtr = &cachePtr->varName0;
 	for (i=0; i < cachePtr->numVars; varNamePtr++, i++) {
 	    if (*varNamePtr) {
-		localName = TclGetStringFromObj(*varNamePtr, &len);
+		localName = TclGetString(*varNamePtr);
+		len = (*varNamePtr)->length;
 		if ((len == nameBytes) && !strncmp(name, localName, len)) {
 		    return i;
 		}
 	    }
 	}
@@ -3005,11 +3034,11 @@
 	for (i = 0;  i < localCt;  i++) {
 	    if (!TclIsVarTemporary(localPtr)) {
 		char *localName = localPtr->name;
 
 		if ((nameBytes == localPtr->nameLength) &&
-			(strncmp(name,localName,nameBytes) == 0)) {
+			(strncmp(name, localName, nameBytes) == 0)) {
 		    return i;
 		}
 	    }
 	    localPtr = localPtr->nextPtr;
 	}
@@ -3019,11 +3048,11 @@
      * Create a new variable if appropriate.
      */
 
     if (create || (name == NULL)) {
 	localVar = procPtr->numCompiledLocals;
-	localPtr = Tcl_Alloc(offsetof(CompiledLocal, name) + nameBytes + 1);
+	localPtr = ckalloc(offsetof(CompiledLocal, name) + nameBytes + 1);
 	if (procPtr->firstLocalPtr == NULL) {
 	    procPtr->firstLocalPtr = procPtr->lastLocalPtr = localPtr;
 	} else {
 	    procPtr->lastLocalPtr->nextPtr = localPtr;
 	    procPtr->lastLocalPtr = localPtr;
@@ -3083,18 +3112,18 @@
 
     size_t currBytes = envPtr->codeNext - envPtr->codeStart;
     size_t newBytes = 2 * (envPtr->codeEnd - envPtr->codeStart);
 
     if (envPtr->mallocedCodeArray) {
-	envPtr->codeStart = Tcl_Realloc(envPtr->codeStart, newBytes);
+	envPtr->codeStart = ckrealloc(envPtr->codeStart, newBytes);
     } else {
 	/*
-	 * envPtr->codeStart isn't a Tcl_Alloc'd pointer, so we must code a
-	 * Tcl_Realloc equivalent for ourselves.
+	 * envPtr->codeStart isn't a ckalloc'd pointer, so we must code a
+	 * ckrealloc equivalent for ourselves.
 	 */
 
-	unsigned char *newPtr = Tcl_Alloc(newBytes);
+	unsigned char *newPtr = ckalloc(newBytes);
 
 	memcpy(newPtr, envPtr->codeStart, currBytes);
 	envPtr->codeStart = newPtr;
 	envPtr->mallocedCodeArray = 1;
     }
@@ -3150,18 +3179,18 @@
 	size_t newElems = 2 * currElems;
 	size_t currBytes = currElems * sizeof(CmdLocation);
 	size_t newBytes = newElems * sizeof(CmdLocation);
 
 	if (envPtr->mallocedCmdMap) {
-	    envPtr->cmdMapPtr = Tcl_Realloc(envPtr->cmdMapPtr, newBytes);
+	    envPtr->cmdMapPtr = ckrealloc(envPtr->cmdMapPtr, newBytes);
 	} else {
 	    /*
-	     * envPtr->cmdMapPtr isn't a Tcl_Alloc'd pointer, so we must code a
-	     * Tcl_Realloc equivalent for ourselves.
+	     * envPtr->cmdMapPtr isn't a ckalloc'd pointer, so we must code a
+	     * ckrealloc equivalent for ourselves.
 	     */
 
-	    CmdLocation *newPtr = Tcl_Alloc(newBytes);
+	    CmdLocation *newPtr = ckalloc(newBytes);
 
 	    memcpy(newPtr, envPtr->cmdMapPtr, currBytes);
 	    envPtr->cmdMapPtr = newPtr;
 	    envPtr->mallocedCmdMap = 1;
 	}
@@ -3254,10 +3283,11 @@
 				 * which to enter command location
 				 * information. */
     int srcOffset,		/* Offset of first char of the command. */
     Tcl_Token *tokenPtr,
     const char *cmd,
+    int len,
     int numWords,
     int line,
     int *clNext,
     int **wlines,
     CompileEnv *envPtr)
@@ -3275,20 +3305,20 @@
 
 	size_t currElems = eclPtr->nloc;
 	size_t newElems = (currElems ? 2*currElems : 1);
 	size_t newBytes = newElems * sizeof(ECL);
 
-	eclPtr->loc = Tcl_Realloc(eclPtr->loc, newBytes);
+	eclPtr->loc = ckrealloc(eclPtr->loc, newBytes);
 	eclPtr->nloc = newElems;
     }
 
     ePtr = &eclPtr->loc[eclPtr->nuloc];
     ePtr->srcOffset = srcOffset;
-    ePtr->line = Tcl_Alloc(numWords * sizeof(int));
-    ePtr->next = Tcl_Alloc(numWords * sizeof(int *));
+    ePtr->line = ckalloc(numWords * sizeof(int));
+    ePtr->next = ckalloc(numWords * sizeof(int *));
     ePtr->nline = numWords;
-    wwlines = Tcl_Alloc(numWords * sizeof(int));
+    wwlines = ckalloc(numWords * sizeof(int));
 
     last = cmd;
     wordLine = line;
     wordNext = clNext;
     for (wordIdx=0 ; wordIdx<numWords;
@@ -3330,15 +3360,15 @@
  */
 
 int
 TclCreateExceptRange(
     ExceptionRangeType type,	/* The kind of ExceptionRange desired. */
-    register CompileEnv *envPtr)/* Points to CompileEnv for which to create a
+    CompileEnv *envPtr)/* Points to CompileEnv for which to create a
 				 * new ExceptionRange structure. */
 {
-    register ExceptionRange *rangePtr;
-    register ExceptionAux *auxPtr;
+    ExceptionRange *rangePtr;
+    ExceptionAux *auxPtr;
     int index = envPtr->exceptArrayNext;
 
     if (index >= envPtr->exceptArrayEnd) {
 	/*
 	 * Expand the ExceptionRange array. The currently allocated entries
@@ -3353,21 +3383,21 @@
 	size_t newBytes = newElems * sizeof(ExceptionRange);
 	size_t newBytes2 = newElems * sizeof(ExceptionAux);
 
 	if (envPtr->mallocedExceptArray) {
 	    envPtr->exceptArrayPtr =
-		    Tcl_Realloc(envPtr->exceptArrayPtr, newBytes);
+		    ckrealloc(envPtr->exceptArrayPtr, newBytes);
 	    envPtr->exceptAuxArrayPtr =
-		    Tcl_Realloc(envPtr->exceptAuxArrayPtr, newBytes2);
+		    ckrealloc(envPtr->exceptAuxArrayPtr, newBytes2);
 	} else {
 	    /*
-	     * envPtr->exceptArrayPtr isn't a Tcl_Alloc'd pointer, so we must
-	     * code a Tcl_Realloc equivalent for ourselves.
+	     * envPtr->exceptArrayPtr isn't a ckalloc'd pointer, so we must
+	     * code a ckrealloc equivalent for ourselves.
 	     */
 
-	    ExceptionRange *newPtr = Tcl_Alloc(newBytes);
-	    ExceptionAux *newPtr2 = Tcl_Alloc(newBytes2);
+	    ExceptionRange *newPtr = ckalloc(newBytes);
+	    ExceptionAux *newPtr2 = ckalloc(newBytes2);
 
 	    memcpy(newPtr, envPtr->exceptArrayPtr, currBytes);
 	    memcpy(newPtr2, envPtr->exceptAuxArrayPtr, currBytes2);
 	    envPtr->exceptArrayPtr = newPtr;
 	    envPtr->exceptAuxArrayPtr = newPtr2;
@@ -3466,15 +3496,15 @@
 
     if (++auxPtr->numBreakTargets > auxPtr->allocBreakTargets) {
 	auxPtr->allocBreakTargets *= 2;
 	auxPtr->allocBreakTargets += 2;
 	if (auxPtr->breakTargets) {
-	    auxPtr->breakTargets = Tcl_Realloc(auxPtr->breakTargets,
+	    auxPtr->breakTargets = ckrealloc(auxPtr->breakTargets,
 		    sizeof(int) * auxPtr->allocBreakTargets);
 	} else {
 	    auxPtr->breakTargets =
-		    Tcl_Alloc(sizeof(int) * auxPtr->allocBreakTargets);
+		    ckalloc(sizeof(int) * auxPtr->allocBreakTargets);
 	}
     }
     auxPtr->breakTargets[auxPtr->numBreakTargets - 1] = CurrentOffset(envPtr);
     TclEmitInstInt4(INST_JUMP4, 0, envPtr);
 }
@@ -3492,15 +3522,15 @@
 
     if (++auxPtr->numContinueTargets > auxPtr->allocContinueTargets) {
 	auxPtr->allocContinueTargets *= 2;
 	auxPtr->allocContinueTargets += 2;
 	if (auxPtr->continueTargets) {
-	    auxPtr->continueTargets = Tcl_Realloc(auxPtr->continueTargets,
+	    auxPtr->continueTargets = ckrealloc(auxPtr->continueTargets,
 		    sizeof(int) * auxPtr->allocContinueTargets);
 	} else {
 	    auxPtr->continueTargets =
-		    Tcl_Alloc(sizeof(int) * auxPtr->allocContinueTargets);
+		    ckalloc(sizeof(int) * auxPtr->allocContinueTargets);
 	}
     }
     auxPtr->continueTargets[auxPtr->numContinueTargets - 1] =
 	    CurrentOffset(envPtr);
     TclEmitInstInt4(INST_JUMP4, 0, envPtr);
@@ -3658,16 +3688,16 @@
     /*
      * Drop the arrays we were holding the only reference to.
      */
 
     if (auxPtr->breakTargets) {
-	Tcl_Free(auxPtr->breakTargets);
+	ckfree(auxPtr->breakTargets);
 	auxPtr->breakTargets = NULL;
 	auxPtr->numBreakTargets = 0;
     }
     if (auxPtr->continueTargets) {
-	Tcl_Free(auxPtr->continueTargets);
+	ckfree(auxPtr->continueTargets);
 	auxPtr->continueTargets = NULL;
 	auxPtr->numContinueTargets = 0;
     }
 }
 
@@ -3698,15 +3728,15 @@
 TclCreateAuxData(
     ClientData clientData,	/* The compilation auxiliary data to store in
 				 * the new aux data record. */
     const AuxDataType *typePtr,	/* Pointer to the type to attach to this
 				 * AuxData */
-    register CompileEnv *envPtr)/* Points to the CompileEnv for which a new
+    CompileEnv *envPtr)/* Points to the CompileEnv for which a new
 				 * aux data structure is to be allocated. */
 {
     int index;			/* Index for the new AuxData structure. */
-    register AuxData *auxDataPtr;
+    AuxData *auxDataPtr;
 				/* Points to the new AuxData structure */
 
     index = envPtr->auxDataArrayNext;
     if (index >= envPtr->auxDataArrayEnd) {
 	/*
@@ -3719,18 +3749,18 @@
 	int newElems = 2*envPtr->auxDataArrayEnd;
 	size_t newBytes = newElems * sizeof(AuxData);
 
 	if (envPtr->mallocedAuxDataArray) {
 	    envPtr->auxDataArrayPtr =
-		    Tcl_Realloc(envPtr->auxDataArrayPtr, newBytes);
+		    ckrealloc(envPtr->auxDataArrayPtr, newBytes);
 	} else {
 	    /*
-	     * envPtr->auxDataArrayPtr isn't a Tcl_Alloc'd pointer, so we must
-	     * code a Tcl_Realloc equivalent for ourselves.
+	     * envPtr->auxDataArrayPtr isn't a ckalloc'd pointer, so we must
+	     * code a ckrealloc equivalent for ourselves.
 	     */
 
-	    AuxData *newPtr = Tcl_Alloc(newBytes);
+	    AuxData *newPtr = ckalloc(newBytes);
 
 	    memcpy(newPtr, envPtr->auxDataArrayPtr, currBytes);
 	    envPtr->auxDataArrayPtr = newPtr;
 	    envPtr->mallocedAuxDataArray = 1;
 	}
@@ -3761,11 +3791,11 @@
  *----------------------------------------------------------------------
  */
 
 void
 TclInitJumpFixupArray(
-    register JumpFixupArray *fixupArrayPtr)
+    JumpFixupArray *fixupArrayPtr)
 				/* Points to the JumpFixupArray structure to
 				 * initialize. */
 {
     fixupArrayPtr->fixup = fixupArrayPtr->staticFixupSpace;
     fixupArrayPtr->next = 0;
@@ -3793,11 +3823,11 @@
  *----------------------------------------------------------------------
  */
 
 void
 TclExpandJumpFixupArray(
-    register JumpFixupArray *fixupArrayPtr)
+    JumpFixupArray *fixupArrayPtr)
 				/* Points to the JumpFixupArray structure to
 				 * enlarge. */
 {
     /*
      * The currently allocated jump fixup entries are stored from fixup[0] up
@@ -3808,18 +3838,18 @@
     size_t currBytes = fixupArrayPtr->next * sizeof(JumpFixup);
     int newElems = 2*(fixupArrayPtr->end + 1);
     size_t newBytes = newElems * sizeof(JumpFixup);
 
     if (fixupArrayPtr->mallocedArray) {
-	fixupArrayPtr->fixup = Tcl_Realloc(fixupArrayPtr->fixup, newBytes);
+	fixupArrayPtr->fixup = ckrealloc(fixupArrayPtr->fixup, newBytes);
     } else {
 	/*
-	 * fixupArrayPtr->fixup isn't a Tcl_Alloc'd pointer, so we must code a
-	 * Tcl_Realloc equivalent for ourselves.
+	 * fixupArrayPtr->fixup isn't a ckalloc'd pointer, so we must code a
+	 * ckrealloc equivalent for ourselves.
 	 */
 
-	JumpFixup *newPtr = Tcl_Alloc(newBytes);
+	JumpFixup *newPtr = ckalloc(newBytes);
 
 	memcpy(newPtr, fixupArrayPtr->fixup, currBytes);
 	fixupArrayPtr->fixup = newPtr;
 	fixupArrayPtr->mallocedArray = 1;
     }
@@ -3842,16 +3872,16 @@
  *----------------------------------------------------------------------
  */
 
 void
 TclFreeJumpFixupArray(
-    register JumpFixupArray *fixupArrayPtr)
+    JumpFixupArray *fixupArrayPtr)
 				/* Points to the JumpFixupArray structure to
 				 * free. */
 {
     if (fixupArrayPtr->mallocedArray) {
-	Tcl_Free(fixupArrayPtr->fixup);
+	ckfree(fixupArrayPtr->fixup);
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -3947,11 +3977,11 @@
     int distThreshold)		/* Maximum distance before the two byte jump
 				 * is grown to five bytes. */
 {
     unsigned char *jumpPc, *p;
     int firstCmd, lastCmd, firstRange, lastRange, k;
-    size_t numBytes;
+    unsigned numBytes;
 
     if (jumpDist <= distThreshold) {
 	jumpPc = envPtr->codeStart + jumpFixupPtr->codeOffset;
 	switch (jumpFixupPtr->jumpType) {
 	case TCL_UNCONDITIONAL_JUMP:
@@ -4289,11 +4319,11 @@
 GetCmdLocEncodingSize(
     CompileEnv *envPtr)		/* Points to compilation environment structure
 				 * containing the CmdLocation structure to
 				 * encode. */
 {
-    register CmdLocation *mapPtr = envPtr->cmdMapPtr;
+    CmdLocation *mapPtr = envPtr->cmdMapPtr;
     int numCmds = envPtr->numCommands;
     int codeDelta, codeLen, srcDelta, srcLen;
     int codeDeltaNext, codeLengthNext, srcDeltaNext, srcLengthNext;
 				/* The offsets in their respective byte
 				 * sequences where the next encoded offset or
@@ -4373,15 +4403,15 @@
 				 * command location information. */
     unsigned char *startPtr)	/* Points to the first byte in codePtr's
 				 * memory block where the location information
 				 * is to be stored. */
 {
-    register CmdLocation *mapPtr = envPtr->cmdMapPtr;
+    CmdLocation *mapPtr = envPtr->cmdMapPtr;
     int numCmds = envPtr->numCommands;
-    register unsigned char *p = startPtr;
+    unsigned char *p = startPtr;
     int codeDelta, codeLen, srcDelta, srcLen, prevOffset;
-    register int i;
+    int i;
 
     /*
      * Encode the code offset for each command as a sequence of deltas.
      */
 
@@ -4491,11 +4521,11 @@
 RecordByteCodeStats(
     ByteCode *codePtr)		/* Points to ByteCode structure with info
 				 * to add to accumulated statistics. */
 {
     Interp *iPtr = (Interp *) *codePtr->interpHandle;
-    register ByteCodeStats *statsPtr;
+    ByteCodeStats *statsPtr;
 
     if (iPtr == NULL) {
 	/* Avoid segfaulting in case we're called in a deleted interp */
 	return;
     }

Index: generic/tclCompile.h
==================================================================
--- generic/tclCompile.h
+++ generic/tclCompile.h
@@ -85,11 +85,11 @@
     CATCH_EXCEPTION_RANGE	/* Exception's range is controlled by a catch
 				 * command. Errors in the range cause a jump
 				 * to a catch PC offset. */
 } ExceptionRangeType;
 
-typedef struct {
+typedef struct ExceptionRange {
     ExceptionRangeType type;	/* The kind of ExceptionRange. */
     int nestingLevel;		/* Static depth of the exception range. Used
 				 * to find the most deeply-nested range
 				 * surrounding a PC at runtime. */
     int codeOffset;		/* Offset of the first instruction byte of the
@@ -160,11 +160,11 @@
  * source's starting offset and length. Note that the code offset increases
  * monotonically: that is, the table is sorted in code offset order. The
  * source offset is not monotonic.
  */
 
-typedef struct {
+typedef struct CmdLocation {
     int codeOffset;		/* Offset of first byte of command code. */
     int numCodeBytes;		/* Number of bytes for command's code. */
     int srcOffset;		/* Offset of first char of the command. */
     int numSrcBytes;		/* Number of command source chars. */
 } CmdLocation;
@@ -178,21 +178,21 @@
  * through the 'lineBCPtr' HashTable in Interp, keyed by the address of BC.
  * Also recorded is information coming from the context, i.e. type of the
  * frame and associated information, like the path of a sourced file.
  */
 
-typedef struct {
-    size_t srcOffset;		/* Command location to find the entry. */
+typedef struct ECL {
+    int srcOffset;		/* Command location to find the entry. */
     int nline;			/* Number of words in the command */
     int *line;			/* Line information for all words in the
 				 * command. */
     int **next;			/* Transient information used by the compiler
 				 * for tracking of hidden continuation
 				 * lines. */
 } ECL;
 
-typedef struct {
+typedef struct ExtCmdLoc {
     int type;			/* Context type. */
     int start;			/* Starting line for compiled script. Needed
 				 * for the extended recompile check in
 				 * tclCompileObj. */
     Tcl_Obj *path;		/* Path of the sourced file the command is
@@ -215,13 +215,13 @@
  * to duplicate or free this auxiliary data when the containing ByteCode
  * objects are duplicated and freed. Pointers to these procedures are kept in
  * 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);
 
 /*
  * We define a separate AuxDataType struct to hold type-related information
@@ -415,23 +415,23 @@
     TclHandle interpHandle;	/* Handle for interpreter containing the
 				 * compiled code. Commands and their compile
 				 * procs are specific to an interpreter so the
 				 * code emitted will depend on the
 				 * interpreter. */
-    size_t compileEpoch;	/* Value of iPtr->compileEpoch when this
+    unsigned int compileEpoch;	/* Value of iPtr->compileEpoch when this
 				 * ByteCode was compiled. Used to invalidate
 				 * code when, e.g., commands with compile
 				 * procs are redefined. */
     Namespace *nsPtr;		/* Namespace context in which this code was
 				 * compiled. If the code is executed if a
 				 * different namespace, it must be
 				 * recompiled. */
-    size_t nsEpoch;		/* Value of nsPtr->resolverEpoch when this
+    unsigned int nsEpoch;	/* Value of nsPtr->resolverEpoch when this
 				 * ByteCode was compiled. Used to invalidate
 				 * code when new namespace resolution rules
 				 * are put into effect. */
-    size_t refCount;		/* Reference count: set 1 when created plus 1
+    unsigned int refCount;	/* Reference count: set 1 when created plus 1
 				 * for each execution of the code currently
 				 * active. This structure can be freed when
 				 * refCount becomes zero. */
     unsigned int flags;		/* flags describing state for the codebyte.
 				 * this variable holds ORed values from the
@@ -527,309 +527,331 @@
 
 #define ByteCodeGetIntRep(objPtr, typePtr, codePtr)			\
     do {								\
 	const Tcl_ObjIntRep *irPtr;					\
 	irPtr = TclFetchIntRep((objPtr), (typePtr));			\
-	(codePtr) = irPtr ? irPtr->twoPtrValue.ptr1 : NULL;		\
+	(codePtr) = irPtr ? (ByteCode*)irPtr->twoPtrValue.ptr1 : NULL;		\
     } while (0)
 
 /*
  * Opcodes for the Tcl bytecode instructions. These must correspond to the
  * entries in the table of instruction descriptions, tclInstructionTable, in
  * tclCompile.c. Also, the order and number of the expression opcodes (e.g.,
- * INST_BITOR) must match the entries in the array operatorStrings in
+ * INST_LOR) must match the entries in the array operatorStrings in
  * tclExecute.c.
  */
 
-enum TclInstruction {
-    /* Opcodes 0 to 9 */
-    INST_DONE = 0,
-    INST_PUSH1,
-    INST_PUSH4,
-    INST_POP,
-    INST_DUP,
-    INST_STR_CONCAT1,
-    INST_INVOKE_STK1,
-    INST_INVOKE_STK4,
-    INST_EVAL_STK,
-    INST_EXPR_STK,
-
-    /* Opcodes 10 to 23 */
-    INST_LOAD_SCALAR1,
-    INST_LOAD_SCALAR4,
-    INST_LOAD_SCALAR_STK,
-    INST_LOAD_ARRAY1,
-    INST_LOAD_ARRAY4,
-    INST_LOAD_ARRAY_STK,
-    INST_LOAD_STK,
-    INST_STORE_SCALAR1,
-    INST_STORE_SCALAR4,
-    INST_STORE_SCALAR_STK,
-    INST_STORE_ARRAY1,
-    INST_STORE_ARRAY4,
-    INST_STORE_ARRAY_STK,
-    INST_STORE_STK,
-
-    /* Opcodes 24 to 33 */
-    INST_INCR_SCALAR1,
-    INST_INCR_SCALAR_STK,
-    INST_INCR_ARRAY1,
-    INST_INCR_ARRAY_STK,
-    INST_INCR_STK,
-    INST_INCR_SCALAR1_IMM,
-    INST_INCR_SCALAR_STK_IMM,
-    INST_INCR_ARRAY1_IMM,
-    INST_INCR_ARRAY_STK_IMM,
-    INST_INCR_STK_IMM,
-
-    /* Opcodes 34 to 39 */
-    INST_JUMP1,
-    INST_JUMP4,
-    INST_JUMP_TRUE1,
-    INST_JUMP_TRUE4,
-    INST_JUMP_FALSE1,
-    INST_JUMP_FALSE4,
-
-    /* Opcodes 42 to 64 */
-    INST_BITOR,
-    INST_BITXOR,
-    INST_BITAND,
-    INST_EQ,
-    INST_NEQ,
-    INST_LT,
-    INST_GT,
-    INST_LE,
-    INST_GE,
-    INST_LSHIFT,
-    INST_RSHIFT,
-    INST_ADD,
-    INST_SUB,
-    INST_MULT,
-    INST_DIV,
-    INST_MOD,
-    INST_UPLUS,
-    INST_UMINUS,
-    INST_BITNOT,
-    INST_LNOT,
-    INST_TRY_CVT_TO_NUMERIC,
-
-    /* Opcodes 65 to 66 */
-    INST_BREAK,
-    INST_CONTINUE,
-
-    /* Opcodes 69 to 72 */
-    INST_BEGIN_CATCH4,
-    INST_END_CATCH,
-    INST_PUSH_RESULT,
-    INST_PUSH_RETURN_CODE,
-
-    /* Opcodes 73 to 78 */
-    INST_STR_EQ,
-    INST_STR_NEQ,
-    INST_STR_CMP,
-    INST_STR_LEN,
-    INST_STR_INDEX,
-    INST_STR_MATCH,
-
-    /* Opcodes 79 to 81 */
-    INST_LIST,
-    INST_LIST_INDEX,
-    INST_LIST_LENGTH,
-
-    /* Opcodes 82 to 87 */
-    INST_APPEND_SCALAR1,
-    INST_APPEND_SCALAR4,
-    INST_APPEND_ARRAY1,
-    INST_APPEND_ARRAY4,
-    INST_APPEND_ARRAY_STK,
-    INST_APPEND_STK,
-
-    /* Opcodes 88 to 93 */
-    INST_LAPPEND_SCALAR1,
-    INST_LAPPEND_SCALAR4,
-    INST_LAPPEND_ARRAY1,
-    INST_LAPPEND_ARRAY4,
-    INST_LAPPEND_ARRAY_STK,
-    INST_LAPPEND_STK,
-
-    /* TIP #22 - LINDEX operator with flat arg list */
-    INST_LIST_INDEX_MULTI,
-
-    /*
-     * TIP #33 - 'lset' command. Code gen also required a Forth-like
-     *	     OVER operation.
-     */
-    INST_OVER,
-    INST_LSET_LIST,
-    INST_LSET_FLAT,
-
-    /* TIP#90 - 'return' command. */
-    INST_RETURN_IMM,
-
-    /* TIP#123 - exponentiation operator. */
-    INST_EXPON,
-
-    /* TIP #157 - {*}... (word expansion) language syntax support. */
-    INST_EXPAND_START,
-    INST_EXPAND_STKTOP,
-    INST_INVOKE_EXPANDED,
-
-    /*
-     * TIP #57 - 'lassign' command. Code generation requires immediate
-     *	     LINDEX and LRANGE operators.
-     */
-    INST_LIST_INDEX_IMM,
-    INST_LIST_RANGE_IMM,
-    INST_START_CMD,
-    INST_LIST_IN,
-    INST_LIST_NOT_IN,
-    INST_PUSH_RETURN_OPTIONS,
-    INST_RETURN_STK,
-
-    /*
-     * Dictionary (TIP#111) related commands.
-     */
-    INST_DICT_GET,
-    INST_DICT_SET,
-    INST_DICT_UNSET,
-    INST_DICT_INCR_IMM,
-    INST_DICT_APPEND,
-    INST_DICT_LAPPEND,
-    INST_DICT_FIRST,
-    INST_DICT_NEXT,
-    INST_DICT_UPDATE_START,
-    INST_DICT_UPDATE_END,
-
-    /*
-     * Instruction to support jumps defined by tables (instead of the classic
-     * [switch] technique of chained comparisons).
-     */
-    INST_JUMP_TABLE,
-
-    /*
-     * Instructions to support compilation of global, variable, upvar and
-     * [namespace upvar].
-     */
-    INST_UPVAR,
-    INST_NSUPVAR,
-    INST_VARIABLE,
-
-    /* Instruction to support compiling syntax error to bytecode */
-    INST_SYNTAX,
-
-    /* Instruction to reverse N items on top of stack */
-    INST_REVERSE,
-
-    /* regexp instruction */
-    INST_REGEXP,
-
-    /* For [info exists] compilation */
-    INST_EXIST_SCALAR,
-    INST_EXIST_ARRAY,
-    INST_EXIST_ARRAY_STK,
-    INST_EXIST_STK,
-
-    /* For [subst] compilation */
-    INST_NOP,
-    INST_RETURN_CODE_BRANCH,
-
-    /* For [unset] compilation */
-    INST_UNSET_SCALAR,
-    INST_UNSET_ARRAY,
-    INST_UNSET_ARRAY_STK,
-    INST_UNSET_STK,
-
-    /* For [dict with], [dict exists], [dict create] and [dict merge] */
-    INST_DICT_EXPAND,
-    INST_DICT_RECOMBINE_STK,
-    INST_DICT_RECOMBINE_IMM,
-    INST_DICT_EXISTS,
-    INST_DICT_VERIFY,
-
-    /* For [string map] and [regsub] compilation */
-    INST_STR_MAP,
-    INST_STR_FIND,
-    INST_STR_FIND_LAST,
-    INST_STR_RANGE_IMM,
-    INST_STR_RANGE,
-
-    /* For operations to do with coroutines and other NRE-manipulators */
-    INST_YIELD,
-    INST_COROUTINE_NAME,
-    INST_TAILCALL,
-
-    /* For compilation of basic information operations */
-    INST_NS_CURRENT,
-    INST_INFO_LEVEL_NUM,
-    INST_INFO_LEVEL_ARGS,
-    INST_RESOLVE_COMMAND,
-
-    /* For compilation relating to TclOO */
-    INST_TCLOO_SELF,
-    INST_TCLOO_CLASS,
-    INST_TCLOO_NS,
-    INST_TCLOO_IS_OBJECT,
-
-    /* For compilation of [array] subcommands */
-    INST_ARRAY_EXISTS_STK,
-    INST_ARRAY_EXISTS_IMM,
-    INST_ARRAY_MAKE_STK,
-    INST_ARRAY_MAKE_IMM,
-
-    INST_INVOKE_REPLACE,
-
-    INST_LIST_CONCAT,
-
-    INST_EXPAND_DROP,
-
-    /* New foreach implementation */
-    INST_FOREACH_START,
-    INST_FOREACH_STEP,
-    INST_FOREACH_END,
-    INST_LMAP_COLLECT,
-
-    /* For compilation of [string trim] and related */
-    INST_STR_TRIM,
-    INST_STR_TRIM_LEFT,
-    INST_STR_TRIM_RIGHT,
-
-    INST_CONCAT_STK,
-
-    INST_STR_UPPER,
-    INST_STR_LOWER,
-    INST_STR_TITLE,
-    INST_STR_REPLACE,
-
-    INST_ORIGIN_COMMAND,
-
-    INST_TCLOO_NEXT,
-    INST_TCLOO_NEXT_CLASS,
-
-    INST_YIELD_TO_INVOKE,
-
-    INST_NUM_TYPE,
-    INST_TRY_CVT_TO_BOOLEAN,
-    INST_STR_CLASS,
-
-    INST_LAPPEND_LIST,
-    INST_LAPPEND_LIST_ARRAY,
-    INST_LAPPEND_LIST_ARRAY_STK,
-    INST_LAPPEND_LIST_STK,
-
-    INST_CLOCK_READ,
-
-    INST_DICT_GET_DEF,
-
-	/* TIP 461 */
-	INST_STR_LT,
-	INST_STR_GT,
-	INST_STR_LE,
-	INST_STR_GE,
-
-    /* The last opcode */
-    LAST_INST_OPCODE
-};
+/* 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
+
+/* 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
+
+/* 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 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 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 65 to 66 */
+#define INST_BREAK			65
+#define INST_CONTINUE			66
+
+/* Opcodes 67 to 68 */
+#define INST_FOREACH_START4		67 /* DEPRECATED */
+#define INST_FOREACH_STEP4		68 /* DEPRECATED */
+
+/* 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
+
+/* 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 78 to 81 */
+#define INST_LIST			79
+#define INST_LIST_INDEX			80
+#define INST_LIST_LENGTH		81
+
+/* 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 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
+
+/* TIP #22 - LINDEX operator with flat arg list */
+
+#define INST_LIST_INDEX_MULTI		94
+
+/*
+ * TIP #33 - 'lset' command. Code gen also required a Forth-like
+ *	     OVER operation.
+ */
+
+#define INST_OVER			95
+#define INST_LSET_LIST			96
+#define INST_LSET_FLAT			97
+
+/* TIP#90 - 'return' command. */
+
+#define INST_RETURN_IMM			98
+
+/* TIP#123 - exponentiation operator. */
+
+#define INST_EXPON			99
+
+/* TIP #157 - {*}... (word expansion) language syntax support. */
+
+#define INST_EXPAND_START		100
+#define INST_EXPAND_STKTOP		101
+#define INST_INVOKE_EXPANDED		102
+
+/*
+ * TIP #57 - 'lassign' command. Code generation requires immediate
+ *	     LINDEX and LRANGE operators.
+ */
+
+#define INST_LIST_INDEX_IMM		103
+#define INST_LIST_RANGE_IMM		104
+
+#define INST_START_CMD			105
+
+#define INST_LIST_IN			106
+#define INST_LIST_NOT_IN		107
+
+#define INST_PUSH_RETURN_OPTIONS	108
+#define INST_RETURN_STK			109
+
+/*
+ * Dictionary (TIP#111) related commands.
+ */
+
+#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
+
+/*
+ * Instruction to support jumps defined by tables (instead of the classic
+ * [switch] technique of chained comparisons).
+ */
+
+#define INST_JUMP_TABLE			121
+
+/*
+ * Instructions to support compilation of global, variable, upvar and
+ * [namespace upvar].
+ */
+
+#define INST_UPVAR			122
+#define INST_NSUPVAR			123
+#define INST_VARIABLE			124
+
+/* Instruction to support compiling syntax error to bytecode */
+
+#define INST_SYNTAX			125
+
+/* Instruction to reverse N items on top of stack */
+
+#define INST_REVERSE			126
+
+/* regexp instruction */
+
+#define INST_REGEXP			127
+
+/* 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
+
+/* For [subst] compilation */
+#define INST_NOP			132
+#define INST_RETURN_CODE_BRANCH		133
+
+/* 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 [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
+
+/* 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
+
+/* For operations to do with coroutines and other NRE-manipulators */
+#define INST_YIELD			148
+#define INST_COROUTINE_NAME		149
+#define INST_TAILCALL			150
+
+/* 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
+
+/* 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
+
+/* 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
+
+#define INST_INVOKE_REPLACE		163
+
+#define INST_LIST_CONCAT		164
+
+#define INST_EXPAND_DROP		165
+
+/* New foreach implementation */
+#define INST_FOREACH_START              166
+#define INST_FOREACH_STEP               167
+#define INST_FOREACH_END                168
+#define INST_LMAP_COLLECT               169
+
+/* 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
 
 /*
  * Table describing the Tcl bytecode instructions: their name (for displaying
  * code), total number of code bytes required (including operand bytes), and a
  * description of the type of each operand. These operand types include signed
@@ -863,11 +885,11 @@
     OPERAND_SCLS1		/* Index into tclStringClassTable. */
 } InstOperandType;
 
 typedef struct InstructionDesc {
     const char *name;		/* Name of instruction. */
-    size_t numBytes;		/* Total number of bytes for instruction. */
+    int numBytes;		/* Total number of bytes for instruction. */
     int stackEffect;		/* The worst-case balance stack effect of the
 				 * instruction, used for stack requirements
 				 * computations. The value INT_MIN signals
 				 * that the instruction's worst case effect is
 				 * (1-opnd1). */
@@ -1021,11 +1043,11 @@
  * needed during program execution. These structures are stored in CompileEnv
  * and ByteCode structures as auxiliary data.
  */
 
 typedef struct {
-    size_t length;		/* Size of array */
+    int length;			/* Size of array */
     int varIndices[1];		/* Array of variable indices to manage when
 				 * processing the start and end of a [dict
 				 * update]. There is really more than one
 				 * entry, and the structure is allocated to
 				 * take account of this. MUST BE LAST FIELD IN
@@ -1076,34 +1098,34 @@
 			    ExceptionAux *auxPtr);
 MODULE_SCOPE void	TclCompileCmdWord(Tcl_Interp *interp,
 			    Tcl_Token *tokenPtr, int count,
 			    CompileEnv *envPtr);
 MODULE_SCOPE void	TclCompileExpr(Tcl_Interp *interp, const char *script,
-			    size_t numBytes, CompileEnv *envPtr, int optimize);
+			    int numBytes, CompileEnv *envPtr, int optimize);
 MODULE_SCOPE void	TclCompileExprWords(Tcl_Interp *interp,
 			    Tcl_Token *tokenPtr, int numWords,
 			    CompileEnv *envPtr);
 MODULE_SCOPE void	TclCompileInvocation(Tcl_Interp *interp,
-			    Tcl_Token *tokenPtr, Tcl_Obj *cmdObj, size_t numWords,
+			    Tcl_Token *tokenPtr, Tcl_Obj *cmdObj, int numWords,
 			    CompileEnv *envPtr);
 MODULE_SCOPE void	TclCompileScript(Tcl_Interp *interp,
-			    const char *script, size_t numBytes,
+			    const char *script, int numBytes,
 			    CompileEnv *envPtr);
 MODULE_SCOPE void	TclCompileSyntaxError(Tcl_Interp *interp,
 			    CompileEnv *envPtr);
 MODULE_SCOPE void	TclCompileTokens(Tcl_Interp *interp,
 			    Tcl_Token *tokenPtr, int count,
 			    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);
-MODULE_SCOPE ExecEnv *	TclCreateExecEnv(Tcl_Interp *interp, size_t size);
+MODULE_SCOPE ExecEnv *	TclCreateExecEnv(Tcl_Interp *interp, int size);
 MODULE_SCOPE Tcl_Obj *	TclCreateLiteral(Interp *iPtr, const char *bytes,
-			    size_t length, size_t hash, int *newPtr,
+			    int length, unsigned int hash, int *newPtr,
 			    Namespace *nsPtr, int flags,
 			    LiteralEntry **globalPtrPtr);
 MODULE_SCOPE void	TclDeleteExecEnv(ExecEnv *eePtr);
 MODULE_SCOPE void	TclDeleteLiteralTable(Tcl_Interp *interp,
 			    LiteralTable *tablePtr);
@@ -1113,26 +1135,26 @@
 MODULE_SCOPE ExceptionRange * TclGetExceptionRangeForPc(unsigned char *pc,
 			    int catchOnly, ByteCode *codePtr);
 MODULE_SCOPE void	TclExpandJumpFixupArray(JumpFixupArray *fixupArrayPtr);
 MODULE_SCOPE int	TclNRExecuteByteCode(Tcl_Interp *interp,
 			    ByteCode *codePtr);
-MODULE_SCOPE Tcl_Obj *	TclFetchLiteral(CompileEnv *envPtr, size_t index);
-MODULE_SCOPE int	TclFindCompiledLocal(const char *name, size_t nameChars,
+MODULE_SCOPE Tcl_Obj *	TclFetchLiteral(CompileEnv *envPtr, unsigned int index);
+MODULE_SCOPE int	TclFindCompiledLocal(const char *name, int nameChars,
 			    int create, CompileEnv *envPtr);
 MODULE_SCOPE int	TclFixupForwardJump(CompileEnv *envPtr,
 			    JumpFixup *jumpFixupPtr, int jumpDist,
 			    int distThreshold);
 MODULE_SCOPE void	TclFreeCompileEnv(CompileEnv *envPtr);
 MODULE_SCOPE void	TclFreeJumpFixupArray(JumpFixupArray *fixupArrayPtr);
 MODULE_SCOPE int	TclGetIndexFromToken(Tcl_Token *tokenPtr,
-			    size_t before, size_t after, int *indexPtr);
+			    int before, int after, int *indexPtr);
 MODULE_SCOPE ByteCode *	TclInitByteCode(CompileEnv *envPtr);
 MODULE_SCOPE ByteCode *	TclInitByteCodeObj(Tcl_Obj *objPtr,
 			    const Tcl_ObjType *typePtr, CompileEnv *envPtr);
 MODULE_SCOPE void	TclInitCompileEnv(Tcl_Interp *interp,
 			    CompileEnv *envPtr, const char *string,
-			    size_t numBytes, const CmdFrame *invoker, int word);
+			    int numBytes, const CmdFrame *invoker, int word);
 MODULE_SCOPE void	TclInitJumpFixupArray(JumpFixupArray *fixupArrayPtr);
 MODULE_SCOPE void	TclInitLiteralTable(LiteralTable *tablePtr);
 MODULE_SCOPE ExceptionRange *TclGetInnermostExceptionRange(CompileEnv *envPtr,
 			    int returnCode, ExceptionAux **auxPtrPtr);
 MODULE_SCOPE void	TclAddLoopBreakFixup(CompileEnv *envPtr,
@@ -1143,11 +1165,11 @@
 			    int range);
 #ifdef TCL_COMPILE_STATS
 MODULE_SCOPE char *	TclLiteralStats(LiteralTable *tablePtr);
 MODULE_SCOPE int	TclLog2(int value);
 #endif
-MODULE_SCOPE int	TclLocalScalar(const char *bytes, size_t numBytes,
+MODULE_SCOPE int	TclLocalScalar(const char *bytes, int numBytes,
 			    CompileEnv *envPtr);
 MODULE_SCOPE int	TclLocalScalarFromToken(Tcl_Token *tokenPtr,
 			    CompileEnv *envPtr);
 MODULE_SCOPE void	TclOptimizeBytecode(void *envPtr);
 #ifdef TCL_COMPILE_DEBUG
@@ -1155,32 +1177,32 @@
 			    Tcl_Obj *objPtr);
 #endif
 MODULE_SCOPE int	TclPrintInstruction(ByteCode *codePtr,
 			    const unsigned char *pc);
 MODULE_SCOPE void	TclPrintObject(FILE *outFile,
-			    Tcl_Obj *objPtr, size_t maxChars);
+			    Tcl_Obj *objPtr, int maxChars);
 MODULE_SCOPE void	TclPrintSource(FILE *outFile,
-			    const char *string, size_t maxChars);
+			    const char *string, int maxChars);
 MODULE_SCOPE void	TclPushVarName(Tcl_Interp *interp,
 			    Tcl_Token *varTokenPtr, CompileEnv *envPtr,
 			    int flags, int *localIndexPtr,
 			    int *isScalarPtr);
 MODULE_SCOPE void	TclPreserveByteCode(ByteCode *codePtr);
 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(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	TclSortingOpCmd(void *clientData,
+MODULE_SCOPE int	TclVariadicOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	TclVariadicOpCmd(void *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
 MODULE_SCOPE void	TclVerifyGlobalLiteralTable(Interp *iPtr);
 MODULE_SCOPE void	TclVerifyLocalLiteralTable(CompileEnv *envPtr);
@@ -1187,17 +1209,17 @@
 #endif
 MODULE_SCOPE int	TclWordKnownAtCompileTime(Tcl_Token *tokenPtr,
 			    Tcl_Obj *valuePtr);
 MODULE_SCOPE void	TclLogCommandInfo(Tcl_Interp *interp,
 			    const char *script, const char *command,
-			    size_t length, const unsigned char *pc,
+			    int length, const unsigned char *pc,
 			    Tcl_Obj **tosPtr);
 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,
-			    register Tcl_Interp *interp, int objc,
+MODULE_SCOPE int	TclPushProcCallFrame(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[], int isLambda);
 
 
 /*
  *----------------------------------------------------------------
@@ -1207,11 +1229,11 @@
  */
 
 /*
  * 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
 
@@ -1381,11 +1403,11 @@
  * void	TclEmitPush(int objIndex, CompileEnv *envPtr);
  */
 
 #define TclEmitPush(objIndex, envPtr) \
     do {							 \
-	register int _objIndexCopy = (objIndex);			 \
+	int _objIndexCopy = (objIndex);			 \
 	if (_objIndexCopy <= 255) {				 \
 	    TclEmitInstInt1(INST_PUSH1, _objIndexCopy, (envPtr)); \
 	} else {						 \
 	    TclEmitInstInt4(INST_PUSH4, _objIndexCopy, (envPtr)); \
 	}							 \
@@ -1526,19 +1548,19 @@
 /*
  * Convenience macros for use when pushing literals. The ANSI C "prototype" for
  * these macros are:
  *
  * static void		PushLiteral(CompileEnv *envPtr,
- *			    const char *string, size_t length);
+ *			    const char *string, int length);
  * static void		PushStringLiteral(CompileEnv *envPtr,
  *			    const char *string);
  */
 
 #define PushLiteral(envPtr, string, length) \
     TclEmitPush(TclRegisterLiteral(envPtr, string, length, 0), (envPtr))
 #define PushStringLiteral(envPtr, string) \
-    PushLiteral(envPtr, string, sizeof(string "") - 1)
+    PushLiteral(envPtr, string, (int) (sizeof(string "") - 1))
 
 /*
  * Macro to advance to the next token; it is more mnemonic than the address
  * arithmetic that it replaces. The ANSI C "prototype" for this macro is:
  *
@@ -1550,11 +1572,11 @@
 
 /*
  * Macro to get the offset to the next instruction to be issued. The ANSI C
  * "prototype" for this macro is:
  *
- * static ptrdiff_t	CurrentOffset(CompileEnv *envPtr);
+ * static int	CurrentOffset(CompileEnv *envPtr);
  */
 
 #define CurrentOffset(envPtr) \
     ((envPtr)->codeNext - (envPtr)->codeStart)
 
@@ -1802,12 +1824,12 @@
     int tclDTraceDebugEnabled = TCL_DTRACE_DEBUG_LOG_ENABLED;	\
     int tclDTraceDebugIndent = 0;				\
     FILE *tclDTraceDebugLog = NULL;				\
     void TclDTraceOpenDebugLog(void) {				\
 	char n[35];						\
-	sprintf(n, "/tmp/tclDTraceDebug-%" TCL_Z_MODIFIER "u.log",		\
-		(size_t) getpid());			\
+	sprintf(n, "/tmp/tclDTraceDebug-%lu.log",		\
+		(unsigned long) getpid());			\
 	tclDTraceDebugLog = fopen(n, "a");			\
     }
 
 #define TclDTraceDbgMsg(p, m, ...) \
     do {								\

Index: generic/tclConfig.c
==================================================================
--- generic/tclConfig.c
+++ generic/tclConfig.c
@@ -29,11 +29,11 @@
  * A ClientData struct for the QueryConfig command.  Store the three bits
  * of data we need; the package name for which we store a config dict,
  * the (Tcl_Interp *) in which it is stored, and the encoding.
  */
 
-typedef struct {
+typedef struct QCCD {
     Tcl_Obj *pkg;
     Tcl_Interp *interp;
     char *encoding;
 } QCCD;
 
@@ -77,15 +77,15 @@
 				 * configuration values, ASCII, thus UTF-8. */
 {
     Tcl_Obj *pDB, *pkgDict;
     Tcl_DString cmdName;
     const Tcl_Config *cfg;
-    QCCD *cdPtr = Tcl_Alloc(sizeof(QCCD));
+    QCCD *cdPtr = ckalloc(sizeof(QCCD));
 
     cdPtr->interp = interp;
     if (valEncoding) {
-	cdPtr->encoding = Tcl_Alloc(strlen(valEncoding)+1);
+	cdPtr->encoding = ckalloc(strlen(valEncoding)+1);
 	strcpy(cdPtr->encoding, valEncoding);
     } else {
 	cdPtr->encoding = NULL;
     }
     cdPtr->pkg = Tcl_NewStringObj(pkgName, -1);
@@ -200,12 +200,11 @@
     struct Tcl_Obj *const *objv)
 {
     QCCD *cdPtr = clientData;
     Tcl_Obj *pkgName = cdPtr->pkg;
     Tcl_Obj *pDB, *pkgDict, *val, *listPtr;
-    size_t n = 0;
-    int index, m;
+    int n, index;
     static const char *const subcmdStrings[] = {
 	"get", "list", NULL
     };
     enum subcmds {
 	CFG_GET, CFG_LIST
@@ -260,11 +259,11 @@
 	}
 	/*
 	 * Value is stored as-is in a byte array, see Bug [9b2e636361],
 	 * so we have to decode it first.
 	 */
-	value = (const char *) TclGetByteArrayFromObj(val, &n);
+	value = (const char *) Tcl_GetByteArrayFromObj(val, &n);
 	value = Tcl_ExternalToUtfDString(venc, value, n, &conv);
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(value,
 		Tcl_DStringLength(&conv)));
 	Tcl_DStringFree(&conv);
 	return TCL_OK;
@@ -273,21 +272,21 @@
 	if (objc != 2) {
 	    Tcl_WrongNumArgs(interp, 2, objv, NULL);
 	    return TCL_ERROR;
 	}
 
-	Tcl_DictObjSize(interp, pkgDict, &m);
-	listPtr = Tcl_NewListObj(m, NULL);
+	Tcl_DictObjSize(interp, pkgDict, &n);
+	listPtr = Tcl_NewListObj(n, NULL);
 
 	if (!listPtr) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "insufficient memory to create list", -1));
 	    Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
 	    return TCL_ERROR;
 	}
 
-	if (m) {
+	if (n) {
 	    Tcl_DictSearch s;
 	    Tcl_Obj *key;
 	    int done;
 
 	    for (Tcl_DictObjFirst(interp, pkgDict, &s, &key, NULL, &done);
@@ -332,13 +331,13 @@
     Tcl_Obj *pDB = GetConfigDict(cdPtr->interp);
 
     Tcl_DictObjRemove(NULL, pDB, pkgName);
     Tcl_DecrRefCount(pkgName);
     if (cdPtr->encoding) {
-	Tcl_Free(cdPtr->encoding);
+	ckfree(cdPtr->encoding);
     }
-    Tcl_Free(cdPtr);
+    ckfree(cdPtr);
 }
 
 /*
  *-------------------------------------------------------------------------
  *

Index: generic/tclDTrace.d
==================================================================
--- generic/tclDTrace.d
+++ generic/tclDTrace.d
@@ -8,11 +8,10 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  */
 
 typedef struct Tcl_Obj Tcl_Obj;
-typedef const char* TclDTraceStr;
 
 /*
  * Tcl DTrace probes
  */
 
@@ -23,39 +22,39 @@
      *	    triggered immediately before proc bytecode execution
      *		arg0: proc name				(string)
      *		arg1: number of arguments		(int)
      *		arg2: array of proc argument objects	(Tcl_Obj**)
      */
-    probe proc__entry(TclDTraceStr name, int objc, struct Tcl_Obj **objv);
+    probe proc__entry(const char *name, int objc, struct Tcl_Obj **objv);
     /*
      *	tcl*:::proc-return probe
      *	    triggered immediately after proc bytecode execution
      *		arg0: proc name				(string)
      *		arg1: return code			(int)
      */
-    probe proc__return(TclDTraceStr name, int code);
+    probe proc__return(const char *name, int code);
     /*
      *	tcl*:::proc-result probe
      *	    triggered after proc-return probe and result processing
      *		arg0: proc name				(string)
      *		arg1: return code			(int)
      *		arg2: proc result			(string)
      *		arg3: proc result object		(Tcl_Obj*)
      */
-    probe proc__result(TclDTraceStr name, int code, TclDTraceStr result,
+    probe proc__result(const char *name, int code, const char *result,
 	    struct Tcl_Obj *resultobj);
     /*
      *	tcl*:::proc-args probe
      *	    triggered before proc-entry probe, gives access to string
      *	    representation of proc arguments
      *		arg0: proc name				(string)
      *		arg1-arg9: proc arguments or NULL	(strings)
      */
-    probe proc__args(TclDTraceStr name, TclDTraceStr arg1, TclDTraceStr arg2,
-	    TclDTraceStr arg3, TclDTraceStr arg4, TclDTraceStr arg5,
-	    TclDTraceStr arg6, TclDTraceStr arg7, TclDTraceStr arg8,
-	    TclDTraceStr arg9);
+    probe proc__args(const char *name, const char *arg1, const char *arg2,
+	    const char *arg3, const char *arg4, const char *arg5,
+	    const char *arg6, const char *arg7, const char *arg8,
+	    const char *arg9);
     /*
      *	tcl*:::proc-info probe
      *	    triggered before proc-entry probe, gives access to TIP 280
      *	    information for the proc invocation (i.e. [info frame 0])
      *		arg0: TIP 280 cmd			(string)
@@ -65,51 +64,51 @@
      *		arg4: TIP 280 line			(int)
      *		arg5: TIP 280 level			(int)
      *		arg6: TclOO method			(string)
      *		arg7: TclOO class/object		(string)
      */
-    probe proc__info(TclDTraceStr cmd, TclDTraceStr type, TclDTraceStr proc,
-	    TclDTraceStr file, int line, int level, TclDTraceStr method,
-	    TclDTraceStr class);
+    probe proc__info(const char *cmd, const char *type, const char *proc,
+	    const char *file, int line, int level, const char *method,
+	    const char *class);
 
     /***************************** cmd probes ******************************/
     /*
      *	tcl*:::cmd-entry probe
      *	    triggered immediately before commmand execution
      *		arg0: command name			(string)
      *		arg1: number of arguments		(int)
      *		arg2: array of command argument objects	(Tcl_Obj**)
      */
-    probe cmd__entry(TclDTraceStr name, int objc, struct Tcl_Obj **objv);
+    probe cmd__entry(const char *name, int objc, struct Tcl_Obj **objv);
     /*
      *	tcl*:::cmd-return probe
      *	    triggered immediately after commmand execution
      *		arg0: command name			(string)
      *		arg1: return code			(int)
      */
-    probe cmd__return(TclDTraceStr name, int code);
+    probe cmd__return(const char *name, int code);
     /*
      *	tcl*:::cmd-result probe
      *	    triggered after cmd-return probe and result processing
      *		arg0: command name			(string)
      *		arg1: return code			(int)
      *		arg2: command result			(string)
      *		arg3: command result object		(Tcl_Obj*)
      */
-    probe cmd__result(TclDTraceStr name, int code, TclDTraceStr result,
+    probe cmd__result(const char *name, int code, const char *result,
 	    struct Tcl_Obj *resultobj);
     /*
      *	tcl*:::cmd-args probe
      *	    triggered before cmd-entry probe, gives access to string
      *	    representation of command arguments
      *		arg0: command name			(string)
      *		arg1-arg9: command arguments or NULL	(strings)
      */
-    probe cmd__args(TclDTraceStr name, TclDTraceStr arg1, TclDTraceStr arg2,
-	    TclDTraceStr arg3, TclDTraceStr arg4, TclDTraceStr arg5,
-	    TclDTraceStr arg6, TclDTraceStr arg7, TclDTraceStr arg8,
-	    TclDTraceStr arg9);
+    probe cmd__args(const char *name, const char *arg1, const char *arg2,
+	    const char *arg3, const char *arg4, const char *arg5,
+	    const char *arg6, const char *arg7, const char *arg8,
+	    const char *arg9);
     /*
      *	tcl*:::cmd-info probe
      *	    triggered before cmd-entry probe, gives access to TIP 280
      *	    information for the command invocation (i.e. [info frame 0])
      *		arg0: TIP 280 cmd			(string)
@@ -119,31 +118,31 @@
      *		arg4: TIP 280 line			(int)
      *		arg5: TIP 280 level			(int)
      *		arg6: TclOO method			(string)
      *		arg7: TclOO class/object		(string)
      */
-    probe cmd__info(TclDTraceStr cmd, TclDTraceStr type, TclDTraceStr proc,
-	    TclDTraceStr file, int line, int level, TclDTraceStr method,
-	    TclDTraceStr class);
+    probe cmd__info(const char *cmd, const char *type, const char *proc,
+	    const char *file, int line, int level, const char *method,
+	    const char *class);
 
     /***************************** inst probes *****************************/
     /*
      *	tcl*:::inst-start probe
      *	    triggered immediately before execution of a bytecode
      *		arg0: bytecode name			(string)
      *		arg1: depth of stack			(int)
      *		arg2: top of stack			(Tcl_Obj**)
      */
-    probe inst__start(TclDTraceStr name, int depth, struct Tcl_Obj **stack);
+    probe inst__start(const char *name, int depth, struct Tcl_Obj **stack);
     /*
      *	tcl*:::inst-done probe
      *	    triggered immediately after execution of a bytecode
      *		arg0: bytecode name			(string)
      *		arg1: depth of stack			(int)
      *		arg2: top of stack			(Tcl_Obj**)
      */
-    probe inst__done(TclDTraceStr name, int depth, struct Tcl_Obj **stack);
+    probe inst__done(const char *name, int depth, struct Tcl_Obj **stack);
 
     /***************************** obj probes ******************************/
     /*
      *	tcl*:::obj-create probe
      *	    triggered immediately after a new Tcl_Obj has been created
@@ -161,33 +160,33 @@
     /*
      *	tcl*:::tcl-probe probe
      *	    triggered when the ::tcl::dtrace command is called
      *		arg0-arg9: command arguments		(strings)
      */
-    probe tcl__probe(TclDTraceStr arg0, TclDTraceStr arg1, TclDTraceStr arg2,
-	    TclDTraceStr arg3, TclDTraceStr arg4, TclDTraceStr arg5,
-	    TclDTraceStr arg6, TclDTraceStr arg7, TclDTraceStr arg8,
-	    TclDTraceStr arg9);
+    probe tcl__probe(const char *arg0, const char *arg1, const char *arg2,
+	    const char *arg3, const char *arg4, const char *arg5,
+	    const char *arg6, const char *arg7, const char *arg8,
+	    const char *arg9);
 };
 
 /*
  * Tcl types and constants for use in DTrace scripts
  */
 
 typedef struct Tcl_ObjType {
-    char *name;
+    const char *name;
     void *freeIntRepProc;
     void *dupIntRepProc;
     void *updateStringProc;
     void *setFromAnyProc;
 } Tcl_ObjType;
 
 struct Tcl_Obj {
-    size_t refCount;
+    int refCount;
     char *bytes;
-    size_t length;
-    Tcl_ObjType *typePtr;
+    int length;
+    const Tcl_ObjType *typePtr;
     union {
 	long longValue;
 	double doubleValue;
 	void *otherValuePtr;
 	int64_t wideValue;

Index: generic/tclDate.c
==================================================================
--- generic/tclDate.c
+++ generic/tclDate.c
@@ -91,10 +91,21 @@
  */
 
 #ifdef _MSC_VER
 #pragma warning( disable : 4102 )
 #endif /* _MSC_VER */
+
+/*
+ * Meridian: am, pm, or 24-hour style.
+ */
+
+typedef enum _MERIDIAN {
+    MERam, MERpm, MER24
+} MERIDIAN;
+
+
+
 
 /*
  * yyparse will accept a 'struct DateInfo' as its parameter; that's where the
  * parsed fields will be returned.
  */
@@ -110,11 +121,11 @@
     int dateHaveDate;
 
     time_t dateHour;
     time_t dateMinutes;
     time_t dateSeconds;
-    int dateMeridian;
+    MERIDIAN dateMeridian;
     int dateHaveTime;
 
     time_t dateTimezone;
     int dateDSTmode;
     int dateHaveZone;
@@ -136,12 +147,12 @@
     time_t *dateRelPointer;
 
     int dateDigitCount;
 } DateInfo;
 
-#define YYMALLOC	Tcl_Alloc
-#define YYFREE(x)	(Tcl_Free((void*) (x)))
+#define YYMALLOC	ckalloc
+#define YYFREE(x)	(ckfree((void*) (x)))
 
 #define yyDSTmode	(info->dateDSTmode)
 #define yyDayOrdinal	(info->dateDayOrdinal)
 #define yyDayNumber	(info->dateDayNumber)
 #define yyMonthOrdinal	(info->dateMonthOrdinal)
@@ -196,21 +207,10 @@
  */
 
 typedef enum _DSTMODE {
     DSTon, DSToff, DSTmaybe
 } DSTMODE;
-
-/*
- * Meridian: am, pm, or 24-hour style.
- */
-
-typedef enum _MERIDIAN {
-    MERam, MERpm, MER24
-} MERIDIAN;
-
-
-
 
 # ifndef YY_NULLPTR
 #  if defined __cplusplus && 201103L <= __cplusplus
 #   define YY_NULLPTR nullptr
 #  else
@@ -2547,13 +2547,13 @@
 static int
 LookupWord(
     YYSTYPE* yylvalPtr,
     char *buff)
 {
-    register char *p;
-    register char *q;
-    register const TABLE *tp;
+    char *p;
+    char *q;
+    const TABLE *tp;
     int i, abbrev;
 
     /*
      * Make it lowercase.
      */
@@ -2672,12 +2672,12 @@
 TclDatelex(
     YYSTYPE* yylvalPtr,
     YYLTYPE* location,
     DateInfo *info)
 {
-    register char c;
-    register char *p;
+    char c;
+    char *p;
     char buff[20];
     int Count;
 
     location->first_column = yyInput - info->dateStart;
     for ( ; ; ) {
@@ -2759,11 +2759,11 @@
 	Tcl_WrongNumArgs(interp, 1, objv,
 		"stringToParse baseYear baseMonth baseDay" );
 	return TCL_ERROR;
     }
 
-    yyInput = TclGetString(objv[1]);
+    yyInput = Tcl_GetString( objv[1] );
     dateInfo.dateStart = yyInput;
 
     yyHaveDate = 0;
     if (Tcl_GetIntFromObj(interp, objv[2], &yr) != TCL_OK
 	    || Tcl_GetIntFromObj(interp, objv[3], &mo) != TCL_OK
@@ -2846,60 +2846,60 @@
 
     result = Tcl_NewObj();
     resultElement = Tcl_NewObj();
     if (yyHaveDate) {
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyYear));
+		Tcl_NewIntObj((int) yyYear));
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyMonth));
+		Tcl_NewIntObj((int) yyMonth));
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyDay));
+		Tcl_NewIntObj((int) yyDay));
     }
     Tcl_ListObjAppendElement(interp, result, resultElement);
 
     if (yyHaveTime) {
-	Tcl_ListObjAppendElement(interp, result, Tcl_NewIntObj(
+	Tcl_ListObjAppendElement(interp, result, Tcl_NewIntObj((int)
 		ToSeconds(yyHour, yyMinutes, yySeconds, yyMeridian)));
     } else {
 	Tcl_ListObjAppendElement(interp, result, Tcl_NewObj());
     }
 
     resultElement = Tcl_NewObj();
     if (yyHaveZone) {
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(-yyTimezone));
+		Tcl_NewIntObj((int) -yyTimezone));
 	Tcl_ListObjAppendElement(interp, resultElement,
 		Tcl_NewIntObj(1 - yyDSTmode));
     }
     Tcl_ListObjAppendElement(interp, result, resultElement);
 
     resultElement = Tcl_NewObj();
     if (yyHaveRel) {
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyRelMonth));
+		Tcl_NewIntObj((int) yyRelMonth));
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyRelDay));
+		Tcl_NewIntObj((int) yyRelDay));
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyRelSeconds));
+		Tcl_NewIntObj((int) yyRelSeconds));
     }
     Tcl_ListObjAppendElement(interp, result, resultElement);
 
     resultElement = Tcl_NewObj();
     if (yyHaveDay && !yyHaveDate) {
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyDayOrdinal));
+		Tcl_NewIntObj((int) yyDayOrdinal));
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyDayNumber));
+		Tcl_NewIntObj((int) yyDayNumber));
     }
     Tcl_ListObjAppendElement(interp, result, resultElement);
 
     resultElement = Tcl_NewObj();
     if (yyHaveOrdinalMonth) {
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyMonthOrdinal));
+		Tcl_NewIntObj((int) yyMonthOrdinal));
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyMonth));
+		Tcl_NewIntObj((int) yyMonth));
     }
     Tcl_ListObjAppendElement(interp, result, resultElement);
 
     Tcl_SetObjResult(interp, result);
     return TCL_OK;

Index: generic/tclDecls.h
==================================================================
--- generic/tclDecls.h
+++ generic/tclDecls.h
@@ -57,32 +57,32 @@
 				const char *name, const char *version,
 				int exact, void *clientDataPtr);
 /* 2 */
 EXTERN TCL_NORETURN void Tcl_Panic(const char *format, ...) TCL_FORMAT_PRINTF(1, 2);
 /* 3 */
-EXTERN void *		Tcl_Alloc(size_t size);
+EXTERN char *		Tcl_Alloc(unsigned int size);
 /* 4 */
-EXTERN void		Tcl_Free(void *ptr);
+EXTERN void		Tcl_Free(char *ptr);
 /* 5 */
-EXTERN void *		Tcl_Realloc(void *ptr, size_t size);
+EXTERN char *		Tcl_Realloc(char *ptr, unsigned int size);
 /* 6 */
-EXTERN void *		Tcl_DbCkalloc(size_t size, const char *file,
+EXTERN char *		Tcl_DbCkalloc(unsigned int size, const char *file,
 				int line);
 /* 7 */
-EXTERN void		Tcl_DbCkfree(void *ptr, const char *file, int line);
+EXTERN void		Tcl_DbCkfree(char *ptr, const char *file, int line);
 /* 8 */
-EXTERN void *		Tcl_DbCkrealloc(void *ptr, size_t size,
+EXTERN char *		Tcl_DbCkrealloc(char *ptr, unsigned int size,
 				const char *file, int line);
 #if !defined(_WIN32) && !defined(MAC_OSX_TCL) /* UNIX */
 /* 9 */
 EXTERN void		Tcl_CreateFileHandler(int fd, int mask,
-				Tcl_FileProc *proc, void *clientData);
+				Tcl_FileProc *proc, ClientData clientData);
 #endif /* UNIX */
 #ifdef MAC_OSX_TCL /* MACOSX */
 /* 9 */
 EXTERN void		Tcl_CreateFileHandler(int fd, int mask,
-				Tcl_FileProc *proc, void *clientData);
+				Tcl_FileProc *proc, ClientData clientData);
 #endif /* MACOSX */
 #if !defined(_WIN32) && !defined(MAC_OSX_TCL) /* UNIX */
 /* 10 */
 EXTERN void		Tcl_DeleteFileHandler(int fd);
 #endif /* UNIX */
@@ -101,11 +101,11 @@
 				Tcl_Obj *objPtr);
 /* 15 */
 EXTERN void		Tcl_AppendStringsToObj(Tcl_Obj *objPtr, ...);
 /* 16 */
 EXTERN void		Tcl_AppendToObj(Tcl_Obj *objPtr, const char *bytes,
-				size_t length);
+				int length);
 /* 17 */
 EXTERN Tcl_Obj *	Tcl_ConcatObj(int objc, Tcl_Obj *const objv[]);
 /* 18 */
 EXTERN int		Tcl_ConvertToType(Tcl_Interp *interp,
 				Tcl_Obj *objPtr, const Tcl_ObjType *typePtr);
@@ -116,29 +116,36 @@
 EXTERN void		Tcl_DbIncrRefCount(Tcl_Obj *objPtr, const char *file,
 				int line);
 /* 21 */
 EXTERN int		Tcl_DbIsShared(Tcl_Obj *objPtr, const char *file,
 				int line);
-/* Slot 22 is reserved */
+/* 22 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+Tcl_Obj *		Tcl_DbNewBooleanObj(int boolValue, const char *file,
+				int line);
 /* 23 */
 EXTERN Tcl_Obj *	Tcl_DbNewByteArrayObj(const unsigned char *bytes,
-				size_t length, 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);
 /* 25 */
 EXTERN Tcl_Obj *	Tcl_DbNewListObj(int objc, Tcl_Obj *const *objv,
 				const char *file, int line);
-/* Slot 26 is reserved */
+/* 26 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+Tcl_Obj *		Tcl_DbNewLongObj(long longValue, const char *file,
+				int line);
 /* 27 */
 EXTERN Tcl_Obj *	Tcl_DbNewObj(const char *file, int line);
 /* 28 */
-EXTERN Tcl_Obj *	Tcl_DbNewStringObj(const char *bytes, size_t length,
+EXTERN Tcl_Obj *	Tcl_DbNewStringObj(const char *bytes, int length,
 				const char *file, int line);
 /* 29 */
 EXTERN Tcl_Obj *	Tcl_DuplicateObj(Tcl_Obj *objPtr);
-/* Slot 30 is reserved */
+/* 30 */
+EXTERN void		TclOldFreeObj(Tcl_Obj *objPtr);
 /* 31 */
 EXTERN int		Tcl_GetBoolean(Tcl_Interp *interp, const char *src,
 				int *boolPtr);
 /* 32 */
 EXTERN int		Tcl_GetBooleanFromObj(Tcl_Interp *interp,
@@ -150,11 +157,15 @@
 EXTERN int		Tcl_GetDouble(Tcl_Interp *interp, const char *src,
 				double *doublePtr);
 /* 35 */
 EXTERN int		Tcl_GetDoubleFromObj(Tcl_Interp *interp,
 				Tcl_Obj *objPtr, double *doublePtr);
-/* Slot 36 is reserved */
+/* 36 */
+TCL_DEPRECATED("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);
 /* 37 */
 EXTERN int		Tcl_GetInt(Tcl_Interp *interp, const char *src,
 				int *intPtr);
 /* 38 */
 EXTERN int		Tcl_GetIntFromObj(Tcl_Interp *interp,
@@ -161,11 +172,11 @@
 				Tcl_Obj *objPtr, int *intPtr);
 /* 39 */
 EXTERN int		Tcl_GetLongFromObj(Tcl_Interp *interp,
 				Tcl_Obj *objPtr, long *longPtr);
 /* 40 */
-EXTERN const Tcl_ObjType * Tcl_GetObjType(const char *typeName);
+EXTERN CONST86 Tcl_ObjType * Tcl_GetObjType(const char *typeName);
 /* 41 */
 EXTERN char *		Tcl_GetStringFromObj(Tcl_Obj *objPtr, int *lengthPtr);
 /* 42 */
 EXTERN void		Tcl_InvalidateStringRep(Tcl_Obj *objPtr);
 /* 43 */
@@ -187,87 +198,109 @@
 				Tcl_Obj *listPtr, int *lengthPtr);
 /* 48 */
 EXTERN int		Tcl_ListObjReplace(Tcl_Interp *interp,
 				Tcl_Obj *listPtr, int first, int count,
 				int objc, Tcl_Obj *const objv[]);
-/* Slot 49 is reserved */
+/* 49 */
+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,
-				size_t length);
+				int length);
 /* 51 */
 EXTERN Tcl_Obj *	Tcl_NewDoubleObj(double doubleValue);
-/* Slot 52 is reserved */
+/* 52 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+Tcl_Obj *		Tcl_NewIntObj(int intValue);
 /* 53 */
 EXTERN Tcl_Obj *	Tcl_NewListObj(int objc, Tcl_Obj *const objv[]);
-/* Slot 54 is reserved */
+/* 54 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+Tcl_Obj *		Tcl_NewLongObj(long longValue);
 /* 55 */
 EXTERN Tcl_Obj *	Tcl_NewObj(void);
 /* 56 */
-EXTERN Tcl_Obj *	Tcl_NewStringObj(const char *bytes, size_t length);
-/* Slot 57 is reserved */
+EXTERN Tcl_Obj *	Tcl_NewStringObj(const char *bytes, int length);
+/* 57 */
+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,
-				size_t length);
+EXTERN unsigned char *	Tcl_SetByteArrayLength(Tcl_Obj *objPtr, int length);
 /* 59 */
 EXTERN void		Tcl_SetByteArrayObj(Tcl_Obj *objPtr,
-				const unsigned char *bytes, size_t length);
+				const unsigned char *bytes, int length);
 /* 60 */
 EXTERN void		Tcl_SetDoubleObj(Tcl_Obj *objPtr, double doubleValue);
-/* Slot 61 is reserved */
+/* 61 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+void			Tcl_SetIntObj(Tcl_Obj *objPtr, int intValue);
 /* 62 */
 EXTERN void		Tcl_SetListObj(Tcl_Obj *objPtr, int objc,
 				Tcl_Obj *const objv[]);
-/* Slot 63 is reserved */
+/* 63 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+void			Tcl_SetLongObj(Tcl_Obj *objPtr, long longValue);
 /* 64 */
-EXTERN void		Tcl_SetObjLength(Tcl_Obj *objPtr, size_t length);
+EXTERN void		Tcl_SetObjLength(Tcl_Obj *objPtr, int length);
 /* 65 */
 EXTERN void		Tcl_SetStringObj(Tcl_Obj *objPtr, const char *bytes,
-				size_t length);
-/* Slot 66 is reserved */
-/* Slot 67 is reserved */
+				int length);
+/* 66 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+void			Tcl_AddErrorInfo(Tcl_Interp *interp,
+				const char *message);
+/* 67 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+void			Tcl_AddObjErrorInfo(Tcl_Interp *interp,
+				const char *message, int length);
 /* 68 */
 EXTERN void		Tcl_AllowExceptions(Tcl_Interp *interp);
 /* 69 */
 EXTERN void		Tcl_AppendElement(Tcl_Interp *interp,
 				const char *element);
 /* 70 */
 EXTERN void		Tcl_AppendResult(Tcl_Interp *interp, ...);
 /* 71 */
 EXTERN Tcl_AsyncHandler	 Tcl_AsyncCreate(Tcl_AsyncProc *proc,
-				void *clientData);
+				ClientData clientData);
 /* 72 */
 EXTERN void		Tcl_AsyncDelete(Tcl_AsyncHandler async);
 /* 73 */
 EXTERN int		Tcl_AsyncInvoke(Tcl_Interp *interp, int code);
 /* 74 */
 EXTERN void		Tcl_AsyncMark(Tcl_AsyncHandler async);
 /* 75 */
 EXTERN int		Tcl_AsyncReady(void);
-/* Slot 76 is reserved */
-/* Slot 77 is reserved */
+/* 76 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+void			Tcl_BackgroundError(Tcl_Interp *interp);
+/* 77 */
+TCL_DEPRECATED("Use Tcl_UtfBackslash")
+char			Tcl_Backslash(const char *src, int *readPtr);
 /* 78 */
 EXTERN int		Tcl_BadChannelOption(Tcl_Interp *interp,
 				const char *optionName,
 				const char *optionList);
 /* 79 */
 EXTERN void		Tcl_CallWhenDeleted(Tcl_Interp *interp,
-				Tcl_InterpDeleteProc *proc, void *clientData);
+				Tcl_InterpDeleteProc *proc,
+				ClientData clientData);
 /* 80 */
 EXTERN void		Tcl_CancelIdleCall(Tcl_IdleProc *idleProc,
-				void *clientData);
+				ClientData clientData);
 /* 81 */
 EXTERN int		Tcl_Close(Tcl_Interp *interp, Tcl_Channel chan);
 /* 82 */
 EXTERN int		Tcl_CommandComplete(const char *cmd);
 /* 83 */
 EXTERN char *		Tcl_Concat(int argc, const char *const *argv);
 /* 84 */
-EXTERN size_t		Tcl_ConvertElement(const char *src, char *dst,
+EXTERN int		Tcl_ConvertElement(const char *src, char *dst,
 				int flags);
 /* 85 */
-EXTERN size_t		Tcl_ConvertCountedElement(const char *src,
-				size_t length, char *dst, int flags);
+EXTERN int		Tcl_ConvertCountedElement(const char *src,
+				int length, char *dst, int flags);
 /* 86 */
 EXTERN int		Tcl_CreateAlias(Tcl_Interp *slave,
 				const char *slaveCmd, Tcl_Interp *target,
 				const char *targetCmd, int argc,
 				const char *const *argv);
@@ -276,72 +309,78 @@
 				const char *slaveCmd, Tcl_Interp *target,
 				const char *targetCmd, int objc,
 				Tcl_Obj *const objv[]);
 /* 88 */
 EXTERN Tcl_Channel	Tcl_CreateChannel(const Tcl_ChannelType *typePtr,
-				const char *chanName, void *instanceData,
-				int mask);
+				const char *chanName,
+				ClientData instanceData, int mask);
 /* 89 */
 EXTERN void		Tcl_CreateChannelHandler(Tcl_Channel chan, int mask,
-				Tcl_ChannelProc *proc, void *clientData);
+				Tcl_ChannelProc *proc, ClientData clientData);
 /* 90 */
 EXTERN void		Tcl_CreateCloseHandler(Tcl_Channel chan,
-				Tcl_CloseProc *proc, void *clientData);
+				Tcl_CloseProc *proc, ClientData clientData);
 /* 91 */
 EXTERN Tcl_Command	Tcl_CreateCommand(Tcl_Interp *interp,
 				const char *cmdName, Tcl_CmdProc *proc,
-				void *clientData,
+				ClientData clientData,
 				Tcl_CmdDeleteProc *deleteProc);
 /* 92 */
 EXTERN void		Tcl_CreateEventSource(Tcl_EventSetupProc *setupProc,
 				Tcl_EventCheckProc *checkProc,
-				void *clientData);
+				ClientData clientData);
 /* 93 */
 EXTERN void		Tcl_CreateExitHandler(Tcl_ExitProc *proc,
-				void *clientData);
+				ClientData clientData);
 /* 94 */
 EXTERN Tcl_Interp *	Tcl_CreateInterp(void);
-/* Slot 95 is reserved */
+/* 95 */
+TCL_DEPRECATED("")
+void			Tcl_CreateMathFunc(Tcl_Interp *interp,
+				const char *name, int numArgs,
+				Tcl_ValueType *argTypes, Tcl_MathProc *proc,
+				ClientData clientData);
 /* 96 */
 EXTERN Tcl_Command	Tcl_CreateObjCommand(Tcl_Interp *interp,
 				const char *cmdName, Tcl_ObjCmdProc *proc,
-				void *clientData,
+				ClientData clientData,
 				Tcl_CmdDeleteProc *deleteProc);
 /* 97 */
 EXTERN Tcl_Interp *	Tcl_CreateSlave(Tcl_Interp *interp,
 				const char *slaveName, int isSafe);
 /* 98 */
 EXTERN Tcl_TimerToken	Tcl_CreateTimerHandler(int milliseconds,
-				Tcl_TimerProc *proc, void *clientData);
+				Tcl_TimerProc *proc, ClientData clientData);
 /* 99 */
 EXTERN Tcl_Trace	Tcl_CreateTrace(Tcl_Interp *interp, int level,
-				Tcl_CmdTraceProc *proc, void *clientData);
+				Tcl_CmdTraceProc *proc,
+				ClientData clientData);
 /* 100 */
 EXTERN void		Tcl_DeleteAssocData(Tcl_Interp *interp,
 				const char *name);
 /* 101 */
 EXTERN void		Tcl_DeleteChannelHandler(Tcl_Channel chan,
-				Tcl_ChannelProc *proc, void *clientData);
+				Tcl_ChannelProc *proc, ClientData clientData);
 /* 102 */
 EXTERN void		Tcl_DeleteCloseHandler(Tcl_Channel chan,
-				Tcl_CloseProc *proc, void *clientData);
+				Tcl_CloseProc *proc, ClientData clientData);
 /* 103 */
 EXTERN int		Tcl_DeleteCommand(Tcl_Interp *interp,
 				const char *cmdName);
 /* 104 */
 EXTERN int		Tcl_DeleteCommandFromToken(Tcl_Interp *interp,
 				Tcl_Command command);
 /* 105 */
 EXTERN void		Tcl_DeleteEvents(Tcl_EventDeleteProc *proc,
-				void *clientData);
+				ClientData clientData);
 /* 106 */
 EXTERN void		Tcl_DeleteEventSource(Tcl_EventSetupProc *setupProc,
 				Tcl_EventCheckProc *checkProc,
-				void *clientData);
+				ClientData clientData);
 /* 107 */
 EXTERN void		Tcl_DeleteExitHandler(Tcl_ExitProc *proc,
-				void *clientData);
+				ClientData clientData);
 /* 108 */
 EXTERN void		Tcl_DeleteHashEntry(Tcl_HashEntry *entryPtr);
 /* 109 */
 EXTERN void		Tcl_DeleteHashTable(Tcl_HashTable *tablePtr);
 /* 110 */
@@ -352,18 +391,20 @@
 EXTERN void		Tcl_DeleteTimerHandler(Tcl_TimerToken token);
 /* 113 */
 EXTERN void		Tcl_DeleteTrace(Tcl_Interp *interp, Tcl_Trace trace);
 /* 114 */
 EXTERN void		Tcl_DontCallWhenDeleted(Tcl_Interp *interp,
-				Tcl_InterpDeleteProc *proc, void *clientData);
+				Tcl_InterpDeleteProc *proc,
+				ClientData clientData);
 /* 115 */
 EXTERN int		Tcl_DoOneEvent(int flags);
 /* 116 */
-EXTERN void		Tcl_DoWhenIdle(Tcl_IdleProc *proc, void *clientData);
+EXTERN void		Tcl_DoWhenIdle(Tcl_IdleProc *proc,
+				ClientData clientData);
 /* 117 */
 EXTERN char *		Tcl_DStringAppend(Tcl_DString *dsPtr,
-				const char *bytes, size_t length);
+				const char *bytes, int length);
 /* 118 */
 EXTERN char *		Tcl_DStringAppendElement(Tcl_DString *dsPtr,
 				const char *element);
 /* 119 */
 EXTERN void		Tcl_DStringEndSublist(Tcl_DString *dsPtr);
@@ -376,27 +417,29 @@
 EXTERN void		Tcl_DStringInit(Tcl_DString *dsPtr);
 /* 123 */
 EXTERN void		Tcl_DStringResult(Tcl_Interp *interp,
 				Tcl_DString *dsPtr);
 /* 124 */
-EXTERN void		Tcl_DStringSetLength(Tcl_DString *dsPtr,
-				size_t length);
+EXTERN void		Tcl_DStringSetLength(Tcl_DString *dsPtr, int length);
 /* 125 */
 EXTERN void		Tcl_DStringStartSublist(Tcl_DString *dsPtr);
 /* 126 */
 EXTERN int		Tcl_Eof(Tcl_Channel chan);
 /* 127 */
 EXTERN const char *	Tcl_ErrnoId(void);
 /* 128 */
 EXTERN const char *	Tcl_ErrnoMsg(int err);
-/* Slot 129 is reserved */
+/* 129 */
+EXTERN int		Tcl_Eval(Tcl_Interp *interp, const char *script);
 /* 130 */
 EXTERN int		Tcl_EvalFile(Tcl_Interp *interp,
 				const char *fileName);
-/* Slot 131 is reserved */
+/* 131 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+int			Tcl_EvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr);
 /* 132 */
-EXTERN void		Tcl_EventuallyFree(void *clientData,
+EXTERN void		Tcl_EventuallyFree(ClientData clientData,
 				Tcl_FreeProc *freeProc);
 /* 133 */
 EXTERN TCL_NORETURN void Tcl_Exit(int status);
 /* 134 */
 EXTERN int		Tcl_ExposeCommand(Tcl_Interp *interp,
@@ -425,11 +468,12 @@
 				Tcl_Obj **resultPtrPtr);
 /* 142 */
 EXTERN int		Tcl_ExprString(Tcl_Interp *interp, const char *expr);
 /* 143 */
 EXTERN void		Tcl_Finalize(void);
-/* Slot 144 is reserved */
+/* 144 */
+EXTERN void		Tcl_FindExecutable(const char *argv0);
 /* 145 */
 EXTERN Tcl_HashEntry *	Tcl_FirstHashEntry(Tcl_HashTable *tablePtr,
 				Tcl_HashSearch *searchPtr);
 /* 146 */
 EXTERN int		Tcl_Flush(Tcl_Channel chan);
@@ -446,33 +490,33 @@
 				const char *slaveCmd,
 				Tcl_Interp **targetInterpPtr,
 				const char **targetCmdPtr, int *objcPtr,
 				Tcl_Obj ***objv);
 /* 150 */
-EXTERN void *		Tcl_GetAssocData(Tcl_Interp *interp,
+EXTERN ClientData	Tcl_GetAssocData(Tcl_Interp *interp,
 				const char *name,
 				Tcl_InterpDeleteProc **procPtr);
 /* 151 */
 EXTERN Tcl_Channel	Tcl_GetChannel(Tcl_Interp *interp,
 				const char *chanName, int *modePtr);
 /* 152 */
 EXTERN int		Tcl_GetChannelBufferSize(Tcl_Channel chan);
 /* 153 */
 EXTERN int		Tcl_GetChannelHandle(Tcl_Channel chan, int direction,
-				void **handlePtr);
+				ClientData *handlePtr);
 /* 154 */
-EXTERN void *		Tcl_GetChannelInstanceData(Tcl_Channel chan);
+EXTERN ClientData	Tcl_GetChannelInstanceData(Tcl_Channel chan);
 /* 155 */
 EXTERN int		Tcl_GetChannelMode(Tcl_Channel chan);
 /* 156 */
 EXTERN const char *	Tcl_GetChannelName(Tcl_Channel chan);
 /* 157 */
 EXTERN int		Tcl_GetChannelOption(Tcl_Interp *interp,
 				Tcl_Channel chan, const char *optionName,
 				Tcl_DString *dsPtr);
 /* 158 */
-EXTERN const Tcl_ChannelType * Tcl_GetChannelType(Tcl_Channel chan);
+EXTERN CONST86 Tcl_ChannelType * Tcl_GetChannelType(Tcl_Channel chan);
 /* 159 */
 EXTERN int		Tcl_GetCommandInfo(Tcl_Interp *interp,
 				const char *cmdName, Tcl_CmdInfo *infoPtr);
 /* 160 */
 EXTERN const char *	Tcl_GetCommandName(Tcl_Interp *interp,
@@ -492,38 +536,47 @@
 EXTERN Tcl_Obj *	Tcl_GetObjResult(Tcl_Interp *interp);
 #if !defined(_WIN32) && !defined(MAC_OSX_TCL) /* UNIX */
 /* 167 */
 EXTERN int		Tcl_GetOpenFile(Tcl_Interp *interp,
 				const char *chanID, int forWriting,
-				int checkUsage, void **filePtr);
+				int checkUsage, ClientData *filePtr);
 #endif /* UNIX */
 #ifdef MAC_OSX_TCL /* MACOSX */
 /* 167 */
 EXTERN int		Tcl_GetOpenFile(Tcl_Interp *interp,
 				const char *chanID, int forWriting,
-				int checkUsage, void **filePtr);
+				int checkUsage, ClientData *filePtr);
 #endif /* MACOSX */
 /* 168 */
 EXTERN Tcl_PathType	Tcl_GetPathType(const char *path);
 /* 169 */
-EXTERN size_t		Tcl_Gets(Tcl_Channel chan, Tcl_DString *dsPtr);
+EXTERN int		Tcl_Gets(Tcl_Channel chan, Tcl_DString *dsPtr);
 /* 170 */
-EXTERN size_t		Tcl_GetsObj(Tcl_Channel chan, Tcl_Obj *objPtr);
+EXTERN int		Tcl_GetsObj(Tcl_Channel chan, Tcl_Obj *objPtr);
 /* 171 */
 EXTERN int		Tcl_GetServiceMode(void);
 /* 172 */
 EXTERN Tcl_Interp *	Tcl_GetSlave(Tcl_Interp *interp,
 				const char *slaveName);
 /* 173 */
 EXTERN Tcl_Channel	Tcl_GetStdChannel(int type);
-/* Slot 174 is reserved */
-/* Slot 175 is reserved */
+/* 174 */
+EXTERN const char *	Tcl_GetStringResult(Tcl_Interp *interp);
+/* 175 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+const char *		Tcl_GetVar(Tcl_Interp *interp, const char *varName,
+				int flags);
 /* 176 */
 EXTERN const char *	Tcl_GetVar2(Tcl_Interp *interp, const char *part1,
 				const char *part2, int flags);
-/* Slot 177 is reserved */
-/* Slot 178 is reserved */
+/* 177 */
+EXTERN int		Tcl_GlobalEval(Tcl_Interp *interp,
+				const char *command);
+/* 178 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+int			Tcl_GlobalEvalObj(Tcl_Interp *interp,
+				Tcl_Obj *objPtr);
 /* 179 */
 EXTERN int		Tcl_HideCommand(Tcl_Interp *interp,
 				const char *cmdName,
 				const char *hiddenCmdToken);
 /* 180 */
@@ -545,15 +598,15 @@
 /* 187 */
 EXTERN int		Tcl_LinkVar(Tcl_Interp *interp, const char *varName,
 				void *addr, int type);
 /* Slot 188 is reserved */
 /* 189 */
-EXTERN Tcl_Channel	Tcl_MakeFileChannel(void *handle, int mode);
+EXTERN Tcl_Channel	Tcl_MakeFileChannel(ClientData handle, int mode);
 /* 190 */
 EXTERN int		Tcl_MakeSafe(Tcl_Interp *interp);
 /* 191 */
-EXTERN Tcl_Channel	Tcl_MakeTcpClientChannel(void *tcpSocket);
+EXTERN Tcl_Channel	Tcl_MakeTcpClientChannel(ClientData tcpSocket);
 /* 192 */
 EXTERN char *		Tcl_Merge(int argc, const char *const *argv);
 /* 193 */
 EXTERN Tcl_HashEntry *	Tcl_NextHashEntry(Tcl_HashSearch *searchPtr);
 /* 194 */
@@ -578,13 +631,13 @@
 				int myport, int async);
 /* 200 */
 EXTERN Tcl_Channel	Tcl_OpenTcpServer(Tcl_Interp *interp, int port,
 				const char *host,
 				Tcl_TcpAcceptProc *acceptProc,
-				void *callbackData);
+				ClientData callbackData);
 /* 201 */
-EXTERN void		Tcl_Preserve(void *data);
+EXTERN void		Tcl_Preserve(ClientData data);
 /* 202 */
 EXTERN void		Tcl_PrintDouble(Tcl_Interp *interp, double value,
 				char *dst);
 /* 203 */
 EXTERN int		Tcl_PutEnv(const char *assignment);
@@ -592,12 +645,11 @@
 EXTERN const char *	Tcl_PosixError(Tcl_Interp *interp);
 /* 205 */
 EXTERN void		Tcl_QueueEvent(Tcl_Event *evPtr,
 				Tcl_QueuePosition position);
 /* 206 */
-EXTERN size_t		Tcl_Read(Tcl_Channel chan, char *bufPtr,
-				size_t toRead);
+EXTERN int		Tcl_Read(Tcl_Channel chan, char *bufPtr, int toRead);
 /* 207 */
 EXTERN void		Tcl_ReapDetachedProcs(void);
 /* 208 */
 EXTERN int		Tcl_RecordAndEval(Tcl_Interp *interp,
 				const char *cmd, int flags);
@@ -617,30 +669,32 @@
 				const char *text, const char *start);
 /* 214 */
 EXTERN int		Tcl_RegExpMatch(Tcl_Interp *interp, const char *text,
 				const char *pattern);
 /* 215 */
-EXTERN void		Tcl_RegExpRange(Tcl_RegExp regexp, size_t index,
+EXTERN void		Tcl_RegExpRange(Tcl_RegExp regexp, int index,
 				const char **startPtr, const char **endPtr);
 /* 216 */
-EXTERN void		Tcl_Release(void *clientData);
+EXTERN void		Tcl_Release(ClientData clientData);
 /* 217 */
 EXTERN void		Tcl_ResetResult(Tcl_Interp *interp);
 /* 218 */
-EXTERN size_t		Tcl_ScanElement(const char *src, int *flagPtr);
+EXTERN int		Tcl_ScanElement(const char *src, int *flagPtr);
 /* 219 */
-EXTERN size_t		Tcl_ScanCountedElement(const char *src,
-				size_t length, int *flagPtr);
-/* Slot 220 is reserved */
+EXTERN int		Tcl_ScanCountedElement(const char *src, int length,
+				int *flagPtr);
+/* 220 */
+TCL_DEPRECATED("")
+int			Tcl_SeekOld(Tcl_Channel chan, int offset, int mode);
 /* 221 */
 EXTERN int		Tcl_ServiceAll(void);
 /* 222 */
 EXTERN int		Tcl_ServiceEvent(int flags);
 /* 223 */
 EXTERN void		Tcl_SetAssocData(Tcl_Interp *interp,
 				const char *name, Tcl_InterpDeleteProc *proc,
-				void *clientData);
+				ClientData clientData);
 /* 224 */
 EXTERN void		Tcl_SetChannelBufferSize(Tcl_Channel chan, int sz);
 /* 225 */
 EXTERN int		Tcl_SetChannelOption(Tcl_Interp *interp,
 				Tcl_Channel chan, const char *optionName,
@@ -653,14 +707,18 @@
 EXTERN void		Tcl_SetErrno(int err);
 /* 228 */
 EXTERN void		Tcl_SetErrorCode(Tcl_Interp *interp, ...);
 /* 229 */
 EXTERN void		Tcl_SetMaxBlockTime(const Tcl_Time *timePtr);
-/* Slot 230 is reserved */
+/* 230 */
+EXTERN void		Tcl_SetPanicProc(
+				TCL_NORETURN1 Tcl_PanicProc *panicProc);
 /* 231 */
 EXTERN int		Tcl_SetRecursionLimit(Tcl_Interp *interp, int depth);
-/* Slot 232 is reserved */
+/* 232 */
+EXTERN void		Tcl_SetResult(Tcl_Interp *interp, char *result,
+				Tcl_FreeProc *freeProc);
 /* 233 */
 EXTERN int		Tcl_SetServiceMode(int mode);
 /* 234 */
 EXTERN void		Tcl_SetObjErrorCode(Tcl_Interp *interp,
 				Tcl_Obj *errorObjPtr);
@@ -667,11 +725,14 @@
 /* 235 */
 EXTERN void		Tcl_SetObjResult(Tcl_Interp *interp,
 				Tcl_Obj *resultObjPtr);
 /* 236 */
 EXTERN void		Tcl_SetStdChannel(Tcl_Channel channel, int type);
-/* Slot 237 is reserved */
+/* 237 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+const char *		Tcl_SetVar(Tcl_Interp *interp, const char *varName,
+				const char *newValue, int flags);
 /* 238 */
 EXTERN const char *	Tcl_SetVar2(Tcl_Interp *interp, const char *part1,
 				const char *part2, const char *newValue,
 				int flags);
 /* 239 */
@@ -685,94 +746,145 @@
 				const char *listStr, int *argcPtr,
 				const char ***argvPtr);
 /* 243 */
 EXTERN void		Tcl_SplitPath(const char *path, int *argcPtr,
 				const char ***argvPtr);
-/* Slot 244 is reserved */
-/* Slot 245 is reserved */
-/* Slot 246 is reserved */
-/* Slot 247 is reserved */
+/* 244 */
+EXTERN void		Tcl_StaticPackage(Tcl_Interp *interp,
+				const char *pkgName,
+				Tcl_PackageInitProc *initProc,
+				Tcl_PackageInitProc *safeInitProc);
+/* 245 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+int			Tcl_StringMatch(const char *str, const char *pattern);
+/* 246 */
+TCL_DEPRECATED("")
+int			Tcl_TellOld(Tcl_Channel chan);
+/* 247 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+int			Tcl_TraceVar(Tcl_Interp *interp, const char *varName,
+				int flags, Tcl_VarTraceProc *proc,
+				ClientData clientData);
 /* 248 */
 EXTERN int		Tcl_TraceVar2(Tcl_Interp *interp, const char *part1,
 				const char *part2, int flags,
-				Tcl_VarTraceProc *proc, void *clientData);
+				Tcl_VarTraceProc *proc,
+				ClientData clientData);
 /* 249 */
 EXTERN char *		Tcl_TranslateFileName(Tcl_Interp *interp,
 				const char *name, Tcl_DString *bufferPtr);
 /* 250 */
-EXTERN size_t		Tcl_Ungets(Tcl_Channel chan, const char *str,
-				size_t len, int atHead);
+EXTERN int		Tcl_Ungets(Tcl_Channel chan, const char *str,
+				int len, int atHead);
 /* 251 */
 EXTERN void		Tcl_UnlinkVar(Tcl_Interp *interp,
 				const char *varName);
 /* 252 */
 EXTERN int		Tcl_UnregisterChannel(Tcl_Interp *interp,
 				Tcl_Channel chan);
-/* Slot 253 is reserved */
+/* 253 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+int			Tcl_UnsetVar(Tcl_Interp *interp, const char *varName,
+				int flags);
 /* 254 */
 EXTERN int		Tcl_UnsetVar2(Tcl_Interp *interp, const char *part1,
 				const char *part2, int flags);
-/* Slot 255 is reserved */
+/* 255 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+void			Tcl_UntraceVar(Tcl_Interp *interp,
+				const char *varName, int flags,
+				Tcl_VarTraceProc *proc,
+				ClientData clientData);
 /* 256 */
 EXTERN void		Tcl_UntraceVar2(Tcl_Interp *interp,
 				const char *part1, const char *part2,
 				int flags, Tcl_VarTraceProc *proc,
-				void *clientData);
+				ClientData clientData);
 /* 257 */
 EXTERN void		Tcl_UpdateLinkedVar(Tcl_Interp *interp,
 				const char *varName);
-/* Slot 258 is reserved */
+/* 258 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+int			Tcl_UpVar(Tcl_Interp *interp, const char *frameName,
+				const char *varName, const char *localName,
+				int flags);
 /* 259 */
 EXTERN int		Tcl_UpVar2(Tcl_Interp *interp, const char *frameName,
 				const char *part1, const char *part2,
 				const char *localName, int flags);
 /* 260 */
 EXTERN int		Tcl_VarEval(Tcl_Interp *interp, ...);
-/* Slot 261 is reserved */
+/* 261 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+ClientData		Tcl_VarTraceInfo(Tcl_Interp *interp,
+				const char *varName, int flags,
+				Tcl_VarTraceProc *procPtr,
+				ClientData prevClientData);
 /* 262 */
-EXTERN void *		Tcl_VarTraceInfo2(Tcl_Interp *interp,
+EXTERN ClientData	Tcl_VarTraceInfo2(Tcl_Interp *interp,
 				const char *part1, const char *part2,
 				int flags, Tcl_VarTraceProc *procPtr,
-				void *prevClientData);
+				ClientData prevClientData);
 /* 263 */
-EXTERN size_t		Tcl_Write(Tcl_Channel chan, const char *s,
-				size_t slen);
+EXTERN int		Tcl_Write(Tcl_Channel chan, const char *s, int slen);
 /* 264 */
 EXTERN void		Tcl_WrongNumArgs(Tcl_Interp *interp, int objc,
 				Tcl_Obj *const objv[], const char *message);
 /* 265 */
 EXTERN int		Tcl_DumpActiveMemory(const char *fileName);
 /* 266 */
 EXTERN void		Tcl_ValidateAllMemory(const char *file, int line);
-/* Slot 267 is reserved */
-/* Slot 268 is reserved */
+/* 267 */
+TCL_DEPRECATED("see TIP #422")
+void			Tcl_AppendResultVA(Tcl_Interp *interp,
+				va_list argList);
+/* 268 */
+TCL_DEPRECATED("see TIP #422")
+void			Tcl_AppendStringsToObjVA(Tcl_Obj *objPtr,
+				va_list argList);
 /* 269 */
 EXTERN char *		Tcl_HashStats(Tcl_HashTable *tablePtr);
 /* 270 */
 EXTERN const char *	Tcl_ParseVar(Tcl_Interp *interp, const char *start,
 				const char **termPtr);
-/* Slot 271 is reserved */
+/* 271 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+const char *		Tcl_PkgPresent(Tcl_Interp *interp, const char *name,
+				const char *version, int exact);
 /* 272 */
 EXTERN const char *	Tcl_PkgPresentEx(Tcl_Interp *interp,
 				const char *name, const char *version,
 				int exact, void *clientDataPtr);
-/* Slot 273 is reserved */
-/* Slot 274 is reserved */
-/* Slot 275 is reserved */
-/* Slot 276 is reserved */
+/* 273 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+int			Tcl_PkgProvide(Tcl_Interp *interp, const char *name,
+				const char *version);
+/* 274 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+const char *		Tcl_PkgRequire(Tcl_Interp *interp, const char *name,
+				const char *version, int exact);
+/* 275 */
+TCL_DEPRECATED("see TIP #422")
+void			Tcl_SetErrorCodeVA(Tcl_Interp *interp,
+				va_list argList);
+/* 276 */
+TCL_DEPRECATED("see TIP #422")
+int			Tcl_VarEvalVA(Tcl_Interp *interp, va_list argList);
 /* 277 */
 EXTERN Tcl_Pid		Tcl_WaitPid(Tcl_Pid pid, int *statPtr, int options);
-/* Slot 278 is reserved */
+/* 278 */
+TCL_DEPRECATED("see TIP #422")
+TCL_NORETURN void	Tcl_PanicVA(const char *format, va_list argList);
 /* 279 */
 EXTERN void		Tcl_GetVersion(int *major, int *minor,
 				int *patchLevel, int *type);
 /* 280 */
 EXTERN void		Tcl_InitMemory(Tcl_Interp *interp);
 /* 281 */
 EXTERN Tcl_Channel	Tcl_StackChannel(Tcl_Interp *interp,
 				const Tcl_ChannelType *typePtr,
-				void *instanceData, int mask,
+				ClientData instanceData, int mask,
 				Tcl_Channel prevChan);
 /* 282 */
 EXTERN int		Tcl_UnstackChannel(Tcl_Interp *interp,
 				Tcl_Channel chan);
 /* 283 */
@@ -785,18 +897,19 @@
 				Tcl_Obj *appendObjPtr);
 /* 287 */
 EXTERN Tcl_Encoding	Tcl_CreateEncoding(const Tcl_EncodingType *typePtr);
 /* 288 */
 EXTERN void		Tcl_CreateThreadExitHandler(Tcl_ExitProc *proc,
-				void *clientData);
+				ClientData clientData);
 /* 289 */
 EXTERN void		Tcl_DeleteThreadExitHandler(Tcl_ExitProc *proc,
-				void *clientData);
-/* Slot 290 is reserved */
+				ClientData clientData);
+/* 290 */
+EXTERN void		Tcl_DiscardResult(Tcl_SavedResult *statePtr);
 /* 291 */
 EXTERN int		Tcl_EvalEx(Tcl_Interp *interp, const char *script,
-				size_t numBytes, int flags);
+				int numBytes, int flags);
 /* 292 */
 EXTERN int		Tcl_EvalObjv(Tcl_Interp *interp, int objc,
 				Tcl_Obj *const objv[], int flags);
 /* 293 */
 EXTERN int		Tcl_EvalObjEx(Tcl_Interp *interp, Tcl_Obj *objPtr,
@@ -804,22 +917,22 @@
 /* 294 */
 EXTERN TCL_NORETURN void Tcl_ExitThread(int status);
 /* 295 */
 EXTERN int		Tcl_ExternalToUtf(Tcl_Interp *interp,
 				Tcl_Encoding encoding, const char *src,
-				size_t srcLen, int flags,
+				int srcLen, int flags,
 				Tcl_EncodingState *statePtr, char *dst,
-				size_t dstLen, int *srcReadPtr,
+				int dstLen, int *srcReadPtr,
 				int *dstWrotePtr, int *dstCharsPtr);
 /* 296 */
 EXTERN char *		Tcl_ExternalToUtfDString(Tcl_Encoding encoding,
-				const char *src, size_t srcLen,
+				const char *src, int srcLen,
 				Tcl_DString *dsPtr);
 /* 297 */
 EXTERN void		Tcl_FinalizeThread(void);
 /* 298 */
-EXTERN void		Tcl_FinalizeNotifier(void *clientData);
+EXTERN void		Tcl_FinalizeNotifier(ClientData clientData);
 /* 299 */
 EXTERN void		Tcl_FreeEncoding(Tcl_Encoding encoding);
 /* 300 */
 EXTERN Tcl_ThreadId	Tcl_GetCurrentThread(void);
 /* 301 */
@@ -829,20 +942,20 @@
 /* 303 */
 EXTERN void		Tcl_GetEncodingNames(Tcl_Interp *interp);
 /* 304 */
 EXTERN int		Tcl_GetIndexFromObjStruct(Tcl_Interp *interp,
 				Tcl_Obj *objPtr, const void *tablePtr,
-				size_t offset, const char *msg, int flags,
+				int offset, const char *msg, int flags,
 				int *indexPtr);
 /* 305 */
 EXTERN void *		Tcl_GetThreadData(Tcl_ThreadDataKey *keyPtr,
-				size_t size);
+				int size);
 /* 306 */
 EXTERN Tcl_Obj *	Tcl_GetVar2Ex(Tcl_Interp *interp, const char *part1,
 				const char *part2, int flags);
 /* 307 */
-EXTERN void *		Tcl_InitNotifier(void);
+EXTERN ClientData	Tcl_InitNotifier(void);
 /* 308 */
 EXTERN void		Tcl_MutexLock(Tcl_Mutex *mutexPtr);
 /* 309 */
 EXTERN void		Tcl_MutexUnlock(Tcl_Mutex *mutexPtr);
 /* 310 */
@@ -849,16 +962,20 @@
 EXTERN void		Tcl_ConditionNotify(Tcl_Condition *condPtr);
 /* 311 */
 EXTERN void		Tcl_ConditionWait(Tcl_Condition *condPtr,
 				Tcl_Mutex *mutexPtr, const Tcl_Time *timePtr);
 /* 312 */
-EXTERN size_t		Tcl_NumUtfChars(const char *src, size_t length);
+EXTERN int		Tcl_NumUtfChars(const char *src, int length);
 /* 313 */
-EXTERN size_t		Tcl_ReadChars(Tcl_Channel channel, Tcl_Obj *objPtr,
-				size_t charsToRead, int appendFlag);
-/* Slot 314 is reserved */
-/* Slot 315 is reserved */
+EXTERN int		Tcl_ReadChars(Tcl_Channel channel, Tcl_Obj *objPtr,
+				int charsToRead, int appendFlag);
+/* 314 */
+EXTERN void		Tcl_RestoreResult(Tcl_Interp *interp,
+				Tcl_SavedResult *statePtr);
+/* 315 */
+EXTERN void		Tcl_SaveResult(Tcl_Interp *interp,
+				Tcl_SavedResult *statePtr);
 /* 316 */
 EXTERN int		Tcl_SetSystemEncoding(Tcl_Interp *interp,
 				const char *name);
 /* 317 */
 EXTERN Tcl_Obj *	Tcl_SetVar2Ex(Tcl_Interp *interp, const char *part1,
@@ -868,25 +985,25 @@
 EXTERN void		Tcl_ThreadAlert(Tcl_ThreadId threadId);
 /* 319 */
 EXTERN void		Tcl_ThreadQueueEvent(Tcl_ThreadId threadId,
 				Tcl_Event *evPtr, Tcl_QueuePosition position);
 /* 320 */
-EXTERN int		Tcl_UniCharAtIndex(const char *src, size_t index);
+EXTERN int		Tcl_UniCharAtIndex(const char *src, int index);
 /* 321 */
 EXTERN int		Tcl_UniCharToLower(int ch);
 /* 322 */
 EXTERN int		Tcl_UniCharToTitle(int ch);
 /* 323 */
 EXTERN int		Tcl_UniCharToUpper(int ch);
 /* 324 */
 EXTERN int		Tcl_UniCharToUtf(int ch, char *buf);
 /* 325 */
-EXTERN const char *	Tcl_UtfAtIndex(const char *src, size_t index);
+EXTERN const char *	Tcl_UtfAtIndex(const char *src, int index);
 /* 326 */
-EXTERN int		Tcl_UtfCharComplete(const char *src, size_t length);
+EXTERN int		Tcl_UtfCharComplete(const char *src, int length);
 /* 327 */
-EXTERN size_t		Tcl_UtfBackslash(const char *src, int *readPtr,
+EXTERN int		Tcl_UtfBackslash(const char *src, int *readPtr,
 				char *dst);
 /* 328 */
 EXTERN const char *	Tcl_UtfFindFirst(const char *src, int ch);
 /* 329 */
 EXTERN const char *	Tcl_UtfFindLast(const char *src, int ch);
@@ -895,17 +1012,17 @@
 /* 331 */
 EXTERN const char *	Tcl_UtfPrev(const char *src, const char *start);
 /* 332 */
 EXTERN int		Tcl_UtfToExternal(Tcl_Interp *interp,
 				Tcl_Encoding encoding, const char *src,
-				size_t srcLen, int flags,
+				int srcLen, int flags,
 				Tcl_EncodingState *statePtr, char *dst,
-				size_t dstLen, int *srcReadPtr,
+				int dstLen, int *srcReadPtr,
 				int *dstWrotePtr, int *dstCharsPtr);
 /* 333 */
 EXTERN char *		Tcl_UtfToExternalDString(Tcl_Encoding encoding,
-				const char *src, size_t srcLen,
+				const char *src, int srcLen,
 				Tcl_DString *dsPtr);
 /* 334 */
 EXTERN int		Tcl_UtfToLower(char *src);
 /* 335 */
 EXTERN int		Tcl_UtfToTitle(char *src);
@@ -912,20 +1029,24 @@
 /* 336 */
 EXTERN int		Tcl_UtfToUniChar(const char *src, Tcl_UniChar *chPtr);
 /* 337 */
 EXTERN int		Tcl_UtfToUpper(char *src);
 /* 338 */
-EXTERN size_t		Tcl_WriteChars(Tcl_Channel chan, const char *src,
-				size_t srcLen);
+EXTERN int		Tcl_WriteChars(Tcl_Channel chan, const char *src,
+				int srcLen);
 /* 339 */
-EXTERN size_t		Tcl_WriteObj(Tcl_Channel chan, Tcl_Obj *objPtr);
+EXTERN int		Tcl_WriteObj(Tcl_Channel chan, Tcl_Obj *objPtr);
 /* 340 */
 EXTERN char *		Tcl_GetString(Tcl_Obj *objPtr);
-/* Slot 341 is reserved */
-/* Slot 342 is reserved */
+/* 341 */
+TCL_DEPRECATED("Use Tcl_GetEncodingSearchPath")
+const char *		Tcl_GetDefaultEncodingDir(void);
+/* 342 */
+TCL_DEPRECATED("Use Tcl_SetEncodingSearchPath")
+void			Tcl_SetDefaultEncodingDir(const char *path);
 /* 343 */
-EXTERN void		Tcl_AlertNotifier(void *clientData);
+EXTERN void		Tcl_AlertNotifier(ClientData clientData);
 /* 344 */
 EXTERN void		Tcl_ServiceModeHook(int mode);
 /* 345 */
 EXTERN int		Tcl_UniCharIsAlnum(int ch);
 /* 346 */
@@ -939,50 +1060,54 @@
 /* 350 */
 EXTERN int		Tcl_UniCharIsUpper(int ch);
 /* 351 */
 EXTERN int		Tcl_UniCharIsWordChar(int ch);
 /* 352 */
-EXTERN size_t		Tcl_UniCharLen(const Tcl_UniChar *uniStr);
+EXTERN int		Tcl_UniCharLen(const Tcl_UniChar *uniStr);
 /* 353 */
 EXTERN int		Tcl_UniCharNcmp(const Tcl_UniChar *ucs,
-				const Tcl_UniChar *uct, size_t numChars);
+				const Tcl_UniChar *uct,
+				unsigned long numChars);
 /* 354 */
 EXTERN char *		Tcl_UniCharToUtfDString(const Tcl_UniChar *uniStr,
-				size_t uniLength, Tcl_DString *dsPtr);
+				int uniLength, Tcl_DString *dsPtr);
 /* 355 */
-EXTERN Tcl_UniChar *	Tcl_UtfToUniCharDString(const char *src,
-				size_t length, Tcl_DString *dsPtr);
+EXTERN Tcl_UniChar *	Tcl_UtfToUniCharDString(const char *src, int length,
+				Tcl_DString *dsPtr);
 /* 356 */
 EXTERN Tcl_RegExp	Tcl_GetRegExpFromObj(Tcl_Interp *interp,
 				Tcl_Obj *patObj, int flags);
-/* Slot 357 is reserved */
+/* 357 */
+TCL_DEPRECATED("Use Tcl_EvalTokensStandard")
+Tcl_Obj *		Tcl_EvalTokens(Tcl_Interp *interp,
+				Tcl_Token *tokenPtr, int count);
 /* 358 */
 EXTERN void		Tcl_FreeParse(Tcl_Parse *parsePtr);
 /* 359 */
 EXTERN void		Tcl_LogCommandInfo(Tcl_Interp *interp,
 				const char *script, const char *command,
-				size_t length);
+				int length);
 /* 360 */
 EXTERN int		Tcl_ParseBraces(Tcl_Interp *interp,
-				const char *start, size_t numBytes,
+				const char *start, int numBytes,
 				Tcl_Parse *parsePtr, int append,
 				const char **termPtr);
 /* 361 */
 EXTERN int		Tcl_ParseCommand(Tcl_Interp *interp,
-				const char *start, size_t numBytes,
-				int nested, Tcl_Parse *parsePtr);
+				const char *start, int numBytes, int nested,
+				Tcl_Parse *parsePtr);
 /* 362 */
 EXTERN int		Tcl_ParseExpr(Tcl_Interp *interp, const char *start,
-				size_t numBytes, Tcl_Parse *parsePtr);
+				int numBytes, Tcl_Parse *parsePtr);
 /* 363 */
 EXTERN int		Tcl_ParseQuotedString(Tcl_Interp *interp,
-				const char *start, size_t numBytes,
+				const char *start, int numBytes,
 				Tcl_Parse *parsePtr, int append,
 				const char **termPtr);
 /* 364 */
 EXTERN int		Tcl_ParseVarName(Tcl_Interp *interp,
-				const char *start, size_t numBytes,
+				const char *start, int numBytes,
 				Tcl_Parse *parsePtr, int append);
 /* 365 */
 EXTERN char *		Tcl_GetCwd(Tcl_Interp *interp, Tcl_DString *cwdPtr);
 /* 366 */
 EXTERN int		Tcl_Chdir(const char *dirName);
@@ -989,14 +1114,15 @@
 /* 367 */
 EXTERN int		Tcl_Access(const char *path, int mode);
 /* 368 */
 EXTERN int		Tcl_Stat(const char *path, struct stat *bufPtr);
 /* 369 */
-EXTERN int		Tcl_UtfNcmp(const char *s1, const char *s2, size_t n);
+EXTERN int		Tcl_UtfNcmp(const char *s1, const char *s2,
+				unsigned long n);
 /* 370 */
 EXTERN int		Tcl_UtfNcasecmp(const char *s1, const char *s2,
-				size_t n);
+				unsigned long n);
 /* 371 */
 EXTERN int		Tcl_StringCaseMatch(const char *str,
 				const char *pattern, int nocase);
 /* 372 */
 EXTERN int		Tcl_UniCharIsControl(int ch);
@@ -1007,31 +1133,32 @@
 /* 375 */
 EXTERN int		Tcl_UniCharIsPunct(int ch);
 /* 376 */
 EXTERN int		Tcl_RegExpExecObj(Tcl_Interp *interp,
 				Tcl_RegExp regexp, Tcl_Obj *textObj,
-				size_t offset, size_t nmatches, int flags);
+				int offset, int nmatches, int flags);
 /* 377 */
 EXTERN void		Tcl_RegExpGetInfo(Tcl_RegExp regexp,
 				Tcl_RegExpInfo *infoPtr);
 /* 378 */
 EXTERN Tcl_Obj *	Tcl_NewUnicodeObj(const Tcl_UniChar *unicode,
-				size_t numChars);
+				int numChars);
 /* 379 */
 EXTERN void		Tcl_SetUnicodeObj(Tcl_Obj *objPtr,
-				const Tcl_UniChar *unicode, size_t numChars);
+				const Tcl_UniChar *unicode, int numChars);
 /* 380 */
-EXTERN size_t		Tcl_GetCharLength(Tcl_Obj *objPtr);
+EXTERN int		Tcl_GetCharLength(Tcl_Obj *objPtr);
 /* 381 */
-EXTERN int		Tcl_GetUniChar(Tcl_Obj *objPtr, size_t index);
-/* Slot 382 is reserved */
+EXTERN int		Tcl_GetUniChar(Tcl_Obj *objPtr, int index);
+/* 382 */
+TCL_DEPRECATED("No longer in use, changed to macro")
+Tcl_UniChar *		Tcl_GetUnicode(Tcl_Obj *objPtr);
 /* 383 */
-EXTERN Tcl_Obj *	Tcl_GetRange(Tcl_Obj *objPtr, size_t first,
-				size_t last);
+EXTERN Tcl_Obj *	Tcl_GetRange(Tcl_Obj *objPtr, int first, int last);
 /* 384 */
 EXTERN void		Tcl_AppendUnicodeToObj(Tcl_Obj *objPtr,
-				const Tcl_UniChar *unicode, size_t length);
+				const Tcl_UniChar *unicode, int length);
 /* 385 */
 EXTERN int		Tcl_RegExpMatchObj(Tcl_Interp *interp,
 				Tcl_Obj *textObj, Tcl_Obj *patternObj);
 /* 386 */
 EXTERN void		Tcl_SetNotifier(Tcl_NotifierProcs *notifierProcPtr);
@@ -1041,26 +1168,28 @@
 EXTERN int		Tcl_GetChannelNames(Tcl_Interp *interp);
 /* 389 */
 EXTERN int		Tcl_GetChannelNamesEx(Tcl_Interp *interp,
 				const char *pattern);
 /* 390 */
-EXTERN int		Tcl_ProcObjCmd(void *clientData, Tcl_Interp *interp,
-				int objc, Tcl_Obj *const objv[]);
+EXTERN int		Tcl_ProcObjCmd(ClientData clientData,
+				Tcl_Interp *interp, int objc,
+				Tcl_Obj *const objv[]);
 /* 391 */
 EXTERN void		Tcl_ConditionFinalize(Tcl_Condition *condPtr);
 /* 392 */
 EXTERN void		Tcl_MutexFinalize(Tcl_Mutex *mutex);
 /* 393 */
 EXTERN int		Tcl_CreateThread(Tcl_ThreadId *idPtr,
-				Tcl_ThreadCreateProc *proc, void *clientData,
-				size_t stackSize, int flags);
+				Tcl_ThreadCreateProc *proc,
+				ClientData clientData, int stackSize,
+				int flags);
 /* 394 */
-EXTERN size_t		Tcl_ReadRaw(Tcl_Channel chan, char *dst,
-				size_t bytesToRead);
+EXTERN int		Tcl_ReadRaw(Tcl_Channel chan, char *dst,
+				int bytesToRead);
 /* 395 */
-EXTERN size_t		Tcl_WriteRaw(Tcl_Channel chan, const char *src,
-				size_t srcLen);
+EXTERN int		Tcl_WriteRaw(Tcl_Channel chan, const char *src,
+				int srcLen);
 /* 396 */
 EXTERN Tcl_Channel	Tcl_GetTopChannel(Tcl_Channel chan);
 /* 397 */
 EXTERN int		Tcl_ChannelBuffered(Tcl_Channel chan);
 /* 398 */
@@ -1119,54 +1248,69 @@
 EXTERN void		Tcl_ClearChannelHandlers(Tcl_Channel channel);
 /* 418 */
 EXTERN int		Tcl_IsChannelExisting(const char *channelName);
 /* 419 */
 EXTERN int		Tcl_UniCharNcasecmp(const Tcl_UniChar *ucs,
-				const Tcl_UniChar *uct, size_t numChars);
+				const Tcl_UniChar *uct,
+				unsigned long numChars);
 /* 420 */
 EXTERN int		Tcl_UniCharCaseMatch(const Tcl_UniChar *uniStr,
 				const Tcl_UniChar *uniPattern, int nocase);
-/* Slot 421 is reserved */
-/* Slot 422 is reserved */
+/* 421 */
+EXTERN Tcl_HashEntry *	Tcl_FindHashEntry(Tcl_HashTable *tablePtr,
+				const void *key);
+/* 422 */
+EXTERN Tcl_HashEntry *	Tcl_CreateHashEntry(Tcl_HashTable *tablePtr,
+				const void *key, int *newPtr);
 /* 423 */
 EXTERN void		Tcl_InitCustomHashTable(Tcl_HashTable *tablePtr,
 				int keyType, const Tcl_HashKeyType *typePtr);
 /* 424 */
 EXTERN void		Tcl_InitObjHashTable(Tcl_HashTable *tablePtr);
 /* 425 */
-EXTERN void *		Tcl_CommandTraceInfo(Tcl_Interp *interp,
+EXTERN ClientData	Tcl_CommandTraceInfo(Tcl_Interp *interp,
 				const char *varName, int flags,
 				Tcl_CommandTraceProc *procPtr,
-				void *prevClientData);
+				ClientData prevClientData);
 /* 426 */
 EXTERN int		Tcl_TraceCommand(Tcl_Interp *interp,
 				const char *varName, int flags,
-				Tcl_CommandTraceProc *proc, void *clientData);
+				Tcl_CommandTraceProc *proc,
+				ClientData clientData);
 /* 427 */
 EXTERN void		Tcl_UntraceCommand(Tcl_Interp *interp,
 				const char *varName, int flags,
-				Tcl_CommandTraceProc *proc, void *clientData);
+				Tcl_CommandTraceProc *proc,
+				ClientData clientData);
 /* 428 */
-EXTERN void *		Tcl_AttemptAlloc(size_t size);
+EXTERN char *		Tcl_AttemptAlloc(unsigned int size);
 /* 429 */
-EXTERN void *		Tcl_AttemptDbCkalloc(size_t size, const char *file,
-				int line);
+EXTERN char *		Tcl_AttemptDbCkalloc(unsigned int size,
+				const char *file, int line);
 /* 430 */
-EXTERN void *		Tcl_AttemptRealloc(void *ptr, size_t size);
+EXTERN char *		Tcl_AttemptRealloc(char *ptr, unsigned int size);
 /* 431 */
-EXTERN void *		Tcl_AttemptDbCkrealloc(void *ptr, size_t size,
+EXTERN char *		Tcl_AttemptDbCkrealloc(char *ptr, unsigned int size,
 				const char *file, int line);
 /* 432 */
-EXTERN int		Tcl_AttemptSetObjLength(Tcl_Obj *objPtr,
-				size_t length);
+EXTERN int		Tcl_AttemptSetObjLength(Tcl_Obj *objPtr, int length);
 /* 433 */
 EXTERN Tcl_ThreadId	Tcl_GetChannelThread(Tcl_Channel channel);
 /* 434 */
 EXTERN Tcl_UniChar *	Tcl_GetUnicodeFromObj(Tcl_Obj *objPtr,
 				int *lengthPtr);
-/* Slot 435 is reserved */
-/* Slot 436 is reserved */
+/* 435 */
+TCL_DEPRECATED("")
+int			Tcl_GetMathFuncInfo(Tcl_Interp *interp,
+				const char *name, int *numArgsPtr,
+				Tcl_ValueType **argTypesPtr,
+				Tcl_MathProc **procPtr,
+				ClientData *clientDataPtr);
+/* 436 */
+TCL_DEPRECATED("")
+Tcl_Obj *		Tcl_ListMathFuncs(Tcl_Interp *interp,
+				const char *pattern);
 /* 437 */
 EXTERN Tcl_Obj *	Tcl_SubstObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 				int flags);
 /* 438 */
 EXTERN int		Tcl_DetachChannel(Tcl_Interp *interp,
@@ -1212,11 +1356,11 @@
 				Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef);
 /* 452 */
 EXTERN int		Tcl_FSFileAttrsSet(Tcl_Interp *interp, int index,
 				Tcl_Obj *pathPtr, Tcl_Obj *objPtr);
 /* 453 */
-EXTERN const char *const * Tcl_FSFileAttrStrings(Tcl_Obj *pathPtr,
+EXTERN const char *CONST86 * Tcl_FSFileAttrStrings(Tcl_Obj *pathPtr,
 				Tcl_Obj **objPtrRef);
 /* 454 */
 EXTERN int		Tcl_FSStat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf);
 /* 455 */
 EXTERN int		Tcl_FSAccess(Tcl_Obj *pathPtr, int mode);
@@ -1243,56 +1387,56 @@
 				Tcl_Obj *pathPtr);
 /* 464 */
 EXTERN Tcl_Obj *	Tcl_FSJoinToPath(Tcl_Obj *pathPtr, int objc,
 				Tcl_Obj *const objv[]);
 /* 465 */
-EXTERN void *		Tcl_FSGetInternalRep(Tcl_Obj *pathPtr,
+EXTERN ClientData	Tcl_FSGetInternalRep(Tcl_Obj *pathPtr,
 				const Tcl_Filesystem *fsPtr);
 /* 466 */
 EXTERN Tcl_Obj *	Tcl_FSGetTranslatedPath(Tcl_Interp *interp,
 				Tcl_Obj *pathPtr);
 /* 467 */
 EXTERN int		Tcl_FSEvalFile(Tcl_Interp *interp, Tcl_Obj *fileName);
 /* 468 */
 EXTERN Tcl_Obj *	Tcl_FSNewNativePath(
 				const Tcl_Filesystem *fromFilesystem,
-				void *clientData);
+				ClientData clientData);
 /* 469 */
 EXTERN const void *	Tcl_FSGetNativePath(Tcl_Obj *pathPtr);
 /* 470 */
 EXTERN Tcl_Obj *	Tcl_FSFileSystemInfo(Tcl_Obj *pathPtr);
 /* 471 */
 EXTERN Tcl_Obj *	Tcl_FSPathSeparator(Tcl_Obj *pathPtr);
 /* 472 */
 EXTERN Tcl_Obj *	Tcl_FSListVolumes(void);
 /* 473 */
-EXTERN int		Tcl_FSRegister(void *clientData,
+EXTERN int		Tcl_FSRegister(ClientData clientData,
 				const Tcl_Filesystem *fsPtr);
 /* 474 */
 EXTERN int		Tcl_FSUnregister(const Tcl_Filesystem *fsPtr);
 /* 475 */
-EXTERN void *		Tcl_FSData(const Tcl_Filesystem *fsPtr);
+EXTERN ClientData	Tcl_FSData(const Tcl_Filesystem *fsPtr);
 /* 476 */
 EXTERN const char *	Tcl_FSGetTranslatedStringPath(Tcl_Interp *interp,
 				Tcl_Obj *pathPtr);
 /* 477 */
-EXTERN const Tcl_Filesystem * Tcl_FSGetFileSystemForPath(Tcl_Obj *pathPtr);
+EXTERN CONST86 Tcl_Filesystem * Tcl_FSGetFileSystemForPath(Tcl_Obj *pathPtr);
 /* 478 */
 EXTERN Tcl_PathType	Tcl_FSGetPathType(Tcl_Obj *pathPtr);
 /* 479 */
 EXTERN int		Tcl_OutputBuffered(Tcl_Channel chan);
 /* 480 */
 EXTERN void		Tcl_FSMountsChanged(const Tcl_Filesystem *fsPtr);
 /* 481 */
 EXTERN int		Tcl_EvalTokensStandard(Tcl_Interp *interp,
-				Tcl_Token *tokenPtr, size_t count);
+				Tcl_Token *tokenPtr, int count);
 /* 482 */
 EXTERN void		Tcl_GetTime(Tcl_Time *timeBuf);
 /* 483 */
 EXTERN Tcl_Trace	Tcl_CreateObjTrace(Tcl_Interp *interp, int level,
 				int flags, Tcl_CmdObjTraceProc *objProc,
-				void *clientData,
+				ClientData clientData,
 				Tcl_CmdObjTraceDeleteProc *delProc);
 /* 484 */
 EXTERN int		Tcl_GetCommandInfoFromToken(Tcl_Command token,
 				Tcl_CmdInfo *infoPtr);
 /* 485 */
@@ -1359,11 +1503,11 @@
 				const char *pkgName,
 				const Tcl_Config *configuration,
 				const char *valEncoding);
 /* 506 */
 EXTERN Tcl_Namespace *	Tcl_CreateNamespace(Tcl_Interp *interp,
-				const char *name, void *clientData,
+				const char *name, ClientData clientData,
 				Tcl_NamespaceDeleteProc *deleteProc);
 /* 507 */
 EXTERN void		Tcl_DeleteNamespace(Tcl_Namespace *nsPtr);
 /* 508 */
 EXTERN int		Tcl_AppendExportList(Tcl_Interp *interp,
@@ -1395,20 +1539,21 @@
 EXTERN void		Tcl_GetCommandFullName(Tcl_Interp *interp,
 				Tcl_Command command, Tcl_Obj *objPtr);
 /* 518 */
 EXTERN int		Tcl_FSEvalFileEx(Tcl_Interp *interp,
 				Tcl_Obj *fileName, const char *encodingName);
-/* Slot 519 is reserved */
+/* 519 */
+EXTERN Tcl_ExitProc *	Tcl_SetExitProc(TCL_NORETURN1 Tcl_ExitProc *proc);
 /* 520 */
 EXTERN void		Tcl_LimitAddHandler(Tcl_Interp *interp, int type,
 				Tcl_LimitHandlerProc *handlerProc,
-				void *clientData,
+				ClientData clientData,
 				Tcl_LimitHandlerDeleteProc *deleteProc);
 /* 521 */
 EXTERN void		Tcl_LimitRemoveHandler(Tcl_Interp *interp, int type,
 				Tcl_LimitHandlerProc *handlerProc,
-				void *clientData);
+				ClientData clientData);
 /* 522 */
 EXTERN int		Tcl_LimitReady(Tcl_Interp *interp);
 /* 523 */
 EXTERN int		Tcl_LimitCheck(Tcl_Interp *interp);
 /* 524 */
@@ -1487,15 +1632,15 @@
 				Tcl_Command token,
 				Tcl_Namespace **namespacePtrPtr);
 /* 552 */
 EXTERN void		Tcl_SetTimeProc(Tcl_GetTimeProc *getProc,
 				Tcl_ScaleTimeProc *scaleProc,
-				void *clientData);
+				ClientData clientData);
 /* 553 */
 EXTERN void		Tcl_QueryTimeProc(Tcl_GetTimeProc **getProc,
 				Tcl_ScaleTimeProc **scaleProc,
-				void **clientData);
+				ClientData *clientData);
 /* 554 */
 EXTERN Tcl_DriverThreadActionProc * Tcl_ChannelThreadActionProc(
 				const Tcl_ChannelType *chanTypePtr);
 /* 555 */
 EXTERN Tcl_Obj *	Tcl_NewBignumObj(mp_int *value);
@@ -1552,12 +1697,12 @@
 /* 574 */
 EXTERN void		Tcl_AppendObjToErrorInfo(Tcl_Interp *interp,
 				Tcl_Obj *objPtr);
 /* 575 */
 EXTERN void		Tcl_AppendLimitedToObj(Tcl_Obj *objPtr,
-				const char *bytes, size_t length,
-				size_t limit, const char *ellipsis);
+				const char *bytes, int length, int limit,
+				const char *ellipsis);
 /* 576 */
 EXTERN Tcl_Obj *	Tcl_Format(Tcl_Interp *interp, const char *format,
 				int objc, Tcl_Obj *const objv[]);
 /* 577 */
 EXTERN int		Tcl_AppendFormatToObj(Tcl_Interp *interp,
@@ -1568,11 +1713,11 @@
 /* 579 */
 EXTERN void		Tcl_AppendPrintfToObj(Tcl_Obj *objPtr,
 				const char *format, ...) TCL_FORMAT_PRINTF(2, 3);
 /* 580 */
 EXTERN int		Tcl_CancelEval(Tcl_Interp *interp,
-				Tcl_Obj *resultObjPtr, void *clientData,
+				Tcl_Obj *resultObjPtr, ClientData clientData,
 				int flags);
 /* 581 */
 EXTERN int		Tcl_Canceled(Tcl_Interp *interp, int flags);
 /* 582 */
 EXTERN int		Tcl_CreatePipe(Tcl_Interp *interp,
@@ -1579,11 +1724,12 @@
 				Tcl_Channel *rchan, Tcl_Channel *wchan,
 				int flags);
 /* 583 */
 EXTERN Tcl_Command	Tcl_NRCreateCommand(Tcl_Interp *interp,
 				const char *cmdName, Tcl_ObjCmdProc *proc,
-				Tcl_ObjCmdProc *nreProc, void *clientData,
+				Tcl_ObjCmdProc *nreProc,
+				ClientData clientData,
 				Tcl_CmdDeleteProc *deleteProc);
 /* 584 */
 EXTERN int		Tcl_NREvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 				int flags);
 /* 585 */
@@ -1592,16 +1738,18 @@
 /* 586 */
 EXTERN int		Tcl_NRCmdSwap(Tcl_Interp *interp, Tcl_Command cmd,
 				int objc, Tcl_Obj *const objv[], int flags);
 /* 587 */
 EXTERN void		Tcl_NRAddCallback(Tcl_Interp *interp,
-				Tcl_NRPostProc *postProcPtr, void *data0,
-				void *data1, void *data2, void *data3);
+				Tcl_NRPostProc *postProcPtr,
+				ClientData data0, ClientData data1,
+				ClientData data2, ClientData data3);
 /* 588 */
 EXTERN int		Tcl_NRCallObjProc(Tcl_Interp *interp,
-				Tcl_ObjCmdProc *objProc, void *clientData,
-				int objc, Tcl_Obj *const objv[]);
+				Tcl_ObjCmdProc *objProc,
+				ClientData clientData, int objc,
+				Tcl_Obj *const objv[]);
 /* 589 */
 EXTERN unsigned		Tcl_GetFSDeviceFromStat(const Tcl_StatBuf *statPtr);
 /* 590 */
 EXTERN unsigned		Tcl_GetFSInodeFromStat(const Tcl_StatBuf *statPtr);
 /* 591 */
@@ -1652,18 +1800,18 @@
 EXTERN int		Tcl_ZlibDeflate(Tcl_Interp *interp, int format,
 				Tcl_Obj *data, int level,
 				Tcl_Obj *gzipHeaderDictObj);
 /* 611 */
 EXTERN int		Tcl_ZlibInflate(Tcl_Interp *interp, int format,
-				Tcl_Obj *data, size_t buffersize,
+				Tcl_Obj *data, int buffersize,
 				Tcl_Obj *gzipHeaderDictObj);
 /* 612 */
 EXTERN unsigned int	Tcl_ZlibCRC32(unsigned int crc,
-				const unsigned char *buf, size_t len);
+				const unsigned char *buf, int len);
 /* 613 */
 EXTERN unsigned int	Tcl_ZlibAdler32(unsigned int adler,
-				const unsigned char *buf, size_t len);
+				const unsigned char *buf, int len);
 /* 614 */
 EXTERN int		Tcl_ZlibStreamInit(Tcl_Interp *interp, int mode,
 				int format, int level, Tcl_Obj *dictObj,
 				Tcl_ZlibStream *zshandle);
 /* 615 */
@@ -1675,11 +1823,11 @@
 /* 618 */
 EXTERN int		Tcl_ZlibStreamPut(Tcl_ZlibStream zshandle,
 				Tcl_Obj *data, int flush);
 /* 619 */
 EXTERN int		Tcl_ZlibStreamGet(Tcl_ZlibStream zshandle,
-				Tcl_Obj *data, size_t count);
+				Tcl_Obj *data, int count);
 /* 620 */
 EXTERN int		Tcl_ZlibStreamClose(Tcl_ZlibStream zshandle);
 /* 621 */
 EXTERN int		Tcl_ZlibStreamReset(Tcl_ZlibStream zshandle);
 /* 622 */
@@ -1713,11 +1861,11 @@
 /* 631 */
 EXTERN Tcl_Channel	Tcl_OpenTcpServerEx(Tcl_Interp *interp,
 				const char *service, const char *host,
 				unsigned int flags,
 				Tcl_TcpAcceptProc *acceptProc,
-				void *callbackData);
+				ClientData callbackData);
 /* 632 */
 EXTERN int		TclZipfs_Mount(Tcl_Interp *interp,
 				const char *mountPoint, const char *zipname,
 				const char *passwd);
 /* 633 */
@@ -1731,11 +1879,11 @@
 				size_t datalen, int copy);
 /* 636 */
 EXTERN void		Tcl_FreeIntRep(Tcl_Obj *objPtr);
 /* 637 */
 EXTERN char *		Tcl_InitStringRep(Tcl_Obj *objPtr, const char *bytes,
-				size_t numBytes);
+				unsigned int numBytes);
 /* 638 */
 EXTERN Tcl_ObjIntRep *	Tcl_FetchIntRep(Tcl_Obj *objPtr,
 				const Tcl_ObjType *typePtr);
 /* 639 */
 EXTERN void		Tcl_StoreIntRep(Tcl_Obj *objPtr,
@@ -1750,15 +1898,14 @@
 /* 643 */
 EXTERN int		Tcl_IsShared(Tcl_Obj *objPtr);
 /* 644 */
 EXTERN int		Tcl_LinkArray(Tcl_Interp *interp,
 				const char *varName, void *addr, int type,
-				size_t size);
+				int size);
 /* 645 */
 EXTERN int		Tcl_GetIntForIndex(Tcl_Interp *interp,
-				Tcl_Obj *objPtr, size_t endValue,
-				size_t *indexPtr);
+				Tcl_Obj *objPtr, int endValue, int *indexPtr);
 
 typedef struct {
     const struct TclPlatStubs *tclPlatStubs;
     const struct TclIntStubs *tclIntStubs;
     const struct TclIntPlatStubs *tclIntPlatStubs;
@@ -1769,24 +1916,24 @@
     const TclStubHooks *hooks;
 
     int (*tcl_PkgProvideEx) (Tcl_Interp *interp, const char *name, const char *version, const void *clientData); /* 0 */
     const char * (*tcl_PkgRequireEx) (Tcl_Interp *interp, const char *name, const char *version, int exact, void *clientDataPtr); /* 1 */
     TCL_NORETURN1 void (*tcl_Panic) (const char *format, ...) TCL_FORMAT_PRINTF(1, 2); /* 2 */
-    void * (*tcl_Alloc) (size_t size); /* 3 */
-    void (*tcl_Free) (void *ptr); /* 4 */
-    void * (*tcl_Realloc) (void *ptr, size_t size); /* 5 */
-    void * (*tcl_DbCkalloc) (size_t size, const char *file, int line); /* 6 */
-    void (*tcl_DbCkfree) (void *ptr, const char *file, int line); /* 7 */
-    void * (*tcl_DbCkrealloc) (void *ptr, size_t size, const char *file, int line); /* 8 */
+    char * (*tcl_Alloc) (unsigned int size); /* 3 */
+    void (*tcl_Free) (char *ptr); /* 4 */
+    char * (*tcl_Realloc) (char *ptr, unsigned int size); /* 5 */
+    char * (*tcl_DbCkalloc) (unsigned int size, const char *file, int line); /* 6 */
+    void (*tcl_DbCkfree) (char *ptr, const char *file, int line); /* 7 */
+    char * (*tcl_DbCkrealloc) (char *ptr, unsigned int size, const char *file, int line); /* 8 */
 #if !defined(_WIN32) && !defined(MAC_OSX_TCL) /* UNIX */
-    void (*tcl_CreateFileHandler) (int fd, int mask, Tcl_FileProc *proc, void *clientData); /* 9 */
+    void (*tcl_CreateFileHandler) (int fd, int mask, Tcl_FileProc *proc, ClientData clientData); /* 9 */
 #endif /* UNIX */
 #if defined(_WIN32) /* WIN */
     void (*reserved9)(void);
 #endif /* WIN */
 #ifdef MAC_OSX_TCL /* MACOSX */
-    void (*tcl_CreateFileHandler) (int fd, int mask, Tcl_FileProc *proc, void *clientData); /* 9 */
+    void (*tcl_CreateFileHandler) (int fd, int mask, Tcl_FileProc *proc, ClientData clientData); /* 9 */
 #endif /* MACOSX */
 #if !defined(_WIN32) && !defined(MAC_OSX_TCL) /* UNIX */
     void (*tcl_DeleteFileHandler) (int fd); /* 10 */
 #endif /* UNIX */
 #if defined(_WIN32) /* WIN */
@@ -1798,127 +1945,127 @@
     void (*tcl_SetTimer) (const Tcl_Time *timePtr); /* 11 */
     void (*tcl_Sleep) (int ms); /* 12 */
     int (*tcl_WaitForEvent) (const Tcl_Time *timePtr); /* 13 */
     int (*tcl_AppendAllObjTypes) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 14 */
     void (*tcl_AppendStringsToObj) (Tcl_Obj *objPtr, ...); /* 15 */
-    void (*tcl_AppendToObj) (Tcl_Obj *objPtr, const char *bytes, size_t length); /* 16 */
+    void (*tcl_AppendToObj) (Tcl_Obj *objPtr, const char *bytes, int length); /* 16 */
     Tcl_Obj * (*tcl_ConcatObj) (int objc, Tcl_Obj *const objv[]); /* 17 */
     int (*tcl_ConvertToType) (Tcl_Interp *interp, Tcl_Obj *objPtr, const Tcl_ObjType *typePtr); /* 18 */
     void (*tcl_DbDecrRefCount) (Tcl_Obj *objPtr, const char *file, int line); /* 19 */
     void (*tcl_DbIncrRefCount) (Tcl_Obj *objPtr, const char *file, int line); /* 20 */
     int (*tcl_DbIsShared) (Tcl_Obj *objPtr, const char *file, int line); /* 21 */
-    void (*reserved22)(void);
-    Tcl_Obj * (*tcl_DbNewByteArrayObj) (const unsigned char *bytes, size_t length, const char *file, int line); /* 23 */
+    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 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 */
-    void (*reserved26)(void);
+    TCL_DEPRECATED_API("No longer in use, changed to macro") Tcl_Obj * (*tcl_DbNewLongObj) (long longValue, const char *file, int line); /* 26 */
     Tcl_Obj * (*tcl_DbNewObj) (const char *file, int line); /* 27 */
-    Tcl_Obj * (*tcl_DbNewStringObj) (const char *bytes, size_t length, const char *file, int line); /* 28 */
+    Tcl_Obj * (*tcl_DbNewStringObj) (const char *bytes, int length, const char *file, int line); /* 28 */
     Tcl_Obj * (*tcl_DuplicateObj) (Tcl_Obj *objPtr); /* 29 */
-    void (*reserved30)(void);
+    void (*tclOldFreeObj) (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 *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 */
-    void (*reserved36)(void);
+    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 */
     int (*tcl_GetInt) (Tcl_Interp *interp, const char *src, int *intPtr); /* 37 */
     int (*tcl_GetIntFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int *intPtr); /* 38 */
     int (*tcl_GetLongFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, long *longPtr); /* 39 */
-    const Tcl_ObjType * (*tcl_GetObjType) (const char *typeName); /* 40 */
+    CONST86 Tcl_ObjType * (*tcl_GetObjType) (const char *typeName); /* 40 */
     char * (*tcl_GetStringFromObj) (Tcl_Obj *objPtr, int *lengthPtr); /* 41 */
     void (*tcl_InvalidateStringRep) (Tcl_Obj *objPtr); /* 42 */
     int (*tcl_ListObjAppendList) (Tcl_Interp *interp, Tcl_Obj *listPtr, Tcl_Obj *elemListPtr); /* 43 */
     int (*tcl_ListObjAppendElement) (Tcl_Interp *interp, Tcl_Obj *listPtr, Tcl_Obj *objPtr); /* 44 */
     int (*tcl_ListObjGetElements) (Tcl_Interp *interp, Tcl_Obj *listPtr, int *objcPtr, Tcl_Obj ***objvPtr); /* 45 */
     int (*tcl_ListObjIndex) (Tcl_Interp *interp, Tcl_Obj *listPtr, int index, Tcl_Obj **objPtrPtr); /* 46 */
     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 */
-    void (*reserved49)(void);
-    Tcl_Obj * (*tcl_NewByteArrayObj) (const unsigned char *bytes, size_t length); /* 50 */
+    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 length); /* 50 */
     Tcl_Obj * (*tcl_NewDoubleObj) (double doubleValue); /* 51 */
-    void (*reserved52)(void);
+    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 */
-    void (*reserved54)(void);
+    TCL_DEPRECATED_API("No longer in use, changed to macro") Tcl_Obj * (*tcl_NewLongObj) (long longValue); /* 54 */
     Tcl_Obj * (*tcl_NewObj) (void); /* 55 */
-    Tcl_Obj * (*tcl_NewStringObj) (const char *bytes, size_t length); /* 56 */
-    void (*reserved57)(void);
-    unsigned char * (*tcl_SetByteArrayLength) (Tcl_Obj *objPtr, size_t length); /* 58 */
-    void (*tcl_SetByteArrayObj) (Tcl_Obj *objPtr, const unsigned char *bytes, size_t length); /* 59 */
+    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 length); /* 58 */
+    void (*tcl_SetByteArrayObj) (Tcl_Obj *objPtr, const unsigned char *bytes, int length); /* 59 */
     void (*tcl_SetDoubleObj) (Tcl_Obj *objPtr, double doubleValue); /* 60 */
-    void (*reserved61)(void);
+    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 */
-    void (*reserved63)(void);
-    void (*tcl_SetObjLength) (Tcl_Obj *objPtr, size_t length); /* 64 */
-    void (*tcl_SetStringObj) (Tcl_Obj *objPtr, const char *bytes, size_t length); /* 65 */
-    void (*reserved66)(void);
-    void (*reserved67)(void);
+    TCL_DEPRECATED_API("No longer in use, changed to macro") void (*tcl_SetLongObj) (Tcl_Obj *objPtr, long longValue); /* 63 */
+    void (*tcl_SetObjLength) (Tcl_Obj *objPtr, int length); /* 64 */
+    void (*tcl_SetStringObj) (Tcl_Obj *objPtr, const char *bytes, int length); /* 65 */
+    TCL_DEPRECATED_API("No longer in use, changed to macro") void (*tcl_AddErrorInfo) (Tcl_Interp *interp, const char *message); /* 66 */
+    TCL_DEPRECATED_API("No longer in use, changed to macro") void (*tcl_AddObjErrorInfo) (Tcl_Interp *interp, const char *message, int length); /* 67 */
     void (*tcl_AllowExceptions) (Tcl_Interp *interp); /* 68 */
     void (*tcl_AppendElement) (Tcl_Interp *interp, const char *element); /* 69 */
     void (*tcl_AppendResult) (Tcl_Interp *interp, ...); /* 70 */
-    Tcl_AsyncHandler (*tcl_AsyncCreate) (Tcl_AsyncProc *proc, void *clientData); /* 71 */
+    Tcl_AsyncHandler (*tcl_AsyncCreate) (Tcl_AsyncProc *proc, ClientData clientData); /* 71 */
     void (*tcl_AsyncDelete) (Tcl_AsyncHandler async); /* 72 */
     int (*tcl_AsyncInvoke) (Tcl_Interp *interp, int code); /* 73 */
     void (*tcl_AsyncMark) (Tcl_AsyncHandler async); /* 74 */
     int (*tcl_AsyncReady) (void); /* 75 */
-    void (*reserved76)(void);
-    void (*reserved77)(void);
+    TCL_DEPRECATED_API("No longer in use, changed to macro") void (*tcl_BackgroundError) (Tcl_Interp *interp); /* 76 */
+    TCL_DEPRECATED_API("Use Tcl_UtfBackslash") char (*tcl_Backslash) (const char *src, int *readPtr); /* 77 */
     int (*tcl_BadChannelOption) (Tcl_Interp *interp, const char *optionName, const char *optionList); /* 78 */
-    void (*tcl_CallWhenDeleted) (Tcl_Interp *interp, Tcl_InterpDeleteProc *proc, void *clientData); /* 79 */
-    void (*tcl_CancelIdleCall) (Tcl_IdleProc *idleProc, void *clientData); /* 80 */
+    void (*tcl_CallWhenDeleted) (Tcl_Interp *interp, Tcl_InterpDeleteProc *proc, ClientData clientData); /* 79 */
+    void (*tcl_CancelIdleCall) (Tcl_IdleProc *idleProc, ClientData clientData); /* 80 */
     int (*tcl_Close) (Tcl_Interp *interp, Tcl_Channel chan); /* 81 */
     int (*tcl_CommandComplete) (const char *cmd); /* 82 */
     char * (*tcl_Concat) (int argc, const char *const *argv); /* 83 */
-    size_t (*tcl_ConvertElement) (const char *src, char *dst, int flags); /* 84 */
-    size_t (*tcl_ConvertCountedElement) (const char *src, size_t length, char *dst, int flags); /* 85 */
+    int (*tcl_ConvertElement) (const char *src, char *dst, int flags); /* 84 */
+    int (*tcl_ConvertCountedElement) (const char *src, int length, char *dst, int flags); /* 85 */
     int (*tcl_CreateAlias) (Tcl_Interp *slave, const char *slaveCmd, Tcl_Interp *target, const char *targetCmd, int argc, const char *const *argv); /* 86 */
     int (*tcl_CreateAliasObj) (Tcl_Interp *slave, const char *slaveCmd, Tcl_Interp *target, const char *targetCmd, int objc, Tcl_Obj *const objv[]); /* 87 */
-    Tcl_Channel (*tcl_CreateChannel) (const Tcl_ChannelType *typePtr, const char *chanName, void *instanceData, int mask); /* 88 */
-    void (*tcl_CreateChannelHandler) (Tcl_Channel chan, int mask, Tcl_ChannelProc *proc, void *clientData); /* 89 */
-    void (*tcl_CreateCloseHandler) (Tcl_Channel chan, Tcl_CloseProc *proc, void *clientData); /* 90 */
-    Tcl_Command (*tcl_CreateCommand) (Tcl_Interp *interp, const char *cmdName, Tcl_CmdProc *proc, void *clientData, Tcl_CmdDeleteProc *deleteProc); /* 91 */
-    void (*tcl_CreateEventSource) (Tcl_EventSetupProc *setupProc, Tcl_EventCheckProc *checkProc, void *clientData); /* 92 */
-    void (*tcl_CreateExitHandler) (Tcl_ExitProc *proc, void *clientData); /* 93 */
+    Tcl_Channel (*tcl_CreateChannel) (const Tcl_ChannelType *typePtr, const char *chanName, ClientData instanceData, int mask); /* 88 */
+    void (*tcl_CreateChannelHandler) (Tcl_Channel chan, int mask, Tcl_ChannelProc *proc, ClientData clientData); /* 89 */
+    void (*tcl_CreateCloseHandler) (Tcl_Channel chan, Tcl_CloseProc *proc, ClientData clientData); /* 90 */
+    Tcl_Command (*tcl_CreateCommand) (Tcl_Interp *interp, const char *cmdName, Tcl_CmdProc *proc, ClientData clientData, Tcl_CmdDeleteProc *deleteProc); /* 91 */
+    void (*tcl_CreateEventSource) (Tcl_EventSetupProc *setupProc, Tcl_EventCheckProc *checkProc, ClientData clientData); /* 92 */
+    void (*tcl_CreateExitHandler) (Tcl_ExitProc *proc, ClientData clientData); /* 93 */
     Tcl_Interp * (*tcl_CreateInterp) (void); /* 94 */
-    void (*reserved95)(void);
-    Tcl_Command (*tcl_CreateObjCommand) (Tcl_Interp *interp, const char *cmdName, Tcl_ObjCmdProc *proc, void *clientData, Tcl_CmdDeleteProc *deleteProc); /* 96 */
+    TCL_DEPRECATED_API("") void (*tcl_CreateMathFunc) (Tcl_Interp *interp, const char *name, int numArgs, Tcl_ValueType *argTypes, Tcl_MathProc *proc, ClientData clientData); /* 95 */
+    Tcl_Command (*tcl_CreateObjCommand) (Tcl_Interp *interp, const char *cmdName, Tcl_ObjCmdProc *proc, ClientData clientData, Tcl_CmdDeleteProc *deleteProc); /* 96 */
     Tcl_Interp * (*tcl_CreateSlave) (Tcl_Interp *interp, const char *slaveName, int isSafe); /* 97 */
-    Tcl_TimerToken (*tcl_CreateTimerHandler) (int milliseconds, Tcl_TimerProc *proc, void *clientData); /* 98 */
-    Tcl_Trace (*tcl_CreateTrace) (Tcl_Interp *interp, int level, Tcl_CmdTraceProc *proc, void *clientData); /* 99 */
+    Tcl_TimerToken (*tcl_CreateTimerHandler) (int milliseconds, Tcl_TimerProc *proc, ClientData clientData); /* 98 */
+    Tcl_Trace (*tcl_CreateTrace) (Tcl_Interp *interp, int level, Tcl_CmdTraceProc *proc, ClientData clientData); /* 99 */
     void (*tcl_DeleteAssocData) (Tcl_Interp *interp, const char *name); /* 100 */
-    void (*tcl_DeleteChannelHandler) (Tcl_Channel chan, Tcl_ChannelProc *proc, void *clientData); /* 101 */
-    void (*tcl_DeleteCloseHandler) (Tcl_Channel chan, Tcl_CloseProc *proc, void *clientData); /* 102 */
+    void (*tcl_DeleteChannelHandler) (Tcl_Channel chan, Tcl_ChannelProc *proc, ClientData clientData); /* 101 */
+    void (*tcl_DeleteCloseHandler) (Tcl_Channel chan, Tcl_CloseProc *proc, ClientData clientData); /* 102 */
     int (*tcl_DeleteCommand) (Tcl_Interp *interp, const char *cmdName); /* 103 */
     int (*tcl_DeleteCommandFromToken) (Tcl_Interp *interp, Tcl_Command command); /* 104 */
-    void (*tcl_DeleteEvents) (Tcl_EventDeleteProc *proc, void *clientData); /* 105 */
-    void (*tcl_DeleteEventSource) (Tcl_EventSetupProc *setupProc, Tcl_EventCheckProc *checkProc, void *clientData); /* 106 */
-    void (*tcl_DeleteExitHandler) (Tcl_ExitProc *proc, void *clientData); /* 107 */
+    void (*tcl_DeleteEvents) (Tcl_EventDeleteProc *proc, ClientData clientData); /* 105 */
+    void (*tcl_DeleteEventSource) (Tcl_EventSetupProc *setupProc, Tcl_EventCheckProc *checkProc, ClientData clientData); /* 106 */
+    void (*tcl_DeleteExitHandler) (Tcl_ExitProc *proc, ClientData clientData); /* 107 */
     void (*tcl_DeleteHashEntry) (Tcl_HashEntry *entryPtr); /* 108 */
     void (*tcl_DeleteHashTable) (Tcl_HashTable *tablePtr); /* 109 */
     void (*tcl_DeleteInterp) (Tcl_Interp *interp); /* 110 */
     void (*tcl_DetachPids) (int numPids, Tcl_Pid *pidPtr); /* 111 */
     void (*tcl_DeleteTimerHandler) (Tcl_TimerToken token); /* 112 */
     void (*tcl_DeleteTrace) (Tcl_Interp *interp, Tcl_Trace trace); /* 113 */
-    void (*tcl_DontCallWhenDeleted) (Tcl_Interp *interp, Tcl_InterpDeleteProc *proc, void *clientData); /* 114 */
+    void (*tcl_DontCallWhenDeleted) (Tcl_Interp *interp, Tcl_InterpDeleteProc *proc, ClientData clientData); /* 114 */
     int (*tcl_DoOneEvent) (int flags); /* 115 */
-    void (*tcl_DoWhenIdle) (Tcl_IdleProc *proc, void *clientData); /* 116 */
-    char * (*tcl_DStringAppend) (Tcl_DString *dsPtr, const char *bytes, size_t length); /* 117 */
+    void (*tcl_DoWhenIdle) (Tcl_IdleProc *proc, ClientData clientData); /* 116 */
+    char * (*tcl_DStringAppend) (Tcl_DString *dsPtr, const char *bytes, int length); /* 117 */
     char * (*tcl_DStringAppendElement) (Tcl_DString *dsPtr, const char *element); /* 118 */
     void (*tcl_DStringEndSublist) (Tcl_DString *dsPtr); /* 119 */
     void (*tcl_DStringFree) (Tcl_DString *dsPtr); /* 120 */
     void (*tcl_DStringGetResult) (Tcl_Interp *interp, Tcl_DString *dsPtr); /* 121 */
     void (*tcl_DStringInit) (Tcl_DString *dsPtr); /* 122 */
     void (*tcl_DStringResult) (Tcl_Interp *interp, Tcl_DString *dsPtr); /* 123 */
-    void (*tcl_DStringSetLength) (Tcl_DString *dsPtr, size_t length); /* 124 */
+    void (*tcl_DStringSetLength) (Tcl_DString *dsPtr, int length); /* 124 */
     void (*tcl_DStringStartSublist) (Tcl_DString *dsPtr); /* 125 */
     int (*tcl_Eof) (Tcl_Channel chan); /* 126 */
     const char * (*tcl_ErrnoId) (void); /* 127 */
     const char * (*tcl_ErrnoMsg) (int err); /* 128 */
-    void (*reserved129)(void);
+    int (*tcl_Eval) (Tcl_Interp *interp, const char *script); /* 129 */
     int (*tcl_EvalFile) (Tcl_Interp *interp, const char *fileName); /* 130 */
-    void (*reserved131)(void);
-    void (*tcl_EventuallyFree) (void *clientData, Tcl_FreeProc *freeProc); /* 132 */
+    TCL_DEPRECATED_API("No longer in use, changed to macro") int (*tcl_EvalObj) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 131 */
+    void (*tcl_EventuallyFree) (ClientData clientData, Tcl_FreeProc *freeProc); /* 132 */
     TCL_NORETURN1 void (*tcl_Exit) (int status); /* 133 */
     int (*tcl_ExposeCommand) (Tcl_Interp *interp, const char *hiddenCmdToken, const char *cmdName); /* 134 */
     int (*tcl_ExprBoolean) (Tcl_Interp *interp, const char *expr, int *ptr); /* 135 */
     int (*tcl_ExprBooleanObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int *ptr); /* 136 */
     int (*tcl_ExprDouble) (Tcl_Interp *interp, const char *expr, double *ptr); /* 137 */
@@ -1926,53 +2073,53 @@
     int (*tcl_ExprLong) (Tcl_Interp *interp, const char *expr, long *ptr); /* 139 */
     int (*tcl_ExprLongObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, long *ptr); /* 140 */
     int (*tcl_ExprObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, Tcl_Obj **resultPtrPtr); /* 141 */
     int (*tcl_ExprString) (Tcl_Interp *interp, const char *expr); /* 142 */
     void (*tcl_Finalize) (void); /* 143 */
-    void (*reserved144)(void);
+    TCL_DEPRECATED_API("Don't use this function in a stub-enabled extension") void (*tcl_FindExecutable) (const char *argv0); /* 144 */
     Tcl_HashEntry * (*tcl_FirstHashEntry) (Tcl_HashTable *tablePtr, Tcl_HashSearch *searchPtr); /* 145 */
     int (*tcl_Flush) (Tcl_Channel chan); /* 146 */
     void (*tcl_FreeResult) (Tcl_Interp *interp); /* 147 */
     int (*tcl_GetAlias) (Tcl_Interp *interp, const char *slaveCmd, Tcl_Interp **targetInterpPtr, const char **targetCmdPtr, int *argcPtr, const char ***argvPtr); /* 148 */
     int (*tcl_GetAliasObj) (Tcl_Interp *interp, const char *slaveCmd, Tcl_Interp **targetInterpPtr, const char **targetCmdPtr, int *objcPtr, Tcl_Obj ***objv); /* 149 */
-    void * (*tcl_GetAssocData) (Tcl_Interp *interp, const char *name, Tcl_InterpDeleteProc **procPtr); /* 150 */
+    ClientData (*tcl_GetAssocData) (Tcl_Interp *interp, const char *name, Tcl_InterpDeleteProc **procPtr); /* 150 */
     Tcl_Channel (*tcl_GetChannel) (Tcl_Interp *interp, const char *chanName, int *modePtr); /* 151 */
     int (*tcl_GetChannelBufferSize) (Tcl_Channel chan); /* 152 */
-    int (*tcl_GetChannelHandle) (Tcl_Channel chan, int direction, void **handlePtr); /* 153 */
-    void * (*tcl_GetChannelInstanceData) (Tcl_Channel chan); /* 154 */
+    int (*tcl_GetChannelHandle) (Tcl_Channel chan, int direction, ClientData *handlePtr); /* 153 */
+    ClientData (*tcl_GetChannelInstanceData) (Tcl_Channel chan); /* 154 */
     int (*tcl_GetChannelMode) (Tcl_Channel chan); /* 155 */
     const char * (*tcl_GetChannelName) (Tcl_Channel chan); /* 156 */
     int (*tcl_GetChannelOption) (Tcl_Interp *interp, Tcl_Channel chan, const char *optionName, Tcl_DString *dsPtr); /* 157 */
-    const Tcl_ChannelType * (*tcl_GetChannelType) (Tcl_Channel chan); /* 158 */
+    CONST86 Tcl_ChannelType * (*tcl_GetChannelType) (Tcl_Channel chan); /* 158 */
     int (*tcl_GetCommandInfo) (Tcl_Interp *interp, const char *cmdName, Tcl_CmdInfo *infoPtr); /* 159 */
     const char * (*tcl_GetCommandName) (Tcl_Interp *interp, Tcl_Command command); /* 160 */
     int (*tcl_GetErrno) (void); /* 161 */
     const char * (*tcl_GetHostName) (void); /* 162 */
     int (*tcl_GetInterpPath) (Tcl_Interp *askInterp, Tcl_Interp *slaveInterp); /* 163 */
     Tcl_Interp * (*tcl_GetMaster) (Tcl_Interp *interp); /* 164 */
     const char * (*tcl_GetNameOfExecutable) (void); /* 165 */
     Tcl_Obj * (*tcl_GetObjResult) (Tcl_Interp *interp); /* 166 */
 #if !defined(_WIN32) && !defined(MAC_OSX_TCL) /* UNIX */
-    int (*tcl_GetOpenFile) (Tcl_Interp *interp, const char *chanID, int forWriting, int checkUsage, void **filePtr); /* 167 */
+    int (*tcl_GetOpenFile) (Tcl_Interp *interp, const char *chanID, int forWriting, int checkUsage, ClientData *filePtr); /* 167 */
 #endif /* UNIX */
 #if defined(_WIN32) /* WIN */
     void (*reserved167)(void);
 #endif /* WIN */
 #ifdef MAC_OSX_TCL /* MACOSX */
-    int (*tcl_GetOpenFile) (Tcl_Interp *interp, const char *chanID, int forWriting, int checkUsage, void **filePtr); /* 167 */
+    int (*tcl_GetOpenFile) (Tcl_Interp *interp, const char *chanID, int forWriting, int checkUsage, ClientData *filePtr); /* 167 */
 #endif /* MACOSX */
     Tcl_PathType (*tcl_GetPathType) (const char *path); /* 168 */
-    size_t (*tcl_Gets) (Tcl_Channel chan, Tcl_DString *dsPtr); /* 169 */
-    size_t (*tcl_GetsObj) (Tcl_Channel chan, Tcl_Obj *objPtr); /* 170 */
+    int (*tcl_Gets) (Tcl_Channel chan, Tcl_DString *dsPtr); /* 169 */
+    int (*tcl_GetsObj) (Tcl_Channel chan, Tcl_Obj *objPtr); /* 170 */
     int (*tcl_GetServiceMode) (void); /* 171 */
     Tcl_Interp * (*tcl_GetSlave) (Tcl_Interp *interp, const char *slaveName); /* 172 */
     Tcl_Channel (*tcl_GetStdChannel) (int type); /* 173 */
-    void (*reserved174)(void);
-    void (*reserved175)(void);
+    const char * (*tcl_GetStringResult) (Tcl_Interp *interp); /* 174 */
+    TCL_DEPRECATED_API("No longer in use, changed to macro") const char * (*tcl_GetVar) (Tcl_Interp *interp, const char *varName, int flags); /* 175 */
     const char * (*tcl_GetVar2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags); /* 176 */
-    void (*reserved177)(void);
-    void (*reserved178)(void);
+    int (*tcl_GlobalEval) (Tcl_Interp *interp, const char *command); /* 177 */
+    TCL_DEPRECATED_API("No longer in use, changed to macro") int (*tcl_GlobalEvalObj) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 178 */
     int (*tcl_HideCommand) (Tcl_Interp *interp, const char *cmdName, const char *hiddenCmdToken); /* 179 */
     int (*tcl_Init) (Tcl_Interp *interp); /* 180 */
     void (*tcl_InitHashTable) (Tcl_HashTable *tablePtr, int keyType); /* 181 */
     int (*tcl_InputBlocked) (Tcl_Channel chan); /* 182 */
     int (*tcl_InputBuffered) (Tcl_Channel chan); /* 183 */
@@ -1979,217 +2126,217 @@
     int (*tcl_InterpDeleted) (Tcl_Interp *interp); /* 184 */
     int (*tcl_IsSafe) (Tcl_Interp *interp); /* 185 */
     char * (*tcl_JoinPath) (int argc, const char *const *argv, Tcl_DString *resultPtr); /* 186 */
     int (*tcl_LinkVar) (Tcl_Interp *interp, const char *varName, void *addr, int type); /* 187 */
     void (*reserved188)(void);
-    Tcl_Channel (*tcl_MakeFileChannel) (void *handle, int mode); /* 189 */
+    Tcl_Channel (*tcl_MakeFileChannel) (ClientData handle, int mode); /* 189 */
     int (*tcl_MakeSafe) (Tcl_Interp *interp); /* 190 */
-    Tcl_Channel (*tcl_MakeTcpClientChannel) (void *tcpSocket); /* 191 */
+    Tcl_Channel (*tcl_MakeTcpClientChannel) (ClientData tcpSocket); /* 191 */
     char * (*tcl_Merge) (int argc, const char *const *argv); /* 192 */
     Tcl_HashEntry * (*tcl_NextHashEntry) (Tcl_HashSearch *searchPtr); /* 193 */
     void (*tcl_NotifyChannel) (Tcl_Channel channel, int mask); /* 194 */
     Tcl_Obj * (*tcl_ObjGetVar2) (Tcl_Interp *interp, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, int flags); /* 195 */
     Tcl_Obj * (*tcl_ObjSetVar2) (Tcl_Interp *interp, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, Tcl_Obj *newValuePtr, int flags); /* 196 */
     Tcl_Channel (*tcl_OpenCommandChannel) (Tcl_Interp *interp, int argc, const char **argv, int flags); /* 197 */
     Tcl_Channel (*tcl_OpenFileChannel) (Tcl_Interp *interp, const char *fileName, const char *modeString, int permissions); /* 198 */
     Tcl_Channel (*tcl_OpenTcpClient) (Tcl_Interp *interp, int port, const char *address, const char *myaddr, int myport, int async); /* 199 */
-    Tcl_Channel (*tcl_OpenTcpServer) (Tcl_Interp *interp, int port, const char *host, Tcl_TcpAcceptProc *acceptProc, void *callbackData); /* 200 */
-    void (*tcl_Preserve) (void *data); /* 201 */
+    Tcl_Channel (*tcl_OpenTcpServer) (Tcl_Interp *interp, int port, const char *host, Tcl_TcpAcceptProc *acceptProc, ClientData callbackData); /* 200 */
+    void (*tcl_Preserve) (ClientData data); /* 201 */
     void (*tcl_PrintDouble) (Tcl_Interp *interp, double value, char *dst); /* 202 */
     int (*tcl_PutEnv) (const char *assignment); /* 203 */
     const char * (*tcl_PosixError) (Tcl_Interp *interp); /* 204 */
     void (*tcl_QueueEvent) (Tcl_Event *evPtr, Tcl_QueuePosition position); /* 205 */
-    size_t (*tcl_Read) (Tcl_Channel chan, char *bufPtr, size_t toRead); /* 206 */
+    int (*tcl_Read) (Tcl_Channel chan, char *bufPtr, int toRead); /* 206 */
     void (*tcl_ReapDetachedProcs) (void); /* 207 */
     int (*tcl_RecordAndEval) (Tcl_Interp *interp, const char *cmd, int flags); /* 208 */
     int (*tcl_RecordAndEvalObj) (Tcl_Interp *interp, Tcl_Obj *cmdPtr, int flags); /* 209 */
     void (*tcl_RegisterChannel) (Tcl_Interp *interp, Tcl_Channel chan); /* 210 */
     void (*tcl_RegisterObjType) (const Tcl_ObjType *typePtr); /* 211 */
     Tcl_RegExp (*tcl_RegExpCompile) (Tcl_Interp *interp, const char *pattern); /* 212 */
     int (*tcl_RegExpExec) (Tcl_Interp *interp, Tcl_RegExp regexp, const char *text, const char *start); /* 213 */
     int (*tcl_RegExpMatch) (Tcl_Interp *interp, const char *text, const char *pattern); /* 214 */
-    void (*tcl_RegExpRange) (Tcl_RegExp regexp, size_t index, const char **startPtr, const char **endPtr); /* 215 */
-    void (*tcl_Release) (void *clientData); /* 216 */
+    void (*tcl_RegExpRange) (Tcl_RegExp regexp, int index, const char **startPtr, const char **endPtr); /* 215 */
+    void (*tcl_Release) (ClientData clientData); /* 216 */
     void (*tcl_ResetResult) (Tcl_Interp *interp); /* 217 */
-    size_t (*tcl_ScanElement) (const char *src, int *flagPtr); /* 218 */
-    size_t (*tcl_ScanCountedElement) (const char *src, size_t length, int *flagPtr); /* 219 */
-    void (*reserved220)(void);
+    int (*tcl_ScanElement) (const char *src, int *flagPtr); /* 218 */
+    int (*tcl_ScanCountedElement) (const char *src, int length, int *flagPtr); /* 219 */
+    TCL_DEPRECATED_API("") int (*tcl_SeekOld) (Tcl_Channel chan, int offset, int mode); /* 220 */
     int (*tcl_ServiceAll) (void); /* 221 */
     int (*tcl_ServiceEvent) (int flags); /* 222 */
-    void (*tcl_SetAssocData) (Tcl_Interp *interp, const char *name, Tcl_InterpDeleteProc *proc, void *clientData); /* 223 */
+    void (*tcl_SetAssocData) (Tcl_Interp *interp, const char *name, Tcl_InterpDeleteProc *proc, ClientData clientData); /* 223 */
     void (*tcl_SetChannelBufferSize) (Tcl_Channel chan, int sz); /* 224 */
     int (*tcl_SetChannelOption) (Tcl_Interp *interp, Tcl_Channel chan, const char *optionName, const char *newValue); /* 225 */
     int (*tcl_SetCommandInfo) (Tcl_Interp *interp, const char *cmdName, const Tcl_CmdInfo *infoPtr); /* 226 */
     void (*tcl_SetErrno) (int err); /* 227 */
     void (*tcl_SetErrorCode) (Tcl_Interp *interp, ...); /* 228 */
     void (*tcl_SetMaxBlockTime) (const Tcl_Time *timePtr); /* 229 */
-    void (*reserved230)(void);
+    TCL_DEPRECATED_API("Don't use this function in a stub-enabled extension") void (*tcl_SetPanicProc) (TCL_NORETURN1 Tcl_PanicProc *panicProc); /* 230 */
     int (*tcl_SetRecursionLimit) (Tcl_Interp *interp, int depth); /* 231 */
-    void (*reserved232)(void);
+    void (*tcl_SetResult) (Tcl_Interp *interp, char *result, Tcl_FreeProc *freeProc); /* 232 */
     int (*tcl_SetServiceMode) (int mode); /* 233 */
     void (*tcl_SetObjErrorCode) (Tcl_Interp *interp, Tcl_Obj *errorObjPtr); /* 234 */
     void (*tcl_SetObjResult) (Tcl_Interp *interp, Tcl_Obj *resultObjPtr); /* 235 */
     void (*tcl_SetStdChannel) (Tcl_Channel channel, int type); /* 236 */
-    void (*reserved237)(void);
+    TCL_DEPRECATED_API("No longer in use, changed to macro") const char * (*tcl_SetVar) (Tcl_Interp *interp, const char *varName, const char *newValue, int flags); /* 237 */
     const char * (*tcl_SetVar2) (Tcl_Interp *interp, const char *part1, const char *part2, const char *newValue, int flags); /* 238 */
     const char * (*tcl_SignalId) (int sig); /* 239 */
     const char * (*tcl_SignalMsg) (int sig); /* 240 */
     void (*tcl_SourceRCFile) (Tcl_Interp *interp); /* 241 */
     int (*tcl_SplitList) (Tcl_Interp *interp, const char *listStr, int *argcPtr, const char ***argvPtr); /* 242 */
     void (*tcl_SplitPath) (const char *path, int *argcPtr, const char ***argvPtr); /* 243 */
-    void (*reserved244)(void);
-    void (*reserved245)(void);
-    void (*reserved246)(void);
-    void (*reserved247)(void);
-    int (*tcl_TraceVar2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags, Tcl_VarTraceProc *proc, void *clientData); /* 248 */
+    TCL_DEPRECATED_API("Don't use this function in a stub-enabled extension") void (*tcl_StaticPackage) (Tcl_Interp *interp, const char *pkgName, Tcl_PackageInitProc *initProc, Tcl_PackageInitProc *safeInitProc); /* 244 */
+    TCL_DEPRECATED_API("No longer in use, changed to macro") int (*tcl_StringMatch) (const char *str, const char *pattern); /* 245 */
+    TCL_DEPRECATED_API("") int (*tcl_TellOld) (Tcl_Channel chan); /* 246 */
+    TCL_DEPRECATED_API("No longer in use, changed to macro") int (*tcl_TraceVar) (Tcl_Interp *interp, const char *varName, int flags, Tcl_VarTraceProc *proc, ClientData clientData); /* 247 */
+    int (*tcl_TraceVar2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags, Tcl_VarTraceProc *proc, ClientData clientData); /* 248 */
     char * (*tcl_TranslateFileName) (Tcl_Interp *interp, const char *name, Tcl_DString *bufferPtr); /* 249 */
-    size_t (*tcl_Ungets) (Tcl_Channel chan, const char *str, size_t len, int atHead); /* 250 */
+    int (*tcl_Ungets) (Tcl_Channel chan, const char *str, int len, int atHead); /* 250 */
     void (*tcl_UnlinkVar) (Tcl_Interp *interp, const char *varName); /* 251 */
     int (*tcl_UnregisterChannel) (Tcl_Interp *interp, Tcl_Channel chan); /* 252 */
-    void (*reserved253)(void);
+    TCL_DEPRECATED_API("No longer in use, changed to macro") int (*tcl_UnsetVar) (Tcl_Interp *interp, const char *varName, int flags); /* 253 */
     int (*tcl_UnsetVar2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags); /* 254 */
-    void (*reserved255)(void);
-    void (*tcl_UntraceVar2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags, Tcl_VarTraceProc *proc, void *clientData); /* 256 */
+    TCL_DEPRECATED_API("No longer in use, changed to macro") void (*tcl_UntraceVar) (Tcl_Interp *interp, const char *varName, int flags, Tcl_VarTraceProc *proc, ClientData clientData); /* 255 */
+    void (*tcl_UntraceVar2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags, Tcl_VarTraceProc *proc, ClientData clientData); /* 256 */
     void (*tcl_UpdateLinkedVar) (Tcl_Interp *interp, const char *varName); /* 257 */
-    void (*reserved258)(void);
+    TCL_DEPRECATED_API("No longer in use, changed to macro") int (*tcl_UpVar) (Tcl_Interp *interp, const char *frameName, const char *varName, const char *localName, int flags); /* 258 */
     int (*tcl_UpVar2) (Tcl_Interp *interp, const char *frameName, const char *part1, const char *part2, const char *localName, int flags); /* 259 */
     int (*tcl_VarEval) (Tcl_Interp *interp, ...); /* 260 */
-    void (*reserved261)(void);
-    void * (*tcl_VarTraceInfo2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags, Tcl_VarTraceProc *procPtr, void *prevClientData); /* 262 */
-    size_t (*tcl_Write) (Tcl_Channel chan, const char *s, size_t slen); /* 263 */
+    TCL_DEPRECATED_API("No longer in use, changed to macro") ClientData (*tcl_VarTraceInfo) (Tcl_Interp *interp, const char *varName, int flags, Tcl_VarTraceProc *procPtr, ClientData prevClientData); /* 261 */
+    ClientData (*tcl_VarTraceInfo2) (Tcl_Interp *interp, const char *part1, const char *part2, int flags, Tcl_VarTraceProc *procPtr, ClientData prevClientData); /* 262 */
+    int (*tcl_Write) (Tcl_Channel chan, const char *s, int slen); /* 263 */
     void (*tcl_WrongNumArgs) (Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], const char *message); /* 264 */
     int (*tcl_DumpActiveMemory) (const char *fileName); /* 265 */
     void (*tcl_ValidateAllMemory) (const char *file, int line); /* 266 */
-    void (*reserved267)(void);
-    void (*reserved268)(void);
+    TCL_DEPRECATED_API("see TIP #422") void (*tcl_AppendResultVA) (Tcl_Interp *interp, va_list argList); /* 267 */
+    TCL_DEPRECATED_API("see TIP #422") void (*tcl_AppendStringsToObjVA) (Tcl_Obj *objPtr, va_list argList); /* 268 */
     char * (*tcl_HashStats) (Tcl_HashTable *tablePtr); /* 269 */
     const char * (*tcl_ParseVar) (Tcl_Interp *interp, const char *start, const char **termPtr); /* 270 */
-    void (*reserved271)(void);
+    TCL_DEPRECATED_API("No longer in use, changed to macro") const char * (*tcl_PkgPresent) (Tcl_Interp *interp, const char *name, const char *version, int exact); /* 271 */
     const char * (*tcl_PkgPresentEx) (Tcl_Interp *interp, const char *name, const char *version, int exact, void *clientDataPtr); /* 272 */
-    void (*reserved273)(void);
-    void (*reserved274)(void);
-    void (*reserved275)(void);
-    void (*reserved276)(void);
+    TCL_DEPRECATED_API("No longer in use, changed to macro") int (*tcl_PkgProvide) (Tcl_Interp *interp, const char *name, const char *version); /* 273 */
+    TCL_DEPRECATED_API("No longer in use, changed to macro") const char * (*tcl_PkgRequire) (Tcl_Interp *interp, const char *name, const char *version, int exact); /* 274 */
+    TCL_DEPRECATED_API("see TIP #422") void (*tcl_SetErrorCodeVA) (Tcl_Interp *interp, va_list argList); /* 275 */
+    TCL_DEPRECATED_API("see TIP #422") int (*tcl_VarEvalVA) (Tcl_Interp *interp, va_list argList); /* 276 */
     Tcl_Pid (*tcl_WaitPid) (Tcl_Pid pid, int *statPtr, int options); /* 277 */
-    void (*reserved278)(void);
+    TCL_DEPRECATED_API("see TIP #422") TCL_NORETURN1 void (*tcl_PanicVA) (const char *format, va_list argList); /* 278 */
     void (*tcl_GetVersion) (int *major, int *minor, int *patchLevel, int *type); /* 279 */
     void (*tcl_InitMemory) (Tcl_Interp *interp); /* 280 */
-    Tcl_Channel (*tcl_StackChannel) (Tcl_Interp *interp, const Tcl_ChannelType *typePtr, void *instanceData, int mask, Tcl_Channel prevChan); /* 281 */
+    Tcl_Channel (*tcl_StackChannel) (Tcl_Interp *interp, const Tcl_ChannelType *typePtr, ClientData instanceData, int mask, Tcl_Channel prevChan); /* 281 */
     int (*tcl_UnstackChannel) (Tcl_Interp *interp, Tcl_Channel chan); /* 282 */
     Tcl_Channel (*tcl_GetStackedChannel) (Tcl_Channel chan); /* 283 */
     void (*tcl_SetMainLoop) (Tcl_MainLoopProc *proc); /* 284 */
     void (*reserved285)(void);
     void (*tcl_AppendObjToObj) (Tcl_Obj *objPtr, Tcl_Obj *appendObjPtr); /* 286 */
     Tcl_Encoding (*tcl_CreateEncoding) (const Tcl_EncodingType *typePtr); /* 287 */
-    void (*tcl_CreateThreadExitHandler) (Tcl_ExitProc *proc, void *clientData); /* 288 */
-    void (*tcl_DeleteThreadExitHandler) (Tcl_ExitProc *proc, void *clientData); /* 289 */
-    void (*reserved290)(void);
-    int (*tcl_EvalEx) (Tcl_Interp *interp, const char *script, size_t numBytes, int flags); /* 291 */
+    void (*tcl_CreateThreadExitHandler) (Tcl_ExitProc *proc, ClientData clientData); /* 288 */
+    void (*tcl_DeleteThreadExitHandler) (Tcl_ExitProc *proc, ClientData clientData); /* 289 */
+    void (*tcl_DiscardResult) (Tcl_SavedResult *statePtr); /* 290 */
+    int (*tcl_EvalEx) (Tcl_Interp *interp, const char *script, int numBytes, int flags); /* 291 */
     int (*tcl_EvalObjv) (Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], int flags); /* 292 */
     int (*tcl_EvalObjEx) (Tcl_Interp *interp, Tcl_Obj *objPtr, int flags); /* 293 */
     TCL_NORETURN1 void (*tcl_ExitThread) (int status); /* 294 */
-    int (*tcl_ExternalToUtf) (Tcl_Interp *interp, Tcl_Encoding encoding, const char *src, size_t srcLen, int flags, Tcl_EncodingState *statePtr, char *dst, size_t dstLen, int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr); /* 295 */
-    char * (*tcl_ExternalToUtfDString) (Tcl_Encoding encoding, const char *src, size_t srcLen, Tcl_DString *dsPtr); /* 296 */
+    int (*tcl_ExternalToUtf) (Tcl_Interp *interp, Tcl_Encoding encoding, const char *src, int srcLen, int flags, Tcl_EncodingState *statePtr, char *dst, int dstLen, int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr); /* 295 */
+    char * (*tcl_ExternalToUtfDString) (Tcl_Encoding encoding, const char *src, int srcLen, Tcl_DString *dsPtr); /* 296 */
     void (*tcl_FinalizeThread) (void); /* 297 */
-    void (*tcl_FinalizeNotifier) (void *clientData); /* 298 */
+    void (*tcl_FinalizeNotifier) (ClientData clientData); /* 298 */
     void (*tcl_FreeEncoding) (Tcl_Encoding encoding); /* 299 */
     Tcl_ThreadId (*tcl_GetCurrentThread) (void); /* 300 */
     Tcl_Encoding (*tcl_GetEncoding) (Tcl_Interp *interp, const char *name); /* 301 */
     const char * (*tcl_GetEncodingName) (Tcl_Encoding encoding); /* 302 */
     void (*tcl_GetEncodingNames) (Tcl_Interp *interp); /* 303 */
-    int (*tcl_GetIndexFromObjStruct) (Tcl_Interp *interp, Tcl_Obj *objPtr, const void *tablePtr, size_t offset, const char *msg, int flags, int *indexPtr); /* 304 */
-    void * (*tcl_GetThreadData) (Tcl_ThreadDataKey *keyPtr, size_t size); /* 305 */
+    int (*tcl_GetIndexFromObjStruct) (Tcl_Interp *interp, Tcl_Obj *objPtr, const void *tablePtr, int offset, const char *msg, int flags, int *indexPtr); /* 304 */
+    void * (*tcl_GetThreadData) (Tcl_ThreadDataKey *keyPtr, int size); /* 305 */
     Tcl_Obj * (*tcl_GetVar2Ex) (Tcl_Interp *interp, const char *part1, const char *part2, int flags); /* 306 */
-    void * (*tcl_InitNotifier) (void); /* 307 */
+    ClientData (*tcl_InitNotifier) (void); /* 307 */
     void (*tcl_MutexLock) (Tcl_Mutex *mutexPtr); /* 308 */
     void (*tcl_MutexUnlock) (Tcl_Mutex *mutexPtr); /* 309 */
     void (*tcl_ConditionNotify) (Tcl_Condition *condPtr); /* 310 */
     void (*tcl_ConditionWait) (Tcl_Condition *condPtr, Tcl_Mutex *mutexPtr, const Tcl_Time *timePtr); /* 311 */
-    size_t (*tcl_NumUtfChars) (const char *src, size_t length); /* 312 */
-    size_t (*tcl_ReadChars) (Tcl_Channel channel, Tcl_Obj *objPtr, size_t charsToRead, int appendFlag); /* 313 */
-    void (*reserved314)(void);
-    void (*reserved315)(void);
+    int (*tcl_NumUtfChars) (const char *src, int length); /* 312 */
+    int (*tcl_ReadChars) (Tcl_Channel channel, Tcl_Obj *objPtr, int charsToRead, int appendFlag); /* 313 */
+    void (*tcl_RestoreResult) (Tcl_Interp *interp, Tcl_SavedResult *statePtr); /* 314 */
+    void (*tcl_SaveResult) (Tcl_Interp *interp, Tcl_SavedResult *statePtr); /* 315 */
     int (*tcl_SetSystemEncoding) (Tcl_Interp *interp, const char *name); /* 316 */
     Tcl_Obj * (*tcl_SetVar2Ex) (Tcl_Interp *interp, const char *part1, const char *part2, Tcl_Obj *newValuePtr, int flags); /* 317 */
     void (*tcl_ThreadAlert) (Tcl_ThreadId threadId); /* 318 */
     void (*tcl_ThreadQueueEvent) (Tcl_ThreadId threadId, Tcl_Event *evPtr, Tcl_QueuePosition position); /* 319 */
-    int (*tcl_UniCharAtIndex) (const char *src, size_t index); /* 320 */
+    int (*tcl_UniCharAtIndex) (const char *src, int index); /* 320 */
     int (*tcl_UniCharToLower) (int ch); /* 321 */
     int (*tcl_UniCharToTitle) (int ch); /* 322 */
     int (*tcl_UniCharToUpper) (int ch); /* 323 */
     int (*tcl_UniCharToUtf) (int ch, char *buf); /* 324 */
-    const char * (*tcl_UtfAtIndex) (const char *src, size_t index); /* 325 */
-    int (*tcl_UtfCharComplete) (const char *src, size_t length); /* 326 */
-    size_t (*tcl_UtfBackslash) (const char *src, int *readPtr, char *dst); /* 327 */
+    const char * (*tcl_UtfAtIndex) (const char *src, int index); /* 325 */
+    int (*tcl_UtfCharComplete) (const char *src, int length); /* 326 */
+    int (*tcl_UtfBackslash) (const char *src, int *readPtr, char *dst); /* 327 */
     const char * (*tcl_UtfFindFirst) (const char *src, int ch); /* 328 */
     const char * (*tcl_UtfFindLast) (const char *src, int ch); /* 329 */
     const char * (*tcl_UtfNext) (const char *src); /* 330 */
     const char * (*tcl_UtfPrev) (const char *src, const char *start); /* 331 */
-    int (*tcl_UtfToExternal) (Tcl_Interp *interp, Tcl_Encoding encoding, const char *src, size_t srcLen, int flags, Tcl_EncodingState *statePtr, char *dst, size_t dstLen, int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr); /* 332 */
-    char * (*tcl_UtfToExternalDString) (Tcl_Encoding encoding, const char *src, size_t srcLen, Tcl_DString *dsPtr); /* 333 */
+    int (*tcl_UtfToExternal) (Tcl_Interp *interp, Tcl_Encoding encoding, const char *src, int srcLen, int flags, Tcl_EncodingState *statePtr, char *dst, int dstLen, int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr); /* 332 */
+    char * (*tcl_UtfToExternalDString) (Tcl_Encoding encoding, const char *src, int srcLen, Tcl_DString *dsPtr); /* 333 */
     int (*tcl_UtfToLower) (char *src); /* 334 */
     int (*tcl_UtfToTitle) (char *src); /* 335 */
     int (*tcl_UtfToUniChar) (const char *src, Tcl_UniChar *chPtr); /* 336 */
     int (*tcl_UtfToUpper) (char *src); /* 337 */
-    size_t (*tcl_WriteChars) (Tcl_Channel chan, const char *src, size_t srcLen); /* 338 */
-    size_t (*tcl_WriteObj) (Tcl_Channel chan, Tcl_Obj *objPtr); /* 339 */
+    int (*tcl_WriteChars) (Tcl_Channel chan, const char *src, int srcLen); /* 338 */
+    int (*tcl_WriteObj) (Tcl_Channel chan, Tcl_Obj *objPtr); /* 339 */
     char * (*tcl_GetString) (Tcl_Obj *objPtr); /* 340 */
-    void (*reserved341)(void);
-    void (*reserved342)(void);
-    void (*tcl_AlertNotifier) (void *clientData); /* 343 */
+    TCL_DEPRECATED_API("Use Tcl_GetEncodingSearchPath") const char * (*tcl_GetDefaultEncodingDir) (void); /* 341 */
+    TCL_DEPRECATED_API("Use Tcl_SetEncodingSearchPath") void (*tcl_SetDefaultEncodingDir) (const char *path); /* 342 */
+    void (*tcl_AlertNotifier) (ClientData clientData); /* 343 */
     void (*tcl_ServiceModeHook) (int mode); /* 344 */
     int (*tcl_UniCharIsAlnum) (int ch); /* 345 */
     int (*tcl_UniCharIsAlpha) (int ch); /* 346 */
     int (*tcl_UniCharIsDigit) (int ch); /* 347 */
     int (*tcl_UniCharIsLower) (int ch); /* 348 */
     int (*tcl_UniCharIsSpace) (int ch); /* 349 */
     int (*tcl_UniCharIsUpper) (int ch); /* 350 */
     int (*tcl_UniCharIsWordChar) (int ch); /* 351 */
-    size_t (*tcl_UniCharLen) (const Tcl_UniChar *uniStr); /* 352 */
-    int (*tcl_UniCharNcmp) (const Tcl_UniChar *ucs, const Tcl_UniChar *uct, size_t numChars); /* 353 */
-    char * (*tcl_UniCharToUtfDString) (const Tcl_UniChar *uniStr, size_t uniLength, Tcl_DString *dsPtr); /* 354 */
-    Tcl_UniChar * (*tcl_UtfToUniCharDString) (const char *src, size_t length, Tcl_DString *dsPtr); /* 355 */
+    int (*tcl_UniCharLen) (const Tcl_UniChar *uniStr); /* 352 */
+    int (*tcl_UniCharNcmp) (const Tcl_UniChar *ucs, const Tcl_UniChar *uct, unsigned long numChars); /* 353 */
+    char * (*tcl_UniCharToUtfDString) (const Tcl_UniChar *uniStr, int uniLength, Tcl_DString *dsPtr); /* 354 */
+    Tcl_UniChar * (*tcl_UtfToUniCharDString) (const char *src, int length, Tcl_DString *dsPtr); /* 355 */
     Tcl_RegExp (*tcl_GetRegExpFromObj) (Tcl_Interp *interp, Tcl_Obj *patObj, int flags); /* 356 */
-    void (*reserved357)(void);
+    TCL_DEPRECATED_API("Use Tcl_EvalTokensStandard") Tcl_Obj * (*tcl_EvalTokens) (Tcl_Interp *interp, Tcl_Token *tokenPtr, int count); /* 357 */
     void (*tcl_FreeParse) (Tcl_Parse *parsePtr); /* 358 */
-    void (*tcl_LogCommandInfo) (Tcl_Interp *interp, const char *script, const char *command, size_t length); /* 359 */
-    int (*tcl_ParseBraces) (Tcl_Interp *interp, const char *start, size_t numBytes, Tcl_Parse *parsePtr, int append, const char **termPtr); /* 360 */
-    int (*tcl_ParseCommand) (Tcl_Interp *interp, const char *start, size_t numBytes, int nested, Tcl_Parse *parsePtr); /* 361 */
-    int (*tcl_ParseExpr) (Tcl_Interp *interp, const char *start, size_t numBytes, Tcl_Parse *parsePtr); /* 362 */
-    int (*tcl_ParseQuotedString) (Tcl_Interp *interp, const char *start, size_t numBytes, Tcl_Parse *parsePtr, int append, const char **termPtr); /* 363 */
-    int (*tcl_ParseVarName) (Tcl_Interp *interp, const char *start, size_t numBytes, Tcl_Parse *parsePtr, int append); /* 364 */
+    void (*tcl_LogCommandInfo) (Tcl_Interp *interp, const char *script, const char *command, int length); /* 359 */
+    int (*tcl_ParseBraces) (Tcl_Interp *interp, const char *start, int numBytes, Tcl_Parse *parsePtr, int append, const char **termPtr); /* 360 */
+    int (*tcl_ParseCommand) (Tcl_Interp *interp, const char *start, int numBytes, int nested, Tcl_Parse *parsePtr); /* 361 */
+    int (*tcl_ParseExpr) (Tcl_Interp *interp, const char *start, int numBytes, Tcl_Parse *parsePtr); /* 362 */
+    int (*tcl_ParseQuotedString) (Tcl_Interp *interp, const char *start, int numBytes, Tcl_Parse *parsePtr, int append, const char **termPtr); /* 363 */
+    int (*tcl_ParseVarName) (Tcl_Interp *interp, const char *start, int numBytes, Tcl_Parse *parsePtr, int append); /* 364 */
     char * (*tcl_GetCwd) (Tcl_Interp *interp, Tcl_DString *cwdPtr); /* 365 */
     int (*tcl_Chdir) (const char *dirName); /* 366 */
     int (*tcl_Access) (const char *path, int mode); /* 367 */
     int (*tcl_Stat) (const char *path, struct stat *bufPtr); /* 368 */
-    int (*tcl_UtfNcmp) (const char *s1, const char *s2, size_t n); /* 369 */
-    int (*tcl_UtfNcasecmp) (const char *s1, const char *s2, size_t n); /* 370 */
+    int (*tcl_UtfNcmp) (const char *s1, const char *s2, unsigned long n); /* 369 */
+    int (*tcl_UtfNcasecmp) (const char *s1, const char *s2, unsigned long n); /* 370 */
     int (*tcl_StringCaseMatch) (const char *str, const char *pattern, int nocase); /* 371 */
     int (*tcl_UniCharIsControl) (int ch); /* 372 */
     int (*tcl_UniCharIsGraph) (int ch); /* 373 */
     int (*tcl_UniCharIsPrint) (int ch); /* 374 */
     int (*tcl_UniCharIsPunct) (int ch); /* 375 */
-    int (*tcl_RegExpExecObj) (Tcl_Interp *interp, Tcl_RegExp regexp, Tcl_Obj *textObj, size_t offset, size_t nmatches, int flags); /* 376 */
+    int (*tcl_RegExpExecObj) (Tcl_Interp *interp, Tcl_RegExp regexp, Tcl_Obj *textObj, int offset, int nmatches, int flags); /* 376 */
     void (*tcl_RegExpGetInfo) (Tcl_RegExp regexp, Tcl_RegExpInfo *infoPtr); /* 377 */
-    Tcl_Obj * (*tcl_NewUnicodeObj) (const Tcl_UniChar *unicode, size_t numChars); /* 378 */
-    void (*tcl_SetUnicodeObj) (Tcl_Obj *objPtr, const Tcl_UniChar *unicode, size_t numChars); /* 379 */
-    size_t (*tcl_GetCharLength) (Tcl_Obj *objPtr); /* 380 */
-    int (*tcl_GetUniChar) (Tcl_Obj *objPtr, size_t index); /* 381 */
-    void (*reserved382)(void);
-    Tcl_Obj * (*tcl_GetRange) (Tcl_Obj *objPtr, size_t first, size_t last); /* 383 */
-    void (*tcl_AppendUnicodeToObj) (Tcl_Obj *objPtr, const Tcl_UniChar *unicode, size_t length); /* 384 */
+    Tcl_Obj * (*tcl_NewUnicodeObj) (const Tcl_UniChar *unicode, int numChars); /* 378 */
+    void (*tcl_SetUnicodeObj) (Tcl_Obj *objPtr, const Tcl_UniChar *unicode, int numChars); /* 379 */
+    int (*tcl_GetCharLength) (Tcl_Obj *objPtr); /* 380 */
+    int (*tcl_GetUniChar) (Tcl_Obj *objPtr, int index); /* 381 */
+    TCL_DEPRECATED_API("No longer in use, changed to macro") Tcl_UniChar * (*tcl_GetUnicode) (Tcl_Obj *objPtr); /* 382 */
+    Tcl_Obj * (*tcl_GetRange) (Tcl_Obj *objPtr, int first, int last); /* 383 */
+    void (*tcl_AppendUnicodeToObj) (Tcl_Obj *objPtr, const Tcl_UniChar *unicode, int length); /* 384 */
     int (*tcl_RegExpMatchObj) (Tcl_Interp *interp, Tcl_Obj *textObj, Tcl_Obj *patternObj); /* 385 */
     void (*tcl_SetNotifier) (Tcl_NotifierProcs *notifierProcPtr); /* 386 */
     Tcl_Mutex * (*tcl_GetAllocMutex) (void); /* 387 */
     int (*tcl_GetChannelNames) (Tcl_Interp *interp); /* 388 */
     int (*tcl_GetChannelNamesEx) (Tcl_Interp *interp, const char *pattern); /* 389 */
-    int (*tcl_ProcObjCmd) (void *clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]); /* 390 */
+    int (*tcl_ProcObjCmd) (ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]); /* 390 */
     void (*tcl_ConditionFinalize) (Tcl_Condition *condPtr); /* 391 */
     void (*tcl_MutexFinalize) (Tcl_Mutex *mutex); /* 392 */
-    int (*tcl_CreateThread) (Tcl_ThreadId *idPtr, Tcl_ThreadCreateProc *proc, void *clientData, size_t stackSize, int flags); /* 393 */
-    size_t (*tcl_ReadRaw) (Tcl_Channel chan, char *dst, size_t bytesToRead); /* 394 */
-    size_t (*tcl_WriteRaw) (Tcl_Channel chan, const char *src, size_t srcLen); /* 395 */
+    int (*tcl_CreateThread) (Tcl_ThreadId *idPtr, Tcl_ThreadCreateProc *proc, ClientData clientData, int stackSize, int flags); /* 393 */
+    int (*tcl_ReadRaw) (Tcl_Channel chan, char *dst, int bytesToRead); /* 394 */
+    int (*tcl_WriteRaw) (Tcl_Channel chan, const char *src, int srcLen); /* 395 */
     Tcl_Channel (*tcl_GetTopChannel) (Tcl_Channel chan); /* 396 */
     int (*tcl_ChannelBuffered) (Tcl_Channel chan); /* 397 */
     const char * (*tcl_ChannelName) (const Tcl_ChannelType *chanTypePtr); /* 398 */
     Tcl_ChannelTypeVersion (*tcl_ChannelVersion) (const Tcl_ChannelType *chanTypePtr); /* 399 */
     Tcl_DriverBlockModeProc * (*tcl_ChannelBlockModeProc) (const Tcl_ChannelType *chanTypePtr); /* 400 */
@@ -2209,28 +2356,28 @@
     int (*tcl_IsChannelRegistered) (Tcl_Interp *interp, Tcl_Channel channel); /* 414 */
     void (*tcl_CutChannel) (Tcl_Channel channel); /* 415 */
     void (*tcl_SpliceChannel) (Tcl_Channel channel); /* 416 */
     void (*tcl_ClearChannelHandlers) (Tcl_Channel channel); /* 417 */
     int (*tcl_IsChannelExisting) (const char *channelName); /* 418 */
-    int (*tcl_UniCharNcasecmp) (const Tcl_UniChar *ucs, const Tcl_UniChar *uct, size_t numChars); /* 419 */
+    int (*tcl_UniCharNcasecmp) (const Tcl_UniChar *ucs, const Tcl_UniChar *uct, unsigned long numChars); /* 419 */
     int (*tcl_UniCharCaseMatch) (const Tcl_UniChar *uniStr, const Tcl_UniChar *uniPattern, int nocase); /* 420 */
-    void (*reserved421)(void);
-    void (*reserved422)(void);
+    Tcl_HashEntry * (*tcl_FindHashEntry) (Tcl_HashTable *tablePtr, const void *key); /* 421 */
+    Tcl_HashEntry * (*tcl_CreateHashEntry) (Tcl_HashTable *tablePtr, const void *key, int *newPtr); /* 422 */
     void (*tcl_InitCustomHashTable) (Tcl_HashTable *tablePtr, int keyType, const Tcl_HashKeyType *typePtr); /* 423 */
     void (*tcl_InitObjHashTable) (Tcl_HashTable *tablePtr); /* 424 */
-    void * (*tcl_CommandTraceInfo) (Tcl_Interp *interp, const char *varName, int flags, Tcl_CommandTraceProc *procPtr, void *prevClientData); /* 425 */
-    int (*tcl_TraceCommand) (Tcl_Interp *interp, const char *varName, int flags, Tcl_CommandTraceProc *proc, void *clientData); /* 426 */
-    void (*tcl_UntraceCommand) (Tcl_Interp *interp, const char *varName, int flags, Tcl_CommandTraceProc *proc, void *clientData); /* 427 */
-    void * (*tcl_AttemptAlloc) (size_t size); /* 428 */
-    void * (*tcl_AttemptDbCkalloc) (size_t size, const char *file, int line); /* 429 */
-    void * (*tcl_AttemptRealloc) (void *ptr, size_t size); /* 430 */
-    void * (*tcl_AttemptDbCkrealloc) (void *ptr, size_t size, const char *file, int line); /* 431 */
-    int (*tcl_AttemptSetObjLength) (Tcl_Obj *objPtr, size_t length); /* 432 */
+    ClientData (*tcl_CommandTraceInfo) (Tcl_Interp *interp, const char *varName, int flags, Tcl_CommandTraceProc *procPtr, ClientData prevClientData); /* 425 */
+    int (*tcl_TraceCommand) (Tcl_Interp *interp, const char *varName, int flags, Tcl_CommandTraceProc *proc, ClientData clientData); /* 426 */
+    void (*tcl_UntraceCommand) (Tcl_Interp *interp, const char *varName, int flags, Tcl_CommandTraceProc *proc, ClientData clientData); /* 427 */
+    char * (*tcl_AttemptAlloc) (unsigned int size); /* 428 */
+    char * (*tcl_AttemptDbCkalloc) (unsigned int size, const char *file, int line); /* 429 */
+    char * (*tcl_AttemptRealloc) (char *ptr, unsigned int size); /* 430 */
+    char * (*tcl_AttemptDbCkrealloc) (char *ptr, unsigned int size, const char *file, int line); /* 431 */
+    int (*tcl_AttemptSetObjLength) (Tcl_Obj *objPtr, int length); /* 432 */
     Tcl_ThreadId (*tcl_GetChannelThread) (Tcl_Channel channel); /* 433 */
     Tcl_UniChar * (*tcl_GetUnicodeFromObj) (Tcl_Obj *objPtr, int *lengthPtr); /* 434 */
-    void (*reserved435)(void);
-    void (*reserved436)(void);
+    TCL_DEPRECATED_API("") int (*tcl_GetMathFuncInfo) (Tcl_Interp *interp, const char *name, int *numArgsPtr, Tcl_ValueType **argTypesPtr, Tcl_MathProc **procPtr, ClientData *clientDataPtr); /* 435 */
+    TCL_DEPRECATED_API("") Tcl_Obj * (*tcl_ListMathFuncs) (Tcl_Interp *interp, const char *pattern); /* 436 */
     Tcl_Obj * (*tcl_SubstObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int flags); /* 437 */
     int (*tcl_DetachChannel) (Tcl_Interp *interp, Tcl_Channel channel); /* 438 */
     int (*tcl_IsStandardChannel) (Tcl_Channel channel); /* 439 */
     int (*tcl_FSCopyFile) (Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr); /* 440 */
     int (*tcl_FSCopyDirectory) (Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr, Tcl_Obj **errorPtr); /* 441 */
@@ -2243,11 +2390,11 @@
     int (*tcl_FSRenameFile) (Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr); /* 448 */
     int (*tcl_FSLstat) (Tcl_Obj *pathPtr, Tcl_StatBuf *buf); /* 449 */
     int (*tcl_FSUtime) (Tcl_Obj *pathPtr, struct utimbuf *tval); /* 450 */
     int (*tcl_FSFileAttrsGet) (Tcl_Interp *interp, int index, Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef); /* 451 */
     int (*tcl_FSFileAttrsSet) (Tcl_Interp *interp, int index, Tcl_Obj *pathPtr, Tcl_Obj *objPtr); /* 452 */
-    const char *const * (*tcl_FSFileAttrStrings) (Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef); /* 453 */
+    const char *CONST86 * (*tcl_FSFileAttrStrings) (Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef); /* 453 */
     int (*tcl_FSStat) (Tcl_Obj *pathPtr, Tcl_StatBuf *buf); /* 454 */
     int (*tcl_FSAccess) (Tcl_Obj *pathPtr, int mode); /* 455 */
     Tcl_Channel (*tcl_FSOpenFileChannel) (Tcl_Interp *interp, Tcl_Obj *pathPtr, const char *modeString, int permissions); /* 456 */
     Tcl_Obj * (*tcl_FSGetCwd) (Tcl_Interp *interp); /* 457 */
     int (*tcl_FSChdir) (Tcl_Obj *pathPtr); /* 458 */
@@ -2255,29 +2402,29 @@
     Tcl_Obj * (*tcl_FSJoinPath) (Tcl_Obj *listObj, int elements); /* 460 */
     Tcl_Obj * (*tcl_FSSplitPath) (Tcl_Obj *pathPtr, int *lenPtr); /* 461 */
     int (*tcl_FSEqualPaths) (Tcl_Obj *firstPtr, Tcl_Obj *secondPtr); /* 462 */
     Tcl_Obj * (*tcl_FSGetNormalizedPath) (Tcl_Interp *interp, Tcl_Obj *pathPtr); /* 463 */
     Tcl_Obj * (*tcl_FSJoinToPath) (Tcl_Obj *pathPtr, int objc, Tcl_Obj *const objv[]); /* 464 */
-    void * (*tcl_FSGetInternalRep) (Tcl_Obj *pathPtr, const Tcl_Filesystem *fsPtr); /* 465 */
+    ClientData (*tcl_FSGetInternalRep) (Tcl_Obj *pathPtr, const Tcl_Filesystem *fsPtr); /* 465 */
     Tcl_Obj * (*tcl_FSGetTranslatedPath) (Tcl_Interp *interp, Tcl_Obj *pathPtr); /* 466 */
     int (*tcl_FSEvalFile) (Tcl_Interp *interp, Tcl_Obj *fileName); /* 467 */
-    Tcl_Obj * (*tcl_FSNewNativePath) (const Tcl_Filesystem *fromFilesystem, void *clientData); /* 468 */
+    Tcl_Obj * (*tcl_FSNewNativePath) (const Tcl_Filesystem *fromFilesystem, ClientData clientData); /* 468 */
     const void * (*tcl_FSGetNativePath) (Tcl_Obj *pathPtr); /* 469 */
     Tcl_Obj * (*tcl_FSFileSystemInfo) (Tcl_Obj *pathPtr); /* 470 */
     Tcl_Obj * (*tcl_FSPathSeparator) (Tcl_Obj *pathPtr); /* 471 */
     Tcl_Obj * (*tcl_FSListVolumes) (void); /* 472 */
-    int (*tcl_FSRegister) (void *clientData, const Tcl_Filesystem *fsPtr); /* 473 */
+    int (*tcl_FSRegister) (ClientData clientData, const Tcl_Filesystem *fsPtr); /* 473 */
     int (*tcl_FSUnregister) (const Tcl_Filesystem *fsPtr); /* 474 */
-    void * (*tcl_FSData) (const Tcl_Filesystem *fsPtr); /* 475 */
+    ClientData (*tcl_FSData) (const Tcl_Filesystem *fsPtr); /* 475 */
     const char * (*tcl_FSGetTranslatedStringPath) (Tcl_Interp *interp, Tcl_Obj *pathPtr); /* 476 */
-    const Tcl_Filesystem * (*tcl_FSGetFileSystemForPath) (Tcl_Obj *pathPtr); /* 477 */
+    CONST86 Tcl_Filesystem * (*tcl_FSGetFileSystemForPath) (Tcl_Obj *pathPtr); /* 477 */
     Tcl_PathType (*tcl_FSGetPathType) (Tcl_Obj *pathPtr); /* 478 */
     int (*tcl_OutputBuffered) (Tcl_Channel chan); /* 479 */
     void (*tcl_FSMountsChanged) (const Tcl_Filesystem *fsPtr); /* 480 */
-    int (*tcl_EvalTokensStandard) (Tcl_Interp *interp, Tcl_Token *tokenPtr, size_t count); /* 481 */
+    int (*tcl_EvalTokensStandard) (Tcl_Interp *interp, Tcl_Token *tokenPtr, int count); /* 481 */
     void (*tcl_GetTime) (Tcl_Time *timeBuf); /* 482 */
-    Tcl_Trace (*tcl_CreateObjTrace) (Tcl_Interp *interp, int level, int flags, Tcl_CmdObjTraceProc *objProc, void *clientData, Tcl_CmdObjTraceDeleteProc *delProc); /* 483 */
+    Tcl_Trace (*tcl_CreateObjTrace) (Tcl_Interp *interp, int level, int flags, Tcl_CmdObjTraceProc *objProc, ClientData clientData, Tcl_CmdObjTraceDeleteProc *delProc); /* 483 */
     int (*tcl_GetCommandInfoFromToken) (Tcl_Command token, Tcl_CmdInfo *infoPtr); /* 484 */
     int (*tcl_SetCommandInfoFromToken) (Tcl_Command token, const Tcl_CmdInfo *infoPtr); /* 485 */
     Tcl_Obj * (*tcl_DbNewWideIntObj) (Tcl_WideInt wideValue, const char *file, int line); /* 486 */
     int (*tcl_GetWideIntFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, Tcl_WideInt *widePtr); /* 487 */
     Tcl_Obj * (*tcl_NewWideIntObj) (Tcl_WideInt wideValue); /* 488 */
@@ -2296,11 +2443,11 @@
     int (*tcl_DictObjPutKeyList) (Tcl_Interp *interp, Tcl_Obj *dictPtr, int keyc, Tcl_Obj *const *keyv, Tcl_Obj *valuePtr); /* 501 */
     int (*tcl_DictObjRemoveKeyList) (Tcl_Interp *interp, Tcl_Obj *dictPtr, int keyc, Tcl_Obj *const *keyv); /* 502 */
     Tcl_Obj * (*tcl_NewDictObj) (void); /* 503 */
     Tcl_Obj * (*tcl_DbNewDictObj) (const char *file, int line); /* 504 */
     void (*tcl_RegisterConfig) (Tcl_Interp *interp, const char *pkgName, const Tcl_Config *configuration, const char *valEncoding); /* 505 */
-    Tcl_Namespace * (*tcl_CreateNamespace) (Tcl_Interp *interp, const char *name, void *clientData, Tcl_NamespaceDeleteProc *deleteProc); /* 506 */
+    Tcl_Namespace * (*tcl_CreateNamespace) (Tcl_Interp *interp, const char *name, ClientData clientData, Tcl_NamespaceDeleteProc *deleteProc); /* 506 */
     void (*tcl_DeleteNamespace) (Tcl_Namespace *nsPtr); /* 507 */
     int (*tcl_AppendExportList) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, Tcl_Obj *objPtr); /* 508 */
     int (*tcl_Export) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, const char *pattern, int resetListFirst); /* 509 */
     int (*tcl_Import) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, const char *pattern, int allowOverwrite); /* 510 */
     int (*tcl_ForgetImport) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, const char *pattern); /* 511 */
@@ -2309,13 +2456,13 @@
     Tcl_Namespace * (*tcl_FindNamespace) (Tcl_Interp *interp, const char *name, Tcl_Namespace *contextNsPtr, int flags); /* 514 */
     Tcl_Command (*tcl_FindCommand) (Tcl_Interp *interp, const char *name, Tcl_Namespace *contextNsPtr, int flags); /* 515 */
     Tcl_Command (*tcl_GetCommandFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 516 */
     void (*tcl_GetCommandFullName) (Tcl_Interp *interp, Tcl_Command command, Tcl_Obj *objPtr); /* 517 */
     int (*tcl_FSEvalFileEx) (Tcl_Interp *interp, Tcl_Obj *fileName, const char *encodingName); /* 518 */
-    void (*reserved519)(void);
-    void (*tcl_LimitAddHandler) (Tcl_Interp *interp, int type, Tcl_LimitHandlerProc *handlerProc, void *clientData, Tcl_LimitHandlerDeleteProc *deleteProc); /* 520 */
-    void (*tcl_LimitRemoveHandler) (Tcl_Interp *interp, int type, Tcl_LimitHandlerProc *handlerProc, void *clientData); /* 521 */
+    TCL_DEPRECATED_API("Don't use this function in a stub-enabled extension") Tcl_ExitProc * (*tcl_SetExitProc) (TCL_NORETURN1 Tcl_ExitProc *proc); /* 519 */
+    void (*tcl_LimitAddHandler) (Tcl_Interp *interp, int type, Tcl_LimitHandlerProc *handlerProc, ClientData clientData, Tcl_LimitHandlerDeleteProc *deleteProc); /* 520 */
+    void (*tcl_LimitRemoveHandler) (Tcl_Interp *interp, int type, Tcl_LimitHandlerProc *handlerProc, ClientData clientData); /* 521 */
     int (*tcl_LimitReady) (Tcl_Interp *interp); /* 522 */
     int (*tcl_LimitCheck) (Tcl_Interp *interp); /* 523 */
     int (*tcl_LimitExceeded) (Tcl_Interp *interp); /* 524 */
     void (*tcl_LimitSetCommands) (Tcl_Interp *interp, int commandLimit); /* 525 */
     void (*tcl_LimitSetTime) (Tcl_Interp *interp, Tcl_Time *timeLimitPtr); /* 526 */
@@ -2342,12 +2489,12 @@
     int (*tcl_GetEnsembleSubcommandList) (Tcl_Interp *interp, Tcl_Command token, Tcl_Obj **subcmdListPtr); /* 547 */
     int (*tcl_GetEnsembleMappingDict) (Tcl_Interp *interp, Tcl_Command token, Tcl_Obj **mapDictPtr); /* 548 */
     int (*tcl_GetEnsembleUnknownHandler) (Tcl_Interp *interp, Tcl_Command token, Tcl_Obj **unknownListPtr); /* 549 */
     int (*tcl_GetEnsembleFlags) (Tcl_Interp *interp, Tcl_Command token, int *flagsPtr); /* 550 */
     int (*tcl_GetEnsembleNamespace) (Tcl_Interp *interp, Tcl_Command token, Tcl_Namespace **namespacePtrPtr); /* 551 */
-    void (*tcl_SetTimeProc) (Tcl_GetTimeProc *getProc, Tcl_ScaleTimeProc *scaleProc, void *clientData); /* 552 */
-    void (*tcl_QueryTimeProc) (Tcl_GetTimeProc **getProc, Tcl_ScaleTimeProc **scaleProc, void **clientData); /* 553 */
+    void (*tcl_SetTimeProc) (Tcl_GetTimeProc *getProc, Tcl_ScaleTimeProc *scaleProc, ClientData clientData); /* 552 */
+    void (*tcl_QueryTimeProc) (Tcl_GetTimeProc **getProc, Tcl_ScaleTimeProc **scaleProc, ClientData *clientData); /* 553 */
     Tcl_DriverThreadActionProc * (*tcl_ChannelThreadActionProc) (const Tcl_ChannelType *chanTypePtr); /* 554 */
     Tcl_Obj * (*tcl_NewBignumObj) (mp_int *value); /* 555 */
     Tcl_Obj * (*tcl_DbNewBignumObj) (mp_int *value, const char *file, int line); /* 556 */
     void (*tcl_SetBignumObj) (Tcl_Obj *obj, mp_int *value); /* 557 */
     int (*tcl_GetBignumFromObj) (Tcl_Interp *interp, Tcl_Obj *obj, mp_int *value); /* 558 */
@@ -2365,24 +2512,24 @@
     Tcl_Obj * (*tcl_GetEncodingSearchPath) (void); /* 570 */
     int (*tcl_SetEncodingSearchPath) (Tcl_Obj *searchPath); /* 571 */
     const char * (*tcl_GetEncodingNameFromEnvironment) (Tcl_DString *bufPtr); /* 572 */
     int (*tcl_PkgRequireProc) (Tcl_Interp *interp, const char *name, int objc, Tcl_Obj *const objv[], void *clientDataPtr); /* 573 */
     void (*tcl_AppendObjToErrorInfo) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 574 */
-    void (*tcl_AppendLimitedToObj) (Tcl_Obj *objPtr, const char *bytes, size_t length, size_t limit, const char *ellipsis); /* 575 */
+    void (*tcl_AppendLimitedToObj) (Tcl_Obj *objPtr, const char *bytes, int length, int limit, const char *ellipsis); /* 575 */
     Tcl_Obj * (*tcl_Format) (Tcl_Interp *interp, const char *format, int objc, Tcl_Obj *const objv[]); /* 576 */
     int (*tcl_AppendFormatToObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, const char *format, int objc, Tcl_Obj *const objv[]); /* 577 */
     Tcl_Obj * (*tcl_ObjPrintf) (const char *format, ...) TCL_FORMAT_PRINTF(1, 2); /* 578 */
     void (*tcl_AppendPrintfToObj) (Tcl_Obj *objPtr, const char *format, ...) TCL_FORMAT_PRINTF(2, 3); /* 579 */
-    int (*tcl_CancelEval) (Tcl_Interp *interp, Tcl_Obj *resultObjPtr, void *clientData, int flags); /* 580 */
+    int (*tcl_CancelEval) (Tcl_Interp *interp, Tcl_Obj *resultObjPtr, ClientData clientData, int flags); /* 580 */
     int (*tcl_Canceled) (Tcl_Interp *interp, int flags); /* 581 */
     int (*tcl_CreatePipe) (Tcl_Interp *interp, Tcl_Channel *rchan, Tcl_Channel *wchan, int flags); /* 582 */
-    Tcl_Command (*tcl_NRCreateCommand) (Tcl_Interp *interp, const char *cmdName, Tcl_ObjCmdProc *proc, Tcl_ObjCmdProc *nreProc, void *clientData, Tcl_CmdDeleteProc *deleteProc); /* 583 */
+    Tcl_Command (*tcl_NRCreateCommand) (Tcl_Interp *interp, const char *cmdName, Tcl_ObjCmdProc *proc, Tcl_ObjCmdProc *nreProc, ClientData clientData, Tcl_CmdDeleteProc *deleteProc); /* 583 */
     int (*tcl_NREvalObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int flags); /* 584 */
     int (*tcl_NREvalObjv) (Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], int flags); /* 585 */
     int (*tcl_NRCmdSwap) (Tcl_Interp *interp, Tcl_Command cmd, int objc, Tcl_Obj *const objv[], int flags); /* 586 */
-    void (*tcl_NRAddCallback) (Tcl_Interp *interp, Tcl_NRPostProc *postProcPtr, void *data0, void *data1, void *data2, void *data3); /* 587 */
-    int (*tcl_NRCallObjProc) (Tcl_Interp *interp, Tcl_ObjCmdProc *objProc, void *clientData, int objc, Tcl_Obj *const objv[]); /* 588 */
+    void (*tcl_NRAddCallback) (Tcl_Interp *interp, Tcl_NRPostProc *postProcPtr, ClientData data0, ClientData data1, ClientData data2, ClientData data3); /* 587 */
+    int (*tcl_NRCallObjProc) (Tcl_Interp *interp, Tcl_ObjCmdProc *objProc, ClientData clientData, int objc, Tcl_Obj *const objv[]); /* 588 */
     unsigned (*tcl_GetFSDeviceFromStat) (const Tcl_StatBuf *statPtr); /* 589 */
     unsigned (*tcl_GetFSInodeFromStat) (const Tcl_StatBuf *statPtr); /* 590 */
     unsigned (*tcl_GetModeFromStat) (const Tcl_StatBuf *statPtr); /* 591 */
     int (*tcl_GetLinkCountFromStat) (const Tcl_StatBuf *statPtr); /* 592 */
     int (*tcl_GetUserIdFromStat) (const Tcl_StatBuf *statPtr); /* 593 */
@@ -2401,19 +2548,19 @@
     void (*tcl_SetErrorLine) (Tcl_Interp *interp, int lineNum); /* 606 */
     void (*tcl_TransferResult) (Tcl_Interp *sourceInterp, int result, Tcl_Interp *targetInterp); /* 607 */
     int (*tcl_InterpActive) (Tcl_Interp *interp); /* 608 */
     void (*tcl_BackgroundException) (Tcl_Interp *interp, int code); /* 609 */
     int (*tcl_ZlibDeflate) (Tcl_Interp *interp, int format, Tcl_Obj *data, int level, Tcl_Obj *gzipHeaderDictObj); /* 610 */
-    int (*tcl_ZlibInflate) (Tcl_Interp *interp, int format, Tcl_Obj *data, size_t buffersize, Tcl_Obj *gzipHeaderDictObj); /* 611 */
-    unsigned int (*tcl_ZlibCRC32) (unsigned int crc, const unsigned char *buf, size_t len); /* 612 */
-    unsigned int (*tcl_ZlibAdler32) (unsigned int adler, const unsigned char *buf, size_t len); /* 613 */
+    int (*tcl_ZlibInflate) (Tcl_Interp *interp, int format, Tcl_Obj *data, int buffersize, Tcl_Obj *gzipHeaderDictObj); /* 611 */
+    unsigned int (*tcl_ZlibCRC32) (unsigned int crc, const unsigned char *buf, int len); /* 612 */
+    unsigned int (*tcl_ZlibAdler32) (unsigned int adler, const unsigned char *buf, int len); /* 613 */
     int (*tcl_ZlibStreamInit) (Tcl_Interp *interp, int mode, int format, int level, Tcl_Obj *dictObj, Tcl_ZlibStream *zshandle); /* 614 */
     Tcl_Obj * (*tcl_ZlibStreamGetCommandName) (Tcl_ZlibStream zshandle); /* 615 */
     int (*tcl_ZlibStreamEof) (Tcl_ZlibStream zshandle); /* 616 */
     int (*tcl_ZlibStreamChecksum) (Tcl_ZlibStream zshandle); /* 617 */
     int (*tcl_ZlibStreamPut) (Tcl_ZlibStream zshandle, Tcl_Obj *data, int flush); /* 618 */
-    int (*tcl_ZlibStreamGet) (Tcl_ZlibStream zshandle, Tcl_Obj *data, size_t count); /* 619 */
+    int (*tcl_ZlibStreamGet) (Tcl_ZlibStream zshandle, Tcl_Obj *data, int count); /* 619 */
     int (*tcl_ZlibStreamClose) (Tcl_ZlibStream zshandle); /* 620 */
     int (*tcl_ZlibStreamReset) (Tcl_ZlibStream zshandle); /* 621 */
     void (*tcl_SetStartupScript) (Tcl_Obj *path, const char *encoding); /* 622 */
     Tcl_Obj * (*tcl_GetStartupScript) (const char **encodingPtr); /* 623 */
     int (*tcl_CloseEx) (Tcl_Interp *interp, Tcl_Channel chan, int flags); /* 624 */
@@ -2421,25 +2568,25 @@
     int (*tcl_NRSubstObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, int flags); /* 626 */
     int (*tcl_LoadFile) (Tcl_Interp *interp, Tcl_Obj *pathPtr, const char *const symv[], int flags, void *procPtrs, Tcl_LoadHandle *handlePtr); /* 627 */
     void * (*tcl_FindSymbol) (Tcl_Interp *interp, Tcl_LoadHandle handle, const char *symbol); /* 628 */
     int (*tcl_FSUnloadFile) (Tcl_Interp *interp, Tcl_LoadHandle handlePtr); /* 629 */
     void (*tcl_ZlibStreamSetCompressionDictionary) (Tcl_ZlibStream zhandle, Tcl_Obj *compressionDictionaryObj); /* 630 */
-    Tcl_Channel (*tcl_OpenTcpServerEx) (Tcl_Interp *interp, const char *service, const char *host, unsigned int flags, Tcl_TcpAcceptProc *acceptProc, void *callbackData); /* 631 */
+    Tcl_Channel (*tcl_OpenTcpServerEx) (Tcl_Interp *interp, const char *service, const char *host, unsigned int flags, Tcl_TcpAcceptProc *acceptProc, ClientData callbackData); /* 631 */
     int (*tclZipfs_Mount) (Tcl_Interp *interp, const char *mountPoint, const char *zipname, const char *passwd); /* 632 */
     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_FreeIntRep) (Tcl_Obj *objPtr); /* 636 */
-    char * (*tcl_InitStringRep) (Tcl_Obj *objPtr, const char *bytes, size_t numBytes); /* 637 */
+    char * (*tcl_InitStringRep) (Tcl_Obj *objPtr, const char *bytes, unsigned int numBytes); /* 637 */
     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 */
     int (*tcl_IsShared) (Tcl_Obj *objPtr); /* 643 */
-    int (*tcl_LinkArray) (Tcl_Interp *interp, const char *varName, void *addr, int type, size_t size); /* 644 */
-    int (*tcl_GetIntForIndex) (Tcl_Interp *interp, Tcl_Obj *objPtr, size_t endValue, size_t *indexPtr); /* 645 */
+    int (*tcl_LinkArray) (Tcl_Interp *interp, const char *varName, void *addr, int type, int size); /* 644 */
+    int (*tcl_GetIntForIndex) (Tcl_Interp *interp, Tcl_Obj *objPtr, int endValue, int *indexPtr); /* 645 */
 } TclStubs;
 
 extern const TclStubs *tclStubsPtr;
 
 #ifdef __cplusplus
@@ -2506,25 +2653,28 @@
 	(tclStubsPtr->tcl_DbDecrRefCount) /* 19 */
 #define Tcl_DbIncrRefCount \
 	(tclStubsPtr->tcl_DbIncrRefCount) /* 20 */
 #define Tcl_DbIsShared \
 	(tclStubsPtr->tcl_DbIsShared) /* 21 */
-/* Slot 22 is reserved */
+#define Tcl_DbNewBooleanObj \
+	(tclStubsPtr->tcl_DbNewBooleanObj) /* 22 */
 #define Tcl_DbNewByteArrayObj \
 	(tclStubsPtr->tcl_DbNewByteArrayObj) /* 23 */
 #define Tcl_DbNewDoubleObj \
 	(tclStubsPtr->tcl_DbNewDoubleObj) /* 24 */
 #define Tcl_DbNewListObj \
 	(tclStubsPtr->tcl_DbNewListObj) /* 25 */
-/* Slot 26 is reserved */
+#define Tcl_DbNewLongObj \
+	(tclStubsPtr->tcl_DbNewLongObj) /* 26 */
 #define Tcl_DbNewObj \
 	(tclStubsPtr->tcl_DbNewObj) /* 27 */
 #define Tcl_DbNewStringObj \
 	(tclStubsPtr->tcl_DbNewStringObj) /* 28 */
 #define Tcl_DuplicateObj \
 	(tclStubsPtr->tcl_DuplicateObj) /* 29 */
-/* Slot 30 is reserved */
+#define TclOldFreeObj \
+	(tclStubsPtr->tclOldFreeObj) /* 30 */
 #define Tcl_GetBoolean \
 	(tclStubsPtr->tcl_GetBoolean) /* 31 */
 #define Tcl_GetBooleanFromObj \
 	(tclStubsPtr->tcl_GetBooleanFromObj) /* 32 */
 #define Tcl_GetByteArrayFromObj \
@@ -2531,11 +2681,12 @@
 	(tclStubsPtr->tcl_GetByteArrayFromObj) /* 33 */
 #define Tcl_GetDouble \
 	(tclStubsPtr->tcl_GetDouble) /* 34 */
 #define Tcl_GetDoubleFromObj \
 	(tclStubsPtr->tcl_GetDoubleFromObj) /* 35 */
-/* Slot 36 is reserved */
+#define Tcl_GetIndexFromObj \
+	(tclStubsPtr->tcl_GetIndexFromObj) /* 36 */
 #define Tcl_GetInt \
 	(tclStubsPtr->tcl_GetInt) /* 37 */
 #define Tcl_GetIntFromObj \
 	(tclStubsPtr->tcl_GetIntFromObj) /* 38 */
 #define Tcl_GetLongFromObj \
@@ -2556,40 +2707,48 @@
 	(tclStubsPtr->tcl_ListObjIndex) /* 46 */
 #define Tcl_ListObjLength \
 	(tclStubsPtr->tcl_ListObjLength) /* 47 */
 #define Tcl_ListObjReplace \
 	(tclStubsPtr->tcl_ListObjReplace) /* 48 */
-/* Slot 49 is reserved */
+#define Tcl_NewBooleanObj \
+	(tclStubsPtr->tcl_NewBooleanObj) /* 49 */
 #define Tcl_NewByteArrayObj \
 	(tclStubsPtr->tcl_NewByteArrayObj) /* 50 */
 #define Tcl_NewDoubleObj \
 	(tclStubsPtr->tcl_NewDoubleObj) /* 51 */
-/* Slot 52 is reserved */
+#define Tcl_NewIntObj \
+	(tclStubsPtr->tcl_NewIntObj) /* 52 */
 #define Tcl_NewListObj \
 	(tclStubsPtr->tcl_NewListObj) /* 53 */
-/* Slot 54 is reserved */
+#define Tcl_NewLongObj \
+	(tclStubsPtr->tcl_NewLongObj) /* 54 */
 #define Tcl_NewObj \
 	(tclStubsPtr->tcl_NewObj) /* 55 */
 #define Tcl_NewStringObj \
 	(tclStubsPtr->tcl_NewStringObj) /* 56 */
-/* Slot 57 is reserved */
+#define Tcl_SetBooleanObj \
+	(tclStubsPtr->tcl_SetBooleanObj) /* 57 */
 #define Tcl_SetByteArrayLength \
 	(tclStubsPtr->tcl_SetByteArrayLength) /* 58 */
 #define Tcl_SetByteArrayObj \
 	(tclStubsPtr->tcl_SetByteArrayObj) /* 59 */
 #define Tcl_SetDoubleObj \
 	(tclStubsPtr->tcl_SetDoubleObj) /* 60 */
-/* Slot 61 is reserved */
+#define Tcl_SetIntObj \
+	(tclStubsPtr->tcl_SetIntObj) /* 61 */
 #define Tcl_SetListObj \
 	(tclStubsPtr->tcl_SetListObj) /* 62 */
-/* Slot 63 is reserved */
+#define Tcl_SetLongObj \
+	(tclStubsPtr->tcl_SetLongObj) /* 63 */
 #define Tcl_SetObjLength \
 	(tclStubsPtr->tcl_SetObjLength) /* 64 */
 #define Tcl_SetStringObj \
 	(tclStubsPtr->tcl_SetStringObj) /* 65 */
-/* Slot 66 is reserved */
-/* Slot 67 is reserved */
+#define Tcl_AddErrorInfo \
+	(tclStubsPtr->tcl_AddErrorInfo) /* 66 */
+#define Tcl_AddObjErrorInfo \
+	(tclStubsPtr->tcl_AddObjErrorInfo) /* 67 */
 #define Tcl_AllowExceptions \
 	(tclStubsPtr->tcl_AllowExceptions) /* 68 */
 #define Tcl_AppendElement \
 	(tclStubsPtr->tcl_AppendElement) /* 69 */
 #define Tcl_AppendResult \
@@ -2602,12 +2761,14 @@
 	(tclStubsPtr->tcl_AsyncInvoke) /* 73 */
 #define Tcl_AsyncMark \
 	(tclStubsPtr->tcl_AsyncMark) /* 74 */
 #define Tcl_AsyncReady \
 	(tclStubsPtr->tcl_AsyncReady) /* 75 */
-/* Slot 76 is reserved */
-/* Slot 77 is reserved */
+#define Tcl_BackgroundError \
+	(tclStubsPtr->tcl_BackgroundError) /* 76 */
+#define Tcl_Backslash \
+	(tclStubsPtr->tcl_Backslash) /* 77 */
 #define Tcl_BadChannelOption \
 	(tclStubsPtr->tcl_BadChannelOption) /* 78 */
 #define Tcl_CallWhenDeleted \
 	(tclStubsPtr->tcl_CallWhenDeleted) /* 79 */
 #define Tcl_CancelIdleCall \
@@ -2638,11 +2799,12 @@
 	(tclStubsPtr->tcl_CreateEventSource) /* 92 */
 #define Tcl_CreateExitHandler \
 	(tclStubsPtr->tcl_CreateExitHandler) /* 93 */
 #define Tcl_CreateInterp \
 	(tclStubsPtr->tcl_CreateInterp) /* 94 */
-/* Slot 95 is reserved */
+#define Tcl_CreateMathFunc \
+	(tclStubsPtr->tcl_CreateMathFunc) /* 95 */
 #define Tcl_CreateObjCommand \
 	(tclStubsPtr->tcl_CreateObjCommand) /* 96 */
 #define Tcl_CreateSlave \
 	(tclStubsPtr->tcl_CreateSlave) /* 97 */
 #define Tcl_CreateTimerHandler \
@@ -2705,14 +2867,16 @@
 	(tclStubsPtr->tcl_Eof) /* 126 */
 #define Tcl_ErrnoId \
 	(tclStubsPtr->tcl_ErrnoId) /* 127 */
 #define Tcl_ErrnoMsg \
 	(tclStubsPtr->tcl_ErrnoMsg) /* 128 */
-/* Slot 129 is reserved */
+#define Tcl_Eval \
+	(tclStubsPtr->tcl_Eval) /* 129 */
 #define Tcl_EvalFile \
 	(tclStubsPtr->tcl_EvalFile) /* 130 */
-/* Slot 131 is reserved */
+#define Tcl_EvalObj \
+	(tclStubsPtr->tcl_EvalObj) /* 131 */
 #define Tcl_EventuallyFree \
 	(tclStubsPtr->tcl_EventuallyFree) /* 132 */
 #define Tcl_Exit \
 	(tclStubsPtr->tcl_Exit) /* 133 */
 #define Tcl_ExposeCommand \
@@ -2733,11 +2897,12 @@
 	(tclStubsPtr->tcl_ExprObj) /* 141 */
 #define Tcl_ExprString \
 	(tclStubsPtr->tcl_ExprString) /* 142 */
 #define Tcl_Finalize \
 	(tclStubsPtr->tcl_Finalize) /* 143 */
-/* Slot 144 is reserved */
+#define Tcl_FindExecutable \
+	(tclStubsPtr->tcl_FindExecutable) /* 144 */
 #define Tcl_FirstHashEntry \
 	(tclStubsPtr->tcl_FirstHashEntry) /* 145 */
 #define Tcl_Flush \
 	(tclStubsPtr->tcl_Flush) /* 146 */
 #define Tcl_FreeResult \
@@ -2798,16 +2963,20 @@
 	(tclStubsPtr->tcl_GetServiceMode) /* 171 */
 #define Tcl_GetSlave \
 	(tclStubsPtr->tcl_GetSlave) /* 172 */
 #define Tcl_GetStdChannel \
 	(tclStubsPtr->tcl_GetStdChannel) /* 173 */
-/* Slot 174 is reserved */
-/* Slot 175 is reserved */
+#define Tcl_GetStringResult \
+	(tclStubsPtr->tcl_GetStringResult) /* 174 */
+#define Tcl_GetVar \
+	(tclStubsPtr->tcl_GetVar) /* 175 */
 #define Tcl_GetVar2 \
 	(tclStubsPtr->tcl_GetVar2) /* 176 */
-/* Slot 177 is reserved */
-/* Slot 178 is reserved */
+#define Tcl_GlobalEval \
+	(tclStubsPtr->tcl_GlobalEval) /* 177 */
+#define Tcl_GlobalEvalObj \
+	(tclStubsPtr->tcl_GlobalEvalObj) /* 178 */
 #define Tcl_HideCommand \
 	(tclStubsPtr->tcl_HideCommand) /* 179 */
 #define Tcl_Init \
 	(tclStubsPtr->tcl_Init) /* 180 */
 #define Tcl_InitHashTable \
@@ -2885,11 +3054,12 @@
 	(tclStubsPtr->tcl_ResetResult) /* 217 */
 #define Tcl_ScanElement \
 	(tclStubsPtr->tcl_ScanElement) /* 218 */
 #define Tcl_ScanCountedElement \
 	(tclStubsPtr->tcl_ScanCountedElement) /* 219 */
-/* Slot 220 is reserved */
+#define Tcl_SeekOld \
+	(tclStubsPtr->tcl_SeekOld) /* 220 */
 #define Tcl_ServiceAll \
 	(tclStubsPtr->tcl_ServiceAll) /* 221 */
 #define Tcl_ServiceEvent \
 	(tclStubsPtr->tcl_ServiceEvent) /* 222 */
 #define Tcl_SetAssocData \
@@ -2904,23 +3074,26 @@
 	(tclStubsPtr->tcl_SetErrno) /* 227 */
 #define Tcl_SetErrorCode \
 	(tclStubsPtr->tcl_SetErrorCode) /* 228 */
 #define Tcl_SetMaxBlockTime \
 	(tclStubsPtr->tcl_SetMaxBlockTime) /* 229 */
-/* Slot 230 is reserved */
+#define Tcl_SetPanicProc \
+	(tclStubsPtr->tcl_SetPanicProc) /* 230 */
 #define Tcl_SetRecursionLimit \
 	(tclStubsPtr->tcl_SetRecursionLimit) /* 231 */
-/* Slot 232 is reserved */
+#define Tcl_SetResult \
+	(tclStubsPtr->tcl_SetResult) /* 232 */
 #define Tcl_SetServiceMode \
 	(tclStubsPtr->tcl_SetServiceMode) /* 233 */
 #define Tcl_SetObjErrorCode \
 	(tclStubsPtr->tcl_SetObjErrorCode) /* 234 */
 #define Tcl_SetObjResult \
 	(tclStubsPtr->tcl_SetObjResult) /* 235 */
 #define Tcl_SetStdChannel \
 	(tclStubsPtr->tcl_SetStdChannel) /* 236 */
-/* Slot 237 is reserved */
+#define Tcl_SetVar \
+	(tclStubsPtr->tcl_SetVar) /* 237 */
 #define Tcl_SetVar2 \
 	(tclStubsPtr->tcl_SetVar2) /* 238 */
 #define Tcl_SignalId \
 	(tclStubsPtr->tcl_SignalId) /* 239 */
 #define Tcl_SignalMsg \
@@ -2929,14 +3102,18 @@
 	(tclStubsPtr->tcl_SourceRCFile) /* 241 */
 #define Tcl_SplitList \
 	(tclStubsPtr->tcl_SplitList) /* 242 */
 #define Tcl_SplitPath \
 	(tclStubsPtr->tcl_SplitPath) /* 243 */
-/* Slot 244 is reserved */
-/* Slot 245 is reserved */
-/* Slot 246 is reserved */
-/* Slot 247 is reserved */
+#define Tcl_StaticPackage \
+	(tclStubsPtr->tcl_StaticPackage) /* 244 */
+#define Tcl_StringMatch \
+	(tclStubsPtr->tcl_StringMatch) /* 245 */
+#define Tcl_TellOld \
+	(tclStubsPtr->tcl_TellOld) /* 246 */
+#define Tcl_TraceVar \
+	(tclStubsPtr->tcl_TraceVar) /* 247 */
 #define Tcl_TraceVar2 \
 	(tclStubsPtr->tcl_TraceVar2) /* 248 */
 #define Tcl_TranslateFileName \
 	(tclStubsPtr->tcl_TranslateFileName) /* 249 */
 #define Tcl_Ungets \
@@ -2943,24 +3120,28 @@
 	(tclStubsPtr->tcl_Ungets) /* 250 */
 #define Tcl_UnlinkVar \
 	(tclStubsPtr->tcl_UnlinkVar) /* 251 */
 #define Tcl_UnregisterChannel \
 	(tclStubsPtr->tcl_UnregisterChannel) /* 252 */
-/* Slot 253 is reserved */
+#define Tcl_UnsetVar \
+	(tclStubsPtr->tcl_UnsetVar) /* 253 */
 #define Tcl_UnsetVar2 \
 	(tclStubsPtr->tcl_UnsetVar2) /* 254 */
-/* Slot 255 is reserved */
+#define Tcl_UntraceVar \
+	(tclStubsPtr->tcl_UntraceVar) /* 255 */
 #define Tcl_UntraceVar2 \
 	(tclStubsPtr->tcl_UntraceVar2) /* 256 */
 #define Tcl_UpdateLinkedVar \
 	(tclStubsPtr->tcl_UpdateLinkedVar) /* 257 */
-/* Slot 258 is reserved */
+#define Tcl_UpVar \
+	(tclStubsPtr->tcl_UpVar) /* 258 */
 #define Tcl_UpVar2 \
 	(tclStubsPtr->tcl_UpVar2) /* 259 */
 #define Tcl_VarEval \
 	(tclStubsPtr->tcl_VarEval) /* 260 */
-/* Slot 261 is reserved */
+#define Tcl_VarTraceInfo \
+	(tclStubsPtr->tcl_VarTraceInfo) /* 261 */
 #define Tcl_VarTraceInfo2 \
 	(tclStubsPtr->tcl_VarTraceInfo2) /* 262 */
 #define Tcl_Write \
 	(tclStubsPtr->tcl_Write) /* 263 */
 #define Tcl_WrongNumArgs \
@@ -2967,26 +3148,34 @@
 	(tclStubsPtr->tcl_WrongNumArgs) /* 264 */
 #define Tcl_DumpActiveMemory \
 	(tclStubsPtr->tcl_DumpActiveMemory) /* 265 */
 #define Tcl_ValidateAllMemory \
 	(tclStubsPtr->tcl_ValidateAllMemory) /* 266 */
-/* Slot 267 is reserved */
-/* Slot 268 is reserved */
+#define Tcl_AppendResultVA \
+	(tclStubsPtr->tcl_AppendResultVA) /* 267 */
+#define Tcl_AppendStringsToObjVA \
+	(tclStubsPtr->tcl_AppendStringsToObjVA) /* 268 */
 #define Tcl_HashStats \
 	(tclStubsPtr->tcl_HashStats) /* 269 */
 #define Tcl_ParseVar \
 	(tclStubsPtr->tcl_ParseVar) /* 270 */
-/* Slot 271 is reserved */
+#define Tcl_PkgPresent \
+	(tclStubsPtr->tcl_PkgPresent) /* 271 */
 #define Tcl_PkgPresentEx \
 	(tclStubsPtr->tcl_PkgPresentEx) /* 272 */
-/* Slot 273 is reserved */
-/* Slot 274 is reserved */
-/* Slot 275 is reserved */
-/* Slot 276 is reserved */
+#define Tcl_PkgProvide \
+	(tclStubsPtr->tcl_PkgProvide) /* 273 */
+#define Tcl_PkgRequire \
+	(tclStubsPtr->tcl_PkgRequire) /* 274 */
+#define Tcl_SetErrorCodeVA \
+	(tclStubsPtr->tcl_SetErrorCodeVA) /* 275 */
+#define Tcl_VarEvalVA \
+	(tclStubsPtr->tcl_VarEvalVA) /* 276 */
 #define Tcl_WaitPid \
 	(tclStubsPtr->tcl_WaitPid) /* 277 */
-/* Slot 278 is reserved */
+#define Tcl_PanicVA \
+	(tclStubsPtr->tcl_PanicVA) /* 278 */
 #define Tcl_GetVersion \
 	(tclStubsPtr->tcl_GetVersion) /* 279 */
 #define Tcl_InitMemory \
 	(tclStubsPtr->tcl_InitMemory) /* 280 */
 #define Tcl_StackChannel \
@@ -3004,11 +3193,12 @@
 	(tclStubsPtr->tcl_CreateEncoding) /* 287 */
 #define Tcl_CreateThreadExitHandler \
 	(tclStubsPtr->tcl_CreateThreadExitHandler) /* 288 */
 #define Tcl_DeleteThreadExitHandler \
 	(tclStubsPtr->tcl_DeleteThreadExitHandler) /* 289 */
-/* Slot 290 is reserved */
+#define Tcl_DiscardResult \
+	(tclStubsPtr->tcl_DiscardResult) /* 290 */
 #define Tcl_EvalEx \
 	(tclStubsPtr->tcl_EvalEx) /* 291 */
 #define Tcl_EvalObjv \
 	(tclStubsPtr->tcl_EvalObjv) /* 292 */
 #define Tcl_EvalObjEx \
@@ -3051,12 +3241,14 @@
 	(tclStubsPtr->tcl_ConditionWait) /* 311 */
 #define Tcl_NumUtfChars \
 	(tclStubsPtr->tcl_NumUtfChars) /* 312 */
 #define Tcl_ReadChars \
 	(tclStubsPtr->tcl_ReadChars) /* 313 */
-/* Slot 314 is reserved */
-/* Slot 315 is reserved */
+#define Tcl_RestoreResult \
+	(tclStubsPtr->tcl_RestoreResult) /* 314 */
+#define Tcl_SaveResult \
+	(tclStubsPtr->tcl_SaveResult) /* 315 */
 #define Tcl_SetSystemEncoding \
 	(tclStubsPtr->tcl_SetSystemEncoding) /* 316 */
 #define Tcl_SetVar2Ex \
 	(tclStubsPtr->tcl_SetVar2Ex) /* 317 */
 #define Tcl_ThreadAlert \
@@ -3103,12 +3295,14 @@
 	(tclStubsPtr->tcl_WriteChars) /* 338 */
 #define Tcl_WriteObj \
 	(tclStubsPtr->tcl_WriteObj) /* 339 */
 #define Tcl_GetString \
 	(tclStubsPtr->tcl_GetString) /* 340 */
-/* Slot 341 is reserved */
-/* Slot 342 is reserved */
+#define Tcl_GetDefaultEncodingDir \
+	(tclStubsPtr->tcl_GetDefaultEncodingDir) /* 341 */
+#define Tcl_SetDefaultEncodingDir \
+	(tclStubsPtr->tcl_SetDefaultEncodingDir) /* 342 */
 #define Tcl_AlertNotifier \
 	(tclStubsPtr->tcl_AlertNotifier) /* 343 */
 #define Tcl_ServiceModeHook \
 	(tclStubsPtr->tcl_ServiceModeHook) /* 344 */
 #define Tcl_UniCharIsAlnum \
@@ -3133,11 +3327,12 @@
 	(tclStubsPtr->tcl_UniCharToUtfDString) /* 354 */
 #define Tcl_UtfToUniCharDString \
 	(tclStubsPtr->tcl_UtfToUniCharDString) /* 355 */
 #define Tcl_GetRegExpFromObj \
 	(tclStubsPtr->tcl_GetRegExpFromObj) /* 356 */
-/* Slot 357 is reserved */
+#define Tcl_EvalTokens \
+	(tclStubsPtr->tcl_EvalTokens) /* 357 */
 #define Tcl_FreeParse \
 	(tclStubsPtr->tcl_FreeParse) /* 358 */
 #define Tcl_LogCommandInfo \
 	(tclStubsPtr->tcl_LogCommandInfo) /* 359 */
 #define Tcl_ParseBraces \
@@ -3182,11 +3377,12 @@
 	(tclStubsPtr->tcl_SetUnicodeObj) /* 379 */
 #define Tcl_GetCharLength \
 	(tclStubsPtr->tcl_GetCharLength) /* 380 */
 #define Tcl_GetUniChar \
 	(tclStubsPtr->tcl_GetUniChar) /* 381 */
-/* Slot 382 is reserved */
+#define Tcl_GetUnicode \
+	(tclStubsPtr->tcl_GetUnicode) /* 382 */
 #define Tcl_GetRange \
 	(tclStubsPtr->tcl_GetRange) /* 383 */
 #define Tcl_AppendUnicodeToObj \
 	(tclStubsPtr->tcl_AppendUnicodeToObj) /* 384 */
 #define Tcl_RegExpMatchObj \
@@ -3259,12 +3455,14 @@
 	(tclStubsPtr->tcl_IsChannelExisting) /* 418 */
 #define Tcl_UniCharNcasecmp \
 	(tclStubsPtr->tcl_UniCharNcasecmp) /* 419 */
 #define Tcl_UniCharCaseMatch \
 	(tclStubsPtr->tcl_UniCharCaseMatch) /* 420 */
-/* Slot 421 is reserved */
-/* Slot 422 is reserved */
+#define Tcl_FindHashEntry \
+	(tclStubsPtr->tcl_FindHashEntry) /* 421 */
+#define Tcl_CreateHashEntry \
+	(tclStubsPtr->tcl_CreateHashEntry) /* 422 */
 #define Tcl_InitCustomHashTable \
 	(tclStubsPtr->tcl_InitCustomHashTable) /* 423 */
 #define Tcl_InitObjHashTable \
 	(tclStubsPtr->tcl_InitObjHashTable) /* 424 */
 #define Tcl_CommandTraceInfo \
@@ -3285,12 +3483,14 @@
 	(tclStubsPtr->tcl_AttemptSetObjLength) /* 432 */
 #define Tcl_GetChannelThread \
 	(tclStubsPtr->tcl_GetChannelThread) /* 433 */
 #define Tcl_GetUnicodeFromObj \
 	(tclStubsPtr->tcl_GetUnicodeFromObj) /* 434 */
-/* Slot 435 is reserved */
-/* Slot 436 is reserved */
+#define Tcl_GetMathFuncInfo \
+	(tclStubsPtr->tcl_GetMathFuncInfo) /* 435 */
+#define Tcl_ListMathFuncs \
+	(tclStubsPtr->tcl_ListMathFuncs) /* 436 */
 #define Tcl_SubstObj \
 	(tclStubsPtr->tcl_SubstObj) /* 437 */
 #define Tcl_DetachChannel \
 	(tclStubsPtr->tcl_DetachChannel) /* 438 */
 #define Tcl_IsStandardChannel \
@@ -3451,11 +3651,12 @@
 	(tclStubsPtr->tcl_GetCommandFromObj) /* 516 */
 #define Tcl_GetCommandFullName \
 	(tclStubsPtr->tcl_GetCommandFullName) /* 517 */
 #define Tcl_FSEvalFileEx \
 	(tclStubsPtr->tcl_FSEvalFileEx) /* 518 */
-/* Slot 519 is reserved */
+#define Tcl_SetExitProc \
+	(tclStubsPtr->tcl_SetExitProc) /* 519 */
 #define Tcl_LimitAddHandler \
 	(tclStubsPtr->tcl_LimitAddHandler) /* 520 */
 #define Tcl_LimitRemoveHandler \
 	(tclStubsPtr->tcl_LimitRemoveHandler) /* 521 */
 #define Tcl_LimitReady \
@@ -3711,94 +3912,128 @@
 
 /* !END!: Do not edit above this line. */
 
 #if defined(USE_TCL_STUBS)
 #   undef Tcl_CreateInterp
+#   undef Tcl_FindExecutable
+#   undef Tcl_GetStringResult
 #   undef Tcl_Init
+#   undef Tcl_SetPanicProc
+#   undef Tcl_SetExitProc
 #   undef Tcl_ObjSetVar2
+#   undef Tcl_StaticPackage
 #   define Tcl_CreateInterp() (tclStubsPtr->tcl_CreateInterp())
+#   define Tcl_GetStringResult(interp) (tclStubsPtr->tcl_GetStringResult(interp))
 #   define Tcl_Init(interp) (tclStubsPtr->tcl_Init(interp))
 #   define Tcl_ObjSetVar2(interp, part1, part2, newValue, flags) \
 	    (tclStubsPtr->tcl_ObjSetVar2(interp, part1, part2, newValue, flags))
 #endif
 
 #if defined(_WIN32) && defined(UNICODE)
 #   define Tcl_FindExecutable(arg) ((Tcl_FindExecutable)((const char *)(arg)))
 #   define Tcl_MainEx Tcl_MainExW
-    EXTERN TCL_NORETURN void Tcl_MainExW(int argc, wchar_t **argv,
+    EXTERN void Tcl_MainExW(int argc, wchar_t **argv,
 	    Tcl_AppInitProc *appInitProc, Tcl_Interp *interp);
     EXTERN int		TclZipfs_AppHook(int *argc, wchar_t ***argv);
 #endif
 
 #undef TCL_STORAGE_CLASS
 #define TCL_STORAGE_CLASS DLLIMPORT
 
+#undef Tcl_SeekOld
+#undef Tcl_TellOld
+
+#undef Tcl_PkgPresent
 #define Tcl_PkgPresent(interp, name, version, exact) \
 	Tcl_PkgPresentEx(interp, name, version, exact, NULL)
+#undef Tcl_PkgProvide
 #define Tcl_PkgProvide(interp, name, version) \
 	Tcl_PkgProvideEx(interp, name, version, NULL)
+#undef Tcl_PkgRequire
 #define Tcl_PkgRequire(interp, name, version, exact) \
 	Tcl_PkgRequireEx(interp, name, version, exact, NULL)
+#undef Tcl_GetIndexFromObj
 #define Tcl_GetIndexFromObj(interp, objPtr, tablePtr, msg, flags, indexPtr) \
 	Tcl_GetIndexFromObjStruct(interp, objPtr, tablePtr, \
 	sizeof(char *), msg, flags, indexPtr)
+#undef Tcl_NewBooleanObj
 #define Tcl_NewBooleanObj(boolValue) \
 	Tcl_NewWideIntObj((boolValue)!=0)
+#undef Tcl_DbNewBooleanObj
 #define Tcl_DbNewBooleanObj(boolValue, file, line) \
 	Tcl_DbNewWideIntObj((boolValue)!=0, file, line)
+#undef Tcl_SetBooleanObj
 #define Tcl_SetBooleanObj(objPtr, boolValue) \
 	Tcl_SetWideIntObj(objPtr, (boolValue)!=0)
+#undef Tcl_SetVar
 #define Tcl_SetVar(interp, varName, newValue, flags) \
 	Tcl_SetVar2(interp, varName, NULL, newValue, flags)
+#undef Tcl_UnsetVar
 #define Tcl_UnsetVar(interp, varName, flags) \
 	Tcl_UnsetVar2(interp, varName, NULL, flags)
+#undef Tcl_GetVar
 #define Tcl_GetVar(interp, varName, flags) \
 	Tcl_GetVar2(interp, varName, NULL, flags)
+#undef Tcl_TraceVar
 #define Tcl_TraceVar(interp, varName, flags, proc, clientData) \
 	Tcl_TraceVar2(interp, varName, NULL, flags, proc, clientData)
+#undef Tcl_UntraceVar
 #define Tcl_UntraceVar(interp, varName, flags, proc, clientData) \
 	Tcl_UntraceVar2(interp, varName, NULL, flags, proc, clientData)
+#undef Tcl_VarTraceInfo
 #define Tcl_VarTraceInfo(interp, varName, flags, proc, prevClientData) \
 	Tcl_VarTraceInfo2(interp, varName, NULL, flags, proc, prevClientData)
+#undef Tcl_UpVar
 #define Tcl_UpVar(interp, frameName, varName, localName, flags) \
 	Tcl_UpVar2(interp, frameName, varName, NULL, localName, flags)
+#undef Tcl_AddErrorInfo
 #define Tcl_AddErrorInfo(interp, message) \
 	Tcl_AppendObjToErrorInfo(interp, Tcl_NewStringObj(message, -1))
+#undef Tcl_AddObjErrorInfo
 #define Tcl_AddObjErrorInfo(interp, message, length) \
 	Tcl_AppendObjToErrorInfo(interp, Tcl_NewStringObj(message, length))
+#ifdef TCL_NO_DEPRECATED
+#undef Tcl_GetStringResult
+#define Tcl_GetStringResult(interp) Tcl_GetString(Tcl_GetObjResult(interp))
+#undef Tcl_Eval
 #define Tcl_Eval(interp, objPtr) \
 	Tcl_EvalEx(interp, objPtr, -1, 0)
+#undef Tcl_GlobalEval
 #define Tcl_GlobalEval(interp, objPtr) \
 	Tcl_EvalEx(interp, objPtr, -1, TCL_EVAL_GLOBAL)
-#define Tcl_GetStringResult(interp) Tcl_GetString(Tcl_GetObjResult(interp))
+#undef Tcl_SaveResult
 #define Tcl_SaveResult(interp, statePtr) \
 	do { \
-	    *(statePtr) = Tcl_GetObjResult(interp); \
-	    Tcl_IncrRefCount(*(statePtr)); \
+	    (statePtr)->objResultPtr = Tcl_GetObjResult(interp); \
+	    Tcl_IncrRefCount((statePtr)->objResultPtr); \
 	    Tcl_SetObjResult(interp, Tcl_NewObj()); \
 	} while(0)
+#undef Tcl_RestoreResult
 #define Tcl_RestoreResult(interp, statePtr) \
 	do { \
 	    Tcl_ResetResult(interp); \
-   	    Tcl_SetObjResult(interp, *(statePtr)); \
-   	    Tcl_DecrRefCount(*(statePtr)); \
+   	    Tcl_SetObjResult(interp, (statePtr)->objResultPtr); \
+   	    Tcl_DecrRefCount((statePtr)->objResultPtr); \
 	} while(0)
+#undef Tcl_DiscardResult
 #define Tcl_DiscardResult(statePtr) \
-	Tcl_DecrRefCount(*(statePtr))
+	Tcl_DecrRefCount((statePtr)->objResultPtr)
+#undef Tcl_SetResult
 #define Tcl_SetResult(interp, result, freeProc) \
 	do { \
 	    char *__result = result; \
 	    Tcl_FreeProc *__freeProc = freeProc; \
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(__result, -1)); \
 	    if (__result != NULL && __freeProc != NULL && __freeProc != TCL_VOLATILE) { \
 		if (__freeProc == TCL_DYNAMIC) { \
-		    Tcl_Free(__result); \
+		    ckfree(__result); \
 		} else { \
 		    (*__freeProc)(__result); \
 		} \
 	    } \
 	} while(0)
+#endif /* TCL_NO_DEPRECATED */
 
 #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
@@ -3808,10 +4043,14 @@
  * without introducing a binary incompatibility.
  */
 #	undef Tcl_GetLongFromObj
 #	undef Tcl_ExprLong
 #	undef Tcl_ExprLongObj
+#	undef Tcl_UniCharNcmp
+#	undef Tcl_UtfNcmp
+#	undef Tcl_UtfNcasecmp
+#	undef Tcl_UniCharNcasecmp
 #	define Tcl_GetLongFromObj ((int(*)(Tcl_Interp*,Tcl_Obj*,long*))Tcl_GetWideIntFromObj)
 #	define Tcl_ExprLong TclExprLong
 	static inline int TclExprLong(Tcl_Interp *interp, const char *string, long *ptr){
 	    int intValue;
 	    int result = tclStubsPtr->tcl_ExprLong(interp, string, (long *)&intValue);
@@ -3823,81 +4062,45 @@
 	    int intValue;
 	    int result = tclStubsPtr->tcl_ExprLongObj(interp, obj, (long *)&intValue);
 	    if (result == TCL_OK) *ptr = (long)intValue;
 	    return result;
 	}
+#	define Tcl_UniCharNcmp(ucs,uct,n) \
+		((int(*)(const Tcl_UniChar*,const Tcl_UniChar*,unsigned int))tclStubsPtr->tcl_UniCharNcmp)(ucs,uct,(unsigned int)(n))
+#	define Tcl_UtfNcmp(s1,s2,n) \
+		((int(*)(const char*,const char*,unsigned int))tclStubsPtr->tcl_UtfNcmp)(s1,s2,(unsigned int)(n))
+#	define Tcl_UtfNcasecmp(s1,s2,n) \
+		((int(*)(const char*,const char*,unsigned int))tclStubsPtr->tcl_UtfNcasecmp)(s1,s2,(unsigned int)(n))
+#	define Tcl_UniCharNcasecmp(ucs,uct,n) \
+		((int(*)(const Tcl_UniChar*,const Tcl_UniChar*,unsigned int))tclStubsPtr->tcl_UniCharNcasecmp)(ucs,uct,(unsigned int)(n))
 #   endif
 #endif
 
-#ifdef TCL_MEM_DEBUG
-#   undef Tcl_Alloc
-#   define Tcl_Alloc(x) \
-    (Tcl_DbCkalloc((x), __FILE__, __LINE__))
-#   undef Tcl_Free
-#   define Tcl_Free(x) \
-    Tcl_DbCkfree((x), __FILE__, __LINE__)
-#   undef Tcl_Realloc
-#   define Tcl_Realloc(x,y) \
-    (Tcl_DbCkrealloc((x), (y), __FILE__, __LINE__))
-#   undef Tcl_AttemptAlloc
-#   define Tcl_AttemptAlloc(x) \
-    (Tcl_AttemptDbCkalloc((x), __FILE__, __LINE__))
-#   undef Tcl_AttemptRealloc
-#   define Tcl_AttemptRealloc(x,y) \
-    (Tcl_AttemptDbCkrealloc((x), (y), __FILE__, __LINE__))
-#endif /* !TCL_MEM_DEBUG */
-
+#undef Tcl_NewLongObj
 #define Tcl_NewLongObj(value) Tcl_NewWideIntObj((long)(value))
+#undef Tcl_NewIntObj
 #define Tcl_NewIntObj(value) Tcl_NewWideIntObj((int)(value))
+#undef Tcl_DbNewLongObj
 #define Tcl_DbNewLongObj(value, file, line) Tcl_DbNewWideIntObj((long)(value), file, line)
+#undef Tcl_SetIntObj
 #define Tcl_SetIntObj(objPtr, value)	Tcl_SetWideIntObj((objPtr), (int)(value))
+#undef Tcl_SetLongObj
 #define Tcl_SetLongObj(objPtr, value)	Tcl_SetWideIntObj((objPtr), (long)(value))
+#undef Tcl_GetUnicode
 #define Tcl_GetUnicode(objPtr)	Tcl_GetUnicodeFromObj((objPtr), NULL)
+#undef Tcl_BackgroundError
 #define Tcl_BackgroundError(interp)	Tcl_BackgroundException((interp), TCL_ERROR)
+#undef Tcl_StringMatch
 #define Tcl_StringMatch(str, pattern) Tcl_StringCaseMatch((str), (pattern), 0)
 
 /*
  * Deprecated Tcl procedures:
  */
 
+#undef Tcl_EvalObj
 #define Tcl_EvalObj(interp, objPtr) \
     Tcl_EvalObjEx(interp, objPtr, 0)
+#undef Tcl_GlobalEvalObj
 #define Tcl_GlobalEvalObj(interp, objPtr) \
     Tcl_EvalObjEx(interp, objPtr, TCL_EVAL_GLOBAL)
 
-#if defined(TCL_8_COMPAT) && !defined(BUILD_tcl)
-#   ifdef USE_TCL_STUBS
-#	undef Tcl_Gets
-#	undef Tcl_GetsObj
-#	undef Tcl_Read
-#	undef Tcl_Ungets
-#	undef Tcl_Write
-#	undef Tcl_ReadChars
-#	undef Tcl_WriteChars
-#	undef Tcl_WriteObj
-#	undef Tcl_ReadRaw
-#	undef Tcl_WriteRaw
-#	define Tcl_Gets(chan, dsPtr) (((Tcl_WideInt)((tclStubsPtr->tcl_Gets)(chan, dsPtr)+1))-1)
-#	define Tcl_GetsObj(chan, objPtr) (((Tcl_WideInt)((tclStubsPtr->tcl_GetsObj)(chan, objPtr)+1))-1)
-#	define Tcl_Read(chan, bufPtr, toRead) (((Tcl_WideInt)((tclStubsPtr->tcl_Read)(chan, bufPtr, toRead)+1))-1)
-#	define Tcl_Ungets(chan, str, len, atHead) (((Tcl_WideInt)((tclStubsPtr->tcl_Ungets)(chan, str, len, atHead)+1))-1)
-#	define Tcl_Write(chan, s, slen) (((Tcl_WideInt)((tclStubsPtr->tcl_Write)(chan, s, slen)+1))-1)
-#	define Tcl_ReadChars(channel, objPtr, charsToRead, appendFlag) (((Tcl_WideInt)((tclStubsPtr->tcl_ReadChars)(channel, objPtr, charsToRead, appendFlag)+1))-1)
-#	define Tcl_WriteChars(chan, src, srcLen) (((Tcl_WideInt)((tclStubsPtr->tcl_WriteChars)(chan, src, srcLen)+1))-1)
-#	define Tcl_WriteObj(chan, objPtr) (((Tcl_WideInt)((tclStubsPtr->tcl_WriteObj)(chan, objPtr)+1))-1)
-#	define Tcl_ReadRaw(chan, dst, bytesToRead) (((Tcl_WideInt)((tclStubsPtr->tcl_ReadRaw)(chan, dst, bytesToRead)+1))-1)
-#	define Tcl_WriteRaw(chan, src, srcLen) (((Tcl_WideInt)((tclStubsPtr->tcl_WriteRaw()(chan, src, srcLen)+1))-1)
-#   else
-#	define Tcl_Gets(chan, dsPtr) (((Tcl_WideInt)((Tcl_Gets)(chan, dsPtr)+1))-1)
-#	define Tcl_GetsObj(chan, objPtr) (((Tcl_WideInt)((Tcl_GetsObj)(chan, objPtr)+1))-1)
-#	define Tcl_Read(chan, bufPtr, toRead) (((Tcl_WideInt)((Tcl_Read)(chan, bufPtr, toRead)+1))-1)
-#	define Tcl_Ungets(chan, str, len, atHead) (((Tcl_WideInt)((Tcl_Ungets)(chan, str, len, atHead)+1))-1)
-#	define Tcl_Write(chan, s, slen) (((Tcl_WideInt)((Tcl_Write)(chan, s, slen)+1))-1)
-#	define Tcl_ReadChars(channel, objPtr, charsToRead, appendFlag) (((Tcl_WideInt)((Tcl_ReadChars)(channel, objPtr, charsToRead, appendFlag)+1))-1)
-#	define Tcl_WriteChars(chan, src, srcLen) (((Tcl_WideInt)((Tcl_WriteChars)(chan, src, srcLen)+1))-1)
-#	define Tcl_WriteObj(chan, objPtr) (((Tcl_WideInt)((Tcl_WriteObj)(chan, objPtr)+1))-1)
-#	define Tcl_ReadRaw(chan, dst, bytesToRead) (((Tcl_WideInt)((Tcl_ReadRaw)(chan, dst, bytesToRead)+1))-1)
-#	define Tcl_WriteRaw(chan, src, srcLen) (((Tcl_WideInt)((Tcl_WriteRaw()(chan, src, srcLen)+1))-1)
-#   endif
-#endif
-
 #endif /* _TCLDECLS */

Index: generic/tclDictObj.c
==================================================================
--- generic/tclDictObj.c
+++ generic/tclDictObj.c
@@ -65,11 +65,11 @@
 static void		DupDictInternalRep(Tcl_Obj *srcPtr, Tcl_Obj *copyPtr);
 static void		FreeDictInternalRep(Tcl_Obj *dictPtr);
 static void		InvalidateDictChain(Tcl_Obj *dictObj);
 static int		SetDictFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr);
 static void		UpdateStringOfDict(Tcl_Obj *dictPtr);
-static Tcl_HashEntry *	AllocChainEntry(Tcl_HashTable *tablePtr, void *keyPtr);
+static Tcl_HashEntry *	AllocChainEntry(Tcl_HashTable *tablePtr,void *keyPtr);
 static inline void	InitChainTable(struct Dict *dict);
 static inline void	DeleteChainTable(struct Dict *dict);
 static inline Tcl_HashEntry *CreateChainEntry(struct Dict *dict,
 			    Tcl_Obj *keyPtr, int *newPtr);
 static inline int	DeleteChainEntry(struct Dict *dict, Tcl_Obj *keyPtr);
@@ -145,11 +145,11 @@
 				 * created. */
     ChainEntry *entryChainTail;	/* Other end of linked list of all entries in
 				 * the dictionary. Used for doing traversal of
 				 * the entries in the order that they are
 				 * created. */
-    size_t epoch;		/* Epoch counter */
+    unsigned int epoch; 	/* Epoch counter */
     size_t refCount;		/* Reference counter (see above) */
     Tcl_Obj *chain;		/* Linked list used for invalidating the
 				 * string representations of updated nested
 				 * dictionaries. */
 } Dict;
@@ -241,17 +241,17 @@
 static Tcl_HashEntry *
 AllocChainEntry(
     Tcl_HashTable *tablePtr,
     void *keyPtr)
 {
-    Tcl_Obj *objPtr = (Tcl_Obj *)keyPtr;
+    Tcl_Obj *objPtr = keyPtr;
     ChainEntry *cPtr;
 
-    cPtr = Tcl_Alloc(sizeof(ChainEntry));
+    cPtr = ckalloc(sizeof(ChainEntry));
     cPtr->entry.key.objPtr = objPtr;
     Tcl_IncrRefCount(objPtr);
-    Tcl_SetHashValue(&cPtr->entry, NULL);
+    cPtr->entry.clientData = NULL;
     cPtr->prevPtr = cPtr->nextPtr = NULL;
 
     return &cPtr->entry;
 }
 
@@ -375,11 +375,11 @@
 static void
 DupDictInternalRep(
     Tcl_Obj *srcPtr,
     Tcl_Obj *copyPtr)
 {
-    Dict *oldDict, *newDict = Tcl_Alloc(sizeof(Dict));
+    Dict *oldDict, *newDict = ckalloc(sizeof(Dict));
     ChainEntry *cPtr;
 
     DictGetIntRep(srcPtr, oldDict);
 
     /*
@@ -470,11 +470,11 @@
 static void
 DeleteDict(
     Dict *dict)
 {
     DeleteChainTable(dict);
-    Tcl_Free(dict);
+    ckfree(dict);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -504,20 +504,20 @@
 #define LOCAL_SIZE 64
     char localFlags[LOCAL_SIZE], *flagPtr = NULL;
     Dict *dict;
     ChainEntry *cPtr;
     Tcl_Obj *keyPtr, *valuePtr;
-    size_t i, length, bytesNeeded = 0;
+    int i, length, bytesNeeded = 0;
     const char *elem;
     char *dst;
 
     /*
      * This field is the most useful one in the whole hash structure, and it
      * is not exposed by any API function...
      */
 
-    size_t numElems;
+    int numElems;
 
     DictGetIntRep(dictPtr, dict);
 
     assert (dict != NULL);
 
@@ -534,11 +534,11 @@
      */
 
     if (numElems <= LOCAL_SIZE) {
 	flagPtr = localFlags;
     } else {
-	flagPtr = Tcl_Alloc(numElems);
+	flagPtr = ckalloc(numElems);
     }
     for (i=0,cPtr=dict->entryChainHead; i<numElems; i+=2,cPtr=cPtr->nextPtr) {
 	/*
 	 * Assume that cPtr is never NULL since we know the number of array
 	 * elements already.
@@ -546,14 +546,24 @@
 
 	flagPtr[i] = ( i ? TCL_DONT_QUOTE_HASH : 0 );
 	keyPtr = Tcl_GetHashKey(&dict->table, &cPtr->entry);
 	elem = TclGetStringFromObj(keyPtr, &length);
 	bytesNeeded += TclScanElement(elem, length, flagPtr+i);
+	if (bytesNeeded < 0) {
+	    Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
+	}
+
 	flagPtr[i+1] = TCL_DONT_QUOTE_HASH;
 	valuePtr = Tcl_GetHashValue(&cPtr->entry);
 	elem = TclGetStringFromObj(valuePtr, &length);
 	bytesNeeded += TclScanElement(elem, length, flagPtr+i+1);
+	if (bytesNeeded < 0) {
+	    Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
+	}
+    }
+    if (bytesNeeded > INT_MAX - numElems + 1) {
+	Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
     }
     bytesNeeded += numElems;
 
     /*
      * Pass 2: copy into string rep buffer.
@@ -575,11 +585,11 @@
 	*dst++ = ' ';
     }
     (void)Tcl_InitStringRep(dictPtr, NULL, bytesNeeded - 1);
 
     if (flagPtr != localFlags) {
-	Tcl_Free(flagPtr);
+	ckfree(flagPtr);
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -606,11 +616,11 @@
     Tcl_Interp *interp,
     Tcl_Obj *objPtr)
 {
     Tcl_HashEntry *hPtr;
     int isNew;
-    Dict *dict = Tcl_Alloc(sizeof(Dict));
+    Dict *dict = ckalloc(sizeof(Dict));
 
     InitChainTable(dict);
 
     /*
      * Since lists and dictionaries have very closely-related string
@@ -639,27 +649,26 @@
 		 * Not really a well-formed dictionary as there are duplicate
 		 * keys, so better get the string rep here so that we can
 		 * convert back.
 		 */
 
-		(void) TclGetString(objPtr);
+		(void) Tcl_GetString(objPtr);
 
 		TclDecrRefCount(discardedValue);
 	    }
 	    Tcl_SetHashValue(hPtr, objv[i+1]);
 	    Tcl_IncrRefCount(objv[i+1]); /* Since hash now holds ref to it */
 	}
     } else {
-	size_t length;
+	int length;
 	const char *nextElem = TclGetStringFromObj(objPtr, &length);
 	const char *limit = (nextElem + length);
 
 	while (nextElem < limit) {
 	    Tcl_Obj *keyPtr, *valuePtr;
 	    const char *elemStart;
-	    size_t elemSize;
-	    int literal;
+	    int elemSize, literal;
 
 	    if (TclFindDictElement(interp, nextElem, (limit - nextElem),
 		    &elemStart, &nextElem, &elemSize, &literal) != TCL_OK) {
 		goto errorInFindDictElement;
 	    }
@@ -735,11 +744,11 @@
 		"missing value to go with key", -1));
 	Tcl_SetErrorCode(interp, "TCL", "VALUE", "DICTIONARY", NULL);
     }
   errorInFindDictElement:
     DeleteChainTable(dict);
-    Tcl_Free(dict);
+    ckfree(dict);
     return TCL_ERROR;
 }
 
 static Dict *
 GetDictFromObj(
@@ -1413,11 +1422,11 @@
     Tcl_Obj *dictPtr;
     Dict *dict;
 
     TclNewObj(dictPtr);
     TclInvalidateStringRep(dictPtr);
-    dict = Tcl_Alloc(sizeof(Dict));
+    dict = ckalloc(sizeof(Dict));
     InitChainTable(dict);
     dict->epoch = 1;
     dict->chain = NULL;
     dict->refCount = 1;
     DictSetIntRep(dictPtr, dict);
@@ -1461,11 +1470,11 @@
     Tcl_Obj *dictPtr;
     Dict *dict;
 
     TclDbNewObj(dictPtr, file, line);
     TclInvalidateStringRep(dictPtr);
-    dict = Tcl_Alloc(sizeof(Dict));
+    dict = ckalloc(sizeof(Dict));
     InitChainTable(dict);
     dict->epoch = 1;
     dict->chain = NULL;
     dict->refCount = 1;
     DictSetIntRep(dictPtr, dict);
@@ -2125,11 +2134,11 @@
 	return TCL_ERROR;
     }
 
     statsStr = Tcl_HashStats(&dict->table);
     Tcl_SetObjResult(interp, Tcl_NewStringObj(statsStr, -1));
-    Tcl_Free(statsStr);
+    ckfree(statsStr);
     return TCL_OK;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -3200,10 +3209,11 @@
 		 * do.
 		 */
 
 		Tcl_ResetResult(interp);
 		Tcl_DictObjDone(&search);
+	    /* FALLTHRU */
 	    case TCL_CONTINUE:
 		result = TCL_OK;
 		break;
 	    case TCL_ERROR:
 		Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
@@ -3298,11 +3308,11 @@
 	    TclDecrRefCount(dictPtr);
 	    return TCL_ERROR;
 	}
 	if (objPtr == NULL) {
 	    /* ??? */
-	    Tcl_UnsetVar(interp, TclGetString(objv[i+1]), 0);
+	    Tcl_UnsetVar2(interp, Tcl_GetString(objv[i+1]), NULL, 0);
 	} else if (Tcl_ObjSetVar2(interp, objv[i+1], NULL, objPtr,
 		TCL_LEAVE_ERR_MSG) == NULL) {
 	    TclDecrRefCount(dictPtr);
 	    return TCL_ERROR;
 	}

Index: generic/tclDisassemble.c
==================================================================
--- generic/tclDisassemble.c
+++ generic/tclDisassemble.c
@@ -193,14 +193,14 @@
 void
 TclPrintObject(
     FILE *outFile,		/* The file to print the source to. */
     Tcl_Obj *objPtr,		/* Points to the Tcl object whose string
 				 * representation should be printed. */
-    size_t maxChars)		/* Maximum number of chars to print. */
+    int maxChars)		/* Maximum number of chars to print. */
 {
     char *bytes;
-    size_t length;
+    int length;
 
     bytes = TclGetStringFromObj(objPtr, &length);
     TclPrintSource(outFile, bytes, TclMin(length, maxChars));
 }
 
@@ -224,11 +224,11 @@
 
 void
 TclPrintSource(
     FILE *outFile,		/* The file to print the source to. */
     const char *stringPtr,	/* The string to print. */
-    size_t maxChars)		/* Maximum number of chars to print. */
+    int maxChars)		/* Maximum number of chars to print. */
 {
     Tcl_Obj *bufferObj;
 
     TclNewObj(bufferObj);
     PrintSourceToObj(bufferObj, stringPtr, maxChars);
@@ -278,19 +278,20 @@
     /*
      * Print header lines describing the ByteCode.
      */
 
     Tcl_AppendPrintfToObj(bufferObj,
-	    "ByteCode %p, refCt %" TCL_Z_MODIFIER "u, epoch %" TCL_Z_MODIFIER "u, interp %p (epoch %" TCL_Z_MODIFIER "u)\n",
-	    codePtr, codePtr->refCount, codePtr->compileEpoch, iPtr, iPtr->compileEpoch);
+	    "ByteCode %p, refCt %u, epoch %u, interp %p (epoch %u)\n",
+	    codePtr, codePtr->refCount, codePtr->compileEpoch, iPtr,
+	    iPtr->compileEpoch);
     Tcl_AppendToObj(bufferObj, "  Source ", -1);
     PrintSourceToObj(bufferObj, codePtr->source,
 	    TclMin(codePtr->numSrcBytes, 55));
     GetLocationInformation(codePtr->procPtr, &fileObj, &line);
     if (line > -1 && fileObj != NULL) {
 	Tcl_AppendPrintfToObj(bufferObj, "\n  File \"%s\" Line %d",
-		TclGetString(fileObj), line);
+		Tcl_GetString(fileObj), line);
     }
     Tcl_AppendPrintfToObj(bufferObj,
 	    "\n  Cmds %d, src %d, inst %d, litObjs %u, aux %d, stkDepth %u, code/src %.2f\n",
 	    numCmds, codePtr->numSrcBytes, codePtr->numCodeBytes,
 	    codePtr->numLitObjects, codePtr->numAuxDataItems,
@@ -322,11 +323,11 @@
     if (codePtr->procPtr != NULL) {
 	Proc *procPtr = codePtr->procPtr;
 	int numCompiledLocals = procPtr->numCompiledLocals;
 
 	Tcl_AppendPrintfToObj(bufferObj,
-		"  Proc %p, refCt %" TCL_Z_MODIFIER "u, args %d, compiled locals %d\n",
+		"  Proc %p, refCt %u, args %d, compiled locals %d\n",
 		procPtr, procPtr->refCount, procPtr->numArgs,
 		numCompiledLocals);
 	if (numCompiledLocals > 0) {
 	    CompiledLocal *localPtr = procPtr->firstLocalPtr;
 
@@ -406,40 +407,40 @@
     codeLengthNext = codePtr->codeLengthStart;
     srcDeltaNext = codePtr->srcDeltaStart;
     srcLengthNext = codePtr->srcLengthStart;
     codeOffset = srcOffset = 0;
     for (i = 0;  i < numCmds;  i++) {
-	if (*codeDeltaNext == 0xFF) {
+	if ((unsigned) *codeDeltaNext == (unsigned) 0xFF) {
 	    codeDeltaNext++;
 	    delta = TclGetInt4AtPtr(codeDeltaNext);
 	    codeDeltaNext += 4;
 	} else {
 	    delta = TclGetInt1AtPtr(codeDeltaNext);
 	    codeDeltaNext++;
 	}
 	codeOffset += delta;
 
-	if (*codeLengthNext == 0xFF) {
+	if ((unsigned) *codeLengthNext == (unsigned) 0xFF) {
 	    codeLengthNext++;
 	    codeLen = TclGetInt4AtPtr(codeLengthNext);
 	    codeLengthNext += 4;
 	} else {
 	    codeLen = TclGetInt1AtPtr(codeLengthNext);
 	    codeLengthNext++;
 	}
 
-	if (*srcDeltaNext == 0xFF) {
+	if ((unsigned) *srcDeltaNext == (unsigned) 0xFF) {
 	    srcDeltaNext++;
 	    delta = TclGetInt4AtPtr(srcDeltaNext);
 	    srcDeltaNext += 4;
 	} else {
 	    delta = TclGetInt1AtPtr(srcDeltaNext);
 	    srcDeltaNext++;
 	}
 	srcOffset += delta;
 
-	if (*srcLengthNext == 0xFF) {
+	if ((unsigned) *srcLengthNext == (unsigned) 0xFF) {
 	    srcLengthNext++;
 	    srcLen = TclGetInt4AtPtr(srcLengthNext);
 	    srcLengthNext += 4;
 	} else {
 	    srcLen = TclGetInt1AtPtr(srcLengthNext);
@@ -465,31 +466,31 @@
     srcDeltaNext = codePtr->srcDeltaStart;
     srcLengthNext = codePtr->srcLengthStart;
     codeOffset = srcOffset = 0;
     pc = codeStart;
     for (i = 0;  i < numCmds;  i++) {
-	if (*codeDeltaNext == 0xFF) {
+	if ((unsigned) *codeDeltaNext == (unsigned) 0xFF) {
 	    codeDeltaNext++;
 	    delta = TclGetInt4AtPtr(codeDeltaNext);
 	    codeDeltaNext += 4;
 	} else {
 	    delta = TclGetInt1AtPtr(codeDeltaNext);
 	    codeDeltaNext++;
 	}
 	codeOffset += delta;
 
-	if (*srcDeltaNext == 0xFF) {
+	if ((unsigned) *srcDeltaNext == (unsigned) 0xFF) {
 	    srcDeltaNext++;
 	    delta = TclGetInt4AtPtr(srcDeltaNext);
 	    srcDeltaNext += 4;
 	} else {
 	    delta = TclGetInt1AtPtr(srcDeltaNext);
 	    srcDeltaNext++;
 	}
 	srcOffset += delta;
 
-	if (*srcLengthNext == 0xFF) {
+	if ((unsigned) *srcLengthNext == (unsigned) 0xFF) {
 	    srcLengthNext++;
 	    srcLen = TclGetInt4AtPtr(srcLengthNext);
 	    srcLengthNext += 4;
 	} else {
 	    srcLen = TclGetInt1AtPtr(srcLengthNext);
@@ -539,11 +540,11 @@
     const unsigned char *pc,	/* Points to first byte of instruction. */
     Tcl_Obj *bufferObj)		/* Object to append instruction info to. */
 {
     Proc *procPtr = codePtr->procPtr;
     unsigned char opCode = *pc;
-    register const InstructionDesc *instDesc = &tclInstructionTable[opCode];
+    const InstructionDesc *instDesc = &tclInstructionTable[opCode];
     unsigned char *codeStart = codePtr->codeStart;
     unsigned pcOffset = pc - codeStart;
     int opnd = 0, i, j, numBytes = 1;
     int localCt = procPtr ? procPtr->numCompiledLocals : 0;
     CompiledLocal *localPtr = procPtr ? procPtr->firstLocalPtr : NULL;
@@ -565,19 +566,19 @@
 	    opnd = TclGetInt4AtPtr(pc+numBytes); numBytes += 4;
 	    Tcl_AppendPrintfToObj(bufferObj, "%+d ", opnd);
 	    break;
 	case OPERAND_UINT1:
 	    opnd = TclGetUInt1AtPtr(pc+numBytes); numBytes++;
-	    Tcl_AppendPrintfToObj(bufferObj, "%u ", opnd);
+	    Tcl_AppendPrintfToObj(bufferObj, "%u ", (unsigned) opnd);
 	    break;
 	case OPERAND_UINT4:
 	    opnd = TclGetUInt4AtPtr(pc+numBytes); numBytes += 4;
 	    if (opCode == INST_START_CMD) {
 		sprintf(suffixBuffer+strlen(suffixBuffer),
 			", %u cmds start here", opnd);
 	    }
-	    Tcl_AppendPrintfToObj(bufferObj, "%u ", opnd);
+	    Tcl_AppendPrintfToObj(bufferObj, "%u ", (unsigned) opnd);
 	    break;
 	case OPERAND_OFFSET1:
 	    opnd = TclGetInt1AtPtr(pc+numBytes); numBytes++;
 	    sprintf(suffixBuffer, "pc %u", pcOffset+opnd);
 	    Tcl_AppendPrintfToObj(bufferObj, "%+d ", opnd);
@@ -592,20 +593,20 @@
 	    Tcl_AppendPrintfToObj(bufferObj, "%+d ", opnd);
 	    break;
 	case OPERAND_LIT1:
 	    opnd = TclGetUInt1AtPtr(pc+numBytes); numBytes++;
 	    suffixObj = codePtr->objArrayPtr[opnd];
-	    Tcl_AppendPrintfToObj(bufferObj, "%u ", opnd);
+	    Tcl_AppendPrintfToObj(bufferObj, "%u ", (unsigned) opnd);
 	    break;
 	case OPERAND_LIT4:
 	    opnd = TclGetUInt4AtPtr(pc+numBytes); numBytes += 4;
 	    suffixObj = codePtr->objArrayPtr[opnd];
-	    Tcl_AppendPrintfToObj(bufferObj, "%u ", opnd);
+	    Tcl_AppendPrintfToObj(bufferObj, "%u ", (unsigned) opnd);
 	    break;
 	case OPERAND_AUX4:
 	    opnd = TclGetUInt4AtPtr(pc+numBytes); numBytes += 4;
-	    Tcl_AppendPrintfToObj(bufferObj, "%u ", opnd);
+	    Tcl_AppendPrintfToObj(bufferObj, "%u ", (unsigned) opnd);
 	    auxPtr = &codePtr->auxDataArrayPtr[opnd];
 	    break;
 	case OPERAND_IDX4:
 	    opnd = TclGetInt4AtPtr(pc+numBytes); numBytes += 4;
 	    if (opnd >= -1) {
@@ -625,23 +626,23 @@
 	    numBytes += 4;
 	printLVTindex:
 	    if (localPtr != NULL) {
 		if (opnd >= localCt) {
 		    Tcl_Panic("FormatInstruction: bad local var index %u (%u locals)",
-			    opnd, localCt);
+			    (unsigned) opnd, localCt);
 		}
 		for (j = 0;  j < opnd;  j++) {
 		    localPtr = localPtr->nextPtr;
 		}
 		if (TclIsVarTemporary(localPtr)) {
-		    sprintf(suffixBuffer, "temp var %u", opnd);
+		    sprintf(suffixBuffer, "temp var %u", (unsigned) opnd);
 		} else {
 		    sprintf(suffixBuffer, "var ");
 		    suffixSrc = localPtr->name;
 		}
 	    }
-	    Tcl_AppendPrintfToObj(bufferObj, "%%v%u ", opnd);
+	    Tcl_AppendPrintfToObj(bufferObj, "%%v%u ", (unsigned) opnd);
 	    break;
 	case OPERAND_SCLS1:
 	    opnd = TclGetUInt1AtPtr(pc+numBytes); numBytes++;
 	    Tcl_AppendPrintfToObj(bufferObj, "%s ",
 		    tclStringClassTable[opnd].name);
@@ -651,11 +652,11 @@
 	    break;
 	}
     }
     if (suffixObj) {
 	const char *bytes;
-	size_t length;
+	int length;
 
 	Tcl_AppendToObj(bufferObj, "\t# ", -1);
 	bytes = TclGetStringFromObj(codePtr->objArrayPtr[opnd], &length);
 	PrintSourceToObj(bufferObj, bytes, TclMin(length, 40));
     } else if (suffixBuffer[0]) {
@@ -838,11 +839,11 @@
 	TclOOM(dst, TCL_INTEGER_SPACE + 5);
         sprintf(dst, "inst_%" TCL_Z_MODIFIER "u", inst);
 	(void) Tcl_InitStringRep(objPtr, NULL, strlen(dst));
     } else {
 	const char *s = tclInstructionTable[inst].name;
-	size_t len = strlen(s);
+	unsigned int len = strlen(s);
 	dst = Tcl_InitStringRep(objPtr, s, len);
 	TclOOM(dst, len);
     }
 }
 
@@ -860,12 +861,12 @@
 PrintSourceToObj(
     Tcl_Obj *appendObj,		/* The object to print the source to. */
     const char *stringPtr,	/* The string to print. */
     int maxChars)		/* Maximum number of chars to print. */
 {
-    register const char *p;
-    register int i = 0, len;
+    const char *p;
+    int i = 0, len;
     Tcl_UniChar ch = 0;
 
     if (stringPtr == NULL) {
 	Tcl_AppendToObj(appendObj, "\"\"", -1);
 	return;

Index: generic/tclEncoding.c
==================================================================
--- generic/tclEncoding.c
+++ generic/tclEncoding.c
@@ -232,16 +232,21 @@
 static int		TableToUtfProc(ClientData clientData, const char *src,
 			    int srcLen, int flags, Tcl_EncodingState *statePtr,
 			    char *dst, int dstLen, int *srcReadPtr,
 			    int *dstWrotePtr, int *dstCharsPtr);
 static size_t		unilen(const char *src);
-static int		UniCharToUtfProc(ClientData clientData,
+static int		Utf16ToUtfProc(ClientData clientData,
+			    const char *src, int srcLen, int flags,
+			    Tcl_EncodingState *statePtr, char *dst, int dstLen,
+			    int *srcReadPtr, int *dstWrotePtr,
+			    int *dstCharsPtr);
+static int		UtfToUtf16Proc(ClientData clientData,
 			    const char *src, int srcLen, int flags,
 			    Tcl_EncodingState *statePtr, char *dst, int dstLen,
 			    int *srcReadPtr, int *dstWrotePtr,
 			    int *dstCharsPtr);
-static int		UtfToUniCharProc(ClientData clientData,
+static int		UtfToUcs2Proc(ClientData clientData,
 			    const char *src, int srcLen, int flags,
 			    Tcl_EncodingState *statePtr, char *dst, int dstLen,
 			    int *srcReadPtr, int *dstWrotePtr,
 			    int *dstCharsPtr);
 static int		UtfToUtfProc(ClientData clientData,
@@ -562,15 +567,20 @@
 {
     Tcl_EncodingType type;
     TableEncodingData *dataPtr;
     unsigned size;
     unsigned short i;
+    union {
+        char c;
+        short s;
+    } isLe;
 
     if (encodingsInitialized) {
 	return;
     }
 
+    isLe.s = 1;
     Tcl_MutexLock(&encodingMutex);
     Tcl_InitHashTable(&encodingTable, TCL_STRING_KEYS);
     Tcl_MutexUnlock(&encodingMutex);
 
     /*
@@ -593,33 +603,58 @@
     type.freeProc	= NULL;
     type.nullSize	= 1;
     type.clientData	= NULL;
     Tcl_CreateEncoding(&type);
 
-    type.encodingName   = "unicode";
-    type.toUtfProc	= UniCharToUtfProc;
-    type.fromUtfProc    = UtfToUniCharProc;
+    type.toUtfProc	= Utf16ToUtfProc;
+    type.fromUtfProc    = UtfToUcs2Proc;
+    type.freeProc	= NULL;
+    type.nullSize	= 2;
+    type.encodingName   = "ucs-2le";
+    type.clientData	= INT2PTR(1);
+    Tcl_CreateEncoding(&type);
+    type.encodingName   = "ucs-2be";
+    type.clientData	= INT2PTR(0);
+    Tcl_CreateEncoding(&type);
+    type.encodingName   = "ucs-2";
+    type.clientData	= INT2PTR(isLe.c);
+    Tcl_CreateEncoding(&type);
+
+    type.toUtfProc	= Utf16ToUtfProc;
+    type.fromUtfProc    = UtfToUtf16Proc;
     type.freeProc	= NULL;
     type.nullSize	= 2;
-    type.clientData	= NULL;
+    type.encodingName   = "utf-16le";
+    type.clientData	= INT2PTR(1);;
+    Tcl_CreateEncoding(&type);
+    type.encodingName   = "utf-16be";
+    type.clientData	= INT2PTR(0);
+    Tcl_CreateEncoding(&type);
+    type.encodingName   = "utf-16";
+    type.clientData	= INT2PTR(isLe.c);;
+    Tcl_CreateEncoding(&type);
+
+#ifndef TCL_NO_DEPRECATED
+    type.encodingName   = "unicode";
     Tcl_CreateEncoding(&type);
+#endif
 
     /*
      * Need the iso8859-1 encoding in order to process binary data, so force
      * it to always be embedded. Note that this encoding *must* be a proper
      * table encoding or some of the escape encodings crash! Hence the ugly
      * code to duplicate the structure of a table encoding here.
      */
 
-    dataPtr = Tcl_Alloc(sizeof(TableEncodingData));
+    dataPtr = ckalloc(sizeof(TableEncodingData));
     memset(dataPtr, 0, sizeof(TableEncodingData));
     dataPtr->fallback = '?';
 
     size = 256*(sizeof(unsigned short *) + sizeof(unsigned short));
-    dataPtr->toUnicode = Tcl_Alloc(size);
+    dataPtr->toUnicode = ckalloc(size);
     memset(dataPtr->toUnicode, 0, size);
-    dataPtr->fromUnicode = Tcl_Alloc(size);
+    dataPtr->fromUnicode = ckalloc(size);
     memset(dataPtr->fromUnicode, 0, size);
 
     dataPtr->toUnicode[0] = (unsigned short *) (dataPtr->toUnicode + 256);
     dataPtr->fromUnicode[0] = (unsigned short *) (dataPtr->fromUnicode + 256);
     for (i=1 ; i<256 ; i++) {
@@ -689,10 +724,74 @@
 
     Tcl_DeleteHashTable(&encodingTable);
     Tcl_MutexUnlock(&encodingMutex);
 }
 
+/*
+ *-------------------------------------------------------------------------
+ *
+ * Tcl_GetDefaultEncodingDir --
+ *
+ *	Legacy public interface to retrieve first directory in the encoding
+ *	searchPath.
+ *
+ * Results:
+ *	The directory pathname, as a string, or NULL for an empty encoding
+ *	search path.
+ *
+ * Side effects:
+ *	None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+const char *
+Tcl_GetDefaultEncodingDir(void)
+{
+    int numDirs;
+    Tcl_Obj *first, *searchPath = Tcl_GetEncodingSearchPath();
+
+    Tcl_ListObjLength(NULL, searchPath, &numDirs);
+    if (numDirs == 0) {
+	return NULL;
+    }
+    Tcl_ListObjIndex(NULL, searchPath, 0, &first);
+
+    return TclGetString(first);
+}
+
+/*
+ *-------------------------------------------------------------------------
+ *
+ * Tcl_SetDefaultEncodingDir --
+ *
+ *	Legacy public interface to set the first directory in the encoding
+ *	search path.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Modifies the encoding search path.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+void
+Tcl_SetDefaultEncodingDir(
+    const char *path)
+{
+    Tcl_Obj *searchPath = Tcl_GetEncodingSearchPath();
+    Tcl_Obj *directory = Tcl_NewStringObj(path, -1);
+
+    searchPath = Tcl_DuplicateObj(searchPath);
+    Tcl_ListObjReplace(NULL, searchPath, 0, 0, 1, &directory);
+    Tcl_SetEncodingSearchPath(searchPath);
+}
+#endif
+
 /*
  *-------------------------------------------------------------------------
  *
  * Tcl_GetEncoding --
  *
@@ -804,13 +903,13 @@
 	}
 	if (encodingPtr->hPtr != NULL) {
 	    Tcl_DeleteHashEntry(encodingPtr->hPtr);
 	}
 	if (encodingPtr->name) {
-	    Tcl_Free(encodingPtr->name);
+	    ckfree(encodingPtr->name);
 	}
-	Tcl_Free(encodingPtr);
+	ckfree(encodingPtr);
     }
 }
 
 /*
  *-------------------------------------------------------------------------
@@ -994,11 +1093,11 @@
 Tcl_Encoding
 Tcl_CreateEncoding(
     const Tcl_EncodingType *typePtr)
 				/* The encoding type. */
 {
-    Encoding *encodingPtr = Tcl_Alloc(sizeof(Encoding));
+    Encoding *encodingPtr = ckalloc(sizeof(Encoding));
     encodingPtr->name		= NULL;
     encodingPtr->toUtfProc	= typePtr->toUtfProc;
     encodingPtr->fromUtfProc	= typePtr->fromUtfProc;
     encodingPtr->freeProc	= typePtr->freeProc;
     encodingPtr->nullSize	= typePtr->nullSize;
@@ -1026,11 +1125,11 @@
 
 	Encoding *replaceMe = Tcl_GetHashValue(hPtr);
 	replaceMe->hPtr = NULL;
     }
 
-    name = Tcl_Alloc(strlen(typePtr->encodingName) + 1);
+    name = ckalloc(strlen(typePtr->encodingName) + 1);
     encodingPtr->name		= strcpy(name, typePtr->encodingName);
     encodingPtr->hPtr		= hPtr;
     Tcl_SetHashValue(hPtr, encodingPtr);
 
     Tcl_MutexUnlock(&encodingMutex);
@@ -1062,20 +1161,19 @@
 char *
 Tcl_ExternalToUtfDString(
     Tcl_Encoding encoding,	/* The encoding for the source string, or NULL
 				 * for the default system encoding. */
     const char *src,		/* Source string in specified encoding. */
-    size_t srcLen,		/* Source string length in bytes, or -1 for
+    int srcLen,			/* Source string length in bytes, or < 0 for
 				 * encoding-specific string length. */
     Tcl_DString *dstPtr)	/* Uninitialized or free DString in which the
 				 * converted string is stored. */
 {
     char *dst;
     Tcl_EncodingState state;
     const Encoding *encodingPtr;
-    int flags, result, soFar, srcRead, dstWrote, dstChars;
-    size_t dstLen;
+    int flags, dstLen, result, soFar, srcRead, dstWrote, dstChars;
 
     Tcl_DStringInit(dstPtr);
     dst = Tcl_DStringValue(dstPtr);
     dstLen = dstPtr->spaceAvl - 1;
 
@@ -1084,11 +1182,11 @@
     }
     encodingPtr = (Encoding *) encoding;
 
     if (src == NULL) {
 	srcLen = 0;
-    } else if (srcLen == TCL_AUTO_LENGTH) {
+    } else if (srcLen < 0) {
 	srcLen = encodingPtr->lengthProc(src);
     }
 
     flags = TCL_ENCODING_START | TCL_ENCODING_END;
 
@@ -1136,21 +1234,21 @@
 Tcl_ExternalToUtf(
     Tcl_Interp *interp,		/* Interp for error return, if not NULL. */
     Tcl_Encoding encoding,	/* The encoding for the source string, or NULL
 				 * for the default system encoding. */
     const char *src,		/* Source string in specified encoding. */
-    size_t srcLen,		/* Source string length in bytes, or -1
-				 * for encoding-specific string length. */
+    int srcLen,			/* Source string length in bytes, or < 0 for
+				 * encoding-specific string length. */
     int flags,			/* Conversion control flags. */
     Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
 				 * information used during a piecewise
 				 * conversion. Contents of statePtr are
 				 * initialized and/or reset by conversion
 				 * routine under control of flags argument. */
     char *dst,			/* Output buffer in which converted string is
 				 * stored. */
-    size_t dstLen,		/* The maximum length of output buffer in
+    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
@@ -1174,11 +1272,11 @@
     }
     encodingPtr = (Encoding *) encoding;
 
     if (src == NULL) {
 	srcLen = 0;
-    } else if (srcLen == TCL_AUTO_LENGTH) {
+    } else if (srcLen < 0) {
 	srcLen = encodingPtr->lengthProc(src);
     }
     if (statePtr == NULL) {
 	flags |= TCL_ENCODING_START | TCL_ENCODING_END;
 	statePtr = &state;
@@ -1214,11 +1312,11 @@
 		flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr,
 		dstCharsPtr);
 	if (*dstCharsPtr <= maxChars) {
 	    break;
 	}
-	dstLen = Tcl_UtfAtIndex(dst, maxChars) - 1 - dst + TCL_UTF_MAX;
+	dstLen = Tcl_UtfAtIndex(dst, maxChars) - dst + (TCL_UTF_MAX - 1);
 	flags = savedFlags;
 	*statePtr = savedState;
     } while (1);
     if (!noTerminate) {
 	/* ...and then append it */
@@ -1253,20 +1351,19 @@
 char *
 Tcl_UtfToExternalDString(
     Tcl_Encoding encoding,	/* The encoding for the converted string, or
 				 * NULL for the default system encoding. */
     const char *src,		/* Source string in UTF-8. */
-    size_t srcLen,		/* Source string length in bytes, or -1 for
+    int srcLen,			/* Source string length in bytes, or < 0 for
 				 * strlen(). */
     Tcl_DString *dstPtr)	/* Uninitialized or free DString in which the
 				 * converted string is stored. */
 {
     char *dst;
     Tcl_EncodingState state;
     const Encoding *encodingPtr;
-    int flags, result, soFar, srcRead, dstWrote, dstChars;
-    size_t dstLen;
+    int flags, dstLen, result, soFar, srcRead, dstWrote, dstChars;
 
     Tcl_DStringInit(dstPtr);
     dst = Tcl_DStringValue(dstPtr);
     dstLen = dstPtr->spaceAvl - 1;
 
@@ -1275,11 +1372,11 @@
     }
     encodingPtr = (Encoding *) encoding;
 
     if (src == NULL) {
 	srcLen = 0;
-    } else if (srcLen == TCL_AUTO_LENGTH) {
+    } else if (srcLen < 0) {
 	srcLen = strlen(src);
     }
     flags = TCL_ENCODING_START | TCL_ENCODING_END;
     while (1) {
 	result = encodingPtr->fromUtfProc(encodingPtr->clientData, src,
@@ -1329,21 +1426,21 @@
 Tcl_UtfToExternal(
     Tcl_Interp *interp,		/* Interp for error return, if not NULL. */
     Tcl_Encoding encoding,	/* The encoding for the converted string, or
 				 * NULL for the default system encoding. */
     const char *src,		/* Source string in UTF-8. */
-    size_t srcLen,		/* Source string length in bytes, or -1
-				 * for strlen(). */
+    int srcLen,			/* Source string length in bytes, or < 0 for
+				 * strlen(). */
     int flags,			/* Conversion control flags. */
     Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
 				 * information used during a piecewise
 				 * conversion. Contents of statePtr are
 				 * initialized and/or reset by conversion
 				 * routine under control of flags argument. */
     char *dst,			/* Output buffer in which converted string
 				 * is stored. */
-    size_t dstLen,		/* The maximum length of output buffer in
+    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
@@ -1364,11 +1461,11 @@
     }
     encodingPtr = (Encoding *) encoding;
 
     if (src == NULL) {
 	srcLen = 0;
-    } else if (srcLen == TCL_AUTO_LENGTH) {
+    } else if (srcLen < 0) {
 	srcLen = strlen(src);
     }
     if (statePtr == NULL) {
 	flags |= TCL_ENCODING_START | TCL_ENCODING_END;
 	statePtr = &state;
@@ -1416,11 +1513,11 @@
 void
 Tcl_FindExecutable(
     const char *argv0)		/* The value of the application's argv[0]
 				 * (native). */
 {
-    TclInitSubsystems();
+    Tcl_InitSubsystems();
     TclpSetInitialEncodings();
     TclpFindExecutable(argv0);
 }
 
 /*
@@ -1696,11 +1793,11 @@
     memset(used, 0, sizeof(used));
 
 #undef PAGESIZE
 #define PAGESIZE    (256 * sizeof(unsigned short))
 
-    dataPtr = Tcl_Alloc(sizeof(TableEncodingData));
+    dataPtr = ckalloc(sizeof(TableEncodingData));
     memset(dataPtr, 0, sizeof(TableEncodingData));
 
     dataPtr->fallback = fallback;
 
     /*
@@ -1708,20 +1805,20 @@
      * malloc to get the memory for the array and all the pages needed by the
      * array.
      */
 
     size = 256 * sizeof(unsigned short *) + numPages * PAGESIZE;
-    dataPtr->toUnicode = Tcl_Alloc(size);
+    dataPtr->toUnicode = ckalloc(size);
     memset(dataPtr->toUnicode, 0, size);
     pageMemPtr = (unsigned short *) (dataPtr->toUnicode + 256);
 
     TclNewObj(objPtr);
     Tcl_IncrRefCount(objPtr);
     for (i = 0; i < numPages; i++) {
 	int ch;
 	const char *p;
-	size_t expected = 3 + 16 * (16 * 4 + 1);
+	int expected = 3 + 16 * (16 * 4 + 1);
 
 	if (Tcl_ReadChars(chan, objPtr, expected, 0) != expected) {
 	    return NULL;
 	}
 	p = TclGetString(objPtr);
@@ -1769,11 +1866,11 @@
 	if (used[hi]) {
 	    numPages++;
 	}
     }
     size = 256 * sizeof(unsigned short *) + numPages * PAGESIZE;
-    dataPtr->fromUnicode = Tcl_Alloc(size);
+    dataPtr->fromUnicode = ckalloc(size);
     memset(dataPtr->fromUnicode, 0, size);
     pageMemPtr = (unsigned short *) (dataPtr->fromUnicode + 256);
 
     for (hi = 0; hi < 256; hi++) {
 	if (dataPtr->toUnicode[hi] == NULL) {
@@ -1865,11 +1962,11 @@
     /*
      * Read lines from the encoding until EOF.
      */
 
     for (TclDStringClear(&lineString);
-	    (len = Tcl_Gets(chan, &lineString)) != -1;
+	    (len = Tcl_Gets(chan, &lineString)) >= 0;
 	    TclDStringClear(&lineString)) {
 	const unsigned char *p;
 	int to, from;
 
 	/*
@@ -1959,11 +2056,11 @@
 	const char **argv;
 	char *line;
 	Tcl_DString lineString;
 
 	Tcl_DStringInit(&lineString);
-	if (Tcl_Gets(chan, &lineString) == TCL_IO_FAILURE) {
+	if (Tcl_Gets(chan, &lineString) < 0) {
 	    break;
 	}
 	line = Tcl_DStringValue(&lineString);
 	if (Tcl_SplitList(NULL, line, &argc, &argv) != TCL_OK) {
 	    Tcl_DStringFree(&lineString);
@@ -2001,17 +2098,17 @@
 		}
 		est.encodingPtr = e;
 		Tcl_DStringAppend(&escapeData, (char *) &est, sizeof(est));
 	    }
 	}
-	Tcl_Free((void *)argv);
+	ckfree(argv);
 	Tcl_DStringFree(&lineString);
     }
 
     size = sizeof(EscapeEncodingData) - sizeof(EscapeSubTable)
 	    + Tcl_DStringLength(&escapeData);
-    dataPtr = Tcl_Alloc(size);
+    dataPtr = ckalloc(size);
     dataPtr->initLen = strlen(init);
     memcpy(dataPtr->init, init, dataPtr->initLen + 1);
     dataPtr->finalLen = strlen(final);
     memcpy(dataPtr->final, final, dataPtr->finalLen + 1);
     dataPtr->numSubTables =
@@ -2337,13 +2434,13 @@
 }
 
 /*
  *-------------------------------------------------------------------------
  *
- * UniCharToUtfProc --
+ * Utf16ToUtfProc --
  *
- *	Convert from Unicode to UTF-8.
+ *	Convert from UTF-16 to UTF-8.
  *
  * Results:
  *	Returns TCL_OK if conversion was successful.
  *
  * Side effects:
@@ -2351,12 +2448,12 @@
  *
  *-------------------------------------------------------------------------
  */
 
 static int
-UniCharToUtfProc(
-    ClientData clientData,	/* Not used. */
+Utf16ToUtfProc(
+    ClientData clientData,	/* != NULL means LE, == NUL means BE */
     const char *src,		/* Source string in Unicode. */
     int srcLen,			/* Source string length in bytes. */
     int flags,			/* Conversion control flags. */
     Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
 				 * information used during a piecewise
@@ -2404,16 +2501,19 @@
 	if (dst > dstEnd) {
 	    result = TCL_CONVERT_NOSPACE;
 	    break;
 	}
 
+	if (clientData) {
+	    ch = (src[1] & 0xFF) << 8 | (src[0] & 0xFF);
+	} else {
+	    ch = (src[0] & 0xFF) << 8 | (src[1] & 0xFF);
+	}
 	/*
 	 * Special case for 1-byte utf chars for speed. Make sure we work with
 	 * unsigned short-size data.
 	 */
-
-	ch = *(unsigned short *)src;
 	if (ch && ch < 0x80) {
 	    *dst++ = (ch & 0xFF);
 	} else {
 	    dst += Tcl_UniCharToUtf(ch, dst);
 	}
@@ -2427,13 +2527,13 @@
 }
 
 /*
  *-------------------------------------------------------------------------
  *
- * UtfToUniCharProc --
+ * UtfToUtf16Proc --
  *
- *	Convert from UTF-8 to Unicode.
+ *	Convert from UTF-8 to UTF-16.
  *
  * Results:
  *	Returns TCL_OK if conversion was successful.
  *
  * Side effects:
@@ -2441,13 +2541,12 @@
  *
  *-------------------------------------------------------------------------
  */
 
 static int
-UtfToUniCharProc(
-    ClientData clientData,	/* TableEncodingData that specifies
-				 * encoding. */
+UtfToUtf16Proc(
+    ClientData clientData,	/* != NULL means LE, == NUL means BE */
     const char *src,		/* Source string in UTF-8. */
     int srcLen,			/* Source string length in bytes. */
     int flags,			/* Conversion control flags. */
     Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
 				 * information used during a piecewise
@@ -2507,48 +2606,155 @@
 	/*
 	 * Need to handle this in a way that won't cause misalignment by
 	 * casting dst to a Tcl_UniChar. [Bug 1122671]
 	 */
 
-#ifdef WORDS_BIGENDIAN
-#if TCL_UTF_MAX > 4
-	if (*chPtr <= 0xFFFF) {
-	    *dst++ = (*chPtr >> 8);
-	    *dst++ = (*chPtr & 0xFF);
-	} else {
-	    *dst++ = ((*chPtr & 0x3) >> 8) | 0xDC;
-	    *dst++ = (*chPtr & 0xFF);
-	    *dst++ = (((*chPtr - 0x10000) >> 18) & 0x3) | 0xD8;
-	    *dst++ = (((*chPtr - 0x10000) >> 10) & 0xFF);
-	}
-#else
-	*dst++ = (*chPtr >> 8);
-	*dst++ = (*chPtr & 0xFF);
-#endif
-#else
-#if TCL_UTF_MAX > 4
-	if (*chPtr <= 0xFFFF) {
-	    *dst++ = (*chPtr & 0xFF);
-	    *dst++ = (*chPtr >> 8);
-	} else {
-	    *dst++ = (((*chPtr - 0x10000) >> 10) & 0xFF);
-	    *dst++ = (((*chPtr - 0x10000) >> 18) & 0x3) | 0xD8;
-	    *dst++ = (*chPtr & 0xFF);
-	    *dst++ = ((*chPtr & 0x3) >> 8) | 0xDC;
-	}
-#else
-	*dst++ = (*chPtr & 0xFF);
-	*dst++ = (*chPtr >> 8);
-#endif
-#endif
-    }
-    *srcReadPtr = src - srcStart;
-    *dstWrotePtr = dst - dstStart;
-    *dstCharsPtr = numChars;
-    return result;
-}
-
+	if (clientData) {
+#if TCL_UTF_MAX > 4
+	    if (*chPtr <= 0xFFFF) {
+		*dst++ = (*chPtr & 0xFF);
+		*dst++ = (*chPtr >> 8);
+	    } else {
+		*dst++ = (((*chPtr - 0x10000) >> 10) & 0xFF);
+		*dst++ = (((*chPtr - 0x10000) >> 18) & 0x3) | 0xD8;
+		*dst++ = (*chPtr & 0xFF);
+		*dst++ = ((*chPtr & 0x3) >> 8) | 0xDC;
+	    }
+#else
+	    *dst++ = (*chPtr & 0xFF);
+	    *dst++ = (*chPtr >> 8);
+#endif
+	} else {
+#if TCL_UTF_MAX > 4
+	    if (*chPtr <= 0xFFFF) {
+		*dst++ = (*chPtr >> 8);
+		*dst++ = (*chPtr & 0xFF);
+	    } else {
+		*dst++ = ((*chPtr & 0x3) >> 8) | 0xDC;
+		*dst++ = (*chPtr & 0xFF);
+		*dst++ = (((*chPtr - 0x10000) >> 18) & 0x3) | 0xD8;
+		*dst++ = (((*chPtr - 0x10000) >> 10) & 0xFF);
+	    }
+#else
+	    *dst++ = (*chPtr >> 8);
+	    *dst++ = (*chPtr & 0xFF);
+#endif
+	}
+    }
+    *srcReadPtr = src - srcStart;
+    *dstWrotePtr = dst - dstStart;
+    *dstCharsPtr = numChars;
+    return result;
+}
+
+/*
+ *-------------------------------------------------------------------------
+ *
+ * UtfToUcs2Proc --
+ *
+ *	Convert from UTF-8 to UCS-2.
+ *
+ * Results:
+ *	Returns TCL_OK if conversion was successful.
+ *
+ * Side effects:
+ *	None.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+static int
+UtfToUcs2Proc(
+    ClientData clientData,	/* != NULL means LE, == NUL means BE */
+    const char *src,		/* Source string in UTF-8. */
+    int srcLen,			/* Source string length in bytes. */
+    int flags,			/* Conversion control flags. */
+    Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
+				 * information used during a piecewise
+				 * conversion. Contents of statePtr are
+				 * initialized and/or reset by conversion
+				 * routine under control of flags argument. */
+    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;
+#if TCL_UTF_MAX <= 4
+    int len;
+#endif
+    Tcl_UniChar ch = 0;
+
+    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);
+
+    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;
+	}
+#if TCL_UTF_MAX <= 4
+	src += (len = TclUtfToUniChar(src, &ch));
+	if ((ch >= 0xD800) && (len < 3)) {
+	    src += TclUtfToUniChar(src, &ch);
+	    ch = 0xFFFD;
+	}
+#else
+	src += TclUtfToUniChar(src, &ch);
+	if (ch > 0xFFFF) {
+	    ch = 0xFFFD;
+	}
+#endif
+
+	/*
+	 * Need to handle this in a way that won't cause misalignment by
+	 * casting dst to a Tcl_UniChar. [Bug 1122671]
+	 */
+
+	if (clientData) {
+	    *dst++ = (ch & 0xFF);
+	    *dst++ = (ch >> 8);
+	} else {
+	    *dst++ = (ch >> 8);
+	    *dst++ = (ch & 0xFF);
+	}
+    }
+    *srcReadPtr = src - srcStart;
+    *dstWrotePtr = dst - dstStart;
+    *dstCharsPtr = numChars;
+    return result;
+}
+
 /*
  *-------------------------------------------------------------------------
  *
  * TableToUtfProc --
  *
@@ -3008,15 +3214,15 @@
 
     /*
      * Make sure we aren't freeing twice on shutdown. [Bug 219314]
      */
 
-    Tcl_Free(dataPtr->toUnicode);
+    ckfree(dataPtr->toUnicode);
     dataPtr->toUnicode = NULL;
-    Tcl_Free(dataPtr->fromUnicode);
+    ckfree(dataPtr->fromUnicode);
     dataPtr->fromUnicode = NULL;
-    Tcl_Free(dataPtr);
+    ckfree(dataPtr);
 }
 
 /*
  *-------------------------------------------------------------------------
  *
@@ -3385,11 +3591,12 @@
 
 		    state = oldState;
 		    result = TCL_CONVERT_NOSPACE;
 		    break;
 		}
-		memcpy(dst, subTablePtr->sequence, subTablePtr->sequenceLen);
+		memcpy(dst, subTablePtr->sequence,
+			subTablePtr->sequenceLen);
 		dst += subTablePtr->sequenceLen;
 	    }
 	}
 
 	if (tablePrefixBytes[(word >> 8)] != 0) {
@@ -3490,11 +3697,11 @@
 	    FreeEncoding((Tcl_Encoding) subTablePtr->encodingPtr);
 	    subTablePtr->encodingPtr = NULL;
 	    subTablePtr++;
 	}
     }
-    Tcl_Free(dataPtr);
+    ckfree(dataPtr);
 }
 
 /*
  *---------------------------------------------------------------------------
  *
@@ -3591,11 +3798,11 @@
  */
 
 static void
 InitializeEncodingSearchPath(
     char **valuePtr,
-    size_t *lengthPtr,
+    unsigned int *lengthPtr,
     Tcl_Encoding *encodingPtr)
 {
     const char *bytes;
     int i, numDirs;
     Tcl_Obj *libPathObj, *encodingObj, *searchPathObj;
@@ -3625,12 +3832,14 @@
     Tcl_DecrRefCount(encodingObj);
     *encodingPtr = libraryPath.encoding;
     if (*encodingPtr) {
 	((Encoding *)(*encodingPtr))->refCount++;
     }
-    bytes = TclGetStringFromObj(searchPathObj, lengthPtr);
-    *valuePtr = Tcl_Alloc(*lengthPtr + 1);
+    bytes = TclGetString(searchPathObj);
+
+    *lengthPtr = searchPathObj->length;
+    *valuePtr = ckalloc(*lengthPtr + 1);
     memcpy(*valuePtr, bytes, *lengthPtr + 1);
     Tcl_DecrRefCount(searchPathObj);
 }
 
 /*

Index: generic/tclEnsemble.c
==================================================================
--- generic/tclEnsemble.c
+++ generic/tclEnsemble.c
@@ -103,11 +103,11 @@
  * The internal rep for caching ensemble subcommand lookups and spelling
  * corrections.
  */
 
 typedef struct {
-    size_t epoch;               /* Used to confirm when the data in this
+    unsigned int epoch;         /* Used to confirm when the data in this
                                  * really structure matches up with the
                                  * ensemble. */
     Command *token;             /* Reference to the command for which this
                                  * structure is a cache of the resolution. */
     Tcl_Obj *fix;               /* Corrected spelling, if needed. */
@@ -117,11 +117,11 @@
 
 static inline Tcl_Obj *
 NewNsObj(
     Tcl_Namespace *namespacePtr)
 {
-    register Namespace *nsPtr = (Namespace *) namespacePtr;
+    Namespace *nsPtr = (Namespace *) namespacePtr;
 
     if (namespacePtr == TclGetGlobalNamespace(nsPtr->interp)) {
 	return Tcl_NewStringObj("::", 2);
     }
     return Tcl_NewStringObj(nsPtr->fullName, -1);
@@ -673,16 +673,16 @@
 {
     Namespace *nsPtr = (Namespace *) ensembleNsPtr;
     EnsembleConfig *ensemblePtr;
     Tcl_Command token;
 
-    ensemblePtr = Tcl_Alloc(sizeof(EnsembleConfig));
+    ensemblePtr = ckalloc(sizeof(EnsembleConfig));
     token = TclNRCreateCommandInNs(interp, name,
 	    (Tcl_Namespace *) nameNsPtr, TclEnsembleImplementationCmd,
 	    NsEnsembleImplementationCmdNR, ensemblePtr, DeleteEnsembleConfig);
     if (token == NULL) {
-	Tcl_Free(ensemblePtr);
+	ckfree(ensemblePtr);
 	return NULL;
     }
 
     ensemblePtr->nsPtr = nsPtr;
     ensemblePtr->epoch = 0;
@@ -1622,11 +1622,11 @@
 			    Tcl_NRCreateCommand(interp, "___tmp", map[i].proc,
 			    map[i].nreProc, map[i].clientData, NULL);
 		    Tcl_DStringSetLength(&hiddenBuf, hiddenLen);
 		    if (Tcl_HideCommand(interp, "___tmp",
 			    Tcl_DStringAppend(&hiddenBuf, map[i].name, -1))) {
-			Tcl_Panic("%s", Tcl_GetStringResult(interp));
+			Tcl_Panic("%s", Tcl_GetString(Tcl_GetObjResult(interp)));
 		    }
 		} else {
 		    /*
 		     * Not hidden, so just create it. Yay!
 		     */
@@ -1643,11 +1643,11 @@
     }
 
     Tcl_DStringFree(&buf);
     Tcl_DStringFree(&hiddenBuf);
     if (nameParts != NULL) {
-	Tcl_Free((void *)nameParts);
+	ckfree(nameParts);
     }
     return ensemble;
 }
 
 /*
@@ -1699,20 +1699,20 @@
 				 * specified but not yet cached command
 				 * names. */
     int reparseCount = 0;	/* Number of reparses. */
     Tcl_Obj *errorObj;		/* Used for building error messages. */
     Tcl_Obj *subObj;
-    size_t subIdx;
+    int subIdx;
 
     /*
      * Must recheck objc, since numParameters might have changed. Cf. test
      * namespace-53.9.
      */
 
   restartEnsembleParse:
     subIdx = 1 + ensemblePtr->numParameters;
-    if ((size_t)objc < subIdx + 1) {
+    if (objc < subIdx + 1) {
 	/*
 	 * We don't have a subcommand argument. Make error message.
 	 */
 
 	Tcl_DString buf;	/* Message being built */
@@ -1805,17 +1805,17 @@
 
 	const char *subcmdName; /* Name of the subcommand, or unique prefix of
 				 * it (will be an error for a non-unique
 				 * prefix). */
 	char *fullName = NULL;	/* Full name of the subcommand. */
-	size_t stringLength, i;
-	size_t tableLength = ensemblePtr->subcommandTable.numEntries;
+	int stringLength, i;
+	int tableLength = ensemblePtr->subcommandTable.numEntries;
 	Tcl_Obj *fix;
 
 	subcmdName = TclGetStringFromObj(subObj, &stringLength);
 	for (i=0 ; i<tableLength ; i++) {
-	    register int cmp = strncmp(subcmdName,
+	    int cmp = strncmp(subcmdName,
 		    ensemblePtr->subcommandArrayPtr[i],
 		    stringLength);
 
 	    if (cmp == 0) {
 		if (fullName != NULL) {
@@ -1970,11 +1970,11 @@
 	    (ensemblePtr->flags & TCL_ENSEMBLE_PREFIX ? " or ambiguous" : ""),
 	    TclGetString(subObj));
     if (ensemblePtr->subcommandTable.numEntries == 1) {
 	Tcl_AppendToObj(errorObj, ensemblePtr->subcommandArrayPtr[0], -1);
     } else {
-	size_t i;
+	int i;
 
 	for (i=0 ; i<ensemblePtr->subcommandTable.numEntries-1 ; i++) {
 	    Tcl_AppendToObj(errorObj, ensemblePtr->subcommandArrayPtr[i], -1);
 	    Tcl_AppendToObj(errorObj, ", ", 2);
 	}
@@ -2015,12 +2015,12 @@
  */
 
 int
 TclInitRewriteEnsemble(
     Tcl_Interp *interp,
-    size_t numRemoved,
-    size_t numInserted,
+    int numRemoved,
+    int numInserted,
     Tcl_Obj *const *objv)
 {
     Interp *iPtr = (Interp *) interp;
 
     int isRootEnsemble = (iPtr->ensembleRewrite.sourceObjs == NULL);
@@ -2028,11 +2028,11 @@
     if (isRootEnsemble) {
 	iPtr->ensembleRewrite.sourceObjs = objv;
 	iPtr->ensembleRewrite.numRemovedObjs = numRemoved;
 	iPtr->ensembleRewrite.numInsertedObjs = numInserted;
     } else {
-	size_t numIns = iPtr->ensembleRewrite.numInsertedObjs;
+	int numIns = iPtr->ensembleRewrite.numInsertedObjs;
 
 	if (numIns < numRemoved) {
 	    iPtr->ensembleRewrite.numRemovedObjs += numRemoved - numIns;
 	    iPtr->ensembleRewrite.numInsertedObjs = numInserted;
 	} else {
@@ -2098,29 +2098,29 @@
     int result)
 {
     Tcl_Obj **tmp = (Tcl_Obj **) data[0];
     Tcl_Obj **store = (Tcl_Obj **) data[1];
 
-    Tcl_Free(store);
-    Tcl_Free(tmp);
+    ckfree(store);
+    ckfree(tmp);
     return result;
 }
 
 void
 TclSpellFix(
     Tcl_Interp *interp,
     Tcl_Obj *const *objv,
     int objc,
-    size_t badIdx,
+    int badIdx,
     Tcl_Obj *bad,
     Tcl_Obj *fix)
 {
     Interp *iPtr = (Interp *) interp;
     Tcl_Obj *const *search;
     Tcl_Obj **store;
-    size_t idx;
-    size_t size;
+    int idx;
+    int size;
 
     if (iPtr->ensembleRewrite.sourceObjs == NULL) {
 	iPtr->ensembleRewrite.sourceObjs = objv;
 	iPtr->ensembleRewrite.numRemovedObjs = 0;
 	iPtr->ensembleRewrite.numInsertedObjs = 0;
@@ -2174,13 +2174,13 @@
 
     search = iPtr->ensembleRewrite.sourceObjs;
     if (search[0] == NULL) {
 	store = (Tcl_Obj **) search[2];
     }  else {
-	Tcl_Obj **tmp = Tcl_Alloc(3 * sizeof(Tcl_Obj *));
+	Tcl_Obj **tmp = ckalloc(3 * sizeof(Tcl_Obj *));
 
-	store = Tcl_Alloc(size * sizeof(Tcl_Obj *));
+	store = ckalloc(size * sizeof(Tcl_Obj *));
 	memcpy(store, iPtr->ensembleRewrite.sourceObjs,
 		size * sizeof(Tcl_Obj *));
 
 	/*
 	 * Awful casting abuse here! Note that the NULL in the first element
@@ -2402,11 +2402,11 @@
     Tcl_Obj *objPtr,
     EnsembleConfig *ensemblePtr,
     Tcl_HashEntry *hPtr,
     Tcl_Obj *fix)
 {
-    register EnsembleCmdRep *ensembleCmd;
+    EnsembleCmdRep *ensembleCmd;
 
     ECRGetIntRep(objPtr, ensembleCmd);
     if (ensembleCmd) {
 	TclCleanupCommandMacro(ensembleCmd->token);
 	if (ensembleCmd->fix) {
@@ -2416,11 +2416,11 @@
 	/*
 	 * Kill the old internal rep, and replace it with a brand new one of
 	 * our own.
 	 */
 
-	ensembleCmd = Tcl_Alloc(sizeof(EnsembleCmdRep));
+	ensembleCmd = ckalloc(sizeof(EnsembleCmdRep));
 	ECRSetIntRep(objPtr, ensembleCmd);
     }
 
     /*
      * Populate the internal rep.
@@ -2469,11 +2469,11 @@
         while (hPtr != NULL) {
             Tcl_Obj *prefixObj = Tcl_GetHashValue(hPtr);
             Tcl_DecrRefCount(prefixObj);
             hPtr = Tcl_NextHashEntry(&search);
         }
-        Tcl_Free(ensemblePtr->subcommandArrayPtr);
+        ckfree((char *) ensemblePtr->subcommandArrayPtr);
     }
     Tcl_DeleteHashTable(hash);
 }
 
 static void
@@ -2566,12 +2566,11 @@
     EnsembleConfig *ensemblePtr)
 {
     Tcl_HashSearch search;	/* Used for scanning the set of commands in
 				 * the namespace that backs up this
 				 * ensemble. */
-    size_t i, j;
-    int isNew;
+    int i, j, isNew;
     Tcl_HashTable *hash = &ensemblePtr->subcommandTable;
     Tcl_HashEntry *hPtr;
     Tcl_Obj *mapDict = ensemblePtr->subcommandDict;
     Tcl_Obj *subList = ensemblePtr->subcmdList;
 
@@ -2579,11 +2578,11 @@
     Tcl_InitHashTable(hash, TCL_STRING_KEYS);
 
     if (subList) {
         int subc;
         Tcl_Obj **subv, *target, *cmdObj, *cmdPrefixObj;
-        char *name;
+        const char *name;
 
         /*
          * There is a list of exactly what subcommands go in the table.
          * Must determine the target for each.
          */
@@ -2593,11 +2592,11 @@
             /*
              * Strange case where explicit list of subcommands is same value
              * as the dict mapping to targets.
              */
 
-            for (i = 0; i < (size_t)subc; i += 2) {
+            for (i = 0; i < subc; i += 2) {
                 name = TclGetString(subv[i]);
                 hPtr = Tcl_CreateHashEntry(hash, name, &isNew);
                 if (!isNew) {
                     cmdObj = (Tcl_Obj *)Tcl_GetHashValue(hPtr);
                     Tcl_DecrRefCount(cmdObj);
@@ -2617,11 +2616,11 @@
         } else {
             /*
 	     * Usual case where we can freely act on the list and dict.
 	     */
 
-            for (i = 0; i < (size_t)subc; i++) {
+            for (i = 0; i < subc; i++) {
                 name = TclGetString(subv[i]);
                 hPtr = Tcl_CreateHashEntry(hash, name, &isNew);
                 if (!isNew) {
                     continue;
                 }
@@ -2664,11 +2663,11 @@
         int done;
 
         Tcl_DictObjFirst(NULL, ensemblePtr->subcommandDict, &dictSearch,
                 &keyObj, &valueObj, &done);
         while (!done) {
-            char *name = TclGetString(keyObj);
+            const char *name = TclGetString(keyObj);
 
             hPtr = Tcl_CreateHashEntry(hash, name, &isNew);
             Tcl_SetHashValue(hPtr, valueObj);
             Tcl_IncrRefCount(valueObj);
             Tcl_DictObjNext(&dictSearch, &keyObj, &valueObj, &done);
@@ -2739,11 +2738,11 @@
      * directly to save a copy, since any time we change the array we change
      * the hash too, and vice versa) and running quicksort over the array.
      */
 
     ensemblePtr->subcommandArrayPtr =
-	    Tcl_Alloc(sizeof(char *) * hash->numEntries);
+	    ckalloc(sizeof(char *) * hash->numEntries);
 
     /*
      * Fill array from both ends as this makes us less likely to end up with
      * performance problems in qsort(), which is good. Note that doing this
      * makes this code much more opaque, but the naive alternatve:
@@ -2833,11 +2832,11 @@
     ECRGetIntRep(objPtr, ensembleCmd);
     TclCleanupCommandMacro(ensembleCmd->token);
     if (ensembleCmd->fix) {
 	Tcl_DecrRefCount(ensembleCmd->fix);
     }
-    Tcl_Free(ensembleCmd);
+    ckfree(ensembleCmd);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -2860,11 +2859,11 @@
 DupEnsembleCmdRep(
     Tcl_Obj *objPtr,
     Tcl_Obj *copyPtr)
 {
     EnsembleCmdRep *ensembleCmd;
-    EnsembleCmdRep *ensembleCopy = Tcl_Alloc(sizeof(EnsembleCmdRep));
+    EnsembleCmdRep *ensembleCopy = ckalloc(sizeof(EnsembleCmdRep));
 
     ECRGetIntRep(objPtr, ensembleCmd);
     ECRSetIntRep(copyPtr, ensembleCopy);
 
     ensembleCopy->epoch = ensembleCmd->epoch;
@@ -2912,11 +2911,11 @@
     Tcl_Obj *replaced = Tcl_NewObj(), *replacement;
     Tcl_Command ensemble = (Tcl_Command) cmdPtr;
     Command *oldCmdPtr = cmdPtr, *newCmdPtr;
     int len, result, flags = 0, i, depth = 1, invokeAnyway = 0;
     int ourResult = TCL_ERROR;
-    size_t numBytes;
+    unsigned numBytes;
     const char *word;
     DefineLineInformation;
 
     Tcl_IncrRefCount(replaced);
     if (parsePtr->numWords < depth + 1) {
@@ -2982,20 +2981,20 @@
      * list filters the entries in the map.
      */
 
     (void) Tcl_GetEnsembleSubcommandList(NULL, ensemble, &listObj);
     if (listObj != NULL) {
-	size_t sclen;
+	int sclen;
 	const char *str;
 	Tcl_Obj *matchObj = NULL;
 
 	if (Tcl_ListObjGetElements(NULL, listObj, &len, &elems) != TCL_OK) {
 	    goto failed;
 	}
 	for (i=0 ; i<len ; i++) {
 	    str = TclGetStringFromObj(elems[i], &sclen);
-	    if ((sclen == numBytes) && !memcmp(word, str, numBytes)) {
+	    if ((sclen == (int) numBytes) && !memcmp(word, str, numBytes)) {
 		/*
 		 * Exact match! Excellent!
 		 */
 
 		result = Tcl_DictObjGet(NULL, mapObj,elems[i], &targetCmdObj);
@@ -3038,11 +3037,11 @@
 
 	/*
 	 * No map, so check the dictionary directly.
 	 */
 
-	TclNewStringObj(subcmdObj, word, numBytes);
+	TclNewStringObj(subcmdObj, word, (int) numBytes);
 	result = Tcl_DictObjGet(NULL, mapObj, subcmdObj, &targetCmdObj);
 	if (result == TCL_OK && targetCmdObj != NULL) {
 	    /*
 	     * Got it. Skip the fiddling around with prefixes.
 	     */
@@ -3179,11 +3178,11 @@
      * Throw out any line information generated by the failed compile attempt.
      */
 
     while (mapPtr->nuloc - 1 > eclIndex) {
         mapPtr->nuloc--;
-        Tcl_Free(mapPtr->loc[mapPtr->nuloc].line);
+        ckfree(mapPtr->loc[mapPtr->nuloc].line);
         mapPtr->loc[mapPtr->nuloc].line = NULL;
     }
 
     /*
      * Reset the index of next command.  Toss out any from failed nested
@@ -3354,11 +3353,11 @@
 
 	int diff = envPtr->currStackDepth - savedStackDepth;
 
 	if (diff != 1) {
 	    Tcl_Panic("bad stack adjustment when compiling"
-		    " %.*s (was %d instead of 1)", (int)parsePtr->tokenPtr->size,
+		    " %.*s (was %d instead of 1)", parsePtr->tokenPtr->size,
 		    parsePtr->tokenPtr->start, diff);
 	}
 #endif
     }
 
@@ -3378,13 +3377,12 @@
     Command *cmdPtr,
     CompileEnv *envPtr)		/* Holds resulting instructions. */
 {
     Tcl_Token *tokPtr;
     Tcl_Obj *objPtr, **words;
-    char *bytes;
+    const char *bytes;
     int i, numWords, cmdLit, extraLiteralFlags = LITERAL_CMD_NAME;
-    size_t length;
     DefineLineInformation;
 
     /*
      * Push the words of the command. Take care; the command words may be
      * scripts that have backslashes in them, and [info frame 0] can see the
@@ -3393,12 +3391,12 @@
 
     Tcl_ListObjGetElements(NULL, replacements, &numWords, &words);
     for (i = 0, tokPtr = parsePtr->tokenPtr; i < parsePtr->numWords;
 	    i++, tokPtr = TokenAfter(tokPtr)) {
 	if (i > 0 && i < numWords+1) {
-	    bytes = TclGetStringFromObj(words[i-1], &length);
-	    PushLiteral(envPtr, bytes, length);
+	    bytes = TclGetString(words[i-1]);
+	    PushLiteral(envPtr, bytes, words[i-1]->length);
 	    continue;
 	}
 
 	SetLineInformation(i);
 	if (tokPtr->type == TCL_TOKEN_SIMPLE_WORD) {
@@ -3422,15 +3420,15 @@
      * the implementation.
      */
 
     objPtr = Tcl_NewObj();
     Tcl_GetCommandFullName(interp, (Tcl_Command) cmdPtr, objPtr);
-    bytes = TclGetStringFromObj(objPtr, &length);
+    bytes = TclGetString(objPtr);
     if ((cmdPtr != NULL) && (cmdPtr->flags & CMD_VIA_RESOLVER)) {
 	extraLiteralFlags |= LITERAL_UNSHARED;
     }
-    cmdLit = TclRegisterLiteral(envPtr, bytes, length, extraLiteralFlags);
+    cmdLit = TclRegisterLiteral(envPtr, bytes, objPtr->length, extraLiteralFlags);
     TclSetCmdNameObj(interp, TclFetchLiteral(envPtr, cmdLit), cmdPtr);
     TclEmitPush(cmdLit, envPtr);
     TclDecrRefCount(objPtr);
 
     /*

Index: generic/tclEnv.c
==================================================================
--- generic/tclEnv.c
+++ generic/tclEnv.c
@@ -16,19 +16,19 @@
 #include "tclInt.h"
 
 TCL_DECLARE_MUTEX(envMutex)	/* To serialize access to environ. */
 
 static struct {
-    size_t cacheSize;		/* Number of env strings in cache. */
+    int cacheSize;		/* Number of env strings in cache. */
     char **cache;		/* Array containing all of the environment
 				 * strings that Tcl has allocated. */
 #ifndef USE_PUTENV
     char **ourEnviron;		/* Cache of the array that we allocate. We
 				 * need to track this in case another
 				 * subsystem swaps around the environ array
 				 * like we do. */
-    size_t ourEnvironSize;	/* Non-zero means that the environ array was
+    int ourEnvironSize;		/* Non-zero means that the environ array was
 				 * malloced and has this many total entries
 				 * allocated to it (not all may be in use at
 				 * once). Zero means that the environment
 				 * array is in its original static state. */
 #endif
@@ -214,12 +214,12 @@
     const char *name,		/* Name of variable whose value is to be set
 				 * (UTF-8). */
     const char *value)		/* New value for variable (UTF-8). */
 {
     Tcl_DString envString;
-    size_t nameLength, valueLength;
-    size_t index, length;
+    unsigned nameLength, valueLength;
+    int index, length;
     char *p, *oldValue;
     const char *p2;
 
     /*
      * Figure out where the entry is going to go. If the name doesn't already
@@ -228,24 +228,24 @@
      */
 
     Tcl_MutexLock(&envMutex);
     index = TclpFindVariable(name, &length);
 
-    if (index == TCL_INDEX_NONE) {
+    if (index == -1) {
 #ifndef USE_PUTENV
 	/*
 	 * We need to handle the case where the environment may be changed
 	 * outside our control. ourEnvironSize is only valid if the current
 	 * environment is the one we allocated. [Bug 979640]
 	 */
 
 	if ((env.ourEnviron != environ) || (length+2 > env.ourEnvironSize)) {
-	    char **newEnviron = Tcl_Alloc((length + 5) * sizeof(char *));
+	    char **newEnviron = ckalloc((length + 5) * sizeof(char *));
 
 	    memcpy(newEnviron, environ, length * sizeof(char *));
 	    if ((env.ourEnvironSize != 0) && (env.ourEnviron != NULL)) {
-		Tcl_Free(env.ourEnviron);
+		ckfree(env.ourEnviron);
 	    }
 	    environ = env.ourEnviron = newEnviron;
 	    env.ourEnvironSize = length + 5;
 	}
 	index = length;
@@ -281,21 +281,21 @@
      * "name=value" pattern. Then convert the string to the native encoding,
      * and set the environ array value.
      */
 
     valueLength = strlen(value);
-    p = Tcl_Alloc(nameLength + valueLength + 2);
+    p = ckalloc(nameLength + valueLength + 2);
     memcpy(p, name, nameLength);
     p[nameLength] = '=';
     memcpy(p+nameLength+1, value, valueLength+1);
     p2 = Tcl_UtfToExternalDString(NULL, p, -1, &envString);
 
     /*
      * Copy the native string to heap memory.
      */
 
-    p = Tcl_Realloc(p, Tcl_DStringLength(&envString) + 1);
+    p = ckrealloc(p, Tcl_DStringLength(&envString) + 1);
     memcpy(p, p2, Tcl_DStringLength(&envString) + 1);
     Tcl_DStringFree(&envString);
 
 #ifdef USE_PUTENV
     /*
@@ -312,19 +312,19 @@
      * Watch out for versions of putenv that copy the string (e.g. VC++). In
      * this case we need to free the string immediately. Otherwise update the
      * string in the cache.
      */
 
-    if ((index != TCL_INDEX_NONE) && (environ[index] == p)) {
+    if ((index != -1) && (environ[index] == p)) {
 	ReplaceString(oldValue, p);
 #ifdef HAVE_PUTENV_THAT_COPIES
     } else {
 	/*
 	 * This putenv() copies instead of taking ownership.
 	 */
 
-	Tcl_Free(p);
+	ckfree(p);
 #endif /* HAVE_PUTENV_THAT_COPIES */
     }
 
     Tcl_MutexUnlock(&envMutex);
 
@@ -412,11 +412,12 @@
 void
 TclUnsetEnv(
     const char *name)		/* Name of variable to remove (UTF-8). */
 {
     char *oldValue;
-    size_t length, index;
+    int length;
+    int index;
 #ifdef USE_PUTENV_FOR_UNSET
     Tcl_DString envString;
     char *string;
 #else
     char **envPtr;
@@ -428,11 +429,11 @@
     /*
      * First make sure that the environment variable exists to avoid doing
      * needless work and to avoid recursion on the unset.
      */
 
-    if (index == TCL_AUTO_LENGTH) {
+    if (index == -1) {
 	Tcl_MutexUnlock(&envMutex);
 	return;
     }
 
     /*
@@ -451,22 +452,22 @@
      * For those platforms that support putenv to unset, Linux indicates
      * that no = should be included, and Windows requires it.
      */
 
 #if defined(_WIN32)
-    string = Tcl_Alloc(length + 2);
+    string = ckalloc(length + 2);
     memcpy(string, name, length);
     string[length] = '=';
     string[length+1] = '\0';
 #else
-    string = Tcl_Alloc(length + 1);
+    string = ckalloc(length + 1);
     memcpy(string, name, length);
     string[length] = '\0';
 #endif /* _WIN32 */
 
     Tcl_UtfToExternalDString(NULL, string, -1, &envString);
-    string = Tcl_Realloc(string, Tcl_DStringLength(&envString) + 1);
+    string = ckrealloc(string, Tcl_DStringLength(&envString) + 1);
     memcpy(string, Tcl_DStringValue(&envString),
 	    Tcl_DStringLength(&envString)+1);
     Tcl_DStringFree(&envString);
 
     putenv(string);
@@ -483,11 +484,11 @@
     } else {
 	/*
 	 * This putenv() copies instead of taking ownership.
 	 */
 
-	Tcl_Free(string);
+	ckfree(string);
 #endif /* HAVE_PUTENV_THAT_COPIES */
     }
 #else /* !USE_PUTENV_FOR_UNSET */
     for (envPtr = environ+index+1; ; envPtr++) {
 	envPtr[-1] = *envPtr;
@@ -527,17 +528,17 @@
 				 * (UTF-8). */
     Tcl_DString *valuePtr)	/* Uninitialized or free DString in which the
 				 * value of the environment variable is
 				 * stored. */
 {
-    size_t length, index;
+    int length, index;
     const char *result;
 
     Tcl_MutexLock(&envMutex);
     index = TclpFindVariable(name, &length);
     result = NULL;
-    if (index != TCL_AUTO_LENGTH) {
+    if (index != -1) {
 	Tcl_DString envStr;
 
 	result = Tcl_ExternalToUtfDString(NULL, environ[index], -1, &envStr);
 	result += length;
 	if (*result == '=') {
@@ -660,11 +661,11 @@
 static void
 ReplaceString(
     const char *oldStr,		/* Old environment string. */
     char *newStr)		/* New environment string. */
 {
-    size_t i;
+    int i;
 
     /*
      * Check to see if the old value was allocated by Tcl. If so, it needs to
      * be deallocated to avoid memory leaks. Note that this algorithm is O(n),
      * not O(1). This will result in n-squared behavior if lots of environment
@@ -680,11 +681,11 @@
 	/*
 	 * Replace or delete the old value.
 	 */
 
 	if (env.cache[i]) {
-	    Tcl_Free(env.cache[i]);
+	    ckfree(env.cache[i]);
 	}
 
 	if (newStr) {
 	    env.cache[i] = newStr;
 	} else {
@@ -698,15 +699,15 @@
 	 * We need to grow the cache in order to hold the new string.
 	 */
 
 	const int growth = 5;
 
-	env.cache = Tcl_Realloc(env.cache,
+	env.cache = ckrealloc(env.cache,
 		(env.cacheSize + growth) * sizeof(char *));
 	env.cache[env.cacheSize] = newStr;
 	(void) memset(env.cache+env.cacheSize+1, 0,
-		(growth-1) * sizeof(char *));
+		(size_t) (growth-1) * sizeof(char *));
 	env.cacheSize += growth;
     }
 }
 
 /*
@@ -741,19 +742,19 @@
 
     if (env.cache) {
 #ifdef PURIFY
 	int i;
 	for (i = 0; i < env.cacheSize; i++) {
-	    Tcl_Free(env.cache[i]);
+	    ckfree(env.cache[i]);
 	}
 #endif
-	Tcl_Free(env.cache);
+	ckfree(env.cache);
 	env.cache = NULL;
 	env.cacheSize = 0;
 #ifndef USE_PUTENV
 	if ((env.ourEnviron != NULL)) {
-	    Tcl_Free(env.ourEnviron);
+	    ckfree(env.ourEnviron);
 	    env.ourEnviron = NULL;
 	}
 	env.ourEnvironSize = 0;
 #endif
     }

Index: generic/tclEvent.c
==================================================================
--- generic/tclEvent.c
+++ generic/tclEvent.c
@@ -122,11 +122,11 @@
 static void		FinalizeThread(int quick);
 
 /*
  *----------------------------------------------------------------------
  *
- * Tcl_BackgroundException --
+ * Tcl_BackgroundError --
  *
  *	This function is invoked to handle errors that occur in Tcl commands
  *	that are invoked in "background" (e.g. from event or timer bindings).
  *
  * Results:
@@ -137,10 +137,21 @@
  *	error, passing it the interp result and return options.
  *
  *----------------------------------------------------------------------
  */
 
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+#undef Tcl_BackgroundError
+void
+Tcl_BackgroundError(
+    Tcl_Interp *interp)		/* Interpreter in which an error has
+				 * occurred. */
+{
+    Tcl_BackgroundException(interp, TCL_ERROR);
+}
+#endif /* TCL_NO_DEPRECATED */
+
 void
 Tcl_BackgroundException(
     Tcl_Interp *interp,		/* Interpreter in which an exception has
 				 * occurred. */
     int code)			/* The exception code value */
@@ -150,11 +161,11 @@
 
     if (code == TCL_OK) {
 	return;
     }
 
-    errPtr = Tcl_Alloc(sizeof(BgError));
+    errPtr = ckalloc(sizeof(BgError));
     errPtr->errorMsg = Tcl_GetObjResult(interp);
     Tcl_IncrRefCount(errPtr->errorMsg);
     errPtr->returnOpts = Tcl_GetReturnOptions(interp, code);
     Tcl_IncrRefCount(errPtr->returnOpts);
     errPtr->nextPtr = NULL;
@@ -217,11 +228,11 @@
 	Tcl_Obj *copyObj = TclListObjCopy(NULL, assocPtr->cmdPrefix);
 
 	errPtr = assocPtr->firstBgPtr;
 
 	Tcl_ListObjGetElements(NULL, copyObj, &prefixObjc, &prefixObjv);
-	tempObjv = Tcl_Alloc((prefixObjc+2) * sizeof(Tcl_Obj *));
+	tempObjv = ckalloc((prefixObjc+2) * sizeof(Tcl_Obj *));
 	memcpy(tempObjv, prefixObjv, prefixObjc*sizeof(Tcl_Obj *));
 	tempObjv[prefixObjc] = errPtr->errorMsg;
 	tempObjv[prefixObjc+1] = errPtr->returnOpts;
 	Tcl_AllowExceptions(interp);
 	code = Tcl_EvalObjv(interp, prefixObjc+2, tempObjv, TCL_EVAL_GLOBAL);
@@ -232,12 +243,12 @@
 
 	Tcl_DecrRefCount(copyObj);
 	Tcl_DecrRefCount(errPtr->errorMsg);
 	Tcl_DecrRefCount(errPtr->returnOpts);
 	assocPtr->firstBgPtr = errPtr->nextPtr;
-	Tcl_Free(errPtr);
-	Tcl_Free(tempObjv);
+	ckfree(errPtr);
+	ckfree(tempObjv);
 
 	if (code == TCL_BREAK) {
 	    /*
 	     * Break means cancel any remaining error reports for this
 	     * interpreter.
@@ -246,11 +257,11 @@
 	    while (assocPtr->firstBgPtr != NULL) {
 		errPtr = assocPtr->firstBgPtr;
 		assocPtr->firstBgPtr = errPtr->nextPtr;
 		Tcl_DecrRefCount(errPtr->errorMsg);
 		Tcl_DecrRefCount(errPtr->returnOpts);
-		Tcl_Free(errPtr);
+		ckfree(errPtr);
 	    }
 	} else if ((code == TCL_ERROR) && !Tcl_IsSafe(interp)) {
 	    Tcl_Channel errChannel = Tcl_GetStdChannel(TCL_STDERR);
 
 	    if (errChannel != NULL) {
@@ -515,11 +526,11 @@
     if (assocPtr == NULL) {
 	/*
 	 * First access: initialize.
 	 */
 
-	assocPtr = Tcl_Alloc(sizeof(ErrAssocData));
+	assocPtr = ckalloc(sizeof(ErrAssocData));
 	assocPtr->interp = interp;
 	assocPtr->cmdPrefix = NULL;
 	assocPtr->firstBgPtr = NULL;
 	assocPtr->lastBgPtr = NULL;
 	Tcl_SetAssocData(interp, "tclBgError", BgErrorDeleteProc, assocPtr);
@@ -594,11 +605,11 @@
     while (assocPtr->firstBgPtr != NULL) {
 	errPtr = assocPtr->firstBgPtr;
 	assocPtr->firstBgPtr = errPtr->nextPtr;
 	Tcl_DecrRefCount(errPtr->errorMsg);
 	Tcl_DecrRefCount(errPtr->returnOpts);
-	Tcl_Free(errPtr);
+	ckfree(errPtr);
     }
     Tcl_CancelIdleCall(HandleBgErrors, assocPtr);
     Tcl_DecrRefCount(assocPtr->cmdPrefix);
     Tcl_EventuallyFree(assocPtr, TCL_DYNAMIC);
 }
@@ -624,11 +635,11 @@
 void
 Tcl_CreateExitHandler(
     Tcl_ExitProc *proc,		/* Function to invoke. */
     ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
-    ExitHandler *exitPtr = Tcl_Alloc(sizeof(ExitHandler));
+    ExitHandler *exitPtr = ckalloc(sizeof(ExitHandler));
 
     exitPtr->proc = proc;
     exitPtr->clientData = clientData;
     Tcl_MutexLock(&exitMutex);
     exitPtr->nextPtr = firstExitPtr;
@@ -657,11 +668,11 @@
 void
 TclCreateLateExitHandler(
     Tcl_ExitProc *proc,		/* Function to invoke. */
     ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
-    ExitHandler *exitPtr = Tcl_Alloc(sizeof(ExitHandler));
+    ExitHandler *exitPtr = ckalloc(sizeof(ExitHandler));
 
     exitPtr->proc = proc;
     exitPtr->clientData = clientData;
     Tcl_MutexLock(&exitMutex);
     exitPtr->nextPtr = firstLateExitPtr;
@@ -702,11 +713,11 @@
 	    if (prevPtr == NULL) {
 		firstExitPtr = exitPtr->nextPtr;
 	    } else {
 		prevPtr->nextPtr = exitPtr->nextPtr;
 	    }
-	    Tcl_Free(exitPtr);
+	    ckfree(exitPtr);
 	    break;
 	}
     }
     Tcl_MutexUnlock(&exitMutex);
     return;
@@ -745,11 +756,11 @@
 	    if (prevPtr == NULL) {
 		firstLateExitPtr = exitPtr->nextPtr;
 	    } else {
 		prevPtr->nextPtr = exitPtr->nextPtr;
 	    }
-	    Tcl_Free(exitPtr);
+	    ckfree(exitPtr);
 	    break;
 	}
     }
     Tcl_MutexUnlock(&exitMutex);
     return;
@@ -779,11 +790,11 @@
     ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
     ExitHandler *exitPtr;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
-    exitPtr = Tcl_Alloc(sizeof(ExitHandler));
+    exitPtr = ckalloc(sizeof(ExitHandler));
     exitPtr->proc = proc;
     exitPtr->clientData = clientData;
     exitPtr->nextPtr = tsdPtr->firstExitPtr;
     tsdPtr->firstExitPtr = exitPtr;
 }
@@ -821,11 +832,11 @@
 	    if (prevPtr == NULL) {
 		tsdPtr->firstExitPtr = exitPtr->nextPtr;
 	    } else {
 		prevPtr->nextPtr = exitPtr->nextPtr;
 	    }
-	    Tcl_Free(exitPtr);
+	    ckfree(exitPtr);
 	    return;
 	}
     }
 }
 
@@ -899,11 +910,11 @@
 	 */
 
 	firstExitPtr = exitPtr->nextPtr;
 	Tcl_MutexUnlock(&exitMutex);
 	exitPtr->proc(exitPtr->clientData);
-	Tcl_Free(exitPtr);
+	ckfree(exitPtr);
 	Tcl_MutexLock(&exitMutex);
     }
     firstExitPtr = NULL;
     Tcl_MutexUnlock(&exitMutex);
 }
@@ -989,11 +1000,11 @@
 }
 
 /*
  *-------------------------------------------------------------------------
  *
- * TclInitSubsystems --
+ * Tcl_InitSubsystems --
  *
  *	Initialize various subsytems in Tcl. This should be called the first
  *	time an interp is created, or before any of the subsystems are used.
  *	This function ensures an order for the initialization of subsystems:
  *
@@ -1012,14 +1023,14 @@
  *
  *-------------------------------------------------------------------------
  */
 
 void
-TclInitSubsystems(void)
+Tcl_InitSubsystems(void)
 {
     if (inExit != 0) {
-	Tcl_Panic("TclInitSubsystems called while exiting");
+	Tcl_Panic("Tcl_InitSubsystems called while exiting");
     }
 
     if (subsystemsInitialized == 0) {
 	/*
 	 * Double check inside the mutex. There are definitly calls back into
@@ -1127,11 +1138,11 @@
 	 */
 
 	firstLateExitPtr = exitPtr->nextPtr;
 	Tcl_MutexUnlock(&exitMutex);
 	exitPtr->proc(exitPtr->clientData);
-	Tcl_Free(exitPtr);
+	ckfree(exitPtr);
 	Tcl_MutexLock(&exitMutex);
     }
     firstLateExitPtr = NULL;
     Tcl_MutexUnlock(&exitMutex);
 
@@ -1238,11 +1249,11 @@
 
     TclFinalizeLoad();
     TclResetFilesystem();
 
     /*
-     * At this point, there should no longer be any Tcl_Alloc'ed memory.
+     * At this point, there should no longer be any ckalloc'ed memory.
      */
 
     TclFinalizeMemorySubsystem();
 
   alreadyFinalized:
@@ -1297,11 +1308,11 @@
 	     * callback should call Tcl_DeleteThreadExitHandler on itself.
 	     */
 
 	    tsdPtr->firstExitPtr = exitPtr->nextPtr;
 	    exitPtr->proc(exitPtr->clientData);
-	    Tcl_Free(exitPtr);
+	    ckfree(exitPtr);
 	}
 	TclFinalizeIOSubsystem();
 	TclFinalizeNotifier();
 	TclFinalizeAsync();
 	TclFinalizeThreadObjects();
@@ -1398,11 +1409,11 @@
 
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "name");
 	return TCL_ERROR;
     }
-    nameString = TclGetString(objv[1]);
+    nameString = Tcl_GetString(objv[1]);
     if (Tcl_TraceVar2(interp, nameString, NULL,
 	    TCL_GLOBAL_ONLY|TCL_TRACE_WRITES|TCL_TRACE_UNSETS,
 	    VwaitVarProc, &done) != TCL_OK) {
 	return TCL_ERROR;
     };
@@ -1560,11 +1571,11 @@
     ClientData threadClientData;
     Tcl_ThreadCreateProc *threadProc;
 
     threadProc = cdPtr->proc;
     threadClientData = cdPtr->clientData;
-    Tcl_Free(clientData);		/* Allocated in Tcl_CreateThread() */
+    ckfree(clientData);		/* Allocated in Tcl_CreateThread() */
 
     threadProc(threadClientData);
 
     TCL_THREAD_CREATE_RETURN;
 }
@@ -1592,23 +1603,23 @@
 int
 Tcl_CreateThread(
     Tcl_ThreadId *idPtr,	/* Return, the ID of the thread */
     Tcl_ThreadCreateProc *proc,	/* Main() function of the thread */
     ClientData clientData,	/* The one argument to Main() */
-    size_t stackSize,		/* Size of stack for the new thread */
+    int stackSize,		/* Size of stack for the new thread */
     int flags)			/* Flags controlling behaviour of the new
 				 * thread. */
 {
 #if TCL_THREADS
-    ThreadClientData *cdPtr = Tcl_Alloc(sizeof(ThreadClientData));
+    ThreadClientData *cdPtr = ckalloc(sizeof(ThreadClientData));
     int result;
 
     cdPtr->proc = proc;
     cdPtr->clientData = clientData;
     result = TclpThreadCreate(idPtr, NewThreadProc, cdPtr, stackSize, flags);
     if (result != TCL_OK) {
-	Tcl_Free(cdPtr);
+	ckfree(cdPtr);
     }
     return result;
 #else
     return TCL_ERROR;
 #endif /* TCL_THREADS */

Index: generic/tclExecute.c
==================================================================
--- generic/tclExecute.c
+++ generic/tclExecute.c
@@ -71,15 +71,15 @@
  * Mapping from expression instruction opcodes to strings; used for error
  * messages. Note that these entries must match the order and number of the
  * expression opcodes (e.g., INST_LOR) in tclCompile.h.
  *
  * Does not include the string for INST_EXPON (and beyond), as that is
- * disjoint for backward-compatibility reasons.
+ * disjoint for backward-compatability reasons.
  */
 
 static const char *const operatorStrings[] = {
-    "|", "^", "&", "==", "!=", "<", ">", "<=", ">=", "<<", ">>",
+    "||", "&&", "|", "^", "&", "==", "!=", "<", ">", "<=", ">=", "<<", ">>",
     "+", "-", "*", "/", "%", "+", "-", "~", "!"
 };
 
 /*
  * Mapping from Tcl result codes to strings; used for error and debugging
@@ -99,18 +99,76 @@
 #ifdef TCL_COMPILE_STATS
 size_t		tclObjsAlloced = 0;
 size_t		tclObjsFreed = 0;
 size_t		tclObjsShared[TCL_MAX_SHARED_OBJ_STATS] = { 0, 0, 0, 0, 0 };
 #endif /* TCL_COMPILE_STATS */
+
+/*
+ * Support pre-8.5 bytecodes unless specifically requested otherwise.
+ */
+
+#ifndef TCL_SUPPORT_84_BYTECODE
+#define TCL_SUPPORT_84_BYTECODE 1
+#endif
+
+#if TCL_SUPPORT_84_BYTECODE
+/*
+ * We need to know the tclBuiltinFuncTable to support translation of pre-8.5
+ * math functions to the namespace-based ::tcl::mathfunc::op in 8.5+.
+ */
+
+typedef struct {
+    const char *name;		/* Name of function. */
+    int numArgs;		/* Number of arguments for function. */
+} BuiltinFunc;
+
+/*
+ * Table describing the built-in math functions. Entries in this table are
+ * indexed by the values of the INST_CALL_BUILTIN_FUNC instruction's
+ * operand byte.
+ */
+
+static BuiltinFunc const tclBuiltinFuncTable[] = {
+    {"acos", 1},
+    {"asin", 1},
+    {"atan", 1},
+    {"atan2", 2},
+    {"ceil", 1},
+    {"cos", 1},
+    {"cosh", 1},
+    {"exp", 1},
+    {"floor", 1},
+    {"fmod", 2},
+    {"hypot", 2},
+    {"log", 1},
+    {"log10", 1},
+    {"pow", 2},
+    {"sin", 1},
+    {"sinh", 1},
+    {"sqrt", 1},
+    {"tan", 1},
+    {"tanh", 1},
+    {"abs", 1},
+    {"double", 1},
+    {"int", 1},
+    {"rand", 0},
+    {"round", 1},
+    {"srand", 1},
+    {"wide", 1},
+    {NULL, 0},
+};
+
+#define LAST_BUILTIN_FUNC	25
+#endif
 
 /*
  * NR_TEBC
  * Helpers for NR - non-recursive calls to TEBC
  * Minimal data required to fully reconstruct the execution state.
  */
 
-typedef struct {
+typedef struct TEBCdata {
     ByteCode *codePtr;		/* Constant until the BC returns */
 				/* -----------------------------------------*/
     ptrdiff_t *catchTop;	/* These fields are used on return TO this */
     Tcl_Obj *auxObjList;	/* this level: they record the state when a */
     CmdFrame cmdFrame;		/* new codePtr was received for NR */
@@ -441,17 +499,17 @@
  */
 
 #define GetNumberFromObj(interp, objPtr, ptrPtr, tPtr) \
     ((TclHasIntRep((objPtr), &tclIntType))					\
 	?	(*(tPtr) = TCL_NUMBER_INT,				\
-		*(ptrPtr) = (void *)				\
+		*(ptrPtr) = (ClientData)				\
 		    (&((objPtr)->internalRep.wideValue)), TCL_OK) :	\
     TclHasIntRep((objPtr), &tclDoubleType)				\
 	?	(((TclIsNaN((objPtr)->internalRep.doubleValue))		\
 		    ?	(*(tPtr) = TCL_NUMBER_NAN)			\
 		    :	(*(tPtr) = TCL_NUMBER_DOUBLE)),			\
-		*(ptrPtr) = (void *)				\
+		*(ptrPtr) = (ClientData)				\
 		    (&((objPtr)->internalRep.doubleValue)), TCL_OK) :	\
     (((objPtr)->bytes != NULL) && ((objPtr)->length == 0))		\
 	? TCL_ERROR :			\
     TclGetNumberFromObj((interp), (objPtr), (ptrPtr), (tPtr)))
 
@@ -623,22 +681,22 @@
 			    Tcl_Obj *valuePtr);
 static void		FreeExprCodeInternalRep(Tcl_Obj *objPtr);
 static ExceptionRange *	GetExceptRangeForPc(const unsigned char *pc,
 			    int searchMode, ByteCode *codePtr);
 static const char *	GetSrcInfoForPc(const unsigned char *pc,
-			    ByteCode *codePtr, size_t *lengthPtr,
+			    ByteCode *codePtr, int *lengthPtr,
 			    const unsigned char **pcBeg, int *cmdIdxPtr);
 static Tcl_Obj **	GrowEvaluationStack(ExecEnv *eePtr, int growth,
 			    int move);
 static void		IllegalExprOperandType(Tcl_Interp *interp,
 			    const unsigned char *pc, Tcl_Obj *opndPtr);
 static void		InitByteCodeExecution(Tcl_Interp *interp);
 static inline int	wordSkip(void *ptr);
 static void		ReleaseDictIterator(Tcl_Obj *objPtr);
 /* Useful elsewhere, make available in tclInt.h or stubs? */
-static Tcl_Obj **	StackAllocWords(Tcl_Interp *interp, size_t numWords);
-static Tcl_Obj **	StackReallocWords(Tcl_Interp *interp, size_t numWords);
+static Tcl_Obj **	StackAllocWords(Tcl_Interp *interp, int numWords);
+static Tcl_Obj **	StackReallocWords(Tcl_Interp *interp, int numWords);
 static Tcl_NRPostProc	CopyCallback;
 static Tcl_NRPostProc	ExprObjCallback;
 static Tcl_NRPostProc	FinalizeOONext;
 static Tcl_NRPostProc	FinalizeOONextFilter;
 static Tcl_NRPostProc   TEBCresume;
@@ -700,11 +758,11 @@
      * that we were holding.
      */
 
     searchPtr = irPtr->twoPtrValue.ptr1;
     Tcl_DictObjDone(searchPtr);
-    Tcl_Free(searchPtr);
+    ckfree(searchPtr);
 
     dictPtr = irPtr->twoPtrValue.ptr2;
     TclDecrRefCount(dictPtr);
 }
 
@@ -770,16 +828,16 @@
 
 ExecEnv *
 TclCreateExecEnv(
     Tcl_Interp *interp,		/* Interpreter for which the execution
 				 * environment is being created. */
-    size_t size)			/* The initial stack size, in number of words
+    int size)			/* The initial stack size, in number of words
 				 * [sizeof(Tcl_Obj*)] */
 {
-    ExecEnv *eePtr = Tcl_Alloc(sizeof(ExecEnv));
-    ExecStack *esPtr = Tcl_Alloc(sizeof(ExecStack)
-	    + (size-1) * sizeof(Tcl_Obj *));
+    ExecEnv *eePtr = ckalloc(sizeof(ExecEnv));
+    ExecStack *esPtr = ckalloc(sizeof(ExecStack)
+	    + (size_t) (size-1) * sizeof(Tcl_Obj *));
 
     eePtr->execStackPtr = esPtr;
     TclNewIntObj(eePtr->constants[0], 0);
     Tcl_IncrRefCount(eePtr->constants[0]);
     TclNewIntObj(eePtr->constants[1], 1);
@@ -834,11 +892,11 @@
 	esPtr->prevPtr->nextPtr = esPtr->nextPtr;
     }
     if (esPtr->nextPtr) {
 	esPtr->nextPtr->prevPtr = esPtr->prevPtr;
     }
-    Tcl_Free(esPtr);
+    ckfree(esPtr);
 }
 
 void
 TclDeleteExecEnv(
     ExecEnv *eePtr)		/* Execution environment to free. */
@@ -866,11 +924,11 @@
 	Tcl_Panic("Deleting execEnv with pending TEOV callbacks!");
     }
     if (eePtr->corPtr && !cachedInExit) {
 	Tcl_Panic("Deleting execEnv with existing coroutine");
     }
-    Tcl_Free(eePtr);
+    ckfree(eePtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -957,12 +1015,12 @@
     int growth,			/* How much larger than the current used
 				 * size. */
     int move)			/* 1 if move words since last marker. */
 {
     ExecStack *esPtr = eePtr->execStackPtr, *oldPtr = NULL;
-    size_t newBytes;
-    int newElems, currElems, needed = growth - (esPtr->endPtr - esPtr->tosPtr);
+    int newBytes, newElems, currElems;
+    int needed = growth - (esPtr->endPtr - esPtr->tosPtr);
     Tcl_Obj **markerPtr = esPtr->markerPtr, **memStart;
     int moveWords = 0;
 
     if (move) {
 	if (!markerPtr) {
@@ -1043,11 +1101,11 @@
 #endif
 
     newBytes = sizeof(ExecStack) + (newElems-1) * sizeof(Tcl_Obj *);
 
     oldPtr = esPtr;
-    esPtr = Tcl_Alloc(newBytes);
+    esPtr = ckalloc(newBytes);
 
     oldPtr->nextPtr = esPtr;
     esPtr->prevPtr = oldPtr;
     esPtr->nextPtr = NULL;
     esPtr->endPtr = &esPtr->stackWords[newElems-1];
@@ -1103,11 +1161,11 @@
  */
 
 static Tcl_Obj **
 StackAllocWords(
     Tcl_Interp *interp,
-    size_t numWords)
+    int numWords)
 {
     /*
      * Note that GrowEvaluationStack sets a marker in the stack. This marker
      * is read when rewinding, e.g., by TclStackFree.
      */
@@ -1121,11 +1179,11 @@
 }
 
 static Tcl_Obj **
 StackReallocWords(
     Tcl_Interp *interp,
-    size_t numWords)
+    int numWords)
 {
     Interp *iPtr = (Interp *) interp;
     ExecEnv *eePtr = iPtr->execEnvPtr;
     Tcl_Obj **resPtr = GrowEvaluationStack(eePtr, numWords, 1);
 
@@ -1142,11 +1200,11 @@
     ExecEnv *eePtr;
     ExecStack *esPtr;
     Tcl_Obj **markerPtr, *marker;
 
     if (iPtr == NULL || iPtr->execEnvPtr == NULL) {
-	Tcl_Free(freePtr);
+	ckfree(freePtr);
 	return;
     }
 
     /*
      * Rewind the stack to the previous marker position. The current marker,
@@ -1200,36 +1258,36 @@
 }
 
 void *
 TclStackAlloc(
     Tcl_Interp *interp,
-    size_t numBytes)
+    int numBytes)
 {
     Interp *iPtr = (Interp *) interp;
-    size_t numWords;
+    int numWords;
 
     if (iPtr == NULL || iPtr->execEnvPtr == NULL) {
-	return (void *) Tcl_Alloc(numBytes);
+	return (void *) ckalloc(numBytes);
     }
     numWords = (numBytes + (sizeof(Tcl_Obj *) - 1))/sizeof(Tcl_Obj *);
-    return StackAllocWords(interp, numWords);
+    return (void *) StackAllocWords(interp, numWords);
 }
 
 void *
 TclStackRealloc(
     Tcl_Interp *interp,
     void *ptr,
-    size_t numBytes)
+    int numBytes)
 {
     Interp *iPtr = (Interp *) interp;
     ExecEnv *eePtr;
     ExecStack *esPtr;
     Tcl_Obj **markerPtr;
-    size_t numWords;
+    int numWords;
 
     if (iPtr == NULL || iPtr->execEnvPtr == NULL) {
-	return Tcl_Realloc(ptr, numBytes);
+	return (void *) ckrealloc((char *) ptr, numBytes);
     }
 
     eePtr = iPtr->execEnvPtr;
     esPtr = eePtr->execStackPtr;
     markerPtr = esPtr->markerPtr;
@@ -1267,11 +1325,11 @@
 
 int
 Tcl_ExprObj(
     Tcl_Interp *interp,		/* Context in which to evaluate the
 				 * expression. */
-    Tcl_Obj *objPtr,		/* Points to Tcl object containing expression
+    Tcl_Obj *objPtr,	/* Points to Tcl object containing expression
 				 * to evaluate. */
     Tcl_Obj **resultPtrPtr)	/* Where the Tcl_Obj* that is the expression
 				 * result is stored if no errors occur. */
 {
     NRE_callback *rootPtr = TOP_CB(interp);
@@ -1413,15 +1471,14 @@
     if (codePtr == NULL) {
 	/*
 	 * TIP #280: No invoker (yet) - Expression compilation.
 	 */
 
-	size_t length;
-	const char *string = TclGetStringFromObj(objPtr, &length);
+	const char *string = TclGetString(objPtr);
 
-	TclInitCompileEnv(interp, &compEnv, string, length, NULL, 0);
-	TclCompileExpr(interp, string, length, &compEnv, 0);
+	TclInitCompileEnv(interp, &compEnv, string, objPtr->length, NULL, 0);
+	TclCompileExpr(interp, string, objPtr->length, &compEnv, 0);
 
 	/*
 	 * Successful compilation. If the expression yielded no instructions,
 	 * push an zero object as the expression's result.
 	 */
@@ -1922,11 +1979,18 @@
     /*
      * Push the callback for bytecode execution
      */
 
     TclNRAddCallback(interp, TEBCresume, TD, /* pc */ NULL,
-	    /* cleanup */ INT2PTR(0), NULL);
+	    /* cleanup */ INT2PTR(0), INT2PTR(iPtr->evalFlags));
+
+    /*
+     * Reset discard result flag - because it is applicable for this call only,
+     * and should not affect all the nested invocations may return result.
+     */
+    iPtr->evalFlags &= ~TCL_EVAL_DISCARD_RESULT;
+
     return TCL_OK;
 }
 
 static int
 TEBCresume(
@@ -1984,10 +2048,11 @@
 
     TEBCdata *TD = data[0];
 #define auxObjList	(TD->auxObjList)
 #define catchTop	(TD->catchTop)
 #define codePtr		(TD->codePtr)
+#define curEvalFlags	PTR2INT(data[3])  /* calling iPtr->evalFlags */
 
     /*
      * Globals: variables that store state, must remain valid at all times.
      */
 
@@ -2002,11 +2067,11 @@
      * executing an instruction.
      */
 
     int cleanup = PTR2INT(data[2]);
     Tcl_Obj *objResultPtr;
-    int checkInterp;            /* Indicates when a check of interp readyness
+    int checkInterp = 0;        /* Indicates when a check of interp readyness
 				 * is necessary. Set by CACHE_STACK_INFO() */
 
     /*
      * Locals - variables that are used within opcodes or bounded sections of
      * the file (jumps between opcodes within a family).
@@ -2037,11 +2102,10 @@
     }
 #endif
 
     if (!pc) {
 	/* bytecode is starting from scratch */
-	checkInterp = 0;
 	pc = codePtr->codeStart;
 	goto cleanup0;
     } else {
         /* resume from invocation */
 	CACHE_STACK_INFO();
@@ -2059,12 +2123,13 @@
 	if (iPtr->execEnvPtr->rewind) {
 	    result = TCL_ERROR;
 	    goto abnormalReturn;
 	}
 	if (codePtr->flags & TCL_BYTECODE_RECOMPILE) {
-	    iPtr->flags |= ERR_ALREADY_LOGGED;
 	    codePtr->flags &= ~TCL_BYTECODE_RECOMPILE;
+	    checkInterp = 1;
+	    iPtr->flags |= ERR_ALREADY_LOGGED;
 	}
 
 	if (result != TCL_OK) {
 	    pc--;
 	    goto processExceptionReturn;
@@ -2120,14 +2185,16 @@
 	cleanup -= 2;
 	while (cleanup--) {
 	    objPtr = POP_OBJECT();
 	    TclDecrRefCount(objPtr);
 	}
+	/* FALLTHRU */
     case 2:
     cleanup2_pushObjResultPtr:
 	objPtr = POP_OBJECT();
 	TclDecrRefCount(objPtr);
+	/* FALLTHRU */
     case 1:
     cleanup1_pushObjResultPtr:
 	objPtr = OBJ_AT_TOS;
 	TclDecrRefCount(objPtr);
     }
@@ -2140,18 +2207,21 @@
 	cleanup -= 2;
 	while (cleanup--) {
 	    objPtr = POP_OBJECT();
 	    TclDecrRefCount(objPtr);
 	}
+	/* FALLTHRU */
     case 2:
     cleanup2:
 	objPtr = POP_OBJECT();
 	TclDecrRefCount(objPtr);
+	/* FALLTHRU */
     case 1:
     cleanup1:
 	objPtr = POP_OBJECT();
 	TclDecrRefCount(objPtr);
+	/* FALLTHRU */
     case 0:
 	/*
 	 * We really want to do nothing now, but this is needed for some
 	 * compilers (SunPro CC).
 	 */
@@ -2235,16 +2305,16 @@
 	 * Peephole: do not run INST_START_CMD, just skip it
 	 */
 
 	iPtr->cmdCount += TclGetUInt4AtPtr(pc+5);
 	if (checkInterp) {
-	    checkInterp = 0;
 	    if (((codePtr->compileEpoch != iPtr->compileEpoch) ||
 		 (codePtr->nsEpoch != iPtr->varFramePtr->nsPtr->resolverEpoch)) &&
 		!(codePtr->flags & TCL_BYTECODE_PRECOMPILED)) {
 		goto instStartCmdFailed;
 	    }
+	    checkInterp = 0;
 	}
 	inst = *(pc += 9);
 	goto peepholeStart;
     } else if (inst == INST_NOP) {
 #ifndef TCL_COMPILE_DEBUG
@@ -2467,10 +2537,18 @@
 	goto processExceptionReturn;
     }
 
     case INST_DONE:
 	if (tosPtr > initTosPtr) {
+
+	    if ((curEvalFlags & TCL_EVAL_DISCARD_RESULT) && (result == TCL_OK)) {
+		/* simulate pop & fast done (like it does continue in loop) */
+		TRACE_WITH_OBJ(("=> discarding "), OBJ_AT_TOS);
+		objPtr = POP_OBJECT();
+		TclDecrRefCount(objPtr);
+		goto abnormalReturn;
+	    }
 	    /*
 	     * Set the interpreter's object result to point to the topmost
 	     * object from the stack, and check for a possible [catch]. The
 	     * stackTop's level and refCount will be handled by "processCatch"
 	     * or "abnormalReturn".
@@ -2556,11 +2634,11 @@
 	 * Push an element to the auxObjList. This records the current
 	 * stack depth - i.e., the point in the stack where the expanded
 	 * command starts.
 	 *
 	 * Use a Tcl_Obj as linked list element; slight mem waste, but faster
-	 * allocation than Tcl_Alloc. This also abuses the Tcl_Obj structure, as
+	 * allocation than ckalloc. This also abuses the Tcl_Obj structure, as
 	 * we do not define a special tclObjType for it. It is not dangerous
 	 * as the obj is never passed anywhere, so that all manipulations are
 	 * performed here and in INST_INVOKE_EXPANDED (in case of an expansion
 	 * error, also in INST_EXPAND_STKTOP).
 	 */
@@ -2666,19 +2744,22 @@
 
 	/*
 	 * INVOCATION BLOCK
 	 */
 
-    instEvalStk:
     case INST_EVAL_STK:
+    instEvalStk:
 	bcFramePtr->data.tebc.pc = (char *) pc;
 	iPtr->cmdFramePtr = bcFramePtr;
 
 	cleanup = 1;
 	pc += 1;
+	/* yield next instruction */
 	TEBC_YIELD();
-	return TclNREvalObjEx(interp, OBJ_AT_TOS, 0, NULL, 0);
+	/* add TEBCResume for object at top of stack */
+	return TclNRExecuteByteCode(interp,
+		    TclCompileObj(interp, OBJ_AT_TOS, NULL, 0));
 
     case INST_INVOKE_EXPANDED:
 	CLANG_ASSERT(auxObjList);
 	objc = CURR_DEPTH - PTR2INT(auxObjList->internalRep.twoPtrValue.ptr2);
 	POP_TAUX_OBJ();
@@ -2745,10 +2826,95 @@
 
 	pc += pcAdjustment;
 	TEBC_YIELD();
 	return TclNREvalObjv(interp, objc, objv,
 		TCL_EVAL_NOERR | TCL_EVAL_SOURCE_IN_FRAME, NULL);
+
+#if TCL_SUPPORT_84_BYTECODE
+    case INST_CALL_BUILTIN_FUNC1:
+	/*
+	 * Call one of the built-in pre-8.5 Tcl math functions. This
+	 * translates to INST_INVOKE_STK1 with the first argument of
+	 * ::tcl::mathfunc::$objv[0]. We need to insert the named math
+	 * function into the stack.
+	 */
+
+	opnd = TclGetUInt1AtPtr(pc+1);
+	if ((opnd < 0) || (opnd > LAST_BUILTIN_FUNC)) {
+	    TRACE(("UNRECOGNIZED BUILTIN FUNC CODE %d\n", opnd));
+	    Tcl_Panic("TclNRExecuteByteCode: unrecognized builtin function code %d", opnd);
+	}
+
+	TclNewLiteralStringObj(objPtr, "::tcl::mathfunc::");
+	Tcl_AppendToObj(objPtr, tclBuiltinFuncTable[opnd].name, -1);
+
+	/*
+	 * Only 0, 1 or 2 args.
+	 */
+
+	{
+	    int numArgs = tclBuiltinFuncTable[opnd].numArgs;
+	    Tcl_Obj *tmpPtr1, *tmpPtr2;
+
+	    if (numArgs == 0) {
+		PUSH_OBJECT(objPtr);
+	    } else if (numArgs == 1) {
+		tmpPtr1 = POP_OBJECT();
+		PUSH_OBJECT(objPtr);
+		PUSH_OBJECT(tmpPtr1);
+		Tcl_DecrRefCount(tmpPtr1);
+	    } else {
+		tmpPtr2 = POP_OBJECT();
+		tmpPtr1 = POP_OBJECT();
+		PUSH_OBJECT(objPtr);
+		PUSH_OBJECT(tmpPtr1);
+		PUSH_OBJECT(tmpPtr2);
+		Tcl_DecrRefCount(tmpPtr1);
+		Tcl_DecrRefCount(tmpPtr2);
+	    }
+	    objc = numArgs + 1;
+	}
+	pcAdjustment = 2;
+	goto doInvocation;
+
+    case INST_CALL_FUNC1:
+	/*
+	 * Call a non-builtin Tcl math function previously registered by a
+	 * call to Tcl_CreateMathFunc pre-8.5. This is essentially
+	 * INST_INVOKE_STK1 converting the first arg to
+	 * ::tcl::mathfunc::$objv[0].
+	 */
+
+	objc = TclGetUInt1AtPtr(pc+1);	/* Number of arguments. The function
+					 * name is the 0-th argument. */
+
+	objPtr = OBJ_AT_DEPTH(objc-1);
+	TclNewLiteralStringObj(tmpPtr, "::tcl::mathfunc::");
+	Tcl_AppendObjToObj(tmpPtr, objPtr);
+	Tcl_DecrRefCount(objPtr);
+
+	/*
+	 * Variation of PUSH_OBJECT.
+	 */
+
+	OBJ_AT_DEPTH(objc-1) = tmpPtr;
+	Tcl_IncrRefCount(tmpPtr);
+
+	pcAdjustment = 2;
+	goto doInvocation;
+#else
+    /*
+     * INST_CALL_BUILTIN_FUNC1 and INST_CALL_FUNC1 were made obsolete by the
+     * changes to add a ::tcl::mathfunc namespace in 8.5. Optional support
+     * remains for existing bytecode precompiled files.
+     */
+
+    case INST_CALL_BUILTIN_FUNC1:
+	Tcl_Panic("TclNRExecuteByteCode: obsolete INST_CALL_BUILTIN_FUNC1 found");
+    case INST_CALL_FUNC1:
+	Tcl_Panic("TclNRExecuteByteCode: obsolete INST_CALL_FUNC1 found");
+#endif
 
     case INST_INVOKE_REPLACE:
 	objc = TclGetUInt4AtPtr(pc+1);
 	opnd = TclGetUInt1AtPtr(pc+5);
 	objPtr = POP_OBJECT();
@@ -3566,11 +3732,11 @@
 	    varPtr = varPtr->value.linkPtr;
 	}
 	arrayPtr = NULL;
 	part1Ptr = part2Ptr = NULL;
 	cleanup = 0;
-	TRACE(("%u %s => ", opnd, TclGetString(incrPtr)));
+	TRACE(("%u %s => ", opnd, Tcl_GetString(incrPtr)));
 
     doIncrVar:
 	if (TclIsVarDirectModifyable2(varPtr, arrayPtr)) {
 	    objPtr = varPtr->value.objPtr;
 	    if (Tcl_IsShared(objPtr)) {
@@ -3833,10 +3999,33 @@
 
     errorInUnset:
 	CACHE_STACK_INFO();
 	TRACE_ERROR(interp);
 	goto gotError;
+
+	/*
+	 * This is really an unset operation these days. Do not issue.
+	 */
+
+    case INST_DICT_DONE:
+	opnd = TclGetUInt4AtPtr(pc+1);
+	TRACE(("%u => OK\n", opnd));
+	varPtr = LOCAL(opnd);
+	while (TclIsVarLink(varPtr)) {
+	    varPtr = varPtr->value.linkPtr;
+	}
+	if (TclIsVarDirectUnsettable(varPtr) && !TclIsVarInHash(varPtr)) {
+	    if (!TclIsVarUndefined(varPtr)) {
+		TclDecrRefCount(varPtr->value.objPtr);
+	    }
+	    varPtr->value.objPtr = NULL;
+	} else {
+	    DECACHE_STACK_INFO();
+	    TclPtrUnsetVarIdx(interp, varPtr, NULL, NULL, NULL, 0, opnd);
+	    CACHE_STACK_INFO();
+	}
+	NEXT_INST_F(5, 0, 0);
     }
 
     /*
      *	   End of INST_UNSET instructions.
      * -----------------------------------------------------------------
@@ -4149,10 +4338,54 @@
 	} else {
 	    TRACE_APPEND(("not found in table\n"));
 	    NEXT_INST_F(5, 1, 0);
 	}
     }
+
+    /*
+     * These two instructions are now redundant: the complete logic of the LOR
+     * and LAND is now handled by the expression compiler.
+     */
+
+    case INST_LOR:
+    case INST_LAND: {
+	/*
+	 * Operands must be boolean or numeric. No int->double conversions are
+	 * performed.
+	 */
+
+	int i1, i2, iResult;
+
+	value2Ptr = OBJ_AT_TOS;
+	valuePtr = OBJ_UNDER_TOS;
+	if (TclGetBooleanFromObj(NULL, valuePtr, &i1) != TCL_OK) {
+	    TRACE(("\"%.20s\" => ILLEGAL TYPE %s \n", O2S(valuePtr),
+		    (valuePtr->typePtr? valuePtr->typePtr->name : "null")));
+	    DECACHE_STACK_INFO();
+	    IllegalExprOperandType(interp, pc, valuePtr);
+	    CACHE_STACK_INFO();
+	    goto gotError;
+	}
+
+	if (TclGetBooleanFromObj(NULL, value2Ptr, &i2) != TCL_OK) {
+	    TRACE(("\"%.20s\" => ILLEGAL TYPE %s \n", O2S(value2Ptr),
+		    (value2Ptr->typePtr? value2Ptr->typePtr->name : "null")));
+	    DECACHE_STACK_INFO();
+	    IllegalExprOperandType(interp, pc, value2Ptr);
+	    CACHE_STACK_INFO();
+	    goto gotError;
+	}
+
+	if (*pc == INST_LOR) {
+	    iResult = (i1 || i2);
+	} else {
+	    iResult = (i1 && i2);
+	}
+	objResultPtr = TCONST(iResult);
+	TRACE(("%.20s %.20s => %d\n", O2S(valuePtr),O2S(value2Ptr),iResult));
+	NEXT_INST_F(1, 2, 1);
+    }
 
     /*
      * -----------------------------------------------------------------
      *	   Start of general introspector instructions.
      */
@@ -4527,12 +4760,12 @@
      * -----------------------------------------------------------------
      *	   Start of INST_LIST and related instructions.
      */
 
     {
-	int numIndices, nocase, match, cflags;
-	size_t slength, length2, fromIdx, toIdx, index, s1len, s2len;
+	int index, numIndices, fromIdx, toIdx;
+	int nocase, match, length2, cflags, s1len, s2len;
 	const char *s1, *s2;
 
     case INST_LIST:
 	/*
 	 * Pop the opnd (objc) top stack elements into a new list obj and then
@@ -4611,11 +4844,11 @@
 
 	index = TclIndexDecode(opnd, objc - 1);
 	pcAdjustment = 5;
 
     lindexFastPath:
-	if (index < (size_t)objc) {
+	if (index >= 0 && index < objc) {
 	    objResultPtr = objv[index];
 	} else {
 	    TclNewObj(objResultPtr);
 	}
 
@@ -4774,17 +5007,17 @@
 	    objResultPtr = Tcl_NewObj();
 	    TRACE_APPEND(("\"%.30s\"", O2S(objResultPtr)));
 	    NEXT_INST_F(9, 1, 1);
 	}
 	toIdx = TclIndexDecode(toIdx, objc - 1);
-	if (toIdx == TCL_INDEX_NONE) {
+	if (toIdx < 0) {
 	    goto emptyList;
-	} else if (toIdx + 1 >= (size_t)objc + 1) {
+	} else if (toIdx >= objc) {
 	    toIdx = objc - 1;
 	}
 
-	assert (toIdx < (size_t)objc);
+	assert ( toIdx >= 0 && toIdx < objc);
 	/*
 	assert ( fromIdx != TCL_INDEX_NONE );
 	 *
 	 * Extra safety for legacy bytecodes:
 	 */
@@ -4936,62 +5169,62 @@
 		(match < 0 ? -1 : match > 0 ? 1 : 0)));
 	JUMP_PEEPHOLE_F(match, 1, 2);
 
     case INST_STR_LEN:
 	valuePtr = OBJ_AT_TOS;
-	slength = Tcl_GetCharLength(valuePtr);
-	objResultPtr = TclNewWideIntObjFromSize(slength);
-	TRACE(("\"%.20s\" => %" TCL_Z_MODIFIER "u\n", O2S(valuePtr), slength));
+	length = Tcl_GetCharLength(valuePtr);
+	TclNewIntObj(objResultPtr, length);
+	TRACE(("\"%.20s\" => %d\n", O2S(valuePtr), length));
 	NEXT_INST_F(1, 1, 1);
 
     case INST_STR_UPPER:
 	valuePtr = OBJ_AT_TOS;
 	TRACE(("\"%.20s\" => ", O2S(valuePtr)));
 	if (Tcl_IsShared(valuePtr)) {
-	    s1 = TclGetStringFromObj(valuePtr, &slength);
-	    TclNewStringObj(objResultPtr, s1, slength);
-	    slength = Tcl_UtfToUpper(TclGetString(objResultPtr));
-	    Tcl_SetObjLength(objResultPtr, slength);
+	    s1 = TclGetStringFromObj(valuePtr, &length);
+	    TclNewStringObj(objResultPtr, s1, length);
+	    length = Tcl_UtfToUpper(TclGetString(objResultPtr));
+	    Tcl_SetObjLength(objResultPtr, length);
 	    TRACE_APPEND(("\"%.20s\"\n", O2S(objResultPtr)));
 	    NEXT_INST_F(1, 1, 1);
 	} else {
-	    slength = Tcl_UtfToUpper(TclGetString(valuePtr));
-	    Tcl_SetObjLength(valuePtr, slength);
+	    length = Tcl_UtfToUpper(TclGetString(valuePtr));
+	    Tcl_SetObjLength(valuePtr, length);
 	    TclFreeIntRep(valuePtr);
 	    TRACE_APPEND(("\"%.20s\"\n", O2S(valuePtr)));
 	    NEXT_INST_F(1, 0, 0);
 	}
     case INST_STR_LOWER:
 	valuePtr = OBJ_AT_TOS;
 	TRACE(("\"%.20s\" => ", O2S(valuePtr)));
 	if (Tcl_IsShared(valuePtr)) {
-	    s1 = TclGetStringFromObj(valuePtr, &slength);
-	    TclNewStringObj(objResultPtr, s1, slength);
-	    slength = Tcl_UtfToLower(TclGetString(objResultPtr));
-	    Tcl_SetObjLength(objResultPtr, slength);
+	    s1 = TclGetStringFromObj(valuePtr, &length);
+	    TclNewStringObj(objResultPtr, s1, length);
+	    length = Tcl_UtfToLower(TclGetString(objResultPtr));
+	    Tcl_SetObjLength(objResultPtr, length);
 	    TRACE_APPEND(("\"%.20s\"\n", O2S(objResultPtr)));
 	    NEXT_INST_F(1, 1, 1);
 	} else {
-	    slength = Tcl_UtfToLower(TclGetString(valuePtr));
-	    Tcl_SetObjLength(valuePtr, slength);
+	    length = Tcl_UtfToLower(TclGetString(valuePtr));
+	    Tcl_SetObjLength(valuePtr, length);
 	    TclFreeIntRep(valuePtr);
 	    TRACE_APPEND(("\"%.20s\"\n", O2S(valuePtr)));
 	    NEXT_INST_F(1, 0, 0);
 	}
     case INST_STR_TITLE:
 	valuePtr = OBJ_AT_TOS;
 	TRACE(("\"%.20s\" => ", O2S(valuePtr)));
 	if (Tcl_IsShared(valuePtr)) {
-	    s1 = TclGetStringFromObj(valuePtr, &slength);
-	    TclNewStringObj(objResultPtr, s1, slength);
-	    slength = Tcl_UtfToTitle(TclGetString(objResultPtr));
-	    Tcl_SetObjLength(objResultPtr, slength);
+	    s1 = TclGetStringFromObj(valuePtr, &length);
+	    TclNewStringObj(objResultPtr, s1, length);
+	    length = Tcl_UtfToTitle(TclGetString(objResultPtr));
+	    Tcl_SetObjLength(objResultPtr, length);
 	    TRACE_APPEND(("\"%.20s\"\n", O2S(objResultPtr)));
 	    NEXT_INST_F(1, 1, 1);
 	} else {
-	    slength = Tcl_UtfToTitle(TclGetString(valuePtr));
-	    Tcl_SetObjLength(valuePtr, slength);
+	    length = Tcl_UtfToTitle(TclGetString(valuePtr));
+	    Tcl_SetObjLength(valuePtr, length);
 	    TclFreeIntRep(valuePtr);
 	    TRACE_APPEND(("\"%.20s\"\n", O2S(valuePtr)));
 	    NEXT_INST_F(1, 0, 0);
 	}
 
@@ -5002,22 +5235,22 @@
 
 	/*
 	 * Get char length to calulate what 'end' means.
 	 */
 
-	slength = Tcl_GetCharLength(valuePtr);
-	if (TclGetIntForIndexM(interp, value2Ptr, slength-1, &index)!=TCL_OK) {
+	length = Tcl_GetCharLength(valuePtr);
+	if (TclGetIntForIndexM(interp, value2Ptr, length-1, &index)!=TCL_OK) {
 	    TRACE_ERROR(interp);
 	    goto gotError;
 	}
 
-	if (index >= slength) {
+	if ((index < 0) || (index >= length)) {
 	    TclNewObj(objResultPtr);
 	} else if (TclIsPureByteArray(valuePtr)) {
 	    objResultPtr = Tcl_NewByteArrayObj(
 		    Tcl_GetByteArrayFromObj(valuePtr, NULL)+index, 1);
-	} else if (valuePtr->bytes && slength == valuePtr->length) {
+	} else if (valuePtr->bytes && length == valuePtr->length) {
 	    objResultPtr = Tcl_NewStringObj((const char *)
 		    valuePtr->bytes+index, 1);
 	} else {
 	    char buf[4] = "";
 	    int ch = Tcl_GetUniChar(valuePtr, index);
@@ -5028,40 +5261,40 @@
 	     * practical use.
 	     */
 	    if (ch == -1) {
 		objResultPtr = Tcl_NewObj();
 	    } else {
-		slength = Tcl_UniCharToUtf(ch, buf);
-		if ((ch >= 0xD800) && (slength < 3)) {
-		    slength += Tcl_UniCharToUtf(-1, buf + slength);
+		length = Tcl_UniCharToUtf(ch, buf);
+		if ((ch >= 0xD800) && (length < 3)) {
+		    length += Tcl_UniCharToUtf(-1, buf + length);
 		}
-		objResultPtr = Tcl_NewStringObj(buf, slength);
+		objResultPtr = Tcl_NewStringObj(buf, length);
 	    }
 	}
 
 	TRACE_APPEND(("\"%s\"\n", O2S(objResultPtr)));
 	NEXT_INST_F(1, 2, 1);
 
     case INST_STR_RANGE:
 	TRACE(("\"%.20s\" %.20s %.20s =>",
 		O2S(OBJ_AT_DEPTH(2)), O2S(OBJ_UNDER_TOS), O2S(OBJ_AT_TOS)));
-	slength = Tcl_GetCharLength(OBJ_AT_DEPTH(2)) - 1;
-	if (TclGetIntForIndexM(interp, OBJ_UNDER_TOS, slength,
+	length = Tcl_GetCharLength(OBJ_AT_DEPTH(2)) - 1;
+	if (TclGetIntForIndexM(interp, OBJ_UNDER_TOS, length,
 		    &fromIdx) != TCL_OK
-	    || TclGetIntForIndexM(interp, OBJ_AT_TOS, slength,
+	    || TclGetIntForIndexM(interp, OBJ_AT_TOS, length,
 		    &toIdx) != TCL_OK) {
 	    TRACE_ERROR(interp);
 	    goto gotError;
 	}
 
-	if (fromIdx == TCL_INDEX_NONE) {
-	    fromIdx = TCL_INDEX_START;
+	if (fromIdx < 0) {
+	    fromIdx = 0;
 	}
-	if (toIdx + 1 >= slength + 1) {
-	    toIdx = slength;
+	if (toIdx >= length) {
+	    toIdx = length;
 	}
-	if (toIdx + 1 >= fromIdx + 1) {
+	if (toIdx >= fromIdx) {
 	    objResultPtr = Tcl_GetRange(OBJ_AT_DEPTH(2), fromIdx, toIdx);
 	} else {
 	    TclNewObj(objResultPtr);
 	}
 	TRACE_APPEND(("\"%.30s\"\n", O2S(objResultPtr)));
@@ -5069,15 +5302,15 @@
 
     case INST_STR_RANGE_IMM:
 	valuePtr = OBJ_AT_TOS;
 	fromIdx = TclGetInt4AtPtr(pc+1);
 	toIdx = TclGetInt4AtPtr(pc+5);
-	slength = Tcl_GetCharLength(valuePtr);
-	TRACE(("\"%.20s\" %" TCL_LL_MODIFIER "d %" TCL_LL_MODIFIER "d => ", O2S(valuePtr), TclWideIntFromSize(fromIdx), TclWideIntFromSize(toIdx)));
+	length = Tcl_GetCharLength(valuePtr);
+	TRACE(("\"%.20s\" %d %d => ", O2S(valuePtr), fromIdx, toIdx));
 
 	/* Every range of an empty value is an empty value */
-	if (slength == 0) {
+	if (length == 0) {
 	    TRACE_APPEND(("\n"));
 	    NEXT_INST_F(9, 0, 0);
 	}
 
 	/* Decode index operands. */
@@ -5089,18 +5322,18 @@
 	 */
 	if (toIdx == TCL_INDEX_NONE) {
 	    goto emptyRange;
 	}
 
-	toIdx = TclIndexDecode(toIdx, slength - 1);
-	if (toIdx == TCL_INDEX_NONE) {
+	toIdx = TclIndexDecode(toIdx, length - 1);
+	if (toIdx < 0) {
 	    goto emptyRange;
-	} else if (toIdx >= slength) {
-	    toIdx = slength - 1;
+	} else if (toIdx >= length) {
+	    toIdx = length - 1;
 	}
 
-	assert ( toIdx != TCL_INDEX_NONE && toIdx < slength );
+	assert ( toIdx >= 0 && toIdx < length );
 
 	/*
 	assert ( fromIdx != TCL_INDEX_NONE );
 	 *
 	 * Extra safety for legacy bytecodes:
@@ -5107,16 +5340,16 @@
 	 */
 	if (fromIdx == TCL_INDEX_NONE) {
 	    fromIdx = TCL_INDEX_START;
 	}
 
-	fromIdx = TclIndexDecode(fromIdx, slength - 1);
-	if (fromIdx == TCL_INDEX_NONE) {
-	    fromIdx = TCL_INDEX_START;
+	fromIdx = TclIndexDecode(fromIdx, length - 1);
+	if (fromIdx < 0) {
+	    fromIdx = 0;
 	}
 
-	if (fromIdx + 1 <= toIdx + 1) {
+	if (fromIdx <= toIdx) {
 	    objResultPtr = Tcl_GetRange(valuePtr, fromIdx, toIdx);
 	} else {
 	emptyRange:
 	    TclNewObj(objResultPtr);
 	}
@@ -5123,22 +5356,22 @@
 	TRACE_APPEND(("%.30s\n", O2S(objResultPtr)));
 	NEXT_INST_F(9, 1, 1);
 
     {
 	Tcl_UniChar *ustring1, *ustring2, *ustring3, *end, *p;
-	size_t length3;
+	int length3, endIdx;
 	Tcl_Obj *value3Ptr;
 
     case INST_STR_REPLACE:
 	value3Ptr = POP_OBJECT();
 	valuePtr = OBJ_AT_DEPTH(2);
-	slength = Tcl_GetCharLength(valuePtr) - 1;
+	endIdx = Tcl_GetCharLength(valuePtr) - 1;
 	TRACE(("\"%.20s\" %s %s \"%.20s\" => ", O2S(valuePtr),
 		O2S(OBJ_UNDER_TOS), O2S(OBJ_AT_TOS), O2S(value3Ptr)));
-	if (TclGetIntForIndexM(interp, OBJ_UNDER_TOS, slength,
+	if (TclGetIntForIndexM(interp, OBJ_UNDER_TOS, endIdx,
 		    &fromIdx) != TCL_OK
-	    || TclGetIntForIndexM(interp, OBJ_AT_TOS, slength,
+	    || TclGetIntForIndexM(interp, OBJ_AT_TOS, endIdx,
 		    &toIdx) != TCL_OK) {
 	    TclDecrRefCount(value3Ptr);
 	    TRACE_ERROR(interp);
 	    goto gotError;
 	}
@@ -5145,27 +5378,27 @@
 	TclDecrRefCount(OBJ_AT_TOS);
 	(void) POP_OBJECT();
 	TclDecrRefCount(OBJ_AT_TOS);
 	(void) POP_OBJECT();
 
-	if ((toIdx == TCL_INDEX_NONE) ||
-		(fromIdx + 1 > slength + 1) ||
-		(toIdx + 1 < fromIdx + 1)) {
+	if ((toIdx < 0) ||
+		(fromIdx > endIdx) ||
+		(toIdx < fromIdx)) {
 	    TRACE_APPEND(("\"%.30s\"\n", O2S(valuePtr)));
 	    TclDecrRefCount(value3Ptr);
 	    NEXT_INST_F(1, 0, 0);
 	}
 
-	if (fromIdx == TCL_INDEX_NONE) {
-	    fromIdx = TCL_INDEX_START;
+	if (fromIdx < 0) {
+	    fromIdx = 0;
 	}
 
-	if (toIdx + 1 > slength + 1) {
-	    toIdx = slength;
+	if (toIdx > endIdx) {
+	    toIdx = endIdx;
 	}
 
-	if ((fromIdx == TCL_INDEX_START) && (toIdx == slength)) {
+	if (fromIdx == 0 && toIdx == endIdx) {
 	    TclDecrRefCount(OBJ_AT_TOS);
 	    OBJ_AT_TOS = value3Ptr;
 	    TRACE_APPEND(("\"%.30s\"\n", O2S(value3Ptr)));
 	    NEXT_INST_F(1, 0, 0);
 	}
@@ -5193,32 +5426,32 @@
 	    goto doneStringMap;
 	} else if (valuePtr == value2Ptr) {
 	    objResultPtr = value3Ptr;
 	    goto doneStringMap;
 	}
-	ustring1 = TclGetUnicodeFromObj(valuePtr, &slength);
-	if (slength == 0) {
+	ustring1 = Tcl_GetUnicodeFromObj(valuePtr, &length);
+	if (length == 0) {
 	    objResultPtr = valuePtr;
 	    goto doneStringMap;
 	}
-	ustring2 = TclGetUnicodeFromObj(value2Ptr, &length2);
-	if (length2 > slength || length2 == 0) {
+	ustring2 = Tcl_GetUnicodeFromObj(value2Ptr, &length2);
+	if (length2 > length || length2 == 0) {
 	    objResultPtr = valuePtr;
 	    goto doneStringMap;
-	} else if (length2 == slength) {
-	    if (memcmp(ustring1, ustring2, sizeof(Tcl_UniChar) * slength)) {
+	} else if (length2 == length) {
+	    if (memcmp(ustring1, ustring2, sizeof(Tcl_UniChar) * length)) {
 		objResultPtr = valuePtr;
 	    } else {
 		objResultPtr = value3Ptr;
 	    }
 	    goto doneStringMap;
 	}
-	ustring3 = TclGetUnicodeFromObj(value3Ptr, &length3);
+	ustring3 = Tcl_GetUnicodeFromObj(value3Ptr, &length3);
 
 	objResultPtr = Tcl_NewUnicodeObj(ustring1, 0);
 	p = ustring1;
-	end = ustring1 + slength;
+	end = ustring1 + length;
 	for (; ustring1 < end; ustring1++) {
 	    if ((*ustring1 == *ustring2) && (length2==1 ||
 		    memcmp(ustring1, ustring2, sizeof(Tcl_UniChar) * length2)
 			    == 0)) {
 		if (p != ustring1) {
@@ -5243,34 +5476,34 @@
 	TRACE_WITH_OBJ(("%.20s %.20s %.20s => ",
 		O2S(value2Ptr), O2S(value3Ptr), O2S(valuePtr)), objResultPtr);
 	NEXT_INST_V(1, 3, 1);
 
     case INST_STR_FIND:
-	slength = TclStringFirst(OBJ_UNDER_TOS, OBJ_AT_TOS, 0);
+	match = TclStringFirst(OBJ_UNDER_TOS, OBJ_AT_TOS, 0);
 
-	TRACE(("%.20s %.20s => %" TCL_LL_MODIFIER "d\n",
-		O2S(OBJ_UNDER_TOS), O2S(OBJ_AT_TOS), TclWideIntFromSize(slength)));
-	objResultPtr = TclNewWideIntObjFromSize(slength);
+	TRACE(("%.20s %.20s => %d\n",
+		O2S(OBJ_UNDER_TOS), O2S(OBJ_AT_TOS), match));
+	TclNewIntObj(objResultPtr, match);
 	NEXT_INST_F(1, 2, 1);
 
     case INST_STR_FIND_LAST:
-	slength = TclStringLast(OBJ_UNDER_TOS, OBJ_AT_TOS, TCL_INDEX_END);
+	match = TclStringLast(OBJ_UNDER_TOS, OBJ_AT_TOS, INT_MAX - 1);
 
-	TRACE(("%.20s %.20s => %" TCL_LL_MODIFIER "d\n",
-		O2S(OBJ_UNDER_TOS), O2S(OBJ_AT_TOS), TclWideIntFromSize(slength)));
-	objResultPtr = TclNewWideIntObjFromSize(slength);
+	TRACE(("%.20s %.20s => %d\n",
+		O2S(OBJ_UNDER_TOS), O2S(OBJ_AT_TOS), match));
+	TclNewIntObj(objResultPtr, match);
 	NEXT_INST_F(1, 2, 1);
 
     case INST_STR_CLASS:
 	opnd = TclGetInt1AtPtr(pc+1);
 	valuePtr = OBJ_AT_TOS;
 	TRACE(("%s \"%.30s\" => ", tclStringClassTable[opnd].name,
 		O2S(valuePtr)));
-	ustring1 = TclGetUnicodeFromObj(valuePtr, &slength);
+	ustring1 = Tcl_GetUnicodeFromObj(valuePtr, &length);
 	match = 1;
-	if (slength > 0) {
-	    end = ustring1 + slength;
+	if (length > 0) {
+	    end = ustring1 + length;
 	    for (p=ustring1 ; p<end ; p++) {
 		if (!tclStringClassTable[opnd].comparator(*p)) {
 		    match = 0;
 		    break;
 		}
@@ -5292,21 +5525,20 @@
 
 	if (TclHasIntRep(valuePtr, &tclStringType)
 		|| TclHasIntRep(value2Ptr, &tclStringType)) {
 	    Tcl_UniChar *ustring1, *ustring2;
 
-	    ustring1 = TclGetUnicodeFromObj(valuePtr, &slength);
-	    ustring2 = TclGetUnicodeFromObj(value2Ptr, &length2);
-	    match = TclUniCharMatch(ustring1, slength, ustring2, length2,
+	    ustring1 = Tcl_GetUnicodeFromObj(valuePtr, &length);
+	    ustring2 = Tcl_GetUnicodeFromObj(value2Ptr, &length2);
+	    match = TclUniCharMatch(ustring1, length, ustring2, length2,
 		    nocase);
 	} else if (TclIsPureByteArray(valuePtr) && !nocase) {
 	    unsigned char *bytes1, *bytes2;
-	    size_t wlen1 = 0, wlen2 = 0;
 
-	    bytes1 = TclGetByteArrayFromObj(valuePtr, &wlen1);
-	    bytes2 = TclGetByteArrayFromObj(value2Ptr, &wlen2);
-	    match = TclByteArrayMatch(bytes1, wlen1, bytes2, wlen2, 0);
+	    bytes1 = Tcl_GetByteArrayFromObj(valuePtr, &length);
+	    bytes2 = Tcl_GetByteArrayFromObj(value2Ptr, &length2);
+	    match = TclByteArrayMatch(bytes1, length, bytes2, length2, 0);
 	} else {
 	    match = Tcl_StringCaseMatch(TclGetString(valuePtr),
 		    TclGetString(value2Ptr), nocase);
 	}
 
@@ -5323,34 +5555,34 @@
 
 	JUMP_PEEPHOLE_F(match, 2, 2);
 
     {
 	const char *string1, *string2;
-	size_t trim1, trim2;
+	int trim1, trim2;
 
     case INST_STR_TRIM_LEFT:
 	valuePtr = OBJ_UNDER_TOS;	/* String */
 	value2Ptr = OBJ_AT_TOS;		/* TrimSet */
 	string2 = TclGetStringFromObj(value2Ptr, &length2);
-	string1 = TclGetStringFromObj(valuePtr, &slength);
-	trim1 = TclTrimLeft(string1, slength, string2, length2);
+	string1 = TclGetStringFromObj(valuePtr, &length);
+	trim1 = TclTrimLeft(string1, length, string2, length2);
 	trim2 = 0;
 	goto createTrimmedString;
     case INST_STR_TRIM_RIGHT:
 	valuePtr = OBJ_UNDER_TOS;	/* String */
 	value2Ptr = OBJ_AT_TOS;		/* TrimSet */
 	string2 = TclGetStringFromObj(value2Ptr, &length2);
-	string1 = TclGetStringFromObj(valuePtr, &slength);
-	trim2 = TclTrimRight(string1, slength, string2, length2);
+	string1 = TclGetStringFromObj(valuePtr, &length);
+	trim2 = TclTrimRight(string1, length, string2, length2);
 	trim1 = 0;
 	goto createTrimmedString;
     case INST_STR_TRIM:
 	valuePtr = OBJ_UNDER_TOS;	/* String */
 	value2Ptr = OBJ_AT_TOS;		/* TrimSet */
 	string2 = TclGetStringFromObj(value2Ptr, &length2);
-	string1 = TclGetStringFromObj(valuePtr, &slength);
-	trim1 = TclTrim(string1, slength, string2, length2, &trim2);
+	string1 = TclGetStringFromObj(valuePtr, &length);
+	trim1 = TclTrim(string1, length, string2, length2, &trim2);
     createTrimmedString:
 	/*
 	 * Careful here; trim set often contains non-ASCII characters so we
 	 * take care when printing. [Bug 971cb4f1db]
 	 */
@@ -5369,11 +5601,11 @@
 		printf("\n");
 	    }
 #endif
 	    NEXT_INST_F(1, 1, 0);
 	} else {
-	    objResultPtr = Tcl_NewStringObj(string1+trim1, slength-trim1-trim2);
+	    objResultPtr = Tcl_NewStringObj(string1+trim1, length-trim1-trim2);
 #ifdef TCL_COMPILE_DEBUG
 	    if (traceInstructions) {
 		TclPrintObject(stdout, objResultPtr, 30);
 		printf("\n");
 	    }
@@ -6127,10 +6359,174 @@
 	result = TCL_CONTINUE;
 	cleanup = 0;
 	TRACE(("=> CONTINUE!\n"));
 	goto processExceptionReturn;
 
+    {
+	ForeachInfo *infoPtr;
+	Var *iterVarPtr, *listVarPtr;
+	Tcl_Obj *oldValuePtr, *listPtr, **elements;
+	ForeachVarList *varListPtr;
+	int numLists, listTmpIndex, listLen, numVars;
+	size_t iterNum;
+	int varIndex, valIndex, continueLoop, j, iterTmpIndex;
+	long i;
+
+    case INST_FOREACH_START4: /* DEPRECATED */
+	/*
+	 * Initialize the temporary local var that holds the count of the
+	 * number of iterations of the loop body to -1.
+	 */
+
+	opnd = TclGetUInt4AtPtr(pc+1);
+	infoPtr = codePtr->auxDataArrayPtr[opnd].clientData;
+	iterTmpIndex = infoPtr->loopCtTemp;
+	iterVarPtr = LOCAL(iterTmpIndex);
+	oldValuePtr = iterVarPtr->value.objPtr;
+
+	if (oldValuePtr == NULL) {
+	    TclNewIntObj(iterVarPtr->value.objPtr, -1);
+	    Tcl_IncrRefCount(iterVarPtr->value.objPtr);
+	} else {
+	    TclSetIntObj(oldValuePtr, -1);
+	}
+	TRACE(("%u => loop iter count temp %d\n", opnd, iterTmpIndex));
+
+#ifndef TCL_COMPILE_DEBUG
+	/*
+	 * Remark that the compiler ALWAYS sets INST_FOREACH_STEP4 immediately
+	 * after INST_FOREACH_START4 - let us just fall through instead of
+	 * jumping back to the top.
+	 */
+
+	pc += 5;
+	TCL_DTRACE_INST_NEXT();
+#else
+	NEXT_INST_F(5, 0, 0);
+#endif
+
+    case INST_FOREACH_STEP4: /* DEPRECATED */
+	/*
+	 * "Step" a foreach loop (i.e., begin its next iteration) by assigning
+	 * the next value list element to each loop var.
+	 */
+
+	opnd = TclGetUInt4AtPtr(pc+1);
+	TRACE(("%u => ", opnd));
+	infoPtr = codePtr->auxDataArrayPtr[opnd].clientData;
+	numLists = infoPtr->numLists;
+
+	/*
+	 * Increment the temp holding the loop iteration number.
+	 */
+
+	iterVarPtr = LOCAL(infoPtr->loopCtTemp);
+	valuePtr = iterVarPtr->value.objPtr;
+	iterNum = (size_t)valuePtr->internalRep.wideValue + 1;
+	TclSetIntObj(valuePtr, iterNum);
+
+	/*
+	 * Check whether all value lists are exhausted and we should stop the
+	 * loop.
+	 */
+
+	continueLoop = 0;
+	listTmpIndex = infoPtr->firstValueTemp;
+	for (i = 0;  i < numLists;  i++) {
+	    varListPtr = infoPtr->varLists[i];
+	    numVars = varListPtr->numVars;
+
+	    listVarPtr = LOCAL(listTmpIndex);
+	    listPtr = listVarPtr->value.objPtr;
+	    if (TclListObjLength(interp, listPtr, &listLen) != TCL_OK) {
+		TRACE_APPEND(("ERROR converting list %ld, \"%.30s\": %s\n",
+			i, O2S(listPtr), O2S(Tcl_GetObjResult(interp))));
+		goto gotError;
+	    }
+	    if ((size_t)listLen > iterNum * numVars) {
+		continueLoop = 1;
+	    }
+	    listTmpIndex++;
+	}
+
+	/*
+	 * If some var in some var list still has a remaining list element
+	 * iterate one more time. Assign to var the next element from its
+	 * value list. We already checked above that each list temp holds a
+	 * valid list object (by calling Tcl_ListObjLength), but cannot rely
+	 * on that check remaining valid: one list could have been shimmered
+	 * as a side effect of setting a traced variable.
+	 */
+
+	if (continueLoop) {
+	    listTmpIndex = infoPtr->firstValueTemp;
+	    for (i = 0;  i < numLists;  i++) {
+		varListPtr = infoPtr->varLists[i];
+		numVars = varListPtr->numVars;
+
+		listVarPtr = LOCAL(listTmpIndex);
+		listPtr = TclListObjCopy(NULL, listVarPtr->value.objPtr);
+		TclListObjGetElements(interp, listPtr, &listLen, &elements);
+
+		valIndex = (iterNum * numVars);
+		for (j = 0;  j < numVars;  j++) {
+		    if (valIndex >= listLen) {
+			TclNewObj(valuePtr);
+		    } else {
+			valuePtr = elements[valIndex];
+		    }
+
+		    varIndex = varListPtr->varIndexes[j];
+		    varPtr = LOCAL(varIndex);
+		    while (TclIsVarLink(varPtr)) {
+			varPtr = varPtr->value.linkPtr;
+		    }
+		    if (TclIsVarDirectWritable(varPtr)) {
+			value2Ptr = varPtr->value.objPtr;
+			if (valuePtr != value2Ptr) {
+			    if (value2Ptr != NULL) {
+				TclDecrRefCount(value2Ptr);
+			    }
+			    varPtr->value.objPtr = valuePtr;
+			    Tcl_IncrRefCount(valuePtr);
+			}
+		    } else {
+			DECACHE_STACK_INFO();
+			if (TclPtrSetVarIdx(interp, varPtr, NULL, NULL, NULL,
+				valuePtr, TCL_LEAVE_ERR_MSG, varIndex)==NULL){
+			    CACHE_STACK_INFO();
+			    TRACE_APPEND((
+				    "ERROR init. index temp %d: %s\n",
+				    varIndex, O2S(Tcl_GetObjResult(interp))));
+			    TclDecrRefCount(listPtr);
+			    goto gotError;
+			}
+			CACHE_STACK_INFO();
+		    }
+		    valIndex++;
+		}
+		TclDecrRefCount(listPtr);
+		listTmpIndex++;
+	    }
+	}
+	TRACE_APPEND(("%d lists, iter %" TCL_Z_MODIFIER "u, %s loop\n",
+		numLists, iterNum, (continueLoop? "continue" : "exit")));
+
+	/*
+	 * Run-time peep-hole optimisation: the compiler ALWAYS follows
+	 * INST_FOREACH_STEP4 with an INST_JUMP_FALSE. We just skip that
+	 * instruction and jump direct from here.
+	 */
+
+	pc += 5;
+	if (*pc == INST_JUMP_FALSE1) {
+	    NEXT_INST_F((continueLoop? 2 : TclGetInt1AtPtr(pc+1)), 0, 0);
+	} else {
+	    NEXT_INST_F((continueLoop? 5 : TclGetInt4AtPtr(pc+1)), 0, 0);
+	}
+
+    }
     {
 	ForeachInfo *infoPtr;
 	Tcl_Obj *listPtr, **elements, *tmpPtr;
 	ForeachVarList *varListPtr;
 	int numLists, listLen, numVars;
@@ -6753,11 +7149,11 @@
 
     case INST_DICT_FIRST:
 	opnd = TclGetUInt4AtPtr(pc+1);
 	TRACE(("%u => ", opnd));
 	dictPtr = POP_OBJECT();
-	searchPtr = Tcl_Alloc(sizeof(Tcl_DictSearch));
+	searchPtr = ckalloc(sizeof(Tcl_DictSearch));
 	if (Tcl_DictObjFirst(interp, dictPtr, searchPtr, &keyPtr,
 		&valuePtr, &done) != TCL_OK) {
 
 	    /*
 	     * dictPtr is no longer on the stack, and we're not
@@ -6764,11 +7160,11 @@
 	     * moving it into the intrep of an iterator.  We need
 	     * to drop the refcount [Tcl Bug 9b352768e6].
 	     */
 
 	    Tcl_DecrRefCount(dictPtr);
-	    Tcl_Free(searchPtr);
+	    ckfree(searchPtr);
 	    TRACE_ERROR(interp);
 	    goto gotError;
 	}
 	{
 	    Tcl_ObjIntRep ir;
@@ -6849,11 +7245,11 @@
 	if (TclListObjGetElements(interp, OBJ_AT_TOS, &length,
 		&keyPtrPtr) != TCL_OK) {
 	    TRACE_ERROR(interp);
 	    goto gotError;
 	}
-	if ((size_t)length != duiPtr->length) {
+	if (length != duiPtr->length) {
 	    Tcl_Panic("dictUpdateStart argument length mismatch");
 	}
 	for (i=0 ; i<length ; i++) {
 	    if (Tcl_DictObjGet(interp, dictPtr, keyPtrPtr[i],
 		    &valuePtr) != TCL_OK) {
@@ -7209,16 +7605,15 @@
 	if (iPtr->execEnvPtr->rewind) {
 	    goto abnormalReturn;
 	}
 	if ((result == TCL_ERROR) && !(iPtr->flags & ERR_ALREADY_LOGGED)) {
 	    const unsigned char *pcBeg;
-	    size_t xxx1length;
 
-	    bytes = GetSrcInfoForPc(pc, codePtr, &xxx1length, &pcBeg, NULL);
+	    bytes = GetSrcInfoForPc(pc, codePtr, &length, &pcBeg, NULL);
 	    DECACHE_STACK_INFO();
 	    TclLogCommandInfo(interp, codePtr->source, bytes,
-		    bytes ? xxx1length : 0, pcBeg, tosPtr);
+		    bytes ? length : 0, pcBeg, tosPtr);
 	    CACHE_STACK_INFO();
 	}
 	iPtr->flags &= ~ERR_ALREADY_LOGGED;
 
 	/*
@@ -7322,11 +7717,11 @@
 	/*
 	 * end of infinite loop dispatching on instructions.
 	 */
 
 	/*
-	 * Abnormal return code. Restore the stack to state it had when
+	 * Done or abnormal return code. Restore the stack to state it had when
 	 * starting to execute the ByteCode. Panic if the stack is below the
 	 * initial level.
 	 */
 
     abnormalReturn:
@@ -7376,31 +7771,33 @@
      */
 
 	instStartCmdFailed:
 	{
 	    const char *bytes;
-	    size_t xxx1length;
-
-	    checkInterp = 1;
-	    xxx1length = 0;
-
-	    /*
-	     * We used to switch to direct eval; for NRE-awareness we now
-	     * compile and eval the command so that this evaluation does not
-	     * add a new TEBC instance. [Bug 2910748]
-	     */
+
+	    length = 0;
 
 	    if (TclInterpReady(interp) == TCL_ERROR) {
 		goto gotError;
 	    }
 
+	    /*
+	     * We used to switch to direct eval; for NRE-awareness we now
+	     * compile and eval the command so that this evaluation does not
+	     * add a new TEBC instance. Bug [2910748], bug [fa6bf38d07]
+	     *
+	     * TODO: recompile, search this command and eval a code starting from,
+	     * so that this evaluation does not add a new TEBC instance without
+	     * NRE-trampoline.
+	     */
+
 	    codePtr->flags |= TCL_BYTECODE_RECOMPILE;
-	    bytes = GetSrcInfoForPc(pc, codePtr, &xxx1length, NULL, NULL);
+	    bytes = GetSrcInfoForPc(pc, codePtr, &length, NULL, NULL);
 	    opnd = TclGetUInt4AtPtr(pc+1);
 	    pc += (opnd-1);
 	    assert(bytes);
-	    PUSH_OBJECT(Tcl_NewStringObj(bytes, xxx1length));
+	    PUSH_OBJECT(Tcl_NewStringObj(bytes, length));
 	    goto instEvalStk;
 	}
 }
 
 #undef codePtr
@@ -8080,11 +8477,11 @@
 		    "exponent too large", -1));
 	    return GENERAL_ARITHMETIC_ERROR;
 	}
 	Tcl_TakeBignumFromObj(NULL, valuePtr, &big1);
 	mp_init(&bigResult);
-	mp_expt_d_ex(&big1, w2, &bigResult, 1);
+	mp_expt_d(&big1, (mp_digit)w2, &bigResult);
 	mp_clear(&big1);
 	BIG_RESULT(&bigResult);
     }
 
     case INST_ADD:
@@ -8518,13 +8915,14 @@
 				 * stdout. */
 {
     Proc *procPtr = codePtr->procPtr;
     Interp *iPtr = (Interp *) *codePtr->interpHandle;
 
-    fprintf(stdout, "\nExecuting ByteCode 0x%p, refCt %" TCL_Z_MODIFIER "u, epoch %" TCL_Z_MODIFIER "u, interp 0x%p (epoch %" TCL_Z_MODIFIER "u)\n",
-	    codePtr, codePtr->refCount, codePtr->compileEpoch, iPtr,
+    fprintf(stdout, "\nExecuting ByteCode 0x%p, refCt %" TCL_Z_MODIFIER "u, epoch %u, interp 0x%p (epoch %u)\n",
+	    codePtr, (size_t)codePtr->refCount, codePtr->compileEpoch, iPtr,
 	    iPtr->compileEpoch);
+
     fprintf(stdout, "  Source: ");
     TclPrintSource(stdout, codePtr->source, 60);
 
     fprintf(stdout, "\n  Cmds %d, src %d, inst %u, litObjs %u, aux %d, stkDepth %u, code/src %.2f\n",
 	    codePtr->numCommands, codePtr->numSrcBytes,
@@ -8546,11 +8944,11 @@
 	    (unsigned long) (codePtr->numAuxDataItems * sizeof(AuxData)),
 	    codePtr->numCmdLocBytes);
 #endif /* TCL_COMPILE_STATS */
     if (procPtr != NULL) {
 	fprintf(stdout,
-		"  Proc 0x%p, refCt %" TCL_Z_MODIFIER "u, args %d, compiled locals %d\n",
+		"  Proc 0x%p, refCt %d, args %d, compiled locals %d\n",
 		procPtr, procPtr->refCount, procPtr->numArgs,
 		procPtr->numCompiledLocals);
     }
 }
 #endif /* TCL_COMPILE_DEBUG */
@@ -8598,18 +8996,18 @@
     if (((size_t) pc < codeStart) || ((size_t) pc > codeEnd)) {
 	fprintf(stderr, "\nBad instruction pc 0x%p in TclNRExecuteByteCode\n",
 		pc);
 	Tcl_Panic("TclNRExecuteByteCode execution failure: bad pc");
     }
-    if ((unsigned) opCode >= LAST_INST_OPCODE) {
+    if ((unsigned) opCode > LAST_INST_OPCODE) {
 	fprintf(stderr, "\nBad opcode %d at pc %" TCL_Z_MODIFIER "u in TclNRExecuteByteCode\n",
 		(unsigned) opCode, relativePc);
 	Tcl_Panic("TclNRExecuteByteCode execution failure: bad opcode");
     }
     if (checkStack &&
 	    ((stackTop < 0) || (stackTop > stackUpperBound))) {
-	size_t numChars;
+	int numChars;
 	const char *cmd = GetSrcInfoForPc(pc, codePtr, &numChars, NULL, NULL);
 
 	fprintf(stderr, "\nBad stack top %d at pc %" TCL_Z_MODIFIER "u in TclNRExecuteByteCode (min 0, max %i)",
 		stackTop, relativePc, stackUpperBound);
 	if (cmd != NULL) {
@@ -8661,15 +9059,24 @@
     const char *description, *operator = "unknown";
 
     if (opcode == INST_EXPON) {
 	operator = "**";
     } else if (opcode <= INST_LNOT) {
-	operator = operatorStrings[opcode - INST_BITOR];
+	operator = operatorStrings[opcode - INST_LOR];
     }
 
     if (GetNumberFromObj(NULL, opndPtr, &ptr, &type) != TCL_OK) {
-	description = "non-numeric string";
+	int numBytes;
+	const char *bytes = TclGetStringFromObj(opndPtr, &numBytes);
+
+	if (numBytes == 0) {
+	    description = "empty string";
+	} else if (TclCheckBadOctal(NULL, bytes)) {
+	    description = "invalid octal number";
+	} else {
+	    description = "non-numeric string";
+	}
     } else if (type == TCL_NUMBER_NAN) {
 	description = "non-numeric floating-point value";
     } else if (type == TCL_NUMBER_DOUBLE) {
 	description = "floating-point value";
     } else {
@@ -8676,12 +9083,11 @@
 	/* TODO: No caller needs this. Eliminate? */
 	description = "(big) integer";
     }
 
     Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-	    "can't use %s \"%s\" as operand of \"%s\"", description,
-	    TclGetString(opndPtr), operator));
+	    "can't use %s as operand of \"%s\"", description, operator));
     Tcl_SetErrorCode(interp, "ARITH", "DOMAIN", description, NULL);
 }
 
 /*
  *----------------------------------------------------------------------
@@ -8754,12 +9160,11 @@
 	 * there find the list of word locations for this command.
 	 */
 
 	ExtCmdLoc *eclPtr;
 	ECL *locPtr = NULL;
-	size_t srcOffset;
-	int i;
+	int srcOffset, i;
 	Interp *iPtr = (Interp *) *codePtr->interpHandle;
 	Tcl_HashEntry *hePtr =
 		Tcl_FindHashEntry(iPtr->lineBCPtr, codePtr);
 
 	if (!hePtr) {
@@ -8801,32 +9206,32 @@
 				 * return the closest command's source info.
 				 * This points within a bytecode instruction
 				 * in codePtr's code. */
     ByteCode *codePtr,		/* The bytecode sequence in which to look up
 				 * the command source for the pc. */
-    size_t *lengthPtr,		/* If non-NULL, the location where the length
+    int *lengthPtr,		/* If non-NULL, the location where the length
 				 * of the command's source should be stored.
 				 * If NULL, no length is stored. */
     const unsigned char **pcBeg,/* If non-NULL, the bytecode location
 				 * where the current instruction starts.
 				 * If NULL; no pointer is stored. */
     int *cmdIdxPtr)		/* If non-NULL, the location where the index
 				 * of the command containing the pc should
 				 * be stored. */
 {
-    size_t pcOffset = (size_t)(pc - codePtr->codeStart);
-    size_t numCmds = codePtr->numCommands;
+    int pcOffset = (pc - codePtr->codeStart);
+    int numCmds = codePtr->numCommands;
     unsigned char *codeDeltaNext, *codeLengthNext;
     unsigned char *srcDeltaNext, *srcLengthNext;
-    size_t codeOffset, codeLen, codeEnd, srcOffset, srcLen, delta, i;
+    int codeOffset, codeLen, codeEnd, srcOffset, srcLen, delta, i;
     int bestDist = INT_MAX;	/* Distance of pc to best cmd's start pc. */
     int bestSrcOffset = -1;	/* Initialized to avoid compiler warning. */
     int bestSrcLength = -1;	/* Initialized to avoid compiler warning. */
     int bestCmdIdx = -1;
 
     /* The pc must point within the bytecode */
-    assert (pcOffset < (size_t)codePtr->numCodeBytes);
+    assert ((pcOffset >= 0) && (pcOffset < codePtr->numCodeBytes));
 
     /*
      * Decode the code and source offset and length for each command. The
      * closest enclosing command is the last one whose code started before
      * pcOffset.
@@ -8965,12 +9370,12 @@
 				 * for the enclosing ExceptionRange. */
 {
     ExceptionRange *rangeArrayPtr;
     int numRanges = codePtr->numExceptRanges;
     ExceptionRange *rangePtr;
-    size_t pcOffset = pc - codePtr->codeStart;
-    size_t start;
+    int pcOffset = pc - codePtr->codeStart;
+    int start;
 
     if (numRanges == 0) {
 	return NULL;
     }
 
@@ -9144,12 +9549,13 @@
     double totalLiteralBytes, currentLiteralBytes;
     double objBytesIfUnshared, strBytesIfUnshared, sharingBytesSaved;
     double strBytesSharedMultX, strBytesSharedOnce;
     double numInstructions, currentHeaderBytes;
     size_t numCurrentByteCodes, numByteCodeLits;
-    size_t refCountSum, literalMgmtBytes, sum, decadeHigh, length;
+    size_t refCountSum, literalMgmtBytes, sum;
     size_t numSharedMultX, numSharedOnce, minSizeDecade, maxSizeDecade, i;
+    int decadeHigh, length;
     char *litTableStats;
     LiteralEntry *entryPtr;
     Tcl_Obj *objPtr;
 
 #define Percent(a,b) ((a) * 100.0 / (b))
@@ -9187,12 +9593,12 @@
      * Summary statistics, total and current source and ByteCode sizes.
      */
 
     Tcl_AppendPrintfToObj(objPtr, "\n----------------------------------------------------------------\n");
     Tcl_AppendPrintfToObj(objPtr,
-	    "Compilation and execution statistics for interpreter %p\n",
-	    iPtr);
+	    "Compilation and execution statistics for interpreter %#" TCL_Z_MODIFIER "x\n",
+	    (size_t)iPtr);
 
     Tcl_AppendPrintfToObj(objPtr, "\nNumber ByteCodes executed\t%" TCL_Z_MODIFIER "u\n",
 	    statsPtr->numExecutions);
     Tcl_AppendPrintfToObj(objPtr, "Number ByteCodes compiled\t%" TCL_Z_MODIFIER "u\n",
 	    statsPtr->numCompilations);
@@ -9235,15 +9641,15 @@
 	    currentCodeBytes);
     Tcl_AppendPrintfToObj(objPtr, "    ByteCode bytes\t\t%.6g\n",
 	    statsPtr->currentByteCodeBytes);
     Tcl_AppendPrintfToObj(objPtr, "    Literal bytes\t\t%.6g\n",
 	    currentLiteralBytes);
-    Tcl_AppendPrintfToObj(objPtr, "      table %" TCL_Z_MODIFIER "u + bkts %" TCL_Z_MODIFIER "u + entries %" TCL_Z_MODIFIER "u + objects %" TCL_Z_MODIFIER "u + strings %.6g\n",
-	    sizeof(LiteralTable),
-	    iPtr->literalTable.numBuckets * sizeof(LiteralEntry *),
-	    iPtr->literalTable.numEntries * sizeof(LiteralEntry),
-	    iPtr->literalTable.numEntries * sizeof(Tcl_Obj),
+    Tcl_AppendPrintfToObj(objPtr, "      table %lu + bkts %lu + entries %lu + objects %lu + strings %.6g\n",
+	    (unsigned long) sizeof(LiteralTable),
+	    (unsigned long) (iPtr->literalTable.numBuckets * sizeof(LiteralEntry *)),
+	    (unsigned long) (iPtr->literalTable.numEntries * sizeof(LiteralEntry)),
+	    (unsigned long) (iPtr->literalTable.numEntries * sizeof(Tcl_Obj)),
 	    statsPtr->currentLitStringBytes);
     Tcl_AppendPrintfToObj(objPtr, "  Mean code/source\t\t%.1f\n",
 	    currentCodeBytes / statsPtr->currentSrcBytes);
     Tcl_AppendPrintfToObj(objPtr, "  Code + source bytes\t\t%.6g (%0.1f mean code/src)\n",
 	    (currentCodeBytes + statsPtr->currentSrcBytes),
@@ -9310,11 +9716,11 @@
     Tcl_AppendPrintfToObj(objPtr, "Current objects\t\t\t%" TCL_Z_MODIFIER "u\n",
 	    (tclObjsAlloced - tclObjsFreed));
     Tcl_AppendPrintfToObj(objPtr, "Total literal objects\t\t%" TCL_Z_MODIFIER "u\n",
 	    statsPtr->numLiteralsCreated);
 
-    Tcl_AppendPrintfToObj(objPtr, "\nCurrent literal objects\t\t%" TCL_Z_MODIFIER "u (%0.1f%% of current objects)\n",
+    Tcl_AppendPrintfToObj(objPtr, "\nCurrent literal objects\t\t%d (%0.1f%% of current objects)\n",
 	    globalTablePtr->numEntries,
 	    Percent(globalTablePtr->numEntries, tclObjsAlloced-tclObjsFreed));
     Tcl_AppendPrintfToObj(objPtr, "  ByteCode literals\t\t%" TCL_Z_MODIFIER "u (%0.1f%% of current literals)\n",
 	    numByteCodeLits,
 	    Percent(numByteCodeLits, globalTablePtr->numEntries));
@@ -9402,18 +9808,18 @@
     }
     sum = 0;
     for (i = 0;  i <= maxSizeDecade;  i++) {
 	decadeHigh = (1 << (i+1)) - 1;
 	sum += statsPtr->literalCount[i];
-	Tcl_AppendPrintfToObj(objPtr, "\t%10" TCL_Z_MODIFIER "u\t\t%8.0f%%\n",
+	Tcl_AppendPrintfToObj(objPtr, "\t%10d\t\t%8.0f%%\n",
 		decadeHigh, Percent(sum, statsPtr->numLiteralsCreated));
     }
 
     litTableStats = TclLiteralStats(globalTablePtr);
     Tcl_AppendPrintfToObj(objPtr, "\nCurrent literal table statistics:\n%s\n",
 	    litTableStats);
-    Tcl_Free(litTableStats);
+    ckfree(litTableStats);
 
     /*
      * Source and ByteCode size distributions.
      */
 
@@ -9434,11 +9840,11 @@
     }
     sum = 0;
     for (i = minSizeDecade;  i <= maxSizeDecade;  i++) {
 	decadeHigh = (1 << (i+1)) - 1;
 	sum += statsPtr->srcCount[i];
-	Tcl_AppendPrintfToObj(objPtr, "\t%10" TCL_Z_MODIFIER "u\t\t%8.0f%%\n",
+	Tcl_AppendPrintfToObj(objPtr, "\t%10d\t\t%8.0f%%\n",
 		decadeHigh, Percent(sum, statsPtr->numCompilations));
     }
 
     Tcl_AppendPrintfToObj(objPtr, "\nByteCode sizes:\n");
     Tcl_AppendPrintfToObj(objPtr, "\t Up to size\t\tPercentage\n");
@@ -9457,11 +9863,11 @@
     }
     sum = 0;
     for (i = minSizeDecade;  i <= maxSizeDecade;  i++) {
 	decadeHigh = (1 << (i+1)) - 1;
 	sum += statsPtr->byteCodeCount[i];
-	Tcl_AppendPrintfToObj(objPtr, "\t%10" TCL_Z_MODIFIER "u\t\t%8.0f%%\n",
+	Tcl_AppendPrintfToObj(objPtr, "\t%10d\t\t%8.0f%%\n",
 		decadeHigh, Percent(sum, statsPtr->numCompilations));
     }
 
     Tcl_AppendPrintfToObj(objPtr, "\nByteCode longevity (excludes Current ByteCodes):\n");
     Tcl_AppendPrintfToObj(objPtr, "\t       Up to ms\t\tPercentage\n");
@@ -9489,11 +9895,11 @@
     /*
      * Instruction counts.
      */
 
     Tcl_AppendPrintfToObj(objPtr, "\nInstruction counts:\n");
-    for (i = 0;  i < LAST_INST_OPCODE;  i++) {
+    for (i = 0;  i <= LAST_INST_OPCODE;  i++) {
 	Tcl_AppendPrintfToObj(objPtr, "%20s %8" TCL_Z_MODIFIER "u ",
 		tclInstructionTable[i].name, statsPtr->instructionCount[i]);
 	if (statsPtr->instructionCount[i]) {
 	    Tcl_AppendPrintfToObj(objPtr, "%6.1f%%\n",
 		    Percent(statsPtr->instructionCount[i], numInstructions));
@@ -9502,11 +9908,11 @@
 	}
     }
 
 #ifdef TCL_MEM_DEBUG
     Tcl_AppendPrintfToObj(objPtr, "\nHeap Statistics:\n");
-    TclDumpMemoryInfo(objPtr, 1);
+    TclDumpMemoryInfo((ClientData) objPtr, 1);
 #endif
     Tcl_AppendPrintfToObj(objPtr, "\n----------------------------------------------------------------\n");
 
     if (objc == 1) {
 	Tcl_SetObjResult(interp, objPtr);

Index: generic/tclFCmd.c
==================================================================
--- generic/tclFCmd.c
+++ generic/tclFCmd.c
@@ -1387,11 +1387,11 @@
     if (objc > 1) {
 	nameVarObj = objv[1];
 	TclNewObj(nameObj);
     }
     if (objc > 2) {
-	size_t length;
+	int length;
 	Tcl_Obj *templateObj = objv[2];
 	const char *string = TclGetStringFromObj(templateObj, &length);
 
 	/*
 	 * Treat an empty string as if it wasn't there.

Index: generic/tclFileName.c
==================================================================
--- generic/tclFileName.c
+++ generic/tclFileName.c
@@ -384,11 +384,12 @@
     int *driveNameLengthPtr,	/* Returns length of drive, if non-NULL and
 				 * path was absolute */
     Tcl_Obj **driveNameRef)
 {
     Tcl_PathType type = TCL_PATH_ABSOLUTE;
-    const char *path = TclGetString(pathPtr);
+    int pathLen;
+    const char *path = TclGetStringFromObj(pathPtr, &pathLen);
 
     if (path[0] == '~') {
 	/*
 	 * This case is common to all platforms. Paths that begin with ~ are
 	 * absolute.
@@ -501,15 +502,15 @@
      * Perform platform specific splitting.
      */
 
     switch (tclPlatform) {
     case TCL_PLATFORM_UNIX:
-	resultPtr = SplitUnixPath(TclGetString(pathPtr));
+	resultPtr = SplitUnixPath(Tcl_GetString(pathPtr));
 	break;
 
     case TCL_PLATFORM_WINDOWS:
-	resultPtr = SplitWinPath(TclGetString(pathPtr));
+	resultPtr = SplitWinPath(Tcl_GetString(pathPtr));
 	break;
     }
 
     /*
      * Compute the number of elements in the result.
@@ -534,11 +535,11 @@
  *	of path components. *argvPtr will be filled in with the address of an
  *	array whose elements point to the elements of path, in order.
  *	*argcPtr will get filled in with the number of valid elements in the
  *	array. A single block of memory is dynamically allocated to hold both
  *	the argv array and a copy of the path elements. The caller must
- *	eventually free this memory by calling Tcl_Free() on *argvPtr. Note:
+ *	eventually free this memory by calling ckfree() on *argvPtr. Note:
  *	*argvPtr and *argcPtr are only modified if the procedure returns
  *	normally.
  *
  * Side effects:
  *	Allocates memory.
@@ -554,12 +555,11 @@
     const char ***argvPtr)	/* Pointer to place to store pointer to array
 				 * of pointers to path elements. */
 {
     Tcl_Obj *resultPtr = NULL;	/* Needed only to prevent gcc warnings. */
     Tcl_Obj *tmpPtr, *eltPtr;
-    int i;
-    size_t size, len;
+    int i, size, len;
     char *p;
     const char *str;
 
     /*
      * Perform the splitting, using objectified, vfs-aware code.
@@ -576,20 +576,20 @@
      */
 
     size = 1;
     for (i = 0; i < *argcPtr; i++) {
 	Tcl_ListObjIndex(NULL, resultPtr, i, &eltPtr);
-	(void)TclGetStringFromObj(eltPtr, &len);
+	TclGetStringFromObj(eltPtr, &len);
 	size += len + 1;
     }
 
     /*
      * Allocate a buffer large enough to hold the contents of all of the list
      * plus the argv pointers and the terminating NULL pointer.
      */
 
-    *argvPtr = Tcl_Alloc((((*argcPtr) + 1) * sizeof(char *)) + size);
+    *argvPtr = ckalloc((((*argcPtr) + 1) * sizeof(char *)) + size);
 
     /*
      * Position p after the last argv pointer and copy the contents of the
      * list in, piece by piece.
      */
@@ -640,11 +640,11 @@
 
 static Tcl_Obj *
 SplitUnixPath(
     const char *path)		/* Pointer to string containing a path. */
 {
-    size_t length;
+    int length;
     const char *origPath = path, *elementStart;
     Tcl_Obj *result = Tcl_NewObj();
 
     /*
      * Deal with the root directory as a special case.
@@ -729,11 +729,11 @@
 
 static Tcl_Obj *
 SplitWinPath(
     const char *path)		/* Pointer to string containing a path. */
 {
-    size_t length;
+    int length;
     const char *p, *elementStart;
     Tcl_PathType type = TCL_PATH_ABSOLUTE;
     Tcl_DString buf;
     Tcl_Obj *result = Tcl_NewObj();
     Tcl_DStringInit(&buf);
@@ -819,16 +819,16 @@
 	pair[0] = pathPtr;
 	pair[1] = objv[0];
 	return TclJoinPath(2, pair, 0);
     } else {
 	int elemc = objc + 1;
-	Tcl_Obj *ret, **elemv = Tcl_Alloc(elemc*sizeof(Tcl_Obj *));
+	Tcl_Obj *ret, **elemv = ckalloc(elemc*sizeof(Tcl_Obj *));
 
 	elemv[0] = pathPtr;
 	memcpy(elemv+1, objv, objc*sizeof(Tcl_Obj *));
 	ret = TclJoinPath(elemc, elemv, 0);
-	Tcl_Free(elemv);
+	ckfree(elemv);
 	return ret;
     }
 }
 
 /*
@@ -850,12 +850,11 @@
 void
 TclpNativeJoinPath(
     Tcl_Obj *prefix,
     const char *joining)
 {
-    int needsSep;
-    size_t length;
+    int length, needsSep;
     char *dest;
     const char *p;
     const char *start;
 
     start = TclGetStringFromObj(prefix, &length);
@@ -884,21 +883,21 @@
 	 * Append a separator if needed.
 	 */
 
 	if (length > 0 && (start[length-1] != '/')) {
 	    Tcl_AppendToObj(prefix, "/", 1);
-	    (void)TclGetStringFromObj(prefix, &length);
+	    TclGetStringFromObj(prefix, &length);
 	}
 	needsSep = 0;
 
 	/*
 	 * Append the element, eliminating duplicate and trailing slashes.
 	 */
 
 	Tcl_SetObjLength(prefix, length + (int) strlen(p));
 
-	dest = TclGetString(prefix) + length;
+	dest = Tcl_GetString(prefix) + length;
 	for (; *p != '\0'; p++) {
 	    if (*p == '/') {
 		while (p[1] == '/') {
 		    p++;
 		}
@@ -908,11 +907,11 @@
 	    } else {
 		*dest++ = *p;
 		needsSep = 1;
 	    }
 	}
-	length = dest - TclGetString(prefix);
+	length = dest - Tcl_GetString(prefix);
 	Tcl_SetObjLength(prefix, length);
 	break;
 
     case TCL_PLATFORM_WINDOWS:
 	/*
@@ -920,20 +919,20 @@
 	 */
 
 	if ((length > 0) &&
 		(start[length-1] != '/') && (start[length-1] != ':')) {
 	    Tcl_AppendToObj(prefix, "/", 1);
-	    (void)TclGetStringFromObj(prefix, &length);
+	    TclGetStringFromObj(prefix, &length);
 	}
 	needsSep = 0;
 
 	/*
 	 * Append the element, eliminating duplicate and trailing slashes.
 	 */
 
 	Tcl_SetObjLength(prefix, length + (int) strlen(p));
-	dest = TclGetString(prefix) + length;
+	dest = Tcl_GetString(prefix) + length;
 	for (; *p != '\0'; p++) {
 	    if ((*p == '/') || (*p == '\\')) {
 		while ((p[1] == '/') || (p[1] == '\\')) {
 		    p++;
 		}
@@ -943,11 +942,11 @@
 	    } else {
 		*dest++ = *p;
 		needsSep = 1;
 	    }
 	}
-	length = dest - TclGetString(prefix);
+	length = dest - Tcl_GetString(prefix);
 	Tcl_SetObjLength(prefix, length);
 	break;
     }
     return;
 }
@@ -975,12 +974,11 @@
 Tcl_JoinPath(
     int argc,
     const char *const *argv,
     Tcl_DString *resultPtr)	/* Pointer to previously initialized DString */
 {
-    int i;
-    size_t len;
+    int i, len;
     Tcl_Obj *listObj = Tcl_NewObj();
     Tcl_Obj *resultObj;
     const char *resultStr;
 
     /*
@@ -1072,11 +1070,11 @@
      * Convert forward slashes to backslashes in Windows paths because some
      * system interfaces don't accept forward slashes.
      */
 
     if (tclPlatform == TCL_PLATFORM_WINDOWS) {
-	register char *p;
+	char *p;
 	for (p = Tcl_DStringValue(bufferPtr); *p != '\0'; p++) {
 	    if (*p == '/') {
 		*p = '\\';
 	    }
 	}
@@ -1249,11 +1247,11 @@
     dir = PATH_NONE;
     typePtr = NULL;
     for (i = 1; i < objc; i++) {
 	if (Tcl_GetIndexFromObj(interp, objv[i], options, "option", 0,
 		&index) != TCL_OK) {
-	    string = TclGetString(objv[i]);
+	    string = TclGetStringFromObj(objv[i], &length);
 	    if (string[0] == '-') {
 		/*
 		 * It looks like the command contains an option so signal an
 		 * error.
 		 */
@@ -1355,11 +1353,11 @@
 	separators = "/\\:";
 	break;
     }
 
     if (dir == PATH_GENERAL) {
-	size_t pathlength;
+	int pathlength;
 	const char *last;
 	const char *first = TclGetStringFromObj(pathOrDir,&pathlength);
 
 	/*
 	 * Find the last path separator in the path
@@ -1407,11 +1405,11 @@
 		 * a valid path like '/' or 'C:/' into an incorrect path like
 		 * '' or 'C:'. The way we do this is to add a separator if
 		 * there are none presently in the prefix.
 		 */
 
-		if (strpbrk(TclGetString(pathOrDir), "\\/") == NULL) {
+		if (strpbrk(Tcl_GetString(pathOrDir), "\\/") == NULL) {
 		    Tcl_AppendToObj(pathOrDir, last-1, 1);
 		}
 	    }
 
 	    /*
@@ -1456,11 +1454,11 @@
 	globTypes->perm = 0;
 	globTypes->macType = NULL;
 	globTypes->macCreator = NULL;
 
 	while (--length >= 0) {
-	    size_t len;
+	    int len;
 	    const char *str;
 
 	    Tcl_ListObjIndex(interp, typePtr, length, &look);
 	    str = TclGetStringFromObj(look, &len);
 	    if (strcmp("readonly", str) == 0) {
@@ -1514,26 +1512,25 @@
 		globTypes->macType = look;
 		Tcl_IncrRefCount(look);
 
 	    } else {
 		Tcl_Obj *item;
-		int llen;
 
-		if ((Tcl_ListObjLength(NULL, look, &llen) == TCL_OK)
-			&& (llen == 3)) {
+		if ((Tcl_ListObjLength(NULL, look, &len) == TCL_OK)
+			&& (len == 3)) {
 		    Tcl_ListObjIndex(interp, look, 0, &item);
-		    if (!strcmp("macintosh", TclGetString(item))) {
+		    if (!strcmp("macintosh", Tcl_GetString(item))) {
 			Tcl_ListObjIndex(interp, look, 1, &item);
-			if (!strcmp("type", TclGetString(item))) {
+			if (!strcmp("type", Tcl_GetString(item))) {
 			    Tcl_ListObjIndex(interp, look, 2, &item);
 			    if (globTypes->macType != NULL) {
 				goto badMacTypesArg;
 			    }
 			    globTypes->macType = item;
 			    Tcl_IncrRefCount(item);
 			    continue;
-			} else if (!strcmp("creator", TclGetString(item))) {
+			} else if (!strcmp("creator", Tcl_GetString(item))) {
 			    Tcl_ListObjIndex(interp, look, 2, &item);
 			    if (globTypes->macCreator != NULL) {
 				goto badMacTypesArg;
 			    }
 			    globTypes->macCreator = item;
@@ -1549,11 +1546,11 @@
 		 */
 
 	    badTypesArg:
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"bad argument to \"-types\": %s",
-			TclGetString(look)));
+			Tcl_GetString(look)));
 		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "BAD", NULL);
 		result = TCL_ERROR;
 		join = 0;
 		goto endOfGlob;
 
@@ -1613,11 +1610,11 @@
 	    }
 	}
 	Tcl_DStringFree(&str);
     } else {
 	for (i = 0; i < objc; i++) {
-	    string = TclGetString(objv[i]);
+	    string = Tcl_GetString(objv[i]);
 	    if (TclGlob(interp, string, pathOrDir, globFlags,
 		    globTypes) != TCL_OK) {
 		result = TCL_ERROR;
 		goto endOfGlob;
 	    }
@@ -1645,11 +1642,11 @@
 	    } else {
 		const char *sep = "";
 
 		for (i = 0; i < objc; i++) {
 		    Tcl_AppendPrintfToObj(errorMsg, "%s%s",
-			    sep, TclGetString(objv[i]));
+			    sep, Tcl_GetString(objv[i]));
 		    sep = " ";
 		}
 	    }
 	    Tcl_AppendToObj(errorMsg, "\"", -1);
 	    Tcl_SetObjResult(interp, errorMsg);
@@ -1848,11 +1845,11 @@
 
 		if (cwd == NULL) {
 		    Tcl_DecrRefCount(temp);
 		    return TCL_ERROR;
 		}
-		pathPrefix = Tcl_NewStringObj(TclGetString(cwd), 3);
+		pathPrefix = Tcl_NewStringObj(Tcl_GetString(cwd), 3);
 		Tcl_DecrRefCount(cwd);
 		if (tail[0] == '/') {
 		    tail++;
 		} else {
 		    tail += 2;
@@ -1982,11 +1979,11 @@
      */
 
     if (globFlags & TCL_GLOBMODE_TAILS) {
 	int objc, i;
 	Tcl_Obj **objv;
-	size_t prefixLen;
+	int prefixLen;
 	const char *pre;
 
 	/*
 	 * If this length has never been set, set it here.
 	 */
@@ -2010,11 +2007,11 @@
 	    }
 	}
 
 	Tcl_ListObjGetElements(NULL, filenamesObj, &objc, &objv);
 	for (i = 0; i< objc; i++) {
-	    size_t len;
+	    int len;
 	    const char *oldStr = TclGetStringFromObj(objv[i], &len);
 	    Tcl_Obj *elem;
 
 	    if (len == prefixLen) {
 		if ((pattern[0] == '\0')
@@ -2078,11 +2075,11 @@
 SkipToChar(
     char **stringPtr,		/* Pointer string to check. */
     int match)			/* Character to find. */
 {
     int quoted, level;
-    register char *p;
+    char *p;
 
     quoted = 0;
     level = 0;
 
     for (p = *stringPtr; *p != '\0'; p++) {
@@ -2342,11 +2339,11 @@
 	    result = Tcl_ListObjGetElements(interp, subdirsPtr,
 		    &subdirc, &subdirv);
 	    for (i=0; result==TCL_OK && i<subdirc; i++) {
 		Tcl_Obj *copy = NULL;
 
-		if (pathPtr == NULL && TclGetString(subdirv[i])[0] == '~') {
+		if (pathPtr == NULL && Tcl_GetString(subdirv[i])[0] == '~') {
 		    Tcl_ListObjLength(NULL, matchesObj, &repair);
 		    copy = subdirv[i];
 		    subdirv[i] = Tcl_NewStringObj("./", 2);
 		    Tcl_AppendObjToObj(subdirv[i], copy);
 		    Tcl_IncrRefCount(subdirv[i]);
@@ -2359,11 +2356,11 @@
 		    Tcl_DecrRefCount(subdirv[i]);
 		    subdirv[i] = copy;
 		    Tcl_ListObjLength(NULL, matchesObj, &end);
 		    while (repair < end) {
 			const char *bytes;
-			size_t numBytes;
+			int numBytes;
 			Tcl_Obj *fixme, *newObj;
 
 			Tcl_ListObjIndex(NULL, matchesObj, repair, &fixme);
 			bytes = TclGetStringFromObj(fixme, &numBytes);
 			newObj = Tcl_NewStringObj(bytes+2, numBytes-2);
@@ -2382,11 +2379,11 @@
     /*
      * We reach here with no pattern char in current section
      */
 
     if (*p == '\0') {
-	size_t length;
+	int length;
 	Tcl_DString append;
 
 	/*
 	 * This is the code path reached by a command like 'glob foo'.
 	 *
@@ -2446,11 +2443,11 @@
 	    if (strchr(separators, Tcl_DStringValue(&append)[0]) == NULL) {
 		/*
 		 * The current prefix must end in a separator.
 		 */
 
-		size_t len;
+		int len;
 		const char *joined = TclGetStringFromObj(joinedPtr,&len);
 
 		if (strchr(separators, joined[len-1]) == NULL) {
 		    Tcl_AppendToObj(joinedPtr, "/", 1);
 		}
@@ -2483,11 +2480,11 @@
 	     * when not using -dir or -path, e.g. 'glob [file join
 	     * //machine/share/subdir *]' requires adding a separator here.
 	     * This behaviour is not currently tested for in the test suite.
 	     */
 
-	    size_t len;
+	    int len;
 	    const char *joined = TclGetStringFromObj(joinedPtr,&len);
 
 	    if (strchr(separators, joined[len-1]) == NULL) {
 		if (Tcl_FSGetPathType(pathPtr) != TCL_PATH_VOLUME_RELATIVE) {
 		    Tcl_AppendToObj(joinedPtr, "/", 1);
@@ -2513,11 +2510,11 @@
  *	extensions may be used unchanged on systems where largefile support is
  *	optional.
  *
  * Results:
  *	A pointer to a Tcl_StatBuf which may be deallocated by being passed to
- *	Tcl_Free().
+ *	ckfree().
  *
  * Side effects:
  *	None.
  *
  *---------------------------------------------------------------------------
@@ -2524,11 +2521,11 @@
  */
 
 Tcl_StatBuf *
 Tcl_AllocStatBuf(void)
 {
-    return Tcl_Alloc(sizeof(Tcl_StatBuf));
+    return ckalloc(sizeof(Tcl_StatBuf));
 }
 
 /*
  *---------------------------------------------------------------------------
  *
@@ -2629,11 +2626,11 @@
     const Tcl_StatBuf *statPtr)
 {
 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
     return (Tcl_WideUInt) statPtr->st_blocks;
 #else
-    register unsigned blksize = Tcl_GetBlockSizeFromStat(statPtr);
+    unsigned blksize = Tcl_GetBlockSizeFromStat(statPtr);
 
     return ((Tcl_WideUInt) statPtr->st_size + blksize - 1) / blksize;
 #endif
 }
 

Index: generic/tclFileSystem.h
==================================================================
--- generic/tclFileSystem.h
+++ generic/tclFileSystem.h
@@ -28,11 +28,11 @@
 MODULE_SCOPE Tcl_Obj *	TclFSMakePathRelative(Tcl_Interp *interp,
 			    Tcl_Obj *pathPtr, Tcl_Obj *cwdPtr);
 MODULE_SCOPE int	TclFSEnsureEpochOk(Tcl_Obj *pathPtr,
 			    const Tcl_Filesystem **fsPtrPtr);
 MODULE_SCOPE void	TclFSSetPathDetails(Tcl_Obj *pathPtr,
-			    const Tcl_Filesystem *fsPtr, void *clientData);
+			    const Tcl_Filesystem *fsPtr, ClientData clientData);
 MODULE_SCOPE Tcl_Obj *	TclFSNormalizeAbsolutePath(Tcl_Interp *interp,
 			    Tcl_Obj *pathPtr);
 MODULE_SCOPE size_t	TclFSEpoch(void);
 
 /*

Index: generic/tclGet.c
==================================================================
--- generic/tclGet.c
+++ generic/tclGet.c
@@ -140,11 +140,11 @@
     code = TclSetBooleanFromAny(interp, &obj);
     if (obj.refCount > 1) {
 	Tcl_Panic("invalid sharing of Tcl_Obj on C stack");
     }
     if (code == TCL_OK) {
-	*boolPtr = obj.internalRep.wideValue != 0;
+	TclGetBooleanFromObj(NULL, &obj, boolPtr);
     }
     return code;
 }
 
 /*

Index: generic/tclGetDate.y
==================================================================
--- generic/tclGetDate.y
+++ generic/tclGetDate.y
@@ -43,10 +43,18 @@
 
 #ifdef _MSC_VER
 #pragma warning( disable : 4102 )
 #endif /* _MSC_VER */
 
+/*
+ * Meridian: am, pm, or 24-hour style.
+ */
+
+typedef enum _MERIDIAN {
+    MERam, MERpm, MER24
+} MERIDIAN;
+
 /*
  * yyparse will accept a 'struct DateInfo' as its parameter; that's where the
  * parsed fields will be returned.
  */
 
@@ -61,11 +69,11 @@
     int dateHaveDate;
 
     time_t dateHour;
     time_t dateMinutes;
     time_t dateSeconds;
-    int dateMeridian;
+    MERIDIAN dateMeridian;
     int dateHaveTime;
 
     time_t dateTimezone;
     int dateDSTmode;
     int dateHaveZone;
@@ -87,12 +95,12 @@
     time_t *dateRelPointer;
 
     int dateDigitCount;
 } DateInfo;
 
-#define YYMALLOC	Tcl_Alloc
-#define YYFREE(x)	(Tcl_Free((void*) (x)))
+#define YYMALLOC	ckalloc
+#define YYFREE(x)	(ckfree((void*) (x)))
 
 #define yyDSTmode	(info->dateDSTmode)
 #define yyDayOrdinal	(info->dateDayOrdinal)
 #define yyDayNumber	(info->dateDayNumber)
 #define yyMonthOrdinal	(info->dateMonthOrdinal)
@@ -148,18 +156,10 @@
 
 typedef enum _DSTMODE {
     DSTon, DSToff, DSTmaybe
 } DSTMODE;
 
-/*
- * Meridian: am, pm, or 24-hour style.
- */
-
-typedef enum _MERIDIAN {
-    MERam, MERpm, MER24
-} MERIDIAN;
-
 %}
 
 %union {
     time_t Number;
     enum _MERIDIAN Meridian;
@@ -763,13 +763,13 @@
 static int
 LookupWord(
     YYSTYPE* yylvalPtr,
     char *buff)
 {
-    register char *p;
-    register char *q;
-    register const TABLE *tp;
+    char *p;
+    char *q;
+    const TABLE *tp;
     int i, abbrev;
 
     /*
      * Make it lowercase.
      */
@@ -888,12 +888,12 @@
 TclDatelex(
     YYSTYPE* yylvalPtr,
     YYLTYPE* location,
     DateInfo *info)
 {
-    register char c;
-    register char *p;
+    char c;
+    char *p;
     char buff[20];
     int Count;
 
     location->first_column = yyInput - info->dateStart;
     for ( ; ; ) {
@@ -1062,60 +1062,60 @@
 
     result = Tcl_NewObj();
     resultElement = Tcl_NewObj();
     if (yyHaveDate) {
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyYear));
+		Tcl_NewIntObj((int) yyYear));
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyMonth));
+		Tcl_NewIntObj((int) yyMonth));
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyDay));
+		Tcl_NewIntObj((int) yyDay));
     }
     Tcl_ListObjAppendElement(interp, result, resultElement);
 
     if (yyHaveTime) {
-	Tcl_ListObjAppendElement(interp, result, Tcl_NewIntObj(
+	Tcl_ListObjAppendElement(interp, result, Tcl_NewIntObj((int)
 		ToSeconds(yyHour, yyMinutes, yySeconds, yyMeridian)));
     } else {
 	Tcl_ListObjAppendElement(interp, result, Tcl_NewObj());
     }
 
     resultElement = Tcl_NewObj();
     if (yyHaveZone) {
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(-yyTimezone));
+		Tcl_NewIntObj((int) -yyTimezone));
 	Tcl_ListObjAppendElement(interp, resultElement,
 		Tcl_NewIntObj(1 - yyDSTmode));
     }
     Tcl_ListObjAppendElement(interp, result, resultElement);
 
     resultElement = Tcl_NewObj();
     if (yyHaveRel) {
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyRelMonth));
+		Tcl_NewIntObj((int) yyRelMonth));
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyRelDay));
+		Tcl_NewIntObj((int) yyRelDay));
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyRelSeconds));
+		Tcl_NewIntObj((int) yyRelSeconds));
     }
     Tcl_ListObjAppendElement(interp, result, resultElement);
 
     resultElement = Tcl_NewObj();
     if (yyHaveDay && !yyHaveDate) {
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyDayOrdinal));
+		Tcl_NewIntObj((int) yyDayOrdinal));
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyDayNumber));
+		Tcl_NewIntObj((int) yyDayNumber));
     }
     Tcl_ListObjAppendElement(interp, result, resultElement);
 
     resultElement = Tcl_NewObj();
     if (yyHaveOrdinalMonth) {
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyMonthOrdinal));
+		Tcl_NewIntObj((int) yyMonthOrdinal));
 	Tcl_ListObjAppendElement(interp, resultElement,
-		Tcl_NewIntObj(yyMonth));
+		Tcl_NewIntObj((int) yyMonth));
     }
     Tcl_ListObjAppendElement(interp, result, resultElement);
 
     Tcl_SetObjResult(interp, result);
     return TCL_OK;

Index: generic/tclHash.c
==================================================================
--- generic/tclHash.c
+++ generic/tclHash.c
@@ -11,10 +11,17 @@
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  */
 
 #include "tclInt.h"
 
+/*
+ * Prevent macros from clashing with function definitions.
+ */
+
+#undef Tcl_FindHashEntry
+#undef Tcl_CreateHashEntry
+
 /*
  * When there are this many entries per bucket, on average, rebuild the hash
  * table to make it larger.
  */
 
@@ -26,11 +33,11 @@
  * preliminary values that are arbitrarily similar will end up in different
  * buckets. The hash function was taken from a random-number generator.
  */
 
 #define RANDOM_INDEX(tablePtr, i) \
-    ((((i)*(size_t)1103515245) >> (tablePtr)->downShift) & (tablePtr)->mask)
+    ((((i)*1103515245L) >> (tablePtr)->downShift) & (tablePtr)->mask)
 
 /*
  * Prototypes for the array hash key methods.
  */
 
@@ -104,11 +111,11 @@
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_InitHashTable(
-    register Tcl_HashTable *tablePtr,
+    Tcl_HashTable *tablePtr,
 				/* Pointer to table record, which is supplied
 				 * by the caller. */
     int keyType)		/* Type of keys to use in table:
 				 * TCL_STRING_KEYS, TCL_ONE_WORD_KEYS, or an
 				 * integer >= 2. */
@@ -142,11 +149,11 @@
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_InitCustomHashTable(
-    register Tcl_HashTable *tablePtr,
+    Tcl_HashTable *tablePtr,
 				/* Pointer to table record, which is supplied
 				 * by the caller. */
     int keyType,		/* Type of keys to use in table:
 				 * TCL_STRING_KEYS, TCL_ONE_WORD_KEYS,
 				 * TCL_CUSTOM_TYPE_KEYS, TCL_CUSTOM_PTR_KEYS,
@@ -191,11 +198,11 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * FindHashEntry --
+ * Tcl_FindHashEntry --
  *
  *	Given a hash table find the entry with a matching key.
  *
  * Results:
  *	The return value is a token for the matching entry in the hash table,
@@ -204,10 +211,18 @@
  * Side effects:
  *	None.
  *
  *----------------------------------------------------------------------
  */
+
+Tcl_HashEntry *
+Tcl_FindHashEntry(
+    Tcl_HashTable *tablePtr,	/* Table in which to lookup entry. */
+    const void *key)		/* Key to use to find matching entry. */
+{
+    return (*((tablePtr)->findProc))(tablePtr, key);
+}
 
 static Tcl_HashEntry *
 FindHashEntry(
     Tcl_HashTable *tablePtr,	/* Table in which to lookup entry. */
     const char *key)		/* Key to use to find matching entry. */
@@ -217,11 +232,11 @@
 
 
 /*
  *----------------------------------------------------------------------
  *
- * CreateHashEntry --
+ * Tcl_CreateHashEntry --
  *
  *	Given a hash table with string keys, and a string key, find the entry
  *	with a matching key. If there is no matching entry, then create a new
  *	entry that does match.
  *
@@ -234,22 +249,34 @@
  * Side effects:
  *	A new entry may be added to the hash table.
  *
  *----------------------------------------------------------------------
  */
+
+Tcl_HashEntry *
+Tcl_CreateHashEntry(
+    Tcl_HashTable *tablePtr,	/* Table in which to lookup entry. */
+    const void *key,		/* Key to use to find or create matching
+				 * entry. */
+    int *newPtr)		/* Store info here telling whether a new entry
+				 * was created. */
+{
+    return (*((tablePtr)->createProc))(tablePtr, key, newPtr);
+}
 
 static Tcl_HashEntry *
 CreateHashEntry(
     Tcl_HashTable *tablePtr,	/* Table in which to lookup entry. */
     const char *key,		/* Key to use to find or create matching
 				 * entry. */
     int *newPtr)		/* Store info here telling whether a new entry
 				 * was created. */
 {
-    register Tcl_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     const Tcl_HashKeyType *typePtr;
-    size_t hash, index;
+    unsigned int hash;
+    int index;
 
     if (tablePtr->keyType == TCL_STRING_KEYS) {
 	typePtr = &tclStringHashKeyType;
     } else if (tablePtr->keyType == TCL_ONE_WORD_KEYS) {
 	typePtr = &tclOneWordHashKeyType;
@@ -266,11 +293,11 @@
 	    index = RANDOM_INDEX(tablePtr, hash);
 	} else {
 	    index = hash & tablePtr->mask;
 	}
     } else {
-	hash = (size_t) key;
+	hash = PTR2UINT(key);
 	index = RANDOM_INDEX(tablePtr, hash);
     }
 
     /*
      * Search all of the entries in the appropriate bucket.
@@ -279,11 +306,11 @@
     if (typePtr->compareKeysProc) {
 	Tcl_CompareHashKeysProc *compareKeysProc = typePtr->compareKeysProc;
 
 	for (hPtr = tablePtr->buckets[index]; hPtr != NULL;
 		hPtr = hPtr->nextPtr) {
-	    if (hash != hPtr->hash) {
+	    if (hash != PTR2UINT(hPtr->hash)) {
 		continue;
 	    }
 	    /* if keys pointers or values are equal */
 	    if ((key == hPtr->key.oneWordValue)
 		|| compareKeysProc((void *) key, hPtr)
@@ -295,11 +322,11 @@
 	    }
 	}
     } else {
 	for (hPtr = tablePtr->buckets[index]; hPtr != NULL;
 		hPtr = hPtr->nextPtr) {
-	    if (hash != hPtr->hash) {
+	    if (hash != PTR2UINT(hPtr->hash)) {
 		continue;
 	    }
 	    if (key == hPtr->key.oneWordValue) {
 		if (newPtr) {
 		    *newPtr = 0;
@@ -319,17 +346,17 @@
 
     *newPtr = 1;
     if (typePtr->allocEntryProc) {
 	hPtr = typePtr->allocEntryProc(tablePtr, (void *) key);
     } else {
-	hPtr = Tcl_Alloc(sizeof(Tcl_HashEntry));
+	hPtr = ckalloc(sizeof(Tcl_HashEntry));
 	hPtr->key.oneWordValue = (char *) key;
-	Tcl_SetHashValue(hPtr, NULL);
+	hPtr->clientData = 0;
     }
 
     hPtr->tablePtr = tablePtr;
-    hPtr->hash = hash;
+    hPtr->hash = UINT2PTR(hash);
     hPtr->nextPtr = tablePtr->buckets[index];
     tablePtr->buckets[index] = hPtr;
     tablePtr->numEntries++;
 
     /*
@@ -363,15 +390,15 @@
 
 void
 Tcl_DeleteHashEntry(
     Tcl_HashEntry *entryPtr)
 {
-    register Tcl_HashEntry *prevPtr;
+    Tcl_HashEntry *prevPtr;
     const Tcl_HashKeyType *typePtr;
     Tcl_HashTable *tablePtr;
     Tcl_HashEntry **bucketPtr;
-    size_t index;
+    int index;
 
     tablePtr = entryPtr->tablePtr;
 
     if (tablePtr->keyType == TCL_STRING_KEYS) {
 	typePtr = &tclStringHashKeyType;
@@ -384,13 +411,13 @@
 	typePtr = &tclArrayHashKeyType;
     }
 
     if (typePtr->hashKeyProc == NULL
 	    || typePtr->flags & TCL_HASH_KEY_RANDOMIZE_HASH) {
-	index = RANDOM_INDEX(tablePtr, entryPtr->hash);
+	index = RANDOM_INDEX(tablePtr, PTR2INT(entryPtr->hash));
     } else {
-	index = entryPtr->hash & tablePtr->mask;
+	index = PTR2UINT(entryPtr->hash) & tablePtr->mask;
     }
 
     bucketPtr = &tablePtr->buckets[index];
 
     if (*bucketPtr == entryPtr) {
@@ -409,11 +436,11 @@
 
     tablePtr->numEntries--;
     if (typePtr->freeEntryProc) {
 	typePtr->freeEntryProc(entryPtr);
     } else {
-	Tcl_Free(entryPtr);
+	ckfree(entryPtr);
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -432,15 +459,15 @@
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_DeleteHashTable(
-    register Tcl_HashTable *tablePtr)	/* Table to delete. */
+    Tcl_HashTable *tablePtr)	/* Table to delete. */
 {
-    register Tcl_HashEntry *hPtr, *nextPtr;
+    Tcl_HashEntry *hPtr, *nextPtr;
     const Tcl_HashKeyType *typePtr;
-    size_t i;
+    int i;
 
     if (tablePtr->keyType == TCL_STRING_KEYS) {
 	typePtr = &tclStringHashKeyType;
     } else if (tablePtr->keyType == TCL_ONE_WORD_KEYS) {
 	typePtr = &tclOneWordHashKeyType;
@@ -460,11 +487,11 @@
 	while (hPtr != NULL) {
 	    nextPtr = hPtr->nextPtr;
 	    if (typePtr->freeEntryProc) {
 		typePtr->freeEntryProc(hPtr);
 	    } else {
-		Tcl_Free(hPtr);
+		ckfree(hPtr);
 	    }
 	    hPtr = nextPtr;
 	}
     }
 
@@ -474,11 +501,11 @@
 
     if (tablePtr->buckets != tablePtr->staticBuckets) {
 	if (typePtr->flags & TCL_HASH_KEY_SYSTEM_HASH) {
 	    TclpSysFree((char *) tablePtr->buckets);
 	} else {
-	    Tcl_Free(tablePtr->buckets);
+	    ckfree(tablePtr->buckets);
 	}
     }
 
     /*
      * Arrange for panics if the table is used again without
@@ -540,11 +567,11 @@
  *----------------------------------------------------------------------
  */
 
 Tcl_HashEntry *
 Tcl_NextHashEntry(
-    register Tcl_HashSearch *searchPtr)
+    Tcl_HashSearch *searchPtr)
 				/* Place to store information about progress
 				 * through the table. Must have been
 				 * initialized by calling
 				 * Tcl_FirstHashEntry. */
 {
@@ -585,13 +612,13 @@
 char *
 Tcl_HashStats(
     Tcl_HashTable *tablePtr)	/* Table for which to produce stats. */
 {
 #define NUM_COUNTERS 10
-    size_t count[NUM_COUNTERS], overflow, i, j;
+    int count[NUM_COUNTERS], overflow, i, j;
     double average, tmp;
-    register Tcl_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     char *result, *p;
 
     /*
      * Compute a histogram of bucket usage.
      */
@@ -619,20 +646,20 @@
 
     /*
      * Print out the histogram and a few other pieces of information.
      */
 
-    result = Tcl_Alloc((NUM_COUNTERS * 60) + 300);
-    sprintf(result, "%" TCL_Z_MODIFIER "u entries in table, %" TCL_Z_MODIFIER "u buckets\n",
+    result = ckalloc((NUM_COUNTERS * 60) + 300);
+    sprintf(result, "%d entries in table, %d buckets\n",
 	    tablePtr->numEntries, tablePtr->numBuckets);
     p = result + strlen(result);
     for (i = 0; i < NUM_COUNTERS; i++) {
-	sprintf(p, "number of buckets with %" TCL_Z_MODIFIER "u entries: %" TCL_Z_MODIFIER "u\n",
+	sprintf(p, "number of buckets with %d entries: %d\n",
 		i, count[i]);
 	p += strlen(p);
     }
-    sprintf(p, "number of buckets with %d or more entries: %" TCL_Z_MODIFIER "u\n",
+    sprintf(p, "number of buckets with %d or more entries: %d\n",
 	    NUM_COUNTERS, overflow);
     p += strlen(p);
     sprintf(p, "average search distance for entry: %.1f", average);
     return result;
 }
@@ -654,31 +681,31 @@
  */
 
 static Tcl_HashEntry *
 AllocArrayEntry(
     Tcl_HashTable *tablePtr,	/* Hash table. */
-    void *keyPtr)			/* Key to store in the hash table entry. */
+    void *keyPtr)		/* Key to store in the hash table entry. */
 {
     int *array = (int *) keyPtr;
-    register int *iPtr1, *iPtr2;
+    int *iPtr1, *iPtr2;
     Tcl_HashEntry *hPtr;
     int count;
-    size_t size;
+    unsigned int size;
 
     count = tablePtr->keyType;
 
     size = sizeof(Tcl_HashEntry) + (count*sizeof(int)) - sizeof(hPtr->key);
     if (size < sizeof(Tcl_HashEntry)) {
 	size = sizeof(Tcl_HashEntry);
     }
-    hPtr = Tcl_Alloc(size);
+    hPtr = ckalloc(size);
 
     for (iPtr1 = array, iPtr2 = hPtr->key.words;
 	    count > 0; count--, iPtr1++, iPtr2++) {
 	*iPtr2 = *iPtr1;
     }
-    Tcl_SetHashValue(hPtr, NULL);
+    hPtr->clientData = 0;
 
     return hPtr;
 }
 
 /*
@@ -698,15 +725,15 @@
  *----------------------------------------------------------------------
  */
 
 static int
 CompareArrayKeys(
-    void *keyPtr,			/* New key to compare. */
+    void *keyPtr,		/* New key to compare. */
     Tcl_HashEntry *hPtr)	/* Existing key to compare. */
 {
-    const int *iPtr1 = keyPtr;
-    const int *iPtr2 = hPtr->key.words;
+    const int *iPtr1 = (const int *) keyPtr;
+    const int *iPtr2 = (const int *) hPtr->key.words;
     Tcl_HashTable *tablePtr = hPtr->tablePtr;
     int count;
 
     for (count = tablePtr->keyType; ; count--, iPtr1++, iPtr2++) {
 	if (count == 0) {
@@ -738,21 +765,21 @@
  */
 
 static TCL_HASH_TYPE
 HashArrayKey(
     Tcl_HashTable *tablePtr,	/* Hash table. */
-    void *keyPtr)				/* Key from which to compute hash value. */
+    void *keyPtr)		/* Key from which to compute hash value. */
 {
-    register const int *array = (const int *) keyPtr;
-    register TCL_HASH_TYPE result;
+    const int *array = (const int *) keyPtr;
+    unsigned int result;
     int count;
 
     for (result = 0, count = tablePtr->keyType; count > 0;
 	    count--, array++) {
 	result += *array;
     }
-    return result;
+    return (TCL_HASH_TYPE) result;
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -770,23 +797,24 @@
  */
 
 static Tcl_HashEntry *
 AllocStringEntry(
     Tcl_HashTable *tablePtr,	/* Hash table. */
-    void *keyPtr)			/* Key to store in the hash table entry. */
+    void *keyPtr)		/* Key to store in the hash table entry. */
 {
     const char *string = (const char *) keyPtr;
     Tcl_HashEntry *hPtr;
-    size_t size, allocsize;
+    unsigned int size, allocsize;
 
     allocsize = size = strlen(string) + 1;
     if (size < sizeof(hPtr->key)) {
 	allocsize = sizeof(hPtr->key);
     }
-    hPtr = Tcl_Alloc(offsetof(Tcl_HashEntry, key) + allocsize);
+    hPtr = ckalloc(offsetof(Tcl_HashEntry, key) + allocsize);
+    memset(hPtr, 0, sizeof(Tcl_HashEntry) + allocsize - sizeof(hPtr->key));
     memcpy(hPtr->key.string, string, size);
-    Tcl_SetHashValue(hPtr, NULL);
+    hPtr->clientData = 0;
     return hPtr;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -805,14 +833,17 @@
  *----------------------------------------------------------------------
  */
 
 static int
 CompareStringKeys(
-    void *keyPtr,			/* New key to compare. */
+    void *keyPtr,		/* New key to compare. */
     Tcl_HashEntry *hPtr)	/* Existing key to compare. */
 {
-    return !strcmp(keyPtr, hPtr->key.string);
+    const char *p1 = (const char *) keyPtr;
+    const char *p2 = (const char *) hPtr->key.string;
+
+    return !strcmp(p1, p2);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -831,15 +862,15 @@
  */
 
 static TCL_HASH_TYPE
 HashStringKey(
     Tcl_HashTable *tablePtr,	/* Hash table. */
-    void *keyPtr)			/* Key from which to compute hash value. */
+    void *keyPtr)		/* Key from which to compute hash value. */
 {
-    register const char *string = keyPtr;
-    register TCL_HASH_TYPE result;
-    register char c;
+    const char *string = keyPtr;
+    unsigned int result;
+    char c;
 
     /*
      * I tried a zillion different hash functions and asked many other people
      * for advice. Many people had their own favorite functions, all
      * different, but no-one had much idea why they were good ones. I chose
@@ -874,11 +905,11 @@
     if ((result = UCHAR(*string)) != 0) {
 	while ((c = *++string) != 0) {
 	    result += (result << 3) + UCHAR(c);
 	}
     }
-    return result;
+    return (TCL_HASH_TYPE) result;
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -954,20 +985,20 @@
  *----------------------------------------------------------------------
  */
 
 static void
 RebuildTable(
-    register Tcl_HashTable *tablePtr)	/* Table to enlarge. */
+    Tcl_HashTable *tablePtr)	/* Table to enlarge. */
 {
-    size_t count, index, oldSize = tablePtr->numBuckets;
+    int count, index, oldSize = tablePtr->numBuckets;
     Tcl_HashEntry **oldBuckets = tablePtr->buckets;
-    register Tcl_HashEntry **oldChainPtr, **newChainPtr;
-    register Tcl_HashEntry *hPtr;
+    Tcl_HashEntry **oldChainPtr, **newChainPtr;
+    Tcl_HashEntry *hPtr;
     const Tcl_HashKeyType *typePtr;
 
     /* Avoid outgrowing capability of the memory allocators */
-    if (oldSize > UINT_MAX / (4 * sizeof(Tcl_HashEntry *))) {
+    if (oldSize > (int)(UINT_MAX / (4 * sizeof(Tcl_HashEntry *)))) {
 	tablePtr->rebuildSize = INT_MAX;
 	return;
     }
 
     if (tablePtr->keyType == TCL_STRING_KEYS) {
@@ -986,24 +1017,22 @@
      * constants for new array size.
      */
 
     tablePtr->numBuckets *= 4;
     if (typePtr->flags & TCL_HASH_KEY_SYSTEM_HASH) {
-	tablePtr->buckets = TclpSysAlloc(
-		tablePtr->numBuckets * sizeof(Tcl_HashEntry *));
+	tablePtr->buckets = (Tcl_HashEntry **) TclpSysAlloc(
+		tablePtr->numBuckets * sizeof(Tcl_HashEntry *), 0);
     } else {
 	tablePtr->buckets =
-		Tcl_Alloc(tablePtr->numBuckets * sizeof(Tcl_HashEntry *));
+		ckalloc(tablePtr->numBuckets * sizeof(Tcl_HashEntry *));
     }
     for (count = tablePtr->numBuckets, newChainPtr = tablePtr->buckets;
 	    count > 0; count--, newChainPtr++) {
 	*newChainPtr = NULL;
     }
     tablePtr->rebuildSize *= 4;
-    if (tablePtr->downShift > 1) {
-	tablePtr->downShift -= 2;
-    }
+    tablePtr->downShift -= 2;
     tablePtr->mask = (tablePtr->mask << 2) + 3;
 
     /*
      * Rehash all of the existing entries into the new bucket array.
      */
@@ -1011,13 +1040,13 @@
     for (oldChainPtr = oldBuckets; oldSize > 0; oldSize--, oldChainPtr++) {
 	for (hPtr = *oldChainPtr; hPtr != NULL; hPtr = *oldChainPtr) {
 	    *oldChainPtr = hPtr->nextPtr;
 	    if (typePtr->hashKeyProc == NULL
 		    || typePtr->flags & TCL_HASH_KEY_RANDOMIZE_HASH) {
-		index = RANDOM_INDEX(tablePtr, hPtr->hash);
+		index = RANDOM_INDEX(tablePtr, PTR2INT(hPtr->hash));
 	    } else {
-		index = hPtr->hash & tablePtr->mask;
+		index = PTR2UINT(hPtr->hash) & tablePtr->mask;
 	    }
 	    hPtr->nextPtr = tablePtr->buckets[index];
 	    tablePtr->buckets[index] = hPtr;
 	}
     }
@@ -1028,11 +1057,11 @@
 
     if (oldBuckets != tablePtr->staticBuckets) {
 	if (typePtr->flags & TCL_HASH_KEY_SYSTEM_HASH) {
 	    TclpSysFree((char *) oldBuckets);
 	} else {
-	    Tcl_Free(oldBuckets);
+	    ckfree(oldBuckets);
 	}
     }
 }
 
 /*

Index: generic/tclHistory.c
==================================================================
--- generic/tclHistory.c
+++ generic/tclHistory.c
@@ -59,11 +59,11 @@
     int flags)			/* Additional flags. TCL_NO_EVAL means only
 				 * record: don't execute command.
 				 * TCL_EVAL_GLOBAL means use Tcl_GlobalEval
 				 * instead of Tcl_Eval. */
 {
-    register Tcl_Obj *cmdPtr;
+    Tcl_Obj *cmdPtr;
     int result;
 
     if (cmd[0]) {
 	/*
 	 * Call Tcl_RecordAndEvalObj to do the actual work.
@@ -71,10 +71,17 @@
 
 	cmdPtr = Tcl_NewStringObj(cmd, -1);
 	Tcl_IncrRefCount(cmdPtr);
 	result = Tcl_RecordAndEvalObj(interp, cmdPtr, flags);
 
+	/*
+	 * Move the interpreter's object result to the string result, then
+	 * reset the object result.
+	 */
+
+	(void) Tcl_GetStringResult(interp);
+
 	/*
 	 * Discard the Tcl object created to hold the command.
 	 */
 
 	Tcl_DecrRefCount(cmdPtr);
@@ -128,11 +135,11 @@
     /*
      * Create the references to the [::history add] command if necessary.
      */
 
     if (histObjsPtr == NULL) {
-	histObjsPtr = Tcl_Alloc(sizeof(HistoryObjs));
+	histObjsPtr = ckalloc(sizeof(HistoryObjs));
 	TclNewLiteralStringObj(histObjsPtr->historyObj, "::history");
 	TclNewLiteralStringObj(histObjsPtr->addObj, "add");
 	Tcl_IncrRefCount(histObjsPtr->historyObj);
 	Tcl_IncrRefCount(histObjsPtr->addObj);
 	Tcl_SetAssocData(interp, HISTORY_OBJS_KEY, DeleteHistoryObjs,
@@ -204,19 +211,19 @@
 static void
 DeleteHistoryObjs(
     ClientData clientData,
     Tcl_Interp *interp)
 {
-    register HistoryObjs *histObjsPtr = clientData;
+    HistoryObjs *histObjsPtr = clientData;
 
     TclDecrRefCount(histObjsPtr->historyObj);
     TclDecrRefCount(histObjsPtr->addObj);
-    Tcl_Free(histObjsPtr);
+    ckfree(histObjsPtr);
 }
 
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 4
  * fill-column: 78
  * End:
  */

Index: generic/tclIO.c
==================================================================
--- generic/tclIO.c
+++ generic/tclIO.c
@@ -189,13 +189,13 @@
 			    Channel *chanPtr, int mask);
 static int		DetachChannel(Tcl_Interp *interp, Tcl_Channel chan);
 static void		DiscardInputQueued(ChannelState *statePtr,
 			    int discardSavedBuffers);
 static void		DiscardOutputQueued(ChannelState *chanPtr);
-static int		DoRead(Channel *chanPtr, char *dst, size_t bytesToRead,
+static int		DoRead(Channel *chanPtr, char *dst, int bytesToRead,
 			    int allowShortReads);
-static int		DoReadChars(Channel *chan, Tcl_Obj *objPtr, size_t toRead,
+static int		DoReadChars(Channel *chan, Tcl_Obj *objPtr, int toRead,
 			    int appendFlag);
 static int		FilterInputBytes(Channel *chanPtr,
 			    GetsState *statePtr);
 static int		FlushChannel(Tcl_Interp *interp, Channel *chanPtr,
 			    int calledFromAsyncFlush);
@@ -237,11 +237,11 @@
  * Simplifying helper macros. All may use their argument(s) multiple times.
  * The ANSI C "prototypes" for the macros are listed below, together with a
  * short description of what the macro does.
  *
  * --------------------------------------------------------------------------
- * size_t BytesLeft(ChannelBuffer *bufPtr)
+ * int BytesLeft(ChannelBuffer *bufPtr)
  *
  *	Returns the number of bytes of data remaining in the buffer.
  *
  * int SpaceLeft(ChannelBuffer *bufPtr)
  *
@@ -275,13 +275,13 @@
  *	Returns a pointer to where characters should be removed from the
  *	buffer.
  * --------------------------------------------------------------------------
  */
 
-#define BytesLeft(bufPtr)	((size_t)((bufPtr)->nextAdded - (bufPtr)->nextRemoved))
+#define BytesLeft(bufPtr)	((bufPtr)->nextAdded - (bufPtr)->nextRemoved)
 
-#define SpaceLeft(bufPtr)	((size_t)((bufPtr)->bufLength - (bufPtr)->nextAdded))
+#define SpaceLeft(bufPtr)	((bufPtr)->bufLength - (bufPtr)->nextAdded)
 
 #define IsBufferReady(bufPtr)	((bufPtr)->nextAdded > (bufPtr)->nextRemoved)
 
 #define IsBufferEmpty(bufPtr)	((bufPtr)->nextAdded == (bufPtr)->nextRemoved)
 
@@ -438,11 +438,11 @@
     if (GotFlag(chanPtr->state, CHANNEL_EOF)) {
         chanPtr->state->inputEncodingFlags |= TCL_ENCODING_START;
     }
     ResetFlag(chanPtr->state, CHANNEL_BLOCKED | CHANNEL_EOF);
     chanPtr->state->inputEncodingFlags &= ~TCL_ENCODING_END;
-    if (WillRead(chanPtr) == -1) {
+    if (WillRead(chanPtr) < 0) {
         return -1;
     }
 
     bytesRead = chanPtr->typePtr->inputProc(chanPtr->instanceData,
 	    dst, dstSize, &result);
@@ -454,20 +454,11 @@
     if (GotFlag(chanPtr->state, CHANNEL_EOF)) {
         chanPtr->state->inputEncodingFlags |= TCL_ENCODING_START;
     }
     ResetFlag(chanPtr->state, CHANNEL_BLOCKED | CHANNEL_EOF);
     chanPtr->state->inputEncodingFlags &= ~TCL_ENCODING_END;
-    if (bytesRead == -1) {
-	if ((result == EWOULDBLOCK) || (result == EAGAIN)) {
-	    SetFlag(chanPtr->state, CHANNEL_BLOCKED);
-	    result = EAGAIN;
-	}
-	Tcl_SetErrno(result);
-    } else if (bytesRead == 0) {
-	SetFlag(chanPtr->state, CHANNEL_EOF);
-	chanPtr->state->inputEncodingFlags |= TCL_ENCODING_END;
-    } else {
+    if (bytesRead > 0) {
 	/*
 	 * If we get a short read, signal up that we may be BLOCKED. We should
 	 * avoid calling the driver because on some platforms we will block in
 	 * the low level reading code even though the channel is set into
 	 * nonblocking mode.
@@ -474,10 +465,19 @@
 	 */
 
 	if (bytesRead < dstSize) {
 	    SetFlag(chanPtr->state, CHANNEL_BLOCKED);
 	}
+    } else if (bytesRead == 0) {
+	SetFlag(chanPtr->state, CHANNEL_EOF);
+	chanPtr->state->inputEncodingFlags |= TCL_ENCODING_END;
+    } else if (bytesRead < 0) {
+	if ((result == EWOULDBLOCK) || (result == EAGAIN)) {
+	    SetFlag(chanPtr->state, CHANNEL_BLOCKED);
+	    result = EAGAIN;
+	}
+	Tcl_SetErrno(result);
     }
     return bytesRead;
 }
 
 static inline Tcl_WideInt
@@ -671,11 +671,11 @@
 		 */
 
 		statePtr->refCount--;
 	    }
 
-	    if (statePtr->refCount + 1 <= 1) {
+	    if (statePtr->refCount <= 0) {
 		/*
 		 * Close it only if the refcount indicates that the channel is
 		 * not referenced from any interpreter. If it is, that
 		 * interpreter will close the channel when it gets destroyed.
 		 */
@@ -858,11 +858,11 @@
 				 * callback. */
 {
     ChannelState *statePtr = ((Channel *) chan)->state;
     CloseCallback *cbPtr;
 
-    cbPtr = Tcl_Alloc(sizeof(CloseCallback));
+    cbPtr = ckalloc(sizeof(CloseCallback));
     cbPtr->proc = proc;
     cbPtr->clientData = clientData;
 
     cbPtr->nextPtr = statePtr->closeCbPtr;
     statePtr->closeCbPtr = cbPtr;
@@ -904,11 +904,11 @@
 	    if (cbPrevPtr == NULL) {
 		statePtr->closeCbPtr = cbPtr->nextPtr;
 	    } else {
 		cbPrevPtr->nextPtr = cbPtr->nextPtr;
 	    }
-	    Tcl_Free(cbPtr);
+	    ckfree(cbPtr);
 	    break;
 	}
 	cbPrevPtr = cbPtr;
     }
 }
@@ -939,11 +939,11 @@
     Tcl_HashTable *hTblPtr;	/* Hash table of channels. */
     Tcl_Channel stdinChan, stdoutChan, stderrChan;
 
     hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
     if (hTblPtr == NULL) {
-	hTblPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+	hTblPtr = ckalloc(sizeof(Tcl_HashTable));
 	Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS);
 	Tcl_SetAssocData(interp, "tclIO",
 		(Tcl_InterpDeleteProc *) DeleteChannelTable, hTblPtr);
 
 	/*
@@ -1031,11 +1031,11 @@
 
 		Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
 			TclChannelEventScriptInvoker, sPtr);
 
 		TclDecrRefCount(sPtr->scriptPtr);
-		Tcl_Free(sPtr);
+		ckfree(sPtr);
 	    } else {
 		prevPtr = sPtr;
 	    }
 	}
 
@@ -1054,11 +1054,11 @@
 	    }
 	}
 
     }
     Tcl_DeleteHashTable(hTblPtr);
-    Tcl_Free(hTblPtr);
+    ckfree(hTblPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1089,27 +1089,27 @@
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     if (tsdPtr->stdinInitialized == 1
 	    && tsdPtr->stdinChannel != NULL
 	    && statePtr == ((Channel *)tsdPtr->stdinChannel)->state) {
-	if (statePtr->refCount + 1 < 3) {
+	if (statePtr->refCount < 2) {
 	    statePtr->refCount = 0;
 	    tsdPtr->stdinChannel = NULL;
 	    return;
 	}
     } else if (tsdPtr->stdoutInitialized == 1
 	    && tsdPtr->stdoutChannel != NULL
 	    && statePtr == ((Channel *)tsdPtr->stdoutChannel)->state) {
-	if (statePtr->refCount + 1 < 3) {
+	if (statePtr->refCount < 2) {
 	    statePtr->refCount = 0;
 	    tsdPtr->stdoutChannel = NULL;
 	    return;
 	}
     } else if (tsdPtr->stderrInitialized == 1
 	    && tsdPtr->stderrChannel != NULL
 	    && statePtr == ((Channel *)tsdPtr->stderrChannel)->state) {
-	if (statePtr->refCount + 1 < 3) {
+	if (statePtr->refCount < 2) {
 	    statePtr->refCount = 0;
 	    tsdPtr->stderrChannel = NULL;
 	    return;
 	}
     }
@@ -1267,11 +1267,11 @@
 
     /*
      * If the refCount reached zero, close the actual channel.
      */
 
-    if (statePtr->refCount + 1 <= 1) {
+    if (statePtr->refCount <= 0) {
 	Tcl_Preserve(statePtr);
 	if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED)) {
 	    /*
 	     * We don't want to re-enter Tcl_Close().
 	     */
@@ -1561,19 +1561,19 @@
     if (resPtr && resPtr->refCount == 1) {
 	/*
          * Re-use the ResolvedCmdName struct.
          */
 
-	Tcl_Release(resPtr->statePtr);
+	Tcl_Release((ClientData) resPtr->statePtr);
     } else {
-	resPtr = (ResolvedChanName *) Tcl_Alloc(sizeof(ResolvedChanName));
+	resPtr = (ResolvedChanName *) ckalloc(sizeof(ResolvedChanName));
 	resPtr->refCount = 0;
 	ChanSetIntRep(objPtr, resPtr);		/* Overwrites, if needed */
     }
     statePtr = ((Channel *)chan)->state;
     resPtr->statePtr = statePtr;
-    Tcl_Preserve(statePtr);
+    Tcl_Preserve((ClientData) statePtr);
     resPtr->interp = interp;
     resPtr->epoch = statePtr->epoch;
 
   valid:
     *channelPtr = (Tcl_Channel) statePtr->bottomChanPtr;
@@ -1647,12 +1647,12 @@
     /*
      * JH: We could subsequently memset these to 0 to avoid the numerous
      * assignments to 0/NULL below.
      */
 
-    chanPtr = Tcl_Alloc(sizeof(Channel));
-    statePtr = Tcl_Alloc(sizeof(ChannelState));
+    chanPtr = ckalloc(sizeof(Channel));
+    statePtr = ckalloc(sizeof(ChannelState));
     chanPtr->state = statePtr;
 
     chanPtr->instanceData = instanceData;
     chanPtr->typePtr = typePtr;
 
@@ -1667,14 +1667,14 @@
 	/*
          * Make sure we allocate at least 7 bytes, so it fits for "stdout"
          * later.
          */
 
-	tmp = Tcl_Alloc((len < 7) ? 7 : len);
+	tmp = ckalloc((len < 7) ? 7 : len);
 	strcpy(tmp, chanName);
     } else {
-	tmp = Tcl_Alloc(7);
+	tmp = ckalloc(7);
 	tmp[0] = '\0';
     }
     statePtr->channelName = tmp;
     statePtr->flags = mask;
 
@@ -1943,11 +1943,11 @@
 
 	statePtr->inQueueHead = NULL;
 	statePtr->inQueueTail = NULL;
     }
 
-    chanPtr = Tcl_Alloc(sizeof(Channel));
+    chanPtr = ckalloc(sizeof(Channel));
 
     /*
      * Save some of the current state into the new structure, reinitialize the
      * parts which will stay with the transformation.
      *
@@ -2005,20 +2005,20 @@
     }
     if (--chanPtr->refCount) {
 	return;
     }
     if (chanPtr->typePtr == NULL) {
-	Tcl_Free(chanPtr);
+	ckfree(chanPtr);
     }
 }
 
 static void
 ChannelFree(
     Channel *chanPtr)
 {
-    if (!chanPtr->refCount) {
-	Tcl_Free(chanPtr);
+    if (chanPtr->refCount == 0) {
+	ckfree(chanPtr);
 	return;
     }
     chanPtr->typePtr = NULL;
 }
 
@@ -2185,11 +2185,11 @@
 	/*
 	 * This channel does not cover another one. Simply do a close, if
 	 * necessary.
 	 */
 
-	if (statePtr->refCount + 1 <= 1) {
+	if (statePtr->refCount <= 0) {
 	    if (Tcl_Close(interp, chan) != TCL_OK) {
 		/*
 		 * TIP #219, Tcl Channel Reflection API.
 		 * "TclChanCaughtErrorBypass" is not required here, it was
 		 * done already by "Tcl_Close".
@@ -2472,11 +2472,11 @@
 {
     ChannelBuffer *bufPtr;
     int n;
 
     n = length + CHANNELBUFFER_HEADER_SIZE + BUFFER_PADDING + BUFFER_PADDING;
-    bufPtr = Tcl_Alloc(n);
+    bufPtr = ckalloc(n);
     bufPtr->nextAdded	= BUFFER_PADDING;
     bufPtr->nextRemoved	= BUFFER_PADDING;
     bufPtr->bufLength	= length + BUFFER_PADDING;
     bufPtr->nextPtr	= NULL;
     bufPtr->refCount	= 1;
@@ -2485,11 +2485,11 @@
 
 static void
 PreserveChannelBuffer(
     ChannelBuffer *bufPtr)
 {
-    if (!bufPtr->refCount) {
+    if (bufPtr->refCount == 0) {
 	Tcl_Panic("Reuse of ChannelBuffer! %p", bufPtr);
     }
     bufPtr->refCount++;
 }
 
@@ -2498,18 +2498,18 @@
     ChannelBuffer *bufPtr)
 {
     if (--bufPtr->refCount) {
 	return;
     }
-    Tcl_Free(bufPtr);
+    ckfree(bufPtr);
 }
 
 static int
 IsShared(
     ChannelBuffer *bufPtr)
 {
-    return bufPtr->refCount + 1 > 2;
+    return bufPtr->refCount > 1;
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -2941,11 +2941,11 @@
      * If the channel is flagged as closed, delete it when the refCount drops
      * to zero, the output queue is empty and there is no output in the
      * current output buffer.
      */
 
-    if (GotFlag(statePtr, CHANNEL_CLOSED) && (statePtr->refCount + 1 <= 1) &&
+    if (GotFlag(statePtr, CHANNEL_CLOSED) && (statePtr->refCount <= 0) &&
 	    (statePtr->outQueueHead == NULL) &&
 	    ((statePtr->curOutPtr == NULL) ||
 	    IsBufferEmpty(statePtr->curOutPtr))) {
 	errorCode = CloseChannel(interp, chanPtr, errorCode);
 	goto done;
@@ -3077,11 +3077,11 @@
      * closed. All the other channels in the stack are not allowed to remove.
      */
 
     if (chanPtr == statePtr->bottomChanPtr) {
 	if (statePtr->channelName != NULL) {
-	    Tcl_Free(statePtr->channelName);
+	    ckfree(statePtr->channelName);
 	    statePtr->channelName = NULL;
 	}
 
 	Tcl_FreeEncoding(statePtr->encoding);
     }
@@ -3408,11 +3408,11 @@
 
     chanPtr = (Channel *) chan;
     statePtr = chanPtr->state;
     chanPtr = statePtr->topChanPtr;
 
-    if (statePtr->refCount + 1 > 1) {
+    if (statePtr->refCount > 0) {
 	Tcl_Panic("called Tcl_Close on channel with refCount > 0");
     }
 
     if (GotFlag(statePtr, CHANNEL_INCLOSE)) {
 	if (interp) {
@@ -3473,11 +3473,11 @@
 
     while (statePtr->closeCbPtr != NULL) {
 	cbPtr = statePtr->closeCbPtr;
 	statePtr->closeCbPtr = cbPtr->nextPtr;
 	cbPtr->proc(cbPtr->clientData);
-	Tcl_Free(cbPtr);
+	ckfree(cbPtr);
     }
 
     ResetFlag(statePtr, CHANNEL_INCLOSE);
 
     /*
@@ -3943,11 +3943,11 @@
      * Remove all the channel handler records attached to the channel itself.
      */
 
     for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chNext) {
 	chNext = chPtr->nextPtr;
-	Tcl_Free(chPtr);
+	ckfree(chPtr);
     }
     statePtr->chPtr = NULL;
 
     /*
      * Cancel any pending copy operation.
@@ -3970,11 +3970,11 @@
      */
 
     for (ePtr = statePtr->scriptRecordPtr; ePtr != NULL; ePtr = eNextPtr) {
 	eNextPtr = ePtr->nextPtr;
 	TclDecrRefCount(ePtr->scriptPtr);
-	Tcl_Free(ePtr);
+	ckfree(ePtr);
     }
     statePtr->scriptRecordPtr = NULL;
 }
 
 /*
@@ -3989,25 +3989,25 @@
  *	the specified channel to the topmost channel in a stack.
  *
  *	No encoding conversions are applied to the bytes being read.
  *
  * Results:
- *	The number of bytes written or TCL_IO_FAILURE in case of error. If
- *	TCL_IO_FAILURE, Tcl_GetErrno will return the error code.
+ *	The number of bytes written or -1 in case of error. If -1,
+ *	Tcl_GetErrno will return the error code.
  *
  * Side effects:
  *	May buffer up output and may cause output to be produced on the
  *	channel.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_Write(
     Tcl_Channel chan,		/* The channel to buffer output for. */
     const char *src,		/* Data to queue in output buffer. */
-    size_t srcLen)			/* Length of data in bytes, or -1 for
+    int srcLen)			/* Length of data in bytes, or < 0 for
 				 * strlen(). */
 {
     /*
      * Always use the topmost channel of the stack
      */
@@ -4017,18 +4017,18 @@
 
     statePtr = ((Channel *) chan)->state;
     chanPtr = statePtr->topChanPtr;
 
     if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
-	return TCL_IO_FAILURE;
+	return -1;
     }
 
-    if (srcLen == TCL_AUTO_LENGTH) {
+    if (srcLen < 0) {
 	srcLen = strlen(src);
     }
-    if (WriteBytes(chanPtr, src, srcLen) == -1) {
-	return TCL_IO_FAILURE;
+    if (WriteBytes(chanPtr, src, srcLen) < 0) {
+	return -1;
     }
     return srcLen;
 }
 
 /*
@@ -4043,48 +4043,47 @@
  *	compensate for stacking.
  *
  *	No encoding conversions are applied to the bytes being read.
  *
  * Results:
- *	The number of bytes written or TCL_IO_FAILURE in case of error. If
- *	TCL_IO_FAILURE, Tcl_GetErrno will return the error code.
+ *	The number of bytes written or -1 in case of error. If -1,
+ *	Tcl_GetErrno will return the error code.
  *
  * Side effects:
  *	May buffer up output and may cause output to be produced on the
  *	channel.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_WriteRaw(
     Tcl_Channel chan,		/* The channel to buffer output for. */
     const char *src,		/* Data to queue in output buffer. */
-    size_t srcLen)		/* Length of data in bytes, or -1 for
+    int srcLen)			/* Length of data in bytes, or < 0 for
 				 * strlen(). */
 {
     Channel *chanPtr = ((Channel *) chan);
     ChannelState *statePtr = chanPtr->state;
 				/* State info for channel */
-    int errorCode;
-    size_t written;
+    int errorCode, written;
 
     if (CheckChannelErrors(statePtr, TCL_WRITABLE | CHANNEL_RAW_MODE) != 0) {
-	return TCL_IO_FAILURE;
+	return -1;
     }
 
-    if (srcLen == TCL_AUTO_LENGTH) {
+    if (srcLen < 0) {
 	srcLen = strlen(src);
     }
 
     /*
      * Go immediately to the driver, do all the error handling by ourselves.
      * The code was stolen from 'FlushChannel'.
      */
 
     written = ChanWrite(chanPtr, src, srcLen, &errorCode);
-    if (written == TCL_IO_FAILURE) {
+    if (written < 0) {
 	Tcl_SetErrno(errorCode);
     }
 
     return written;
 }
@@ -4100,40 +4099,40 @@
  *	ready e.g. if it contains a newline and we are in line buffering
  *	mode. Compensates stacking, i.e. will redirect the data from the
  *	specified channel to the topmost channel in a stack.
  *
  * Results:
- *	The number of bytes written or TCL_IO_FAILURE in case of error. If
- *	TCL_IO_FAILURE, Tcl_GetErrno will return the error code.
+ *	The number of bytes written or -1 in case of error. If -1,
+ *	Tcl_GetErrno will return the error code.
  *
  * Side effects:
  *	May buffer up output and may cause output to be produced on the
  *	channel.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_WriteChars(
     Tcl_Channel chan,		/* The channel to buffer output for. */
     const char *src,		/* UTF-8 characters to queue in output
 				 * buffer. */
-    size_t len)			/* Length of string in bytes, or -1 for
+    int len)			/* Length of string in bytes, or < 0 for
 				 * strlen(). */
 {
     Channel *chanPtr = (Channel *) chan;
     ChannelState *statePtr = chanPtr->state;	/* State info for channel */
     int result;
     Tcl_Obj *objPtr;
 
     if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
-	return TCL_IO_FAILURE;
+	return -1;
     }
 
     chanPtr = statePtr->topChanPtr;
 
-    if (len == TCL_AUTO_LENGTH) {
+    if (len < 0) {
 	len = strlen(src);
     }
     if (statePtr->encoding) {
 	return WriteChars(chanPtr, src, len);
     }
@@ -4148,11 +4147,11 @@
     if ((len == 1) && (UCHAR(*src) < 0xC0)) {
 	return WriteBytes(chanPtr, src, len);
     }
 
     objPtr = Tcl_NewStringObj(src, len);
-    src = (char *) TclGetByteArrayFromObj(objPtr, &len);
+    src = (char *) Tcl_GetByteArrayFromObj(objPtr, &len);
     result = WriteBytes(chanPtr, src, len);
     TclDecrRefCount(objPtr);
     return result;
 }
 
@@ -4179,11 +4178,11 @@
  *	channel.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_WriteObj(
     Tcl_Channel chan,		/* The channel to buffer output for. */
     Tcl_Obj *objPtr)		/* The object to write. */
 {
     /*
@@ -4191,20 +4190,20 @@
      */
 
     Channel *chanPtr;
     ChannelState *statePtr;	/* State info for channel */
     const char *src;
-    size_t srcLen = 0;
+    int srcLen;
 
     statePtr = ((Channel *) chan)->state;
     chanPtr = statePtr->topChanPtr;
 
     if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
-	return TCL_IO_FAILURE;
+	return -1;
     }
     if (statePtr->encoding == NULL) {
-	src = (char *) TclGetByteArrayFromObj(objPtr, &srcLen);
+	src = (char *) Tcl_GetByteArrayFromObj(objPtr, &srcLen);
 	return WriteBytes(chanPtr, src, srcLen);
     } else {
 	src = TclGetStringFromObj(objPtr, &srcLen);
 	return WriteChars(chanPtr, src, srcLen);
     }
@@ -4411,11 +4410,11 @@
 	     * the output buffer, so that we would get a completely full
 	     * buffer before flushing it. The extra bytes will be moved to the
 	     * beginning of the next buffer.
 	     */
 
-	    saved = 1 + ~SpaceLeft(bufPtr);
+	    saved = -SpaceLeft(bufPtr);
 	    memcpy(safe, dst + dstLen, saved);
 	    bufPtr->nextAdded = bufPtr->bufLength;
 	}
 
 	if ((srcLen + saved == 0) && (result == TCL_OK)) {
@@ -4475,24 +4474,24 @@
  *	the channel.
  *
  *---------------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_Gets(
     Tcl_Channel chan,		/* Channel from which to read. */
     Tcl_DString *lineRead)	/* The line read will be appended to this
 				 * DString as UTF-8 characters. The caller
 				 * must have initialized it and is responsible
 				 * for managing the storage. */
 {
     Tcl_Obj *objPtr;
-    size_t charsStored;
+    int charsStored;
 
     TclNewObj(objPtr);
     charsStored = Tcl_GetsObj(chan, objPtr);
-    if (charsStored + 1 > 1) {
+    if (charsStored > 0) {
 	TclDStringAppendObj(lineRead, objPtr);
     }
     TclDecrRefCount(objPtr);
     return charsStored;
 }
@@ -4518,11 +4517,11 @@
  *	leave channel pointing after EOL, but don't return EOL in dst buffer.
  *
  *---------------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_GetsObj(
     Tcl_Channel chan,		/* Channel from which to read. */
     Tcl_Obj *objPtr)		/* The line read will be appended to this
 				 * object as UTF-8 characters. */
 {
@@ -4529,18 +4528,17 @@
     GetsState gs;
     Channel *chanPtr = (Channel *) chan;
     ChannelState *statePtr = chanPtr->state;
 				/* State info for channel */
     ChannelBuffer *bufPtr;
-    int inEofChar, skip, copiedTotal, oldFlags, oldRemoved;
-    size_t oldLength;
+    int inEofChar, skip, copiedTotal, oldLength, oldFlags, oldRemoved;
     Tcl_Encoding encoding;
     char *dst, *dstEnd, *eol, *eof;
     Tcl_EncodingState oldState;
 
     if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
-	return TCL_IO_FAILURE;
+	return -1;
     }
 
     /*
      * If we're sitting ready to read the eofchar, there's no need to
      * do it.
@@ -4551,11 +4549,11 @@
 	assert(statePtr->inputEncodingFlags & TCL_ENCODING_END);
 	assert(!GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR));
 
 	/* TODO: Do we need this? */
 	UpdateInterest(chanPtr);
-	return TCL_IO_FAILURE;
+	return -1;
     }
 
     /*
      * A binary version of Tcl_GetsObj. This could also handle encodings that
      * are ascii-7 pure (iso8859, utf-8, ...) with a final encoding conversion
@@ -4581,11 +4579,11 @@
     /*
      * Preserved so we can restore the channel's state in case we don't find a
      * newline in the available input.
      */
 
-    (void)TclGetStringFromObj(objPtr, &oldLength);
+    TclGetStringFromObj(objPtr, &oldLength);
     oldFlags = statePtr->inputEncodingFlags;
     oldState = statePtr->inputEncodingState;
     oldRemoved = BUFFER_PADDING;
     if (bufPtr != NULL) {
 	oldRemoved = bufPtr->nextRemoved;
@@ -4678,11 +4676,11 @@
 		     * LF at the begining of the next buffer, unless EOF char
 		     * was found already.
 		     */
 
 		    if (eol >= dstEnd) {
-			size_t offset;
+			int offset;
 
 			if (eol != eof) {
 			    offset = eol - objPtr->bytes;
 			    dst = dstEnd;
 			    if (FilterInputBytes(chanPtr, &gs) != 0) {
@@ -4724,11 +4722,11 @@
 			    TCL_UTF_MAX, &rawRead, NULL, NULL);
 		    bufPtr->nextRemoved += rawRead;
 		    gs.rawRead -= rawRead;
 		    gs.bytesWrote--;
 		    gs.charsWrote--;
-		    memmove(dst, dst + 1, dstEnd - dst);
+		    memmove(dst, dst + 1, (size_t) (dstEnd - dst));
 		    dstEnd--;
 		}
 	    }
 	    for (eol = dst; eol < dstEnd; eol++) {
 		if (*eol == '\r') {
@@ -4945,13 +4943,12 @@
 {
     Channel *chanPtr = (Channel *) chan;
     ChannelState *statePtr = chanPtr->state;
 				/* State info for channel */
     ChannelBuffer *bufPtr;
-    int inEofChar, skip, copiedTotal, oldFlags, oldRemoved;
-    size_t rawLen, byteLen = 0, oldLength;
-    int eolChar;
+    int inEofChar, skip, copiedTotal, oldLength, oldFlags, oldRemoved;
+    int rawLen, byteLen, eolChar;
     unsigned char *dst, *dstEnd, *eol, *eof, *byteArray;
 
     /*
      * This operation should occur at the top of a channel stack.
      */
@@ -4964,11 +4961,11 @@
     /*
      * Preserved so we can restore the channel's state in case we don't find a
      * newline in the available input.
      */
 
-    byteArray = TclGetByteArrayFromObj(objPtr, &byteLen);
+    byteArray = Tcl_GetByteArrayFromObj(objPtr, &byteLen);
     oldFlags = statePtr->inputEncodingFlags;
     oldRemoved = BUFFER_PADDING;
     oldLength = byteLen;
     if (bufPtr != NULL) {
 	oldRemoved = bufPtr->nextRemoved;
@@ -5407,11 +5404,11 @@
 		bufPtr->nextPtr = nextPtr;
 		statePtr->inQueueTail = nextPtr;
 	    }
 	    extra = rawLen - gsPtr->rawRead;
 	    memcpy(nextPtr->buf + (BUFFER_PADDING - extra),
-		    raw + gsPtr->rawRead, extra);
+		    raw + gsPtr->rawRead, (size_t) extra);
 	    nextPtr->nextRemoved -= extra;
 	    bufPtr->nextAdded -= extra;
 	}
     }
 
@@ -5587,15 +5584,15 @@
  *	May cause input to be buffered.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_Read(
     Tcl_Channel chan,		/* The channel from which to read. */
     char *dst,			/* Where to store input read. */
-    size_t bytesToRead)		/* Maximum number of bytes to read. */
+    int bytesToRead)		/* Maximum number of bytes to read. */
 {
     Channel *chanPtr = (Channel *) chan;
     ChannelState *statePtr = chanPtr->state;
 				/* State info for channel */
 
@@ -5604,11 +5601,11 @@
      */
 
     chanPtr = statePtr->topChanPtr;
 
     if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
-	return TCL_IO_FAILURE;
+	return -1;
     }
 
     return DoRead(chanPtr, dst, bytesToRead, 0);
 }
 
@@ -5632,35 +5629,35 @@
  *	May cause input to be buffered.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_ReadRaw(
     Tcl_Channel chan,		/* The channel from which to read. */
     char *readBuf,		/* Where to store input read. */
-    size_t bytesToRead)		/* Maximum number of bytes to read. */
+    int bytesToRead)		/* Maximum number of bytes to read. */
 {
     Channel *chanPtr = (Channel *) chan;
     ChannelState *statePtr = chanPtr->state;
 				/* State info for channel */
     int copied = 0;
 
     assert(bytesToRead > 0);
     if (CheckChannelErrors(statePtr, TCL_READABLE | CHANNEL_RAW_MODE) != 0) {
-	return TCL_IO_FAILURE;
+	return -1;
     }
 
     /*
      * First read bytes from the push-back buffers.
      */
 
     while (chanPtr->inQueueHead && bytesToRead > 0) {
 	ChannelBuffer *bufPtr = chanPtr->inQueueHead;
 	int bytesInBuffer = BytesLeft(bufPtr);
-	int toCopy = (bytesInBuffer < (int)bytesToRead) ? bytesInBuffer
-		: (int)bytesToRead;
+	int toCopy = (bytesInBuffer < bytesToRead) ? bytesInBuffer
+		: bytesToRead;
 
 	/*
          * Copy the current chunk into the read buffer.
          */
 
@@ -5699,11 +5696,17 @@
      */
 
     if (bytesToRead > 0) {
 	int nread = ChanRead(chanPtr, readBuf, bytesToRead);
 
-	if (nread == -1) {
+	if (nread > 0) {
+	    /*
+             * Successful read (short is OK) - add to bytes copied.
+             */
+
+	    copied += nread;
+	} else if (nread < 0) {
 	    /*
 	     * An error signaled.  If CHANNEL_BLOCKED, then the error is not
 	     * real, but an indication of blocked state.  In that case, retain
 	     * the flag and let caller receive the short read of copied bytes
 	     * from the pushback.  HOWEVER, if copied==0 bytes from pushback
@@ -5713,16 +5716,10 @@
 	     */
 
 	    if (!GotFlag(statePtr, CHANNEL_BLOCKED) || copied == 0) {
 		copied = -1;
 	    }
-	} else if (nread > 0) {
-	    /*
-             * Successful read (short is OK) - add to bytes copied.
-             */
-
-	    copied += nread;
 	} else {
 	    /*
 	     * nread == 0.  Driver is at EOF. Let that state filter up.
 	     */
 	}
@@ -5750,15 +5747,15 @@
  *	May cause input to be buffered.
  *
  *---------------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_ReadChars(
     Tcl_Channel chan,		/* The channel to read. */
     Tcl_Obj *objPtr,		/* Input data is stored in this object. */
-    size_t toRead,		/* Maximum number of characters to store, or
+    int toRead,			/* Maximum number of characters to store, or
 				 * -1 to read all available data (up to EOF or
 				 * when channel blocks). */
     int appendFlag)		/* If non-zero, data read from the channel
 				 * will be appended to the object. Otherwise,
 				 * the data will replace the existing contents
@@ -5810,11 +5807,11 @@
 
 static int
 DoReadChars(
     Channel *chanPtr,		/* The channel to read. */
     Tcl_Obj *objPtr,		/* Input data is stored in this object. */
-    size_t toRead,			/* Maximum number of characters to store, or
+    int toRead,			/* Maximum number of characters to store, or
 				 * -1 to read all available data (up to EOF or
 				 * when channel blocks). */
     int appendFlag)		/* If non-zero, data read from the channel
 				 * will be appended to the object. Otherwise,
 				 * the data will replace the existing contents
@@ -5896,11 +5893,11 @@
     if (GotFlag(statePtr, CHANNEL_EOF)) {
 	statePtr->inputEncodingFlags |= TCL_ENCODING_START;
     }
     ResetFlag(statePtr, CHANNEL_BLOCKED|CHANNEL_EOF);
     statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
-    for (copied = 0; toRead > 0; ) {
+    for (copied = 0; (unsigned) toRead > 0; ) {
 	copiedNow = -1;
 	if (statePtr->inQueueHead != NULL) {
 	    if (binaryMode) {
 		copiedNow = ReadBytes(statePtr, objPtr, toRead);
 	    } else {
@@ -6014,11 +6011,11 @@
     Tcl_Obj *objPtr,		/* Input data is appended to this ByteArray
 				 * object. Its length is how much space has
 				 * been allocated to hold data, not how many
 				 * bytes of data have been stored in the
 				 * object. */
-    int bytesToRead)		/* Maximum number of bytes to store, or -1 to
+    int bytesToRead)		/* Maximum number of bytes to store, or < 0 to
 				 * get all available bytes. Bytes are obtained
 				 * from the first buffer in the queue - even
 				 * if this number is larger than the number of
 				 * bytes available in the first buffer, only
 				 * the bytes from the first buffer are
@@ -6091,12 +6088,11 @@
     Tcl_EncodingState savedState = statePtr->inputEncodingState;
     ChannelBuffer *bufPtr = statePtr->inQueueHead;
     int savedIEFlags = statePtr->inputEncodingFlags;
     int savedFlags = statePtr->flags;
     char *dst, *src = RemovePoint(bufPtr);
-    size_t numBytes;
-    int srcLen = BytesLeft(bufPtr);
+    int numBytes, srcLen = BytesLeft(bufPtr);
 
     /*
      * One src byte can yield at most one character.  So when the number of
      * src bytes we plan to read is less than the limit on character count to
      * be read, clearly we will remain within that limit, and we can use the
@@ -6115,11 +6111,11 @@
     int dstLimit = TCL_UTF_MAX - 1 + toRead * factor / UTF_EXPANSION_FACTOR;
 
     (void) TclGetStringFromObj(objPtr, &numBytes);
     Tcl_AppendToObj(objPtr, NULL, dstLimit);
     if (toRead == srcLen) {
-	size_t size;
+	unsigned int size;
 
 	dst = TclGetStringStorage(objPtr, &size) + numBytes;
 	dstLimit = size - numBytes;
     } else {
 	dst = TclGetString(objPtr) + numBytes;
@@ -6621,23 +6617,23 @@
  *
  *	Causes the supplied string to be added to the input queue of the
  *	channel, at either the head or tail of the queue.
  *
  * Results:
- *	The number of bytes stored in the channel, or TCL_IO_FAILURE on error.
+ *	The number of bytes stored in the channel, or -1 on error.
  *
  * Side effects:
  *	Adds input to the input queue of a channel.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_Ungets(
     Tcl_Channel chan,		/* The channel for which to add the input. */
     const char *str,		/* The input itself. */
-    size_t len,			/* The length of the input. */
+    int len,			/* The length of the input. */
     int atEnd)			/* If non-zero, add at end of queue; otherwise
 				 * add at head of queue. */
 {
     Channel *chanPtr;		/* The real IO channel. */
     ChannelState *statePtr;	/* State of actual channel. */
@@ -6657,11 +6653,11 @@
      * CheckChannelErrors clears too many flag bits in this one case.
      */
 
     flags = statePtr->flags;
     if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) {
-	len = TCL_IO_FAILURE;
+	len = -1;
 	goto done;
     }
     statePtr->flags = flags;
 
     /*
@@ -7249,11 +7245,11 @@
      * pre-read input data.
      */
 
     WillWrite(chanPtr);
 
-    if (WillRead(chanPtr) == -1) {
+    if (WillRead(chanPtr) < 0) {
         return TCL_ERROR;
     }
 
     /*
      * We're all flushed to disk now and we also don't have any unfortunate
@@ -7482,11 +7478,11 @@
     for (bytesBuffered = 0, bufPtr = statePtr->outQueueHead; bufPtr != NULL;
 	    bufPtr = bufPtr->nextPtr) {
 	bytesBuffered += BytesLeft(bufPtr);
     }
     if (statePtr->curOutPtr != NULL) {
-	register ChannelBuffer *curOutPtr = statePtr->curOutPtr;
+	ChannelBuffer *curOutPtr = statePtr->curOutPtr;
 
 	if (IsBufferReady(curOutPtr)) {
 	    bytesBuffered += BytesLeft(curOutPtr);
 	}
     }
@@ -7677,11 +7673,11 @@
 	    Tcl_AppendPrintfToObj(errObj, "-%s, ", argv[i]);
 	}
 	Tcl_AppendPrintfToObj(errObj, "or -%s", argv[i]);
         Tcl_SetObjResult(interp, errObj);
 	Tcl_DStringFree(&ds);
-	Tcl_Free((void *)argv);
+	ckfree(argv);
     }
     Tcl_SetErrno(EINVAL);
     return TCL_ERROR;
 }
 
@@ -8068,11 +8064,11 @@
 		if (interp) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
                             "bad value for -eofchar: must be non-NUL ASCII"
                             " character", -1));
 		}
-		Tcl_Free((void *)argv);
+		ckfree(argv);
 		return TCL_ERROR;
 	    }
 	    if (GotFlag(statePtr, TCL_READABLE)) {
 		statePtr->inEofChar = inValue;
 	    }
@@ -8083,15 +8079,15 @@
 	    if (interp) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"bad value for -eofchar: should be a list of zero,"
 			" one, or two elements", -1));
 	    }
-	    Tcl_Free((void *)argv);
+	    ckfree(argv);
 	    return TCL_ERROR;
 	}
 	if (argv != NULL) {
-	    Tcl_Free((void *)argv);
+	    ckfree(argv);
 	}
 
 	/*
 	 * [Bug 930851] Reset EOF and BLOCKED flags. Changing the character
 	 * which signals eof can transform a current eof condition into a 'go
@@ -8121,11 +8117,11 @@
 	    if (interp) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"bad value for -translation: must be a one or two"
 			" element list", -1));
 	    }
-	    Tcl_Free((void *)argv);
+	    ckfree(argv);
 	    return TCL_ERROR;
 	}
 
 	if (readMode) {
 	    TclEolTranslation translation;
@@ -8151,11 +8147,11 @@
 		if (interp) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			    "bad value for -translation: must be one of "
                             "auto, binary, cr, lf, crlf, or platform", -1));
 		}
-		Tcl_Free((void *)argv);
+		ckfree(argv);
 		return TCL_ERROR;
 	    }
 
 	    /*
 	     * Reset the EOL flags since we need to look at any buffered data
@@ -8201,15 +8197,15 @@
 		if (interp) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			    "bad value for -translation: must be one of "
                             "auto, binary, cr, lf, crlf, or platform", -1));
 		}
-		Tcl_Free((void *)argv);
+		ckfree(argv);
 		return TCL_ERROR;
 	    }
 	}
-	Tcl_Free((void *)argv);
+	ckfree(argv);
 	return TCL_OK;
     } else if (chanPtr->typePtr->setOptionProc != NULL) {
 	return chanPtr->typePtr->setOptionProc(chanPtr->instanceData, interp,
 		optionName, newValue);
     } else {
@@ -8264,11 +8260,11 @@
 
 	    Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
 		    TclChannelEventScriptInvoker, sPtr);
 
 	    TclDecrRefCount(sPtr->scriptPtr);
-	    Tcl_Free(sPtr);
+	    ckfree(sPtr);
 	} else {
 	    prevPtr = sPtr;
 	}
     }
 }
@@ -8634,11 +8630,11 @@
 		(chPtr->clientData == clientData)) {
 	    break;
 	}
     }
     if (chPtr == NULL) {
-	chPtr = Tcl_Alloc(sizeof(ChannelHandler));
+	chPtr = ckalloc(sizeof(ChannelHandler));
 	chPtr->mask = 0;
 	chPtr->proc = proc;
 	chPtr->clientData = clientData;
 	chPtr->chanPtr = chanPtr;
 	chPtr->nextPtr = statePtr->chPtr;
@@ -8738,11 +8734,11 @@
     if (prevChPtr == NULL) {
 	statePtr->chPtr = chPtr->nextPtr;
     } else {
 	prevChPtr->nextPtr = chPtr->nextPtr;
     }
-    Tcl_Free(chPtr);
+    ckfree(chPtr);
 
     /*
      * Recompute the interest list for the channel, so that infinite loops
      * will not result if Tcl_DeleteChannelHandler is called inside an event.
      */
@@ -8797,11 +8793,11 @@
 
 	    Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
 		    TclChannelEventScriptInvoker, esPtr);
 
 	    TclDecrRefCount(esPtr->scriptPtr);
-	    Tcl_Free(esPtr);
+	    ckfree(esPtr);
 
 	    break;
 	}
     }
 }
@@ -8846,11 +8842,11 @@
     }
 
     makeCH = (esPtr == NULL);
 
     if (makeCH) {
-	esPtr = Tcl_Alloc(sizeof(EventScriptRecord));
+	esPtr = ckalloc(sizeof(EventScriptRecord));
     }
 
     /*
      * Initialize the structure before calling Tcl_CreateChannelHandler,
      * because a reflected channel calling 'chan postevent' aka
@@ -9080,10 +9076,24 @@
  *	be marked busy.
  *
  *----------------------------------------------------------------------
  */
 
+#if !defined(TCL_NO_DEPRECATED)
+int
+TclCopyChannelOld(
+    Tcl_Interp *interp,		/* Current interpreter. */
+    Tcl_Channel inChan,		/* Channel to read from. */
+    Tcl_Channel outChan,	/* Channel to write to. */
+    int toRead,			/* Amount of data to copy, or -1 for all. */
+    Tcl_Obj *cmdPtr)		/* Pointer to script to execute or NULL. */
+{
+    return TclCopyChannel(interp, inChan, outChan, (Tcl_WideInt) toRead,
+            cmdPtr);
+}
+#endif
+
 int
 TclCopyChannel(
     Tcl_Interp *interp,		/* Current interpreter. */
     Tcl_Channel inChan,		/* Channel to read from. */
     Tcl_Channel outChan,	/* Channel to write to. */
@@ -9162,11 +9172,11 @@
      * Allocate a new CopyState to maintain info about the current copy in
      * progress. This structure will be deallocated when the copy is
      * completed.
      */
 
-    csPtr = Tcl_Alloc(sizeof(CopyState) + !moveBytes * inStatePtr->bufSize);
+    csPtr = ckalloc(sizeof(CopyState) + !moveBytes * inStatePtr->bufSize);
     csPtr->bufSize = !moveBytes * inStatePtr->bufSize;
     csPtr->readPtr = inPtr;
     csPtr->writePtr = outPtr;
     csPtr->readFlags = readFlags;
     csPtr->writeFlags = writeFlags;
@@ -9456,12 +9466,11 @@
 {
     Tcl_Interp *interp;
     Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL, *msg = NULL;
     Tcl_Channel inChan, outChan;
     ChannelState *inStatePtr, *outStatePtr;
-    int result = TCL_OK, size;
-    size_t sizeb;
+    int result = TCL_OK, size, sizeb;
     Tcl_WideInt total;
     const char *buffer;
     int inBinary, outBinary, sameEncoding;
 				/* Encoding control */
     int underflow;		/* Input underflow */
@@ -9523,21 +9532,21 @@
 
 	    if ((csPtr->toRead == (Tcl_WideInt) -1)
                     || (csPtr->toRead > (Tcl_WideInt) csPtr->bufSize)) {
 		sizeb = csPtr->bufSize;
 	    } else {
-		sizeb = csPtr->toRead;
+		sizeb = (int) csPtr->toRead;
 	    }
 
 	    if (inBinary || sameEncoding) {
 		size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, sizeb,
                               !GotFlag(inStatePtr, CHANNEL_NONBLOCKING));
 	    } else {
 		size = DoReadChars(inStatePtr->topChanPtr, bufObj, sizeb,
 			0 /* No append */);
 	    }
-	    underflow = (size >= 0) && ((size_t)size < sizeb);	/* Input underflow */
+	    underflow = (size >= 0) && (size < sizeb);	/* Input underflow */
 	}
 
 	if (size < 0) {
 	readError:
 	    if (interp) {
@@ -9617,11 +9626,11 @@
 	 * to 'size' (It can be smaller or larger, in the latter case able to
 	 * drive toRead below -1, causing infinite looping). Completely
 	 * unsuitable for updating totals and toRead.
 	 */
 
-	if (sizeb == TCL_AUTO_LENGTH) {
+	if (sizeb < 0) {
 	writeError:
 	    if (interp) {
 		TclNewObj(errObj);
 		Tcl_AppendStringsToObj(errObj, "error writing \"",
 			Tcl_GetChannelName(outChan), "\": ", NULL);
@@ -9785,15 +9794,17 @@
 
 static int
 DoRead(
     Channel *chanPtr,		/* The channel from which to read. */
     char *dst,			/* Where to store input read. */
-    size_t bytesToRead,		/* Maximum number of bytes to read. */
+    int bytesToRead,		/* Maximum number of bytes to read. */
     int allowShortReads)	/* Allow half-blocking (pipes,sockets) */
 {
     ChannelState *statePtr = chanPtr->state;
     char *p = dst;
+
+    assert(bytesToRead >= 0);
 
     /*
      * Early out when we know a read will get the eofchar.
      *
      * NOTE: This seems to be a bug.  The special handling for
@@ -9844,11 +9855,11 @@
 	 * Don't read more data if we have what we need.
 	 */
 
 	while (!bufPtr ||			/* We got no buffer!   OR */
 		(!IsBufferFull(bufPtr) && 	/* Our buffer has room AND */
-		((size_t)BytesLeft(bufPtr) < bytesToRead))) {
+		(BytesLeft(bufPtr) < bytesToRead))) {
 						/* Not enough bytes in it yet
 						 * to fill the dst */
 	    int code;
 
 	moreData:
@@ -10088,11 +10099,11 @@
 	Tcl_DeleteChannelHandler(outChan, MBEvent, csPtr);
 	TclDecrRefCount(csPtr->cmdPtr);
     }
     inStatePtr->csPtrR = NULL;
     outStatePtr->csPtrW = NULL;
-    Tcl_Free(csPtr);
+    ckfree(csPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -10390,11 +10401,11 @@
     Tcl_Channel chan)		/* The channel to query */
 {
     ChannelState *statePtr = ((Channel *) chan)->state;
 				/* State of real channel structure. */
 
-    return ((statePtr->refCount + 1 > 2) ? 1 : 0);
+    return ((statePtr->refCount > 1) ? 1 : 0);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -10434,11 +10445,11 @@
 	} else {
 	    name = statePtr->channelName;
 	}
 
 	if ((*chanName == *name) &&
-		(memcmp(name, chanName, chanNameLen + 1) == 0)) {
+		(memcmp(name, chanName, (size_t) chanNameLen + 1) == 0)) {
 	    return 1;
 	}
     }
 
     return 0;
@@ -11061,11 +11072,11 @@
     }
     if (newcode >= 0) {
 	lcn += 2;
     }
 
-    lvn = Tcl_Alloc(lcn * sizeof(Tcl_Obj *));
+    lvn = ckalloc(lcn * sizeof(Tcl_Obj *));
 
     /*
      * New level/code information is spliced into the first occurence of
      * -level, -code, further occurences are ignored. The options cannot be
      * not present, we would not come here. Options which are ok are simply
@@ -11114,11 +11125,11 @@
 	lvn[j++] = lv[i];
     }
 
     msg = Tcl_NewListObj(j, lvn);
 
-    Tcl_Free(lvn);
+    ckfree(lvn);
     return msg;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -11222,13 +11233,13 @@
  *----------------------------------------------------------------------
  */
 
 static void
 DupChannelIntRep(
-    register Tcl_Obj *srcPtr,	/* Object with internal rep to copy. Must have
+    Tcl_Obj *srcPtr,	/* Object with internal rep to copy. Must have
 				 * an internal rep of type "Channel". */
-    register Tcl_Obj *copyPtr)	/* Object with internal rep to set. Must not
+    Tcl_Obj *copyPtr)	/* Object with internal rep to set. Must not
 				 * currently have an internal rep.*/
 {
     ResolvedChanName *resPtr;
 
     ChanGetIntRep(srcPtr, resPtr);
@@ -11262,11 +11273,11 @@
     assert(resPtr);
     if (resPtr->refCount-- > 1) {
 	return;
     }
     Tcl_Release(resPtr->statePtr);
-    Tcl_Free(resPtr);
+    ckfree(resPtr);
 }
 
 #if 0
 /*
  * For future debugging work, a simple function to print the flags of a

Index: generic/tclIO.h
==================================================================
--- generic/tclIO.h
+++ generic/tclIO.h
@@ -34,11 +34,11 @@
  *
  * Buffers data being sent to or from a channel.
  */
 
 typedef struct ChannelBuffer {
-    size_t refCount;		/* Current uses count */
+    int refCount;		/* Current uses count */
     int nextAdded;		/* The next position into which a character
 				 * will be put in the buffer. */
     int nextRemoved;		/* Position of next byte to be removed from
 				 * the buffer. */
     int bufLength;		/* How big is the buffer? */
@@ -111,11 +111,11 @@
      */
 
     ChannelBuffer *inQueueHead;	/* Points at first buffer in input queue. */
     ChannelBuffer *inQueueTail;	/* Points at last buffer in input queue. */
 
-    size_t refCount;
+    int refCount;
 } Channel;
 
 /*
  * struct ChannelState:
  *
@@ -161,11 +161,11 @@
     int outEofChar;		/* If nonzero, append this to the channel when
 				 * it is closed if it is open for writing. */
     int unreportedError;	/* Non-zero if an error report was deferred
 				 * because it happened in the background. The
 				 * value is the POSIX error code. */
-    size_t refCount;		/* How many interpreters hold references to
+    int refCount;		/* How many interpreters hold references to
 				 * this IO channel? */
     struct CloseCallback *closeCbPtr;
 				/* Callbacks registered to be called when the
 				 * channel is closed. */
     char *outputStage;		/* Temporary staging buffer used when

Index: generic/tclIOCmd.c
==================================================================
--- generic/tclIOCmd.c
+++ generic/tclIOCmd.c
@@ -13,11 +13,11 @@
 
 /*
  * Callback structure for accept callback in a TCP server.
  */
 
-typedef struct {
+typedef struct AcceptCallback {
     Tcl_Obj *script;		/* Script to invoke. */
     Tcl_Interp *interp;		/* Interpreter in which to run it. */
 } AcceptCallback;
 
 /*
@@ -135,10 +135,23 @@
 	newline = 0;
 	if (strcmp(TclGetString(objv[1]), "-nonewline") == 0) {
 	    chanObjPtr = objv[2];
 	    string = objv[3];
 	    break;
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+	} else if (strcmp(TclGetString(objv[3]), "nonewline") == 0) {
+	    /*
+	     * The code below provides backwards compatibility with an old
+	     * form of the command that is no longer recommended or
+	     * documented. See also [Bug #3151675]. Will be removed in Tcl 9,
+	     * maybe even earlier.
+	     */
+
+	    chanObjPtr = objv[1];
+	    string = objv[2];
+	    break;
+#endif
 	}
 	/* Fall through */
     default:			/* [puts] or
 				 * [puts some bad number of arguments...] */
 	Tcl_WrongNumArgs(interp, 1, objv, "?-nonewline? ?channelId? string");
@@ -166,16 +179,16 @@
 	return TCL_ERROR;
     }
 
     TclChannelPreserve(chan);
     result = Tcl_WriteObj(chan, string);
-    if (result == -1) {
+    if (result < 0) {
 	goto error;
     }
     if (newline != 0) {
 	result = Tcl_WriteChars(chan, "\n", 1);
-	if (result == -1) {
+	if (result < 0) {
 	    goto error;
 	}
     }
     TclChannelRelease(chan);
     return TCL_OK;
@@ -424,15 +437,29 @@
 
     toRead = -1;
     if (i < objc) {
 	if ((TclGetIntFromObj(interp, objv[i], &toRead) != TCL_OK)
 		|| (toRead < 0)) {
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+	    /*
+	     * The code below provides backwards compatibility with an old
+	     * form of the command that is no longer recommended or
+	     * documented. See also [Bug #3151675]. Will be removed in Tcl 9,
+	     * maybe even earlier.
+	     */
+
+	    if (strcmp(TclGetString(objv[i]), "nonewline") != 0) {
+#endif
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"expected non-negative integer but got \"%s\"",
 			TclGetString(objv[i])));
 		Tcl_SetErrorCode(interp, "TCL", "VALUE", "NUMBER", NULL);
 		return TCL_ERROR;
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+	    }
+	    newline = 1;
+#endif
 	}
     }
 
     resultPtr = Tcl_NewObj();
     Tcl_IncrRefCount(resultPtr);
@@ -460,11 +487,11 @@
      * If requested, remove the last newline in the channel if at EOF.
      */
 
     if ((charactersRead > 0) && (newline != 0)) {
 	const char *result;
-	size_t length;
+	int length;
 
 	result = TclGetStringFromObj(resultPtr, &length);
 	if (result[length - 1] == '\n') {
 	    Tcl_SetObjLength(resultPtr, length - 1);
 	}
@@ -706,11 +733,11 @@
 	 * a terminating newline.
 	 */
 
 	Tcl_Obj *resultPtr = Tcl_GetObjResult(interp);
 	const char *string;
-	size_t len;
+	int len;
 
 	if (Tcl_IsShared(resultPtr)) {
 	    resultPtr = Tcl_DuplicateObj(resultPtr);
 	    Tcl_SetObjResult(interp, resultPtr);
 	}
@@ -868,12 +895,12 @@
     Tcl_Obj *resultPtr;
     const char **argv;		/* An array for the string arguments. Stored
 				 * on the _Tcl_ stack. */
     const char *string;
     Tcl_Channel chan;
-    int argc, background, i, index, keepNewline, result, skip, ignoreStderr;
-    size_t length;
+    int argc, background, i, index, keepNewline, result, skip, length;
+    int ignoreStderr;
     static const char *const options[] = {
 	"-ignorestderr", "-keepnewline", "--", NULL
     };
     enum options {
 	EXEC_IGNORESTDERR, EXEC_KEEPNEWLINE, EXEC_LAST
@@ -1163,11 +1190,11 @@
 	    chan = Tcl_OpenCommandChannel(interp, cmdObjc, cmdArgv, flags);
 	    if (binary && chan) {
 		Tcl_SetChannelOption(interp, chan, "-translation", "binary");
 	    }
 	}
-	Tcl_Free((void *)cmdArgv);
+	ckfree(cmdArgv);
     }
     if (chan == NULL) {
 	return TCL_ERROR;
     }
     Tcl_RegisterChannel(interp, chan);
@@ -1212,11 +1239,11 @@
 	AcceptCallback *acceptCallbackPtr = Tcl_GetHashValue(hPtr);
 
 	acceptCallbackPtr->interp = NULL;
     }
     Tcl_DeleteHashTable(hTblPtr);
-    Tcl_Free(hTblPtr);
+    ckfree(hTblPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1252,11 +1279,11 @@
     int isNew;			/* Is the entry new? */
 
     hTblPtr = Tcl_GetAssocData(interp, "tclTCPAcceptCallbacks", NULL);
 
     if (hTblPtr == NULL) {
-	hTblPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+	hTblPtr = ckalloc(sizeof(Tcl_HashTable));
 	Tcl_InitHashTable(hTblPtr, TCL_ONE_WORD_KEYS);
 	Tcl_SetAssocData(interp, "tclTCPAcceptCallbacks",
 		TcpAcceptCallbacksDeleteProc, hTblPtr);
     }
 
@@ -1427,11 +1454,11 @@
     if (acceptCallbackPtr->interp != NULL) {
 	UnregisterTcpServerInterpCleanupProc(acceptCallbackPtr->interp,
 		acceptCallbackPtr);
     }
     Tcl_DecrRefCount(acceptCallbackPtr->script);
-    Tcl_Free(acceptCallbackPtr);
+    ckfree(acceptCallbackPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1474,11 +1501,11 @@
     if (TclpHasSockets(interp) != TCL_OK) {
 	return TCL_ERROR;
     }
 
     for (a = 1; a < objc; a++) {
-	const char *arg = TclGetString(objv[a]);
+	const char *arg = Tcl_GetString(objv[a]);
 
 	if (arg[0] != '-') {
 	    break;
 	}
 	if (Tcl_GetIndexFromObj(interp, objv[a], socketOptions, "option",
@@ -1623,21 +1650,21 @@
     }
 
     port = TclGetString(objv[a]);
 
     if (server) {
-	AcceptCallback *acceptCallbackPtr = Tcl_Alloc(sizeof(AcceptCallback));
+	AcceptCallback *acceptCallbackPtr = ckalloc(sizeof(AcceptCallback));
 
 	Tcl_IncrRefCount(script);
 	acceptCallbackPtr->script = script;
 	acceptCallbackPtr->interp = interp;
 
 	chan = Tcl_OpenTcpServerEx(interp, port, host, flags,
 		AcceptCallbackProc, acceptCallbackPtr);
 	if (chan == NULL) {
 	    Tcl_DecrRefCount(script);
-	    Tcl_Free(acceptCallbackPtr);
+	    ckfree(acceptCallbackPtr);
 	    return TCL_ERROR;
 	}
 
 	/*
 	 * Register with the interpreter to let us know when the interpreter

Index: generic/tclIOGT.c
==================================================================
--- generic/tclIOGT.c
+++ generic/tclIOGT.c
@@ -228,11 +228,11 @@
     if (dataPtr->refCount-- > 1) {
 	return;
     }
     ResultClear(&dataPtr->result);
     Tcl_DecrRefCount(dataPtr->command);
-    Tcl_Free(dataPtr);
+    ckfree(dataPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -285,11 +285,11 @@
      * Now initialize the transformation state and stack it upon the specified
      * channel. One of the necessary things to do is to retrieve the blocking
      * regime of the underlying channel and to use the same for us too.
      */
 
-    dataPtr = Tcl_Alloc(sizeof(TransformChannelData));
+    dataPtr = ckalloc(sizeof(TransformChannelData));
 
     dataPtr->refCount = 1;
     Tcl_DStringInit(&ds);
     Tcl_GetChannelOption(interp, chan, "-blocking", &ds);
     dataPtr->readIsFlushed = 0;
@@ -376,11 +376,11 @@
     int preserve)		/* Flag. If true the procedure will preserve
 				 * the result state of all accessed
 				 * interpreters. */
 {
     Tcl_Obj *resObj;		/* See below, switch (transmit). */
-    size_t resLen = 0;
+    int resLen;
     unsigned char *resBuf;
     Tcl_InterpState state = NULL;
     int res = TCL_OK;
     Tcl_Obj *command = TclListObjCopy(NULL, dataPtr->command);
     Tcl_Interp *eval = dataPtr->interp;
@@ -441,27 +441,27 @@
     case TRANSMIT_DOWN:
 	if (dataPtr->self == NULL) {
 	    break;
 	}
 	resObj = Tcl_GetObjResult(eval);
-	resBuf = TclGetByteArrayFromObj(resObj, &resLen);
+	resBuf = Tcl_GetByteArrayFromObj(resObj, &resLen);
 	Tcl_WriteRaw(Tcl_GetStackedChannel(dataPtr->self), (char *) resBuf,
 		resLen);
 	break;
 
     case TRANSMIT_SELF:
 	if (dataPtr->self == NULL) {
 	    break;
 	}
 	resObj = Tcl_GetObjResult(eval);
-	resBuf = TclGetByteArrayFromObj(resObj, &resLen);
+	resBuf = Tcl_GetByteArrayFromObj(resObj, &resLen);
 	Tcl_WriteRaw(dataPtr->self, (char *) resBuf, resLen);
 	break;
 
     case TRANSMIT_IBUF:
 	resObj = Tcl_GetObjResult(eval);
-	resBuf = TclGetByteArrayFromObj(resObj, &resLen);
+	resBuf = Tcl_GetByteArrayFromObj(resObj, &resLen);
 	ResultAdd(&dataPtr->result, resBuf, resLen);
 	break;
 
     case TRANSMIT_NUM:
 	/*
@@ -1270,11 +1270,11 @@
     ResultBuffer *r)		/* Reference to the buffer to clear out. */
 {
     r->used = 0;
 
     if (r->allocated) {
-	Tcl_Free(r->buf);
+	ckfree(r->buf);
 	r->buf = NULL;
 	r->allocated = 0;
     }
 }
 
@@ -1414,14 +1414,14 @@
 	 * Extension of the internal buffer is required.
 	 */
 
 	if (r->allocated == 0) {
 	    r->allocated = toWrite + INCREMENT;
-	    r->buf = Tcl_Alloc(r->allocated);
+	    r->buf = ckalloc(r->allocated);
 	} else {
 	    r->allocated += toWrite + INCREMENT;
-	    r->buf = Tcl_Realloc(r->buf, r->allocated);
+	    r->buf = ckrealloc(r->buf, r->allocated);
 	}
     }
 
     /*
      * Now we may copy the data.

Index: generic/tclIORChan.c
==================================================================
--- generic/tclIORChan.c
+++ generic/tclIORChan.c
@@ -261,11 +261,11 @@
  */
 
 struct ForwardParamInput {
     ForwardParamBase base;	/* "Supertype". MUST COME FIRST. */
     char *buf;			/* O: Where to store the read bytes */
-    size_t toRead;			/* I: #bytes to read,
+    int toRead;			/* I: #bytes to read,
 				 * O: #bytes actually read */
 };
 struct ForwardParamOutput {
     ForwardParamBase base;	/* "Supertype". MUST COME FIRST. */
     const char *buf;		/* I: Where the bytes to write come from */
@@ -394,11 +394,11 @@
 static int		ForwardProc(Tcl_Event *evPtr, int mask);
 static void		SrcExitProc(ClientData clientData);
 
 #define FreeReceivedError(p) \
 	if ((p)->base.mustFree) {                               \
-	    Tcl_Free((p)->base.msgStr);                           \
+	    ckfree((p)->base.msgStr);                           \
 	}
 #define PassReceivedErrorInterp(i,p) \
 	if ((i) != NULL) {                                      \
 	    Tcl_SetChannelErrorInterp((i),                      \
 		    Tcl_NewStringObj((p)->base.msgStr, -1));    \
@@ -679,11 +679,11 @@
 	 * Some of the nullable methods are not supported. We clone the
 	 * channel type, null the associated C functions, and use the result
 	 * as the actual channel type.
 	 */
 
-	Tcl_ChannelType *clonePtr = Tcl_Alloc(sizeof(Tcl_ChannelType));
+	Tcl_ChannelType *clonePtr = ckalloc(sizeof(Tcl_ChannelType));
 
 	memcpy(clonePtr, &tclRChannelType, sizeof(Tcl_ChannelType));
 
 	if (!(methods & FLAG(METH_CONFIGURE))) {
 	    clonePtr->setOptionProc = NULL;
@@ -734,11 +734,11 @@
 
   error:
     Tcl_DecrRefCount(rcPtr->name);
     Tcl_DecrRefCount(rcPtr->methods);
     Tcl_DecrRefCount(rcPtr->cmd);
-    Tcl_Free(rcPtr);
+    ckfree(rcPtr);
     return TCL_ERROR;
 
 #undef MODE
 #undef CMD
 }
@@ -943,11 +943,11 @@
 			TimerRunWrite, rcPtr);
 	    }
 	}
 #if TCL_THREADS
     } else {
-        ReflectEvent *ev = Tcl_Alloc(sizeof(ReflectEvent));
+        ReflectEvent *ev = ckalloc(sizeof(ReflectEvent));
 
         ev->header.proc = ReflectEventRun;
         ev->events = events;
         ev->rcPtr = rcPtr;
 
@@ -1196,11 +1196,11 @@
 	}
 #endif
 
 	tctPtr = ((Channel *)rcPtr->chan)->typePtr;
 	if (tctPtr && tctPtr != &tclRChannelType) {
-	    Tcl_Free((void *)tctPtr);
+	    ckfree(tctPtr);
 	    ((Channel *)rcPtr->chan)->typePtr = NULL;
 	}
 	if (rcPtr->readTimer != NULL) {
 	    Tcl_DeleteTimerHandler(rcPtr->readTimer);
 	}
@@ -1271,11 +1271,11 @@
 	}
     }
 #endif
     tctPtr = ((Channel *)rcPtr->chan)->typePtr;
     if (tctPtr && tctPtr != &tclRChannelType) {
-	Tcl_Free((void *)tctPtr);
+	ckfree(tctPtr);
 	((Channel *)rcPtr->chan)->typePtr = NULL;
     }
     if (rcPtr->readTimer != NULL) {
 	Tcl_DeleteTimerHandler(rcPtr->readTimer);
     }
@@ -1309,11 +1309,11 @@
     int toRead,
     int *errorCodePtr)
 {
     ReflectedChannel *rcPtr = clientData;
     Tcl_Obj *toReadObj;
-    size_t bytec = 0;		/* Number of returned bytes */
+    int bytec;			/* Number of returned bytes */
     unsigned char *bytev;	/* Array of returned bytes */
     Tcl_Obj *resObj;		/* Result data for 'read' */
 
     /*
      * Are we in the correct thread?
@@ -1337,11 +1337,11 @@
 		*errorCodePtr = -p.base.code;
 	    } else {
 		PassReceivedError(rcPtr->chan, &p);
 		*errorCodePtr = EINVAL;
 	    }
-	    p.input.toRead = TCL_AUTO_LENGTH;
+	    p.input.toRead = -1;
 	} else {
 	    *errorCodePtr = EOK;
 	}
 
 	return p.input.toRead;
@@ -1366,20 +1366,20 @@
 
 	Tcl_SetChannelError(rcPtr->chan, resObj);
         goto invalid;
     }
 
-    bytev = TclGetByteArrayFromObj(resObj, &bytec);
+    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 
-    if ((size_t)toRead < bytec) {
+    if (toRead < bytec) {
 	SetChannelErrorStr(rcPtr->chan, msg_read_toomuch);
-	goto invalid;
+        goto invalid;
     }
 
     *errorCodePtr = EOK;
 
-    if (bytec + 1 > 1) {
+    if (bytec > 0) {
 	memcpy(buf, bytev, bytec);
     }
 
  stop:
     Tcl_DecrRefCount(toReadObj);
@@ -2007,11 +2007,11 @@
 		"Expected list with even number of "
 		"elements, got %d element%s instead", listc,
 		(listc == 1 ? "" : "s")));
         goto error;
     } else {
-	size_t len;
+	int len;
 	const char *str = TclGetStringFromObj(resObj, &len);
 
 	if (len) {
 	    TclDStringAppendLiteral(dsPtr, " ");
 	    Tcl_DStringAppend(dsPtr, str, len);
@@ -2123,11 +2123,11 @@
 
 static Tcl_Obj *
 DecodeEventMask(
     int mask)
 {
-    register const char *eventStr;
+    const char *eventStr;
     Tcl_Obj *evObj;
 
     switch (mask & RANDW) {
     case RANDW:
 	eventStr = "read write";
@@ -2174,11 +2174,11 @@
     Tcl_Obj *handleObj)
 {
     ReflectedChannel *rcPtr;
     MethodName mn = METH_BLOCKING;
 
-    rcPtr = Tcl_Alloc(sizeof(ReflectedChannel));
+    rcPtr = ckalloc(sizeof(ReflectedChannel));
 
     /* rcPtr->chan: Assigned by caller. Dummy data here. */
 
     rcPtr->chan = NULL;
     rcPtr->interp = interp;
@@ -2261,11 +2261,11 @@
 	Tcl_DecrRefCount(rcPtr->methods);
     }
     if (rcPtr->cmd) {
 	Tcl_DecrRefCount(rcPtr->cmd);
     }
-    Tcl_Free(rcPtr);
+    ckfree(rcPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -2382,11 +2382,11 @@
 	     * This is complex and ugly, and would be completely unnecessary
 	     * if we only added support for a TCL_FORBID_EXCEPTIONS flag.
 	     */
 
 	    if (result != TCL_ERROR) {
-		size_t cmdLen;
+		int cmdLen;
 		const char *cmdString = TclGetStringFromObj(cmd, &cmdLen);
 
 		Tcl_IncrRefCount(cmd);
 		Tcl_ResetResult(rcPtr->interp);
 		Tcl_SetObjResult(rcPtr->interp, Tcl_ObjPrintf(
@@ -2497,11 +2497,11 @@
     Tcl_Interp *interp)
 {
     ReflectedChannelMap *rcmPtr = Tcl_GetAssocData(interp, RCMKEY, NULL);
 
     if (rcmPtr == NULL) {
-	rcmPtr = Tcl_Alloc(sizeof(ReflectedChannelMap));
+	rcmPtr = ckalloc(sizeof(ReflectedChannelMap));
 	Tcl_InitHashTable(&rcmPtr->map, TCL_STRING_KEYS);
 	Tcl_SetAssocData(interp, RCMKEY,
 		(Tcl_InterpDeleteProc *) DeleteReflectedChannelMap, rcmPtr);
     }
     return rcmPtr;
@@ -2586,11 +2586,11 @@
 
 	MarkDead(rcPtr);
 	Tcl_DeleteHashEntry(hPtr);
     }
     Tcl_DeleteHashTable(&rcmPtr->map);
-    Tcl_Free(&rcmPtr->map);
+    ckfree(&rcmPtr->map);
 
 #if TCL_THREADS
     /*
      * The origin interpreter for one or more reflected channels is gone.
      */
@@ -2698,11 +2698,11 @@
 GetThreadReflectedChannelMap(void)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     if (!tsdPtr->rcmPtr) {
-	tsdPtr->rcmPtr = Tcl_Alloc(sizeof(ReflectedChannelMap));
+	tsdPtr->rcmPtr = ckalloc(sizeof(ReflectedChannelMap));
 	Tcl_InitHashTable(&tsdPtr->rcmPtr->map, TCL_STRING_KEYS);
 	Tcl_CreateThreadExitHandler(DeleteThreadReflectedChannelMap, NULL);
     }
 
     return tsdPtr->rcmPtr;
@@ -2821,11 +2821,11 @@
 	ReflectedChannel *rcPtr = Tcl_GetChannelInstanceData(chan);
 
 	MarkDead(rcPtr);
 	Tcl_DeleteHashEntry(hPtr);
     }
-    Tcl_Free(rcmPtr);
+    ckfree(rcmPtr);
 }
 
 static void
 ForwardOpToHandlerThread(
     ReflectedChannel *rcPtr,	/* Channel instance */
@@ -2861,12 +2861,12 @@
 
     /*
      * Create and initialize the event and data structures.
      */
 
-    evPtr = Tcl_Alloc(sizeof(ForwardingEvent));
-    resultPtr = Tcl_Alloc(sizeof(ForwardingResult));
+    evPtr = ckalloc(sizeof(ForwardingEvent));
+    resultPtr = ckalloc(sizeof(ForwardingResult));
 
     evPtr->event.proc = ForwardProc;
     evPtr->resultPtr = resultPtr;
     evPtr->op = op;
     evPtr->rcPtr = rcPtr;
@@ -2944,11 +2944,11 @@
      * Note: The event structure has already been deleted.
      */
 
     Tcl_DeleteThreadExitHandler(SrcExitProc, evPtr);
 
-    Tcl_Free(resultPtr);
+    ckfree(resultPtr);
 }
 
 static int
 ForwardProc(
     Tcl_Event *evGPtr,
@@ -3044,26 +3044,26 @@
 	    if (code < 0) {
 		paramPtr->base.code = code;
 	    } else {
 		ForwardSetObjError(paramPtr, resObj);
 	    }
-	    paramPtr->input.toRead = TCL_IO_FAILURE;
+	    paramPtr->input.toRead = -1;
 	} else {
 	    /*
 	     * Process a regular result.
 	     */
 
-	    size_t bytec = 0;		/* Number of returned bytes */
+	    int bytec;			/* Number of returned bytes */
 	    unsigned char *bytev;	/* Array of returned bytes */
 
-	    bytev = TclGetByteArrayFromObj(resObj, &bytec);
+	    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 
 	    if (paramPtr->input.toRead < bytec) {
 		ForwardSetStaticError(paramPtr, msg_read_toomuch);
-		paramPtr->input.toRead = TCL_IO_FAILURE;
+		paramPtr->input.toRead = -1;
 	    } else {
-		if (bytec + 1 > 1) {
+		if (bytec > 0) {
 		    memcpy(paramPtr->input.buf, bytev, bytec);
 		}
 		paramPtr->input.toRead = bytec;
 	    }
 	}
@@ -3239,18 +3239,18 @@
 	    } else if ((listc % 2) == 1) {
 		/*
 		 * Odd number of elements is wrong. [x].
 		 */
 
-		char *buf = Tcl_Alloc(200);
+		char *buf = ckalloc(200);
 		sprintf(buf,
 			"{Expected list with even number of elements, got %d %s instead}",
 			listc, (listc == 1 ? "element" : "elements"));
 
 		ForwardSetDynamicError(paramPtr, buf);
 	    } else {
-		size_t len;
+		int len;
 		const char *str = TclGetStringFromObj(resObj, &len);
 
 		if (len) {
 		    TclDStringAppendLiteral(paramPtr->getOpt.value, " ");
 		    Tcl_DStringAppend(paramPtr->getOpt.value, str, len);
@@ -3345,15 +3345,15 @@
 static void
 ForwardSetObjError(
     ForwardParam *paramPtr,
     Tcl_Obj *obj)
 {
-    size_t len;
+    int len;
     const char *msgStr = TclGetStringFromObj(obj, &len);
 
     len++;
-    ForwardSetDynamicError(paramPtr, Tcl_Alloc(len));
+    ForwardSetDynamicError(paramPtr, ckalloc(len));
     memcpy(paramPtr->base.msgStr, msgStr, len);
 }
 #endif
 
 /*

Index: generic/tclIORTrans.c
==================================================================
--- generic/tclIORTrans.c
+++ generic/tclIORTrans.c
@@ -87,12 +87,12 @@
  * layers upon reading from the channel, plus the functions to manage such.
  */
 
 typedef struct {
     unsigned char *buf;		/* Reference to the buffer area. */
-    size_t allocated;		/* Allocated size of the buffer area. */
-    size_t used;			/* Number of bytes in the buffer,
+    int allocated;		/* Allocated size of the buffer area. */
+    int used;			/* Number of bytes in the buffer,
 				 * <= allocated. */
 } ResultBuffer;
 
 #define ResultLength(r) ((r)->used)
 /* static int		ResultLength(ResultBuffer *r); */
@@ -268,11 +268,11 @@
 
 struct ForwardParamTransform {
     ForwardParamBase base;	/* "Supertype". MUST COME FIRST. */
     char *buf;			/* I: Bytes to transform,
 				 * O: Bytes in transform result */
-    size_t size;		/* I: #bytes to transform,
+    int size;			/* I: #bytes to transform,
 				 * O: #bytes in the transform result */
 };
 struct ForwardParamLimit {
     ForwardParamBase base;	/* "Supertype". MUST COME FIRST. */
     int max;			/* O: Character read limit */
@@ -364,11 +364,11 @@
 static void		SrcExitProc(ClientData clientData);
 
 #define FreeReceivedError(p) \
 	do {								\
 	    if ((p)->base.mustFree) {					\
-		Tcl_Free((p)->base.msgStr);				\
+		ckfree((p)->base.msgStr);				\
 	    }								\
 	} while (0)
 #define PassReceivedErrorInterp(i,p) \
 	do {								\
 	    if ((i) != NULL) {						\
@@ -618,11 +618,11 @@
 	if (Tcl_GetIndexFromObj(interp, listv[listc-1], methodNames,
 		"method", TCL_EXACT, &methIndex) != TCL_OK) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "chan handler \"%s initialize\" returned %s",
 		    TclGetString(cmdObj),
-		    Tcl_GetStringResult(interp)));
+		    Tcl_GetString(Tcl_GetObjResult(interp))));
 	    Tcl_DecrRefCount(resObj);
 	    goto error;
 	}
 
 	methods |= FLAG(methIndex);
@@ -1012,11 +1012,11 @@
      * the per-interp DeleteReflectedTransformMap exit-handler.
      */
 
     if (!rtPtr->dead) {
 	rtmPtr = GetReflectedTransformMap(rtPtr->interp);
-	hPtr = Tcl_FindHashEntry(&rtmPtr->map, TclGetString(rtPtr->handle));
+	hPtr = Tcl_FindHashEntry(&rtmPtr->map, Tcl_GetString(rtPtr->handle));
 	if (hPtr) {
 	    Tcl_DeleteHashEntry(hPtr);
 	}
 
 	/*
@@ -1704,11 +1704,11 @@
 
 static Tcl_Obj *
 DecodeEventMask(
     int mask)
 {
-    register const char *eventStr;
+    const char *eventStr;
     Tcl_Obj *evObj;
 
     switch (mask & RANDW) {
     case RANDW:
 	eventStr = "read write";
@@ -1757,11 +1757,11 @@
     ReflectedTransform *rtPtr;
     int listc;
     Tcl_Obj **listv;
     int i;
 
-    rtPtr = Tcl_Alloc(sizeof(ReflectedTransform));
+    rtPtr = ckalloc(sizeof(ReflectedTransform));
 
     /* rtPtr->chan: Assigned by caller. Dummy data here. */
     /* rtPtr->methods: Assigned by caller. Dummy data here. */
 
     rtPtr->chan = NULL;
@@ -1804,11 +1804,11 @@
      * argv  [0]   ... [.] | [argc-2] [argc-1]  | [argc]  [argc+2]
      *       cmd   ... pfx | method   chan      | detail1 detail2
      */
 
     rtPtr->argc = listc + 2;
-    rtPtr->argv = Tcl_Alloc(sizeof(Tcl_Obj *) * (listc+4));
+    rtPtr->argv = ckalloc(sizeof(Tcl_Obj *) * (listc+4));
 
     /*
      * Duplicate object references.
      */
 
@@ -1912,12 +1912,12 @@
     TimerKill(rtPtr);
     ResultClear(&rtPtr->result);
 
     FreeReflectedTransformArgs(rtPtr);
 
-    Tcl_Free(rtPtr->argv);
-    Tcl_Free(rtPtr);
+    ckfree(rtPtr->argv);
+    ckfree(rtPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -2039,11 +2039,11 @@
 	     * This is complex and ugly, and would be completely unnecessary
 	     * if we only added support for a TCL_FORBID_EXCEPTIONS flag.
 	     */
 	    if (result != TCL_ERROR) {
 		Tcl_Obj *cmd = Tcl_NewListObj(cmdc, rtPtr->argv);
-		size_t cmdLen;
+		int cmdLen;
 		const char *cmdString = TclGetStringFromObj(cmd, &cmdLen);
 
 		Tcl_IncrRefCount(cmd);
 		Tcl_ResetResult(rtPtr->interp);
 		Tcl_SetObjResult(rtPtr->interp, Tcl_ObjPrintf(
@@ -2112,11 +2112,11 @@
     Tcl_Interp *interp)
 {
     ReflectedTransformMap *rtmPtr = Tcl_GetAssocData(interp, RTMKEY, NULL);
 
     if (rtmPtr == NULL) {
-	rtmPtr = Tcl_Alloc(sizeof(ReflectedTransformMap));
+	rtmPtr = ckalloc(sizeof(ReflectedTransformMap));
 	Tcl_InitHashTable(&rtmPtr->map, TCL_STRING_KEYS);
 	Tcl_SetAssocData(interp, RTMKEY,
 		(Tcl_InterpDeleteProc *) DeleteReflectedTransformMap, rtmPtr);
     }
     return rtmPtr;
@@ -2177,11 +2177,11 @@
 
 	rtPtr->dead = 1;
 	Tcl_DeleteHashEntry(hPtr);
     }
     Tcl_DeleteHashTable(&rtmPtr->map);
-    Tcl_Free(&rtmPtr->map);
+    ckfree(&rtmPtr->map);
 
 #if TCL_THREADS
     /*
      * The origin interpreter for one or more reflected channels is gone.
      */
@@ -2275,11 +2275,11 @@
 GetThreadReflectedTransformMap(void)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     if (!tsdPtr->rtmPtr) {
-	tsdPtr->rtmPtr = Tcl_Alloc(sizeof(ReflectedTransformMap));
+	tsdPtr->rtmPtr = ckalloc(sizeof(ReflectedTransformMap));
 	Tcl_InitHashTable(&tsdPtr->rtmPtr->map, TCL_STRING_KEYS);
 	Tcl_CreateThreadExitHandler(DeleteThreadReflectedTransformMap, NULL);
     }
 
     return tsdPtr->rtmPtr;
@@ -2333,11 +2333,11 @@
 
 	rtPtr->dead = 1;
 	FreeReflectedTransformArgs(rtPtr);
 	Tcl_DeleteHashEntry(hPtr);
     }
-    Tcl_Free(rtmPtr);
+    ckfree(rtmPtr);
 
     /*
      * Go through the list of pending results and cancel all whose events were
      * destined for this thread. While this is in progress we block any
      * other access to the list of pending results.
@@ -2410,12 +2410,12 @@
 
     /*
      * Create and initialize the event and data structures.
      */
 
-    evPtr = Tcl_Alloc(sizeof(ForwardingEvent));
-    resultPtr = Tcl_Alloc(sizeof(ForwardingResult));
+    evPtr = ckalloc(sizeof(ForwardingEvent));
+    resultPtr = ckalloc(sizeof(ForwardingResult));
 
     evPtr->event.proc = ForwardProc;
     evPtr->resultPtr = resultPtr;
     evPtr->op = op;
     evPtr->rtPtr = rtPtr;
@@ -2491,11 +2491,11 @@
      * notifier, after it serviced the event.
      */
 
     Tcl_DeleteThreadExitHandler(SrcExitProc, evPtr);
 
-    Tcl_Free(resultPtr);
+    ckfree(resultPtr);
 }
 
 static int
 ForwardProc(
     Tcl_Event *evGPtr,
@@ -2588,27 +2588,27 @@
 		paramPtr->transform.buf, paramPtr->transform.size);
 	Tcl_IncrRefCount(bufObj);
 
 	if (InvokeTclMethod(rtPtr, "read", bufObj, NULL, &resObj) != TCL_OK) {
 	    ForwardSetObjError(paramPtr, resObj);
-	    paramPtr->transform.size = TCL_AUTO_LENGTH;
+	    paramPtr->transform.size = -1;
 	} else {
 	    /*
 	     * Process a regular return. Contains the transformation result.
 	     * Sent it back to the request originator.
 	     */
 
-	    size_t bytec = 0;	/* Number of returned bytes */
+	    int bytec;		/* Number of returned bytes */
 	    unsigned char *bytev;
 				/* Array of returned bytes */
 
-	    bytev = TclGetByteArrayFromObj(resObj, &bytec);
+	    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 
 	    paramPtr->transform.size = bytec;
 
 	    if (bytec > 0) {
-		paramPtr->transform.buf = Tcl_Alloc(bytec);
+		paramPtr->transform.buf = ckalloc(bytec);
 		memcpy(paramPtr->transform.buf, bytev, bytec);
 	    } else {
 		paramPtr->transform.buf = NULL;
 	    }
 	}
@@ -2622,27 +2622,27 @@
 		paramPtr->transform.buf, paramPtr->transform.size);
 	Tcl_IncrRefCount(bufObj);
 
 	if (InvokeTclMethod(rtPtr, "write", bufObj, NULL, &resObj) != TCL_OK) {
 	    ForwardSetObjError(paramPtr, resObj);
-	    paramPtr->transform.size = TCL_AUTO_LENGTH;
+	    paramPtr->transform.size = -1;
 	} else {
 	    /*
 	     * Process a regular return. Contains the transformation result.
 	     * Sent it back to the request originator.
 	     */
 
-	    size_t bytec = 0;	/* Number of returned bytes */
+	    int bytec;		/* Number of returned bytes */
 	    unsigned char *bytev;
 				/* Array of returned bytes */
 
-	    bytev = TclGetByteArrayFromObj(resObj, &bytec);
+	    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 
 	    paramPtr->transform.size = bytec;
 
 	    if (bytec > 0) {
-		paramPtr->transform.buf = Tcl_Alloc(bytec);
+		paramPtr->transform.buf = ckalloc(bytec);
 		memcpy(paramPtr->transform.buf, bytev, bytec);
 	    } else {
 		paramPtr->transform.buf = NULL;
 	    }
 	}
@@ -2652,26 +2652,26 @@
     }
 
     case ForwardedDrain:
 	if (InvokeTclMethod(rtPtr, "drain", NULL, NULL, &resObj) != TCL_OK) {
 	    ForwardSetObjError(paramPtr, resObj);
-	    paramPtr->transform.size = TCL_AUTO_LENGTH;
+	    paramPtr->transform.size = -1;
 	} else {
 	    /*
 	     * Process a regular return. Contains the transformation result.
 	     * Sent it back to the request originator.
 	     */
 
-	    size_t bytec = 0;	/* Number of returned bytes */
+	    int bytec;		/* Number of returned bytes */
 	    unsigned char *bytev; /* Array of returned bytes */
 
-	    bytev = TclGetByteArrayFromObj(resObj, &bytec);
+	    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 
 	    paramPtr->transform.size = bytec;
 
 	    if (bytec > 0) {
-		paramPtr->transform.buf = Tcl_Alloc(bytec);
+		paramPtr->transform.buf = ckalloc(bytec);
 		memcpy(paramPtr->transform.buf, bytev, bytec);
 	    } else {
 		paramPtr->transform.buf = NULL;
 	    }
 	}
@@ -2678,27 +2678,27 @@
 	break;
 
     case ForwardedFlush:
 	if (InvokeTclMethod(rtPtr, "flush", NULL, NULL, &resObj) != TCL_OK) {
 	    ForwardSetObjError(paramPtr, resObj);
-	    paramPtr->transform.size = TCL_AUTO_LENGTH;
+	    paramPtr->transform.size = -1;
 	} else {
 	    /*
 	     * Process a regular return. Contains the transformation result.
 	     * Sent it back to the request originator.
 	     */
 
-	    size_t bytec = 0;	/* Number of returned bytes */
+	    int bytec;		/* Number of returned bytes */
 	    unsigned char *bytev;
 				/* Array of returned bytes */
 
-	    bytev = TclGetByteArrayFromObj(resObj, &bytec);
+	    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 
 	    paramPtr->transform.size = bytec;
 
 	    if (bytec > 0) {
-		paramPtr->transform.buf = Tcl_Alloc(bytec);
+		paramPtr->transform.buf = ckalloc(bytec);
 		memcpy(paramPtr->transform.buf, bytev, bytec);
 	    } else {
 		paramPtr->transform.buf = NULL;
 	    }
 	}
@@ -2803,15 +2803,15 @@
 static void
 ForwardSetObjError(
     ForwardParam *paramPtr,
     Tcl_Obj *obj)
 {
-    size_t len;
+    int len;
     const char *msgStr = TclGetStringFromObj(obj, &len);
 
     len++;
-    ForwardSetDynamicError(paramPtr, Tcl_Alloc(len));
+    ForwardSetDynamicError(paramPtr, ckalloc(len));
     memcpy(paramPtr->base.msgStr, msgStr, len);
 }
 #endif /* TCL_THREADS */
 
 /*
@@ -2952,11 +2952,11 @@
 
     if (!rPtr->allocated) {
 	return;
     }
 
-    Tcl_Free(rPtr->buf);
+    ckfree(rPtr->buf);
     rPtr->buf = NULL;
     rPtr->allocated = 0;
 }
 
 /*
@@ -2987,14 +2987,14 @@
 	 * NOTE: Currently linear. Should be doubling to amortize.
 	 */
 
 	if (rPtr->allocated == 0) {
 	    rPtr->allocated = toWrite + RB_INCREMENT;
-	    rPtr->buf = UCHARP(Tcl_Alloc(rPtr->allocated));
+	    rPtr->buf = UCHARP(ckalloc(rPtr->allocated));
 	} else {
 	    rPtr->allocated += toWrite + RB_INCREMENT;
-	    rPtr->buf = UCHARP(Tcl_Realloc((char *) rPtr->buf,
+	    rPtr->buf = UCHARP(ckrealloc((char *) rPtr->buf,
 		    rPtr->allocated));
 	}
     }
 
     /*
@@ -3035,19 +3035,19 @@
 	/*
 	 * Nothing to copy in the case of an empty buffer.
 	 */
 
 	copied = 0;
-    } else if (rPtr->used == (size_t)toRead) {
+    } else if (rPtr->used == toRead) {
 	/*
 	 * We have just enough. Copy everything to the caller.
 	 */
 
 	memcpy(buf, rPtr->buf, toRead);
 	rPtr->used = 0;
 	copied = toRead;
-    } else if (rPtr->used > (size_t)toRead) {
+    } else if (rPtr->used > toRead) {
 	/*
 	 * The internal buffer contains more than requested. Copy the
 	 * requested subset to the caller, and shift the remaining bytes down.
 	 */
 
@@ -3078,11 +3078,11 @@
     ReflectedTransform *rtPtr,
     int *errorCodePtr,
     Tcl_Obj *bufObj)
 {
     Tcl_Obj *resObj;
-    size_t bytec = 0;		/* Number of returned bytes */
+    int bytec;			/* Number of returned bytes */
     unsigned char *bytev;	/* Array of returned bytes */
 
     /*
      * Are we in the correct thread?
      */
@@ -3089,11 +3089,11 @@
 
 #if TCL_THREADS
     if (rtPtr->thread != Tcl_GetCurrentThread()) {
 	ForwardParam p;
 
-	p.transform.buf = (char *) TclGetByteArrayFromObj(bufObj,
+	p.transform.buf = (char *) Tcl_GetByteArrayFromObj(bufObj,
 		&(p.transform.size));
 
 	ForwardOpToOwnerThread(rtPtr, ForwardedInput, &p);
 
 	if (p.base.code != TCL_OK) {
@@ -3102,11 +3102,11 @@
 	    return 0;
 	}
 
 	*errorCodePtr = EOK;
 	ResultAdd(&rtPtr->result, UCHARP(p.transform.buf), p.transform.size);
-	Tcl_Free(p.transform.buf);
+	ckfree(p.transform.buf);
 	return 1;
     }
 #endif /* TCL_THREADS */
 
     /* ASSERT: rtPtr->method & FLAG(METH_READ) */
@@ -3117,11 +3117,11 @@
 	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
 	*errorCodePtr = EINVAL;
 	return 0;
     }
 
-    bytev = TclGetByteArrayFromObj(resObj, &bytec);
+    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
     ResultAdd(&rtPtr->result, bytev, bytec);
 
     Tcl_DecrRefCount(resObj);		/* Remove reference held from invoke */
     return 1;
 }
@@ -3133,11 +3133,11 @@
     unsigned char *buf,
     int toWrite)
 {
     Tcl_Obj *bufObj;
     Tcl_Obj *resObj;
-    size_t bytec = 0;		/* Number of returned bytes */
+    int bytec;			/* Number of returned bytes */
     unsigned char *bytev;	/* Array of returned bytes */
     int res;
 
     /*
      * Are we in the correct thread?
@@ -3159,11 +3159,11 @@
 	}
 
 	*errorCodePtr = EOK;
 	res = Tcl_WriteRaw(rtPtr->parent, (char *) p.transform.buf,
 		p.transform.size);
-	Tcl_Free(p.transform.buf);
+	ckfree(p.transform.buf);
     } else
 #endif /* TCL_THREADS */
     {
 	/* ASSERT: rtPtr->method & FLAG(METH_WRITE) */
 	/* ASSERT: rtPtr->mode & TCL_WRITABLE */
@@ -3179,11 +3179,11 @@
 	    return 0;
 	}
 
 	*errorCodePtr = EOK;
 
-	bytev = TclGetByteArrayFromObj(resObj, &bytec);
+	bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 	res = Tcl_WriteRaw(rtPtr->parent, (char *) bytev, bytec);
 
 	Tcl_DecrRefCount(bufObj);
 	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
     }
@@ -3200,11 +3200,11 @@
 TransformDrain(
     ReflectedTransform *rtPtr,
     int *errorCodePtr)
 {
     Tcl_Obj *resObj;
-    size_t bytec = 0;		/* Number of returned bytes */
+    int bytec;			/* Number of returned bytes */
     unsigned char *bytev;	/* Array of returned bytes */
 
     /*
      * Are we in the correct thread?
      */
@@ -3221,11 +3221,11 @@
 	    return 0;
 	}
 
 	*errorCodePtr = EOK;
 	ResultAdd(&rtPtr->result, UCHARP(p.transform.buf), p.transform.size);
-	Tcl_Free(p.transform.buf);
+	ckfree(p.transform.buf);
     } else
 #endif /* TCL_THREADS */
     {
 	if (InvokeTclMethod(rtPtr, "drain", NULL, NULL, &resObj)!=TCL_OK) {
 	    Tcl_SetChannelError(rtPtr->chan, resObj);
@@ -3232,11 +3232,11 @@
 	    Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
 	    *errorCodePtr = EINVAL;
 	    return 0;
 	}
 
-	bytev = TclGetByteArrayFromObj(resObj, &bytec);
+	bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 	ResultAdd(&rtPtr->result, bytev, bytec);
 
 	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
     }
 
@@ -3249,11 +3249,11 @@
     ReflectedTransform *rtPtr,
     int *errorCodePtr,
     int op)
 {
     Tcl_Obj *resObj;
-    size_t bytec = 0;		/* Number of returned bytes */
+    int bytec;			/* Number of returned bytes */
     unsigned char *bytev;	/* Array of returned bytes */
     int res;
 
     /*
      * Are we in the correct thread?
@@ -3276,11 +3276,11 @@
 	    res = Tcl_WriteRaw(rtPtr->parent, (char *) p.transform.buf,
 		    p.transform.size);
 	} else {
 	    res = 0;
 	}
-	Tcl_Free(p.transform.buf);
+	ckfree(p.transform.buf);
     } else
 #endif /* TCL_THREADS */
     {
 	if (InvokeTclMethod(rtPtr, "flush", NULL, NULL, &resObj)!=TCL_OK) {
 	    Tcl_SetChannelError(rtPtr->chan, resObj);
@@ -3288,11 +3288,11 @@
 	    *errorCodePtr = EINVAL;
 	    return 0;
 	}
 
 	if (op == FLUSH_WRITE) {
-	    bytev = TclGetByteArrayFromObj(resObj, &bytec);
+	    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 	    res = Tcl_WriteRaw(rtPtr->parent, (char *) bytev, bytec);
 	} else {
 	    res = 0;
 	}
 	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */

Index: generic/tclIOSock.c
==================================================================
--- generic/tclIOSock.c
+++ generic/tclIOSock.c
@@ -221,11 +221,11 @@
      * have no networking besides the loopback interface and want to resolve
      * localhost. See [Bugs 3385024, 3382419, 3382431]. As the advantage of
      * using AI_ADDRCONFIG is probably low even in situations where it works,
      * we'll leave it out for now. After all, it is just an optimisation.
      *
-     * Missing on NetBSD.
+     * Missing on: OpenBSD, NetBSD.
      * Causes failure when used on AIX 5.1 and HP-UX
      */
 
 #if defined(AI_ADDRCONFIG) && !defined(_AIX) && !defined(__hpux)
     hints.ai_flags |= AI_ADDRCONFIG;

Index: generic/tclIOUtil.c
==================================================================
--- generic/tclIOUtil.c
+++ generic/tclIOUtil.c
@@ -325,13 +325,13 @@
 	oldStyleBuf->st_rdev	= buf.st_rdev;
 	oldStyleBuf->st_nlink	= buf.st_nlink;
 	oldStyleBuf->st_uid	= buf.st_uid;
 	oldStyleBuf->st_gid	= buf.st_gid;
 	oldStyleBuf->st_size	= (off_t) buf.st_size;
-	oldStyleBuf->st_atime	= buf.st_atime;
-	oldStyleBuf->st_mtime	= buf.st_mtime;
-	oldStyleBuf->st_ctime	= buf.st_ctime;
+	oldStyleBuf->st_atime	= Tcl_GetAccessTimeFromStat(&buf);
+	oldStyleBuf->st_mtime	= Tcl_GetModificationTimeFromStat(&buf);
+	oldStyleBuf->st_ctime	= Tcl_GetChangeTimeFromStat(&buf);
 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
 	oldStyleBuf->st_blksize	= buf.st_blksize;
 #endif
 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
 #ifdef HAVE_BLKCNT_T
@@ -455,11 +455,11 @@
 
     fsRecPtr = tsdPtr->filesystemList;
     while (fsRecPtr != NULL) {
 	tmpFsRecPtr = fsRecPtr->nextPtr;
 	fsRecPtr->fsPtr = NULL;
-	Tcl_Free(fsRecPtr);
+	ckfree(fsRecPtr);
 	fsRecPtr = tmpFsRecPtr;
     }
     tsdPtr->filesystemList = NULL;
     tsdPtr->initialized = 0;
 }
@@ -537,11 +537,11 @@
     }
 
     if (tsdPtr->cwdPathPtr == *pathPtrPtr) {
 	return 1;
     } else {
-	size_t len1, len2;
+	int len1, len2;
 	const char *str1, *str2;
 
 	str1 = TclGetStringFromObj(tsdPtr->cwdPathPtr, &len1);
 	str2 = TclGetStringFromObj(*pathPtrPtr, &len2);
 	if ((len1 == len2) && !memcmp(str1, str2, len1)) {
@@ -594,11 +594,11 @@
      */
 
     list = NULL;
     fsRecPtr = tmpFsRecPtr;
     while (fsRecPtr != NULL) {
-	tmpFsRecPtr = Tcl_Alloc(sizeof(FilesystemRecord));
+	tmpFsRecPtr = ckalloc(sizeof(FilesystemRecord));
 	*tmpFsRecPtr = *fsRecPtr;
 	tmpFsRecPtr->nextPtr = list;
 	tmpFsRecPtr->prevPtr = NULL;
 	list = tmpFsRecPtr;
 	fsRecPtr = fsRecPtr->prevPtr;
@@ -609,11 +609,11 @@
 
     while (toFree) {
 	FilesystemRecord *next = toFree->nextPtr;
 
 	toFree->fsPtr = NULL;
-	Tcl_Free(toFree);
+	ckfree(toFree);
 	toFree = next;
     }
 
     /*
      * Make sure the above gets released on thread exit.
@@ -679,11 +679,11 @@
 static void
 FsUpdateCwd(
     Tcl_Obj *cwdObj,
     ClientData clientData)
 {
-    size_t len = 0;
+    int len;
     const char *str = NULL;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&fsDataKey);
 
     if (cwdObj != NULL) {
 	str = TclGetStringFromObj(cwdObj, &len);
@@ -785,11 +785,11 @@
 	/*
 	 * The native filesystem is static, so we don't free it.
 	 */
 
 	if (fsRecPtr != &nativeFilesystemRecord) {
-	    Tcl_Free(fsRecPtr);
+	    ckfree(fsRecPtr);
 	}
 	fsRecPtr = tmpFsRecPtr;
     }
     if (++theFilesystemEpoch == 0) {
 	++theFilesystemEpoch;
@@ -870,11 +870,11 @@
 
     if (fsPtr == NULL) {
 	return TCL_ERROR;
     }
 
-    newFilesystemPtr = Tcl_Alloc(sizeof(FilesystemRecord));
+    newFilesystemPtr = ckalloc(sizeof(FilesystemRecord));
 
     newFilesystemPtr->clientData = clientData;
     newFilesystemPtr->fsPtr = fsPtr;
 
     /*
@@ -973,11 +973,11 @@
 
 	    if (++theFilesystemEpoch == 0) {
 		++theFilesystemEpoch;
 	    }
 
-	    Tcl_Free(fsRecPtr);
+	    ckfree(fsRecPtr);
 
 	    retVal = TCL_OK;
 	} else {
 	    fsRecPtr = fsRecPtr->nextPtr;
 	}
@@ -1201,11 +1201,11 @@
 		break;		/* Break out of for loop. */
 	    }
 	}
 	if (!found && dir) {
 	    Tcl_Obj *norm;
-	    size_t len, mlen;
+	    int len, mlen;
 
 	    /*
 	     * We know mElt is absolute normalized and lies inside pathPtr, so
 	     * now we must add to the result the right representation of mElt,
 	     * i.e. the representation which is relative to pathPtr.
@@ -1388,13 +1388,13 @@
     Tcl_Obj *pathPtr,		/* The path to normalize in place. */
     int startAt)		/* Start at this char-offset. */
 {
     FilesystemRecord *fsRecPtr, *firstFsRecPtr;
 
-    size_t i;
+    int i;
     int isVfsPath = 0;
-    char *path;
+    const char *path;
 
     /*
      * Paths starting with a UNC prefix whose final character is a colon
      * are reserved for VFS use.  These names can not conflict with real
      * UNC paths per https://msdn.microsoft.com/en-us/library/gg465305.aspx
@@ -1401,11 +1401,11 @@
      * and rfc3986's definition of reg-name.
      *
      * We check these first to avoid useless calls to the native filesystem's
      * normalizePathProc.
      */
-    path = TclGetStringFromObj(pathPtr, &i);
+    path = Tcl_GetStringFromObj(pathPtr, &i);
 
     if ( (i >= 3) && ( (path[0] == '/' && path[1] == '/')
 		    || (path[0] == '\\' && path[1] == '\\') ) ) {
 	for ( i = 2; ; i++) {
 	    if (path[i] == '\0') break;
@@ -1665,11 +1665,11 @@
 	    if (interp != NULL) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"access mode \"%s\" not supported by this system",
 			flag));
 	    }
-	    Tcl_Free((void *)modeArgv);
+	    ckfree(modeArgv);
 	    return -1;
 #endif
 
 	} else if ((c == 'N') && (strcmp(flag, "NONBLOCK") == 0)) {
 #ifdef O_NONBLOCK
@@ -1678,11 +1678,11 @@
 	    if (interp != NULL) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"access mode \"%s\" not supported by this system",
 			flag));
 	    }
-	    Tcl_Free((void *)modeArgv);
+	    ckfree(modeArgv);
 	    return -1;
 #endif
 
 	} else if ((c == 'T') && (strcmp(flag, "TRUNC") == 0)) {
 	    mode |= O_TRUNC;
@@ -1694,16 +1694,16 @@
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"invalid access mode \"%s\": must be RDONLY, WRONLY, "
 			"RDWR, APPEND, BINARY, CREAT, EXCL, NOCTTY, NONBLOCK,"
 			" or TRUNC", flag));
 	    }
-	    Tcl_Free((void *)modeArgv);
+	    ckfree(modeArgv);
 	    return -1;
 	}
     }
 
-    Tcl_Free((void *)modeArgv);
+    ckfree(modeArgv);
 
     if (!gotRW) {
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "access mode must include either RDONLY, WRONLY, or RDWR",
@@ -1750,12 +1750,11 @@
     Tcl_Obj *pathPtr,		/* Path of file to process. Tilde-substitution
 				 * will be performed on this name. */
     const char *encodingName)	/* If non-NULL, then use this encoding for the
 				 * file. NULL means use the system encoding. */
 {
-    size_t length;
-	int result = TCL_ERROR;
+    int length, result = TCL_ERROR;
     Tcl_StatBuf statBuf;
     Tcl_Obj *oldScriptFile;
     Interp *iPtr;
     const char *string;
     Tcl_Channel chan;
@@ -1767,18 +1766,18 @@
 
     if (Tcl_FSStat(pathPtr, &statBuf) == -1) {
 	Tcl_SetErrno(errno);
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"couldn't read file \"%s\": %s",
-		TclGetString(pathPtr), Tcl_PosixError(interp)));
+		Tcl_GetString(pathPtr), Tcl_PosixError(interp)));
 	return result;
     }
     chan = Tcl_FSOpenFileChannel(interp, pathPtr, "r", 0644);
     if (chan == NULL) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"couldn't read file \"%s\": %s",
-		TclGetString(pathPtr), Tcl_PosixError(interp)));
+		Tcl_GetString(pathPtr), Tcl_PosixError(interp)));
 	return result;
     }
 
     /*
      * The eofchar is \32 (^Z). This is the usual on Windows, but we effect
@@ -1810,14 +1809,14 @@
 
     if (Tcl_ReadChars(chan, objPtr, 1, 0) == TCL_IO_FAILURE) {
 	Tcl_Close(interp, chan);
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"couldn't read file \"%s\": %s",
-		TclGetString(pathPtr), Tcl_PosixError(interp)));
+		Tcl_GetString(pathPtr), Tcl_PosixError(interp)));
 	goto end;
     }
-    string = TclGetString(objPtr);
+    string = Tcl_GetString(objPtr);
 
     /*
      * If first character is not a BOM, append the remaining characters,
      * otherwise replace them. [Bug 3466099]
      */
@@ -1825,11 +1824,11 @@
     if (Tcl_ReadChars(chan, objPtr, -1,
 	    memcmp(string, "\xef\xbb\xbf", 3)) == TCL_IO_FAILURE) {
 	Tcl_Close(interp, chan);
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"couldn't read file \"%s\": %s",
-		TclGetString(pathPtr), Tcl_PosixError(interp)));
+		Tcl_GetString(pathPtr), Tcl_PosixError(interp)));
 	goto end;
     }
 
     if (Tcl_Close(interp, chan) != TCL_OK) {
 	goto end;
@@ -1865,16 +1864,16 @@
 	/*
 	 * Record information telling where the error occurred.
 	 */
 
 	const char *pathString = TclGetStringFromObj(pathPtr, &length);
-	unsigned limit = 150;
+	int limit = 150;
 	int overflow = (length > limit);
 
 	Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 		"\n    (file \"%.*s%s\" line %d)",
-		(overflow ? limit : (unsigned)length), pathString,
+		(overflow ? limit : length), pathString,
 		(overflow ? "..." : ""), Tcl_GetErrorLine(interp)));
     }
 
   end:
     Tcl_DecrRefCount(objPtr);
@@ -1901,21 +1900,21 @@
 
     if (Tcl_FSStat(pathPtr, &statBuf) == -1) {
 	Tcl_SetErrno(errno);
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"couldn't read file \"%s\": %s",
-		TclGetString(pathPtr), Tcl_PosixError(interp)));
+		Tcl_GetString(pathPtr), Tcl_PosixError(interp)));
 	return TCL_ERROR;
     }
     chan = Tcl_FSOpenFileChannel(interp, pathPtr, "r", 0644);
     if (chan == NULL) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"couldn't read file \"%s\": %s",
-		TclGetString(pathPtr), Tcl_PosixError(interp)));
+		Tcl_GetString(pathPtr), Tcl_PosixError(interp)));
 	return TCL_ERROR;
     }
-    TclPkgFileSeen(interp, TclGetString(pathPtr));
+    TclPkgFileSeen(interp, Tcl_GetString(pathPtr));
 
     /*
      * The eofchar is \32 (^Z). This is the usual on Windows, but we effect
      * this cross-platform to allow for scripted documents. [Bug: 2040]
      */
@@ -1945,15 +1944,15 @@
 
     if (Tcl_ReadChars(chan, objPtr, 1, 0) == TCL_IO_FAILURE) {
 	Tcl_Close(interp, chan);
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"couldn't read file \"%s\": %s",
-		TclGetString(pathPtr), Tcl_PosixError(interp)));
+		Tcl_GetString(pathPtr), Tcl_PosixError(interp)));
 	Tcl_DecrRefCount(objPtr);
 	return TCL_ERROR;
     }
-    string = TclGetString(objPtr);
+    string = Tcl_GetString(objPtr);
 
     /*
      * If first character is not a BOM, append the remaining characters,
      * otherwise replace them. [Bug 3466099]
      */
@@ -1961,11 +1960,11 @@
     if (Tcl_ReadChars(chan, objPtr, -1,
 	    memcmp(string, "\xef\xbb\xbf", 3)) == TCL_IO_FAILURE) {
 	Tcl_Close(interp, chan);
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"couldn't read file \"%s\": %s",
-		TclGetString(pathPtr), Tcl_PosixError(interp)));
+		Tcl_GetString(pathPtr), Tcl_PosixError(interp)));
 	Tcl_DecrRefCount(objPtr);
 	return TCL_ERROR;
     }
 
     if (Tcl_Close(interp, chan) != TCL_OK) {
@@ -2015,18 +2014,18 @@
     } else if (result == TCL_ERROR) {
 	/*
 	 * Record information telling where the error occurred.
 	 */
 
-	size_t length;
+	int length;
 	const char *pathString = TclGetStringFromObj(pathPtr, &length);
-	const unsigned int limit = 150;
+	const int limit = 150;
 	int overflow = (length > limit);
 
 	Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 		"\n    (file \"%.*s%s\" line %d)",
-		(overflow ? limit : (unsigned int)length), pathString,
+		(overflow ? limit : length), pathString,
 		(overflow ? "..." : ""), Tcl_GetErrorLine(interp)));
     }
 
     Tcl_DecrRefCount(objPtr);
     return result;
@@ -2299,11 +2298,11 @@
 	if (seekFlag && Tcl_Seek(retVal, (Tcl_WideInt) 0, SEEK_END)
 		< (Tcl_WideInt) 0) {
 	    if (interp != NULL) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"could not seek to end of file while opening \"%s\": %s",
-			TclGetString(pathPtr), Tcl_PosixError(interp)));
+			Tcl_GetString(pathPtr), Tcl_PosixError(interp)));
 	    }
 	    Tcl_Close(NULL, retVal);
 	    return NULL;
 	}
 	if (binary) {
@@ -2318,11 +2317,11 @@
 
     Tcl_SetErrno(ENOENT);
     if (interp != NULL) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"couldn't open \"%s\": %s",
-		TclGetString(pathPtr), Tcl_PosixError(interp)));
+		Tcl_GetString(pathPtr), Tcl_PosixError(interp)));
     }
     return NULL;
 }
 
 /*
@@ -2866,11 +2865,11 @@
 	     * paths. Therefore we can be more efficient than calling
 	     * 'Tcl_FSEqualPaths', and in addition avoid a nasty infinite loop
 	     * bug when trying to normalize tsdPtr->cwdPathPtr.
 	     */
 
-	    size_t len1, len2;
+	    int len1, len2;
 	    const char *str1, *str2;
 
 	    str1 = TclGetStringFromObj(tsdPtr->cwdPathPtr, &len1);
 	    str2 = TclGetStringFromObj(norm, &len2);
 	    if ((len1 == len2) && (strcmp(str1, str2) == 0)) {
@@ -3226,11 +3225,11 @@
 	 * Better reference will be gladly taken.
 	 */
 #ifndef AUFS_SUPER_MAGIC
 #define AUFS_SUPER_MAGIC ('a' << 24 | 'u' << 16 | 'f' << 8 | 's')
 #endif /* AUFS_SUPER_MAGIC */
-	if ((statfs(TclGetString(shlibFile), &fs) == 0)
+	if ((statfs(Tcl_GetString(shlibFile), &fs) == 0)
 		&& (fs.f_type == AUFS_SUPER_MAGIC)) {
 	    return 1;
 	}
     }
 #endif /* ... NO_FSTATFS */
@@ -3302,11 +3301,11 @@
 
     if (Tcl_FSAccess(pathPtr, R_OK) != 0) {
 	if (interp) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "couldn't load library \"%s\": %s",
-		    TclGetString(pathPtr), Tcl_PosixError(interp)));
+		    Tcl_GetString(pathPtr), Tcl_PosixError(interp)));
 	}
 	return TCL_ERROR;
     }
 
 #ifdef TCL_LOAD_FROM_MEMORY
@@ -3465,11 +3464,11 @@
     /*
      * When we unload this file, we need to divert the unloading so we can
      * unload and cleanup the temporary file correctly.
      */
 
-    tvdlPtr = Tcl_Alloc(sizeof(FsDivertLoad));
+    tvdlPtr = ckalloc(sizeof(FsDivertLoad));
 
     /*
      * Remember three pieces of information. This allows us to cleanup the
      * diverted load completely, on platforms which allow proper unloading of
      * code.
@@ -3511,11 +3510,11 @@
 	Tcl_DecrRefCount(copyToPtr);
     }
 
     copyToPtr = NULL;
 
-    divertedLoadHandle = Tcl_Alloc(sizeof(struct Tcl_LoadHandle_));
+    divertedLoadHandle = ckalloc(sizeof(struct Tcl_LoadHandle_));
     divertedLoadHandle->clientData = tvdlPtr;
     divertedLoadHandle->findSymbolProcPtr = DivertFindSymbol;
     divertedLoadHandle->unloadFileProcPtr = DivertUnloadFile;
     *handlePtr = divertedLoadHandle;
 
@@ -3657,12 +3656,12 @@
 	 */
 
 	Tcl_DecrRefCount(tvdlPtr->divertedFile);
     }
 
-    Tcl_Free(tvdlPtr);
-    Tcl_Free(loadHandle);
+    ckfree(tvdlPtr);
+    ckfree(loadHandle);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -3807,11 +3806,11 @@
 	 */
 
 	Tcl_DecrRefCount(tvdlPtr->divertedFile);
     }
 
-    Tcl_Free(tvdlPtr);
+    ckfree(tvdlPtr);
 }
 
 /*
  *---------------------------------------------------------------------------
  *
@@ -4032,11 +4031,11 @@
     if (fsPtr->filesystemSeparatorProc != NULL) {
 	Tcl_Obj *sep = fsPtr->filesystemSeparatorProc(pathPtr);
 
 	if (sep != NULL) {
 	    Tcl_IncrRefCount(sep);
-	    separator = TclGetString(sep)[0];
+	    separator = Tcl_GetString(sep)[0];
 	    Tcl_DecrRefCount(sep);
 	}
     }
 
     /*
@@ -4044,11 +4043,11 @@
      * name may contain strange characters, like colons and multiple forward
      * slashes (for example 'ftp://' is a valid vfs drive name)
      */
 
     result = Tcl_NewObj();
-    p = TclGetString(pathPtr);
+    p = Tcl_GetString(pathPtr);
     Tcl_ListObjAppendElement(NULL, result,
 	    Tcl_NewStringObj(p, driveNameLength));
     p += driveNameLength;
 
     /*
@@ -4121,11 +4120,11 @@
 				 * non-NULL, then set to the name of the
 				 * drive, network-volume which contains the
 				 * path, already with a refCount for the
 				 * caller. */
 {
-    size_t pathLen;
+    int pathLen;
     const char *path = TclGetStringFromObj(pathPtr, &pathLen);
     Tcl_PathType type;
 
     type = TclFSNonnativePathType(path, pathLen, filesystemPtrPtr,
 	    driveNameLengthPtr, driveNameRef);
@@ -4229,20 +4228,20 @@
 
 		    numVolumes = -1;
 		}
 		while (numVolumes > 0) {
 		    Tcl_Obj *vol;
-		    size_t len;
+		    int len;
 		    const char *strVol;
 
 		    numVolumes--;
 		    Tcl_ListObjIndex(NULL, thisFsVolumes, numVolumes, &vol);
 		    strVol = TclGetStringFromObj(vol,&len);
-		    if ((size_t) pathLen < len) {
+		    if (pathLen < len) {
 			continue;
 		    }
-		    if (strncmp(strVol, path, len) == 0) {
+		    if (strncmp(strVol, path, (size_t) len) == 0) {
 			type = TCL_PATH_ABSOLUTE;
 			if (filesystemPtrPtr != NULL) {
 			    *filesystemPtrPtr = fsRecPtr->fsPtr;
 			}
 			if (driveNameLengthPtr != NULL) {
@@ -4421,12 +4420,12 @@
     /*
      * Set modification date of copied file.
      */
 
     if (Tcl_FSLstat(source, &sourceStatBuf) == 0) {
-	tval.actime = sourceStatBuf.st_atime;
-	tval.modtime = sourceStatBuf.st_mtime;
+	tval.actime = Tcl_GetAccessTimeFromStat(&sourceStatBuf);
+	tval.modtime = Tcl_GetModificationTimeFromStat(&sourceStatBuf);
 	Tcl_FSUtime(target, &tval);
     }
 
   done:
     return result;
@@ -4577,18 +4576,18 @@
     if (recursive) {
 	Tcl_Obj *cwdPtr = Tcl_FSGetCwd(NULL);
 
 	if (cwdPtr != NULL) {
 	    const char *cwdStr, *normPathStr;
-	    size_t cwdLen, normLen;
+	    int cwdLen, normLen;
 	    Tcl_Obj *normPath = Tcl_FSGetNormalizedPath(NULL, pathPtr);
 
 	    if (normPath != NULL) {
 		normPathStr = TclGetStringFromObj(normPath, &normLen);
 		cwdStr = TclGetStringFromObj(cwdPtr, &cwdLen);
 		if ((cwdLen >= normLen) && (strncmp(normPathStr, cwdStr,
-			normLen) == 0)) {
+			(size_t) normLen) == 0)) {
 		    /*
 		     * The cwd is inside the directory, so we perform a 'cd
 		     * [file dirname $path]'.
 		     */
 
@@ -4748,11 +4747,11 @@
 
 static void
 NativeFreeInternalRep(
     ClientData clientData)
 {
-    Tcl_Free(clientData);
+    ckfree(clientData);
 }
 
 /*
  *---------------------------------------------------------------------------
  *

Index: generic/tclIndexObj.c
==================================================================
--- generic/tclIndexObj.c
+++ generic/tclIndexObj.c
@@ -59,12 +59,12 @@
  * Keep this structure declaration in sync with tclTestObj.c
  */
 
 typedef struct {
     void *tablePtr;		/* Pointer to the table of strings */
-    size_t offset;			/* Offset between table entries */
-    size_t index;			/* Selected index into table. */
+    int offset;			/* Offset between table entries */
+    int index;			/* Selected index into table. */
 } IndexRep;
 
 /*
  * The following macros greatly simplify moving through a table...
  */
@@ -74,10 +74,79 @@
 #define NEXT_ENTRY(table, offset) \
 	(&(STRING_AT(table, offset)))
 #define EXPAND_OF(indexRep) \
 	STRING_AT((indexRep)->tablePtr, (indexRep)->offset*(indexRep)->index)
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetIndexFromObj --
+ *
+ *	This function looks up an object's value in a table of strings and
+ *	returns the index of the matching string, if any.
+ *
+ * Results:
+ *	If the value of objPtr is identical to or a unique abbreviation for
+ *	one of the entries in tablePtr, then the return value is TCL_OK and the
+ *	index of the matching entry is stored at *indexPtr. If there isn't a
+ *	proper match, then TCL_ERROR is returned and an error message is left
+ *	in interp's result (unless interp is NULL). The msg argument is used
+ *	in the error message; for example, if msg has the value "option" then
+ *	the error message will say something flag 'bad option "foo": must be
+ *	...'
+ *
+ * Side effects:
+ *	The result of the lookup is cached as the internal rep of objPtr, so
+ *	that repeated lookups can be done quickly.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_GetIndexFromObj
+int
+Tcl_GetIndexFromObj(
+    Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
+    Tcl_Obj *objPtr,		/* Object containing the string to lookup. */
+    const char *const*tablePtr,	/* Array of strings to compare against the
+				 * value of objPtr; last entry must be NULL
+				 * and there must not be duplicate entries. */
+    const char *msg,		/* Identifying word to use in error
+				 * messages. */
+    int flags,			/* 0 or TCL_EXACT */
+    int *indexPtr)		/* Place to store resulting integer index. */
+{
+    if (!(flags & INDEX_TEMP_TABLE)) {
+
+    /*
+     * See if there is a valid cached result from a previous lookup (doing the
+     * check here saves the overhead of calling Tcl_GetIndexFromObjStruct in
+     * the common case where the result is cached).
+     */
+
+    const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objPtr, &indexType);
+
+    if (irPtr) {
+	IndexRep *indexRep = irPtr->twoPtrValue.ptr1;
+
+	/*
+	 * Here's hoping we don't get hit by unfortunate packing constraints
+	 * on odd platforms like a Cray PVP...
+	 */
+
+	if (indexRep->tablePtr == (void *) tablePtr
+		&& indexRep->offset == sizeof(char *)) {
+	    *indexPtr = indexRep->index;
+	    return TCL_OK;
+	}
+    }
+    }
+    return Tcl_GetIndexFromObjStruct(interp, objPtr, tablePtr, sizeof(char *),
+	    msg, flags, indexPtr);
+}
+#endif /* TCL_NO_DEPRECATED */
+
 /*
  *----------------------------------------------------------------------
  *
  * GetIndexFromObjList --
  *
@@ -129,30 +198,30 @@
 
     /*
      * Build a string table from the list.
      */
 
-    tablePtr = Tcl_Alloc((objc + 1) * sizeof(char *));
+    tablePtr = ckalloc((objc + 1) * sizeof(char *));
     for (t = 0; t < objc; t++) {
 	if (objv[t] == objPtr) {
 	    /*
 	     * An exact match is always chosen, so we can stop here.
 	     */
 
-	    Tcl_Free((void *)tablePtr);
+	    ckfree(tablePtr);
 	    *indexPtr = t;
 	    return TCL_OK;
 	}
 
-	tablePtr[t] = TclGetString(objv[t]);
+	tablePtr[t] = Tcl_GetString(objv[t]);
     }
     tablePtr[objc] = NULL;
 
     result = Tcl_GetIndexFromObjStruct(interp, objPtr, tablePtr,
 	    sizeof(char *), msg, flags | INDEX_TEMP_TABLE, indexPtr);
 
-    Tcl_Free((void *)tablePtr);
+    ckfree(tablePtr);
 
     return result;
 }
 
 /*
@@ -188,11 +257,11 @@
     const void *tablePtr,	/* The first string in the table. The second
 				 * string will be at this address plus the
 				 * offset, the third plus the offset again,
 				 * etc. The last entry must be NULL and there
 				 * must not be duplicate entries. */
-    size_t offset,			/* The number of bytes between entries */
+    int offset,			/* The number of bytes between entries */
     const char *msg,		/* Identifying word to use in error
 				 * messages. */
     int flags,			/* 0 or TCL_EXACT */
     int *indexPtr)		/* Place to store resulting integer index. */
 {
@@ -203,12 +272,12 @@
     Tcl_Obj *resultPtr;
     IndexRep *indexRep;
     const Tcl_ObjIntRep *irPtr;
 
     /* Protect against invalid values, like -1 or 0. */
-    if (offset+1 <= sizeof(char *)) {
-	offset = sizeof(char *);
+    if (offset < (int)sizeof(char *)) {
+	offset = (int)sizeof(char *);
     }
     /*
      * See if there is a valid cached result from a previous lookup.
      */
 
@@ -281,11 +350,11 @@
     if (irPtr) {
 	indexRep = irPtr->twoPtrValue.ptr1;
     } else {
 	Tcl_ObjIntRep ir;
 
-	indexRep = Tcl_Alloc(sizeof(IndexRep));
+	indexRep = ckalloc(sizeof(IndexRep));
 	ir.twoPtrValue.ptr1 = indexRep;
 	Tcl_StoreIntRep(objPtr, &indexType, &ir);
     }
     indexRep->tablePtr = (void *) tablePtr;
     indexRep->offset = offset;
@@ -355,11 +424,11 @@
  */
 
 static int
 SetIndexFromAny(
     Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
-    register Tcl_Obj *objPtr)	/* The object to convert. */
+    Tcl_Obj *objPtr)	/* The object to convert. */
 {
     if (interp) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 	    "can't convert value to index except via Tcl_GetIndexFromObj API",
 	    -1));
@@ -387,11 +456,11 @@
 static void
 UpdateStringOfIndex(
     Tcl_Obj *objPtr)
 {
     IndexRep *indexRep = TclFetchIntRep(objPtr, &indexType)->twoPtrValue.ptr1;
-    register const char *indexStr = EXPAND_OF(indexRep);
+    const char *indexStr = EXPAND_OF(indexRep);
 
     Tcl_InitStringRep(objPtr, indexStr, strlen(indexStr));
 }
 
 /*
@@ -416,11 +485,11 @@
 DupIndex(
     Tcl_Obj *srcPtr,
     Tcl_Obj *dupPtr)
 {
     Tcl_ObjIntRep ir;
-    IndexRep *dupIndexRep = Tcl_Alloc(sizeof(IndexRep));
+    IndexRep *dupIndexRep = ckalloc(sizeof(IndexRep));
 
     memcpy(dupIndexRep, TclFetchIntRep(srcPtr, &indexType)->twoPtrValue.ptr1,
 	    sizeof(IndexRep));
 
     ir.twoPtrValue.ptr1 = dupIndexRep;
@@ -446,11 +515,11 @@
 
 static void
 FreeIndex(
     Tcl_Obj *objPtr)
 {
-    Tcl_Free(TclFetchIntRep(objPtr, &indexType)->twoPtrValue.ptr1);
+    ckfree(TclFetchIntRep(objPtr, &indexType)->twoPtrValue.ptr1);
     objPtr->typePtr = NULL;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -542,11 +611,11 @@
 			"missing value for -message", -1));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "NOARG", NULL);
 		return TCL_ERROR;
 	    }
 	    i++;
-	    message = TclGetString(objv[i]);
+	    message = Tcl_GetString(objv[i]);
 	    break;
 	case PRFMATCH_ERROR:
 	    if (i > objc-4) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"missing value for -error", -1));
@@ -632,12 +701,11 @@
     ClientData clientData,	/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    int tableObjc, result, t;
-    size_t length, elemLength;
+    int tableObjc, result, t, length, elemLength;
     const char *string, *elemString;
     Tcl_Obj **tableObjv, *resultPtr;
 
     if (objc != 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "table string");
@@ -690,12 +758,11 @@
     ClientData clientData,	/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    int tableObjc, result, t;
-    size_t i, length, elemLength, resultLength;
+    int tableObjc, result, i, t, length, elemLength, resultLength;
     const char *string, *elemString, *resultString;
     Tcl_Obj **tableObjv;
 
     if (objc != 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "table string");
@@ -814,16 +881,38 @@
     const char *message)	/* Error message to print after the leading
 				 * objects in objv. The message may be
 				 * NULL. */
 {
     Tcl_Obj *objPtr;
-    int i;
-    size_t len, elemLen;
+    int i, len, elemLen;
     char flags;
     Interp *iPtr = (Interp *) interp;
     const char *elementStr;
 
+    /*
+     * [incr Tcl] does something fairly horrific when generating error
+     * messages for its ensembles; it passes the whole set of ensemble
+     * arguments as a list in the first argument. This means that this code
+     * causes a problem in iTcl if it attempts to correctly quote all
+     * arguments, which would be the correct thing to do. We work around this
+     * nasty behaviour for now, and hope that we can remove it all in the
+     * future...
+     */
+
+#ifndef AVOID_HACKS_FOR_ITCL
+    int isFirst = 1;		/* Special flag used to inhibit the treating
+				 * of the first word as a list element so the
+				 * hacky way Itcl generates error messages for
+				 * its ensembles will still work. [Bug
+				 * 1066837] */
+#   define MAY_QUOTE_WORD	(!isFirst)
+#   define AFTER_FIRST_WORD	(isFirst = 0)
+#else /* !AVOID_HACKS_FOR_ITCL */
+#   define MAY_QUOTE_WORD	1
+#   define AFTER_FIRST_WORD	(void) 0
+#endif /* AVOID_HACKS_FOR_ITCL */
+
     TclNewObj(objPtr);
     if (iPtr->flags & INTERP_ALTERNATE_WRONG_ARGS) {
 	iPtr->flags &= ~INTERP_ALTERNATE_WRONG_ARGS;
 	Tcl_AppendObjToObj(objPtr, Tcl_GetObjResult(interp));
 	Tcl_AppendToObj(objPtr, " or \"", -1);
@@ -876,30 +965,32 @@
 	     * Add the element, quoting it if necessary.
 	     */
 	    const Tcl_ObjIntRep *irPtr;
 
 	    if ((irPtr = TclFetchIntRep(origObjv[i], &indexType))) {
-		register IndexRep *indexRep = irPtr->twoPtrValue.ptr1;
+		IndexRep *indexRep = irPtr->twoPtrValue.ptr1;
 
 		elementStr = EXPAND_OF(indexRep);
 		elemLen = strlen(elementStr);
 	    } else {
 		elementStr = TclGetStringFromObj(origObjv[i], &elemLen);
 	    }
 	    flags = 0;
 	    len = TclScanElement(elementStr, elemLen, &flags);
 
-	    if (len != elemLen) {
+	    if (MAY_QUOTE_WORD && len != elemLen) {
 		char *quotedElementStr = TclStackAlloc(interp, len + 1);
 
 		len = TclConvertElement(elementStr, elemLen,
 			quotedElementStr, flags);
 		Tcl_AppendToObj(objPtr, quotedElementStr, len);
 		TclStackFree(interp, quotedElementStr);
 	    } else {
 		Tcl_AppendToObj(objPtr, elementStr, elemLen);
 	    }
+
+	    AFTER_FIRST_WORD;
 
 	    /*
 	     * Add a space if the word is not the last one (which has a
 	     * moderately complex condition here).
 	     */
@@ -923,11 +1014,11 @@
 	 * Otherwise, just use the string rep.
 	 */
 	const Tcl_ObjIntRep *irPtr;
 
 	if ((irPtr = TclFetchIntRep(objv[i], &indexType))) {
-	    register IndexRep *indexRep = irPtr->twoPtrValue.ptr1;
+	    IndexRep *indexRep = irPtr->twoPtrValue.ptr1;
 
 	    Tcl_AppendStringsToObj(objPtr, EXPAND_OF(indexRep), NULL);
 	} else {
 	    /*
 	     * Quote the argument if it contains spaces (Bug 942757).
@@ -935,11 +1026,11 @@
 
 	    elementStr = TclGetStringFromObj(objv[i], &elemLen);
 	    flags = 0;
 	    len = TclScanElement(elementStr, elemLen, &flags);
 
-	    if (len != elemLen) {
+	    if (MAY_QUOTE_WORD && len != elemLen) {
 		char *quotedElementStr = TclStackAlloc(interp, len + 1);
 
 		len = TclConvertElement(elementStr, elemLen,
 			quotedElementStr, flags);
 		Tcl_AppendToObj(objPtr, quotedElementStr, len);
@@ -946,10 +1037,12 @@
 		TclStackFree(interp, quotedElementStr);
 	    } else {
 		Tcl_AppendToObj(objPtr, elementStr, elemLen);
 	    }
 	}
+
+	AFTER_FIRST_WORD;
 
 	/*
 	 * Append a space character (" ") if there is more text to follow
 	 * (either another element from objv, or the message string).
 	 */
@@ -969,10 +1062,12 @@
 	Tcl_AppendStringsToObj(objPtr, message, NULL);
     }
     Tcl_AppendStringsToObj(objPtr, "\"", NULL);
     Tcl_SetErrorCode(interp, "TCL", "WRONGARGS", NULL);
     Tcl_SetObjResult(interp, objPtr);
+#undef MAY_QUOTE_WORD
+#undef AFTER_FIRST_WORD
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1010,28 +1105,28 @@
 {
     Tcl_Obj **leftovers;	/* Array to write back to remObjv on
 				 * successful exit. Will include the name of
 				 * the command. */
     int nrem;			/* Size of leftovers.*/
-    register const Tcl_ArgvInfo *infoPtr;
+    const Tcl_ArgvInfo *infoPtr;
 				/* Pointer to the current entry in the table
 				 * of argument descriptions. */
     const Tcl_ArgvInfo *matchPtr;
 				/* Descriptor that matches current argument */
     Tcl_Obj *curArg;		/* Current argument */
     const char *str = NULL;
-    register char c;		/* Second character of current arg (used for
+    char c;		/* Second character of current arg (used for
 				 * quick check for matching; use 2nd char.
 				 * because first char. will almost always be
 				 * '-'). */
     int srcIndex;		/* Location from which to read next argument
 				 * from objv. */
     int dstIndex;		/* Used to keep track of current arguments
 				 * being processed, primarily for error
 				 * reporting. */
     int objc;			/* # arguments in objv still to process. */
-    size_t length;			/* Number of characters in current argument */
+    int length;			/* Number of characters in current argument */
 
     if (remObjv != NULL) {
 	/*
 	 * Then we should copy the name of the command (0th argument). The
 	 * upper bound on the number of elements is known, and (undocumented,
@@ -1038,11 +1133,11 @@
 	 * but historically true) there should be a NULL argument after the
 	 * last result. [Bug 3413857]
 	 */
 
 	nrem = 1;
-	leftovers = Tcl_Alloc((1 + *objcPtr) * sizeof(Tcl_Obj *));
+	leftovers = ckalloc((1 + *objcPtr) * sizeof(Tcl_Obj *));
 	leftovers[0] = objv[0];
     } else {
 	nrem = 0;
 	leftovers = NULL;
     }
@@ -1124,11 +1219,11 @@
 	    }
 	    if (Tcl_GetIntFromObj(interp, objv[srcIndex],
 		    (int *) infoPtr->dstPtr) == TCL_ERROR) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"expected integer argument for \"%s\" but got \"%s\"",
-			infoPtr->keyStr, TclGetString(objv[srcIndex])));
+			infoPtr->keyStr, Tcl_GetString(objv[srcIndex])));
 		goto error;
 	    }
 	    srcIndex++;
 	    objc--;
 	    break;
@@ -1135,11 +1230,11 @@
 	case TCL_ARGV_STRING:
 	    if (objc == 0) {
 		goto missingArg;
 	    }
 	    *((const char **) infoPtr->dstPtr) =
-		    TclGetString(objv[srcIndex]);
+		    Tcl_GetString(objv[srcIndex]);
 	    srcIndex++;
 	    objc--;
 	    break;
 	case TCL_ARGV_REST:
 	    /*
@@ -1157,11 +1252,11 @@
 	    }
 	    if (Tcl_GetDoubleFromObj(interp, objv[srcIndex],
 		    (double *) infoPtr->dstPtr) == TCL_ERROR) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"expected floating-point argument for \"%s\" but got \"%s\"",
-			infoPtr->keyStr, TclGetString(objv[srcIndex])));
+			infoPtr->keyStr, Tcl_GetString(objv[srcIndex])));
 		goto error;
 	    }
 	    srcIndex++;
 	    objc--;
 	    break;
@@ -1222,11 +1317,11 @@
 	memcpy(leftovers+nrem, objv+srcIndex, objc*sizeof(Tcl_Obj *));
 	nrem += objc;
     }
     leftovers[nrem] = NULL;
     *objcPtr = nrem++;
-    *remObjv = Tcl_Realloc(leftovers, nrem * sizeof(Tcl_Obj *));
+    *remObjv = ckrealloc(leftovers, nrem * sizeof(Tcl_Obj *));
     return TCL_OK;
 
     /*
      * Make sure to handle freeing any temporary space we've allocated on the
      * way to an error.
@@ -1235,11 +1330,11 @@
   missingArg:
     Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 	    "\"%s\" option requires an additional argument", str));
   error:
     if (leftovers != NULL) {
-	Tcl_Free(leftovers);
+	ckfree(leftovers);
     }
     return TCL_ERROR;
 }
 
 /*
@@ -1265,11 +1360,11 @@
 				 * area. */
     const Tcl_ArgvInfo *argTable)
 				/* Array of command-specific argument
 				 * descriptions. */
 {
-    register const Tcl_ArgvInfo *infoPtr;
+    const Tcl_ArgvInfo *infoPtr;
     int width, numSpaces;
 #define NUM_SPACES 20
     static const char spaces[] = "                    ";
     char tmp[TCL_DOUBLE_SPACE];
     Tcl_Obj *msg;
@@ -1279,17 +1374,17 @@
      * everything line up.
      */
 
     width = 4;
     for (infoPtr = argTable; infoPtr->type != TCL_ARGV_END; infoPtr++) {
-	size_t length;
+	int length;
 
 	if (infoPtr->keyStr == NULL) {
 	    continue;
 	}
 	length = strlen(infoPtr->keyStr);
-	if (length > (size_t)width) {
+	if (length > width) {
 	    width = length;
 	}
     }
 
     /*

Index: generic/tclInt.decls
==================================================================
--- generic/tclInt.decls
+++ generic/tclInt.decls
@@ -46,17 +46,16 @@
 }
 declare 6 {
     void TclCleanupCommand(Command *cmdPtr)
 }
 declare 7 {
-    size_t TclCopyAndCollapse(size_t count, const char *src, char *dst)
+    int TclCopyAndCollapse(int count, const char *src, char *dst)
 }
-# Removed in 9.0:
-#declare 8 {
-#    int TclCopyChannelOld(Tcl_Interp *interp, Tcl_Channel inChan,
-#	    Tcl_Channel outChan, int toRead, Tcl_Obj *cmdPtr)
-#}
+declare 8 {deprecated {}} {
+    int TclCopyChannelOld(Tcl_Interp *interp, Tcl_Channel inChan,
+	    Tcl_Channel outChan, int toRead, Tcl_Obj *cmdPtr)
+}
 
 # TclCreatePipeline unofficially exported for use by BLT.
 
 declare 9 {
     int TclCreatePipeline(Tcl_Interp *interp, int argc, const char **argv,
@@ -78,11 +77,11 @@
 #declare 13 {
 #    int TclDoGlob(Tcl_Interp *interp, char *separators,
 #	    Tcl_DString *headPtr, char *tail, Tcl_GlobTypeData *types)
 #}
 declare 14 {
-    int TclDumpMemoryInfo(void *clientData, int flags)
+    int TclDumpMemoryInfo(ClientData clientData, int flags)
 }
 # Removed in 8.1:
 #  declare 15 {
 #      void TclExpandParseValue(ParseValue *pvPtr, int needed)
 #  }
@@ -106,18 +105,18 @@
 #    int TclFileRenameCmd(Tcl_Interp *interp, int argc, char **argv)
 #}
 declare 22 {
     int TclFindElement(Tcl_Interp *interp, const char *listStr,
 	    int listLength, const char **elementPtr, const char **nextPtr,
-	    size_t *sizePtr, int *bracePtr)
+	    int *sizePtr, int *bracePtr)
 }
 declare 23 {
     Proc *TclFindProc(Interp *iPtr, const char *procName)
 }
 # Replaced with macro (see tclInt.h) in Tcl 8.5.0, restored in 8.5.10
 declare 24 {
-    size_t TclFormatInt(char *buffer, Tcl_WideInt n)
+    int TclFormatInt(char *buffer, Tcl_WideInt n)
 }
 declare 25 {
     void TclFreePackageInfo(Interp *iPtr)
 }
 # Removed in 8.1:
@@ -150,15 +149,14 @@
 }
 # Removed in 8.5:
 #declare 33 {
 #    TclCmdProcType TclGetInterpProc(void)
 #}
-# Removed in 9.0:
-#declare 34 {deprecated {Use Tcl_GetIntForIndex}} {
-#    int TclGetIntForIndex(Tcl_Interp *interp, Tcl_Obj *objPtr,
-#	    int endValue, int *indexPtr)
-#}
+declare 34 {deprecated {Use Tcl_GetIntForIndex}} {
+    int TclGetIntForIndex(Tcl_Interp *interp, Tcl_Obj *objPtr,
+	    int endValue, int *indexPtr)
+}
 # Removed in 8.4b2:
 #declare 35 {
 #    Tcl_Obj *TclGetIndexedScalar(Tcl_Interp *interp, int localIndex,
 #	    int flags)
 #}
@@ -183,11 +181,11 @@
 }
 declare 41 {
     Tcl_Command TclGetOriginalCommand(Tcl_Command command)
 }
 declare 42 {
-    const char *TclpGetUserHome(const char *name, Tcl_DString *bufferPtr)
+    CONST86 char *TclpGetUserHome(const char *name, Tcl_DString *bufferPtr)
 }
 # Removed in 8.5a2:
 #declare 43 {
 #    int TclGlobalInvoke(Tcl_Interp *interp, int argc, const char **argv,
 #	    int flags)
@@ -226,15 +224,15 @@
 #declare 52 {
 #    int TclInvoke(Tcl_Interp *interp, int argc, const char **argv,
 #	    int flags)
 #}
 declare 53 {
-    int TclInvokeObjectCommand(void *clientData, Tcl_Interp *interp,
+    int TclInvokeObjectCommand(ClientData clientData, Tcl_Interp *interp,
 	    int argc, const char **argv)
 }
 declare 54 {
-    int TclInvokeStringCommand(void *clientData, Tcl_Interp *interp,
+    int TclInvokeStringCommand(ClientData clientData, Tcl_Interp *interp,
 	    int objc, Tcl_Obj *const objv[])
 }
 declare 55 {
     Proc *TclIsProc(Command *cmdPtr)
 }
@@ -266,11 +264,11 @@
 }
 declare 62 {
     int TclObjCommandComplete(Tcl_Obj *cmdPtr)
 }
 declare 63 {
-    int TclObjInterpProc(void *clientData, Tcl_Interp *interp,
+    int TclObjInterpProc(ClientData clientData, Tcl_Interp *interp,
 	    int objc, Tcl_Obj *const objv[])
 }
 declare 64 {
     int TclObjInvoke(Tcl_Interp *interp, int objc, Tcl_Obj *const objv[],
 	    int flags)
@@ -289,11 +287,11 @@
 # Replaced by Tcl_FSAccess in 8.4:
 #declare 68 {
 #    int TclpAccess(const char *path, int mode)
 #}
 declare 69 {
-    void *TclpAlloc(size_t size)
+    char *TclpAlloc(unsigned int size)
 }
 #declare 70 {
 #    int TclpCopyFile(const char *source, const char *dest)
 #}
 #declare 71 {
@@ -305,23 +303,21 @@
 #}
 #declare 73 {
 #    int TclpDeleteFile(const char *path)
 #}
 declare 74 {
-    void TclpFree(void *ptr)
+    void TclpFree(char *ptr)
 }
 declare 75 {
-    Tcl_WideUInt TclpGetClicks(void)
+    unsigned long TclpGetClicks(void)
 }
 declare 76 {
-    Tcl_WideUInt TclpGetSeconds(void)
+    unsigned long TclpGetSeconds(void)
 }
-
-# Removed in 9.0:
-#declare 77 {
-#    void TclpGetTime(Tcl_Time *time)
-#}
+declare 77 {deprecated {}} {
+    void TclpGetTime(Tcl_Time *time)
+}
 # Removed in 8.6:
 #declare 78 {
 #    int TclpGetTimeZone(unsigned long time)
 #}
 # Replaced by Tcl_FSListVolumes in 8.4:
@@ -332,11 +328,11 @@
 #declare 80 {
 #    Tcl_Channel TclpOpenFileChannel(Tcl_Interp *interp, char *fileName,
 #	    char *modeString, int permissions)
 #}
 declare 81 {
-    void *TclpRealloc(void *ptr, size_t size)
+    char *TclpRealloc(char *ptr, unsigned int size)
 }
 #declare 82 {
 #    int TclpRemoveDirectory(const char *path, int recursive,
 #	    Tcl_DString *errorPtr)
 #}
@@ -357,15 +353,14 @@
 #  	    int flags, char **termPtr, ParseValue *pvPtr)
 #  }
 #  declare 87 {
 #      void TclPlatformInit(Tcl_Interp *interp)
 #  }
-# Removed in 9.0:
-#declare 88 {
-#    char *TclPrecTraceProc(void *clientData, Tcl_Interp *interp,
-#	    const char *name1, const char *name2, int flags)
-#}
+declare 88 {deprecated {}} {
+    char *TclPrecTraceProc(ClientData clientData, Tcl_Interp *interp,
+	    const char *name1, const char *name2, int flags)
+}
 declare 89 {
     int TclPreventAliasLoop(Tcl_Interp *interp, Tcl_Interp *cmdInterp,
 	    Tcl_Command cmd)
 }
 # Removed in 8.1 (only available if compiled with TCL_COMPILE_DEBUG):
@@ -379,15 +374,15 @@
     int TclProcCompileProc(Tcl_Interp *interp, Proc *procPtr,
 	    Tcl_Obj *bodyPtr, Namespace *nsPtr, const char *description,
 	    const char *procName)
 }
 declare 93 {
-    void TclProcDeleteProc(void *clientData)
+    void TclProcDeleteProc(ClientData clientData)
 }
 # Removed in 8.5:
 #declare 94 {
-#    int TclProcInterpProc(void *clientData, Tcl_Interp *interp,
+#    int TclProcInterpProc(ClientData clientData, Tcl_Interp *interp,
 #	    int argc, const char **argv)
 #}
 # Replaced by Tcl_FSStat in 8.4:
 #declare 95 {
 #    int TclpStat(const char *path, Tcl_StatBuf *buf)
@@ -411,23 +406,22 @@
 #declare 100 {
 #    Tcl_Obj *TclSetIndexedScalar(Tcl_Interp *interp, int localIndex,
 #	    Tcl_Obj *objPtr, int flags)
 #}
 declare 101 {
-    const char *TclSetPreInitScript(const char *string)
+    CONST86 char *TclSetPreInitScript(const char *string)
 }
 declare 102 {
     void TclSetupEnv(Tcl_Interp *interp)
 }
 declare 103 {
     int TclSockGetPort(Tcl_Interp *interp, const char *str, const char *proto,
 	    int *portPtr)
 }
-# Removed in 9.0:
-#declare 104 {
-#    int TclSockMinimumBuffersOld(int sock, int size)
-#}
+declare 104 {deprecated {}} {
+    int TclSockMinimumBuffersOld(int sock, int size)
+}
 # Replaced by Tcl_FSStat in 8.4:
 #declare 105 {
 #    int TclStat(const char *path, Tcl_StatBuf *buf)
 #}
 #declare 106 {
@@ -456,39 +450,33 @@
 declare 111 {
     void Tcl_AddInterpResolvers(Tcl_Interp *interp, const char *name,
 	    Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc,
 	    Tcl_ResolveCompiledVarProc *compiledVarProc)
 }
-# Removed in 9.0:
-#declare 112 {
-#    int Tcl_AppendExportList(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
-#	    Tcl_Obj *objPtr)
-#}
-# Removed in 9.0:
-#declare 113 {
-#    Tcl_Namespace *Tcl_CreateNamespace(Tcl_Interp *interp, const char *name,
-#	    void *clientData, Tcl_NamespaceDeleteProc *deleteProc)
-#}
-# Removed in 9.0:
-#declare 114 {
-#    void Tcl_DeleteNamespace(Tcl_Namespace *nsPtr)
-#}
-# Removed in 9.0:
-#declare 115 {
-#    int Tcl_Export(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
-#	    const char *pattern, int resetListFirst)
-#}
-# Removed in 9.0:
-#declare 116 {
-#    Tcl_Command Tcl_FindCommand(Tcl_Interp *interp, const char *name,
-#	    Tcl_Namespace *contextNsPtr, int flags)
-#}
-# Removed in 9.0:
-#declare 117 {
-#    Tcl_Namespace *Tcl_FindNamespace(Tcl_Interp *interp, const char *name,
-#	    Tcl_Namespace *contextNsPtr, int flags)
-#}
+declare 112 {
+    int TclAppendExportList(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
+	    Tcl_Obj *objPtr)
+}
+declare 113 {
+    Tcl_Namespace *TclCreateNamespace(Tcl_Interp *interp, const char *name,
+	    ClientData clientData, Tcl_NamespaceDeleteProc *deleteProc)
+}
+declare 114 {
+    void TclDeleteNamespace(Tcl_Namespace *nsPtr)
+}
+declare 115 {
+    int TclExport(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
+	    const char *pattern, int resetListFirst)
+}
+declare 116 {
+    Tcl_Command TclFindCommand(Tcl_Interp *interp, const char *name,
+	    Tcl_Namespace *contextNsPtr, int flags)
+}
+declare 117 {
+    Tcl_Namespace *TclFindNamespace(Tcl_Interp *interp, const char *name,
+	    Tcl_Namespace *contextNsPtr, int flags)
+}
 declare 118 {
     int Tcl_GetInterpResolvers(Tcl_Interp *interp, const char *name,
 	    Tcl_ResolverInfo *resInfo)
 }
 declare 119 {
@@ -497,41 +485,35 @@
 }
 declare 120 {
     Tcl_Var Tcl_FindNamespaceVar(Tcl_Interp *interp, const char *name,
 	    Tcl_Namespace *contextNsPtr, int flags)
 }
-# Removed in 9.0:
-#declare 121 {
-#    int Tcl_ForgetImport(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
-#	    const char *pattern)
-#}
-# Removed in 9.0:
-#declare 122 {
-#    Tcl_Command Tcl_GetCommandFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr)
-#}
-# Removed in 9.0:
-#declare 123 {
-#    void Tcl_GetCommandFullName(Tcl_Interp *interp, Tcl_Command command,
-#	    Tcl_Obj *objPtr)
-#}
-# Removed in 9.0:
-#declare 124 {
-#    Tcl_Namespace *Tcl_GetCurrentNamespace(Tcl_Interp *interp)
-#}
-# Removed in 9.0:
-#declare 125 {
-#    Tcl_Namespace *Tcl_GetGlobalNamespace(Tcl_Interp *interp)
-#}
+declare 121 {
+    int TclForgetImport(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
+	    const char *pattern)
+}
+declare 122 {
+    Tcl_Command TclGetCommandFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr)
+}
+declare 123 {
+    void TclGetCommandFullName(Tcl_Interp *interp, Tcl_Command command,
+	    Tcl_Obj *objPtr)
+}
+declare 124 {
+    Tcl_Namespace *TclGetCurrentNamespace_(Tcl_Interp *interp)
+}
+declare 125 {
+    Tcl_Namespace *TclGetGlobalNamespace_(Tcl_Interp *interp)
+}
 declare 126 {
     void Tcl_GetVariableFullName(Tcl_Interp *interp, Tcl_Var variable,
 	    Tcl_Obj *objPtr)
 }
-# Removed in 9.0:
-#declare 127 {
-#    int Tcl_Import(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
-#	    const char *pattern, int allowOverwrite)
-#}
+declare 127 {
+    int TclImport(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
+	    const char *pattern, int allowOverwrite)
+}
 declare 128 {
     void Tcl_PopCallFrame(Tcl_Interp *interp)
 }
 declare 129 {
     int Tcl_PushCallFrame(Tcl_Interp *interp, Tcl_CallFrame *framePtr,
@@ -546,14 +528,13 @@
 	    Tcl_ResolveCompiledVarProc *compiledVarProc)
 }
 declare 132 {
     int TclpHasSockets(Tcl_Interp *interp)
 }
-# Removed in 9.0
-#declare 133 {
-#    struct tm *TclpGetDate(const time_t *time, int useGMT)
-#}
+declare 133 {deprecated {}} {
+    struct tm *TclpGetDate(const time_t *time, int useGMT)
+}
 # Removed in 8.5
 #declare 134 {
 #    size_t TclpStrftime(char *s, size_t maxsize, const char *format,
 #	    const struct tm *t, int useGMT)
 #}
@@ -570,11 +551,11 @@
     const char *TclGetEnv(const char *name, Tcl_DString *valuePtr)
 }
 #declare 139 {
 #    int TclpLoadFile(Tcl_Interp *interp, char *fileName, char *sym1,
 #	    char *sym2, Tcl_PackageInitProc **proc1Ptr,
-#	    Tcl_PackageInitProc **proc2Ptr, void **clientDataPtr)
+#	    Tcl_PackageInitProc **proc2Ptr, ClientData *clientDataPtr)
 #}
 #declare 140 {
 #    int TclLooksLikeInt(const char *bytes, int length)
 #}
 # This is used by TclX, but should otherwise be considered private
@@ -581,11 +562,11 @@
 declare 141 {
     const char *TclpGetCwd(Tcl_Interp *interp, Tcl_DString *cwdPtr)
 }
 declare 142 {
     int TclSetByteCodeFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr,
-	    CompileHookProc *hookProc, void *clientData)
+	    CompileHookProc *hookProc, ClientData clientData)
 }
 declare 143 {
     int TclAddLiteralObj(struct CompileEnv *envPtr, Tcl_Obj *objPtr,
 	    LiteralEntry **litPtrPtr)
 }
@@ -613,12 +594,12 @@
 
 declare 150 {
     int TclRegAbout(Tcl_Interp *interp, Tcl_RegExp re)
 }
 declare 151 {
-    void TclRegExpRangeUniChar(Tcl_RegExp re, size_t index, size_t *startPtr,
-	    size_t *endPtr)
+    void TclRegExpRangeUniChar(Tcl_RegExp re, int index, int *startPtr,
+	    int *endPtr)
 }
 declare 152 {
     void TclSetLibraryPath(Tcl_Obj *pathPtr)
 }
 declare 153 {
@@ -625,15 +606,15 @@
     Tcl_Obj *TclGetLibraryPath(void)
 }
 
 # moved to tclTest.c (static) in 8.3.2/8.4a2
 #declare 154 {
-#    int TclTestChannelCmd(void *clientData,
+#    int TclTestChannelCmd(ClientData clientData,
 #    Tcl_Interp *interp, int argc, char **argv)
 #}
 #declare 155 {
-#    int TclTestChannelEventCmd(void *clientData,
+#    int TclTestChannelEventCmd(ClientData clientData,
 #	     Tcl_Interp *interp, int argc, char **argv)
 #}
 
 declare 156 {
     void TclRegError(Tcl_Interp *interp, const char *msg,
@@ -640,18 +621,16 @@
 	    int status)
 }
 declare 157 {
     Var *TclVarTraceExists(Tcl_Interp *interp, const char *varName)
 }
-# REMOVED - use public Tcl_SetStartupScript()
-#declare 158 {
-#    void TclSetStartupScriptFileName(const char *filename)
-#}
-# REMOVED - use public Tcl_GetStartupScript()
-#declare 159 {
-#    const char *TclGetStartupScriptFileName(void)
-#}
+declare 158 {deprecated {use public Tcl_SetStartupScript()}} {
+    void TclSetStartupScriptFileName(const char *filename)
+}
+declare 159 {deprecated {use public Tcl_GetStartupScript()}} {
+    const char *TclGetStartupScriptFileName(void)
+}
 #declare 160 {
 #    int TclpMatchFilesTypes(Tcl_Interp *interp, char *separators,
 #	    Tcl_DString *dirPtr, char *pattern, char *tail,
 #	    GlobTypeData *types)
 #}
@@ -660,11 +639,11 @@
 declare 161 {
     int TclChannelTransform(Tcl_Interp *interp, Tcl_Channel chan,
 	    Tcl_Obj *cmdObjPtr)
 }
 declare 162 {
-    void TclChannelEventScriptInvoker(void *clientData, int flags)
+    void TclChannelEventScriptInvoker(ClientData clientData, int flags)
 }
 
 # ALERT: The result of 'TclGetInstructionTable' is actually a
 # "const InstructionDesc*" but we do not want to describe this structure in
 # "tclInt.h". It is described in "tclCompile.h". Use a cast to the
@@ -691,42 +670,39 @@
 declare 166 {
     int TclListObjSetElement(Tcl_Interp *interp, Tcl_Obj *listPtr,
 	    int index, Tcl_Obj *valuePtr)
 }
 
-# VFS-aware versions of Tcl*StartupScriptFileName (158 and 159 above)
-# REMOVED - use public Tcl_SetStartupScript()
-#declare 167 {
-#    void TclSetStartupScriptPath(Tcl_Obj *pathPtr)
-#}
-# REMOVED - use public Tcl_GetStartupScript()
-#declare 168 {
-#    Tcl_Obj *TclGetStartupScriptPath(void)
-#}
+declare 167 {deprecated {use public Tcl_SetStartupScript()}} {
+    void TclSetStartupScriptPath(Tcl_Obj *pathPtr)
+}
+declare 168 {deprecated {use public Tcl_GetStartupScript()}} {
+    Tcl_Obj *TclGetStartupScriptPath(void)
+}
 # variant of Tcl_UtfNCmp that takes n as bytes, not chars
 declare 169 {
-    int TclpUtfNcmp2(const char *s1, const char *s2, size_t n)
+    int TclpUtfNcmp2(const char *s1, const char *s2, unsigned long n)
 }
 declare 170 {
     int TclCheckInterpTraces(Tcl_Interp *interp, const char *command,
-	    size_t numChars, Command *cmdPtr, int result, int traceFlags,
+	    int numChars, Command *cmdPtr, int result, int traceFlags,
 	    int objc, Tcl_Obj *const objv[])
 }
 declare 171 {
     int TclCheckExecutionTraces(Tcl_Interp *interp, const char *command,
-	    size_t numChars, Command *cmdPtr, int result, int traceFlags,
+	    int numChars, Command *cmdPtr, int result, int traceFlags,
 	    int objc, Tcl_Obj *const objv[])
 }
 declare 172 {
     int TclInThreadExit(void)
 }
 
 # added for 8.4.2
 
 declare 173 {
-    int TclUniCharMatch(const Tcl_UniChar *string, size_t strLen,
-	    const Tcl_UniChar *pattern, size_t ptnLen, int flags)
+    int TclUniCharMatch(const Tcl_UniChar *string, int strLen,
+	    const Tcl_UniChar *pattern, int ptnLen, int flags)
 }
 
 # added for 8.4.3
 
 #declare 174 {
@@ -745,17 +721,16 @@
 }
 declare 177 {
     void TclVarErrMsg(Tcl_Interp *interp, const char *part1, const char *part2,
 	    const char *operation, const char *reason)
 }
-# TIP 338 made these public - now declared in tcl.h
-#declare 178 {
-#    void Tcl_SetStartupScript(Tcl_Obj *pathPtr, const char *encodingName)
-#}
-#declare 179 {
-#    Tcl_Obj *Tcl_GetStartupScript(const char **encodingNamePtr)
-#}
+declare 178 {
+    void TclSetStartupScript(Tcl_Obj *pathPtr, const char *encodingName)
+}
+declare 179 {
+    Tcl_Obj *TclGetStartupScript(const char **encodingNamePtr)
+}
 
 # REMOVED
 # Allocate lists without copying arrays
 # declare 180 {
 #    Tcl_Obj *TclNewListObjDirect(int objc, Tcl_Obj **objv)
@@ -763,18 +738,16 @@
 #declare 181 {
 #    Tcl_Obj *TclDbNewListObjDirect(int objc, Tcl_Obj **objv,
 #	    const char *file, int line)
 #}
 
-# Removed in 9.0
-#declare 182 {
-#     struct tm *TclpLocaltime(const time_t *clock)
-#}
-# Removed in 9.0
-#declare 183 {
-#     struct tm *TclpGmtime(const time_t *clock)
-#}
+declare 182 {deprecated {}} {
+     struct tm *TclpLocaltime(const time_t *clock)
+}
+declare 183 {deprecated {}}  {
+     struct tm *TclpGmtime(const time_t *clock)
+}
 
 # For the new "Thread Storage" subsystem.
 
 ### REMOVED on grounds it should never have been exposed. All these
 ### functions are now either static in tclThreadStorage.c or
@@ -885,11 +858,11 @@
 }
 declare 214 {
     void TclSetObjNameOfExecutable(Tcl_Obj *name, Tcl_Encoding encoding)
 }
 declare 215 {
-    void *TclStackAlloc(Tcl_Interp *interp, size_t numBytes)
+    void *TclStackAlloc(Tcl_Interp *interp, int numBytes)
 }
 declare 216 {
     void TclStackFree(Tcl_Interp *interp, void *freePtr)
 }
 declare 217 {
@@ -912,11 +885,11 @@
 }
 declare 226 {
     int TclObjBeingDeleted(Tcl_Obj *objPtr)
 }
 declare 227 {
-    void TclSetNsPath(Namespace *nsPtr, size_t pathLength,
+    void TclSetNsPath(Namespace *nsPtr, int pathLength,
             Tcl_Namespace *pathAry[])
 }
 #  Used to be needed for TclOO-extension; unneeded now that TclOO is in the
 #  core and NRE-enabled
 #  declare 228 {
@@ -952,26 +925,23 @@
              int *newPtr)
 }
 declare 235 {
     void TclInitVarHashTable(TclVarHashTable *tablePtr, Namespace *nsPtr)
 }
-
-
-# TIP 337 made this one public
-#declare 236 {
-#    void TclBackgroundException(Tcl_Interp *interp, int code)
-#}
+declare 236 {deprecated {use Tcl_BackgroundException}} {
+    void TclBackgroundException(Tcl_Interp *interp, int code)
+}
 
 # TIP #285: Script cancellation support.
 declare 237 {
     int TclResetCancellation(Tcl_Interp *interp, int force)
 }
 
 # NRE functions for "rogue" extensions to exploit NRE; they will need to
 # include NRE.h too.
 declare 238 {
-    int TclNRInterpProc(void *clientData, Tcl_Interp *interp,
+    int TclNRInterpProc(ClientData clientData, Tcl_Interp *interp,
 	    int objc, Tcl_Obj *const objv[])
 }
 declare 239 {
     int TclNRInterpProcCore(Tcl_Interp *interp, Tcl_Obj *procNameObj,
 			    int skip, ProcErrorProc *errorProc)
@@ -1000,12 +970,12 @@
 }
 declare 245 {
     Tcl_HashTable *TclGetNamespaceCommandTable(Tcl_Namespace *nsPtr)
 }
 declare 246 {
-    int TclInitRewriteEnsemble(Tcl_Interp *interp, size_t numRemoved,
-	    size_t numInserted, Tcl_Obj *const *objv)
+    int TclInitRewriteEnsemble(Tcl_Interp *interp, int numRemoved,
+	    int numInserted, Tcl_Obj *const *objv)
 }
 declare 247 {
     void TclResetRewriteEnsemble(Tcl_Interp *interp, int isRootEnsemble)
 }
 
@@ -1024,11 +994,11 @@
 }
 
 # Allow extensions for optimization
 declare 251 {
     int TclRegisterLiteral(void *envPtr,
-	    const char *bytes, size_t length, int flags)
+	    const char *bytes, int length, int flags)
 }
 
 # Exporting of the internal API to variables.
 
 declare 252 {
@@ -1076,24 +1046,21 @@
 # Windows specific functions
 
 declare 0 win {
     void TclWinConvertError(DWORD errCode)
 }
-# Removed in 9.0:
-#declare 1 win {
-#    void TclWinConvertWSAError(DWORD errCode)
-#}
-# Removed in 9.0:
-#declare 2 win {
-#    struct servent *TclWinGetServByName(const char *nm,
-#	    const char *proto)
-#}
-# Removed in 9.0:
-#declare 3 win {
-#    int TclWinGetSockOpt(SOCKET s, int level, int optname,
-#	    char *optval, int *optlen)
-#}
+declare 1 win {
+    void TclWinConvertWSAError(DWORD errCode)
+}
+declare 2 win {
+    struct servent *TclWinGetServByName(const char *nm,
+	    const char *proto)
+}
+declare 3 win {
+    int TclWinGetSockOpt(SOCKET s, int level, int optname,
+	    char *optval, int *optlen)
+}
 declare 4 win {
     HINSTANCE TclWinGetTclInstance(void)
 }
 # new for 8.4.20+/8.5.12+ Cygwin only
 declare 5 win {
@@ -1101,30 +1068,27 @@
 }
 # Removed in 8.1:
 #  declare 5 win {
 #      HINSTANCE TclWinLoadLibrary(char *name)
 #  }
-# Removed in 9.0:
-#declare 6 win {
-#    unsigned short TclWinNToHS(unsigned short ns)
-#}
-# Removed in 9.0:
-#declare 7 win {
-#    int TclWinSetSockOpt(SOCKET s, int level, int optname,
-#	    const char *optval, int optlen)
-#}
+declare 6 win {
+    unsigned short TclWinNToHS(unsigned short ns)
+}
+declare 7 win {
+    int TclWinSetSockOpt(SOCKET s, int level, int optname,
+	    const char *optval, int optlen)
+}
 declare 8 win {
-    size_t TclpGetPid(Tcl_Pid pid)
-}
-# Removed in 9.0:
-#declare 9 win {
-#    int TclWinGetPlatformId(void)
-#}
-# Removed in 9.0:
-#declare 10 win {
-#    Tcl_DirEntry *TclpReaddir(TclDIR *dir)
-#}
+    int TclpGetPid(Tcl_Pid pid)
+}
+declare 9 win {
+    int TclWinGetPlatformId(void)
+}
+# new for 8.4.20+/8.5.12+ Cygwin only
+declare 10 win {
+    Tcl_DirEntry *TclpReaddir(TclDIR *dir)
+}
 # Removed in 8.3.1 (for Win32s only):
 #declare 10 win {
 #    int TclWinSynchSpawn(void *args, int type, void **trans, Tcl_Pid *pidPtr)
 #}
 
@@ -1169,16 +1133,15 @@
 }
 declare 19 win {
     TclFile TclpOpenFile(const char *fname, int mode)
 }
 declare 20 win {
-    void TclWinAddProcess(HANDLE hProcess, size_t id)
+    void TclWinAddProcess(HANDLE hProcess, DWORD id)
 }
-# Removed in 9.0:
-#declare 21 win {
-#    char *TclpInetNtoa(struct in_addr addr)
-#}
+declare 21 win {
+    char *TclpInetNtoa(struct in_addr addr)
+}
 # removed permanently for 8.4
 #declare 21 win {
 #    void TclpAsyncMark(Tcl_AsyncHandler async)
 #}
 
@@ -1195,27 +1158,25 @@
 }
 # replaced by generic TclGetPlatform
 #declare 25 win {
 #    TclPlatformType *TclWinGetPlatform(void)
 #}
-# Removed in 9.0:
-#declare 26 win {
-#    void TclWinSetInterfaces(int wide)
-#}
+declare 26 win {
+    void TclWinSetInterfaces(int wide)
+}
 
 # Added in Tcl 8.3.3 / 8.4
 
 declare 27 win {
     void TclWinFlushDirtyChannels(void)
 }
 
 # Added in 8.4.2
 
-# Removed in 9.0:
-#declare 28 win {
-#    void TclWinResetInterfaces(void)
-#}
+declare 28 win {
+    void TclWinResetInterfaces(void)
+}
 
 ################################
 # Unix specific functions
 
 # Pipe channel functions
@@ -1258,26 +1219,24 @@
     TclFile TclpCreateTempFile(const char *contents)
 }
 
 # Added in 8.4:
 
-# Removed in 9.0:
-#declare 10 unix {
-#    Tcl_DirEntry *TclpReaddir(TclDIR *dir)
-#}
-# Removed in 9.0:
-#declare 11 unix {
-#    struct tm *TclpLocaltime_unix(const time_t *clock)
-#}
-# Removed in 9.0:
-#declare 12 unix {
-#    struct tm *TclpGmtime_unix(const time_t *clock)
-#}
-# Removed in 9.0:
-#declare 13 unix {
-#    char *TclpInetNtoa(struct in_addr addr)
-#}
+declare 10 unix {
+    Tcl_DirEntry *TclpReaddir(TclDIR *dir)
+}
+# Slots 11 and 12 are forwarders for functions that were promoted to
+# generic Stubs
+declare 11 unix {
+    struct tm *TclpLocaltime_unix(const time_t *clock)
+}
+declare 12 unix {
+    struct tm *TclpGmtime_unix(const time_t *clock)
+}
+declare 13 unix {
+    char *TclpInetNtoa(struct in_addr addr)
+}
 
 # Added in 8.5:
 
 declare 14 unix {
     int TclUnixCopyFile(const char *src, const char *dst,

Index: generic/tclInt.h
==================================================================
--- generic/tclInt.h
+++ generic/tclInt.h
@@ -22,10 +22,24 @@
 /*
  * Some numerics configuration options.
  */
 
 #undef ACCEPT_NAN
+
+/*
+ * In Tcl 8.7, stop supporting special hacks for legacy Itcl 3.
+ * Itcl 4 doesn't need them. Itcl 3 can be updated to not need them
+ * using the Tcl(Init|Reset)RewriteEnsemble() routines in all Tcl 8.6+
+ * releases.  Perhaps Tcl 8.7 will add even better public interfaces
+ * supporting all the re-invocation mechanisms extensions like Itcl 3
+ * need.  As an absolute last resort, folks who must make Itcl 3 work
+ * unchanged with Tcl 8.7 can remove this line to regain the migration
+ * support.  Tcl 9 will no longer offer even that option.
+ */
+
+#define AVOID_HACKS_FOR_ITCL 1
+
 
 /*
  * Used to tag functions that are only to be visible within the module being
  * built and not outside it (where this is supported by the linker).
  * Also used in the platform-specific *Port.h files.
@@ -36,10 +50,12 @@
 #	define MODULE_SCOPE extern "C"
 #   else
 #	define MODULE_SCOPE extern
 #   endif
 #endif
+
+
 
 /*
  * Common include files needed by most of the Tcl source files are included
  * here, so that system-dependent personalizations for the include files only
  * have to be made in once place. This results in a few extra includes, but
@@ -50,11 +66,10 @@
 #include "tclPort.h"
 
 #include <stdio.h>
 
 #include <ctype.h>
-#include <stdarg.h>
 #ifdef NO_STDLIB_H
 #   include "../compat/stdlib.h"
 #else
 #   include <stdlib.h>
 #endif
@@ -61,16 +76,16 @@
 #ifdef NO_STRING_H
 #include "../compat/string.h"
 #else
 #include <string.h>
 #endif
-#if defined(STDC_HEADERS) || defined(__STDC__) || defined(__C99__FUNC__) \
-     || defined(__cplusplus) || defined(_MSC_VER) || defined(__ICC)
-#include <stddef.h>
-#else
+#if !defined(STDC_HEADERS) && !defined(__STDC__) && !defined(__C99__FUNC__) \
+     && !defined(__cplusplus) && !defined(_MSC_VER) && !defined(__ICC)
 typedef int ptrdiff_t;
 #endif
+#include <stddef.h>
+#include <locale.h>
 
 /*
  * Ensure WORDS_BIGENDIAN is defined correctly:
  * Needs to happen here in addition to configure to work with fat compiles on
  * Darwin (where configure runs only once for multiple architectures).
@@ -197,10 +212,13 @@
  * lookup is performed for upvar (or similar) purposes, with slightly
  * different rules:
  *    - Bug #696893 - variable is either proc-local or in the current
  *	namespace; never follow the second (global) resolution path
  *    - Bug #631741 - do not use special namespace or interp resolvers
+ *
+ * It should also not collide with the (deprecated) TCL_PARSE_PART1 flag
+ * (Bug #835020)
  */
 
 #define TCL_AVOID_RESOLVERS 0x40000
 
 /*
@@ -269,20 +287,20 @@
     Tcl_HashTable *childTablePtr;
 				/* Contains any child namespaces. Indexed by
 				 * strings; values have type (Namespace *). If
 				 * NULL, there are no children. */
 #endif
-    size_t nsId;		/* Unique id for the namespace. */
-    Tcl_Interp *interp;	/* The interpreter containing this
+    unsigned long nsId;		/* Unique id for the namespace. */
+    Tcl_Interp *interp;		/* The interpreter containing this
 				 * namespace. */
     int flags;			/* OR-ed combination of the namespace status
 				 * flags NS_DYING and NS_DEAD listed below. */
-    size_t activationCount;	/* Number of "activations" or active call
+    int activationCount;	/* Number of "activations" or active call
 				 * frames for this namespace that are on the
 				 * Tcl call stack. The namespace won't be
 				 * freed until activationCount becomes zero. */
-    size_t refCount;		/* Count of references by namespaceName
+    unsigned int refCount;	/* Count of references by namespaceName
 				 * objects. The namespace can't be freed until
 				 * refCount becomes zero. */
     Tcl_HashTable cmdTable;	/* Contains all the commands currently
 				 * registered in the namespace. Indexed by
 				 * strings; values have type (Command *).
@@ -299,20 +317,20 @@
 				 * pattern may include "string match" style
 				 * wildcard characters to specify multiple
 				 * commands; however, no namespace qualifiers
 				 * are allowed. NULL if no export patterns are
 				 * registered. */
-    size_t numExportPatterns;	/* Number of export patterns currently
+    int numExportPatterns;	/* Number of export patterns currently
 				 * registered using "namespace export". */
-    size_t maxExportPatterns;	/* Number of export patterns for which space
+    int maxExportPatterns;	/* Mumber of export patterns for which space
 				 * is currently allocated. */
-    size_t cmdRefEpoch;		/* Incremented if a newly added command
+    unsigned int cmdRefEpoch;	/* Incremented if a newly added command
 				 * shadows a command for which this namespace
 				 * has already cached a Command* pointer; this
 				 * causes all its cached Command* pointers to
 				 * be invalidated. */
-    size_t resolverEpoch;	/* Incremented whenever (a) the name
+    unsigned int resolverEpoch;	/* Incremented whenever (a) the name
 				 * resolution rules change for this namespace
 				 * or (b) a newly added command shadows a
 				 * command that is compiled to bytecodes. This
 				 * invalidates all byte codes compiled in the
 				 * namespace, causing the code to be
@@ -335,11 +353,11 @@
 				 * usual variable resolution mechanism in Tcl.
 				 * This procedure is invoked within
 				 * LookupCompiledLocal to resolve variable
 				 * references within the namespace at compile
 				 * time. */
-    size_t exportLookupEpoch;	/* Incremented whenever a command is added to
+    unsigned int exportLookupEpoch;	/* Incremented whenever a command is added to
 				 * a namespace, removed from a namespace or
 				 * the exports of a namespace are changed.
 				 * Allows TIP#112-driven command lists to be
 				 * validated efficiently. */
     Tcl_Ensemble *ensembles;	/* List of structures that contain the details
@@ -346,11 +364,11 @@
 				 * of the ensembles that are implemented on
 				 * top of this namespace. */
     Tcl_Obj *unknownHandlerPtr;	/* A script fragment to be used when command
 				 * resolution in this namespace fails. TIP
 				 * 181. */
-    size_t commandPathLength;	/* The length of the explicit path. */
+    int commandPathLength;	/* The length of the explicit path. */
     NamespacePathEntry *commandPathArray;
 				/* The explicit path of the namespace as an
 				 * array. */
     NamespacePathEntry *commandPathSourceList;
 				/* Linked list of path entries that point to
@@ -436,11 +454,11 @@
     Tcl_Command token;		/* The token for the command that provides
 				 * ensemble support for the namespace, or NULL
 				 * if the command has been deleted (or never
 				 * existed; the global namespace never has an
 				 * ensemble command.) */
-    size_t epoch;		/* The epoch at which this ensemble's table of
+    unsigned int epoch;		/* The epoch at which this ensemble's table of
 				 * exported commands is valid. */
     char **subcommandArrayPtr;	/* Array of ensemble subcommand names. At all
 				 * consistent points, this will have the same
 				 * number of entries as there are entries in
 				 * the subcommandTable hash. */
@@ -549,11 +567,11 @@
 				 * interested in: OR-ed combination of
 				 * TCL_TRACE_RENAME, TCL_TRACE_DELETE. */
     struct CommandTrace *nextPtr;
 				/* Next in list of traces associated with a
 				 * particular command. */
-    size_t refCount;	/* Used to ensure this structure is not
+    unsigned int refCount; /* Used to ensure this structure is not
 				 * deleted too early. Keeps track of how many
 				 * pieces of code have a pointer to this
 				 * structure. */
 } CommandTrace;
 
@@ -612,21 +630,21 @@
 	Tcl_Obj *objPtr;	/* The variable's object value. Used for
 				 * scalar variables and array elements. */
 	TclVarHashTable *tablePtr;/* For array variables, this points to
 				 * information about the hash table used to
 				 * implement the associative array. Points to
-				 * Tcl_Alloc-ed data. */
+				 * ckalloc-ed data. */
 	struct Var *linkPtr;	/* If this is a global variable being referred
 				 * to in a procedure, or a variable created by
 				 * "upvar", this field points to the
 				 * referenced variable's Var struct. */
     } value;
 } Var;
 
 typedef struct VarInHash {
     Var var;
-    size_t refCount;		/* Counts number of active uses of this
+    unsigned int refCount;	/* Counts number of active uses of this
 				 * variable: 1 for the entry in the hash
 				 * table, 1 for each additional variable whose
 				 * linkPtr points here, 1 for each nested
 				 * trace active on variable, and 1 if the
 				 * variable is a namespace variable. This
@@ -919,11 +937,11 @@
 typedef struct CompiledLocal {
     struct CompiledLocal *nextPtr;
 				/* Next compiler-recognized local variable for
 				 * this procedure, or NULL if this is the last
 				 * local. */
-    size_t nameLength;		/* The number of bytes in local variable's name.
+    int nameLength;		/* The number of bytes in local variable's name.
 				 * Among others used to speed up var lookups. */
     int frameIndex;		/* Index in the array of compiler-assigned
 				 * variables in the procedure call frame. */
     int flags;			/* Flag bits for the local variable. Same as
 				 * the flags for the Var structure above,
@@ -953,11 +971,11 @@
  */
 
 typedef struct Proc {
     struct Interp *iPtr;	/* Interpreter for which this command is
 				 * defined. */
-    size_t refCount;		/* Reference count: 1 if still present in
+    unsigned int refCount;	/* Reference count: 1 if still present in
 				 * command table plus 1 for each call to the
 				 * procedure that is currently active. This
 				 * structure can be freed when refCount
 				 * becomes zero. */
     struct Command *cmdPtr;	/* Points to the Command structure for this
@@ -1070,11 +1088,11 @@
  * Will be grown to contain: pointers to the varnames (allocated at the end),
  * plus the init values for each variable (suitable to be memcopied on init)
  */
 
 typedef struct LocalCache {
-    size_t refCount;
+    unsigned int refCount;
     int numVars;
     Tcl_Obj *varName0;
 } LocalCache;
 
 #define localName(framePtr, i) \
@@ -1225,11 +1243,11 @@
 	    const char *pc;	/* ... and instruction pointer. */
 	} tebc;
     } data;
     Tcl_Obj *cmdObj;
     const char *cmd;		/* The executed command, if possible... */
-    size_t len;			/* ... and its length. */
+    int len;			/* ... and its length. */
     const struct CFWordBC *litarg;
 				/* Link to set of literal arguments which have
 				 * ben pushed on the lineLABCPtr stack by
 				 * TclArgumentBCEnter(). These will be removed
 				 * by TclArgumentBCRelease. */
@@ -1236,17 +1254,17 @@
 } CmdFrame;
 
 typedef struct CFWord {
     CmdFrame *framePtr;		/* CmdFrame to access. */
     int word;			/* Index of the word in the command. */
-    size_t refCount;		/* Number of times the word is on the
+    unsigned int refCount;	/* Number of times the word is on the
 				 * stack. */
 } CFWord;
 
 typedef struct CFWordBC {
     CmdFrame *framePtr;		/* CmdFrame to access. */
-    size_t pc;			/* Instruction pointer of a command in
+    int pc;			/* Instruction pointer of a command in
 				 * ExtCmdLoc.loc[.] */
     int word;			/* Index of word in
 				 * ExtCmdLoc.loc[cmd]->line[.] */
     struct CFWordBC *prevPtr;	/* Previous entry in stack for same Tcl_Obj. */
     struct CFWordBC *nextPtr;	/* Next entry for same command call. See
@@ -1323,11 +1341,11 @@
 				 * directly (after casting) if NULL. */
     void *clientData;	/* Context for above function, or Tcl_Obj* if
 				 * proc field is NULL. */
 } ExtraFrameInfoField;
 typedef struct {
-    size_t length;			/* Length of array. */
+    int length;			/* Length of array. */
     ExtraFrameInfoField fields[2];
 				/* Really as long as necessary, but this is
 				 * long enough for nearly anything. */
 } ExtraFrameInfo;
 
@@ -1364,11 +1382,11 @@
 /*
  * This is a convenience macro used to initialize a thread local storage ptr.
  */
 
 #define TCL_TSD_INIT(keyPtr) \
-	Tcl_GetThreadData((keyPtr), sizeof(ThreadSpecificData))
+	(ThreadSpecificData *)Tcl_GetThreadData((keyPtr), sizeof(ThreadSpecificData))
 
 /*
  *----------------------------------------------------------------
  * Data structures related to bytecode compilation and execution. These are
  * used primarily in tclCompile.c, tclExecute.c, and tclBasic.c.
@@ -1412,11 +1430,11 @@
  * The type of procedure called from the compilation hook point in
  * SetByteCodeFromAny.
  */
 
 typedef int (CompileHookProc)(Tcl_Interp *interp,
-	struct CompileEnv *compEnvPtr, void *clientData);
+	struct CompileEnv *compEnvPtr, ClientData clientData);
 
 /*
  * The data structure for a (linked list of) execution stacks.
  */
 
@@ -1499,15 +1517,15 @@
     struct LiteralEntry *nextPtr;
 				/* Points to next entry in this hash bucket or
 				 * NULL if end of chain. */
     Tcl_Obj *objPtr;		/* Points to Tcl object that holds the
 				 * literal's bytes and length. */
-    size_t refCount;		/* If in an interpreter's global literal
+    unsigned int refCount; /* If in an interpreter's global literal
 				 * table, the number of ByteCode structures
 				 * that share the literal object; the literal
 				 * entry can be freed when refCount drops to
-				 * 0. If in a local literal table, TCL_AUTO_LENGTH. */
+				 * 0. If in a local literal table, (unsigned)-1. */
     Namespace *nsPtr;		/* Namespace in which this literal is used. We
 				 * try to avoid sharing literal non-FQ command
 				 * names among different namespaces to reduce
 				 * shimmering. */
 } LiteralEntry;
@@ -1517,17 +1535,17 @@
 				 * points to first entry in bucket's hash
 				 * chain, or NULL. */
     LiteralEntry *staticBuckets[TCL_SMALL_HASH_TABLE];
 				/* Bucket array used for small tables to avoid
 				 * mallocs and frees. */
-    size_t numBuckets;		/* Total number of buckets allocated at
+    unsigned int numBuckets; /* Total number of buckets allocated at
 				 * **buckets. */
-    size_t numEntries;		/* Total number of entries present in
+    unsigned int numEntries; /* Total number of entries present in
 				 * table. */
-    size_t rebuildSize;		/* Enlarge table when numEntries gets to be
+    unsigned int rebuildSize; /* Enlarge table when numEntries gets to be
 				 * this large. */
-    size_t mask;		/* Mask value used in hashing function. */
+    unsigned int mask;		/* Mask value used in hashing function. */
 } LiteralTable;
 
 /*
  * The following structure defines for each Tcl interpreter various
  * statistics-related information about the bytecode compiler and
@@ -1641,16 +1659,16 @@
 				 * already (this can happen if deleteProc
 				 * causes the command to be deleted or
 				 * recreated). */
     Namespace *nsPtr;		/* Points to the namespace containing this
 				 * command. */
-    size_t refCount;		/* 1 if in command hashtable plus 1 for each
+    unsigned int refCount;	/* 1 if in command hashtable plus 1 for each
 				 * reference from a CmdName Tcl object
 				 * representing a command's name in a ByteCode
 				 * instruction sequence. This structure can be
 				 * freed when refCount becomes zero. */
-    size_t cmdEpoch;		/* Incremented to invalidate any references
+    unsigned int cmdEpoch;	/* Incremented to invalidate any references
 				 * that point to this command when it is
 				 * renamed, deleted, hidden, or exposed. */
     CompileProc *compileProc;	/* Procedure called to compile command. NULL
 				 * if no compile proc exists for command. */
     Tcl_ObjCmdProc *objProc;	/* Object-based command procedure. */
@@ -1766,11 +1784,11 @@
 
 typedef struct AllocCache {
     struct Cache *nextPtr;	/* Linked list of cache entries. */
     Tcl_ThreadId owner;		/* Which thread's cache is this? */
     Tcl_Obj *firstObjPtr;	/* List of free objects for thread. */
-    size_t numObjects;		/* Number of objects for thread. */
+    int numObjects;		/* Number of objects for thread. */
 } AllocCache;
 
 /*
  *----------------------------------------------------------------
  * This structure defines an interpreter, which is a collection of commands
@@ -1780,35 +1798,45 @@
  *----------------------------------------------------------------
  */
 
 typedef struct Interp {
     /*
-     * The first two fields were named "result" and "freeProc" in earlier
-     * versions of Tcl.  They are no longer used within Tcl, and are no
-     * longer available to be accessed by extensions.  However, they cannot
-     * be removed.  Why?  There is a deployed base of stub-enabled extensions
-     * that query the value of iPtr->stubTable.  For them to continue to work,
-     * the location of the field "stubTable" within the Interp struct cannot
-     * change.  The most robust way to assure that is to leave all fields up to
-     * that one undisturbed.
+     * Note: the first three fields must match exactly the fields in a
+     * Tcl_Interp struct (see tcl.h). If you change one, be sure to change the
+     * other.
+     *
+     * The interpreter's result is held in both the string and the
+     * objResultPtr fields. These fields hold, respectively, the result's
+     * string or object value. The interpreter's result is always in the
+     * result field if that is non-empty, otherwise it is in objResultPtr.
+     * The two fields are kept consistent unless some C code sets
+     * interp->result directly. Programs should not access result and
+     * objResultPtr directly; instead, they should always get and set the
+     * result using procedures such as Tcl_SetObjResult, Tcl_GetObjResult, and
+     * Tcl_GetStringResult. See the SetResult man page for details.
      */
 
-    const char *legacyResult;
-    void (*legacyFreeProc) (void);
+    char *result;		/* If the last command returned a string
+				 * result, this points to it. Should not be
+				 * accessed directly; see comment above. */
+    Tcl_FreeProc *freeProc;	/* Zero means a string result is statically
+				 * allocated. TCL_DYNAMIC means string result
+				 * was allocated with ckalloc and should be
+				 * freed with ckfree. Other values give
+				 * address of procedure to invoke to free the
+				 * string result. Tcl_Eval must free it before
+				 * executing next command. */
     int errorLine;		/* When TCL_ERROR is returned, this gives the
 				 * line number in the command where the error
 				 * occurred (1 means first line). */
     const struct TclStubs *stubTable;
-				/* Pointer to the exported Tcl stub table.  In
-				 * ancient pre-8.1 versions of Tcl this was a
-				 * pointer to the objResultPtr or a pointer to a
-				 * buckets array in a hash table. Deployed stubs
-				 * enabled extensions check for a NULL pointer value
-				 * and for a TCL_STUBS_MAGIC value to verify they
-				 * are not [load]ing into one of those pre-stubs
-				 * interps.
-				 */
+				/* Pointer to the exported Tcl stub table. On
+				 * previous versions of Tcl this is a pointer
+				 * to the objResultPtr or a pointer to a
+				 * buckets array in a hash table. We therefore
+				 * have to do some careful checking before we
+				 * can use this. */
 
     TclHandle handle;		/* Handle used to keep track of when this
 				 * interp is deleted. */
 
     Namespace *globalNsPtr;	/* The interpreter's global namespace. */
@@ -1817,11 +1845,19 @@
 				 * of hidden commands on a per-interp
 				 * basis. */
     void *interpInfo;	/* Information used by tclInterp.c to keep
 				 * track of master/slave interps on a
 				 * per-interp basis. */
-    void (*optimizer)(void *envPtr);
+    union {
+	void (*optimizer)(void *envPtr);
+	Tcl_HashTable unused2;	/* No longer used (was mathFuncTable). The
+				 * unused space in interp was repurposed for
+				 * pluggable bytecode optimizers. The core
+				 * contains one optimizer, which can be
+				 * selectively overridden by extensions. */
+    } extra;
+
     /*
      * Information related to procedures and variables. See tclProc.c and
      * tclVar.c for usage.
      */
 
@@ -1846,10 +1882,29 @@
     CallFrame *rootFramePtr;	/* Global frame pointer for this
 				 * interpreter. */
     Namespace *lookupNsPtr;	/* Namespace to use ONLY on the next
 				 * TCL_EVAL_INVOKE call to Tcl_EvalObjv. */
 
+    /*
+     * Information used by Tcl_AppendResult to keep track of partial results.
+     * See Tcl_AppendResult code for details.
+     */
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+    char *appendResult;		/* Storage space for results generated by
+				 * Tcl_AppendResult. Ckalloc-ed. NULL means
+				 * not yet allocated. */
+    int appendAvl;		/* Total amount of space available at
+				 * partialResult. */
+    int appendUsed;		/* Number of non-null bytes currently stored
+				 * at partialResult. */
+#else
+    char *appendResultDontUse;
+    int appendAvlDontUse;
+    int appendUsedDontUse;
+#endif
+
     /*
      * Information about packages. Used only in tclPkg.c.
      */
 
     Tcl_HashTable packageTable;	/* Describes all of the packages loaded in or
@@ -1862,22 +1917,23 @@
 				 * NULL. */
     /*
      * Miscellaneous information:
      */
 
-    size_t cmdCount;		/* Total number of times a command procedure
+    int cmdCount;		/* Total number of times a command procedure
 				 * has been called for this interpreter. */
     int evalFlags;		/* Flags to control next call to Tcl_Eval.
 				 * Normally zero, but may be set before
 				 * calling Tcl_Eval. See below for valid
 				 * values. */
+    int unused1;		/* No longer used (was termOffset) */
     LiteralTable literalTable;	/* Contains LiteralEntry's describing all Tcl
 				 * objects holding literals of scripts
 				 * compiled by the interpreter. Indexed by the
 				 * string representations of literals. Used to
 				 * avoid creating duplicate objects. */
-    size_t compileEpoch;	/* Holds the current "compilation epoch" for
+    unsigned int compileEpoch;	/* Holds the current "compilation epoch" for
 				 * this interpreter. This is incremented to
 				 * invalidate existing ByteCodes when, e.g., a
 				 * command with a compile procedure is
 				 * redefined. */
     Proc *compiledProcPtr;	/* If a procedure is being compiled, a pointer
@@ -1905,10 +1961,18 @@
 				 * evaluation stack. */
     Tcl_Obj *emptyObjPtr;	/* Points to an object holding an empty
 				 * string. Returned by Tcl_ObjSetVar2 when
 				 * variable traces change a variable in a
 				 * gross way. */
+#if TCL_MAJOR_VERSION < 9
+# if !defined(TCL_NO_DEPRECATED)
+    char resultSpace[TCL_DSTRING_STATIC_SIZE+1];
+				/* Static space holding small results. */
+# else
+    char resultSpaceDontUse[TCL_DSTRING_STATIC_SIZE+1];
+# endif
+#endif
     Tcl_Obj *objResultPtr;	/* If the last command returned an object
 				 * result, this points to it. Should not be
 				 * accessed directly; see comment above. */
     Tcl_ThreadId threadId;	/* ID of thread that owns the interpreter. */
 
@@ -1947,11 +2011,11 @@
 				 * check the limits. */
 	int exceeded;		/* Which limits have been exceeded, described
 				 * as flag values the same as the 'active'
 				 * field. */
 
-	size_t cmdCount;		/* Limit for how many commands to execute in
+	int cmdCount;		/* Limit for how many commands to execute in
 				 * the interpreter. */
 	LimitHandler *cmdHandlers;
 				/* Handlers to execute when the limit is
 				 * reached. */
 	int cmdGranularity;	/* Mod factor used to determine how often to
@@ -1983,13 +2047,13 @@
 	Tcl_Obj *const *sourceObjs;
 				/* What arguments were actually input into the
 				 * *root* ensemble command? (Nested ensembles
 				 * don't rewrite this.) NULL if we're not
 				 * processing an ensemble. */
-	size_t numRemovedObjs;	/* How many arguments have been stripped off
+	int numRemovedObjs;	/* How many arguments have been stripped off
 				 * because of ensemble processing. */
-	size_t numInsertedObjs;	/* How many of the current arguments were
+	int numInsertedObjs;	/* How many of the current arguments were
 				 * inserted by an ensemble. */
     } ensembleRewrite;
 
     /*
      * TIP #219: Global info for the I/O system.
@@ -2193,10 +2257,11 @@
 
 #define TCL_ALLOW_EXCEPTIONS		0x04
 #define TCL_EVAL_FILE			0x02
 #define TCL_EVAL_SOURCE_IN_FRAME	0x10
 #define TCL_EVAL_NORESOLVE		0x20
+#define TCL_EVAL_DISCARD_RESULT		0x40
 
 /*
  * Flag bits for Interp structures:
  *
  * DELETED:		Non-zero means the interpreter has been deleted:
@@ -2301,11 +2366,11 @@
 /*
  * A common panic alert when memory allocation fails.
  */
 
 #define TclOOM(ptr, size) \
-	((size) && ((ptr)||(Tcl_Panic("unable to alloc %" TCL_Z_MODIFIER "u bytes", (size_t)(size)),1)))
+	((size) && ((ptr)||(Tcl_Panic("unable to alloc %u bytes", (size)),1)))
 
 /*
  * The following enum values are used to specify the runtime platform setting
  * of the tclPlatform variable.
  */
@@ -2354,11 +2419,11 @@
  * used to hold all element pointers. This is done to make append operations
  * faster.
  */
 
 typedef struct List {
-    size_t refCount;
+    unsigned int refCount;
     int maxElemCount;		/* Total number of element array slots. */
     int elemCount;		/* Current number of list elements. */
     int canonicalFlag;		/* Set if the string representation was
 				 * derived from the list representation. May
 				 * be ignored if there is no string rep at
@@ -2368,11 +2433,11 @@
 } List;
 
 #define LIST_MAX \
 	(1 + (int)(((size_t)UINT_MAX - sizeof(List))/sizeof(Tcl_Obj *)))
 #define LIST_SIZE(numElems) \
-	(sizeof(List) + (((numElems) - 1) * sizeof(Tcl_Obj *)))
+	(unsigned)(sizeof(List) + (((numElems) - 1) * sizeof(Tcl_Obj *)))
 
 /*
  * Macro used to get the elements of a list object.
  */
 
@@ -2417,13 +2482,14 @@
  *
  * WARNING: these macros eval their args more than once.
  */
 
 #define TclGetBooleanFromObj(interp, objPtr, boolPtr) \
-    (((objPtr)->typePtr == &tclIntType \
-	    || (objPtr)->typePtr == &tclBooleanType) \
+    (((objPtr)->typePtr == &tclIntType)			\
 	? (*(boolPtr) = ((objPtr)->internalRep.wideValue!=0), TCL_OK)	\
+	: ((objPtr)->typePtr == &tclBooleanType)			\
+	? (*(boolPtr) = ((objPtr)->internalRep.longValue!=0), TCL_OK)	\
 	: Tcl_GetBooleanFromObj((interp), (objPtr), (boolPtr)))
 
 #ifdef TCL_WIDE_INT_IS_LONG
 #define TclGetLongFromObj(interp, objPtr, longPtr) \
     (((objPtr)->typePtr == &tclIntType)	\
@@ -2446,11 +2512,11 @@
 	    : Tcl_GetIntFromObj((interp), (objPtr), (intPtr)))
 #define TclGetIntForIndexM(interp, objPtr, endValue, idxPtr) \
     (((objPtr)->typePtr == &tclIntType \
 	    && (objPtr)->internalRep.wideValue <= (Tcl_WideInt)(INT_MAX)) \
 	    ? ((*(idxPtr) = ((objPtr)->internalRep.wideValue >= 0) \
-	    ? (size_t)(objPtr)->internalRep.wideValue : TCL_INDEX_NONE), TCL_OK) \
+	    ? (int)(objPtr)->internalRep.wideValue : TCL_INDEX_NONE), TCL_OK) \
 	    : Tcl_GetIntForIndex((interp), (objPtr), (endValue), (idxPtr)))
 
 /*
  * Macro used to save a function call for common uses of
  * Tcl_GetWideIntFromObj(). The ANSI C "prototype" is:
@@ -2504,11 +2570,11 @@
  * more efficiency in 'path' manipulation and usage, and cleaner filesystem
  * code internally.
  */
 
 #define TCL_FILESYSTEM_VERSION_2	((Tcl_FSVersion) 0x2)
-typedef void *(TclFSGetCwdProc2)(void *clientData);
+typedef ClientData (TclFSGetCwdProc2)(ClientData clientData);
 typedef int (Tcl_FSLoadFileProc2) (Tcl_Interp *interp, Tcl_Obj *pathPtr,
 	Tcl_LoadHandle *handlePtr, Tcl_FSUnloadFileProc **unloadProcPtr, int flags);
 
 /*
  * The following types are used for getting and storing platform-specific file
@@ -2585,11 +2651,11 @@
  *----------------------------------------------------------------
  * Data structures for process-global values.
  *----------------------------------------------------------------
  */
 
-typedef void (TclInitProcessGlobalValueProc)(char **valuePtr, size_t *lengthPtr,
+typedef void (TclInitProcessGlobalValueProc)(char **valuePtr, unsigned int *lengthPtr,
 	Tcl_Encoding *encodingPtr);
 
 /*
  * A ProcessGlobalValue struct exists for each internal value in Tcl that is
  * to be shared among several threads. Each thread sees a (Tcl_Obj) copy of
@@ -2597,13 +2663,13 @@
  * control. Each ProcessGlobalValue struct should be a static variable in some
  * file.
  */
 
 typedef struct ProcessGlobalValue {
-    size_t epoch;		/* Epoch counter to detect changes in the
+    unsigned int epoch;		/* Epoch counter to detect changes in the
 				 * master value. */
-    size_t numBytes;		/* Length of the master string. */
+    unsigned int numBytes;	/* Length of the master string. */
     char *value;		/* The master string value. */
     Tcl_Encoding encoding;	/* system encoding when master string was
 				 * initialized. */
     TclInitProcessGlobalValueProc *proc;
     				/* A procedure to initialize the master string
@@ -2643,10 +2709,14 @@
  * Type values TclGetNumberFromObj
  *----------------------------------------------------------------------
  */
 
 #define TCL_NUMBER_INT		2
+#if (TCL_MAJOR_VERSION < 9) && !defined(TCL_NO_DEPRECATED)
+#   define TCL_NUMBER_LONG		1 /* deprecated, not used any more */
+#   define TCL_NUMBER_WIDE		TCL_NUMBER_INT /* deprecated */
+#endif
 #define TCL_NUMBER_BIG		3
 #define TCL_NUMBER_DOUBLE	4
 #define TCL_NUMBER_NAN		5
 
 /*
@@ -2668,11 +2738,11 @@
  * Data for the time hooks, if any.
  */
 
 MODULE_SCOPE Tcl_GetTimeProc *tclGetTimeProcPtr;
 MODULE_SCOPE Tcl_ScaleTimeProc *tclScaleTimeProcPtr;
-MODULE_SCOPE void *tclTimeClientData;
+MODULE_SCOPE ClientData tclTimeClientData;
 
 /*
  * Variables denoting the Tcl object types defined in the core.
  */
 
@@ -2828,11 +2898,11 @@
  * Procedures shared among Tcl modules but not used by the outside world:
  *----------------------------------------------------------------
  */
 
 MODULE_SCOPE void	TclAppendBytesToByteArray(Tcl_Obj *objPtr,
-			    const unsigned char *bytes, size_t len);
+			    const unsigned char *bytes, int len);
 MODULE_SCOPE int	TclNREvalCmd(Tcl_Interp *interp, Tcl_Obj *objPtr,
 			    int flags);
 MODULE_SCOPE void	TclAdvanceContinuations(int *line, int **next,
 			    int loc);
 MODULE_SCOPE void	TclAdvanceLines(int *line, const char *start,
@@ -2841,24 +2911,26 @@
 			    Tcl_Obj *objv[], int objc, CmdFrame *cf);
 MODULE_SCOPE void	TclArgumentRelease(Tcl_Interp *interp,
 			    Tcl_Obj *objv[], int objc);
 MODULE_SCOPE void	TclArgumentBCEnter(Tcl_Interp *interp,
 			    Tcl_Obj *objv[], int objc,
-			    void *codePtr, CmdFrame *cfPtr, int cmd, size_t pc);
+			    void *codePtr, CmdFrame *cfPtr, int cmd, int pc);
 MODULE_SCOPE void	TclArgumentBCRelease(Tcl_Interp *interp,
 			    CmdFrame *cfPtr);
 MODULE_SCOPE void	TclArgumentGet(Tcl_Interp *interp, Tcl_Obj *obj,
 			    CmdFrame **cfPtrPtr, int *wordPtr);
 MODULE_SCOPE double	TclBignumToDouble(const mp_int *bignum);
 MODULE_SCOPE int	TclByteArrayMatch(const unsigned char *string,
-			    size_t strLen, const unsigned char *pattern,
-			    size_t ptnLen, int flags);
+			    int strLen, const unsigned char *pattern,
+			    int ptnLen, int flags);
 MODULE_SCOPE double	TclCeil(const mp_int *a);
 MODULE_SCOPE void	TclChannelPreserve(Tcl_Channel chan);
 MODULE_SCOPE void	TclChannelRelease(Tcl_Channel chan);
 MODULE_SCOPE int	TclCheckArrayTraces(Tcl_Interp *interp, Var *varPtr,
 			    Var *arrayPtr, Tcl_Obj *name, int index);
+MODULE_SCOPE int	TclCheckBadOctal(Tcl_Interp *interp,
+			    const char *value);
 MODULE_SCOPE int	TclCheckEmptyString(Tcl_Obj *objPtr);
 MODULE_SCOPE int	TclChanCaughtErrorBypass(Tcl_Interp *interp,
 			    Tcl_Channel chan);
 MODULE_SCOPE Tcl_ObjCmdProc TclChannelNamesCmd;
 MODULE_SCOPE Tcl_NRPostProc TclClearRootEnsemble;
@@ -2869,27 +2941,27 @@
 MODULE_SCOPE void	TclContinuationsEnterDerived(Tcl_Obj *objPtr,
 			    int start, int *clNext);
 MODULE_SCOPE ContLineLoc *TclContinuationsGet(Tcl_Obj *objPtr);
 MODULE_SCOPE void	TclContinuationsCopy(Tcl_Obj *objPtr,
 			    Tcl_Obj *originObjPtr);
-MODULE_SCOPE size_t	TclConvertElement(const char *src, size_t length,
+MODULE_SCOPE int	TclConvertElement(const char *src, int length,
 			    char *dst, int flags);
 MODULE_SCOPE Tcl_Command TclCreateObjCommandInNs(Tcl_Interp *interp,
 			    const char *cmdName, Tcl_Namespace *nsPtr,
-			    Tcl_ObjCmdProc *proc, void *clientData,
+			    Tcl_ObjCmdProc *proc, ClientData clientData,
 			    Tcl_CmdDeleteProc *deleteProc);
 MODULE_SCOPE Tcl_Command TclCreateEnsembleInNs(Tcl_Interp *interp,
 			    const char *name, Tcl_Namespace *nameNamespacePtr,
 			    Tcl_Namespace *ensembleNamespacePtr, int flags);
 MODULE_SCOPE void	TclDeleteNamespaceVars(Namespace *nsPtr);
 MODULE_SCOPE int	TclFindDictElement(Tcl_Interp *interp,
 			    const char *dict, int dictLength,
 			    const char **elementPtr, const char **nextPtr,
-			    size_t *sizePtr, int *literalPtr);
+			    int *sizePtr, int *literalPtr);
 /* TIP #280 - Modified token based evaluation, with line information. */
 MODULE_SCOPE int	TclEvalEx(Tcl_Interp *interp, const char *script,
-			    size_t numBytes, int flags, int line,
+			    int numBytes, int flags, int line,
 			    int *clNextOuter, const char *outerScript);
 MODULE_SCOPE Tcl_ObjCmdProc TclFileAttrsCmd;
 MODULE_SCOPE Tcl_ObjCmdProc TclFileCopyCmd;
 MODULE_SCOPE Tcl_ObjCmdProc TclFileDeleteCmd;
 MODULE_SCOPE Tcl_ObjCmdProc TclFileLinkCmd;
@@ -2897,13 +2969,13 @@
 MODULE_SCOPE Tcl_ObjCmdProc TclFileReadLinkCmd;
 MODULE_SCOPE Tcl_ObjCmdProc TclFileRenameCmd;
 MODULE_SCOPE Tcl_ObjCmdProc TclFileTempDirCmd;
 MODULE_SCOPE Tcl_ObjCmdProc TclFileTemporaryCmd;
 MODULE_SCOPE void	TclCreateLateExitHandler(Tcl_ExitProc *proc,
-			    void *clientData);
+			    ClientData clientData);
 MODULE_SCOPE void	TclDeleteLateExitHandler(Tcl_ExitProc *proc,
-			    void *clientData);
+			    ClientData clientData);
 MODULE_SCOPE char *	TclDStringAppendObj(Tcl_DString *dsPtr,
 			    Tcl_Obj *objPtr);
 MODULE_SCOPE char *	TclDStringAppendDString(Tcl_DString *dsPtr,
 			    Tcl_DString *toAppendPtr);
 MODULE_SCOPE Tcl_Obj *	TclDStringToObj(Tcl_DString *dsPtr);
@@ -2938,11 +3010,11 @@
 MODULE_SCOPE int	TclFSFileAttrIndex(Tcl_Obj *pathPtr,
 			    const char *attributeName, int *indexPtr);
 MODULE_SCOPE Tcl_Command TclNRCreateCommandInNs(Tcl_Interp *interp,
 			    const char *cmdName, Tcl_Namespace *nsPtr,
 			    Tcl_ObjCmdProc *proc, Tcl_ObjCmdProc *nreProc,
-			    void *clientData,
+			    ClientData clientData,
 			    Tcl_CmdDeleteProc *deleteProc);
 MODULE_SCOPE int	TclNREvalFile(Tcl_Interp *interp, Tcl_Obj *pathPtr,
 			    const char *encodingName);
 MODULE_SCOPE void	TclFSUnloadTempFile(Tcl_LoadHandle loadHandle);
 MODULE_SCOPE int *	TclGetAsyncReadyPtr(void);
@@ -2954,20 +3026,20 @@
 MODULE_SCOPE int	TclGetCompletionCodeFromObj(Tcl_Interp *interp,
 			    Tcl_Obj *value, int *code);
 MODULE_SCOPE Proc *	TclGetLambdaFromObj(Tcl_Interp *interp,
 			    Tcl_Obj *objPtr, Tcl_Obj **nsObjPtrPtr);
 MODULE_SCOPE int	TclGetNumberFromObj(Tcl_Interp *interp,
-			    Tcl_Obj *objPtr, void **clientDataPtr,
+			    Tcl_Obj *objPtr, ClientData *clientDataPtr,
 			    int *typePtr);
 MODULE_SCOPE int	TclGetOpenModeEx(Tcl_Interp *interp,
 			    const char *modeString, int *seekFlagPtr,
 			    int *binaryPtr);
 MODULE_SCOPE Tcl_Obj *	TclGetProcessGlobalValue(ProcessGlobalValue *pgvPtr);
 MODULE_SCOPE Tcl_Obj *	TclGetSourceFromFrame(CmdFrame *cfPtr, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE char *	TclGetStringStorage(Tcl_Obj *objPtr,
-			    size_t *sizePtr);
+			    unsigned int *sizePtr);
 MODULE_SCOPE int	TclGetLoadedPackagesEx(Tcl_Interp *interp,
 				const char *targetName,
 				const char *packageName);
 MODULE_SCOPE int	TclGetWideBitsFromObj(Tcl_Interp *, Tcl_Obj *,
 				Tcl_WideInt *);
@@ -2976,20 +3048,20 @@
 			    Tcl_GlobTypeData *types);
 MODULE_SCOPE int	TclIncrObj(Tcl_Interp *interp, Tcl_Obj *valuePtr,
 			    Tcl_Obj *incrPtr);
 MODULE_SCOPE Tcl_Obj *	TclIncrObjVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr,
 			    Tcl_Obj *part2Ptr, Tcl_Obj *incrPtr, int flags);
-MODULE_SCOPE int	TclInfoExistsCmd(void *dummy, Tcl_Interp *interp,
+MODULE_SCOPE int	TclInfoExistsCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
-MODULE_SCOPE int	TclInfoCoroutineCmd(void *dummy, Tcl_Interp *interp,
+MODULE_SCOPE int	TclInfoCoroutineCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
 MODULE_SCOPE Tcl_Obj *	TclInfoFrame(Tcl_Interp *interp, CmdFrame *framePtr);
-MODULE_SCOPE int	TclInfoGlobalsCmd(void *dummy, Tcl_Interp *interp,
+MODULE_SCOPE int	TclInfoGlobalsCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
-MODULE_SCOPE int	TclInfoLocalsCmd(void *dummy, Tcl_Interp *interp,
+MODULE_SCOPE int	TclInfoLocalsCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
-MODULE_SCOPE int	TclInfoVarsCmd(void *dummy, Tcl_Interp *interp,
+MODULE_SCOPE int	TclInfoVarsCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
 MODULE_SCOPE void	TclInitAlloc(void);
 MODULE_SCOPE void	TclInitBignumFromWideInt(mp_int *, Tcl_WideInt);
 MODULE_SCOPE void	TclInitBignumFromWideUInt(mp_int *, Tcl_WideUInt);
 MODULE_SCOPE void	TclInitDbCkalloc(void);
@@ -3000,13 +3072,13 @@
 MODULE_SCOPE void	TclInitIOSubsystem(void);
 MODULE_SCOPE void	TclInitLimitSupport(Tcl_Interp *interp);
 MODULE_SCOPE void	TclInitNamespaceSubsystem(void);
 MODULE_SCOPE void	TclInitNotifier(void);
 MODULE_SCOPE void	TclInitObjSubsystem(void);
-MODULE_SCOPE void	TclInitSubsystems(void);
 MODULE_SCOPE int	TclInterpReady(Tcl_Interp *interp);
 MODULE_SCOPE int	TclIsSpaceProc(int byte);
+MODULE_SCOPE int	TclIsDigitProc(int byte);
 MODULE_SCOPE int	TclIsBareword(int byte);
 MODULE_SCOPE Tcl_Obj *	TclJoinPath(int elements, Tcl_Obj * const objv[],
 			    int forceRelative);
 MODULE_SCOPE int	TclJoinThread(Tcl_ThreadId id, int *result);
 MODULE_SCOPE void	TclLimitRemoveAllHandlers(Tcl_Interp *interp);
@@ -3025,11 +3097,11 @@
 MODULE_SCOPE Tcl_Obj *	TclLsetFlat(Tcl_Interp *interp, Tcl_Obj *listPtr,
 			    int indexCount, Tcl_Obj *const indexArray[],
 			    Tcl_Obj *valuePtr);
 MODULE_SCOPE Tcl_Command TclMakeEnsemble(Tcl_Interp *interp, const char *name,
 			    const EnsembleImplMap map[]);
-MODULE_SCOPE int	TclMaxListLength(const char *bytes, size_t numBytes,
+MODULE_SCOPE int	TclMaxListLength(const char *bytes, int numBytes,
 			    const char **endPtr);
 MODULE_SCOPE int	TclMergeReturnOptions(Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[], Tcl_Obj **optionsPtrPtr,
 			    int *codePtr, int *levelPtr);
 MODULE_SCOPE Tcl_Obj *  TclNoErrorStack(Tcl_Interp *interp, Tcl_Obj *options);
@@ -3043,26 +3115,26 @@
 			    int objc, Tcl_Obj *const objv[],
 			    Tcl_Namespace *nsPtr, int flags);
 MODULE_SCOPE int	TclObjUnsetVar2(Tcl_Interp *interp,
 			    Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, int flags);
 MODULE_SCOPE int	TclParseBackslash(const char *src,
-			    size_t numBytes, size_t *readPtr, char *dst);
-MODULE_SCOPE int	TclParseHex(const char *src, size_t numBytes,
+			    int numBytes, int *readPtr, char *dst);
+MODULE_SCOPE int	TclParseHex(const char *src, int numBytes,
 			    int *resultPtr);
 MODULE_SCOPE int	TclParseNumber(Tcl_Interp *interp, Tcl_Obj *objPtr,
 			    const char *expected, const char *bytes,
-			    size_t numBytes, const char **endPtrPtr, int flags);
+			    int numBytes, const char **endPtrPtr, int flags);
 MODULE_SCOPE void	TclParseInit(Tcl_Interp *interp, const char *string,
-			    size_t numBytes, Tcl_Parse *parsePtr);
-MODULE_SCOPE size_t	TclParseAllWhiteSpace(const char *src, size_t numBytes);
+			    int numBytes, Tcl_Parse *parsePtr);
+MODULE_SCOPE int	TclParseAllWhiteSpace(const char *src, int numBytes);
 MODULE_SCOPE int	TclProcessReturn(Tcl_Interp *interp,
 			    int code, int level, Tcl_Obj *returnOpts);
 MODULE_SCOPE int	TclpObjLstat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf);
 MODULE_SCOPE Tcl_Obj *	TclpTempFileName(void);
 MODULE_SCOPE Tcl_Obj *  TclpTempFileNameForLibrary(Tcl_Interp *interp, Tcl_Obj* pathPtr);
 MODULE_SCOPE Tcl_Obj *	TclNewFSPathObj(Tcl_Obj *dirPtr, const char *addStrRep,
-			    size_t len);
+			    int len);
 MODULE_SCOPE int	TclpDeleteFile(const void *path);
 MODULE_SCOPE void	TclpFinalizeCondition(Tcl_Condition *condPtr);
 MODULE_SCOPE void	TclpFinalizeMutex(Tcl_Mutex *mutexPtr);
 MODULE_SCOPE void	TclpFinalizePipes(void);
 MODULE_SCOPE void	TclpFinalizeSockets(void);
@@ -3069,15 +3141,15 @@
 MODULE_SCOPE int	TclCreateSocketAddress(Tcl_Interp *interp,
 			    struct addrinfo **addrlist,
 			    const char *host, int port, int willBind,
 			    const char **errorMsgPtr);
 MODULE_SCOPE int	TclpThreadCreate(Tcl_ThreadId *idPtr,
-			    Tcl_ThreadCreateProc *proc, void *clientData,
-			    size_t stackSize, int flags);
-MODULE_SCOPE size_t	TclpFindVariable(const char *name, size_t *lengthPtr);
+			    Tcl_ThreadCreateProc *proc, ClientData clientData,
+			    int stackSize, int flags);
+MODULE_SCOPE int	TclpFindVariable(const char *name, int *lengthPtr);
 MODULE_SCOPE void	TclpInitLibraryPath(char **valuePtr,
-			    size_t *lengthPtr, Tcl_Encoding *encodingPtr);
+			    unsigned int *lengthPtr, Tcl_Encoding *encodingPtr);
 MODULE_SCOPE void	TclpInitLock(void);
 MODULE_SCOPE void	TclpInitPlatform(void);
 MODULE_SCOPE void	TclpInitUnlock(void);
 MODULE_SCOPE Tcl_Obj *	TclpObjListVolumes(void);
 MODULE_SCOPE void	TclpMasterLock(void);
@@ -3093,11 +3165,11 @@
 MODULE_SCOPE int	TclCrossFilesystemCopy(Tcl_Interp *interp,
 			    Tcl_Obj *source, Tcl_Obj *target);
 MODULE_SCOPE int	TclpMatchInDirectory(Tcl_Interp *interp,
 			    Tcl_Obj *resultPtr, Tcl_Obj *pathPtr,
 			    const char *pattern, Tcl_GlobTypeData *types);
-MODULE_SCOPE void	*TclpGetNativeCwd(void *clientData);
+MODULE_SCOPE ClientData	TclpGetNativeCwd(ClientData clientData);
 MODULE_SCOPE Tcl_FSDupInternalRepProc TclNativeDupInternalRep;
 MODULE_SCOPE Tcl_Obj *	TclpObjLink(Tcl_Obj *pathPtr, Tcl_Obj *toPtr,
 			    int linkType);
 MODULE_SCOPE int	TclpObjChdir(Tcl_Obj *pathPtr);
 MODULE_SCOPE Tcl_Channel TclpOpenTemporaryFile(Tcl_Obj *dirObj,
@@ -3117,13 +3189,13 @@
 MODULE_SCOPE void	TclRememberCondition(Tcl_Condition *mutex);
 MODULE_SCOPE void	TclRememberJoinableThread(Tcl_ThreadId id);
 MODULE_SCOPE void	TclRememberMutex(Tcl_Mutex *mutex);
 MODULE_SCOPE void	TclRemoveScriptLimitCallbacks(Tcl_Interp *interp);
 MODULE_SCOPE int	TclReToGlob(Tcl_Interp *interp, const char *reStr,
-			    size_t reStrLen, Tcl_DString *dsPtr, int *flagsPtr,
+			    int reStrLen, Tcl_DString *dsPtr, int *flagsPtr,
 			    int *quantifiersFoundPtr);
-MODULE_SCOPE size_t	TclScanElement(const char *string, size_t length,
+MODULE_SCOPE int	TclScanElement(const char *string, int length,
 			    char *flagPtr);
 MODULE_SCOPE void	TclSetBgErrorHandler(Tcl_Interp *interp,
 			    Tcl_Obj *cmdPrefix);
 MODULE_SCOPE void	TclSetBignumIntRep(Tcl_Obj *objPtr,
 			    mp_int *bignumValue);
@@ -3134,41 +3206,41 @@
 MODULE_SCOPE void	TclSetDuplicateObj(Tcl_Obj *dupPtr, Tcl_Obj *objPtr);
 MODULE_SCOPE void	TclSetProcessGlobalValue(ProcessGlobalValue *pgvPtr,
 			    Tcl_Obj *newValue, Tcl_Encoding encoding);
 MODULE_SCOPE void	TclSignalExitThread(Tcl_ThreadId id, int result);
 MODULE_SCOPE void	TclSpellFix(Tcl_Interp *interp,
-			    Tcl_Obj *const *objv, int objc, size_t subIdx,
+			    Tcl_Obj *const *objv, int objc, int subIdx,
 			    Tcl_Obj *bad, Tcl_Obj *fix);
 MODULE_SCOPE void *	TclStackRealloc(Tcl_Interp *interp, void *ptr,
-			    size_t numBytes);
+			    int numBytes);
 typedef int (*memCmpFn_t)(const void*, const void*, size_t);
 MODULE_SCOPE int	TclStringCmp(Tcl_Obj *value1Ptr, Tcl_Obj *value2Ptr,
-			    int checkEq, int nocase, size_t reqlength);
+			    int checkEq, int nocase, int reqlength);
 MODULE_SCOPE int	TclStringCmpOpts(Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[], int *nocase,
 			    int *reqlength);
-MODULE_SCOPE int	TclStringMatch(const char *str, size_t strLen,
+MODULE_SCOPE int	TclStringMatch(const char *str, int strLen,
 			    const char *pattern, int ptnLen, int flags);
 MODULE_SCOPE int	TclStringMatchObj(Tcl_Obj *stringObj,
 			    Tcl_Obj *patternObj, int flags);
 MODULE_SCOPE void	TclSubstCompile(Tcl_Interp *interp, const char *bytes,
-			    size_t numBytes, int flags, int line,
+			    int numBytes, int flags, int line,
 			    struct CompileEnv *envPtr);
 MODULE_SCOPE int	TclSubstOptions(Tcl_Interp *interp, int numOpts,
 			    Tcl_Obj *const opts[], int *flagPtr);
 MODULE_SCOPE void	TclSubstParse(Tcl_Interp *interp, const char *bytes,
-			    size_t numBytes, int flags, Tcl_Parse *parsePtr,
+			    int numBytes, int flags, Tcl_Parse *parsePtr,
 			    Tcl_InterpState *statePtr);
 MODULE_SCOPE int	TclSubstTokens(Tcl_Interp *interp, Tcl_Token *tokenPtr,
 			    int count, int *tokensLeftPtr, int line,
 			    int *clNextOuter, const char *outerScript);
-MODULE_SCOPE size_t	TclTrim(const char *bytes, size_t numBytes,
-			    const char *trim, size_t numTrim, size_t *trimRight);
-MODULE_SCOPE size_t	TclTrimLeft(const char *bytes, size_t numBytes,
-			    const char *trim, size_t numTrim);
-MODULE_SCOPE size_t	TclTrimRight(const char *bytes, size_t numBytes,
-			    const char *trim, size_t numTrim);
+MODULE_SCOPE int	TclTrim(const char *bytes, int numBytes,
+			    const char *trim, int numTrim, int *trimRight);
+MODULE_SCOPE int	TclTrimLeft(const char *bytes, int numBytes,
+			    const char *trim, int numTrim);
+MODULE_SCOPE int	TclTrimRight(const char *bytes, int numBytes,
+			    const char *trim, int numTrim);
 MODULE_SCOPE const char*TclGetCommandTypeName(Tcl_Command command);
 MODULE_SCOPE void	TclRegisterCommandTypeName(
 			    Tcl_ObjCmdProc *implementationProc,
 			    const char *nameStr);
 #if (TCL_UTF_MAX > 4) && (defined(__CYGWIN__) || defined(_WIN32))
@@ -3182,12 +3254,12 @@
 #   define TclWCharToUtfDString Tcl_UniCharToUtfDString
 #   define TclUtfToWCharDString Tcl_UtfToUniCharDString
 #endif
 MODULE_SCOPE int	TclUtfCmp(const char *cs, const char *ct);
 MODULE_SCOPE int	TclUtfCasecmp(const char *cs, const char *ct);
-MODULE_SCOPE size_t	TclUtfCount(int ch);
-MODULE_SCOPE Tcl_Obj *	TclpNativeToNormalized(void *clientData);
+MODULE_SCOPE int	TclUtfCount(int ch);
+MODULE_SCOPE Tcl_Obj *	TclpNativeToNormalized(ClientData clientData);
 MODULE_SCOPE Tcl_Obj *	TclpFilesystemPathType(Tcl_Obj *pathPtr);
 MODULE_SCOPE int	TclpDlopen(Tcl_Interp *interp, Tcl_Obj *pathPtr,
 			    Tcl_LoadHandle *loadHandle,
 			    Tcl_FSUnloadFileProc **unloadProcPtr, int flags);
 MODULE_SCOPE int	TclpUtime(Tcl_Obj *pathPtr, struct utimbuf *tval);
@@ -3199,10 +3271,17 @@
 #endif
 MODULE_SCOPE void	TclInitThreadStorage(void);
 MODULE_SCOPE void	TclFinalizeThreadDataThread(void);
 MODULE_SCOPE void	TclFinalizeThreadStorage(void);
 
+/* TclWideMUInt -- wide integer used for measurement calculations: */
+#if (!defined(_WIN32) || !defined(_MSC_VER) || (_MSC_VER >= 1400))
+#   define TclWideMUInt Tcl_WideUInt
+#else
+/* older MSVS may not allow conversions between unsigned __int64 and double) */
+#   define TclWideMUInt Tcl_WideInt
+#endif
 #ifdef TCL_WIDE_CLICKS
 MODULE_SCOPE Tcl_WideInt TclpGetWideClicks(void);
 MODULE_SCOPE double	TclpWideClicksToNanoseconds(Tcl_WideInt clicks);
 MODULE_SCOPE double	TclpWideClickInMicrosec(void);
 #else
@@ -3220,11 +3299,11 @@
 MODULE_SCOPE void *	TclpThreadCreateKey(void);
 MODULE_SCOPE void	TclpThreadDeleteKey(void *keyPtr);
 MODULE_SCOPE void	TclpThreadSetMasterTSD(void *tsdKeyPtr, void *ptr);
 MODULE_SCOPE void *	TclpThreadGetMasterTSD(void *tsdKeyPtr);
 MODULE_SCOPE void	TclErrorStackResetIf(Tcl_Interp *interp,
-			    const char *msg, size_t length);
+			    const char *msg, int length);
 /* Tip 430 */
 MODULE_SCOPE int    TclZipfs_Init(Tcl_Interp *interp);
 
 
 /*
@@ -3231,297 +3310,302 @@
  *----------------------------------------------------------------
  * Command procedures in the generic core:
  *----------------------------------------------------------------
  */
 
-MODULE_SCOPE int	Tcl_AfterObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_AfterObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_AppendObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_AppendObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ApplyObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_ApplyObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE Tcl_Command TclInitArrayCmd(Tcl_Interp *interp);
 MODULE_SCOPE Tcl_Command TclInitBinaryCmd(Tcl_Interp *interp);
-MODULE_SCOPE int	Tcl_BreakObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_BreakObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_CatchObjCmd(void *clientData,
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+MODULE_SCOPE int	Tcl_CaseObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_CdObjCmd(void *clientData,
+#endif
+MODULE_SCOPE int	Tcl_CatchObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_CdObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE Tcl_Command TclInitChanCmd(Tcl_Interp *interp);
-MODULE_SCOPE int	TclChanCreateObjCmd(void *clientData,
+MODULE_SCOPE int	TclChanCreateObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	TclChanPostEventObjCmd(void *clientData,
+MODULE_SCOPE int	TclChanPostEventObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	TclChanPopObjCmd(void *clientData,
+MODULE_SCOPE int	TclChanPopObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
-MODULE_SCOPE int	TclChanPushObjCmd(void *clientData,
+MODULE_SCOPE int	TclChanPushObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
 MODULE_SCOPE void	TclClockInit(Tcl_Interp *interp);
 MODULE_SCOPE int	TclClockOldscanObjCmd(
 			    void *clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_CloseObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_CloseObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ConcatObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_ConcatObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ContinueObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_ContinueObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE Tcl_TimerToken TclCreateAbsoluteTimerHandler(
 			    Tcl_Time *timePtr, Tcl_TimerProc *proc,
-			    void *clientData);
+			    ClientData clientData);
 MODULE_SCOPE int	TclDefaultBgErrorHandlerObjCmd(
-			    void *clientData, Tcl_Interp *interp,
+			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
 MODULE_SCOPE Tcl_Command TclInitDictCmd(Tcl_Interp *interp);
 MODULE_SCOPE int	TclDictWithFinish(Tcl_Interp *interp, Var *varPtr,
 			    Var *arrayPtr, Tcl_Obj *part1Ptr,
 			    Tcl_Obj *part2Ptr, int index, int pathc,
 			    Tcl_Obj *const pathv[], Tcl_Obj *keysPtr);
 MODULE_SCOPE Tcl_Obj *	TclDictWithInit(Tcl_Interp *interp, Tcl_Obj *dictPtr,
 			    int pathc, Tcl_Obj *const pathv[]);
-MODULE_SCOPE int	Tcl_DisassembleObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_DisassembleObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 
 /* Assemble command function */
-MODULE_SCOPE int	Tcl_AssembleObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_AssembleObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	TclNRAssembleObjCmd(void *clientData,
+MODULE_SCOPE int	TclNRAssembleObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE Tcl_Command TclInitEncodingCmd(Tcl_Interp *interp);
-MODULE_SCOPE int	Tcl_EofObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ErrorObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_EvalObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ExecObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ExitObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ExprObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_FblockedObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_EofObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_ErrorObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_EvalObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_ExecObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_ExitObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_ExprObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_FblockedObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	Tcl_FconfigureObjCmd(
-			    void *clientData, Tcl_Interp *interp,
+			    ClientData clientData, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_FcopyObjCmd(void *dummy,
+MODULE_SCOPE int	Tcl_FcopyObjCmd(ClientData dummy,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE Tcl_Command TclInitFileCmd(Tcl_Interp *interp);
-MODULE_SCOPE int	Tcl_FileEventObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_FlushObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ForObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ForeachObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_FormatObjCmd(void *dummy,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_GetsObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_GlobalObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_GlobObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_IfObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_IncrObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_FileEventObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_FlushObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_ForObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_ForeachObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_FormatObjCmd(ClientData dummy,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_GetsObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_GlobalObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_GlobObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_IfObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_IncrObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE Tcl_Command TclInitInfoCmd(Tcl_Interp *interp);
-MODULE_SCOPE int	Tcl_InterpObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_InterpObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int argc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_JoinObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LappendObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LassignObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LindexObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LinsertObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LlengthObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ListObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LmapObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LoadObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LpopObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LrangeObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LremoveObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LrepeatObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LreplaceObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LreverseObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LsearchObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LsetObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_LsortObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_JoinObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LappendObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LassignObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LindexObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LinsertObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LlengthObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_ListObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LmapObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LoadObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LpopObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LrangeObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LremoveObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LrepeatObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LreplaceObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LreverseObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LsearchObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LsetObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_LsortObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE Tcl_Command TclInitNamespaceCmd(Tcl_Interp *interp);
-MODULE_SCOPE int	TclNamespaceEnsembleCmd(void *dummy,
+MODULE_SCOPE int	TclNamespaceEnsembleCmd(ClientData dummy,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_OpenObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_OpenObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_PackageObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_PackageObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_PidObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_PidObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE Tcl_Command TclInitPrefixCmd(Tcl_Interp *interp);
-MODULE_SCOPE int	Tcl_PutsObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_PwdObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ReadObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_RegexpObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_RegsubObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_RenameObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_RepresentationCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ReturnObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ScanObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_SeekObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_SetObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_SplitObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_SocketObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_SourceObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_PutsObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_PwdObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_ReadObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_RegexpObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_RegsubObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_RenameObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_RepresentationCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_ReturnObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_ScanObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_SeekObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_SetObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_SplitObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_SocketObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_SourceObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE Tcl_Command TclInitStringCmd(Tcl_Interp *interp);
-MODULE_SCOPE int	Tcl_SubstObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_SubstObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_SwitchObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_SwitchObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_TellObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_TellObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_ThrowObjCmd(void *dummy, Tcl_Interp *interp,
+MODULE_SCOPE int	Tcl_ThrowObjCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_TimeObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_TimeRateObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_TraceObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_TryObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_UnloadObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_UnsetObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_UpdateObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_UplevelObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_UpvarObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_VariableObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_VwaitObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const objv[]);
-MODULE_SCOPE int	Tcl_WhileObjCmd(void *clientData,
+MODULE_SCOPE int	Tcl_TimeObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_TimeRateObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_TraceObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_TryObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_UnloadObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_UnsetObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_UpdateObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_UplevelObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_UpvarObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_VariableObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_VwaitObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_WhileObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 
 /*
  *----------------------------------------------------------------
@@ -3849,107 +3933,107 @@
 			    struct CompileEnv *envPtr);
 MODULE_SCOPE int	TclCompileBasicMin2ArgCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
 
-MODULE_SCOPE int	TclInvertOpCmd(void *clientData,
+MODULE_SCOPE int	TclInvertOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileInvertOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclNotOpCmd(void *clientData,
+MODULE_SCOPE int	TclNotOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileNotOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclAddOpCmd(void *clientData,
+MODULE_SCOPE int	TclAddOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileAddOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclMulOpCmd(void *clientData,
+MODULE_SCOPE int	TclMulOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileMulOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclAndOpCmd(void *clientData,
+MODULE_SCOPE int	TclAndOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileAndOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclOrOpCmd(void *clientData,
+MODULE_SCOPE int	TclOrOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileOrOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclXorOpCmd(void *clientData,
+MODULE_SCOPE int	TclXorOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileXorOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclPowOpCmd(void *clientData,
+MODULE_SCOPE int	TclPowOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompilePowOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclLshiftOpCmd(void *clientData,
+MODULE_SCOPE int	TclLshiftOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileLshiftOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclRshiftOpCmd(void *clientData,
+MODULE_SCOPE int	TclRshiftOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileRshiftOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclModOpCmd(void *clientData,
+MODULE_SCOPE int	TclModOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileModOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclNeqOpCmd(void *clientData,
+MODULE_SCOPE int	TclNeqOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileNeqOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclStrneqOpCmd(void *clientData,
+MODULE_SCOPE int	TclStrneqOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileStrneqOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclInOpCmd(void *clientData,
+MODULE_SCOPE int	TclInOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileInOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclNiOpCmd(void *clientData,
+MODULE_SCOPE int	TclNiOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileNiOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclMinusOpCmd(void *clientData,
+MODULE_SCOPE int	TclMinusOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileMinusOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
-MODULE_SCOPE int	TclDivOpCmd(void *clientData,
+MODULE_SCOPE int	TclDivOpCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclCompileDivOpCmd(Tcl_Interp *interp,
 			    Tcl_Parse *parsePtr, Command *cmdPtr,
 			    struct CompileEnv *envPtr);
@@ -3993,18 +4077,18 @@
  * candidates for public interface.
  */
 
 MODULE_SCOPE Tcl_Obj *	TclStringCat(Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[], int flags);
-MODULE_SCOPE size_t	TclStringFirst(Tcl_Obj *needle, Tcl_Obj *haystack,
-			    size_t start);
-MODULE_SCOPE size_t	TclStringLast(Tcl_Obj *needle, Tcl_Obj *haystack,
-			    size_t last);
+MODULE_SCOPE int	TclStringFirst(Tcl_Obj *needle, Tcl_Obj *haystack,
+			    int start);
+MODULE_SCOPE int	TclStringLast(Tcl_Obj *needle, Tcl_Obj *haystack,
+			    int last);
 MODULE_SCOPE Tcl_Obj *	TclStringRepeat(Tcl_Interp *interp, Tcl_Obj *objPtr,
-			    size_t count, int flags);
+			    int count, int flags);
 MODULE_SCOPE Tcl_Obj *	TclStringReplace(Tcl_Interp *interp, Tcl_Obj *objPtr,
-			    size_t first, size_t count, Tcl_Obj *insertPtr,
+			    int first, int count, Tcl_Obj *insertPtr,
 			    int flags);
 MODULE_SCOPE Tcl_Obj *	TclStringReverse(Tcl_Obj *objPtr, int flags);
 
 /* Flag values for the [string] ensemble functions. */
 
@@ -4115,16 +4199,16 @@
  * Utility routines for encoding index values as integers. Used by both
  * some of the command compilers and by [lsort] and [lsearch].
  */
 
 MODULE_SCOPE int	TclIndexEncode(Tcl_Interp *interp, Tcl_Obj *objPtr,
-			    size_t before, size_t after, int *indexPtr);
-MODULE_SCOPE size_t	TclIndexDecode(int encoded, size_t endValue);
+			    int before, int after, int *indexPtr);
+MODULE_SCOPE int	TclIndexDecode(int encoded, int endValue);
 
 /* Constants used in index value encoding routines. */
-#define TCL_INDEX_END           ((size_t)-2)
-#define TCL_INDEX_START         ((size_t)0)
+#define TCL_INDEX_END           (-2)
+#define TCL_INDEX_START         (0)
 
 /*
  *----------------------------------------------------------------
  * Macros used by the Tcl core to create and release Tcl objects.
  * TclNewObj(objPtr) creates a new object denoting an empty string.
@@ -4149,11 +4233,10 @@
  * DTrace object allocation probe macros.
  */
 
 #ifdef USE_DTRACE
 #ifndef _TCLDTRACE_H
-typedef const char *TclDTraceStr;
 #include "tclDTrace.h"
 #endif
 #define	TCL_DTRACE_OBJ_CREATE(objPtr)	TCL_OBJ_CREATE(objPtr)
 #define	TCL_DTRACE_OBJ_FREE(objPtr)	TCL_OBJ_FREE(objPtr)
 #else /* USE_DTRACE */
@@ -4188,23 +4271,23 @@
     TCL_DTRACE_OBJ_CREATE(objPtr)
 
 /*
  * Invalidate the string rep first so we can use the bytes value for our
  * pointer chain, and signal an obj deletion (as opposed to shimmering) with
- * 'length == TCL_AUTO_LENGTH'.
+ * 'length == -1'.
  * Use empty 'if ; else' to handle use in unbraced outer if/else conditions.
  */
 
 # define TclDecrRefCount(objPtr) \
     if ((objPtr)->refCount-- > 1) ; else { \
 	if (!(objPtr)->typePtr || !(objPtr)->typePtr->freeIntRepProc) { \
 	    TCL_DTRACE_OBJ_FREE(objPtr); \
 	    if ((objPtr)->bytes \
 		    && ((objPtr)->bytes != &tclEmptyString)) { \
-		Tcl_Free((objPtr)->bytes); \
+		ckfree((objPtr)->bytes); \
 	    } \
-	    (objPtr)->length = TCL_AUTO_LENGTH; \
+	    (objPtr)->length = -1; \
 	    TclFreeObjStorage(objPtr); \
 	    TclIncrObjsFreed(); \
 	} else { \
 	    TclFreeObj(objPtr); \
 	} \
@@ -4222,14 +4305,14 @@
  * allocates and frees a single Tcl_Obj so that tools like Purify can better
  * track memory leaks.
  */
 
 #  define TclAllocObjStorageEx(interp, objPtr) \
-	(objPtr) = (Tcl_Obj *) Tcl_Alloc(sizeof(Tcl_Obj))
+	(objPtr) = (Tcl_Obj *) ckalloc(sizeof(Tcl_Obj))
 
 #  define TclFreeObjStorageEx(interp, objPtr) \
-	Tcl_Free(objPtr)
+	ckfree(objPtr)
 
 #undef USE_THREAD_ALLOC
 #undef USE_TCLALLOC
 #elif TCL_THREADS && defined(USE_THREAD_ALLOC)
 
@@ -4353,11 +4436,11 @@
  * copy of the "len" bytes starting at "bytePtr". This code works even if the
  * byte array contains NULLs as long as the length is correct. Because "len"
  * is referenced multiple times, it should be as simple an expression as
  * possible. The ANSI C "prototype" for this macro is:
  *
- * MODULE_SCOPE void TclInitStringRep(Tcl_Obj *objPtr, char *bytePtr, size_t len);
+ * MODULE_SCOPE void TclInitStringRep(Tcl_Obj *objPtr, char *bytePtr, int len);
  *
  * This macro should only be called on an unshared objPtr where
  *  objPtr->typePtr->freeIntRepProc == NULL
  *----------------------------------------------------------------
  */
@@ -4365,11 +4448,11 @@
 #define TclInitStringRep(objPtr, bytePtr, len) \
     if ((len) == 0) { \
 	(objPtr)->bytes	 = &tclEmptyString; \
 	(objPtr)->length = 0; \
     } else { \
-	(objPtr)->bytes = Tcl_Alloc((len) + 1); \
+	(objPtr)->bytes = (char *) ckalloc((len) + 1); \
 	memcpy((objPtr)->bytes, (bytePtr) ? (bytePtr) : &tclEmptyString, (len)); \
 	(objPtr)->bytes[len] = '\0'; \
 	(objPtr)->length = (len); \
     }
 
@@ -4386,42 +4469,14 @@
  */
 
 #define TclGetString(objPtr) \
     ((objPtr)->bytes? (objPtr)->bytes : Tcl_GetString(objPtr))
 
-#if 0
-   static inline char *TclGetStringFromObj(Tcl_Obj *objPtr, size_t *lenPtr) {
-      char *response = Tcl_GetString(objPtr);
-      *(lenPtr) = objPtr->length;
-      return response;
-   }
-   static inline Tcl_UniChar *TclGetUnicodeFromObj(Tcl_Obj *objPtr, size_t *lenPtr) {
-      Tcl_UniChar *response = Tcl_GetUnicodeFromObj(objPtr, NULL);
-      *(lenPtr) = *((size_t *) (objPtr)->internalRep.twoPtrValue.ptr1);
-      return response;
-   }
-   static inline unsigned char *TclGetByteArrayFromObj(Tcl_Obj *objPtr, size_t *lenPtr) {
-      unsigned char *response = Tcl_GetByteArrayFromObj(objPtr, NULL);
-      if (response) {
-          *(lenPtr) = *((size_t *) (objPtr)->internalRep.twoPtrValue.ptr1);
-      }
-      return response;
-   }
-#else
 #define TclGetStringFromObj(objPtr, lenPtr) \
-    (((objPtr)->bytes \
-	    ? NULL : Tcl_GetString((objPtr)), \
-	    *(lenPtr) = (objPtr)->length, (objPtr)->bytes))
-#define TclGetUnicodeFromObj(objPtr, lenPtr) \
-    (Tcl_GetUnicodeFromObj((objPtr), NULL), \
-	    *(lenPtr) = *((size_t *) (objPtr)->internalRep.twoPtrValue.ptr1), \
-	    Tcl_GetUnicodeFromObj((objPtr), NULL))
-#define TclGetByteArrayFromObj(objPtr, lenPtr) \
-    (Tcl_GetByteArrayFromObj((objPtr), NULL) ? \
-	(*(lenPtr) = *((size_t *) (objPtr)->internalRep.twoPtrValue.ptr1), \
-	(unsigned char *)(((size_t *) (objPtr)->internalRep.twoPtrValue.ptr1) + 2)) : NULL)
-#endif
+    ((objPtr)->bytes \
+	    ? (*(lenPtr) = (objPtr)->length, (objPtr)->bytes)	\
+	    : Tcl_GetStringFromObj((objPtr), (lenPtr)))
 
 /*
  *----------------------------------------------------------------
  * Macro used by the Tcl core to clean out an object's internal
  * representation. Does not actually reset the rep's bytes. The ANSI C
@@ -4449,11 +4504,11 @@
  */
 
 #define TclInvalidateStringRep(objPtr) \
     if ((objPtr)->bytes != NULL) { \
 	if ((objPtr)->bytes != &tclEmptyString) { \
-	    Tcl_Free((objPtr)->bytes); \
+	    ckfree((objPtr)->bytes); \
 	} \
 	(objPtr)->bytes = NULL; \
     }
 
 /*
@@ -4478,12 +4533,12 @@
  *----------------------------------------------------------------
  */
 
 #define TclUnpackBignum(objPtr, bignum) \
     do {								\
-	register Tcl_Obj *bignumObj = (objPtr);				\
-	register int bignumPayload =					\
+	Tcl_Obj *bignumObj = (objPtr);				\
+	int bignumPayload =					\
 		PTR2INT(bignumObj->internalRep.twoPtrValue.ptr2);	\
 	if (bignumPayload == -1) {					\
 	    (bignum) = *((mp_int *) bignumObj->internalRep.twoPtrValue.ptr1); \
 	} else {							\
 	    (bignum).dp = bignumObj->internalRep.twoPtrValue.ptr1;	\
@@ -4538,24 +4593,24 @@
 		oldPtr = NULL;						\
 	    }								\
 	    if (allocated > TCL_MAX_TOKENS) {				\
 		allocated = TCL_MAX_TOKENS;				\
 	    }								\
-	    newPtr = (Tcl_Token *) Tcl_AttemptRealloc((char *) oldPtr,	\
-		    (allocated * sizeof(Tcl_Token)));	\
+	    newPtr = (Tcl_Token *) attemptckrealloc((char *) oldPtr,	\
+		    allocated * sizeof(Tcl_Token));	\
 	    if (newPtr == NULL) {					\
 		allocated = _needed + (append) + TCL_MIN_TOKEN_GROWTH;	\
 		if (allocated > TCL_MAX_TOKENS) {			\
 		    allocated = TCL_MAX_TOKENS;				\
 		}							\
-		newPtr = (Tcl_Token *) Tcl_Realloc((char *) oldPtr,	\
-			(allocated * sizeof(Tcl_Token))); \
+		newPtr = (Tcl_Token *) ckrealloc((char *) oldPtr,	\
+			allocated * sizeof(Tcl_Token)); \
 	    }								\
 	    (available) = allocated;					\
 	    if (oldPtr == NULL) {					\
 		memcpy(newPtr, staticPtr,				\
-			((used) * sizeof(Tcl_Token)));		\
+			(used) * sizeof(Tcl_Token));		\
 	    }								\
 	    (tokenPtr) = newPtr;					\
 	}								\
     } while (0)
 
@@ -4587,17 +4642,17 @@
  * -sensitive points where it pays to avoid a function call in the common case
  * of counting along a string of all one-byte characters.  The ANSI C
  * "prototype" for this macro is:
  *
  * MODULE_SCOPE void	TclNumUtfChars(int numChars, const char *bytes,
- *				size_t numBytes);
+ *				int numBytes);
  *----------------------------------------------------------------
  */
 
 #define TclNumUtfChars(numChars, bytes, numBytes) \
     do { \
-	size_t _count, _i = (numBytes); \
+	int _count, _i = (numBytes); \
 	unsigned char *_str = (unsigned char *) (bytes); \
 	while (_i && (*_str < 0xC0)) { _i--; _str++; } \
 	_count = (numBytes) - _i; \
 	if (_i) { \
 	    _count += Tcl_NumUtfChars((bytes) + _count, _i); \
@@ -4736,11 +4791,11 @@
  * types, avoiding the corresponding function calls in time critical parts of
  * the core. The ANSI C "prototypes" for these macros are:
  *
  * MODULE_SCOPE void	TclNewIntObj(Tcl_Obj *objPtr, Tcl_WideInt w);
  * MODULE_SCOPE void	TclNewDoubleObj(Tcl_Obj *objPtr, double d);
- * MODULE_SCOPE void	TclNewStringObj(Tcl_Obj *objPtr, const char *s, size_t len);
+ * MODULE_SCOPE void	TclNewStringObj(Tcl_Obj *objPtr, const char *s, int len);
  * MODULE_SCOPE void	TclNewLiteralStringObj(Tcl_Obj*objPtr, const char *sLiteral);
  *
  *----------------------------------------------------------------
  */
 
@@ -4791,11 +4846,11 @@
 /*
  * The sLiteral argument *must* be a string literal; the incantation with
  * sizeof(sLiteral "") will fail to compile otherwise.
  */
 #define TclNewLiteralStringObj(objPtr, sLiteral) \
-    TclNewStringObj((objPtr), (sLiteral), sizeof(sLiteral "") - 1)
+    TclNewStringObj((objPtr), (sLiteral), (int) (sizeof(sLiteral "") - 1))
 
 /*
  *----------------------------------------------------------------
  * Convenience macros for DStrings.
  * The ANSI C "prototypes" for these macros are:
@@ -4804,11 +4859,11 @@
  *			const char *sLiteral);
  * MODULE_SCOPE void   TclDStringClear(Tcl_DString *dsPtr);
  */
 
 #define TclDStringAppendLiteral(dsPtr, sLiteral) \
-    Tcl_DStringAppend((dsPtr), (sLiteral), sizeof(sLiteral "") - 1)
+    Tcl_DStringAppend((dsPtr), (sLiteral), (int) (sizeof(sLiteral "") - 1))
 #define TclDStringClear(dsPtr) \
     Tcl_DStringSetLength((dsPtr), 0)
 
 /*
  *----------------------------------------------------------------
@@ -4829,10 +4884,18 @@
 #    else
 #	 define TclIsNaN(d)	(isnan(d))
 #    endif
 #endif
 
+/*
+ * Macro to use to find the offset of a field in astructure.
+ * Computes number of bytes from beginning of structure to a given field.
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#   define TclOffset(type, field) ((int) offsetof(type, field))
+#endif
 /* Workaround for platforms missing offsetof(), e.g. VC++ 6.0 */
 #ifndef offsetof
 #   define offsetof(type, field) ((size_t) ((char *) &((type *) 0)->field))
 #endif
 
@@ -4853,11 +4916,11 @@
  * the internal stubs, but the core can use the macro instead.
  */
 
 #define TclCleanupCommandMacro(cmdPtr) \
     if ((cmdPtr)->refCount-- <= 1) { \
-	Tcl_Free(cmdPtr);\
+	ckfree(cmdPtr);\
     }
 
 /*
  *----------------------------------------------------------------
  * Inline versions of Tcl_LimitReady() and Tcl_LimitExceeded to limit number
@@ -4916,27 +4979,27 @@
 #define TclSmallAllocEx(interp, nbytes, memPtr) \
     do {								\
 	Tcl_Obj *_objPtr;						\
 	TCL_CT_ASSERT((nbytes)<=sizeof(Tcl_Obj));			\
 	TclIncrObjsAllocated();						\
-	TclAllocObjStorageEx((interp), _objPtr);			\
-	memPtr = (void *)_objPtr;					\
+	TclAllocObjStorageEx((interp), (_objPtr));			\
+	memPtr = (ClientData) (_objPtr);					\
     } while (0)
 
 #define TclSmallFreeEx(interp, memPtr) \
     do {								\
-	TclFreeObjStorageEx((interp), (Tcl_Obj *)memPtr);		\
+	TclFreeObjStorageEx((interp), (Tcl_Obj *) (memPtr));		\
 	TclIncrObjsFreed();						\
     } while (0)
 
 #else    /* TCL_MEM_DEBUG */
 #define TclSmallAllocEx(interp, nbytes, memPtr) \
     do {								\
 	Tcl_Obj *_objPtr;						\
 	TCL_CT_ASSERT((nbytes)<=sizeof(Tcl_Obj));			\
 	TclNewObj(_objPtr);						\
-	memPtr = (void *)_objPtr;					\
+	memPtr = (ClientData) _objPtr;					\
     } while (0)
 
 #define TclSmallFreeEx(interp, memPtr) \
     do {								\
 	Tcl_Obj *_objPtr = (Tcl_Obj *) memPtr;				\
@@ -4945,25 +5008,10 @@
 	_objPtr->refCount = 1;						\
 	TclDecrRefCount(_objPtr);					\
     } while (0)
 #endif   /* TCL_MEM_DEBUG */
 
-/*
- * Macros to convert size_t to wide-int (and wide-int object) considering
- * platform-related negative value ((size_t)-1), if wide-int and size_t
- * have different dimensions (e. g. 32-bit platform).
- */
-
-#if (!defined(TCL_WIDE_INT_IS_LONG) || (LONG_MAX > UINT_MAX)) && (SIZE_MAX <= UINT_MAX)
-#   define TclWideIntFromSize(value)	(((Tcl_WideInt)(((size_t)(value))+1))-1)
-#   define TclNewWideIntObjFromSize(value) \
-	Tcl_NewWideIntObj(TclWideIntFromSize(value))
-#else
-#   define TclWideIntFromSize(value)	((Tcl_WideInt)(value))
-#   define TclNewWideIntObjFromSize Tcl_NewWideIntObj
-#endif
-
 /*
  * Support for Clang Static Analyzer <http://clang-analyzer.llvm.org>
  */
 
 #if defined(PURIFY) && defined(__clang__)
@@ -4996,11 +5044,11 @@
  * available.
  */
 
 typedef struct NRE_callback {
     Tcl_NRPostProc *procPtr;
-    void *data[4];
+    ClientData data[4];
     struct NRE_callback *nextPtr;
 } NRE_callback;
 
 #define TOP_CB(iPtr) (((Interp *)(iPtr))->execEnvPtr->callbackPtr)
 
@@ -5011,14 +5059,14 @@
 #define TclNRAddCallback(interp,postProcPtr,data0,data1,data2,data3) \
     do {								\
 	NRE_callback *_callbackPtr;					\
 	TCLNR_ALLOC((interp), (_callbackPtr));				\
 	_callbackPtr->procPtr = (postProcPtr);				\
-	_callbackPtr->data[0] = (void *)(data0);			\
-	_callbackPtr->data[1] = (void *)(data1);			\
-	_callbackPtr->data[2] = (void *)(data2);			\
-	_callbackPtr->data[3] = (void *)(data3);			\
+	_callbackPtr->data[0] = (ClientData)(data0);			\
+	_callbackPtr->data[1] = (ClientData)(data1);			\
+	_callbackPtr->data[2] = (ClientData)(data2);			\
+	_callbackPtr->data[3] = (ClientData)(data3);			\
 	_callbackPtr->nextPtr = TOP_CB(interp);				\
 	TOP_CB(interp) = _callbackPtr;					\
     } while (0)
 
 #if NRE_USE_SMALL_ALLOC
@@ -5025,12 +5073,12 @@
 #define TCLNR_ALLOC(interp, ptr) \
     TclSmallAllocEx(interp, sizeof(NRE_callback), (ptr))
 #define TCLNR_FREE(interp, ptr)  TclSmallFreeEx((interp), (ptr))
 #else
 #define TCLNR_ALLOC(interp, ptr) \
-    (ptr = (Tcl_Alloc(sizeof(NRE_callback))))
-#define TCLNR_FREE(interp, ptr)  Tcl_Free(ptr)
+    (ptr = ((ClientData) ckalloc(sizeof(NRE_callback))))
+#define TCLNR_FREE(interp, ptr)  ckfree(ptr)
 #endif
 
 #if NRE_ENABLE_ASSERTS
 #define NRE_ASSERT(expr) assert((expr))
 #else
@@ -5040,13 +5088,13 @@
 #include "tclIntDecls.h"
 #include "tclIntPlatDecls.h"
 #include "tclTomMathDecls.h"
 
 #if !defined(USE_TCL_STUBS) && !defined(TCL_MEM_DEBUG)
-#define Tcl_AttemptAlloc        TclpAlloc
-#define Tcl_AttemptRealloc      TclpRealloc
-#define Tcl_Free                TclpFree
+#define Tcl_AttemptAlloc(size)        TclpAlloc(size)
+#define Tcl_AttemptRealloc(ptr, size) TclpRealloc((ptr), (size))
+#define Tcl_Free(ptr)                 TclpFree(ptr)
 #endif
 
 #endif /* _TCLINT */
 
 /*

Index: generic/tclIntDecls.h
==================================================================
--- generic/tclIntDecls.h
+++ generic/tclIntDecls.h
@@ -25,10 +25,27 @@
 #   else
 #      define TCL_STORAGE_CLASS DLLIMPORT
 #   endif
 #endif
 
+#if !defined(TCL_NO_DEPRECATED) && (TCL_MAJOR_VERSION < 9)
+#   define tclGetIntForIndex tcl_GetIntForIndex
+/* Those macro's are especially for Itcl 3.4 compatibility */
+#   define tclCreateNamespace tcl_CreateNamespace
+#   define tclDeleteNamespace tcl_DeleteNamespace
+#   define tclAppendExportList tcl_AppendExportList
+#   define tclExport tcl_Export
+#   define tclImport tcl_Import
+#   define tclForgetImport tcl_ForgetImport
+#   define tclGetCurrentNamespace_ tcl_GetCurrentNamespace
+#   define tclGetGlobalNamespace_ tcl_GetGlobalNamespace
+#   define tclFindNamespace tcl_FindNamespace
+#   define tclFindCommand tcl_FindCommand
+#   define tclGetCommandFromObj tcl_GetCommandFromObj
+#   define tclGetCommandFullName tcl_GetCommandFullName
+#endif /* !defined(TCL_NO_DEPRECATED) */
+
 /*
  * WARNING: This file is automatically generated by the tools/genStubs.tcl
  * script.  Any modifications to the function declarations below should be made
  * in the generic/tclInt.decls script.
  */
@@ -53,13 +70,17 @@
 EXTERN int		TclCleanupChildren(Tcl_Interp *interp, int numPids,
 				Tcl_Pid *pidPtr, Tcl_Channel errorChan);
 /* 6 */
 EXTERN void		TclCleanupCommand(Command *cmdPtr);
 /* 7 */
-EXTERN size_t		TclCopyAndCollapse(size_t count, const char *src,
+EXTERN int		TclCopyAndCollapse(int count, const char *src,
 				char *dst);
-/* Slot 8 is reserved */
+/* 8 */
+TCL_DEPRECATED("")
+int			TclCopyChannelOld(Tcl_Interp *interp,
+				Tcl_Channel inChan, Tcl_Channel outChan,
+				int toRead, Tcl_Obj *cmdPtr);
 /* 9 */
 EXTERN int		TclCreatePipeline(Tcl_Interp *interp, int argc,
 				const char **argv, Tcl_Pid **pidArrayPtr,
 				TclFile *inPipePtr, TclFile *outPipePtr,
 				TclFile *errFilePtr);
@@ -73,11 +94,11 @@
 /* 12 */
 EXTERN void		TclDeleteVars(Interp *iPtr,
 				TclVarHashTable *tablePtr);
 /* Slot 13 is reserved */
 /* 14 */
-EXTERN int		TclDumpMemoryInfo(void *clientData, int flags);
+EXTERN int		TclDumpMemoryInfo(ClientData clientData, int flags);
 /* Slot 15 is reserved */
 /* 16 */
 EXTERN void		TclExprFloatError(Tcl_Interp *interp, double value);
 /* Slot 17 is reserved */
 /* Slot 18 is reserved */
@@ -86,16 +107,16 @@
 /* Slot 21 is reserved */
 /* 22 */
 EXTERN int		TclFindElement(Tcl_Interp *interp,
 				const char *listStr, int listLength,
 				const char **elementPtr,
-				const char **nextPtr, size_t *sizePtr,
+				const char **nextPtr, int *sizePtr,
 				int *bracePtr);
 /* 23 */
 EXTERN Proc *		TclFindProc(Interp *iPtr, const char *procName);
 /* 24 */
-EXTERN size_t		TclFormatInt(char *buffer, Tcl_WideInt n);
+EXTERN int		TclFormatInt(char *buffer, Tcl_WideInt n);
 /* 25 */
 EXTERN void		TclFreePackageInfo(Interp *iPtr);
 /* Slot 26 is reserved */
 /* Slot 27 is reserved */
 /* 28 */
@@ -106,11 +127,14 @@
 EXTERN const char *	TclGetExtension(const char *name);
 /* 32 */
 EXTERN int		TclGetFrame(Tcl_Interp *interp, const char *str,
 				CallFrame **framePtrPtr);
 /* Slot 33 is reserved */
-/* Slot 34 is reserved */
+/* 34 */
+TCL_DEPRECATED("Use Tcl_GetIntForIndex")
+int			TclGetIntForIndex(Tcl_Interp *interp,
+				Tcl_Obj *objPtr, int endValue, int *indexPtr);
 /* Slot 35 is reserved */
 /* Slot 36 is reserved */
 /* 37 */
 EXTERN int		TclGetLoadedPackages(Tcl_Interp *interp,
 				const char *targetName);
@@ -127,11 +151,11 @@
 EXTERN int		TclGetOpenMode(Tcl_Interp *interp, const char *str,
 				int *seekFlagPtr);
 /* 41 */
 EXTERN Tcl_Command	TclGetOriginalCommand(Tcl_Command command);
 /* 42 */
-EXTERN const char *	TclpGetUserHome(const char *name,
+EXTERN CONST86 char *	TclpGetUserHome(const char *name,
 				Tcl_DString *bufferPtr);
 /* Slot 43 is reserved */
 /* 44 */
 EXTERN int		TclGuessPackageName(const char *fileName,
 				Tcl_DString *bufPtr);
@@ -147,15 +171,15 @@
 				CallFrame *framePtr, Namespace *nsPtr);
 /* 51 */
 EXTERN int		TclInterpInit(Tcl_Interp *interp);
 /* Slot 52 is reserved */
 /* 53 */
-EXTERN int		TclInvokeObjectCommand(void *clientData,
+EXTERN int		TclInvokeObjectCommand(ClientData clientData,
 				Tcl_Interp *interp, int argc,
 				const char **argv);
 /* 54 */
-EXTERN int		TclInvokeStringCommand(void *clientData,
+EXTERN int		TclInvokeStringCommand(ClientData clientData,
 				Tcl_Interp *interp, int objc,
 				Tcl_Obj *const objv[]);
 /* 55 */
 EXTERN Proc *		TclIsProc(Command *cmdPtr);
 /* Slot 56 is reserved */
@@ -171,11 +195,11 @@
 /* 61 */
 EXTERN Tcl_Obj *	TclNewProcBodyObj(Proc *procPtr);
 /* 62 */
 EXTERN int		TclObjCommandComplete(Tcl_Obj *cmdPtr);
 /* 63 */
-EXTERN int		TclObjInterpProc(void *clientData,
+EXTERN int		TclObjInterpProc(ClientData clientData,
 				Tcl_Interp *interp, int objc,
 				Tcl_Obj *const objv[]);
 /* 64 */
 EXTERN int		TclObjInvoke(Tcl_Interp *interp, int objc,
 				Tcl_Obj *const objv[], int flags);
@@ -182,34 +206,40 @@
 /* Slot 65 is reserved */
 /* Slot 66 is reserved */
 /* Slot 67 is reserved */
 /* Slot 68 is reserved */
 /* 69 */
-EXTERN void *		TclpAlloc(size_t size);
+EXTERN char *		TclpAlloc(unsigned int size);
 /* Slot 70 is reserved */
 /* Slot 71 is reserved */
 /* Slot 72 is reserved */
 /* Slot 73 is reserved */
 /* 74 */
-EXTERN void		TclpFree(void *ptr);
+EXTERN void		TclpFree(char *ptr);
 /* 75 */
-EXTERN Tcl_WideUInt	TclpGetClicks(void);
+EXTERN unsigned long	TclpGetClicks(void);
 /* 76 */
-EXTERN Tcl_WideUInt	TclpGetSeconds(void);
-/* Slot 77 is reserved */
+EXTERN unsigned long	TclpGetSeconds(void);
+/* 77 */
+TCL_DEPRECATED("")
+void			TclpGetTime(Tcl_Time *time);
 /* Slot 78 is reserved */
 /* Slot 79 is reserved */
 /* Slot 80 is reserved */
 /* 81 */
-EXTERN void *		TclpRealloc(void *ptr, size_t size);
+EXTERN char *		TclpRealloc(char *ptr, unsigned int size);
 /* Slot 82 is reserved */
 /* Slot 83 is reserved */
 /* Slot 84 is reserved */
 /* Slot 85 is reserved */
 /* Slot 86 is reserved */
 /* Slot 87 is reserved */
-/* Slot 88 is reserved */
+/* 88 */
+TCL_DEPRECATED("")
+char *			TclPrecTraceProc(ClientData clientData,
+				Tcl_Interp *interp, const char *name1,
+				const char *name2, int flags);
 /* 89 */
 EXTERN int		TclPreventAliasLoop(Tcl_Interp *interp,
 				Tcl_Interp *cmdInterp, Tcl_Command cmd);
 /* Slot 90 is reserved */
 /* 91 */
@@ -218,11 +248,11 @@
 EXTERN int		TclProcCompileProc(Tcl_Interp *interp, Proc *procPtr,
 				Tcl_Obj *bodyPtr, Namespace *nsPtr,
 				const char *description,
 				const char *procName);
 /* 93 */
-EXTERN void		TclProcDeleteProc(void *clientData);
+EXTERN void		TclProcDeleteProc(ClientData clientData);
 /* Slot 94 is reserved */
 /* Slot 95 is reserved */
 /* 96 */
 EXTERN int		TclRenameCommand(Tcl_Interp *interp,
 				const char *oldName, const char *newName);
@@ -232,17 +262,19 @@
 /* 98 */
 EXTERN int		TclServiceIdle(void);
 /* Slot 99 is reserved */
 /* Slot 100 is reserved */
 /* 101 */
-EXTERN const char *	TclSetPreInitScript(const char *string);
+EXTERN CONST86 char *	TclSetPreInitScript(const char *string);
 /* 102 */
 EXTERN void		TclSetupEnv(Tcl_Interp *interp);
 /* 103 */
 EXTERN int		TclSockGetPort(Tcl_Interp *interp, const char *str,
 				const char *proto, int *portPtr);
-/* Slot 104 is reserved */
+/* 104 */
+TCL_DEPRECATED("")
+int			TclSockMinimumBuffersOld(int sock, int size);
 /* Slot 105 is reserved */
 /* Slot 106 is reserved */
 /* Slot 107 is reserved */
 /* 108 */
 EXTERN void		TclTeardownNamespace(Namespace *nsPtr);
@@ -254,16 +286,29 @@
 EXTERN void		Tcl_AddInterpResolvers(Tcl_Interp *interp,
 				const char *name,
 				Tcl_ResolveCmdProc *cmdProc,
 				Tcl_ResolveVarProc *varProc,
 				Tcl_ResolveCompiledVarProc *compiledVarProc);
-/* Slot 112 is reserved */
-/* Slot 113 is reserved */
-/* Slot 114 is reserved */
-/* Slot 115 is reserved */
-/* Slot 116 is reserved */
-/* Slot 117 is reserved */
+/* 112 */
+EXTERN int		TclAppendExportList(Tcl_Interp *interp,
+				Tcl_Namespace *nsPtr, Tcl_Obj *objPtr);
+/* 113 */
+EXTERN Tcl_Namespace *	TclCreateNamespace(Tcl_Interp *interp,
+				const char *name, ClientData clientData,
+				Tcl_NamespaceDeleteProc *deleteProc);
+/* 114 */
+EXTERN void		TclDeleteNamespace(Tcl_Namespace *nsPtr);
+/* 115 */
+EXTERN int		TclExport(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
+				const char *pattern, int resetListFirst);
+/* 116 */
+EXTERN Tcl_Command	TclFindCommand(Tcl_Interp *interp, const char *name,
+				Tcl_Namespace *contextNsPtr, int flags);
+/* 117 */
+EXTERN Tcl_Namespace *	TclFindNamespace(Tcl_Interp *interp,
+				const char *name,
+				Tcl_Namespace *contextNsPtr, int flags);
 /* 118 */
 EXTERN int		Tcl_GetInterpResolvers(Tcl_Interp *interp,
 				const char *name, Tcl_ResolverInfo *resInfo);
 /* 119 */
 EXTERN int		Tcl_GetNamespaceResolvers(
@@ -271,19 +316,29 @@
 				Tcl_ResolverInfo *resInfo);
 /* 120 */
 EXTERN Tcl_Var		Tcl_FindNamespaceVar(Tcl_Interp *interp,
 				const char *name,
 				Tcl_Namespace *contextNsPtr, int flags);
-/* Slot 121 is reserved */
-/* Slot 122 is reserved */
-/* Slot 123 is reserved */
-/* Slot 124 is reserved */
-/* Slot 125 is reserved */
+/* 121 */
+EXTERN int		TclForgetImport(Tcl_Interp *interp,
+				Tcl_Namespace *nsPtr, const char *pattern);
+/* 122 */
+EXTERN Tcl_Command	TclGetCommandFromObj(Tcl_Interp *interp,
+				Tcl_Obj *objPtr);
+/* 123 */
+EXTERN void		TclGetCommandFullName(Tcl_Interp *interp,
+				Tcl_Command command, Tcl_Obj *objPtr);
+/* 124 */
+EXTERN Tcl_Namespace *	TclGetCurrentNamespace_(Tcl_Interp *interp);
+/* 125 */
+EXTERN Tcl_Namespace *	TclGetGlobalNamespace_(Tcl_Interp *interp);
 /* 126 */
 EXTERN void		Tcl_GetVariableFullName(Tcl_Interp *interp,
 				Tcl_Var variable, Tcl_Obj *objPtr);
-/* Slot 127 is reserved */
+/* 127 */
+EXTERN int		TclImport(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
+				const char *pattern, int allowOverwrite);
 /* 128 */
 EXTERN void		Tcl_PopCallFrame(Tcl_Interp *interp);
 /* 129 */
 EXTERN int		Tcl_PushCallFrame(Tcl_Interp *interp,
 				Tcl_CallFrame *framePtr,
@@ -297,11 +352,13 @@
 				Tcl_ResolveCmdProc *cmdProc,
 				Tcl_ResolveVarProc *varProc,
 				Tcl_ResolveCompiledVarProc *compiledVarProc);
 /* 132 */
 EXTERN int		TclpHasSockets(Tcl_Interp *interp);
-/* Slot 133 is reserved */
+/* 133 */
+TCL_DEPRECATED("")
+struct tm *		TclpGetDate(const time_t *time, int useGMT);
 /* Slot 134 is reserved */
 /* Slot 135 is reserved */
 /* Slot 136 is reserved */
 /* Slot 137 is reserved */
 /* 138 */
@@ -311,11 +368,11 @@
 /* 141 */
 EXTERN const char *	TclpGetCwd(Tcl_Interp *interp, Tcl_DString *cwdPtr);
 /* 142 */
 EXTERN int		TclSetByteCodeFromAny(Tcl_Interp *interp,
 				Tcl_Obj *objPtr, CompileHookProc *hookProc,
-				void *clientData);
+				ClientData clientData);
 /* 143 */
 EXTERN int		TclAddLiteralObj(struct CompileEnv *envPtr,
 				Tcl_Obj *objPtr, LiteralEntry **litPtrPtr);
 /* 144 */
 EXTERN void		TclHideLiteral(Tcl_Interp *interp,
@@ -331,12 +388,12 @@
 /* 149 */
 EXTERN void		TclHandleRelease(TclHandle handle);
 /* 150 */
 EXTERN int		TclRegAbout(Tcl_Interp *interp, Tcl_RegExp re);
 /* 151 */
-EXTERN void		TclRegExpRangeUniChar(Tcl_RegExp re, size_t index,
-				size_t *startPtr, size_t *endPtr);
+EXTERN void		TclRegExpRangeUniChar(Tcl_RegExp re, int index,
+				int *startPtr, int *endPtr);
 /* 152 */
 EXTERN void		TclSetLibraryPath(Tcl_Obj *pathPtr);
 /* 153 */
 EXTERN Tcl_Obj *	TclGetLibraryPath(void);
 /* Slot 154 is reserved */
@@ -345,18 +402,22 @@
 EXTERN void		TclRegError(Tcl_Interp *interp, const char *msg,
 				int status);
 /* 157 */
 EXTERN Var *		TclVarTraceExists(Tcl_Interp *interp,
 				const char *varName);
-/* Slot 158 is reserved */
-/* Slot 159 is reserved */
+/* 158 */
+TCL_DEPRECATED("use public Tcl_SetStartupScript()")
+void			TclSetStartupScriptFileName(const char *filename);
+/* 159 */
+TCL_DEPRECATED("use public Tcl_GetStartupScript()")
+const char *		TclGetStartupScriptFileName(void);
 /* Slot 160 is reserved */
 /* 161 */
 EXTERN int		TclChannelTransform(Tcl_Interp *interp,
 				Tcl_Channel chan, Tcl_Obj *cmdObjPtr);
 /* 162 */
-EXTERN void		TclChannelEventScriptInvoker(void *clientData,
+EXTERN void		TclChannelEventScriptInvoker(ClientData clientData,
 				int flags);
 /* 163 */
 EXTERN const void *	TclGetInstructionTable(void);
 /* 164 */
 EXTERN void		TclExpandCodeArray(void *envPtr);
@@ -364,31 +425,35 @@
 EXTERN void		TclpSetInitialEncodings(void);
 /* 166 */
 EXTERN int		TclListObjSetElement(Tcl_Interp *interp,
 				Tcl_Obj *listPtr, int index,
 				Tcl_Obj *valuePtr);
-/* Slot 167 is reserved */
-/* Slot 168 is reserved */
+/* 167 */
+TCL_DEPRECATED("use public Tcl_SetStartupScript()")
+void			TclSetStartupScriptPath(Tcl_Obj *pathPtr);
+/* 168 */
+TCL_DEPRECATED("use public Tcl_GetStartupScript()")
+Tcl_Obj *		TclGetStartupScriptPath(void);
 /* 169 */
 EXTERN int		TclpUtfNcmp2(const char *s1, const char *s2,
-				size_t n);
+				unsigned long n);
 /* 170 */
 EXTERN int		TclCheckInterpTraces(Tcl_Interp *interp,
-				const char *command, size_t numChars,
+				const char *command, int numChars,
 				Command *cmdPtr, int result, int traceFlags,
 				int objc, Tcl_Obj *const objv[]);
 /* 171 */
 EXTERN int		TclCheckExecutionTraces(Tcl_Interp *interp,
-				const char *command, size_t numChars,
+				const char *command, int numChars,
 				Command *cmdPtr, int result, int traceFlags,
 				int objc, Tcl_Obj *const objv[]);
 /* 172 */
 EXTERN int		TclInThreadExit(void);
 /* 173 */
 EXTERN int		TclUniCharMatch(const Tcl_UniChar *string,
-				size_t strLen, const Tcl_UniChar *pattern,
-				size_t ptnLen, int flags);
+				int strLen, const Tcl_UniChar *pattern,
+				int ptnLen, int flags);
 /* Slot 174 is reserved */
 /* 175 */
 EXTERN int		TclCallVarTraces(Interp *iPtr, Var *arrayPtr,
 				Var *varPtr, const char *part1,
 				const char *part2, int flags,
@@ -397,16 +462,23 @@
 EXTERN void		TclCleanupVar(Var *varPtr, Var *arrayPtr);
 /* 177 */
 EXTERN void		TclVarErrMsg(Tcl_Interp *interp, const char *part1,
 				const char *part2, const char *operation,
 				const char *reason);
-/* Slot 178 is reserved */
-/* Slot 179 is reserved */
+/* 178 */
+EXTERN void		TclSetStartupScript(Tcl_Obj *pathPtr,
+				const char *encodingName);
+/* 179 */
+EXTERN Tcl_Obj *	TclGetStartupScript(const char **encodingNamePtr);
 /* Slot 180 is reserved */
 /* Slot 181 is reserved */
-/* Slot 182 is reserved */
-/* Slot 183 is reserved */
+/* 182 */
+TCL_DEPRECATED("")
+struct tm *		TclpLocaltime(const time_t *clock);
+/* 183 */
+TCL_DEPRECATED("")
+struct tm *		TclpGmtime(const time_t *clock);
 /* Slot 184 is reserved */
 /* Slot 185 is reserved */
 /* Slot 186 is reserved */
 /* Slot 187 is reserved */
 /* Slot 188 is reserved */
@@ -455,11 +527,11 @@
 EXTERN Tcl_Obj *	TclGetObjNameOfExecutable(void);
 /* 214 */
 EXTERN void		TclSetObjNameOfExecutable(Tcl_Obj *name,
 				Tcl_Encoding encoding);
 /* 215 */
-EXTERN void *		TclStackAlloc(Tcl_Interp *interp, size_t numBytes);
+EXTERN void *		TclStackAlloc(Tcl_Interp *interp, int numBytes);
 /* 216 */
 EXTERN void		TclStackFree(Tcl_Interp *interp, void *freePtr);
 /* 217 */
 EXTERN int		TclPushStackFrame(Tcl_Interp *interp,
 				Tcl_CallFrame **framePtrPtr,
@@ -479,11 +551,11 @@
 				Tcl_Obj *rootPtr, int keyc,
 				Tcl_Obj *const keyv[], int flags);
 /* 226 */
 EXTERN int		TclObjBeingDeleted(Tcl_Obj *objPtr);
 /* 227 */
-EXTERN void		TclSetNsPath(Namespace *nsPtr, size_t pathLength,
+EXTERN void		TclSetNsPath(Namespace *nsPtr, int pathLength,
 				Tcl_Namespace *pathAry[]);
 /* Slot 228 is reserved */
 /* 229 */
 EXTERN int		TclPtrMakeUpvar(Tcl_Interp *interp, Var *otherP1Ptr,
 				const char *myName, int myFlags, int index);
@@ -505,16 +577,19 @@
 EXTERN Var *		TclVarHashCreateVar(TclVarHashTable *tablePtr,
 				const char *key, int *newPtr);
 /* 235 */
 EXTERN void		TclInitVarHashTable(TclVarHashTable *tablePtr,
 				Namespace *nsPtr);
-/* Slot 236 is reserved */
+/* 236 */
+TCL_DEPRECATED("use Tcl_BackgroundException")
+void			TclBackgroundException(Tcl_Interp *interp, int code);
 /* 237 */
 EXTERN int		TclResetCancellation(Tcl_Interp *interp, int force);
 /* 238 */
-EXTERN int		TclNRInterpProc(void *clientData, Tcl_Interp *interp,
-				int objc, Tcl_Obj *const objv[]);
+EXTERN int		TclNRInterpProc(ClientData clientData,
+				Tcl_Interp *interp, int objc,
+				Tcl_Obj *const objv[]);
 /* 239 */
 EXTERN int		TclNRInterpProcCore(Tcl_Interp *interp,
 				Tcl_Obj *procNameObj, int skip,
 				ProcErrorProc *errorProc);
 /* 240 */
@@ -533,11 +608,11 @@
 EXTERN Tcl_HashTable *	TclGetNamespaceChildTable(Tcl_Namespace *nsPtr);
 /* 245 */
 EXTERN Tcl_HashTable *	TclGetNamespaceCommandTable(Tcl_Namespace *nsPtr);
 /* 246 */
 EXTERN int		TclInitRewriteEnsemble(Tcl_Interp *interp,
-				size_t numRemoved, size_t numInserted,
+				int numRemoved, int numInserted,
 				Tcl_Obj *const *objv);
 /* 247 */
 EXTERN void		TclResetRewriteEnsemble(Tcl_Interp *interp,
 				int isRootEnsemble);
 /* 248 */
@@ -550,11 +625,11 @@
 /* 250 */
 EXTERN void		TclSetSlaveCancelFlags(Tcl_Interp *interp, int flags,
 				int force);
 /* 251 */
 EXTERN int		TclRegisterLiteral(void *envPtr, const char *bytes,
-				size_t length, int flags);
+				int length, int flags);
 /* 252 */
 EXTERN Tcl_Obj *	TclPtrGetVar(Tcl_Interp *interp, Tcl_Var varPtr,
 				Tcl_Var arrayPtr, Tcl_Obj *part1Ptr,
 				Tcl_Obj *part2Ptr, const int flags);
 /* 253 */
@@ -593,46 +668,46 @@
     void (*reserved2)(void);
     void (*tclAllocateFreeObjects) (void); /* 3 */
     void (*reserved4)(void);
     int (*tclCleanupChildren) (Tcl_Interp *interp, int numPids, Tcl_Pid *pidPtr, Tcl_Channel errorChan); /* 5 */
     void (*tclCleanupCommand) (Command *cmdPtr); /* 6 */
-    size_t (*tclCopyAndCollapse) (size_t count, const char *src, char *dst); /* 7 */
-    void (*reserved8)(void);
+    int (*tclCopyAndCollapse) (int count, const char *src, char *dst); /* 7 */
+    TCL_DEPRECATED_API("") int (*tclCopyChannelOld) (Tcl_Interp *interp, Tcl_Channel inChan, Tcl_Channel outChan, int toRead, Tcl_Obj *cmdPtr); /* 8 */
     int (*tclCreatePipeline) (Tcl_Interp *interp, int argc, const char **argv, Tcl_Pid **pidArrayPtr, TclFile *inPipePtr, TclFile *outPipePtr, TclFile *errFilePtr); /* 9 */
     int (*tclCreateProc) (Tcl_Interp *interp, Namespace *nsPtr, const char *procName, Tcl_Obj *argsPtr, Tcl_Obj *bodyPtr, Proc **procPtrPtr); /* 10 */
     void (*tclDeleteCompiledLocalVars) (Interp *iPtr, CallFrame *framePtr); /* 11 */
     void (*tclDeleteVars) (Interp *iPtr, TclVarHashTable *tablePtr); /* 12 */
     void (*reserved13)(void);
-    int (*tclDumpMemoryInfo) (void *clientData, int flags); /* 14 */
+    int (*tclDumpMemoryInfo) (ClientData clientData, int flags); /* 14 */
     void (*reserved15)(void);
     void (*tclExprFloatError) (Tcl_Interp *interp, double value); /* 16 */
     void (*reserved17)(void);
     void (*reserved18)(void);
     void (*reserved19)(void);
     void (*reserved20)(void);
     void (*reserved21)(void);
-    int (*tclFindElement) (Tcl_Interp *interp, const char *listStr, int listLength, const char **elementPtr, const char **nextPtr, size_t *sizePtr, int *bracePtr); /* 22 */
+    int (*tclFindElement) (Tcl_Interp *interp, const char *listStr, int listLength, const char **elementPtr, const char **nextPtr, int *sizePtr, int *bracePtr); /* 22 */
     Proc * (*tclFindProc) (Interp *iPtr, const char *procName); /* 23 */
-    size_t (*tclFormatInt) (char *buffer, Tcl_WideInt n); /* 24 */
+    int (*tclFormatInt) (char *buffer, Tcl_WideInt n); /* 24 */
     void (*tclFreePackageInfo) (Interp *iPtr); /* 25 */
     void (*reserved26)(void);
     void (*reserved27)(void);
     Tcl_Channel (*tclpGetDefaultStdChannel) (int type); /* 28 */
     void (*reserved29)(void);
     void (*reserved30)(void);
     const char * (*tclGetExtension) (const char *name); /* 31 */
     int (*tclGetFrame) (Tcl_Interp *interp, const char *str, CallFrame **framePtrPtr); /* 32 */
     void (*reserved33)(void);
-    void (*reserved34)(void);
+    TCL_DEPRECATED_API("Use Tcl_GetIntForIndex") int (*tclGetIntForIndex) (Tcl_Interp *interp, Tcl_Obj *objPtr, int endValue, int *indexPtr); /* 34 */
     void (*reserved35)(void);
     void (*reserved36)(void);
     int (*tclGetLoadedPackages) (Tcl_Interp *interp, const char *targetName); /* 37 */
     int (*tclGetNamespaceForQualName) (Tcl_Interp *interp, const char *qualName, Namespace *cxtNsPtr, int flags, Namespace **nsPtrPtr, Namespace **altNsPtrPtr, Namespace **actualCxtPtrPtr, const char **simpleNamePtr); /* 38 */
     TclObjCmdProcType (*tclGetObjInterpProc) (void); /* 39 */
     int (*tclGetOpenMode) (Tcl_Interp *interp, const char *str, int *seekFlagPtr); /* 40 */
     Tcl_Command (*tclGetOriginalCommand) (Tcl_Command command); /* 41 */
-    const char * (*tclpGetUserHome) (const char *name, Tcl_DString *bufferPtr); /* 42 */
+    CONST86 char * (*tclpGetUserHome) (const char *name, Tcl_DString *bufferPtr); /* 42 */
     void (*reserved43)(void);
     int (*tclGuessPackageName) (const char *fileName, Tcl_DString *bufPtr); /* 44 */
     int (*tclHideUnsafeCommands) (Tcl_Interp *interp); /* 45 */
     int (*tclInExit) (void); /* 46 */
     void (*reserved47)(void);
@@ -639,141 +714,141 @@
     void (*reserved48)(void);
     void (*reserved49)(void);
     void (*tclInitCompiledLocals) (Tcl_Interp *interp, CallFrame *framePtr, Namespace *nsPtr); /* 50 */
     int (*tclInterpInit) (Tcl_Interp *interp); /* 51 */
     void (*reserved52)(void);
-    int (*tclInvokeObjectCommand) (void *clientData, Tcl_Interp *interp, int argc, const char **argv); /* 53 */
-    int (*tclInvokeStringCommand) (void *clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]); /* 54 */
+    int (*tclInvokeObjectCommand) (ClientData clientData, Tcl_Interp *interp, int argc, const char **argv); /* 53 */
+    int (*tclInvokeStringCommand) (ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]); /* 54 */
     Proc * (*tclIsProc) (Command *cmdPtr); /* 55 */
     void (*reserved56)(void);
     void (*reserved57)(void);
     Var * (*tclLookupVar) (Tcl_Interp *interp, const char *part1, const char *part2, int flags, const char *msg, int createPart1, int createPart2, Var **arrayPtrPtr); /* 58 */
     void (*reserved59)(void);
     int (*tclNeedSpace) (const char *start, const char *end); /* 60 */
     Tcl_Obj * (*tclNewProcBodyObj) (Proc *procPtr); /* 61 */
     int (*tclObjCommandComplete) (Tcl_Obj *cmdPtr); /* 62 */
-    int (*tclObjInterpProc) (void *clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]); /* 63 */
+    int (*tclObjInterpProc) (ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]); /* 63 */
     int (*tclObjInvoke) (Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], int flags); /* 64 */
     void (*reserved65)(void);
     void (*reserved66)(void);
     void (*reserved67)(void);
     void (*reserved68)(void);
-    void * (*tclpAlloc) (size_t size); /* 69 */
+    char * (*tclpAlloc) (unsigned int size); /* 69 */
     void (*reserved70)(void);
     void (*reserved71)(void);
     void (*reserved72)(void);
     void (*reserved73)(void);
-    void (*tclpFree) (void *ptr); /* 74 */
-    Tcl_WideUInt (*tclpGetClicks) (void); /* 75 */
-    Tcl_WideUInt (*tclpGetSeconds) (void); /* 76 */
-    void (*reserved77)(void);
+    void (*tclpFree) (char *ptr); /* 74 */
+    unsigned long (*tclpGetClicks) (void); /* 75 */
+    unsigned long (*tclpGetSeconds) (void); /* 76 */
+    TCL_DEPRECATED_API("") void (*tclpGetTime) (Tcl_Time *time); /* 77 */
     void (*reserved78)(void);
     void (*reserved79)(void);
     void (*reserved80)(void);
-    void * (*tclpRealloc) (void *ptr, size_t size); /* 81 */
+    char * (*tclpRealloc) (char *ptr, unsigned int size); /* 81 */
     void (*reserved82)(void);
     void (*reserved83)(void);
     void (*reserved84)(void);
     void (*reserved85)(void);
     void (*reserved86)(void);
     void (*reserved87)(void);
-    void (*reserved88)(void);
+    TCL_DEPRECATED_API("") char * (*tclPrecTraceProc) (ClientData clientData, Tcl_Interp *interp, const char *name1, const char *name2, int flags); /* 88 */
     int (*tclPreventAliasLoop) (Tcl_Interp *interp, Tcl_Interp *cmdInterp, Tcl_Command cmd); /* 89 */
     void (*reserved90)(void);
     void (*tclProcCleanupProc) (Proc *procPtr); /* 91 */
     int (*tclProcCompileProc) (Tcl_Interp *interp, Proc *procPtr, Tcl_Obj *bodyPtr, Namespace *nsPtr, const char *description, const char *procName); /* 92 */
-    void (*tclProcDeleteProc) (void *clientData); /* 93 */
+    void (*tclProcDeleteProc) (ClientData clientData); /* 93 */
     void (*reserved94)(void);
     void (*reserved95)(void);
     int (*tclRenameCommand) (Tcl_Interp *interp, const char *oldName, const char *newName); /* 96 */
     void (*tclResetShadowedCmdRefs) (Tcl_Interp *interp, Command *newCmdPtr); /* 97 */
     int (*tclServiceIdle) (void); /* 98 */
     void (*reserved99)(void);
     void (*reserved100)(void);
-    const char * (*tclSetPreInitScript) (const char *string); /* 101 */
+    CONST86 char * (*tclSetPreInitScript) (const char *string); /* 101 */
     void (*tclSetupEnv) (Tcl_Interp *interp); /* 102 */
     int (*tclSockGetPort) (Tcl_Interp *interp, const char *str, const char *proto, int *portPtr); /* 103 */
-    void (*reserved104)(void);
+    TCL_DEPRECATED_API("") int (*tclSockMinimumBuffersOld) (int sock, int size); /* 104 */
     void (*reserved105)(void);
     void (*reserved106)(void);
     void (*reserved107)(void);
     void (*tclTeardownNamespace) (Namespace *nsPtr); /* 108 */
     int (*tclUpdateReturnInfo) (Interp *iPtr); /* 109 */
     int (*tclSockMinimumBuffers) (void *sock, int size); /* 110 */
     void (*tcl_AddInterpResolvers) (Tcl_Interp *interp, const char *name, Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc, Tcl_ResolveCompiledVarProc *compiledVarProc); /* 111 */
-    void (*reserved112)(void);
-    void (*reserved113)(void);
-    void (*reserved114)(void);
-    void (*reserved115)(void);
-    void (*reserved116)(void);
-    void (*reserved117)(void);
+    int (*tclAppendExportList) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, Tcl_Obj *objPtr); /* 112 */
+    Tcl_Namespace * (*tclCreateNamespace) (Tcl_Interp *interp, const char *name, ClientData clientData, Tcl_NamespaceDeleteProc *deleteProc); /* 113 */
+    void (*tclDeleteNamespace) (Tcl_Namespace *nsPtr); /* 114 */
+    int (*tclExport) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, const char *pattern, int resetListFirst); /* 115 */
+    Tcl_Command (*tclFindCommand) (Tcl_Interp *interp, const char *name, Tcl_Namespace *contextNsPtr, int flags); /* 116 */
+    Tcl_Namespace * (*tclFindNamespace) (Tcl_Interp *interp, const char *name, Tcl_Namespace *contextNsPtr, int flags); /* 117 */
     int (*tcl_GetInterpResolvers) (Tcl_Interp *interp, const char *name, Tcl_ResolverInfo *resInfo); /* 118 */
     int (*tcl_GetNamespaceResolvers) (Tcl_Namespace *namespacePtr, Tcl_ResolverInfo *resInfo); /* 119 */
     Tcl_Var (*tcl_FindNamespaceVar) (Tcl_Interp *interp, const char *name, Tcl_Namespace *contextNsPtr, int flags); /* 120 */
-    void (*reserved121)(void);
-    void (*reserved122)(void);
-    void (*reserved123)(void);
-    void (*reserved124)(void);
-    void (*reserved125)(void);
+    int (*tclForgetImport) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, const char *pattern); /* 121 */
+    Tcl_Command (*tclGetCommandFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 122 */
+    void (*tclGetCommandFullName) (Tcl_Interp *interp, Tcl_Command command, Tcl_Obj *objPtr); /* 123 */
+    Tcl_Namespace * (*tclGetCurrentNamespace_) (Tcl_Interp *interp); /* 124 */
+    Tcl_Namespace * (*tclGetGlobalNamespace_) (Tcl_Interp *interp); /* 125 */
     void (*tcl_GetVariableFullName) (Tcl_Interp *interp, Tcl_Var variable, Tcl_Obj *objPtr); /* 126 */
-    void (*reserved127)(void);
+    int (*tclImport) (Tcl_Interp *interp, Tcl_Namespace *nsPtr, const char *pattern, int allowOverwrite); /* 127 */
     void (*tcl_PopCallFrame) (Tcl_Interp *interp); /* 128 */
     int (*tcl_PushCallFrame) (Tcl_Interp *interp, Tcl_CallFrame *framePtr, Tcl_Namespace *nsPtr, int isProcCallFrame); /* 129 */
     int (*tcl_RemoveInterpResolvers) (Tcl_Interp *interp, const char *name); /* 130 */
     void (*tcl_SetNamespaceResolvers) (Tcl_Namespace *namespacePtr, Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc, Tcl_ResolveCompiledVarProc *compiledVarProc); /* 131 */
     int (*tclpHasSockets) (Tcl_Interp *interp); /* 132 */
-    void (*reserved133)(void);
+    TCL_DEPRECATED_API("") struct tm * (*tclpGetDate) (const time_t *time, int useGMT); /* 133 */
     void (*reserved134)(void);
     void (*reserved135)(void);
     void (*reserved136)(void);
     void (*reserved137)(void);
     const char * (*tclGetEnv) (const char *name, Tcl_DString *valuePtr); /* 138 */
     void (*reserved139)(void);
     void (*reserved140)(void);
     const char * (*tclpGetCwd) (Tcl_Interp *interp, Tcl_DString *cwdPtr); /* 141 */
-    int (*tclSetByteCodeFromAny) (Tcl_Interp *interp, Tcl_Obj *objPtr, CompileHookProc *hookProc, void *clientData); /* 142 */
+    int (*tclSetByteCodeFromAny) (Tcl_Interp *interp, Tcl_Obj *objPtr, CompileHookProc *hookProc, ClientData clientData); /* 142 */
     int (*tclAddLiteralObj) (struct CompileEnv *envPtr, Tcl_Obj *objPtr, LiteralEntry **litPtrPtr); /* 143 */
     void (*tclHideLiteral) (Tcl_Interp *interp, struct CompileEnv *envPtr, int index); /* 144 */
     const struct AuxDataType * (*tclGetAuxDataType) (const char *typeName); /* 145 */
     TclHandle (*tclHandleCreate) (void *ptr); /* 146 */
     void (*tclHandleFree) (TclHandle handle); /* 147 */
     TclHandle (*tclHandlePreserve) (TclHandle handle); /* 148 */
     void (*tclHandleRelease) (TclHandle handle); /* 149 */
     int (*tclRegAbout) (Tcl_Interp *interp, Tcl_RegExp re); /* 150 */
-    void (*tclRegExpRangeUniChar) (Tcl_RegExp re, size_t index, size_t *startPtr, size_t *endPtr); /* 151 */
+    void (*tclRegExpRangeUniChar) (Tcl_RegExp re, int index, int *startPtr, int *endPtr); /* 151 */
     void (*tclSetLibraryPath) (Tcl_Obj *pathPtr); /* 152 */
     Tcl_Obj * (*tclGetLibraryPath) (void); /* 153 */
     void (*reserved154)(void);
     void (*reserved155)(void);
     void (*tclRegError) (Tcl_Interp *interp, const char *msg, int status); /* 156 */
     Var * (*tclVarTraceExists) (Tcl_Interp *interp, const char *varName); /* 157 */
-    void (*reserved158)(void);
-    void (*reserved159)(void);
+    TCL_DEPRECATED_API("use public Tcl_SetStartupScript()") void (*tclSetStartupScriptFileName) (const char *filename); /* 158 */
+    TCL_DEPRECATED_API("use public Tcl_GetStartupScript()") const char * (*tclGetStartupScriptFileName) (void); /* 159 */
     void (*reserved160)(void);
     int (*tclChannelTransform) (Tcl_Interp *interp, Tcl_Channel chan, Tcl_Obj *cmdObjPtr); /* 161 */
-    void (*tclChannelEventScriptInvoker) (void *clientData, int flags); /* 162 */
+    void (*tclChannelEventScriptInvoker) (ClientData clientData, int flags); /* 162 */
     const void * (*tclGetInstructionTable) (void); /* 163 */
     void (*tclExpandCodeArray) (void *envPtr); /* 164 */
     void (*tclpSetInitialEncodings) (void); /* 165 */
     int (*tclListObjSetElement) (Tcl_Interp *interp, Tcl_Obj *listPtr, int index, Tcl_Obj *valuePtr); /* 166 */
-    void (*reserved167)(void);
-    void (*reserved168)(void);
-    int (*tclpUtfNcmp2) (const char *s1, const char *s2, size_t n); /* 169 */
-    int (*tclCheckInterpTraces) (Tcl_Interp *interp, const char *command, size_t numChars, Command *cmdPtr, int result, int traceFlags, int objc, Tcl_Obj *const objv[]); /* 170 */
-    int (*tclCheckExecutionTraces) (Tcl_Interp *interp, const char *command, size_t numChars, Command *cmdPtr, int result, int traceFlags, int objc, Tcl_Obj *const objv[]); /* 171 */
+    TCL_DEPRECATED_API("use public Tcl_SetStartupScript()") void (*tclSetStartupScriptPath) (Tcl_Obj *pathPtr); /* 167 */
+    TCL_DEPRECATED_API("use public Tcl_GetStartupScript()") Tcl_Obj * (*tclGetStartupScriptPath) (void); /* 168 */
+    int (*tclpUtfNcmp2) (const char *s1, const char *s2, unsigned long n); /* 169 */
+    int (*tclCheckInterpTraces) (Tcl_Interp *interp, const char *command, int numChars, Command *cmdPtr, int result, int traceFlags, int objc, Tcl_Obj *const objv[]); /* 170 */
+    int (*tclCheckExecutionTraces) (Tcl_Interp *interp, const char *command, int numChars, Command *cmdPtr, int result, int traceFlags, int objc, Tcl_Obj *const objv[]); /* 171 */
     int (*tclInThreadExit) (void); /* 172 */
-    int (*tclUniCharMatch) (const Tcl_UniChar *string, size_t strLen, const Tcl_UniChar *pattern, size_t ptnLen, int flags); /* 173 */
+    int (*tclUniCharMatch) (const Tcl_UniChar *string, int strLen, const Tcl_UniChar *pattern, int ptnLen, int flags); /* 173 */
     void (*reserved174)(void);
     int (*tclCallVarTraces) (Interp *iPtr, Var *arrayPtr, Var *varPtr, const char *part1, const char *part2, int flags, int leaveErrMsg); /* 175 */
     void (*tclCleanupVar) (Var *varPtr, Var *arrayPtr); /* 176 */
     void (*tclVarErrMsg) (Tcl_Interp *interp, const char *part1, const char *part2, const char *operation, const char *reason); /* 177 */
-    void (*reserved178)(void);
-    void (*reserved179)(void);
+    void (*tclSetStartupScript) (Tcl_Obj *pathPtr, const char *encodingName); /* 178 */
+    Tcl_Obj * (*tclGetStartupScript) (const char **encodingNamePtr); /* 179 */
     void (*reserved180)(void);
     void (*reserved181)(void);
-    void (*reserved182)(void);
-    void (*reserved183)(void);
+    TCL_DEPRECATED_API("") struct tm * (*tclpLocaltime) (const time_t *clock); /* 182 */
+    TCL_DEPRECATED_API("") struct tm * (*tclpGmtime) (const time_t *clock); /* 183 */
     void (*reserved184)(void);
     void (*reserved185)(void);
     void (*reserved186)(void);
     void (*reserved187)(void);
     void (*reserved188)(void);
@@ -801,11 +876,11 @@
     void (*reserved210)(void);
     void (*reserved211)(void);
     void (*tclpFindExecutable) (const char *argv0); /* 212 */
     Tcl_Obj * (*tclGetObjNameOfExecutable) (void); /* 213 */
     void (*tclSetObjNameOfExecutable) (Tcl_Obj *name, Tcl_Encoding encoding); /* 214 */
-    void * (*tclStackAlloc) (Tcl_Interp *interp, size_t numBytes); /* 215 */
+    void * (*tclStackAlloc) (Tcl_Interp *interp, int numBytes); /* 215 */
     void (*tclStackFree) (Tcl_Interp *interp, void *freePtr); /* 216 */
     int (*tclPushStackFrame) (Tcl_Interp *interp, Tcl_CallFrame **framePtrPtr, Tcl_Namespace *namespacePtr, int isProcCallFrame); /* 217 */
     void (*tclPopStackFrame) (Tcl_Interp *interp); /* 218 */
     void (*reserved219)(void);
     void (*reserved220)(void);
@@ -813,35 +888,35 @@
     void (*reserved222)(void);
     void (*reserved223)(void);
     TclPlatformType * (*tclGetPlatform) (void); /* 224 */
     Tcl_Obj * (*tclTraceDictPath) (Tcl_Interp *interp, Tcl_Obj *rootPtr, int keyc, Tcl_Obj *const keyv[], int flags); /* 225 */
     int (*tclObjBeingDeleted) (Tcl_Obj *objPtr); /* 226 */
-    void (*tclSetNsPath) (Namespace *nsPtr, size_t pathLength, Tcl_Namespace *pathAry[]); /* 227 */
+    void (*tclSetNsPath) (Namespace *nsPtr, int pathLength, Tcl_Namespace *pathAry[]); /* 227 */
     void (*reserved228)(void);
     int (*tclPtrMakeUpvar) (Tcl_Interp *interp, Var *otherP1Ptr, const char *myName, int myFlags, int index); /* 229 */
     Var * (*tclObjLookupVar) (Tcl_Interp *interp, Tcl_Obj *part1Ptr, const char *part2, int flags, const char *msg, const int createPart1, const int createPart2, Var **arrayPtrPtr); /* 230 */
     int (*tclGetNamespaceFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr, Tcl_Namespace **nsPtrPtr); /* 231 */
     int (*tclEvalObjEx) (Tcl_Interp *interp, Tcl_Obj *objPtr, int flags, const CmdFrame *invoker, int word); /* 232 */
     void (*tclGetSrcInfoForPc) (CmdFrame *contextPtr); /* 233 */
     Var * (*tclVarHashCreateVar) (TclVarHashTable *tablePtr, const char *key, int *newPtr); /* 234 */
     void (*tclInitVarHashTable) (TclVarHashTable *tablePtr, Namespace *nsPtr); /* 235 */
-    void (*reserved236)(void);
+    TCL_DEPRECATED_API("use Tcl_BackgroundException") void (*tclBackgroundException) (Tcl_Interp *interp, int code); /* 236 */
     int (*tclResetCancellation) (Tcl_Interp *interp, int force); /* 237 */
-    int (*tclNRInterpProc) (void *clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]); /* 238 */
+    int (*tclNRInterpProc) (ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]); /* 238 */
     int (*tclNRInterpProcCore) (Tcl_Interp *interp, Tcl_Obj *procNameObj, int skip, ProcErrorProc *errorProc); /* 239 */
     int (*tclNRRunCallbacks) (Tcl_Interp *interp, int result, struct NRE_callback *rootPtr); /* 240 */
     int (*tclNREvalObjEx) (Tcl_Interp *interp, Tcl_Obj *objPtr, int flags, const CmdFrame *invoker, int word); /* 241 */
     int (*tclNREvalObjv) (Tcl_Interp *interp, int objc, Tcl_Obj *const objv[], int flags, Command *cmdPtr); /* 242 */
     void (*tclDbDumpActiveObjects) (FILE *outFile); /* 243 */
     Tcl_HashTable * (*tclGetNamespaceChildTable) (Tcl_Namespace *nsPtr); /* 244 */
     Tcl_HashTable * (*tclGetNamespaceCommandTable) (Tcl_Namespace *nsPtr); /* 245 */
-    int (*tclInitRewriteEnsemble) (Tcl_Interp *interp, size_t numRemoved, size_t numInserted, Tcl_Obj *const *objv); /* 246 */
+    int (*tclInitRewriteEnsemble) (Tcl_Interp *interp, int numRemoved, int numInserted, Tcl_Obj *const *objv); /* 246 */
     void (*tclResetRewriteEnsemble) (Tcl_Interp *interp, int isRootEnsemble); /* 247 */
     int (*tclCopyChannel) (Tcl_Interp *interp, Tcl_Channel inChan, Tcl_Channel outChan, Tcl_WideInt toRead, Tcl_Obj *cmdPtr); /* 248 */
     char * (*tclDoubleDigits) (double dv, int ndigits, int flags, int *decpt, int *signum, char **endPtr); /* 249 */
     void (*tclSetSlaveCancelFlags) (Tcl_Interp *interp, int flags, int force); /* 250 */
-    int (*tclRegisterLiteral) (void *envPtr, const char *bytes, size_t length, int flags); /* 251 */
+    int (*tclRegisterLiteral) (void *envPtr, const char *bytes, int length, int flags); /* 251 */
     Tcl_Obj * (*tclPtrGetVar) (Tcl_Interp *interp, Tcl_Var varPtr, Tcl_Var arrayPtr, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, const int flags); /* 252 */
     Tcl_Obj * (*tclPtrSetVar) (Tcl_Interp *interp, Tcl_Var varPtr, Tcl_Var arrayPtr, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, Tcl_Obj *newValuePtr, const int flags); /* 253 */
     Tcl_Obj * (*tclPtrIncrObjVar) (Tcl_Interp *interp, Tcl_Var varPtr, Tcl_Var arrayPtr, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, Tcl_Obj *incrPtr, const int flags); /* 254 */
     int (*tclPtrObjMakeUpvar) (Tcl_Interp *interp, Tcl_Var otherPtr, Tcl_Obj *myNamePtr, int myFlags); /* 255 */
     int (*tclPtrUnsetVar) (Tcl_Interp *interp, Tcl_Var varPtr, Tcl_Var arrayPtr, Tcl_Obj *part1Ptr, Tcl_Obj *part2Ptr, const int flags); /* 256 */
@@ -871,11 +946,12 @@
 	(tclIntStubsPtr->tclCleanupChildren) /* 5 */
 #define TclCleanupCommand \
 	(tclIntStubsPtr->tclCleanupCommand) /* 6 */
 #define TclCopyAndCollapse \
 	(tclIntStubsPtr->tclCopyAndCollapse) /* 7 */
-/* Slot 8 is reserved */
+#define TclCopyChannelOld \
+	(tclIntStubsPtr->tclCopyChannelOld) /* 8 */
 #define TclCreatePipeline \
 	(tclIntStubsPtr->tclCreatePipeline) /* 9 */
 #define TclCreateProc \
 	(tclIntStubsPtr->tclCreateProc) /* 10 */
 #define TclDeleteCompiledLocalVars \
@@ -910,11 +986,12 @@
 #define TclGetExtension \
 	(tclIntStubsPtr->tclGetExtension) /* 31 */
 #define TclGetFrame \
 	(tclIntStubsPtr->tclGetFrame) /* 32 */
 /* Slot 33 is reserved */
-/* Slot 34 is reserved */
+#define TclGetIntForIndex \
+	(tclIntStubsPtr->tclGetIntForIndex) /* 34 */
 /* Slot 35 is reserved */
 /* Slot 36 is reserved */
 #define TclGetLoadedPackages \
 	(tclIntStubsPtr->tclGetLoadedPackages) /* 37 */
 #define TclGetNamespaceForQualName \
@@ -977,11 +1054,12 @@
 	(tclIntStubsPtr->tclpFree) /* 74 */
 #define TclpGetClicks \
 	(tclIntStubsPtr->tclpGetClicks) /* 75 */
 #define TclpGetSeconds \
 	(tclIntStubsPtr->tclpGetSeconds) /* 76 */
-/* Slot 77 is reserved */
+#define TclpGetTime \
+	(tclIntStubsPtr->tclpGetTime) /* 77 */
 /* Slot 78 is reserved */
 /* Slot 79 is reserved */
 /* Slot 80 is reserved */
 #define TclpRealloc \
 	(tclIntStubsPtr->tclpRealloc) /* 81 */
@@ -989,11 +1067,12 @@
 /* Slot 83 is reserved */
 /* Slot 84 is reserved */
 /* Slot 85 is reserved */
 /* Slot 86 is reserved */
 /* Slot 87 is reserved */
-/* Slot 88 is reserved */
+#define TclPrecTraceProc \
+	(tclIntStubsPtr->tclPrecTraceProc) /* 88 */
 #define TclPreventAliasLoop \
 	(tclIntStubsPtr->tclPreventAliasLoop) /* 89 */
 /* Slot 90 is reserved */
 #define TclProcCleanupProc \
 	(tclIntStubsPtr->tclProcCleanupProc) /* 91 */
@@ -1015,11 +1094,12 @@
 	(tclIntStubsPtr->tclSetPreInitScript) /* 101 */
 #define TclSetupEnv \
 	(tclIntStubsPtr->tclSetupEnv) /* 102 */
 #define TclSockGetPort \
 	(tclIntStubsPtr->tclSockGetPort) /* 103 */
-/* Slot 104 is reserved */
+#define TclSockMinimumBuffersOld \
+	(tclIntStubsPtr->tclSockMinimumBuffersOld) /* 104 */
 /* Slot 105 is reserved */
 /* Slot 106 is reserved */
 /* Slot 107 is reserved */
 #define TclTeardownNamespace \
 	(tclIntStubsPtr->tclTeardownNamespace) /* 108 */
@@ -1027,30 +1107,42 @@
 	(tclIntStubsPtr->tclUpdateReturnInfo) /* 109 */
 #define TclSockMinimumBuffers \
 	(tclIntStubsPtr->tclSockMinimumBuffers) /* 110 */
 #define Tcl_AddInterpResolvers \
 	(tclIntStubsPtr->tcl_AddInterpResolvers) /* 111 */
-/* Slot 112 is reserved */
-/* Slot 113 is reserved */
-/* Slot 114 is reserved */
-/* Slot 115 is reserved */
-/* Slot 116 is reserved */
-/* Slot 117 is reserved */
+#define TclAppendExportList \
+	(tclIntStubsPtr->tclAppendExportList) /* 112 */
+#define TclCreateNamespace \
+	(tclIntStubsPtr->tclCreateNamespace) /* 113 */
+#define TclDeleteNamespace \
+	(tclIntStubsPtr->tclDeleteNamespace) /* 114 */
+#define TclExport \
+	(tclIntStubsPtr->tclExport) /* 115 */
+#define TclFindCommand \
+	(tclIntStubsPtr->tclFindCommand) /* 116 */
+#define TclFindNamespace \
+	(tclIntStubsPtr->tclFindNamespace) /* 117 */
 #define Tcl_GetInterpResolvers \
 	(tclIntStubsPtr->tcl_GetInterpResolvers) /* 118 */
 #define Tcl_GetNamespaceResolvers \
 	(tclIntStubsPtr->tcl_GetNamespaceResolvers) /* 119 */
 #define Tcl_FindNamespaceVar \
 	(tclIntStubsPtr->tcl_FindNamespaceVar) /* 120 */
-/* Slot 121 is reserved */
-/* Slot 122 is reserved */
-/* Slot 123 is reserved */
-/* Slot 124 is reserved */
-/* Slot 125 is reserved */
+#define TclForgetImport \
+	(tclIntStubsPtr->tclForgetImport) /* 121 */
+#define TclGetCommandFromObj \
+	(tclIntStubsPtr->tclGetCommandFromObj) /* 122 */
+#define TclGetCommandFullName \
+	(tclIntStubsPtr->tclGetCommandFullName) /* 123 */
+#define TclGetCurrentNamespace_ \
+	(tclIntStubsPtr->tclGetCurrentNamespace_) /* 124 */
+#define TclGetGlobalNamespace_ \
+	(tclIntStubsPtr->tclGetGlobalNamespace_) /* 125 */
 #define Tcl_GetVariableFullName \
 	(tclIntStubsPtr->tcl_GetVariableFullName) /* 126 */
-/* Slot 127 is reserved */
+#define TclImport \
+	(tclIntStubsPtr->tclImport) /* 127 */
 #define Tcl_PopCallFrame \
 	(tclIntStubsPtr->tcl_PopCallFrame) /* 128 */
 #define Tcl_PushCallFrame \
 	(tclIntStubsPtr->tcl_PushCallFrame) /* 129 */
 #define Tcl_RemoveInterpResolvers \
@@ -1057,11 +1149,12 @@
 	(tclIntStubsPtr->tcl_RemoveInterpResolvers) /* 130 */
 #define Tcl_SetNamespaceResolvers \
 	(tclIntStubsPtr->tcl_SetNamespaceResolvers) /* 131 */
 #define TclpHasSockets \
 	(tclIntStubsPtr->tclpHasSockets) /* 132 */
-/* Slot 133 is reserved */
+#define TclpGetDate \
+	(tclIntStubsPtr->tclpGetDate) /* 133 */
 /* Slot 134 is reserved */
 /* Slot 135 is reserved */
 /* Slot 136 is reserved */
 /* Slot 137 is reserved */
 #define TclGetEnv \
@@ -1098,12 +1191,14 @@
 /* Slot 155 is reserved */
 #define TclRegError \
 	(tclIntStubsPtr->tclRegError) /* 156 */
 #define TclVarTraceExists \
 	(tclIntStubsPtr->tclVarTraceExists) /* 157 */
-/* Slot 158 is reserved */
-/* Slot 159 is reserved */
+#define TclSetStartupScriptFileName \
+	(tclIntStubsPtr->tclSetStartupScriptFileName) /* 158 */
+#define TclGetStartupScriptFileName \
+	(tclIntStubsPtr->tclGetStartupScriptFileName) /* 159 */
 /* Slot 160 is reserved */
 #define TclChannelTransform \
 	(tclIntStubsPtr->tclChannelTransform) /* 161 */
 #define TclChannelEventScriptInvoker \
 	(tclIntStubsPtr->tclChannelEventScriptInvoker) /* 162 */
@@ -1113,12 +1208,14 @@
 	(tclIntStubsPtr->tclExpandCodeArray) /* 164 */
 #define TclpSetInitialEncodings \
 	(tclIntStubsPtr->tclpSetInitialEncodings) /* 165 */
 #define TclListObjSetElement \
 	(tclIntStubsPtr->tclListObjSetElement) /* 166 */
-/* Slot 167 is reserved */
-/* Slot 168 is reserved */
+#define TclSetStartupScriptPath \
+	(tclIntStubsPtr->tclSetStartupScriptPath) /* 167 */
+#define TclGetStartupScriptPath \
+	(tclIntStubsPtr->tclGetStartupScriptPath) /* 168 */
 #define TclpUtfNcmp2 \
 	(tclIntStubsPtr->tclpUtfNcmp2) /* 169 */
 #define TclCheckInterpTraces \
 	(tclIntStubsPtr->tclCheckInterpTraces) /* 170 */
 #define TclCheckExecutionTraces \
@@ -1132,16 +1229,20 @@
 	(tclIntStubsPtr->tclCallVarTraces) /* 175 */
 #define TclCleanupVar \
 	(tclIntStubsPtr->tclCleanupVar) /* 176 */
 #define TclVarErrMsg \
 	(tclIntStubsPtr->tclVarErrMsg) /* 177 */
-/* Slot 178 is reserved */
-/* Slot 179 is reserved */
+#define TclSetStartupScript \
+	(tclIntStubsPtr->tclSetStartupScript) /* 178 */
+#define TclGetStartupScript \
+	(tclIntStubsPtr->tclGetStartupScript) /* 179 */
 /* Slot 180 is reserved */
 /* Slot 181 is reserved */
-/* Slot 182 is reserved */
-/* Slot 183 is reserved */
+#define TclpLocaltime \
+	(tclIntStubsPtr->tclpLocaltime) /* 182 */
+#define TclpGmtime \
+	(tclIntStubsPtr->tclpGmtime) /* 183 */
 /* Slot 184 is reserved */
 /* Slot 185 is reserved */
 /* Slot 186 is reserved */
 /* Slot 187 is reserved */
 /* Slot 188 is reserved */
@@ -1218,11 +1319,12 @@
 	(tclIntStubsPtr->tclGetSrcInfoForPc) /* 233 */
 #define TclVarHashCreateVar \
 	(tclIntStubsPtr->tclVarHashCreateVar) /* 234 */
 #define TclInitVarHashTable \
 	(tclIntStubsPtr->tclInitVarHashTable) /* 235 */
-/* Slot 236 is reserved */
+#define TclBackgroundException \
+	(tclIntStubsPtr->tclBackgroundException) /* 236 */
 #define TclResetCancellation \
 	(tclIntStubsPtr->tclResetCancellation) /* 237 */
 #define TclNRInterpProc \
 	(tclIntStubsPtr->tclNRInterpProc) /* 238 */
 #define TclNRInterpProcCore \
@@ -1268,15 +1370,36 @@
 
 #endif /* defined(USE_TCL_STUBS) */
 
 /* !END!: Do not edit above this line. */
 
-#if defined(USE_TCL_STUBS)
-#undef Tcl_StaticPackage
-#define Tcl_StaticPackage \
-	(tclIntStubsPtr->tclStaticPackage)
-#endif /* defined(USE_TCL_STUBS) */
-
 #undef TCL_STORAGE_CLASS
 #define TCL_STORAGE_CLASS DLLIMPORT
+
+#if defined(USE_TCL_STUBS)
+#   undef TclGetStartupScriptFileName
+#   undef TclSetStartupScriptFileName
+#   undef TclGetStartupScriptPath
+#   undef TclSetStartupScriptPath
+#   undef TclBackgroundException
+#   undef TclSetStartupScript
+#   undef TclGetStartupScript
+#   undef TclGetIntForIndex
+#   undef TclCreateNamespace
+#   undef TclDeleteNamespace
+#   undef TclAppendExportList
+#   undef TclExport
+#   undef TclImport
+#   undef TclForgetImport
+#   undef TclGetCurrentNamespace_
+#   undef TclGetGlobalNamespace_
+#   undef TclFindNamespace
+#   undef TclFindCommand
+#   undef TclGetCommandFromObj
+#   undef TclGetCommandFullName
+#   undef TclCopyChannelOld
+#   undef TclSockMinimumBuffersOld
+#   undef Tcl_StaticPackage
+#   define Tcl_StaticPackage (tclIntStubsPtr->tclStaticPackage)
+#endif
 
 #endif /* _TCLINTDECLS */

Index: generic/tclIntPlatDecls.h
==================================================================
--- generic/tclIntPlatDecls.h
+++ generic/tclIntPlatDecls.h
@@ -64,14 +64,18 @@
 EXTERN TclFile		TclpOpenFile(const char *fname, int mode);
 /* 8 */
 EXTERN int		TclUnixWaitForFile(int fd, int mask, int timeout);
 /* 9 */
 EXTERN TclFile		TclpCreateTempFile(const char *contents);
-/* Slot 10 is reserved */
-/* Slot 11 is reserved */
-/* Slot 12 is reserved */
-/* Slot 13 is reserved */
+/* 10 */
+EXTERN Tcl_DirEntry *	TclpReaddir(TclDIR *dir);
+/* 11 */
+EXTERN struct tm *	TclpLocaltime_unix(const time_t *clock);
+/* 12 */
+EXTERN struct tm *	TclpGmtime_unix(const time_t *clock);
+/* 13 */
+EXTERN char *		TclpInetNtoa(struct in_addr addr);
 /* 14 */
 EXTERN int		TclUnixCopyFile(const char *src, const char *dst,
 				const Tcl_StatBuf *statBufPtr,
 				int dontCopyAtts);
 /* Slot 15 is reserved */
@@ -96,23 +100,33 @@
 				Tcl_Obj *resultingNameObj);
 #endif /* UNIX */
 #if defined(_WIN32) || defined(__CYGWIN__) /* WIN */
 /* 0 */
 EXTERN void		TclWinConvertError(DWORD errCode);
-/* Slot 1 is reserved */
-/* Slot 2 is reserved */
-/* Slot 3 is reserved */
+/* 1 */
+EXTERN void		TclWinConvertWSAError(DWORD errCode);
+/* 2 */
+EXTERN struct servent *	 TclWinGetServByName(const char *nm,
+				const char *proto);
+/* 3 */
+EXTERN int		TclWinGetSockOpt(SOCKET s, int level, int optname,
+				char *optval, int *optlen);
 /* 4 */
 EXTERN HINSTANCE	TclWinGetTclInstance(void);
 /* 5 */
 EXTERN int		TclUnixWaitForFile(int fd, int mask, int timeout);
-/* Slot 6 is reserved */
-/* Slot 7 is reserved */
+/* 6 */
+EXTERN unsigned short	TclWinNToHS(unsigned short ns);
+/* 7 */
+EXTERN int		TclWinSetSockOpt(SOCKET s, int level, int optname,
+				const char *optval, int optlen);
 /* 8 */
-EXTERN size_t		TclpGetPid(Tcl_Pid pid);
-/* Slot 9 is reserved */
-/* Slot 10 is reserved */
+EXTERN int		TclpGetPid(Tcl_Pid pid);
+/* 9 */
+EXTERN int		TclWinGetPlatformId(void);
+/* 10 */
+EXTERN Tcl_DirEntry *	TclpReaddir(TclDIR *dir);
 /* 11 */
 EXTERN void		TclGetAndDetachPids(Tcl_Interp *interp,
 				Tcl_Channel chan);
 /* 12 */
 EXTERN int		TclpCloseFile(TclFile file);
@@ -136,22 +150,25 @@
 /* 18 */
 EXTERN TclFile		TclpMakeFile(Tcl_Channel channel, int direction);
 /* 19 */
 EXTERN TclFile		TclpOpenFile(const char *fname, int mode);
 /* 20 */
-EXTERN void		TclWinAddProcess(HANDLE hProcess, size_t id);
-/* Slot 21 is reserved */
+EXTERN void		TclWinAddProcess(HANDLE hProcess, DWORD id);
+/* 21 */
+EXTERN char *		TclpInetNtoa(struct in_addr addr);
 /* 22 */
 EXTERN TclFile		TclpCreateTempFile(const char *contents);
 /* Slot 23 is reserved */
 /* 24 */
 EXTERN char *		TclWinNoBackslash(char *path);
 /* Slot 25 is reserved */
-/* Slot 26 is reserved */
+/* 26 */
+EXTERN void		TclWinSetInterfaces(int wide);
 /* 27 */
 EXTERN void		TclWinFlushDirtyChannels(void);
-/* Slot 28 is reserved */
+/* 28 */
+EXTERN void		TclWinResetInterfaces(void);
 /* 29 */
 EXTERN int		TclWinCPUID(int index, int *regs);
 /* 30 */
 EXTERN int		TclUnixOpenTemporaryFile(Tcl_Obj *dirObj,
 				Tcl_Obj *basenameObj, Tcl_Obj *extensionObj,
@@ -181,14 +198,18 @@
 EXTERN TclFile		TclpOpenFile(const char *fname, int mode);
 /* 8 */
 EXTERN int		TclUnixWaitForFile(int fd, int mask, int timeout);
 /* 9 */
 EXTERN TclFile		TclpCreateTempFile(const char *contents);
-/* Slot 10 is reserved */
-/* Slot 11 is reserved */
-/* Slot 12 is reserved */
-/* Slot 13 is reserved */
+/* 10 */
+EXTERN Tcl_DirEntry *	TclpReaddir(TclDIR *dir);
+/* 11 */
+EXTERN struct tm *	TclpLocaltime_unix(const time_t *clock);
+/* 12 */
+EXTERN struct tm *	TclpGmtime_unix(const time_t *clock);
+/* 13 */
+EXTERN char *		TclpInetNtoa(struct in_addr addr);
 /* 14 */
 EXTERN int		TclUnixCopyFile(const char *src, const char *dst,
 				const Tcl_StatBuf *statBufPtr,
 				int dontCopyAtts);
 /* 15 */
@@ -241,14 +262,14 @@
     void (*reserved5)(void);
     TclFile (*tclpMakeFile) (Tcl_Channel channel, int direction); /* 6 */
     TclFile (*tclpOpenFile) (const char *fname, int mode); /* 7 */
     int (*tclUnixWaitForFile) (int fd, int mask, int timeout); /* 8 */
     TclFile (*tclpCreateTempFile) (const char *contents); /* 9 */
-    void (*reserved10)(void);
-    void (*reserved11)(void);
-    void (*reserved12)(void);
-    void (*reserved13)(void);
+    Tcl_DirEntry * (*tclpReaddir) (TclDIR *dir); /* 10 */
+    struct tm * (*tclpLocaltime_unix) (const time_t *clock); /* 11 */
+    struct tm * (*tclpGmtime_unix) (const time_t *clock); /* 12 */
+    char * (*tclpInetNtoa) (struct in_addr addr); /* 13 */
     int (*tclUnixCopyFile) (const char *src, const char *dst, const Tcl_StatBuf *statBufPtr, int dontCopyAtts); /* 14 */
     void (*reserved15)(void);
     void (*reserved16)(void);
     void (*reserved17)(void);
     void (*reserved18)(void);
@@ -265,38 +286,38 @@
     int (*tclWinCPUID) (int index, int *regs); /* 29 */
     int (*tclUnixOpenTemporaryFile) (Tcl_Obj *dirObj, Tcl_Obj *basenameObj, Tcl_Obj *extensionObj, Tcl_Obj *resultingNameObj); /* 30 */
 #endif /* UNIX */
 #if defined(_WIN32) || defined(__CYGWIN__) /* WIN */
     void (*tclWinConvertError) (DWORD errCode); /* 0 */
-    void (*reserved1)(void);
-    void (*reserved2)(void);
-    void (*reserved3)(void);
+    void (*tclWinConvertWSAError) (DWORD errCode); /* 1 */
+    struct servent * (*tclWinGetServByName) (const char *nm, const char *proto); /* 2 */
+    int (*tclWinGetSockOpt) (SOCKET s, int level, int optname, char *optval, int *optlen); /* 3 */
     HINSTANCE (*tclWinGetTclInstance) (void); /* 4 */
     int (*tclUnixWaitForFile) (int fd, int mask, int timeout); /* 5 */
-    void (*reserved6)(void);
-    void (*reserved7)(void);
-    size_t (*tclpGetPid) (Tcl_Pid pid); /* 8 */
-    void (*reserved9)(void);
-    void (*reserved10)(void);
+    unsigned short (*tclWinNToHS) (unsigned short ns); /* 6 */
+    int (*tclWinSetSockOpt) (SOCKET s, int level, int optname, const char *optval, int optlen); /* 7 */
+    int (*tclpGetPid) (Tcl_Pid pid); /* 8 */
+    int (*tclWinGetPlatformId) (void); /* 9 */
+    Tcl_DirEntry * (*tclpReaddir) (TclDIR *dir); /* 10 */
     void (*tclGetAndDetachPids) (Tcl_Interp *interp, Tcl_Channel chan); /* 11 */
     int (*tclpCloseFile) (TclFile file); /* 12 */
     Tcl_Channel (*tclpCreateCommandChannel) (TclFile readFile, TclFile writeFile, TclFile errorFile, int numPids, Tcl_Pid *pidPtr); /* 13 */
     int (*tclpCreatePipe) (TclFile *readPipe, TclFile *writePipe); /* 14 */
     int (*tclpCreateProcess) (Tcl_Interp *interp, int argc, const char **argv, TclFile inputFile, TclFile outputFile, TclFile errorFile, Tcl_Pid *pidPtr); /* 15 */
     int (*tclpIsAtty) (int fd); /* 16 */
     int (*tclUnixCopyFile) (const char *src, const char *dst, const Tcl_StatBuf *statBufPtr, int dontCopyAtts); /* 17 */
     TclFile (*tclpMakeFile) (Tcl_Channel channel, int direction); /* 18 */
     TclFile (*tclpOpenFile) (const char *fname, int mode); /* 19 */
-    void (*tclWinAddProcess) (HANDLE hProcess, size_t id); /* 20 */
-    void (*reserved21)(void);
+    void (*tclWinAddProcess) (HANDLE hProcess, DWORD id); /* 20 */
+    char * (*tclpInetNtoa) (struct in_addr addr); /* 21 */
     TclFile (*tclpCreateTempFile) (const char *contents); /* 22 */
     void (*reserved23)(void);
     char * (*tclWinNoBackslash) (char *path); /* 24 */
     void (*reserved25)(void);
-    void (*reserved26)(void);
+    void (*tclWinSetInterfaces) (int wide); /* 26 */
     void (*tclWinFlushDirtyChannels) (void); /* 27 */
-    void (*reserved28)(void);
+    void (*tclWinResetInterfaces) (void); /* 28 */
     int (*tclWinCPUID) (int index, int *regs); /* 29 */
     int (*tclUnixOpenTemporaryFile) (Tcl_Obj *dirObj, Tcl_Obj *basenameObj, Tcl_Obj *extensionObj, Tcl_Obj *resultingNameObj); /* 30 */
 #endif /* WIN */
 #ifdef MAC_OSX_TCL /* MACOSX */
     void (*tclGetAndDetachPids) (Tcl_Interp *interp, Tcl_Channel chan); /* 0 */
@@ -307,14 +328,14 @@
     void (*reserved5)(void);
     TclFile (*tclpMakeFile) (Tcl_Channel channel, int direction); /* 6 */
     TclFile (*tclpOpenFile) (const char *fname, int mode); /* 7 */
     int (*tclUnixWaitForFile) (int fd, int mask, int timeout); /* 8 */
     TclFile (*tclpCreateTempFile) (const char *contents); /* 9 */
-    void (*reserved10)(void);
-    void (*reserved11)(void);
-    void (*reserved12)(void);
-    void (*reserved13)(void);
+    Tcl_DirEntry * (*tclpReaddir) (TclDIR *dir); /* 10 */
+    struct tm * (*tclpLocaltime_unix) (const time_t *clock); /* 11 */
+    struct tm * (*tclpGmtime_unix) (const time_t *clock); /* 12 */
+    char * (*tclpInetNtoa) (struct in_addr addr); /* 13 */
     int (*tclUnixCopyFile) (const char *src, const char *dst, const Tcl_StatBuf *statBufPtr, int dontCopyAtts); /* 14 */
     int (*tclMacOSXGetFileAttribute) (Tcl_Interp *interp, int objIndex, Tcl_Obj *fileName, Tcl_Obj **attributePtrPtr); /* 15 */
     int (*tclMacOSXSetFileAttribute) (Tcl_Interp *interp, int objIndex, Tcl_Obj *fileName, Tcl_Obj *attributePtr); /* 16 */
     int (*tclMacOSXCopyFileAttributes) (const char *src, const char *dst, const Tcl_StatBuf *statBufPtr); /* 17 */
     int (*tclMacOSXMatchType) (Tcl_Interp *interp, const char *pathName, const char *fileName, Tcl_StatBuf *statBufPtr, Tcl_GlobTypeData *types); /* 18 */
@@ -363,14 +384,18 @@
 	(tclIntPlatStubsPtr->tclpOpenFile) /* 7 */
 #define TclUnixWaitForFile \
 	(tclIntPlatStubsPtr->tclUnixWaitForFile) /* 8 */
 #define TclpCreateTempFile \
 	(tclIntPlatStubsPtr->tclpCreateTempFile) /* 9 */
-/* Slot 10 is reserved */
-/* Slot 11 is reserved */
-/* Slot 12 is reserved */
-/* Slot 13 is reserved */
+#define TclpReaddir \
+	(tclIntPlatStubsPtr->tclpReaddir) /* 10 */
+#define TclpLocaltime_unix \
+	(tclIntPlatStubsPtr->tclpLocaltime_unix) /* 11 */
+#define TclpGmtime_unix \
+	(tclIntPlatStubsPtr->tclpGmtime_unix) /* 12 */
+#define TclpInetNtoa \
+	(tclIntPlatStubsPtr->tclpInetNtoa) /* 13 */
 #define TclUnixCopyFile \
 	(tclIntPlatStubsPtr->tclUnixCopyFile) /* 14 */
 /* Slot 15 is reserved */
 /* Slot 16 is reserved */
 /* Slot 17 is reserved */
@@ -391,23 +416,30 @@
 	(tclIntPlatStubsPtr->tclUnixOpenTemporaryFile) /* 30 */
 #endif /* UNIX */
 #if defined(_WIN32) || defined(__CYGWIN__) /* WIN */
 #define TclWinConvertError \
 	(tclIntPlatStubsPtr->tclWinConvertError) /* 0 */
-/* Slot 1 is reserved */
-/* Slot 2 is reserved */
-/* Slot 3 is reserved */
+#define TclWinConvertWSAError \
+	(tclIntPlatStubsPtr->tclWinConvertWSAError) /* 1 */
+#define TclWinGetServByName \
+	(tclIntPlatStubsPtr->tclWinGetServByName) /* 2 */
+#define TclWinGetSockOpt \
+	(tclIntPlatStubsPtr->tclWinGetSockOpt) /* 3 */
 #define TclWinGetTclInstance \
 	(tclIntPlatStubsPtr->tclWinGetTclInstance) /* 4 */
 #define TclUnixWaitForFile \
 	(tclIntPlatStubsPtr->tclUnixWaitForFile) /* 5 */
-/* Slot 6 is reserved */
-/* Slot 7 is reserved */
+#define TclWinNToHS \
+	(tclIntPlatStubsPtr->tclWinNToHS) /* 6 */
+#define TclWinSetSockOpt \
+	(tclIntPlatStubsPtr->tclWinSetSockOpt) /* 7 */
 #define TclpGetPid \
 	(tclIntPlatStubsPtr->tclpGetPid) /* 8 */
-/* Slot 9 is reserved */
-/* Slot 10 is reserved */
+#define TclWinGetPlatformId \
+	(tclIntPlatStubsPtr->tclWinGetPlatformId) /* 9 */
+#define TclpReaddir \
+	(tclIntPlatStubsPtr->tclpReaddir) /* 10 */
 #define TclGetAndDetachPids \
 	(tclIntPlatStubsPtr->tclGetAndDetachPids) /* 11 */
 #define TclpCloseFile \
 	(tclIntPlatStubsPtr->tclpCloseFile) /* 12 */
 #define TclpCreateCommandChannel \
@@ -424,21 +456,24 @@
 	(tclIntPlatStubsPtr->tclpMakeFile) /* 18 */
 #define TclpOpenFile \
 	(tclIntPlatStubsPtr->tclpOpenFile) /* 19 */
 #define TclWinAddProcess \
 	(tclIntPlatStubsPtr->tclWinAddProcess) /* 20 */
-/* Slot 21 is reserved */
+#define TclpInetNtoa \
+	(tclIntPlatStubsPtr->tclpInetNtoa) /* 21 */
 #define TclpCreateTempFile \
 	(tclIntPlatStubsPtr->tclpCreateTempFile) /* 22 */
 /* Slot 23 is reserved */
 #define TclWinNoBackslash \
 	(tclIntPlatStubsPtr->tclWinNoBackslash) /* 24 */
 /* Slot 25 is reserved */
-/* Slot 26 is reserved */
+#define TclWinSetInterfaces \
+	(tclIntPlatStubsPtr->tclWinSetInterfaces) /* 26 */
 #define TclWinFlushDirtyChannels \
 	(tclIntPlatStubsPtr->tclWinFlushDirtyChannels) /* 27 */
-/* Slot 28 is reserved */
+#define TclWinResetInterfaces \
+	(tclIntPlatStubsPtr->tclWinResetInterfaces) /* 28 */
 #define TclWinCPUID \
 	(tclIntPlatStubsPtr->tclWinCPUID) /* 29 */
 #define TclUnixOpenTemporaryFile \
 	(tclIntPlatStubsPtr->tclUnixOpenTemporaryFile) /* 30 */
 #endif /* WIN */
@@ -460,14 +495,18 @@
 	(tclIntPlatStubsPtr->tclpOpenFile) /* 7 */
 #define TclUnixWaitForFile \
 	(tclIntPlatStubsPtr->tclUnixWaitForFile) /* 8 */
 #define TclpCreateTempFile \
 	(tclIntPlatStubsPtr->tclpCreateTempFile) /* 9 */
-/* Slot 10 is reserved */
-/* Slot 11 is reserved */
-/* Slot 12 is reserved */
-/* Slot 13 is reserved */
+#define TclpReaddir \
+	(tclIntPlatStubsPtr->tclpReaddir) /* 10 */
+#define TclpLocaltime_unix \
+	(tclIntPlatStubsPtr->tclpLocaltime_unix) /* 11 */
+#define TclpGmtime_unix \
+	(tclIntPlatStubsPtr->tclpGmtime_unix) /* 12 */
+#define TclpInetNtoa \
+	(tclIntPlatStubsPtr->tclpInetNtoa) /* 13 */
 #define TclUnixCopyFile \
 	(tclIntPlatStubsPtr->tclUnixCopyFile) /* 14 */
 #define TclMacOSXGetFileAttribute \
 	(tclIntPlatStubsPtr->tclMacOSXGetFileAttribute) /* 15 */
 #define TclMacOSXSetFileAttribute \
@@ -497,13 +536,35 @@
 
 /* !END!: Do not edit above this line. */
 
 #undef TCL_STORAGE_CLASS
 #define TCL_STORAGE_CLASS DLLIMPORT
+#undef TclpLocaltime_unix
+#undef TclpGmtime_unix
+#undef TclWinConvertWSAError
 #define TclWinConvertWSAError TclWinConvertError
+#undef TclpInetNtoa
+#define TclpInetNtoa inet_ntoa
 
-#if !defined(_WIN32)
+#if defined(_WIN32)
+#   undef TclWinNToHS
+#   undef TclWinGetServByName
+#   undef TclWinGetSockOpt
+#   undef TclWinSetSockOpt
+#   undef TclWinGetPlatformId
+#   undef TclWinResetInterfaces
+#   undef TclWinSetInterfaces
+#   if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+#	define TclWinNToHS ntohs
+#	define TclWinGetServByName getservbyname
+#	define TclWinGetSockOpt getsockopt
+#	define TclWinSetSockOpt setsockopt
+#	define TclWinGetPlatformId() (2) /* VER_PLATFORM_WIN32_NT */
+#	define TclWinResetInterfaces() /* nop */
+#	define TclWinSetInterfaces(dummy) /* nop */
+#   endif /* TCL_NO_DEPRECATED */
+#else
 #   undef TclpGetPid
-#   define TclpGetPid(pid) ((size_t) (pid))
+#   define TclpGetPid(pid) ((unsigned long) (pid))
 #endif
 
 #endif /* _TCLINTPLATDECLS */

Index: generic/tclInterp.c
==================================================================
--- generic/tclInterp.c
+++ generic/tclInterp.c
@@ -23,18 +23,18 @@
 
 /* Forward declaration */
 struct Target;
 
 /*
- * Alias:
+ * struct Alias:
  *
  * Stores information about an alias. Is stored in the slave interpreter and
  * used by the source command to find the target command in the master when
  * the source command is invoked.
  */
 
-typedef struct {
+typedef struct Alias {
     Tcl_Obj *token;		/* Token for the alias command in the slave
 				 * interp. This used to be the command name in
 				 * the slave when the alias was first
 				 * created. */
     Tcl_Interp *targetInterp;	/* Interp in which target command will be
@@ -64,18 +64,18 @@
 				 * prefix. */
 } Alias;
 
 /*
  *
- * Slave:
+ * struct Slave:
  *
  * Used by the "interp" command to record and find information about slave
  * interpreters. Maps from a command name in the master to information about a
  * slave interpreter, e.g. what aliases are defined in it.
  */
 
-typedef struct {
+typedef struct Slave {
     Tcl_Interp *masterInterp;	/* Master interpreter for this slave. */
     Tcl_HashEntry *slaveEntryPtr;
 				/* Hash entry in masters slave table for this
 				 * slave interpreter. Used to find this
 				 * record, and used when deleting the slave
@@ -110,11 +110,11 @@
     struct Target *prevPtr;	/* Previous in list of target records, or NULL
 				 * if at the start of the list of targets. */
 } Target;
 
 /*
- * Master:
+ * struct Master:
  *
  * This record is used for two purposes: First, slaveTable (a hashtable) maps
  * from names of commands to slave interpreters. This hashtable is used to
  * store information about slave interpreters of this interpreter, to map over
  * all slaves, etc. The second purpose is to store information about all
@@ -125,11 +125,11 @@
  * denotes whether the interpreter is safe or not. Safe interpreters have
  * restricted functionality, can only create safe slave interpreters and can
  * only load safe extensions.
  */
 
-typedef struct {
+typedef struct Master {
     Tcl_HashTable slaveTable;	/* Hash table for slave interpreters. Maps
 				 * from command names to Slave records. */
     Target *targetsPtr;		/* The head of a doubly-linked list of all the
 				 * target records which denote aliases from
 				 * slaves or sibling interpreters that direct
@@ -142,11 +142,11 @@
 /*
  * The following structure keeps track of all the Master and Slave information
  * on a per-interp basis.
  */
 
-typedef struct {
+typedef struct InterpInfo {
     Master master;		/* Keeps track of all interps for which this
 				 * interp is the Master. */
     Slave slave;		/* Information necessary for this interp to
 				 * function as a slave. */
 } InterpInfo;
@@ -156,11 +156,11 @@
  * stored in hashes indexed by a two-word key. Note that the type of the
  * 'type' field in the key is not int; this is to make sure that things are
  * likely to work properly on 64-bit architectures.
  */
 
-typedef struct {
+typedef struct ScriptLimitCallback {
     Tcl_Interp *interp;		/* The interpreter in which to execute the
 				 * callback. */
     Tcl_Obj *scriptObj;		/* The script to execute to perform the
 				 * user-defined part of the callback. */
     int type;			/* What kind of callback is this. */
@@ -169,11 +169,11 @@
 				 * callback record, or NULL if the entry has
 				 * already been deleted from that hash
 				 * table. */
 } ScriptLimitCallback;
 
-typedef struct {
+typedef struct ScriptLimitCallbackKey {
     Tcl_Interp *interp;		/* The interpreter that the limit callback was
 				 * attached to. This is not the interpreter
 				 * that the callback runs in! */
     long type;			/* The type of callback that this is. */
 } ScriptLimitCallbackKey;
@@ -483,11 +483,11 @@
 {
     InterpInfo *interpInfoPtr;
     Master *masterPtr;
     Slave *slavePtr;
 
-    interpInfoPtr = Tcl_Alloc(sizeof(InterpInfo));
+    interpInfoPtr = ckalloc(sizeof(InterpInfo));
     ((Interp *) interp)->interpInfo = interpInfoPtr;
 
     masterPtr = &interpInfoPtr->master;
     Tcl_InitHashTable(&masterPtr->slaveTable, TCL_STRING_KEYS);
     masterPtr->targetsPtr = NULL;
@@ -580,11 +580,11 @@
     if (slavePtr->aliasTable.numEntries != 0) {
 	Tcl_Panic("InterpInfoDeleteProc: still exist aliases");
     }
     Tcl_DeleteHashTable(&slavePtr->aliasTable);
 
-    Tcl_Free(interpInfoPtr);
+    ckfree(interpInfoPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -784,11 +784,11 @@
 	 */
 
 	slavePtr = NULL;
 	last = 0;
 	for (i = 2; i < objc; i++) {
-	    if ((last == 0) && (TclGetString(objv[i])[0] == '-')) {
+	    if ((last == 0) && (Tcl_GetString(objv[i])[0] == '-')) {
 		if (Tcl_GetIndexFromObj(interp, objv[i], createOptions,
 			"option", 0, &index) != TCL_OK) {
 		    return TCL_ERROR;
 		}
 		if (index == OPT_SAFE) {
@@ -1098,20 +1098,20 @@
 	iiPtr = (InterpInfo *) ((Interp *) slaveInterp)->interpInfo;
 	hPtr = Tcl_FindHashEntry(&iiPtr->slave.aliasTable, aliasName);
 	if (hPtr == NULL) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "alias \"%s\" in path \"%s\" not found",
-		    aliasName, TclGetString(objv[2])));
+		    aliasName, Tcl_GetString(objv[2])));
 	    Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "ALIAS", aliasName,
 		    NULL);
 	    return TCL_ERROR;
 	}
 	aliasPtr = Tcl_GetHashValue(hPtr);
 	if (Tcl_GetInterpPath(interp, aliasPtr->targetInterp) != TCL_OK) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "target interpreter for alias \"%s\" in path \"%s\" is "
-		    "not my descendant", aliasName, TclGetString(objv[2])));
+		    "not my descendant", aliasName, Tcl_GetString(objv[2])));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "INTERP",
 		    "TARGETSHROUDED", NULL);
 	    return TCL_ERROR;
 	}
 	return TCL_OK;
@@ -1307,11 +1307,11 @@
     if (argcPtr != NULL) {
 	*argcPtr = objc - 1;
     }
     if (argvPtr != NULL) {
 	*argvPtr = (const char **)
-		Tcl_Alloc(sizeof(const char *) * (objc - 1));
+		ckalloc(sizeof(const char *) * (objc - 1));
 	for (i = 1; i < objc; i++) {
 	    (*argvPtr)[i - 1] = TclGetString(objv[i]);
 	}
     }
     return TCL_OK;
@@ -1515,11 +1515,11 @@
     Slave *slavePtr;
     Master *masterPtr;
     Tcl_Obj **prefv;
     int isNew, i;
 
-    aliasPtr = Tcl_Alloc(sizeof(Alias) + objc * sizeof(Tcl_Obj *));
+    aliasPtr = ckalloc(sizeof(Alias) + objc * sizeof(Tcl_Obj *));
     aliasPtr->token = namePtr;
     Tcl_IncrRefCount(aliasPtr->token);
     aliasPtr->targetInterp = masterInterp;
 
     aliasPtr->objc = objc + 1;
@@ -1566,11 +1566,11 @@
 	cmdPtr->clientData = NULL;
 	cmdPtr->deleteProc = NULL;
 	cmdPtr->deleteData = NULL;
 	Tcl_DeleteCommandFromToken(slaveInterp, aliasPtr->slaveCmd);
 
-	Tcl_Free(aliasPtr);
+	ckfree(aliasPtr);
 
 	/*
 	 * The result was already set by TclPreventAliasLoop.
 	 */
 
@@ -1623,11 +1623,11 @@
      * interp alias {} foo {} bar		# Create an alias "foo"
      * rename foo zop				# Now rename the alias
      * interp alias {} foo {} zop		# Now recreate "foo"...
      */
 
-    targetPtr = Tcl_Alloc(sizeof(Target));
+    targetPtr = ckalloc(sizeof(Target));
     targetPtr->slaveCmd = aliasPtr->slaveCmd;
     targetPtr->slaveInterp = slaveInterp;
 
     masterPtr = &((InterpInfo*) ((Interp*) masterInterp)->interpInfo)->master;
     targetPtr->nextPtr = masterPtr->targetsPtr;
@@ -1725,11 +1725,11 @@
      * the original name (with which it was created) to find the alias to
      * describe it.
      */
 
     slavePtr = &((InterpInfo *) ((Interp *) slaveInterp)->interpInfo)->slave;
-    hPtr = Tcl_FindHashEntry(&slavePtr->aliasTable, TclGetString(namePtr));
+    hPtr = Tcl_FindHashEntry(&slavePtr->aliasTable, Tcl_GetString(namePtr));
     if (hPtr == NULL) {
 	return TCL_OK;
     }
     aliasPtr = Tcl_GetHashValue(hPtr);
     prefixPtr = Tcl_NewListObj(aliasPtr->objc, &aliasPtr->objPtr);
@@ -1829,12 +1829,12 @@
     listRep = ListRepPtr(listPtr);
     listRep->elemCount = cmdc;
     cmdv = &listRep->elements;
 
     prefv = &aliasPtr->objPtr;
-    memcpy(cmdv, prefv, (prefc * sizeof(Tcl_Obj *)));
-    memcpy(cmdv+prefc, objv+1, ((objc-1) * sizeof(Tcl_Obj *)));
+    memcpy(cmdv, prefv, prefc * sizeof(Tcl_Obj *));
+    memcpy(cmdv+prefc, objv+1, (objc-1) * sizeof(Tcl_Obj *));
 
     for (i=0; i<cmdc; i++) {
 	Tcl_IncrRefCount(cmdv[i]);
     }
 
@@ -2057,12 +2057,12 @@
     }
     if (targetPtr->nextPtr != NULL) {
 	targetPtr->nextPtr->prevPtr = targetPtr->prevPtr;
     }
 
-    Tcl_Free(targetPtr);
-    Tcl_Free(aliasPtr);
+    ckfree(targetPtr);
+    ckfree(aliasPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -3289,11 +3289,11 @@
 
     /*
      * No env array in a safe slave.
      */
 
-    Tcl_UnsetVar(interp, "env", TCL_GLOBAL_ONLY);
+    Tcl_UnsetVar2(interp, "env", NULL, TCL_GLOBAL_ONLY);
 
     /*
      * Remove unsafe parts of tcl_platform
      */
 
@@ -3305,13 +3305,13 @@
     /*
      * Unset path informations variables (the only one remaining is [info
      * nameofexecutable])
      */
 
-    Tcl_UnsetVar(interp, "tclDefaultLibrary", TCL_GLOBAL_ONLY);
-    Tcl_UnsetVar(interp, "tcl_library", TCL_GLOBAL_ONLY);
-    Tcl_UnsetVar(interp, "tcl_pkgPath", TCL_GLOBAL_ONLY);
+    Tcl_UnsetVar2(interp, "tclDefaultLibrary", NULL, TCL_GLOBAL_ONLY);
+    Tcl_UnsetVar2(interp, "tcl_library", NULL, TCL_GLOBAL_ONLY);
+    Tcl_UnsetVar2(interp, "tcl_pkgPath", NULL, TCL_GLOBAL_ONLY);
 
     /*
      * Remove the standard channels from the interpreter; safe interpreters do
      * not ordinarily have access to stdin, stdout and stderr.
      *
@@ -3360,11 +3360,11 @@
 
 int
 Tcl_LimitExceeded(
     Tcl_Interp *interp)
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
 
     return iPtr->limit.exceeded != 0;
 }
 
 /*
@@ -3391,14 +3391,14 @@
 
 int
 Tcl_LimitReady(
     Tcl_Interp *interp)
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
 
     if (iPtr->limit.active != 0) {
-	register int ticker = ++iPtr->limit.granularityTicker;
+	int ticker = ++iPtr->limit.granularityTicker;
 
 	if ((iPtr->limit.active & TCL_LIMIT_COMMANDS) &&
 		((iPtr->limit.cmdGranularity == 1) ||
 		    (ticker % iPtr->limit.cmdGranularity == 0))) {
 	    return 1;
@@ -3438,11 +3438,11 @@
 int
 Tcl_LimitCheck(
     Tcl_Interp *interp)
 {
     Interp *iPtr = (Interp *) interp;
-    register int ticker = iPtr->limit.granularityTicker;
+    int ticker = iPtr->limit.granularityTicker;
 
     if (Tcl_InterpDeleted(interp)) {
 	return TCL_OK;
     }
 
@@ -3558,11 +3558,11 @@
 
 	if (handlerPtr->flags & LIMIT_HANDLER_DELETED) {
 	    if (handlerPtr->deleteProc != NULL) {
 		handlerPtr->deleteProc(handlerPtr->clientData);
 	    }
-	    Tcl_Free(handlerPtr);
+	    ckfree(handlerPtr);
 	}
     }
 }
 
 /*
@@ -3595,18 +3595,18 @@
     /*
      * Convert everything into a real deletion callback.
      */
 
     if (deleteProc == (Tcl_LimitHandlerDeleteProc *) TCL_DYNAMIC) {
-	deleteProc = (Tcl_LimitHandlerDeleteProc *) TclpFree;
+	deleteProc = (Tcl_LimitHandlerDeleteProc *) Tcl_Free;
     }
 
     /*
      * Allocate a handler record.
      */
 
-    handlerPtr = Tcl_Alloc(sizeof(LimitHandler));
+    handlerPtr = ckalloc(sizeof(LimitHandler));
     handlerPtr->flags = 0;
     handlerPtr->handlerProc = handlerProc;
     handlerPtr->clientData = clientData;
     handlerPtr->deleteProc = deleteProc;
     handlerPtr->prevPtr = NULL;
@@ -3721,11 +3721,11 @@
 
 	if (!(handlerPtr->flags & LIMIT_HANDLER_ACTIVE)) {
 	    if (handlerPtr->deleteProc != NULL) {
 		handlerPtr->deleteProc(handlerPtr->clientData);
 	    }
-	    Tcl_Free(handlerPtr);
+	    ckfree(handlerPtr);
 	}
 	return;
     }
 }
 
@@ -3781,11 +3781,11 @@
 
 	if (!(handlerPtr->flags & LIMIT_HANDLER_ACTIVE)) {
 	    if (handlerPtr->deleteProc != NULL) {
 		handlerPtr->deleteProc(handlerPtr->clientData);
 	    }
-	    Tcl_Free(handlerPtr);
+	    ckfree(handlerPtr);
 	}
     }
 
     /*
      * Delete all time-limit handlers.
@@ -3814,11 +3814,11 @@
 
 	if (!(handlerPtr->flags & LIMIT_HANDLER_ACTIVE)) {
 	    if (handlerPtr->deleteProc != NULL) {
 		handlerPtr->deleteProc(handlerPtr->clientData);
 	    }
-	    Tcl_Free(handlerPtr);
+	    ckfree(handlerPtr);
 	}
     }
 
     /*
      * Delete the timer callback that is used to trap limits that occur in
@@ -4209,11 +4209,11 @@
 
     Tcl_DecrRefCount(limitCBPtr->scriptObj);
     if (limitCBPtr->entryPtr != NULL) {
 	Tcl_DeleteHashEntry(limitCBPtr->entryPtr);
     }
-    Tcl_Free(limitCBPtr);
+    ckfree(limitCBPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -4309,11 +4309,11 @@
 	limitCBPtr->entryPtr = NULL;
 	Tcl_LimitRemoveHandler(targetInterp, type, CallScriptLimitCallback,
 		limitCBPtr);
     }
 
-    limitCBPtr = Tcl_Alloc(sizeof(ScriptLimitCallback));
+    limitCBPtr = ckalloc(sizeof(ScriptLimitCallback));
     limitCBPtr->interp = interp;
     limitCBPtr->scriptObj = scriptObj;
     limitCBPtr->entryPtr = hashPtr;
     limitCBPtr->type = type;
     Tcl_IncrRefCount(scriptObj);
@@ -4562,12 +4562,11 @@
 	return TCL_OK;
     } else if ((objc-consumedObjc) & 1 /* isOdd(objc-consumedObjc) */) {
 	Tcl_WrongNumArgs(interp, consumedObjc, objv, "?-option value ...?");
 	return TCL_ERROR;
     } else {
-	int i;
-	size_t scriptLen = 0, limitLen = 0;
+	int i, scriptLen = 0, limitLen = 0;
 	Tcl_Obj *scriptObj = NULL, *granObj = NULL, *limitObj = NULL;
 	int gran = 0, limit = 0;
 
 	for (i=consumedObjc ; i<objc ; i+=2) {
 	    if (Tcl_GetIndexFromObj(interp, objv[i], options, "option", 0,
@@ -4768,12 +4767,11 @@
 	return TCL_OK;
     } else if ((objc-consumedObjc) & 1 /* isOdd(objc-consumedObjc) */) {
 	Tcl_WrongNumArgs(interp, consumedObjc, objv, "?-option value ...?");
 	return TCL_ERROR;
     } else {
-	int i;
-	size_t scriptLen = 0, milliLen = 0, secLen = 0;
+	int i, scriptLen = 0, milliLen = 0, secLen = 0;
 	Tcl_Obj *scriptObj = NULL, *granObj = NULL;
 	Tcl_Obj *milliObj = NULL, *secObj = NULL;
 	int gran = 0;
 	Tcl_Time limitMoment;
 	int tmp;

Index: generic/tclLink.c
==================================================================
--- generic/tclLink.c
+++ generic/tclLink.c
@@ -23,22 +23,22 @@
  * For each linked variable there is a data structure of the following type,
  * which describes the link and is the clientData for the trace set on the Tcl
  * variable.
  */
 
-typedef struct {
+typedef struct Link {
     Tcl_Interp *interp;		/* Interpreter containing Tcl variable. */
     Namespace *nsPtr;		/* Namespace containing Tcl variable */
     Tcl_Obj *varName;		/* Name of variable (must be global). This is
 				 * needed during trace callbacks, since the
 				 * actual variable may be aliased at that time
 				 * via upvar. */
     void *addr;			/* Location of C variable. */
-    size_t bytes;		/* Size of C variable array. This is 0 when
+    int bytes;			/* Size of C variable array. This is 0 when
 				 * single variables, and >0 used for array
 				 * variables. */
-    size_t numElems;	/* Number of elements in C variable array.
+    int numElems;		/* Number of elements in C variable array.
 				 * Zero for single variables. */
     int type;			/* Type of link (TCL_LINK_INT, etc.). */
     union {
 	char c;
 	unsigned char uc;
@@ -169,11 +169,11 @@
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"variable '%s' is already linked", varName));
 	return TCL_ERROR;
     }
 
-    linkPtr = Tcl_Alloc(sizeof(Link));
+    linkPtr = ckalloc(sizeof(Link));
     linkPtr->interp = interp;
     linkPtr->nsPtr = NULL;
     linkPtr->varName = Tcl_NewStringObj(varName, -1);
     Tcl_IncrRefCount(linkPtr->varName);
     linkPtr->addr = addr;
@@ -243,11 +243,11 @@
 				 * varName. If NULL then the necessary space
 				 * will be allocated and returned as the
 				 * interpreter result. */
     int type,			/* Type of C variable: TCL_LINK_INT, etc. Also
 				 * may have TCL_LINK_READ_ONLY OR'ed in. */
-    size_t size)			/* Size of C variable array, >1 if array */
+    int size)			/* Size of C variable array, >1 if array */
 {
     Tcl_Obj *objPtr;
     Link *linkPtr;
     Namespace *dummy;
     const char *name;
@@ -257,11 +257,11 @@
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"wrong array size given", -1));
 	return TCL_ERROR;
     }
 
-    linkPtr = Tcl_Alloc(sizeof(Link));
+    linkPtr = ckalloc(sizeof(Link));
     linkPtr->type = type & ~TCL_LINK_READ_ONLY;
     linkPtr->numElems = size;
     if (type & TCL_LINK_READ_ONLY) {
 	linkPtr->flags = LINK_READ_ONLY;
     } else {
@@ -317,11 +317,11 @@
 	 * If no address is given create one and use as address the
          * not needed linkPtr->lastValue
 	 */
 
 	if (addr == NULL) {
-	    linkPtr->lastValue.aryPtr = Tcl_Alloc(linkPtr->bytes);
+	    linkPtr->lastValue.aryPtr = ckalloc(linkPtr->bytes);
 	    linkPtr->flags |= LINK_ALLOC_LAST;
 	    addr = (char *) &linkPtr->lastValue.cPtr;
 	}
 	break;
     case TCL_LINK_CHARS:
@@ -338,11 +338,11 @@
     /*
      * Allocate C variable space in case no address is given
      */
 
     if (addr == NULL) {
-	linkPtr->addr = Tcl_Alloc(linkPtr->bytes);
+	linkPtr->addr = ckalloc(linkPtr->bytes);
 	linkPtr->flags |= LINK_ALLOC_ADDR;
     } else {
 	linkPtr->addr = addr;
     }
 
@@ -349,11 +349,11 @@
     /*
      * If necessary create space for last used value.
      */
 
     if (size > 1) {
-	linkPtr->lastValue.aryPtr = Tcl_Alloc(linkPtr->bytes);
+	linkPtr->lastValue.aryPtr = ckalloc(linkPtr->bytes);
 	linkPtr->flags |= LINK_ALLOC_LAST;
     }
 
     /*
      * Initialize allocated space.
@@ -621,24 +621,24 @@
 static int
 SetInvalidRealFromAny(
     Tcl_Interp *interp,
     Tcl_Obj *objPtr)
 {
-    size_t length;
-    const char *str, *endPtr;
+    const char *str;
+    const char *endPtr;
 
-    str = TclGetStringFromObj(objPtr, &length);
-    if ((length == 1) && (str[0] == '.')) {
+    str = TclGetString(objPtr);
+    if ((objPtr->length == 1) && (str[0] == '.')) {
 	objPtr->typePtr = &invalidRealType;
 	objPtr->internalRep.doubleValue = 0.0;
 	return TCL_OK;
     }
-    if (TclParseNumber(NULL, objPtr, NULL, str, length, &endPtr,
+    if (TclParseNumber(NULL, objPtr, NULL, str, objPtr->length, &endPtr,
 	    TCL_PARSE_DECIMAL_ONLY) == TCL_OK) {
 	/*
-	 * If number is followed by [eE][+-]?, then it is an invalid double,
-	 * but it could be the start of a valid double.
+	 * If number is followed by [eE][+-]?, then it is an invalid
+	 * double, but it could be the start of a valid double.
 	 */
 
 	if (*endPtr == 'e' || *endPtr == 'E') {
 	    ++endPtr;
 	    if (*endPtr == '+' || *endPtr == '-') {
@@ -657,40 +657,39 @@
     }
     return TCL_ERROR;
 }
 
 /*
- * This function checks for integer representations, which are valid when
- * linking with C variables, but which are invalid in other contexts in Tcl.
- * Handled are "+", "-", "", "0x", "0b", "0d" and "0o" (upper- and
- * lower-case).  See bug [39f6304c2e].
+ * This function checks for integer representations, which are valid
+ * when linking with C variables, but which are invalid in other
+ * contexts in Tcl. Handled are "+", "-", "", "0x", "0b", "0d" and "0o"
+ * (upperand lowercase). See bug [39f6304c2e].
  */
 
 static int
 GetInvalidIntFromObj(
     Tcl_Obj *objPtr,
     int *intPtr)
 {
-    size_t length;
-    const char *str = TclGetStringFromObj(objPtr, &length);
+    const char *str = TclGetString(objPtr);
 
-    if ((length == 0) ||
-	    ((length == 2) && (str[0] == '0') && strchr("xXbBoOdD", str[1]))) {
+    if ((objPtr->length == 0) || ((objPtr->length == 2) && (str[0] == '0')
+	    && strchr("xXbBoOdD", str[1]))) {
 	*intPtr = 0;
 	return TCL_OK;
-    } else if ((length == 1) && strchr("+-", str[0])) {
+    } else if ((objPtr->length == 1) && strchr("+-", str[0])) {
 	*intPtr = (str[0] == '+');
 	return TCL_OK;
     }
     return TCL_ERROR;
 }
 
 /*
- * This function checks for double representations, which are valid when
- * linking with C variables, but which are invalid in other contexts in Tcl.
- * Handled are "+", "-", "", ".", "0x", "0b" and "0o" (upper- and lower-case)
- * and sequences like "1e-". See bug [39f6304c2e].
+ * This function checks for double representations, which are valid
+ * when linking with C variables, but which are invalid in other
+ * contexts in Tcl. Handled are "+", "-", "", ".", "0x", "0b" and "0o"
+ * (upper- and lowercase) and sequences like "1e-". See bug [39f6304c2e].
  */
 
 static int
 GetInvalidDoubleFromObj(
     Tcl_Obj *objPtr,
@@ -742,11 +741,11 @@
     const char *name2,		/* Second part of variable name. */
     int flags)			/* Miscellaneous additional information. */
 {
     Link *linkPtr = clientData;
     int changed;
-    size_t valueLength = 0;
+    int valueLength;
     const char *value;
     char **pp;
     Tcl_Obj *valueObj;
     int valueInt;
     Tcl_WideInt valueWide;
@@ -766,11 +765,11 @@
 	    Tcl_DecrRefCount(linkPtr->varName);
 	    LinkFree(linkPtr);
 	} else if (flags & TCL_TRACE_DESTROYED) {
 	    Tcl_ObjSetVar2(interp, linkPtr->varName, NULL, ObjValue(linkPtr),
 		    TCL_GLOBAL_ONLY);
-	    Tcl_TraceVar2(interp, TclGetString(linkPtr->varName), NULL,
+	    Tcl_TraceVar2(interp, Tcl_GetString(linkPtr->varName), NULL,
 		    TCL_GLOBAL_ONLY|TCL_TRACE_READS|TCL_TRACE_WRITES
 		    |TCL_TRACE_UNSETS, LinkTraceProc, linkPtr);
 	}
 	return NULL;
     }
@@ -884,19 +883,20 @@
      * Special cases.
      */
 
     switch (linkPtr->type) {
     case TCL_LINK_STRING:
-	value = TclGetStringFromObj(valueObj, &valueLength);
+	value = TclGetString(valueObj);
+	valueLength = valueObj->length + 1;
 	pp = (char **) linkPtr->addr;
 
-	*pp = Tcl_Realloc(*pp, ++valueLength);
+	*pp = ckrealloc(*pp, valueLength);
 	memcpy(*pp, value, valueLength);
 	return NULL;
 
     case TCL_LINK_CHARS:
-	value = (char *) TclGetStringFromObj(valueObj, &valueLength);
+	value = (char *) Tcl_GetStringFromObj(valueObj, &valueLength);
 	valueLength++;		/* include end of string char */
 	if (valueLength > linkPtr->bytes) {
 	    return (char *) "wrong size of char* value";
 	}
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
@@ -907,11 +907,11 @@
 	    LinkedVar(char) = linkPtr->lastValue.c;
 	}
 	return NULL;
 
     case TCL_LINK_BINARY:
-	value = (char *) TclGetByteArrayFromObj(valueObj, &valueLength);
+	value = (char *) Tcl_GetByteArrayFromObj(valueObj, &valueLength);
 	if (valueLength != linkPtr->bytes) {
 	    return (char *) "wrong size of binary value";
 	}
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, value, (size_t) valueLength);
@@ -935,11 +935,11 @@
      * If we're working with an array of numbers, extract the Tcl list.
      */
 
     if (linkPtr->flags & LINK_ALLOC_LAST) {
 	if (Tcl_ListObjGetElements(NULL, (valueObj), &objc, &objv) == TCL_ERROR
-		|| (size_t)objc != linkPtr->numElems) {
+		|| objc != linkPtr->numElems) {
 	    return (char *) "wrong dimension";
 	}
     }
 
     switch (linkPtr->type) {
@@ -1275,181 +1275,181 @@
 ObjValue(
     Link *linkPtr)		/* Structure describing linked variable. */
 {
     char *p;
     Tcl_Obj *resultObj, **objv;
-    size_t i;
+    int i;
 
     switch (linkPtr->type) {
     case TCL_LINK_INT:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewIntObj(linkPtr->lastValue.iPtr[i]);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.i = LinkedVar(int);
 	return Tcl_NewIntObj(linkPtr->lastValue.i);
     case TCL_LINK_WIDE_INT:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewWideIntObj(linkPtr->lastValue.wPtr[i]);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.w = LinkedVar(Tcl_WideInt);
 	return Tcl_NewWideIntObj(linkPtr->lastValue.w);
     case TCL_LINK_DOUBLE:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewDoubleObj(linkPtr->lastValue.dPtr[i]);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.d = LinkedVar(double);
 	return Tcl_NewDoubleObj(linkPtr->lastValue.d);
     case TCL_LINK_BOOLEAN:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewBooleanObj(linkPtr->lastValue.iPtr[i] != 0);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.i = LinkedVar(int);
 	return Tcl_NewBooleanObj(linkPtr->lastValue.i);
     case TCL_LINK_CHAR:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewIntObj(linkPtr->lastValue.cPtr[i]);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.c = LinkedVar(char);
 	return Tcl_NewIntObj(linkPtr->lastValue.c);
     case TCL_LINK_UCHAR:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewIntObj(linkPtr->lastValue.ucPtr[i]);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.uc = LinkedVar(unsigned char);
 	return Tcl_NewIntObj(linkPtr->lastValue.uc);
     case TCL_LINK_SHORT:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewIntObj(linkPtr->lastValue.sPtr[i]);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.s = LinkedVar(short);
 	return Tcl_NewIntObj(linkPtr->lastValue.s);
     case TCL_LINK_USHORT:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewIntObj(linkPtr->lastValue.usPtr[i]);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.us = LinkedVar(unsigned short);
 	return Tcl_NewIntObj(linkPtr->lastValue.us);
     case TCL_LINK_UINT:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewWideIntObj(linkPtr->lastValue.uiPtr[i]);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.ui = LinkedVar(unsigned int);
 	return Tcl_NewWideIntObj((Tcl_WideInt) linkPtr->lastValue.ui);
 #if !defined(TCL_WIDE_INT_IS_LONG) && !defined(_WIN32) && !defined(__CYGWIN__)
     case TCL_LINK_LONG:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewWideIntObj(linkPtr->lastValue.lPtr[i]);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.l = LinkedVar(long);
 	return Tcl_NewWideIntObj((Tcl_WideInt) linkPtr->lastValue.l);
     case TCL_LINK_ULONG:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewWideIntObj(linkPtr->lastValue.ulPtr[i]);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.ul = LinkedVar(unsigned long);
 	return Tcl_NewWideIntObj((Tcl_WideInt) linkPtr->lastValue.ul);
 #endif
     case TCL_LINK_FLOAT:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewDoubleObj(linkPtr->lastValue.fPtr[i]);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.f = LinkedVar(float);
 	return Tcl_NewDoubleObj(linkPtr->lastValue.f);
     case TCL_LINK_WIDE_UINT:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
 	    memcpy(linkPtr->lastValue.aryPtr, linkPtr->addr, linkPtr->bytes);
-	    objv = Tcl_Alloc(linkPtr->numElems * sizeof(Tcl_Obj *));
+	    objv = ckalloc(linkPtr->numElems * sizeof(Tcl_Obj *));
 	    for (i=0; i < linkPtr->numElems; i++) {
 		objv[i] = Tcl_NewWideIntObj((Tcl_WideInt)
 			linkPtr->lastValue.uwPtr[i]);
 	    }
 	    resultObj = Tcl_NewListObj(linkPtr->numElems, objv);
-	    Tcl_Free(objv);
+	    ckfree(objv);
 	    return resultObj;
 	}
 	linkPtr->lastValue.uw = LinkedVar(Tcl_WideUInt);
 	return Tcl_NewWideIntObj((Tcl_WideInt) linkPtr->lastValue.uw);
 
@@ -1513,20 +1513,20 @@
 {
     if (linkPtr->nsPtr) {
 	TclNsDecrRefCount(linkPtr->nsPtr);
     }
     if (linkPtr->flags & LINK_ALLOC_ADDR) {
-	Tcl_Free(linkPtr->addr);
+	ckfree(linkPtr->addr);
     }
     if (linkPtr->flags & LINK_ALLOC_LAST) {
-	Tcl_Free(linkPtr->lastValue.aryPtr);
+	ckfree(linkPtr->lastValue.aryPtr);
     }
-    Tcl_Free(linkPtr);
+    ckfree((char *) linkPtr);
 }
 
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 4
  * fill-column: 78
  * End:
  */

Index: generic/tclListObj.c
==================================================================
--- generic/tclListObj.c
+++ generic/tclListObj.c
@@ -75,26 +75,24 @@
 /*
  *----------------------------------------------------------------------
  *
  * NewListIntRep --
  *
- *	Creates a 'List' structure with space for 'objc' elements.  'objc' must
- *	be > 0.  If 'objv' is not NULL, The list is initialized with first
- *	'objc' values in that array.  Otherwise the list is initialized to have
- *	0 elements, with space to add 'objc' more.  Flag value 'p' indicates
+ *	Creates a list internal rep with space for objc elements.  objc
+ *	must be > 0.  If objv!=NULL, initializes with the first objc values
+ *	in that array.  If objv==NULL, initalize list internal rep to have
+ *	0 elements, with space to add objc more.  Flag value "p" indicates
  *	how to behave on failure.
  *
- * Value
- *
- *	A new 'List' structure with refCount 0. If some failure
- *	prevents this NULL is returned if 'p' is 0 , and 'Tcl_Panic'
- *	is called if it is not.
- *
- * Effect
- *
- *	The refCount of each value in 'objv' is incremented as it is added
- *	to the list.
+ * Results:
+ *	A new List struct with refCount 0 is returned. If some failure
+ *	prevents this then if p=0, NULL is returned and otherwise the
+ *	routine panics.
+ *
+ * Side effects:
+ *	The ref counts of the elements in objv are incremented since the
+ *	resulting list now refers to them.
  *
  *----------------------------------------------------------------------
  */
 
 static List *
@@ -122,14 +120,14 @@
 		    LIST_MAX);
 	}
 	return NULL;
     }
 
-    listRepPtr = Tcl_AttemptAlloc(LIST_SIZE(objc));
+    listRepPtr = attemptckalloc(LIST_SIZE(objc));
     if (listRepPtr == NULL) {
 	if (p) {
-	    Tcl_Panic("list creation failed: unable to alloc %" TCL_Z_MODIFIER "u bytes",
+	    Tcl_Panic("list creation failed: unable to alloc %u bytes",
 		    LIST_SIZE(objc));
 	}
 	return NULL;
     }
 
@@ -154,13 +152,25 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
- *  AttemptNewList --
+ * AttemptNewList --
  *
- *	Like NewListIntRep, but additionally sets an error message on failure.
+ *	Creates a list internal rep with space for objc elements.  objc
+ *	must be > 0.  If objv!=NULL, initializes with the first objc values
+ *	in that array.  If objv==NULL, initalize list internal rep to have
+ *	0 elements, with space to add objc more.
+ *
+ * Results:
+ *	A new List struct with refCount 0 is returned. If some failure
+ *	prevents this then NULL is returned, and an error message is left
+ *	in the interp result, unless interp is NULL.
+ *
+ * Side effects:
+ *	The ref counts of the elements in objv are incremented since the
+ *	resulting list now refers to them.
  *
  *----------------------------------------------------------------------
  */
 
 static List *
@@ -176,11 +186,11 @@
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "max length of a Tcl list (%d elements) exceeded",
 		    LIST_MAX));
 	} else {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		    "list creation failed: unable to alloc %" TCL_Z_MODIFIER "u bytes",
+		    "list creation failed: unable to alloc %u bytes",
 		    LIST_SIZE(objc)));
 	}
 	Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
     }
     return listRepPtr;
@@ -189,24 +199,27 @@
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_NewListObj --
  *
- *	Creates a new list object and adds values to it. When TCL_MEM_DEBUG is
- *	defined, 'Tcl_DbNewListObj' is called instead.
- *
- * Value
- *
- *	A new list 'Tcl_Obj' to which is appended values from 'objv', or if
- *	'objc' is less than or equal to zero, a list 'Tcl_Obj' having no
- *	elements.  The string representation of the new 'Tcl_Obj' is set to
- *	NULL.  The refCount of the list is 0.
- *
- * Effect
- *
- *	The refCount of each elements in 'objv' is incremented as it is added
- *	to the list.
+ *	This function is normally called when not debugging: i.e., when
+ *	TCL_MEM_DEBUG is not defined. It creates a new list object from an
+ *	(objc,objv) array: that is, each of the objc elements of the array
+ *	referenced by objv is inserted as an element into a new Tcl object.
+ *
+ *	When TCL_MEM_DEBUG is defined, this function just returns the result
+ *	of calling the debugging version Tcl_DbNewListObj.
+ *
+ * Results:
+ *	A new list object is returned that is initialized from the object
+ *	pointers in objv. If objc is less than or equal to zero, an empty
+ *	object is returned. The new object's string representation is left
+ *	NULL. The resulting new list object has ref count 0.
+ *
+ * Side effects:
+ *	The ref counts of the elements in objv are incremented since the
+ *	resulting list now refers to them.
  *
  *----------------------------------------------------------------------
  */
 
 #ifdef TCL_MEM_DEBUG
@@ -253,18 +266,32 @@
 #endif /* if TCL_MEM_DEBUG */
 
 /*
  *----------------------------------------------------------------------
  *
- *  Tcl_DbNewListObj --
- *
- *	Like 'Tcl_NewListObj', but it calls Tcl_DbCkalloc directly with the
- *	file name and line number from its caller.  This simplifies debugging
- *	since the [memory active] command will report the correct file
- *	name and line number when reporting objects that haven't been freed.
- *
- *	When TCL_MEM_DEBUG is not defined, 'Tcl_NewListObj' is called instead.
+ * Tcl_DbNewListObj --
+ *
+ *	This function is normally called when debugging: i.e., when
+ *	TCL_MEM_DEBUG is defined. It creates new list objects. It is the same
+ *	as the Tcl_NewListObj function above except that it calls
+ *	Tcl_DbCkalloc directly with the file name and line number from its
+ *	caller. This simplifies debugging since then the [memory active]
+ *	command will report the correct file name and line number when
+ *	reporting objects that haven't been freed.
+ *
+ *	When TCL_MEM_DEBUG is not defined, this function just returns the
+ *	result of calling Tcl_NewListObj.
+ *
+ * Results:
+ *	A new list object is returned that is initialized from the object
+ *	pointers in objv. If objc is less than or equal to zero, an empty
+ *	object is returned. The new object's string representation is left
+ *	NULL. The new list object has ref count 0.
+ *
+ * Side effects:
+ *	The ref counts of the elements in objv are incremented since the
+ *	resulting list now refers to them.
  *
  *----------------------------------------------------------------------
  */
 
 #ifdef TCL_MEM_DEBUG
@@ -321,12 +348,23 @@
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_SetListObj --
  *
- *	Like 'Tcl_NewListObj', but operates on an existing 'Tcl_Obj'instead of
- *	creating a new one.
+ *	Modify an object to be a list containing each of the objc elements of
+ *	the object array referenced by objv.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The object is made a list object and is initialized from the object
+ *	pointers in objv. If objc is less than or equal to zero, an empty
+ *	object is returned. The new object's string representation is left
+ *	NULL. The ref counts of the elements in objv are incremented since the
+ *	list now refers to them. The object's old string and internal
+ *	representations are freed and its type is set NULL.
  *
  *----------------------------------------------------------------------
  */
 
 void
@@ -365,24 +403,22 @@
 /*
  *----------------------------------------------------------------------
  *
  * TclListObjCopy --
  *
- *	Creates a new 'Tcl_Obj' which is a pure copy of a list value. This
- *	provides for the C level a counterpart of the [lrange $list 0 end]
- *	command, while using internals details to be as efficient as possible.
- *
- * Value
- *
- *	The address of the new 'Tcl_Obj' which shares its internal
- *	representation with 'listPtr', and whose refCount is 0.  If 'listPtr'
- *	is not actually a list, the value is NULL, and an error message is left
- *	in 'interp' if it is not NULL.
- *
- * Effect
- *
- *	'listPtr' is converted to a list if it isn't one already.
+ *	Makes a "pure list" copy of a list value. This provides for the C
+ *	level a counterpart of the [lrange $list 0 end] command, while using
+ *	internals details to be as efficient as possible.
+ *
+ * Results:
+ *	Normally returns a pointer to a new Tcl_Obj, that contains the same
+ *	list value as *listPtr does. The returned Tcl_Obj has a refCount of
+ *	zero. If *listPtr does not hold a list, NULL is returned, and if
+ *	interp is non-NULL, an error message is recorded there.
+ *
+ * Side effects:
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 Tcl_Obj *
@@ -491,57 +527,53 @@
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_ListObjGetElements --
  *
- *	Retreive the elements in a list 'Tcl_Obj'.
- *
- * Value
- *
- *	TCL_OK
- *
- *	    A count of list elements is stored, 'objcPtr', And a pointer to the
- *	    array of elements in the list is stored in 'objvPtr'.
- *
- *	    The elements accessible via 'objvPtr' should be treated as readonly
- *	    and the refCount for each object is _not_ incremented; the caller
- *	    must do that if it holds on to a reference. Furthermore, the
- *	    pointer and length returned by this function may change as soon as
- *	    any function is called on the list object. Be careful about
- *	    retaining the pointer in a local data structure.
- *
- *	TCL_ERROR
- *
- *	    'listPtr' is not a valid list. An error message is left in the
- *	    interpreter's result if 'interp' is not NULL.
- *
- * Effect
- *
- *	'listPtr' is converted to a list object if it isn't one already.
+ *	This function returns an (objc,objv) array of the elements in a list
+ *	object.
+ *
+ * Results:
+ *	The return value is normally TCL_OK; in this case *objcPtr is set to
+ *	the count of list elements and *objvPtr is set to a pointer to an
+ *	array of (*objcPtr) pointers to each list element. If listPtr does not
+ *	refer to a list object and the object can not be converted to one,
+ *	TCL_ERROR is returned and an error message will be left in the
+ *	interpreter's result if interp is not NULL.
+ *
+ *	The objects referenced by the returned array should be treated as
+ *	readonly and their ref counts are _not_ incremented; the caller must
+ *	do that if it holds on to a reference. Furthermore, the pointer and
+ *	length returned by this function may change as soon as any function is
+ *	called on the list object; be careful about retaining the pointer in a
+ *	local data structure.
+ *
+ * Side effects:
+ *	The possible conversion of the object referenced by listPtr
+ *	to a list object.
  *
  *----------------------------------------------------------------------
  */
 
 int
 Tcl_ListObjGetElements(
     Tcl_Interp *interp,		/* Used to report errors if not NULL. */
-    register Tcl_Obj *listPtr,	/* List object for which an element array is
+    Tcl_Obj *listPtr,	/* List object for which an element array is
 				 * to be returned. */
     int *objcPtr,		/* Where to store the count of objects
 				 * referenced by objv. */
     Tcl_Obj ***objvPtr)		/* Where to store the pointer to an array of
 				 * pointers to the list's objects. */
 {
-    register List *listRepPtr;
+    List *listRepPtr;
 
     ListGetIntRep(listPtr, listRepPtr);
 
     if (listRepPtr == NULL) {
-	int result;
-	size_t length;
+	int result, length;
 
-	(void) TclGetStringFromObj(listPtr, &length);
+	(void) Tcl_GetStringFromObj(listPtr, &length);
 	if (length == 0) {
 	    *objcPtr = 0;
 	    *objvPtr = NULL;
 	    return TCL_OK;
 	}
@@ -559,39 +591,32 @@
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_ListObjAppendList --
  *
- *	Appends the elements of elemListPtr to those of listPtr.
- *
- * Value
- *
- *	TCL_OK
- *
- *	    Success.
- *
- *	TCL_ERROR
- *
- *	    'listPtr' or 'elemListPtr' are not valid lists.  An error
- *	    message is left in the interpreter's result if 'interp' is not NULL.
- *
- * Effect
- *
- *	The reference count of each element of 'elemListPtr' as it is added to
- *	'listPtr'. 'listPtr' and 'elemListPtr' are converted to 'tclListType'
- *	if they are not already. Appending the new elements may cause the
- *	array of element pointers in 'listObj' to grow.  If any objects are
- *	appended to 'listPtr'. Any preexisting string representation of
- *	'listPtr' is invalidated.
+ *	This function appends the elements in the list value referenced by
+ *	elemListPtr to the list value referenced by listPtr.
+ *
+ * Results:
+ *	The return value is normally TCL_OK. If listPtr or elemListPtr do not
+ *	refer to list values, TCL_ERROR is returned and an error message is
+ *	left in the interpreter's result if interp is not NULL.
+ *
+ * Side effects:
+ *	The reference counts of the elements in elemListPtr are incremented
+ *	since the list now refers to them. listPtr and elemListPtr are
+ *	converted, if necessary, to list objects. Also, appending the new
+ *	elements may cause listObj's array of element pointers to grow.
+ *	listPtr's old string representation, if any, is invalidated.
  *
  *----------------------------------------------------------------------
  */
 
 int
 Tcl_ListObjAppendList(
     Tcl_Interp *interp,		/* Used to report errors if not NULL. */
-    register Tcl_Obj *listPtr,	/* List object to append elements to. */
+    Tcl_Obj *listPtr,	/* List object to append elements to. */
     Tcl_Obj *elemListPtr)	/* List obj with elements to append. */
 {
     int objc;
     Tcl_Obj **objv;
 
@@ -618,31 +643,28 @@
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_ListObjAppendElement --
  *
- *	Like 'Tcl_ListObjAppendList', but Appends a single value to a list.
- *
- * Value
- *
- *	TCL_OK
- *
- *	    'objPtr' is appended to the elements of 'listPtr'.
- *
- *	TCL_ERROR
- *
- *	    listPtr does not refer to a list object and the object can not be
- *	    converted to one. An error message will be left in the
- *	    interpreter's result if interp is not NULL.
- *
- * Effect
- *
- *	If 'listPtr' is not already of type 'tclListType', it is converted.
- *	The 'refCount' of 'objPtr' is incremented as it is added to 'listPtr'.
- *	Appending the new element may cause the the array of element pointers
- *	in 'listObj' to grow.  Any preexisting string representation of
- *	'listPtr' is invalidated.
+ *	This function is a special purpose version of Tcl_ListObjAppendList:
+ *	it appends a single object referenced by objPtr to the list object
+ *	referenced by listPtr. If listPtr is not already a list object, an
+ *	attempt will be made to convert it to one.
+ *
+ * Results:
+ *	The return value is normally TCL_OK; in this case objPtr is added to
+ *	the end of listPtr's list. If listPtr does not refer to a list object
+ *	and the object can not be converted to one, TCL_ERROR is returned and
+ *	an error message will be left in the interpreter's result if interp is
+ *	not NULL.
+ *
+ * Side effects:
+ *	The ref count of objPtr is incremented since the list now refers to
+ *	it. listPtr will be converted, if necessary, to a list object. Also,
+ *	appending the new element may cause listObj's array of element
+ *	pointers to grow. listPtr's old string representation, if any, is
+ *	invalidated.
  *
  *----------------------------------------------------------------------
  */
 
 int
@@ -649,23 +671,22 @@
 Tcl_ListObjAppendElement(
     Tcl_Interp *interp,		/* Used to report errors if not NULL. */
     Tcl_Obj *listPtr,		/* List object to append objPtr to. */
     Tcl_Obj *objPtr)		/* Object to append to listPtr's list. */
 {
-    register List *listRepPtr, *newPtr = NULL;
+    List *listRepPtr, *newPtr = NULL;
     int numElems, numRequired, needGrow, isShared, attempt;
 
     if (Tcl_IsShared(listPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_ListObjAppendElement");
     }
 
     ListGetIntRep(listPtr, listRepPtr);
     if (listRepPtr == NULL) {
-	int result;
-	size_t length;
+	int result, length;
 
-	(void) TclGetStringFromObj(listPtr, &length);
+	(void) Tcl_GetStringFromObj(listPtr, &length);
 	if (length == 0) {
 	    Tcl_SetListObj(listPtr, 1, &objPtr);
 	    return TCL_OK;
 	}
 	result = SetListFromAny(interp, listPtr);
@@ -695,22 +716,22 @@
 	 * Need to grow + unshared intrep => try to realloc
 	 */
 
 	attempt = 2 * numRequired;
 	if (attempt <= LIST_MAX) {
-	    newPtr = Tcl_AttemptRealloc(listRepPtr, LIST_SIZE(attempt));
+	    newPtr = attemptckrealloc(listRepPtr, LIST_SIZE(attempt));
 	}
 	if (newPtr == NULL) {
 	    attempt = numRequired + 1 + TCL_MIN_ELEMENT_GROWTH;
 	    if (attempt > LIST_MAX) {
 		attempt = LIST_MAX;
 	    }
-	    newPtr = Tcl_AttemptRealloc(listRepPtr, LIST_SIZE(attempt));
+	    newPtr = attemptckrealloc(listRepPtr, LIST_SIZE(attempt));
 	}
 	if (newPtr == NULL) {
 	    attempt = numRequired;
-	    newPtr = Tcl_AttemptRealloc(listRepPtr, LIST_SIZE(attempt));
+	    newPtr = attemptckrealloc(listRepPtr, LIST_SIZE(attempt));
 	}
 	if (newPtr) {
 	    listRepPtr = newPtr;
 	    listRepPtr->maxElemCount = attempt;
 	    needGrow = 0;
@@ -764,11 +785,11 @@
 	    /*
 	     * Old intrep to be freed, re-use refCounts.
 	     */
 
 	    memcpy(dst, src, numElems * sizeof(Tcl_Obj *));
-	    Tcl_Free(listRepPtr);
+	    ckfree(listRepPtr);
 	}
 	listRepPtr = newPtr;
     }
     ListResetIntRep(listPtr, listRepPtr);
     listRepPtr->refCount++;
@@ -797,50 +818,45 @@
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_ListObjIndex --
  *
- * 	Retrieve a pointer to the element of 'listPtr' at 'index'.  The index
- * 	of the first element is 0.
- *
- * Value
- *
- * 	TCL_OK
- *
- *	    A pointer to the element at 'index' is stored in 'objPtrPtr'.  If
- *	    'index' is out of range, NULL is stored in 'objPtrPtr'.  This
- *	    object should be treated as readonly and its 'refCount' is _not_
- *	    incremented. The caller must do that if it holds on to the
- *	    reference.
- *
- * 	TCL_ERROR
- *
- * 	    'listPtr' is not a valid list. An an error message is left in the
- * 	    interpreter's result if 'interp' is not NULL.
- *
- *  Effect
- *
- * 	If 'listPtr' is not already of type 'tclListType', it is converted.
+ *	This function returns a pointer to the index'th object from the list
+ *	referenced by listPtr. The first element has index 0. If index is
+ *	negative or greater than or equal to the number of elements in the
+ *	list, a NULL is returned. If listPtr is not a list object, an attempt
+ *	will be made to convert it to a list.
+ *
+ * Results:
+ *	The return value is normally TCL_OK; in this case objPtrPtr is set to
+ *	the Tcl_Obj pointer for the index'th list element or NULL if index is
+ *	out of range. This object should be treated as readonly and its ref
+ *	count is _not_ incremented; the caller must do that if it holds on to
+ *	the reference. If listPtr does not refer to a list and can't be
+ *	converted to one, TCL_ERROR is returned and an error message is left
+ *	in the interpreter's result if interp is not NULL.
+ *
+ * Side effects:
+ *	listPtr will be converted, if necessary, to a list object.
  *
  *----------------------------------------------------------------------
  */
 
 int
 Tcl_ListObjIndex(
     Tcl_Interp *interp,		/* Used to report errors if not NULL. */
-    register Tcl_Obj *listPtr,	/* List object to index into. */
-    register int index,		/* Index of element to return. */
+    Tcl_Obj *listPtr,	/* List object to index into. */
+    int index,		/* Index of element to return. */
     Tcl_Obj **objPtrPtr)	/* The resulting Tcl_Obj* is stored here. */
 {
-    register List *listRepPtr;
+    List *listRepPtr;
 
     ListGetIntRep(listPtr, listRepPtr);
     if (listRepPtr == NULL) {
-	int result;
-	size_t length;
+	int result, length;
 
-	(void) TclGetStringFromObj(listPtr, &length);
+	(void) Tcl_GetStringFromObj(listPtr, &length);
 	if (length == 0) {
 	    *objPtrPtr = NULL;
 	    return TCL_OK;
 	}
 	result = SetListFromAny(interp, listPtr);
@@ -862,42 +878,40 @@
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_ListObjLength --
  *
- * 	Retrieve the number of elements in a list.
- *
- * Value
- *
- *	TCL_OK
- *
- *	    A count of list elements is stored at the address provided by
- *	    'intPtr'. If 'listPtr' is not already of type 'tclListPtr', it is
- *	    converted.
- *
- *	TCL_ERROR
- *
- *	    'listPtr' is not a valid list.  An error message will be left in
- *	    the interpreter's result if 'interp' is not NULL.
+ *	This function returns the number of elements in a list object. If the
+ *	object is not already a list object, an attempt will be made to
+ *	convert it to one.
+ *
+ * Results:
+ *	The return value is normally TCL_OK; in this case *intPtr will be set
+ *	to the integer count of list elements. If listPtr does not refer to a
+ *	list object and the object can not be converted to one, TCL_ERROR is
+ *	returned and an error message will be left in the interpreter's result
+ *	if interp is not NULL.
+ *
+ * Side effects:
+ *	The possible conversion of the argument object to a list object.
  *
  *----------------------------------------------------------------------
  */
 
 int
 Tcl_ListObjLength(
     Tcl_Interp *interp,		/* Used to report errors if not NULL. */
-    register Tcl_Obj *listPtr,	/* List object whose #elements to return. */
-    register int *intPtr)	/* The resulting int is stored here. */
+    Tcl_Obj *listPtr,	/* List object whose #elements to return. */
+    int *intPtr)	/* The resulting int is stored here. */
 {
-    register List *listRepPtr;
+    List *listRepPtr;
 
     ListGetIntRep(listPtr, listRepPtr);
     if (listRepPtr == NULL) {
-	int result;
-	size_t length;
+	int result, length;
 
-	(void) TclGetStringFromObj(listPtr, &length);
+	(void) Tcl_GetStringFromObj(listPtr, &length);
 	if (length == 0) {
 	    *intPtr = 0;
 	    return TCL_OK;
 	}
 	result = SetListFromAny(interp, listPtr);
@@ -914,40 +928,39 @@
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_ListObjReplace --
  *
- *	Replace values in a list.
- *
- *	If 'first' is zero or negative, it refers to the first element. If
- *	'first' outside the range of elements in the list, no elements are
- *	deleted.
- *
- *	If 'count' is zero or negative no elements are deleted, and any new
- *	elements are inserted at the beginning of the list.
- *
- * Value
- *
- *	TCL_OK
- *
- *	    The first 'objc' values of 'objv' replaced 'count' elements in 'listPtr'
- *	    starting at 'first'.  If 'objc' 0, no new elements are added.
- *
- *	TCL_ERROR
- *
- *	    'listPtr' is not a valid list.   An error message is left in the
- *	    interpreter's result if 'interp' is not NULL.
- *
- * Effect
- *
- *	If 'listPtr' is not of type 'tclListType', it is converted if possible.
- *
- *	The 'refCount' of each element appended to the list is incremented.
- *	Similarly, the 'refCount' for each replaced element is decremented.
- *
- *	If 'listPtr' is modified, any previous string representation is
- *	invalidated.
+ *	This function replaces zero or more elements of the list referenced by
+ *	listPtr with the objects from an (objc,objv) array. The objc elements
+ *	of the array referenced by objv replace the count elements in listPtr
+ *	starting at first.
+ *
+ *	If the argument first is zero or negative, it refers to the first
+ *	element. If first is greater than or equal to the number of elements
+ *	in the list, then no elements are deleted; the new elements are
+ *	appended to the list. Count gives the number of elements to replace.
+ *	If count is zero or negative then no elements are deleted; the new
+ *	elements are simply inserted before first.
+ *
+ *	The argument objv refers to an array of objc pointers to the new
+ *	elements to be added to listPtr in place of those that were deleted.
+ *	If objv is NULL, no new elements are added. If listPtr is not a list
+ *	object, an attempt will be made to convert it to one.
+ *
+ * Results:
+ *	The return value is normally TCL_OK. If listPtr does not refer to a
+ *	list object and can not be converted to one, TCL_ERROR is returned and
+ *	an error message will be left in the interpreter's result if interp is
+ *	not NULL.
+ *
+ * Side effects:
+ *	The ref counts of the objc elements in objv are incremented since the
+ *	resulting list now refers to them. Similarly, the ref counts for
+ *	replaced objects are decremented. listPtr is converted, if necessary,
+ *	to a list object. listPtr's old string representation, if any, is
+ *	freed.
  *
  *----------------------------------------------------------------------
  */
 
 int
@@ -959,22 +972,22 @@
     int objc,			/* Number of objects to insert. */
     Tcl_Obj *const objv[])	/* An array of objc pointers to Tcl objects to
 				 * insert. */
 {
     List *listRepPtr;
-    register Tcl_Obj **elemPtrs;
+    Tcl_Obj **elemPtrs;
     int needGrow, numElems, numRequired, numAfterLast, start, i, j, isShared;
 
     if (Tcl_IsShared(listPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_ListObjReplace");
     }
 
     ListGetIntRep(listPtr, listRepPtr);
     if (listRepPtr == NULL) {
-	size_t length;
+	int length;
 
-	(void) TclGetStringFromObj(listPtr, &length);
+	(void) Tcl_GetStringFromObj(listPtr, &length);
 	if (length == 0) {
 	    if (objc == 0) {
 		return TCL_OK;
 	    }
 	    Tcl_SetListObj(listPtr, objc, NULL);
@@ -1032,22 +1045,22 @@
     if (needGrow && !isShared) {
 	/* Try to use realloc */
 	List *newPtr = NULL;
 	int attempt = 2 * numRequired;
 	if (attempt <= LIST_MAX) {
-	    newPtr = Tcl_AttemptRealloc(listRepPtr, LIST_SIZE(attempt));
+	    newPtr = attemptckrealloc(listRepPtr, LIST_SIZE(attempt));
 	}
 	if (newPtr == NULL) {
 	    attempt = numRequired + 1 + TCL_MIN_ELEMENT_GROWTH;
 	    if (attempt > LIST_MAX) {
 		attempt = LIST_MAX;
 	    }
-	    newPtr = Tcl_AttemptRealloc(listRepPtr, LIST_SIZE(attempt));
+	    newPtr = attemptckrealloc(listRepPtr, LIST_SIZE(attempt));
 	}
 	if (newPtr == NULL) {
 	    attempt = numRequired;
-	    newPtr = Tcl_AttemptRealloc(listRepPtr, LIST_SIZE(attempt));
+	    newPtr = attemptckrealloc(listRepPtr, LIST_SIZE(attempt));
 	}
 	if (newPtr) {
 	    listRepPtr = newPtr;
 	    ListResetIntRep(listPtr, listRepPtr);
 	    elemPtrs = &listRepPtr->elements;
@@ -1078,11 +1091,11 @@
 	numAfterLast = numElems - start;
 	shift = objc - count;	/* numNewElems - numDeleted */
 	if ((numAfterLast > 0) && (shift != 0)) {
 	    Tcl_Obj **src = elemPtrs + start;
 
-	    memmove(src+shift, src, numAfterLast * sizeof(Tcl_Obj*));
+	    memmove(src+shift, src, (size_t) numAfterLast * sizeof(Tcl_Obj*));
 	}
     } else {
 	/*
 	 * Cannot use the current List struct; it is shared, too small, or
 	 * both. Allocate a new struct and insert elements into it.
@@ -1109,11 +1122,15 @@
 	    if (listRepPtr == NULL) {
 		listRepPtr = AttemptNewList(interp, numRequired, NULL);
 		if (listRepPtr == NULL) {
 		    for (i = 0;  i < objc;  i++) {
 			/* See bug 3598580 */
+#if TCL_MAJOR_VERSION > 8
 			Tcl_DecrRefCount(objv[i]);
+#else
+			objv[i]->refCount--;
+#endif
 		    }
 		    return TCL_ERROR;
 		}
 	    }
 	}
@@ -1170,11 +1187,11 @@
 	    if (numAfterLast > 0) {
 		memcpy(elemPtrs + first + objc, oldPtrs + start,
 			(size_t) numAfterLast * sizeof(Tcl_Obj *));
 	    }
 
-	    Tcl_Free(oldListRepPtr);
+	    ckfree(oldListRepPtr);
 	}
     }
 
     /*
      * Insert the new elements into elemPtrs before "first".
@@ -1207,23 +1224,26 @@
 /*
  *----------------------------------------------------------------------
  *
  * TclLindexList --
  *
- *	Implements the 'lindex' command when objc==3.
- *
- *	Implemented entirely as a wrapper around 'TclLindexFlat'. Reconfigures
- *	the argument format into required form while taking care to manage
- *	shimmering so as to tend to keep the most useful intreps
- *	and/or avoid the most expensive conversions.
- *
- * Value
- *
- *	A pointer to the specified element, with its 'refCount' incremented, or
- *	NULL if an error occurred.
- *
- * Notes
+ *	This procedure handles the 'lindex' command when objc==3.
+ *
+ * Results:
+ *	Returns a pointer to the object extracted, or NULL if an error
+ *	occurred. The returned object already includes one reference count for
+ *	the pointer returned.
+ *
+ * Side effects:
+ *	None.
+ *
+ * Notes:
+ *	This procedure is implemented entirely as a wrapper around
+ *	TclLindexFlat. All it does is reconfigure the argument format into the
+ *	form required by TclLindexFlat, while taking care to manage shimmering
+ *	in such a way that we tend to keep the most useful intreps and/or
+ *	avoid the most expensive conversions.
  *
  *----------------------------------------------------------------------
  */
 
 Tcl_Obj *
@@ -1231,11 +1251,11 @@
     Tcl_Interp *interp,		/* Tcl interpreter. */
     Tcl_Obj *listPtr,		/* List being unpacked. */
     Tcl_Obj *argPtr)		/* Index or index list. */
 {
 
-    size_t index;			/* Index into the list. */
+    int index;			/* Index into the list. */
     Tcl_Obj *indexListCopy;
     List *listRepPtr;
 
     /*
      * Determine whether argPtr designates a list or a single index. We have
@@ -1243,11 +1263,11 @@
      * shimmering; see TIP#22 and TIP#33 for the details.
      */
 
     ListGetIntRep(argPtr, listRepPtr);
     if ((listRepPtr == NULL)
-	    && TclGetIntForIndexM(NULL , argPtr, TCL_INDEX_START, &index) == TCL_OK) {
+	    && TclGetIntForIndexM(NULL , argPtr, 0, &index) == TCL_OK) {
 	/*
 	 * argPtr designates a single index.
 	 */
 
 	return TclLindexFlat(interp, listPtr, 1, &argPtr);
@@ -1286,24 +1306,29 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
- *  TclLindexFlat --
- *
- * 	The core of the 'lindex' command, with all index
- * 	arguments presented as a flat list.
- *
- *  Value
- *
- *	A pointer to the object extracted, with its 'refCount' incremented,  or
- *	NULL if an error occurred.  Thus, the calling code will usually do
- *	something like:
- *
- * 		Tcl_SetObjResult(interp, result);
- * 		Tcl_DecrRefCount(result);
- *
+ * TclLindexFlat --
+ *
+ *	This procedure is the core of the 'lindex' command, with all index
+ *	arguments presented as a flat list.
+ *
+ * Results:
+ *	Returns a pointer to the object extracted, or NULL if an error
+ *	occurred. The returned object already includes one reference count for
+ *	the pointer returned.
+ *
+ * Side effects:
+ *	None.
+ *
+ * Notes:
+ *	The reference count of the returned object includes one reference
+ *	corresponding to the pointer returned. Thus, the calling code will
+ *	usually do something like:
+ *		Tcl_SetObjResult(interp, result);
+ *		Tcl_DecrRefCount(result);
  *
  *----------------------------------------------------------------------
  */
 
 Tcl_Obj *
@@ -1317,12 +1342,11 @@
     int i;
 
     Tcl_IncrRefCount(listPtr);
 
     for (i=0 ; i<indexCount && listPtr ; i++) {
-	size_t index;
-	int listLen = 0;
+	int index, listLen = 0;
 	Tcl_Obj **elemPtrs = NULL, *sublistCopy;
 
 	/*
 	 * Here we make a private copy of the current sublist, so we avoid any
 	 * shimmering issues that might invalidate the elemPtr array below
@@ -1342,18 +1366,18 @@
 	}
 	TclListObjGetElements(NULL, sublistCopy, &listLen, &elemPtrs);
 
 	if (TclGetIntForIndexM(interp, indexArray[i], /*endValue*/ listLen-1,
 		&index) == TCL_OK) {
-	    if (index >= (size_t)listLen) {
+	    if (index<0 || index>=listLen) {
 		/*
 		 * Index is out of range. Break out of loop with empty result.
 		 * First check remaining indices for validity
 		 */
 
 		while (++i < indexCount) {
-		    if (TclGetIntForIndexM(interp, indexArray[i], TCL_INDEX_NONE, &index)
+		    if (TclGetIntForIndexM(interp, indexArray[i], -1, &index)
 			!= TCL_OK) {
 			Tcl_DecrRefCount(sublistCopy);
 			return NULL;
 		    }
 		}
@@ -1376,21 +1400,28 @@
 /*
  *----------------------------------------------------------------------
  *
  * TclLsetList --
  *
- *	The core of [lset] when objc == 4. Objv[2] may be either a
+ *	Core of the 'lset' command when objc == 4. Objv[2] may be either a
  *	scalar index or a list of indices.
  *      It also handles 'lpop' when given a NULL value.
  *
- *	Implemented entirely as a wrapper around 'TclLindexFlat', as described
- *	for 'TclLindexList'.
+ * Results:
+ *	Returns the new value of the list variable, or NULL if there was an
+ *	error. The returned object includes one reference count for the
+ *	pointer returned.
  *
- * Value
+ * Side effects:
+ *	None.
  *
- *	The new list, with the 'refCount' of 'valuPtr' incremented, or NULL if
- *	there was an error.
+ * Notes:
+ *	This procedure is implemented entirely as a wrapper around
+ *	TclLsetFlat. All it does is reconfigure the argument format into the
+ *	form required by TclLsetFlat, while taking care to manage shimmering
+ *	in such a way that we tend to keep the most useful intreps and/or
+ *	avoid the most expensive conversions.
  *
  *----------------------------------------------------------------------
  */
 
 Tcl_Obj *
@@ -1401,11 +1432,11 @@
     Tcl_Obj *valuePtr)		/* Value arg to 'lset' or NULL to 'lpop'. */
 {
     int indexCount = 0;		/* Number of indices in the index list. */
     Tcl_Obj **indices = NULL;	/* Vector of indices in the index list. */
     Tcl_Obj *retValuePtr;	/* Pointer to the list to be returned. */
-    size_t index;			/* Current index in the list - discarded. */
+    int index;			/* Current index in the list - discarded. */
     Tcl_Obj *indexListCopy;
     List *listRepPtr;
 
     /*
      * Determine whether the index arg designates a list or a single index.
@@ -1413,11 +1444,11 @@
      * shimmering; see TIP #22 and #23 for details.
      */
 
     ListGetIntRep(indexArgPtr, listRepPtr);
     if (listRepPtr == NULL
-	    && TclGetIntForIndexM(NULL, indexArgPtr, TCL_INDEX_START, &index) == TCL_OK) {
+	    && TclGetIntForIndexM(NULL, indexArgPtr, 0, &index) == TCL_OK) {
 	/*
 	 * indexArgPtr designates a single index.
 	 */
 
 	return TclLsetFlat(interp, listPtr, 1, &indexArgPtr, valuePtr);
@@ -1451,43 +1482,40 @@
  * TclLsetFlat --
  *
  *	Core engine of the 'lset' command.
  *      It also handles 'lpop' when given a NULL value.
  *
- * Value
- *
- *	The resulting list
- *
- *	    The 'refCount' of 'valuePtr' is incremented.  If 'listPtr' was not
- *	    duplicated, its 'refCount' is incremented.  The reference count of
- *	    an unduplicated object is therefore 2 (one for the returned pointer
- *	    and one for the variable that holds it).  The reference count of a
- *	    duplicate object is 1, reflecting that result is the only active
- *	    reference. The caller is expected to store the result in the
- *	    variable and decrement its reference count. (INST_STORE_* does
- *	    exactly this.)
- *
- *	NULL
- *
- *	    An error occurred.  If 'listPtr' was duplicated, the reference
- *	    count on the duplicate is decremented so that it is 0, causing any
- *	    memory allocated by this function to be freed.
- *
- *
- * Effect
- *
- *	On entry, the reference count of 'listPtr' does not reflect any
- *	references held on the stack. The first action of this function is to
- *	determine whether 'listPtr' is shared and to create a duplicate
- *	unshared copy if it is.  The reference count of the duplicate is
- *	incremented. At this point, the reference count is 1 in either case so
- *	that the object is considered unshared.
- *
- *	The unshared list is altered directly to produce the result.
- *	'TclLsetFlat' maintains a linked list of 'Tcl_Obj' values whose string
+ * Results:
+ *	Returns the new value of the list variable, or NULL if an error
+ *	occurred. The returned object includes one reference count for the
+ *	pointer returned.
+ *
+ * Side effects:
+ *	On entry, the reference count of the variable value does not reflect
+ *	any references held on the stack. The first action of this function is
+ *	to determine whether the object is shared, and to duplicate it if it
+ *	is. The reference count of the duplicate is incremented. At this
+ *	point, the reference count will be 1 for either case, so that the
+ *	object will appear to be unshared.
+ *
+ *	If an error occurs, and the object has been duplicated, the reference
+ *	count on the duplicate is decremented so that it is now 0: this
+ *	dismisses any memory that was allocated by this function.
+ *
+ *	If no error occurs, the reference count of the original object is
+ *	incremented if the object has not been duplicated, and nothing is done
+ *	to a reference count of the duplicate. Now the reference count of an
+ *	unduplicated object is 2 (the returned pointer, plus the one stored in
+ *	the variable). The reference count of a duplicate object is 1,
+ *	reflecting that the returned pointer is the only active reference. The
+ *	caller is expected to store the returned value back in the variable
+ *	and decrement its reference count. (INST_STORE_* does exactly this.)
+ *
+ *	Surgery is performed on the unshared list value to produce the result.
+ *	TclLsetFlat maintains a linked list of Tcl_Obj's whose string
  *	representations must be spoilt by threading via 'ptr2' of the
- *	two-pointer internal representation. On entry to 'TclLsetFlat', the
+ *	two-pointer internal representation. On entry to TclLsetFlat, the
  *	values of 'ptr2' are immaterial; on exit, the 'ptr2' field of any
  *	Tcl_Obj that has been modified is set to NULL.
  *
  *----------------------------------------------------------------------
  */
@@ -1499,12 +1527,11 @@
     int indexCount,		/* Number of index args. */
     Tcl_Obj *const indexArray[],
 				/* Index args. */
     Tcl_Obj *valuePtr)		/* Value arg to 'lset' or NULL to 'lpop'. */
 {
-    size_t index;
-    int result, len;
+    int index, result, len;
     Tcl_Obj *subListPtr, *retValuePtr, *chainPtr;
     Tcl_ObjIntRep *irPtr;
 
     /*
      * If there are no indices, simply return the new value.  (Without
@@ -1573,12 +1600,12 @@
 	    indexArray++;
 	    break;
 	}
 	indexArray++;
 
-	if (index > (size_t)elemCount
-		|| (valuePtr == NULL && index >= (size_t)elemCount)) {
+	if (index < 0 || index > elemCount
+		|| (valuePtr == NULL && index >= elemCount)) {
 	    /* ...the index points outside the sublist. */
 	    if (interp != NULL) {
 		Tcl_SetObjResult(interp,
 			Tcl_NewStringObj("list index out of range", -1));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION",
@@ -1596,11 +1623,11 @@
 	 * modify it.
 	 */
 
 	if (--indexCount) {
 	    parentList = subListPtr;
-	    if (index == (size_t)elemCount) {
+	    if (index == elemCount) {
 		subListPtr = Tcl_NewObj();
 	    } else {
 		subListPtr = elemPtrs[index];
 	    }
 	    if (Tcl_IsShared(subListPtr)) {
@@ -1614,11 +1641,11 @@
 	     * Tcl_Obj's.  Dealing with the shared intrep case can cause
 	     * subListPtr to become shared again, so detect that case and make
 	     * and store another copy.
 	     */
 
-	    if (index == (size_t)elemCount) {
+	    if (index == elemCount) {
 		Tcl_ListObjAppendElement(NULL, parentList, subListPtr);
 	    } else {
 		TclListObjSetElement(NULL, parentList, index, subListPtr);
 	    }
 	    if (Tcl_IsShared(subListPtr)) {
@@ -1703,11 +1730,11 @@
 
     len = -1;
     TclListObjLength(NULL, subListPtr, &len);
     if (valuePtr == NULL) {
 	Tcl_ListObjReplace(NULL, subListPtr, index, 1, 0, NULL);
-    } else if (index == (size_t)len) {
+    } else if (index == len) {
 	Tcl_ListObjAppendElement(NULL, subListPtr, valuePtr);
     } else {
 	TclListObjSetElement(NULL, subListPtr, index, valuePtr);
 	TclInvalidateStringRep(subListPtr);
     }
@@ -1718,42 +1745,30 @@
 /*
  *----------------------------------------------------------------------
  *
  * TclListObjSetElement --
  *
- *	Set a single element of a list to a specified value.
+ *	Set a single element of a list to a specified value
+ *
+ * Results:
+ *	The return value is normally TCL_OK. If listPtr does not refer to a
+ *	list object and cannot be converted to one, TCL_ERROR is returned and
+ *	an error message will be left in the interpreter result if interp is
+ *	not NULL. Similarly, if index designates an element outside the range
+ *	[0..listLength-1], where listLength is the count of elements in the
+ *	list object designated by listPtr, TCL_ERROR is returned and an error
+ *	message is left in the interpreter result.
+ *
+ * Side effects:
+ *	Tcl_Panic if listPtr designates a shared object. Otherwise, attempts
+ *	to convert it to a list with a non-shared internal rep. Decrements the
+ *	ref count of the object at the specified index within the list,
+ *	replaces with the object designated by valuePtr, and increments the
+ *	ref count of the replacement object.
  *
  *	It is the caller's responsibility to invalidate the string
- *	representation of the 'listPtr'.
- *
- * Value
- *
- * 	TCL_OK
- *
- *	    Success.
- *
- *	TCL_ERROR
- *
- *	    'listPtr' does not refer to a list object and cannot be converted
- *	    to one.  An error message will be left in the interpreter result if
- *	    interp is not NULL.
- *
- *	TCL_ERROR
- *
- *	    An index designates an element outside the range [0..listLength-1],
- *	    where 'listLength' is the count of elements in the list object
- *	    designated by 'listPtr'.  An error message is left in the
- *	    interpreter result.
- *
- * Effect
- *
- *	If 'listPtr' designates a shared object, 'Tcl_Panic' is called.  If
- *	'listPtr' is not already of type 'tclListType', it is converted and the
- *	internal representation is unshared. The 'refCount' of the element at
- *	'index' is decremented and replaced in the list with the 'valuePtr',
- *	whose 'refCount' in turn is incremented.
- *
+ *	representation of the object.
  *
  *----------------------------------------------------------------------
  */
 
 int
@@ -1779,14 +1794,13 @@
 	Tcl_Panic("%s called with shared object", "TclListObjSetElement");
     }
 
     ListGetIntRep(listPtr, listRepPtr);
     if (listRepPtr == NULL) {
-	int result;
-	size_t length;
+	int result, length;
 
-	(void) TclGetStringFromObj(listPtr, &length);
+	(void) Tcl_GetStringFromObj(listPtr, &length);
 	if (length == 0) {
 	    if (interp != NULL) {
 		Tcl_SetObjResult(interp,
 			Tcl_NewStringObj("list index out of range", -1));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "LSET",
@@ -1884,15 +1898,17 @@
 /*
  *----------------------------------------------------------------------
  *
  * FreeListInternalRep --
  *
- *	Deallocate the storage associated with the internal representation of a
- *	a list object.
+ *	Deallocate the storage associated with a list object's internal
+ *	representation.
+ *
+ * Results:
+ *	None.
  *
- * Effect
- *
+ * Side effects:
  *	Frees listPtr's List* internal representation, if no longer shared.
  *	May decrement the ref counts of element objects, which may free them.
  *
  *----------------------------------------------------------------------
  */
@@ -1911,25 +1927,27 @@
 	int i, numElems = listRepPtr->elemCount;
 
 	for (i = 0;  i < numElems;  i++) {
 	    Tcl_DecrRefCount(elemPtrs[i]);
 	}
-	Tcl_Free(listRepPtr);
+	ckfree(listRepPtr);
     }
 }
 
 /*
  *----------------------------------------------------------------------
  *
  * DupListInternalRep --
  *
- *	Initialize the internal representation of a list 'Tcl_Obj' to share the
+ *	Initialize the internal representation of a list Tcl_Obj to share the
  *	internal representation of an existing list object.
  *
- * Effect
+ * Results:
+ *	None.
  *
- *	The 'refCount' of the List internal rep is incremented.
+ * Side effects:
+ *	The reference count of the List internal rep is incremented.
  *
  *----------------------------------------------------------------------
  */
 
 static void
@@ -1947,24 +1965,20 @@
 /*
  *----------------------------------------------------------------------
  *
  * SetListFromAny --
  *
- *	Convert any object to a list.
- *
- * Value
- *
- *    TCL_OK
- *
- *	Success.  The internal representation of 'objPtr' is set, and the type
- *	of 'objPtr' is 'tclListType'.
- *
- *    TCL_ERROR
- *
- *	An error occured during conversion. An error message is left in the
- *	interpreter's result if 'interp' is not NULL.
- *
+ *	Attempt to generate a list internal form for the Tcl object "objPtr".
+ *
+ * Results:
+ *	The return value is TCL_OK or TCL_ERROR. If an error occurs during
+ *	conversion, an error message is left in the interpreter's result
+ *	unless "interp" is NULL.
+ *
+ * Side effects:
+ *	If no error occurs, a list is stored as "objPtr"s internal
+ *	representation.
  *
  *----------------------------------------------------------------------
  */
 
 static int
@@ -2016,12 +2030,11 @@
 	    Tcl_IncrRefCount(keyPtr);
 	    Tcl_IncrRefCount(valuePtr);
 	    Tcl_DictObjNext(&search, &keyPtr, &valuePtr, &done);
 	}
     } else {
-	int estCount;
-	size_t length;
+	int estCount, length;
 	const char *limit, *nextElem = TclGetStringFromObj(objPtr, &length);
 
 	/*
 	 * Allocate enough space to hold a (Tcl_Obj *) for each
 	 * (possible) list element.
@@ -2041,20 +2054,19 @@
 	 */
 
 	while (nextElem < limit) {
 	    const char *elemStart;
 	    char *check;
-	    size_t elemSize;
-	    int literal;
+	    int elemSize, literal;
 
 	    if (TCL_OK != TclFindElement(interp, nextElem, limit - nextElem,
 		    &elemStart, &nextElem, &elemSize, &literal)) {
 	    fail:
 		while (--elemPtrs >= &listRepPtr->elements) {
 		    Tcl_DecrRefCount(*elemPtrs);
 		}
-		Tcl_Free(listRepPtr);
+		ckfree(listRepPtr);
 		return TCL_ERROR;
 	    }
 	    if (elemStart == limit) {
 		break;
 	    }
@@ -2095,20 +2107,22 @@
 /*
  *----------------------------------------------------------------------
  *
  * UpdateStringOfList --
  *
- *	Update the string representation for a list object.
- *
- *	Any previously-exising string representation is not invalidated, so
- *	storage is lost if this has not been taken care of.
- *
- * Effect
- *
- *	The string representation of 'listPtr' is set to the resulting string.
- *	This string will be empty if the list has no elements. It is assumed
- *	that the list internal representation is not NULL.
+ *	Update the string representation for a list object. Note: This
+ *	function does not invalidate an existing old string rep so storage
+ *	will be lost if this has not already been done.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The object's string is set to a valid string that results from the
+ *	list-to-string conversion. This string will be empty if the list has
+ *	no elements. The list internal representation should not be NULL and
+ *	we assume it is not NULL.
  *
  *----------------------------------------------------------------------
  */
 
 static void
@@ -2115,12 +2129,11 @@
 UpdateStringOfList(
     Tcl_Obj *listPtr)		/* List object with string rep to update. */
 {
 #   define LOCAL_SIZE 64
     char localFlags[LOCAL_SIZE], *flagPtr = NULL;
-    int numElems, i;
-    size_t length, bytesNeeded = 0;
+    int numElems, i, length, bytesNeeded = 0;
     const char *elem, *start;
     char *dst;
     Tcl_Obj **elemPtrs;
     List *listRepPtr;
 
@@ -2156,17 +2169,23 @@
     } else {
 	/*
 	 * We know numElems <= LIST_MAX, so this is safe.
 	 */
 
-	flagPtr = Tcl_Alloc(numElems);
+	flagPtr = ckalloc(numElems);
     }
     elemPtrs = &listRepPtr->elements;
     for (i = 0; i < numElems; i++) {
 	flagPtr[i] = (i ? TCL_DONT_QUOTE_HASH : 0);
 	elem = TclGetStringFromObj(elemPtrs[i], &length);
 	bytesNeeded += TclScanElement(elem, length, flagPtr+i);
+	if (bytesNeeded < 0) {
+	    Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
+	}
+    }
+    if (bytesNeeded > INT_MAX - numElems + 1) {
+	Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
     }
     bytesNeeded += numElems - 1;
 
     /*
      * Pass 2: copy into string rep buffer.
@@ -2183,11 +2202,11 @@
 
     /* Set the string length to what was actually written, the safe choice */
     (void) Tcl_InitStringRep(listPtr, NULL, dst - 1 - start);
 
     if (flagPtr != localFlags) {
-	Tcl_Free(flagPtr);
+	ckfree(flagPtr);
     }
 }
 
 /*
  * Local Variables:

Index: generic/tclLiteral.c
==================================================================
--- generic/tclLiteral.c
+++ generic/tclLiteral.c
@@ -29,11 +29,11 @@
  */
 
 static int		AddLocalLiteralEntry(CompileEnv *envPtr,
 			    Tcl_Obj *objPtr, int localHash);
 static void		ExpandLocalLiteralArray(CompileEnv *envPtr);
-static size_t		HashString(const char *string, size_t length);
+static unsigned		HashString(const char *string, int length);
 #ifdef TCL_COMPILE_DEBUG
 static LiteralEntry *	LookupLiteralEntry(Tcl_Interp *interp,
 			    Tcl_Obj *objPtr);
 #endif
 static void		RebuildLiteralTable(LiteralTable *tablePtr);
@@ -56,11 +56,11 @@
  *----------------------------------------------------------------------
  */
 
 void
 TclInitLiteralTable(
-    register LiteralTable *tablePtr)
+    LiteralTable *tablePtr)
 				/* Pointer to table structure, which is
 				 * supplied by the caller. */
 {
 #if (TCL_SMALL_HASH_TABLE != 4)
     Tcl_Panic("%s: TCL_SMALL_HASH_TABLE is %d, not 4", "TclInitLiteralTable",
@@ -129,21 +129,21 @@
 	entryPtr = tablePtr->buckets[i];
 	while (entryPtr != NULL) {
 	    objPtr = entryPtr->objPtr;
 	    TclDecrRefCount(objPtr);
 	    nextPtr = entryPtr->nextPtr;
-	    Tcl_Free(entryPtr);
+	    ckfree(entryPtr);
 	    entryPtr = nextPtr;
 	}
     }
 
     /*
      * Free up the table's bucket array if it was dynamically allocated.
      */
 
     if (tablePtr->buckets != tablePtr->staticBuckets) {
-	Tcl_Free(tablePtr->buckets);
+	ckfree(tablePtr->buckets);
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -174,28 +174,28 @@
 Tcl_Obj *
 TclCreateLiteral(
     Interp *iPtr,
     const char *bytes,	/* The start of the string. Note that this is
 				 * not a NUL-terminated string. */
-    size_t length,		/* Number of bytes in the string. */
-    size_t hash,		/* The string's hash. If -1, it will be
+    int length,			/* Number of bytes in the string. */
+    unsigned hash,		/* The string's hash. If -1, it will be
 				 * computed here. */
     int *newPtr,
     Namespace *nsPtr,
     int flags,
     LiteralEntry **globalPtrPtr)
 {
     LiteralTable *globalTablePtr = &iPtr->literalTable;
     LiteralEntry *globalPtr;
-    size_t globalHash;
+    unsigned int globalHash;
     Tcl_Obj *objPtr;
 
     /*
      * Is it in the interpreter's global literal table?
      */
 
-    if (hash == TCL_AUTO_LENGTH) {
+    if (hash == (unsigned) -1) {
 	hash = HashString(bytes, length);
     }
     globalHash = (hash & globalTablePtr->mask);
     for (globalPtr=globalTablePtr->buckets[globalHash] ; globalPtr!=NULL;
 	    globalPtr = globalPtr->nextPtr) {
@@ -206,12 +206,12 @@
 	     * is not guaranteed so we need to be careful anyway.
 	     *
 	     * https://stackoverflow.com/q/54337750/301832
 	     */
 
-	    size_t objLength;
-	    char *objBytes = TclGetStringFromObj(objPtr, &objLength);
+	    int objLength;
+	    const char *objBytes = TclGetStringFromObj(objPtr, &objLength);
 
 	    if ((objLength == length) && ((length == 0)
 		    || ((objBytes[0] == bytes[0])
 		    && (memcmp(objBytes, bytes, length) == 0)))) {
 		/*
@@ -223,22 +223,22 @@
 		}
 		if (globalPtrPtr) {
 		    *globalPtrPtr = globalPtr;
 		}
 		if (flags & LITERAL_ON_HEAP) {
-		    Tcl_Free((void *)bytes);
+		    ckfree(bytes);
 		}
-		if (globalPtr->refCount != TCL_AUTO_LENGTH) {
+		if (globalPtr->refCount != (unsigned) -1) {
 		    globalPtr->refCount++;
 		}
 		return objPtr;
 	    }
 	}
     }
     if (!newPtr) {
 	if ((flags & LITERAL_ON_HEAP)) {
-	    Tcl_Free((void *)bytes);
+	    ckfree(bytes);
 	}
 	return NULL;
     }
 
     /*
@@ -270,15 +270,15 @@
      * Yes, add it to the global literal table.
      */
 #ifdef TCL_COMPILE_DEBUG
     if (LookupLiteralEntry((Tcl_Interp *) iPtr, objPtr) != NULL) {
 	Tcl_Panic("%s: literal \"%.*s\" found globally but shouldn't be",
-		"TclRegisterLiteral", (length>60? 60 : (int)length), bytes);
+		"TclRegisterLiteral", (length>60? 60 : length), bytes);
     }
 #endif
 
-    globalPtr = Tcl_Alloc(sizeof(LiteralEntry));
+    globalPtr = ckalloc(sizeof(LiteralEntry));
     globalPtr->objPtr = objPtr;
     Tcl_IncrRefCount(objPtr);
     globalPtr->refCount = 1;
     globalPtr->nsPtr = nsPtr;
     globalPtr->nextPtr = globalTablePtr->buckets[globalHash];
@@ -310,11 +310,11 @@
 		}
 	    }
 	}
 	if (!found) {
 	    Tcl_Panic("%s: literal \"%.*s\" wasn't global",
-		    "TclRegisterLiteral", (length>60? 60 : (int)length), bytes);
+		    "TclRegisterLiteral", (length>60? 60 : length), bytes);
 	}
     }
 #endif /*TCL_COMPILE_DEBUG*/
 
 #ifdef TCL_COMPILE_STATS
@@ -347,14 +347,14 @@
 
 Tcl_Obj *
 TclFetchLiteral(
     CompileEnv *envPtr,		/* Points to the CompileEnv from which to
 				 * fetch the registered literal value. */
-    size_t index)		/* Index of the desired literal, as returned
+    unsigned int index)		/* Index of the desired literal, as returned
 				 * by prior call to TclRegisterLiteral() */
 {
-    if (index >= (size_t) envPtr->literalArrayNext) {
+    if (index >= (unsigned int) envPtr->literalArrayNext) {
 	return NULL;
     }
     return envPtr->literalArrayPtr[index].objPtr;
 }
 
@@ -387,14 +387,14 @@
 
 int
 TclRegisterLiteral(
     void *ePtr,		/* Points to the CompileEnv in whose object
 				 * array an object is found or created. */
-    register const char *bytes,	/* Points to string for which to find or
+    const char *bytes,	/* Points to string for which to find or
 				 * create an object in CompileEnv's object
 				 * array. */
-    size_t length,			/* Number of bytes in the string. If -1, the
+    int length,			/* Number of bytes in the string. If < 0, the
 				 * string consists of all bytes up to the
 				 * first null character. */
     int flags)			/* If LITERAL_ON_HEAP then the caller already
 				 * malloc'd bytes and ownership is passed to
 				 * this function. If LITERAL_CMD_NAME then
@@ -404,15 +404,16 @@
     CompileEnv *envPtr = ePtr;
     Interp *iPtr = envPtr->iPtr;
     LiteralTable *localTablePtr = &envPtr->localLitTable;
     LiteralEntry *globalPtr, *localPtr;
     Tcl_Obj *objPtr;
-    size_t hash, localHash, objIndex;
-    int new;
+    unsigned hash;
+    unsigned int localHash;
+    int objIndex, isNew;
     Namespace *nsPtr;
 
-    if (length == TCL_AUTO_LENGTH) {
+    if (length < 0) {
 	length = (bytes ? strlen(bytes) : 0);
     }
     hash = HashString(bytes, length);
 
     /*
@@ -426,11 +427,11 @@
 	objPtr = localPtr->objPtr;
 	if ((objPtr->length == length) && ((length == 0)
 		|| ((objPtr->bytes[0] == bytes[0])
 		&& (memcmp(objPtr->bytes, bytes, length) == 0)))) {
 	    if ((flags & LITERAL_ON_HEAP)) {
-		Tcl_Free((void *)bytes);
+		ckfree(bytes);
 	    }
 	    objIndex = (localPtr - envPtr->literalArrayPtr);
 #ifdef TCL_COMPILE_DEBUG
 	    TclVerifyLocalLiteralTable(envPtr);
 #endif /*TCL_COMPILE_DEBUG*/
@@ -459,18 +460,18 @@
     /*
      * Is it in the interpreter's global literal table? If not, create it.
      */
 
     globalPtr = NULL;
-    objPtr = TclCreateLiteral(iPtr, bytes, length, hash, &new, nsPtr, flags,
+    objPtr = TclCreateLiteral(iPtr, bytes, length, hash, &isNew, nsPtr, flags,
 	    &globalPtr);
     objIndex = AddLocalLiteralEntry(envPtr, objPtr, localHash);
 
 #ifdef TCL_COMPILE_DEBUG
-    if (globalPtr != NULL && (globalPtr->refCount + 1 < 2)) {
-	Tcl_Panic("%s: global literal \"%.*s\" had bad refCount %" TCL_Z_MODIFIER "u",
-		"TclRegisterLiteral", (length>60? 60 : (int)length), bytes,
+    if (globalPtr != NULL && globalPtr->refCount + 1 < 2) {
+	Tcl_Panic("%s: global literal \"%.*s\" had bad refCount %d",
+		"TclRegisterLiteral", (length>60? 60 : length), bytes,
 		globalPtr->refCount);
     }
     TclVerifyLocalLiteralTable(envPtr);
 #endif /*TCL_COMPILE_DEBUG*/
     return objIndex;
@@ -496,19 +497,19 @@
 
 static LiteralEntry *
 LookupLiteralEntry(
     Tcl_Interp *interp,		/* Interpreter for which objPtr was created to
 				 * hold a literal. */
-    register Tcl_Obj *objPtr)	/* Points to a Tcl object holding a literal
+    Tcl_Obj *objPtr)	/* Points to a Tcl object holding a literal
 				 * that was previously created by a call to
 				 * TclRegisterLiteral. */
 {
     Interp *iPtr = (Interp *) interp;
     LiteralTable *globalTablePtr = &iPtr->literalTable;
-    register LiteralEntry *entryPtr;
+    LiteralEntry *entryPtr;
     const char *bytes;
-    size_t globalHash, length;
+    int length, globalHash;
 
     bytes = TclGetStringFromObj(objPtr, &length);
     globalHash = (HashString(bytes, length) & globalTablePtr->mask);
     for (entryPtr=globalTablePtr->buckets[globalHash] ; entryPtr!=NULL;
 	    entryPtr=entryPtr->nextPtr) {
@@ -542,18 +543,19 @@
 
 void
 TclHideLiteral(
     Tcl_Interp *interp,		/* Interpreter for which objPtr was created to
 				 * hold a literal. */
-    register CompileEnv *envPtr,/* Points to CompileEnv whose literal array
+    CompileEnv *envPtr,/* Points to CompileEnv whose literal array
 				 * contains the entry being hidden. */
     int index)			/* The index of the entry in the literal
 				 * array. */
 {
     LiteralEntry **nextPtrPtr, *entryPtr, *lPtr;
     LiteralTable *localTablePtr = &envPtr->localLitTable;
-    size_t localHash, length;
+    unsigned int localHash;
+    int length;
     const char *bytes;
     Tcl_Obj *newObjPtr;
 
     lPtr = &envPtr->literalArrayPtr[index];
 
@@ -605,18 +607,18 @@
  *----------------------------------------------------------------------
  */
 
 int
 TclAddLiteralObj(
-    register CompileEnv *envPtr,/* Points to CompileEnv in whose literal array
+    CompileEnv *envPtr,/* Points to CompileEnv in whose literal array
 				 * the object is to be inserted. */
     Tcl_Obj *objPtr,		/* The object to insert into the array. */
     LiteralEntry **litPtrPtr)	/* The location where the pointer to the new
 				 * literal entry should be stored. May be
 				 * NULL. */
 {
-    register LiteralEntry *lPtr;
+    LiteralEntry *lPtr;
     int objIndex;
 
     if (envPtr->literalArrayNext >= envPtr->literalArrayEnd) {
 	ExpandLocalLiteralArray(envPtr);
     }
@@ -624,11 +626,11 @@
     envPtr->literalArrayNext++;
 
     lPtr = &envPtr->literalArrayPtr[objIndex];
     lPtr->objPtr = objPtr;
     Tcl_IncrRefCount(objPtr);
-    lPtr->refCount = TCL_AUTO_LENGTH;	/* i.e., unused */
+    lPtr->refCount = (unsigned) -1;	/* i.e., unused */
     lPtr->nextPtr = NULL;
 
     if (litPtrPtr) {
 	*litPtrPtr = lPtr;
     }
@@ -654,16 +656,16 @@
  *----------------------------------------------------------------------
  */
 
 static int
 AddLocalLiteralEntry(
-    register CompileEnv *envPtr,/* Points to CompileEnv in whose literal array
+    CompileEnv *envPtr,/* Points to CompileEnv in whose literal array
 				 * the object is to be inserted. */
     Tcl_Obj *objPtr,		/* The literal to add to the CompileEnv. */
     int localHash)		/* Hash value for the literal's string. */
 {
-    register LiteralTable *localTablePtr = &envPtr->localLitTable;
+    LiteralTable *localTablePtr = &envPtr->localLitTable;
     LiteralEntry *localPtr;
     int objIndex;
 
     objIndex = TclAddLiteralObj(envPtr, objPtr, &localPtr);
 
@@ -686,12 +688,12 @@
 
 #ifdef TCL_COMPILE_DEBUG
     TclVerifyLocalLiteralTable(envPtr);
     {
 	char *bytes;
-	int found;
-	size_t length, i;
+	int length, found;
+	size_t i;
 
 	found = 0;
 	for (i=0 ; i<localTablePtr->numBuckets ; i++) {
 	    for (localPtr=localTablePtr->buckets[i] ; localPtr!=NULL ;
 		    localPtr=localPtr->nextPtr) {
@@ -702,11 +704,11 @@
 	}
 
 	if (!found) {
 	    bytes = TclGetStringFromObj(objPtr, &length);
 	    Tcl_Panic("%s: literal \"%.*s\" wasn't found locally",
-		    "AddLocalLiteralEntry", (length>60? 60 : (int)length), bytes);
+		    "AddLocalLiteralEntry", (length>60? 60 : length), bytes);
 	}
     }
 #endif /*TCL_COMPILE_DEBUG*/
 
     return objIndex;
@@ -732,11 +734,11 @@
  *----------------------------------------------------------------------
  */
 
 static void
 ExpandLocalLiteralArray(
-    register CompileEnv *envPtr)/* Points to the CompileEnv whose object array
+    CompileEnv *envPtr)/* Points to the CompileEnv whose object array
 				 * must be enlarged. */
 {
     /*
      * The current allocated local literal entries are stored between elements
      * 0 and (envPtr->literalArrayNext - 1) [inclusive].
@@ -754,18 +756,18 @@
 	Tcl_Panic("max size of Tcl literal array (%" TCL_Z_MODIFIER "u literals) exceeded",
 		currElems);
     }
 
     if (envPtr->mallocedLiteralArray) {
-	newArrayPtr = Tcl_Realloc(currArrayPtr, newSize);
+	newArrayPtr = ckrealloc(currArrayPtr, newSize);
     } else {
 	/*
-	 * envPtr->literalArrayPtr isn't a Tcl_Alloc'd pointer, so we must
-	 * code a Tcl_Realloc equivalent for ourselves.
+	 * envPtr->literalArrayPtr isn't a ckalloc'd pointer, so we must
+	 * code a ckrealloc equivalent for ourselves.
 	 */
 
-	newArrayPtr = Tcl_Alloc(newSize);
+	newArrayPtr = ckalloc(newSize);
 	memcpy(newArrayPtr, currArrayPtr, currBytes);
 	envPtr->mallocedLiteralArray = 1;
     }
 
     /*
@@ -814,27 +816,28 @@
 
 void
 TclReleaseLiteral(
     Tcl_Interp *interp,		/* Interpreter for which objPtr was created to
 				 * hold a literal. */
-    register Tcl_Obj *objPtr)	/* Points to a literal object that was
+    Tcl_Obj *objPtr)	/* Points to a literal object that was
 				 * previously created by a call to
 				 * TclRegisterLiteral. */
 {
     Interp *iPtr = (Interp *) interp;
     LiteralTable *globalTablePtr;
-    register LiteralEntry *entryPtr, *prevPtr;
+    LiteralEntry *entryPtr, *prevPtr;
     const char *bytes;
-    size_t length, index;
+    int length;
+    unsigned int index;
 
     if (iPtr == NULL) {
 	goto done;
     }
 
     globalTablePtr = &iPtr->literalTable;
     bytes = TclGetStringFromObj(objPtr, &length);
-    index = HashString(bytes, length) & globalTablePtr->mask;
+    index = (HashString(bytes, length) & globalTablePtr->mask);
 
     /*
      * Check to see if the object is in the global literal table and remove
      * this reference. The object may not be in the table if it is a hidden
      * local literal.
@@ -847,17 +850,17 @@
 	     * If the literal is no longer being used by any ByteCode, delete
 	     * the entry then remove the reference corresponding to the global
 	     * literal table entry (decrement the ref count of the object).
 	     */
 
-	    if ((entryPtr->refCount != TCL_AUTO_LENGTH) && (entryPtr->refCount-- <= 1)) {
+	    if ((entryPtr->refCount != (unsigned)-1) && (entryPtr->refCount-- <= 1)) {
 		if (prevPtr == NULL) {
 		    globalTablePtr->buckets[index] = entryPtr->nextPtr;
 		} else {
 		    prevPtr->nextPtr = entryPtr->nextPtr;
 		}
-		Tcl_Free(entryPtr);
+		ckfree(entryPtr);
 		globalTablePtr->numEntries--;
 
 		TclDecrRefCount(objPtr);
 
 #ifdef TCL_COMPILE_STATS
@@ -891,16 +894,16 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-static size_t
+static unsigned
 HashString(
-    register const char *string,	/* String for which to compute hash value. */
-    size_t length)			/* Number of bytes in the string. */
+    const char *string,	/* String for which to compute hash value. */
+    int length)			/* Number of bytes in the string. */
 {
-    register size_t result = 0;
+    unsigned int result = 0;
 
     /*
      * I tried a zillion different hash functions and asked many other people
      * for advice. Many people had their own favorite functions, all
      * different, but no-one had much idea why they were good ones. I chose
@@ -957,19 +960,20 @@
  *----------------------------------------------------------------------
  */
 
 static void
 RebuildLiteralTable(
-    register LiteralTable *tablePtr)
+    LiteralTable *tablePtr)
 				/* Local or global table to enlarge. */
 {
     LiteralEntry **oldBuckets;
-    register LiteralEntry **oldChainPtr, **newChainPtr;
-    register LiteralEntry *entryPtr;
+    LiteralEntry **oldChainPtr, **newChainPtr;
+    LiteralEntry *entryPtr;
     LiteralEntry **bucketPtr;
     const char *bytes;
-    size_t oldSize, count, index, length;
+    unsigned int oldSize, index;
+    int count, length;
 
     oldSize = tablePtr->numBuckets;
     oldBuckets = tablePtr->buckets;
 
     /*
@@ -986,11 +990,11 @@
 
 	return;
     }
 
     tablePtr->numBuckets *= 4;
-    tablePtr->buckets = Tcl_Alloc(tablePtr->numBuckets * sizeof(LiteralEntry*));
+    tablePtr->buckets = ckalloc(tablePtr->numBuckets * sizeof(LiteralEntry*));
     for (count=tablePtr->numBuckets, newChainPtr=tablePtr->buckets;
 	    count>0 ; count--, newChainPtr++) {
 	*newChainPtr = NULL;
     }
     tablePtr->rebuildSize *= 4;
@@ -1015,11 +1019,11 @@
     /*
      * Free up the old bucket array, if it was dynamically allocated.
      */
 
     if (oldBuckets != tablePtr->staticBuckets) {
-	Tcl_Free(oldBuckets);
+	ckfree(oldBuckets);
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1088,13 +1092,15 @@
 char *
 TclLiteralStats(
     LiteralTable *tablePtr)	/* Table for which to produce stats. */
 {
 #define NUM_COUNTERS 10
-    size_t count[NUM_COUNTERS], overflow, i, j;
+    size_t count[NUM_COUNTERS];
+    int overflow;
+    size_t i, j;
     double average, tmp;
-    register LiteralEntry *entryPtr;
+    LiteralEntry *entryPtr;
     char *result, *p;
 
     /*
      * Compute a histogram of bucket usage. For each bucket chain i, j is the
      * number of entries in the chain.
@@ -1122,20 +1128,20 @@
 
     /*
      * Print out the histogram and a few other pieces of information.
      */
 
-    result = Tcl_Alloc(NUM_COUNTERS*60 + 300);
-    sprintf(result, "%" TCL_Z_MODIFIER "u entries in table, %" TCL_Z_MODIFIER "u buckets\n",
+    result = ckalloc(NUM_COUNTERS*60 + 300);
+    sprintf(result, "%d entries in table, %d buckets\n",
 	    tablePtr->numEntries, tablePtr->numBuckets);
     p = result + strlen(result);
     for (i=0 ; i<NUM_COUNTERS ; i++) {
 	sprintf(p, "number of buckets with %" TCL_Z_MODIFIER "u entries: %" TCL_Z_MODIFIER "u\n",
 		i, count[i]);
 	p += strlen(p);
     }
-    sprintf(p, "number of buckets with %d or more entries: %" TCL_Z_MODIFIER "u\n",
+    sprintf(p, "number of buckets with %d or more entries: %d\n",
 	    NUM_COUNTERS, overflow);
     p += strlen(p);
     sprintf(p, "average search distance for entry: %.1f", average);
     return result;
 }
@@ -1161,33 +1167,35 @@
 void
 TclVerifyLocalLiteralTable(
     CompileEnv *envPtr)		/* Points to CompileEnv whose literal table is
 				 * to be validated. */
 {
-    register LiteralTable *localTablePtr = &envPtr->localLitTable;
-    register LiteralEntry *localPtr;
+    LiteralTable *localTablePtr = &envPtr->localLitTable;
+    LiteralEntry *localPtr;
     char *bytes;
-    size_t i, length, count = 0;
+    size_t i, count;
+    int length;
 
+    count = 0;
     for (i=0 ; i<localTablePtr->numBuckets ; i++) {
 	for (localPtr=localTablePtr->buckets[i] ; localPtr!=NULL;
 		localPtr=localPtr->nextPtr) {
 	    count++;
-	    if (localPtr->refCount != TCL_AUTO_LENGTH) {
+	    if (localPtr->refCount != (unsigned)-1) {
 		bytes = TclGetStringFromObj(localPtr->objPtr, &length);
-		Tcl_Panic("%s: local literal \"%.*s\" had bad refCount %" TCL_Z_MODIFIER "u",
+		Tcl_Panic("%s: local literal \"%.*s\" had bad refCount %u",
 			"TclVerifyLocalLiteralTable",
-			(length>60? 60 : (int) length), bytes, localPtr->refCount);
+			(length>60? 60 : length), bytes, localPtr->refCount);
 	    }
 	    if (localPtr->objPtr->bytes == NULL) {
 		Tcl_Panic("%s: literal has NULL string rep",
 			"TclVerifyLocalLiteralTable");
 	    }
 	}
     }
     if (count != localTablePtr->numEntries) {
-	Tcl_Panic("%s: local literal table had %" TCL_Z_MODIFIER "u entries, should be %" TCL_Z_MODIFIER "u",
+	Tcl_Panic("%s: local literal table had %" TCL_Z_MODIFIER "u entries, should be %u",
 		"TclVerifyLocalLiteralTable", count,
 		localTablePtr->numEntries);
     }
 }
 
@@ -1210,33 +1218,35 @@
 void
 TclVerifyGlobalLiteralTable(
     Interp *iPtr)		/* Points to interpreter whose global literal
 				 * table is to be validated. */
 {
-    register LiteralTable *globalTablePtr = &iPtr->literalTable;
-    register LiteralEntry *globalPtr;
+    LiteralTable *globalTablePtr = &iPtr->literalTable;
+    LiteralEntry *globalPtr;
     char *bytes;
-    size_t i, length, count = 0;
+    size_t i, count;
+    int length;
 
+    count = 0;
     for (i=0 ; i<globalTablePtr->numBuckets ; i++) {
 	for (globalPtr=globalTablePtr->buckets[i] ; globalPtr!=NULL;
 		globalPtr=globalPtr->nextPtr) {
 	    count++;
 	    if (globalPtr->refCount + 1 < 2) {
 		bytes = TclGetStringFromObj(globalPtr->objPtr, &length);
-		Tcl_Panic("%s: global literal \"%.*s\" had bad refCount %" TCL_Z_MODIFIER "u",
+		Tcl_Panic("%s: global literal \"%.*s\" had bad refCount %d",
 			"TclVerifyGlobalLiteralTable",
-			(length>60? 60 : (int)length), bytes, globalPtr->refCount);
+			(length>60? 60 : length), bytes, globalPtr->refCount);
 	    }
 	    if (globalPtr->objPtr->bytes == NULL) {
 		Tcl_Panic("%s: literal has NULL string rep",
 			"TclVerifyGlobalLiteralTable");
 	    }
 	}
     }
     if (count != globalTablePtr->numEntries) {
-	Tcl_Panic("%s: global literal table had %" TCL_Z_MODIFIER "u entries, should be %" TCL_Z_MODIFIER "u",
+	Tcl_Panic("%s: global literal table had %" TCL_Z_MODIFIER "u entries, should be %u",
 		"TclVerifyGlobalLiteralTable", count,
 		globalTablePtr->numEntries);
     }
 }
 #endif /*TCL_COMPILE_DEBUG*/

Index: generic/tclLoad.c
==================================================================
--- generic/tclLoad.c
+++ generic/tclLoad.c
@@ -129,11 +129,11 @@
     const char *symbols[2];
     Tcl_PackageInitProc *initProc;
     const char *p, *fullFileName, *packageName;
     Tcl_LoadHandle loadHandle;
     Tcl_UniChar ch = 0;
-    size_t len;
+    unsigned len;
     int index, flags = 0;
     Tcl_Obj *const *savedobjv = objv;
     static const char *const options[] = {
 	"-global",		"-lazy",		"--",	NULL
     };
@@ -163,11 +163,11 @@
 	return TCL_ERROR;
     }
     if (Tcl_FSConvertToPathType(interp, objv[1]) != TCL_OK) {
 	return TCL_ERROR;
     }
-    fullFileName = TclGetString(objv[1]);
+    fullFileName = Tcl_GetString(objv[1]);
 
     Tcl_DStringInit(&pkgName);
     Tcl_DStringInit(&initName);
     Tcl_DStringInit(&safeInitName);
     Tcl_DStringInit(&unloadName);
@@ -174,11 +174,11 @@
     Tcl_DStringInit(&safeUnloadName);
     Tcl_DStringInit(&tmp);
 
     packageName = NULL;
     if (objc >= 3) {
-	packageName = TclGetString(objv[2]);
+	packageName = Tcl_GetString(objv[2]);
 	if (packageName[0] == '\0') {
 	    packageName = NULL;
 	}
     }
     if ((fullFileName[0] == 0) && (packageName == NULL)) {
@@ -194,11 +194,11 @@
      * Figure out which interpreter we're going to load the package into.
      */
 
     target = interp;
     if (objc == 4) {
-	const char *slaveIntName = TclGetString(objv[3]);
+	const char *slaveIntName = Tcl_GetString(objv[3]);
 
 	target = Tcl_GetSlave(interp, slaveIntName);
 	if (target == NULL) {
 	    code = TCL_ERROR;
 	    goto done;
@@ -322,11 +322,11 @@
 		 * that.
 		 */
 
 		splitPtr = Tcl_FSSplitPath(objv[1], &pElements);
 		Tcl_ListObjIndex(NULL, splitPtr, pElements -1, &pkgGuessPtr);
-		pkgGuess = TclGetString(pkgGuessPtr);
+		pkgGuess = Tcl_GetString(pkgGuessPtr);
 		if ((pkgGuess[0] == 'l') && (pkgGuess[1] == 'i')
 			&& (pkgGuess[2] == 'b')) {
 		    pkgGuess += 3;
 		}
 #ifdef __CYGWIN__
@@ -399,16 +399,16 @@
 
 	/*
 	 * Create a new record to describe this package.
 	 */
 
-	pkgPtr = Tcl_Alloc(sizeof(LoadedPackage));
+	pkgPtr = ckalloc(sizeof(LoadedPackage));
 	len = strlen(fullFileName) + 1;
-	pkgPtr->fileName	   = Tcl_Alloc(len);
+	pkgPtr->fileName	   = ckalloc(len);
 	memcpy(pkgPtr->fileName, fullFileName, len);
 	len = Tcl_DStringLength(&pkgName) + 1;
-	pkgPtr->packageName	   = Tcl_Alloc(len);
+	pkgPtr->packageName	   = ckalloc(len);
 	memcpy(pkgPtr->packageName, Tcl_DStringValue(&pkgName), len);
 	pkgPtr->loadHandle	   = loadHandle;
 	pkgPtr->initProc	   = initProc;
 	pkgPtr->safeInitProc	   = (Tcl_PackageInitProc *)
 		Tcl_FindSymbol(interp, loadHandle,
@@ -468,21 +468,23 @@
      * Test for whether the initialization failed. If so, transfer the error
      * from the target interpreter to the originating one.
      */
 
     if (code != TCL_OK) {
+#if defined(TCL_NO_DEPRECATED) || TCL_MAJOR_VERSION > 8
 	Interp *iPtr = (Interp *) target;
-	if (iPtr->legacyResult && *(iPtr->legacyResult) && !iPtr->legacyFreeProc) {
+	if (iPtr->result && *(iPtr->result) && !iPtr->freeProc) {
 	    /*
 	     * A call to Tcl_InitStubs() determined the caller extension and
 	     * this interp are incompatible in their stubs mechanisms, and
 	     * recorded the error in the oldest legacy place we have to do so.
 	     */
-	    Tcl_SetObjResult(target, Tcl_NewStringObj(iPtr->legacyResult, -1));
-	    iPtr->legacyResult = NULL;
-	    iPtr->legacyFreeProc = (void (*) (void))-1;
+	    Tcl_SetObjResult(target, Tcl_NewStringObj(iPtr->result, -1));
+	    iPtr->result =  &tclEmptyString;
+	    iPtr->freeProc = NULL;
 	}
+#endif /* defined(TCL_NO_DEPRECATED) */
 	Tcl_TransferResult(target, code, interp);
 	goto done;
     }
 
     /*
@@ -504,11 +506,11 @@
      * Refetch ipFirstPtr: loading the package may have introduced additional
      * static packages at the head of the linked list!
      */
 
     ipFirstPtr = Tcl_GetAssocData(target, "tclLoad", NULL);
-    ipPtr = Tcl_Alloc(sizeof(InterpPackage));
+    ipPtr = ckalloc(sizeof(InterpPackage));
     ipPtr->pkgPtr = pkgPtr;
     ipPtr->nextPtr = ipFirstPtr;
     Tcl_SetAssocData(target, "tclLoad", LoadCleanupProc, ipPtr);
 
   done:
@@ -562,11 +564,11 @@
     };
 
     for (i = 1; i < objc; i++) {
 	if (Tcl_GetIndexFromObj(interp, objv[i], options, "option", 0,
 		&index) != TCL_OK) {
-	    fullFileName = TclGetString(objv[i]);
+	    fullFileName = Tcl_GetString(objv[i]);
 	    if (fullFileName[0] == '-') {
 		/*
 		 * It looks like the command contains an option so signal an
 		 * error
 		 */
@@ -602,17 +604,17 @@
     }
     if (Tcl_FSConvertToPathType(interp, objv[i]) != TCL_OK) {
 	return TCL_ERROR;
     }
 
-    fullFileName = TclGetString(objv[i]);
+    fullFileName = Tcl_GetString(objv[i]);
     Tcl_DStringInit(&pkgName);
     Tcl_DStringInit(&tmp);
 
     packageName = NULL;
     if (objc - i >= 2) {
-	packageName = TclGetString(objv[i+1]);
+	packageName = Tcl_GetString(objv[i+1]);
 	if (packageName[0] == '\0') {
 	    packageName = NULL;
 	}
     }
     if ((fullFileName[0] == 0) && (packageName == NULL)) {
@@ -628,11 +630,11 @@
      * Figure out which interpreter we're going to load the package into.
      */
 
     target = interp;
     if (objc - i == 3) {
-	const char *slaveIntName = TclGetString(objv[i + 2]);
+	const char *slaveIntName = Tcl_GetString(objv[i + 2]);
 
 	target = Tcl_GetSlave(interp, slaveIntName);
 	if (target == NULL) {
 	    return TCL_ERROR;
 	}
@@ -888,14 +890,14 @@
 			}
 		    }
 		}
 		Tcl_SetAssocData(target, "tclLoad", LoadCleanupProc,
 			ipFirstPtr);
-		Tcl_Free(defaultPtr->fileName);
-		Tcl_Free(defaultPtr->packageName);
-		Tcl_Free(defaultPtr);
-		Tcl_Free(ipPtr);
+		ckfree(defaultPtr->fileName);
+		ckfree(defaultPtr->packageName);
+		ckfree(defaultPtr);
+		ckfree(ipPtr);
 		Tcl_MutexUnlock(&packageMutex);
 	    } else {
 		code = TCL_ERROR;
 	    }
 	}
@@ -978,14 +980,14 @@
      * If the package is not yet recorded as being loaded statically, add it
      * to the list now.
      */
 
     if (pkgPtr == NULL) {
-	pkgPtr = Tcl_Alloc(sizeof(LoadedPackage));
-	pkgPtr->fileName	= Tcl_Alloc(1);
+	pkgPtr = ckalloc(sizeof(LoadedPackage));
+	pkgPtr->fileName	= ckalloc(1);
 	pkgPtr->fileName[0]	= 0;
-	pkgPtr->packageName	= Tcl_Alloc(strlen(pkgName) + 1);
+	pkgPtr->packageName	= ckalloc(strlen(pkgName) + 1);
 	strcpy(pkgPtr->packageName, pkgName);
 	pkgPtr->loadHandle	= NULL;
 	pkgPtr->initProc	= initProc;
 	pkgPtr->safeInitProc	= safeInitProc;
 	Tcl_MutexLock(&packageMutex);
@@ -1011,11 +1013,11 @@
 	/*
 	 * Package isn't loaded in the current interp yet. Mark it as now being
 	 * loaded.
 	 */
 
-	ipPtr = Tcl_Alloc(sizeof(InterpPackage));
+	ipPtr = ckalloc(sizeof(InterpPackage));
 	ipPtr->pkgPtr = pkgPtr;
 	ipPtr->nextPtr = ipFirstPtr;
 	Tcl_SetAssocData(interp, "tclLoad", LoadCleanupProc, ipPtr);
     }
 }
@@ -1155,11 +1157,11 @@
     InterpPackage *ipPtr, *nextPtr;
 
     ipPtr = clientData;
     while (ipPtr != NULL) {
 	nextPtr = ipPtr->nextPtr;
-	Tcl_Free(ipPtr);
+	ckfree(ipPtr);
 	ipPtr = nextPtr;
     }
 }
 
 /*
@@ -1206,13 +1208,13 @@
 	if (pkgPtr->fileName[0] != '\0') {
 	    Tcl_FSUnloadFile(NULL, pkgPtr->loadHandle);
 	}
 #endif
 
-	Tcl_Free(pkgPtr->fileName);
-	Tcl_Free(pkgPtr->packageName);
-	Tcl_Free(pkgPtr);
+	ckfree(pkgPtr->fileName);
+	ckfree(pkgPtr->packageName);
+	ckfree(pkgPtr);
     }
 }
 
 /*
  * Local Variables:

Index: generic/tclMain.c
==================================================================
--- generic/tclMain.c
+++ generic/tclMain.c
@@ -16,11 +16,11 @@
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  */
 
 /*
  * On Windows, this file needs to be compiled twice, once with TCL_ASCII_MAIN
- * defined. This way both Tcl_MainEx and Tcl_MainExW can be implemented, sharing
+ * defined. This way both Tcl_Main and Tcl_MainExW can be implemented, sharing
  * the same source code.
  */
 
 #if defined(TCL_ASCII_MAIN)
 #   ifdef UNICODE
@@ -63,11 +63,11 @@
 #   define NewNativeObj Tcl_NewUnicodeObj
 #else /* !UNICODE || (TCL_UTF_MAX > 4) */
 static inline Tcl_Obj *
 NewNativeObj(
     TCHAR *string,
-    size_t length)
+    int length)
 {
     Tcl_DString ds;
 
 #ifdef UNICODE
     if (length > 0) {
@@ -220,11 +220,11 @@
 
     if (encodingPtr != NULL) {
 	if (tsdPtr->encoding == NULL) {
 	    *encodingPtr = NULL;
 	} else {
-	    *encodingPtr = TclGetString(tsdPtr->encoding);
+	    *encodingPtr = Tcl_GetString(tsdPtr->encoding);
 	}
     }
     return tsdPtr->path;
 }
 
@@ -304,11 +304,11 @@
  *	interpreted.
  *
  *----------------------------------------------------------------------
  */
 
-TCL_NORETURN void
+void
 Tcl_MainEx(
     int argc,			/* Number of arguments. */
     TCHAR **argv,		/* Array of argument strings. */
     Tcl_AppInitProc *appInitProc,
 				/* Application-specific initialization
@@ -348,11 +348,11 @@
 
 	if ((argc > 3) && (0 == _tcscmp(TEXT("-encoding"), argv[1]))
 		&& ('-' != argv[3][0])) {
 	    Tcl_Obj *value = NewNativeObj(argv[2], -1);
 	    Tcl_SetStartupScript(NewNativeObj(argv[3], -1),
-		    TclGetString(value));
+		    Tcl_GetString(value));
 	    Tcl_DecrRefCount(value);
 	    argc -= 3;
 	    argv += 3;
 	} else if ((argc > 1) && ('-' != argv[1][0])) {
 	    Tcl_SetStartupScript(NewNativeObj(argv[1], -1), NULL);
@@ -472,11 +472,11 @@
     Tcl_LinkVar(interp, "tcl_interactive", (char *) &is.tty, TCL_LINK_BOOLEAN);
     is.input = Tcl_GetStdChannel(TCL_STDIN);
     while ((is.input != NULL) && !Tcl_InterpDeleted(interp)) {
 	mainLoopProc = TclGetMainLoop();
 	if (mainLoopProc == NULL) {
-	    size_t length;
+	    int length;
 
 	    if (is.tty) {
 		Prompt(interp, &is);
 		if (Tcl_InterpDeleted(interp)) {
 		    break;
@@ -493,11 +493,11 @@
 		Tcl_DecrRefCount(is.commandPtr);
 		is.commandPtr = Tcl_DuplicateObj(is.commandPtr);
 		Tcl_IncrRefCount(is.commandPtr);
 	    }
 	    length = Tcl_GetsObj(is.input, is.commandPtr);
-	    if (length == TCL_AUTO_LENGTH) {
+	    if (length < 0) {
 		if (Tcl_InputBlocked(is.input)) {
 		    /*
 		     * This can only happen if stdin has been set to
 		     * non-blocking. In that case cycle back and try again.
 		     * This sets up a tight polling loop (since we have no
@@ -537,11 +537,11 @@
 	    /*
 	     * The final newline is syntactically redundant, and causes some
 	     * error messages troubles deeper in, so lop it back off.
 	     */
 
-	    (void)TclGetStringFromObj(is.commandPtr, &length);
+	    TclGetStringFromObj(is.commandPtr, &length);
 	    Tcl_SetObjLength(is.commandPtr, --length);
 	    code = Tcl_RecordAndEvalObj(interp, is.commandPtr,
 		    TCL_EVAL_GLOBAL);
 	    is.input = Tcl_GetStdChannel(TCL_STDIN);
 	    Tcl_DecrRefCount(is.commandPtr);
@@ -554,11 +554,11 @@
 		    Tcl_WriteChars(chan, "\n", 1);
 		}
 	    } else if (is.tty) {
 		resultPtr = Tcl_GetObjResult(interp);
 		Tcl_IncrRefCount(resultPtr);
-		(void)TclGetStringFromObj(resultPtr, &length);
+		TclGetStringFromObj(resultPtr, &length);
 		chan = Tcl_GetStdChannel(TCL_STDOUT);
 		if ((length > 0) && chan) {
 		    Tcl_WriteObj(chan, resultPtr);
 		    Tcl_WriteChars(chan, "\n", 1);
 		}
@@ -758,12 +758,11 @@
 static void
 StdinProc(
     ClientData clientData,	/* The state of interactive cmd line */
     int mask)			/* Not used. */
 {
-    int code;
-    size_t length;
+    int code, length;
     InteractiveState *isPtr = clientData;
     Tcl_Channel chan = isPtr->input;
     Tcl_Obj *commandPtr = isPtr->commandPtr;
     Tcl_Interp *interp = isPtr->interp;
 
@@ -771,11 +770,11 @@
 	Tcl_DecrRefCount(commandPtr);
 	commandPtr = Tcl_DuplicateObj(commandPtr);
 	Tcl_IncrRefCount(commandPtr);
     }
     length = Tcl_GetsObj(chan, commandPtr);
-    if (length == TCL_AUTO_LENGTH) {
+    if (length < 0) {
 	if (Tcl_InputBlocked(chan)) {
 	    return;
 	}
 	if (isPtr->tty) {
 	    /*
@@ -799,11 +798,11 @@
     if (!TclObjCommandComplete(commandPtr)) {
 	isPtr->prompt = PROMPT_CONTINUE;
 	goto prompt;
     }
     isPtr->prompt = PROMPT_START;
-    (void)TclGetStringFromObj(commandPtr, &length);
+    TclGetStringFromObj(commandPtr, &length);
     Tcl_SetObjLength(commandPtr, --length);
 
     /*
      * Disable the stdin channel handler while evaluating the command;
      * otherwise if the command re-enters the event loop we might process
@@ -830,11 +829,11 @@
     } else if (isPtr->tty) {
 	Tcl_Obj *resultPtr = Tcl_GetObjResult(interp);
 	chan = Tcl_GetStdChannel(TCL_STDOUT);
 
 	Tcl_IncrRefCount(resultPtr);
-	(void)TclGetStringFromObj(resultPtr, &length);
+	TclGetStringFromObj(resultPtr, &length);
 	if ((length > 0) && (chan != NULL)) {
 	    Tcl_WriteObj(chan, resultPtr);
 	    Tcl_WriteChars(chan, "\n", 1);
 	}
 	Tcl_DecrRefCount(resultPtr);

Index: generic/tclNamesp.c
==================================================================
--- generic/tclNamesp.c
+++ generic/tclNamesp.c
@@ -31,11 +31,11 @@
  * Thread-local storage used to avoid having a global lock on data that is not
  * limited to a single interpreter.
  */
 
 typedef struct {
-    size_t numNsCreated;	/* Count of the number of namespaces created
+    unsigned long numNsCreated;	/* Count of the number of namespaces created
 				 * within the thread. This value is used as a
 				 * unique id for each namespace. Cannot be
 				 * per-interp because the nsId is used to
 				 * distinguish objects which can be passed
 				 * around between interps in the same thread,
@@ -51,11 +51,11 @@
  * of resolving the namespace's name in some other namespace. It is the
  * internal representation for a nsName object. It contains the pointer along
  * with some information that is used to check the cached pointer's validity.
  */
 
-typedef struct {
+typedef struct ResolvedNsName {
     Namespace *nsPtr;		/* A cached pointer to the Namespace that the
 				 * name resolved to. */
     Namespace *refNsPtr;	/* Points to the namespace context in which
 				 * the name was resolved. NULL if the name is
 				 * fully qualified and thus the resolution
@@ -238,11 +238,11 @@
  *----------------------------------------------------------------------
  */
 
 Tcl_Namespace *
 Tcl_GetCurrentNamespace(
-    register Tcl_Interp *interp)/* Interpreter whose current namespace is
+    Tcl_Interp *interp)/* Interpreter whose current namespace is
 				 * being queried. */
 {
     return TclGetCurrentNamespace(interp);
 }
 
@@ -262,11 +262,11 @@
  *----------------------------------------------------------------------
  */
 
 Tcl_Namespace *
 Tcl_GetGlobalNamespace(
-    register Tcl_Interp *interp)/* Interpreter whose global namespace should
+    Tcl_Interp *interp)/* Interpreter whose global namespace should
 				 * be returned. */
 {
     return TclGetGlobalNamespace(interp);
 }
 
@@ -314,12 +314,12 @@
 				 * inscope" command and var references are
 				 * treated as references to namespace
 				 * variables. */
 {
     Interp *iPtr = (Interp *) interp;
-    register CallFrame *framePtr = (CallFrame *) callFramePtr;
-    register Namespace *nsPtr;
+    CallFrame *framePtr = (CallFrame *) callFramePtr;
+    Namespace *nsPtr;
 
     if (namespacePtr == NULL) {
 	nsPtr = (Namespace *) TclGetCurrentNamespace(interp);
     } else {
 	nsPtr = (Namespace *) namespacePtr;
@@ -391,12 +391,12 @@
 
 void
 Tcl_PopCallFrame(
     Tcl_Interp *interp)		/* Interpreter with call frame to pop. */
 {
-    register Interp *iPtr = (Interp *) interp;
-    register CallFrame *framePtr = iPtr->framePtr;
+    Interp *iPtr = (Interp *) interp;
+    CallFrame *framePtr = iPtr->framePtr;
     Namespace *nsPtr;
 
     /*
      * It's important to remove the call frame from the interpreter's stack of
      * call frames before deleting local variables, so that traces invoked by
@@ -410,11 +410,11 @@
 	/* Tcl_PopCallFrame: trying to pop rootCallFrame! */
     }
 
     if (framePtr->varTablePtr != NULL) {
 	TclDeleteVars(iPtr, framePtr->varTablePtr);
-	Tcl_Free(framePtr->varTablePtr);
+	ckfree(framePtr->varTablePtr);
 	framePtr->varTablePtr = NULL;
     }
     if (framePtr->numCompiledLocals > 0) {
 	TclDeleteCompiledLocalVars(iPtr, framePtr);
 	if (framePtr->localCachePtr->refCount-- <= 1) {
@@ -428,12 +428,13 @@
      * is "dying" and there are no more active call frames, call
      * Tcl_DeleteNamespace to destroy it.
      */
 
     nsPtr = framePtr->nsPtr;
-    if ((--nsPtr->activationCount <= (unsigned)(nsPtr == iPtr->globalNsPtr))
-	    && (nsPtr->flags & NS_DYING)) {
+    nsPtr->activationCount--;
+    if ((nsPtr->flags & NS_DYING)
+	    && (nsPtr->activationCount - (nsPtr == iPtr->globalNsPtr) == 0)) {
 	Tcl_DeleteNamespace((Tcl_Namespace *) nsPtr);
     }
     framePtr->nsPtr = NULL;
 
     if (framePtr->tailcallPtr) {
@@ -676,19 +677,18 @@
 				/* Function called to delete client data when
 				 * the namespace is deleted. NULL if no
 				 * function should be called. */
 {
     Interp *iPtr = (Interp *) interp;
-    register Namespace *nsPtr, *ancestorPtr;
+    Namespace *nsPtr, *ancestorPtr;
     Namespace *parentPtr, *dummy1Ptr, *dummy2Ptr;
     Namespace *globalNsPtr = iPtr->globalNsPtr;
     const char *simpleName;
     Tcl_HashEntry *entryPtr;
     Tcl_DString buffer1, buffer2;
     Tcl_DString *namePtr, *buffPtr;
-    int newEntry;
-    size_t nameLen;
+    int newEntry, nameLen;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     const char *nameStr;
     Tcl_DString tmpBuffer;
 
     Tcl_DStringInit(&tmpBuffer);
@@ -783,13 +783,13 @@
      * Create the new namespace and root it in its parent. Increment the count
      * of namespaces created.
      */
 
   doCreate:
-    nsPtr = Tcl_Alloc(sizeof(Namespace));
+    nsPtr = ckalloc(sizeof(Namespace));
     nameLen = strlen(simpleName) + 1;
-    nsPtr->name = Tcl_Alloc(nameLen);
+    nsPtr->name = ckalloc(nameLen);
     memcpy(nsPtr->name, simpleName, nameLen);
     nsPtr->fullName = NULL;		/* Set below. */
     nsPtr->clientData = clientData;
     nsPtr->deleteProc = deleteProc;
     nsPtr->parentPtr = parentPtr;
@@ -846,11 +846,11 @@
     namePtr = &buffer1;
     buffPtr = &buffer2;
     for (ancestorPtr = nsPtr; ancestorPtr != NULL;
 	    ancestorPtr = ancestorPtr->parentPtr) {
 	if (ancestorPtr != globalNsPtr) {
-	    register Tcl_DString *tempPtr = namePtr;
+	    Tcl_DString *tempPtr = namePtr;
 
 	    TclDStringAppendLiteral(buffPtr, "::");
 	    Tcl_DStringAppend(buffPtr, ancestorPtr->name, -1);
 	    TclDStringAppendDString(buffPtr, namePtr);
 
@@ -873,11 +873,11 @@
 	}
     }
 
     name = Tcl_DStringValue(namePtr);
     nameLen = Tcl_DStringLength(namePtr);
-    nsPtr->fullName = Tcl_Alloc(nameLen + 1);
+    nsPtr->fullName = ckalloc(nameLen + 1);
     memcpy(nsPtr->fullName, name, nameLen + 1);
 
     Tcl_DStringFree(&buffer1);
     Tcl_DStringFree(&buffer2);
     Tcl_DStringFree(&tmpBuffer);
@@ -920,11 +920,11 @@
 
 void
 Tcl_DeleteNamespace(
     Tcl_Namespace *namespacePtr)/* Points to the namespace to delete. */
 {
-    register Namespace *nsPtr = (Namespace *) namespacePtr;
+    Namespace *nsPtr = (Namespace *) namespacePtr;
     Interp *iPtr = (Interp *) nsPtr->interp;
     Namespace *globalNsPtr = (Namespace *)
 	    TclGetGlobalNamespace((Tcl_Interp *) iPtr);
     Tcl_HashEntry *entryPtr;
     Tcl_HashSearch search;
@@ -1021,11 +1021,11 @@
      * namespace resolution code to recognize that the namespace is "deleted".
      * The structure's storage is freed by FreeNsNameInternalRep when its
      * refCount reaches 0.
      */
 
-    if (nsPtr->activationCount > (unsigned)(nsPtr == globalNsPtr)) {
+    if (nsPtr->activationCount - (nsPtr == globalNsPtr) > 0) {
 	nsPtr->flags |= NS_DYING;
 	if (nsPtr->parentPtr != NULL) {
 	    entryPtr = Tcl_FindHashEntry(
 		    TclGetNamespaceChildTable((Tcl_Namespace *)
 			    nsPtr->parentPtr), nsPtr->name);
@@ -1060,11 +1060,11 @@
 #ifndef BREAK_NAMESPACE_COMPAT
 	    Tcl_DeleteHashTable(&nsPtr->childTable);
 #else
 	    if (nsPtr->childTablePtr != NULL) {
 		Tcl_DeleteHashTable(nsPtr->childTablePtr);
-		Tcl_Free(nsPtr->childTablePtr);
+		ckfree(nsPtr->childTablePtr);
 	    }
 #endif
 	    Tcl_DeleteHashTable(&nsPtr->cmdTable);
 
 	    nsPtr ->flags |= NS_DEAD;
@@ -1116,17 +1116,17 @@
  *----------------------------------------------------------------------
  */
 
 void
 TclTeardownNamespace(
-    register Namespace *nsPtr)	/* Points to the namespace to be dismantled
+    Namespace *nsPtr)	/* Points to the namespace to be dismantled
 				 * and unlinked from its parent. */
 {
     Interp *iPtr = (Interp *) nsPtr->interp;
-    register Tcl_HashEntry *entryPtr;
+    Tcl_HashEntry *entryPtr;
     Tcl_HashSearch search;
-    size_t i;
+    int i;
 
     /*
      * Start by destroying the namespace's variable table, since variables
      * might trigger traces. Variable table should be cleared but not freed!
      * TclDeleteNamespaceVars frees it, so we reinitialize it afterwards.
@@ -1143,11 +1143,11 @@
      * f97d4ee020]) we copy to a temporary array and then delete all those
      * commands.
      */
 
     while (nsPtr->cmdTable.numEntries > 0) {
-	size_t length = nsPtr->cmdTable.numEntries;
+	int length = nsPtr->cmdTable.numEntries;
 	Command **cmds = TclStackAlloc((Tcl_Interp *) iPtr,
 		sizeof(Command *) * length);
 
 	i = 0;
 	for (entryPtr = Tcl_FirstHashEntry(&nsPtr->cmdTable, &search);
@@ -1215,11 +1215,11 @@
      * Important: leave the hash table itself still live.
      */
 
 #ifndef BREAK_NAMESPACE_COMPAT
     while (nsPtr->childTable.numEntries > 0) {
-	size_t length = nsPtr->childTable.numEntries;
+	int length = nsPtr->childTable.numEntries;
 	Namespace **children = TclStackAlloc((Tcl_Interp *) iPtr,
 		sizeof(Namespace *) * length);
 
 	i = 0;
 	for (entryPtr = Tcl_FirstHashEntry(&nsPtr->childTable, &search);
@@ -1236,11 +1236,11 @@
 	TclStackFree((Tcl_Interp *) iPtr, children);
     }
 #else
     if (nsPtr->childTablePtr != NULL) {
 	while (nsPtr->childTablePtr->numEntries > 0) {
-	    size_t length = nsPtr->childTablePtr->numEntries;
+	    int length = nsPtr->childTablePtr->numEntries;
 	    Namespace **children = TclStackAlloc((Tcl_Interp *) iPtr,
 		    sizeof(Namespace *) * length);
 
 	    i = 0;
 	    for (entryPtr = Tcl_FirstHashEntry(nsPtr->childTablePtr, &search);
@@ -1263,13 +1263,13 @@
      * Free the namespace's export pattern array.
      */
 
     if (nsPtr->exportArrayPtr != NULL) {
 	for (i = 0;  i < nsPtr->numExportPatterns;  i++) {
-	    Tcl_Free(nsPtr->exportArrayPtr[i]);
+	    ckfree(nsPtr->exportArrayPtr[i]);
 	}
-	Tcl_Free(nsPtr->exportArrayPtr);
+	ckfree(nsPtr->exportArrayPtr);
 	nsPtr->exportArrayPtr = NULL;
 	nsPtr->numExportPatterns = 0;
 	nsPtr->maxExportPatterns = 0;
     }
 
@@ -1309,21 +1309,21 @@
  *----------------------------------------------------------------------
  */
 
 static void
 NamespaceFree(
-    register Namespace *nsPtr)	/* Points to the namespace to free. */
+    Namespace *nsPtr)	/* Points to the namespace to free. */
 {
     /*
      * Most of the namespace's contents are freed when the namespace is
      * deleted by Tcl_DeleteNamespace. All that remains is to free its names
      * (for error messages), and the structure itself.
      */
 
-    Tcl_Free(nsPtr->name);
-    Tcl_Free(nsPtr->fullName);
-    Tcl_Free(nsPtr);
+    ckfree(nsPtr->name);
+    ckfree(nsPtr->fullName);
+    ckfree(nsPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1388,11 +1388,11 @@
 #define INIT_EXPORT_PATTERNS 5
     Namespace *nsPtr, *exportNsPtr, *dummyPtr;
     Namespace *currNsPtr = (Namespace *) TclGetCurrentNamespace(interp);
     const char *simplePattern;
     char *patternCpy;
-    size_t neededElems, len, i;
+    int neededElems, len, i;
 
     /*
      * If the specified namespace is NULL, use the current namespace.
      */
 
@@ -1408,13 +1408,13 @@
      */
 
     if (resetListFirst) {
 	if (nsPtr->exportArrayPtr != NULL) {
 	    for (i = 0;  i < nsPtr->numExportPatterns;  i++) {
-		Tcl_Free(nsPtr->exportArrayPtr[i]);
+		ckfree(nsPtr->exportArrayPtr[i]);
 	    }
-	    Tcl_Free(nsPtr->exportArrayPtr);
+	    ckfree(nsPtr->exportArrayPtr);
 	    nsPtr->exportArrayPtr = NULL;
 	    TclInvalidateNsCmdLookup(nsPtr);
 	    nsPtr->numExportPatterns = 0;
 	    nsPtr->maxExportPatterns = 0;
 	}
@@ -1457,20 +1457,20 @@
 
     neededElems = nsPtr->numExportPatterns + 1;
     if (neededElems > nsPtr->maxExportPatterns) {
 	nsPtr->maxExportPatterns = nsPtr->maxExportPatterns ?
 		2 * nsPtr->maxExportPatterns : INIT_EXPORT_PATTERNS;
-	nsPtr->exportArrayPtr = Tcl_Realloc(nsPtr->exportArrayPtr,
+	nsPtr->exportArrayPtr = ckrealloc(nsPtr->exportArrayPtr,
 		sizeof(char *) * nsPtr->maxExportPatterns);
     }
 
     /*
      * Add the pattern to the namespace's array of export patterns.
      */
 
     len = strlen(pattern);
-    patternCpy = Tcl_Alloc(len + 1);
+    patternCpy = ckalloc(len + 1);
     memcpy(patternCpy, pattern, len + 1);
 
     nsPtr->exportArrayPtr[nsPtr->numExportPatterns] = patternCpy;
     nsPtr->numExportPatterns++;
 
@@ -1515,12 +1515,11 @@
 				 * for the current namespace. */
     Tcl_Obj *objPtr)		/* Points to the Tcl object onto which the
 				 * export pattern list is appended. */
 {
     Namespace *nsPtr;
-    size_t i;
-    int result;
+    int i, result;
 
     /*
      * If the specified namespace is NULL, use the current namespace.
      */
 
@@ -1585,11 +1584,11 @@
 				 * return an error if an imported cmd
 				 * conflicts with an existing one. */
 {
     Namespace *nsPtr, *importNsPtr, *dummyPtr;
     const char *simplePattern;
-    register Tcl_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     Tcl_HashSearch search;
 
     /*
      * If the specified namespace is NULL, use the current namespace.
      */
@@ -1718,11 +1717,11 @@
     const char *cmdName,
     const char *pattern,
     Namespace *importNsPtr,
     int allowOverwrite)
 {
-    size_t i = 0, exported = 0;
+    int i = 0, exported = 0;
     Tcl_HashEntry *found;
 
     /*
      * The command cmdName in the source namespace matches the pattern. Check
      * whether it was exported. If it wasn't, we ignore it.
@@ -1785,11 +1784,11 @@
 		    return TCL_ERROR;
 		}
 	    }
 	}
 
-	dataPtr = Tcl_Alloc(sizeof(ImportedCmdData));
+	dataPtr = ckalloc(sizeof(ImportedCmdData));
 	importedCmd = Tcl_NRCreateCommand(interp, Tcl_DStringValue(&ds),
 		TclInvokeImportedCmd, InvokeImportedNRCmd, dataPtr,
 		DeleteImportedCmd);
 	dataPtr->realCmdPtr = cmdPtr;
 	dataPtr->selfPtr = (Command *) importedCmd;
@@ -1799,11 +1798,11 @@
 	/*
 	 * Create an ImportRef structure describing this new import command
 	 * and add it to the import ref list in the "real" command.
 	 */
 
-	refPtr = Tcl_Alloc(sizeof(ImportRef));
+	refPtr = ckalloc(sizeof(ImportRef));
 	refPtr->importedCmdPtr = (Command *) importedCmd;
 	refPtr->nextPtr = cmdPtr->importRefPtr;
 	cmdPtr->importRefPtr = refPtr;
     } else {
 	Command *overwrite = Tcl_GetHashValue(found);
@@ -1864,11 +1863,11 @@
 				 * commands to remove. */
 {
     Namespace *nsPtr, *sourceNsPtr, *dummyPtr;
     const char *simplePattern;
     char *cmdName;
-    register Tcl_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     Tcl_HashSearch search;
 
     /*
      * If the specified namespace is NULL, use the current namespace.
      */
@@ -1991,11 +1990,11 @@
 Tcl_Command
 TclGetOriginalCommand(
     Tcl_Command command)	/* The imported command for which the original
 				 * command should be returned. */
 {
-    register Command *cmdPtr = (Command *) command;
+    Command *cmdPtr = (Command *) command;
     ImportedCmdData *dataPtr;
 
     if (cmdPtr->deleteProc != DeleteImportedCmd) {
 	return NULL;
     }
@@ -2080,11 +2079,11 @@
 				 * ImportedCmdData structure. */
 {
     ImportedCmdData *dataPtr = clientData;
     Command *realCmdPtr = dataPtr->realCmdPtr;
     Command *selfPtr = dataPtr->selfPtr;
-    register ImportRef *refPtr, *prevPtr;
+    ImportRef *refPtr, *prevPtr;
 
     prevPtr = NULL;
     for (refPtr = realCmdPtr->importRefPtr; refPtr != NULL;
 	    refPtr = refPtr->nextPtr) {
 	if (refPtr->importedCmdPtr == selfPtr) {
@@ -2096,12 +2095,12 @@
 	    if (prevPtr == NULL) { /* refPtr is first in list. */
 		realCmdPtr->importRefPtr = refPtr->nextPtr;
 	    } else {
 		prevPtr->nextPtr = refPtr->nextPtr;
 	    }
-	    Tcl_Free(refPtr);
-	    Tcl_Free(dataPtr);
+	    ckfree(refPtr);
+	    ckfree(dataPtr);
 	    return;
 	}
 	prevPtr = refPtr;
     }
 
@@ -2500,11 +2499,11 @@
     Tcl_Namespace *contextNsPtr,/* Ignored if TCL_GLOBAL_ONLY flag is set or
 				 * if the name starts with "::". Otherwise,
 				 * points to namespace in which to resolve
 				 * name; if NULL, look up name in the current
 				 * namespace. */
-    register int flags)		/* Flags controlling namespace lookup: an OR'd
+    int flags)		/* Flags controlling namespace lookup: an OR'd
 				 * combination of TCL_GLOBAL_ONLY and
 				 * TCL_LEAVE_ERR_MSG flags. */
 {
     Namespace *nsPtr, *dummy1Ptr, *dummy2Ptr;
     const char *dummy;
@@ -2571,12 +2570,12 @@
 				 * and TCL_NAMESPACE_ONLY are given,
 				 * TCL_GLOBAL_ONLY is ignored. */
 {
     Interp *iPtr = (Interp *) interp;
     Namespace *cxtNsPtr;
-    register Tcl_HashEntry *entryPtr;
-    register Command *cmdPtr;
+    Tcl_HashEntry *entryPtr;
+    Command *cmdPtr;
     const char *simpleName;
     int result;
 
     /*
      * If this namespace has a command resolver, then give it first crack at
@@ -2627,11 +2626,11 @@
      */
 
     cmdPtr = NULL;
     if (cxtNsPtr->commandPathLength!=0 && strncmp(name, "::", 2)
 	    && !(flags & TCL_NAMESPACE_ONLY)) {
-	size_t i;
+	int i;
 	Namespace *pathNsPtr, *realNsPtr, *dummyNsPtr;
 
 	(void) TclGetNamespaceForQualName(interp, name, cxtNsPtr,
 		TCL_NAMESPACE_ONLY, &realNsPtr, &dummyNsPtr, &dummyNsPtr,
 		&simpleName);
@@ -2683,11 +2682,11 @@
 		}
 	    }
 	}
     } else {
 	Namespace *nsPtr[2];
-	register int search;
+	int search;
 
 	TclGetNamespaceForQualName(interp, name, cxtNsPtr,
 		flags, &nsPtr[0], &nsPtr[1], &cxtNsPtr, &simpleName);
 
 	/*
@@ -2757,11 +2756,11 @@
     Tcl_Interp *interp,		/* Interpreter containing the new command. */
     Command *newCmdPtr)		/* Points to the new command. */
 {
     char *cmdName;
     Tcl_HashEntry *hPtr;
-    register Namespace *nsPtr;
+    Namespace *nsPtr;
     Namespace *trailNsPtr, *shadowNsPtr;
     Namespace *globalNsPtr = (Namespace *) TclGetGlobalNamespace(interp);
     int found, i;
     int trailFront = -1;
     int trailSize = 5;		/* Formerly NUM_TRAIL_ELEMS. */
@@ -3007,11 +3006,11 @@
     Tcl_Namespace *namespacePtr;
     Namespace *nsPtr, *childNsPtr;
     Namespace *globalNsPtr = (Namespace *) TclGetGlobalNamespace(interp);
     const char *pattern = NULL;
     Tcl_DString buffer;
-    register Tcl_HashEntry *entryPtr;
+    Tcl_HashEntry *entryPtr;
     Tcl_HashSearch search;
     Tcl_Obj *listPtr, *elemPtr;
 
     /*
      * Get a pointer to the specified namespace, or the current namespace.
@@ -3054,11 +3053,11 @@
      * names match the specified pattern, if any.
      */
 
     listPtr = Tcl_NewListObj(0, NULL);
     if ((pattern != NULL) && TclMatchIsTrivial(pattern)) {
-	size_t length = strlen(nsPtr->fullName);
+	unsigned int length = strlen(nsPtr->fullName);
 
 	if (strncmp(pattern, nsPtr->fullName, length) != 0) {
 	    goto searchDone;
 	}
 	if (
@@ -3133,12 +3132,12 @@
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Namespace *currNsPtr;
     Tcl_Obj *listPtr, *objPtr;
-    register const char *arg;
-    size_t length;
+    const char *arg;
+    int length;
 
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "arg");
 	return TCL_ERROR;
     }
@@ -3212,11 +3211,11 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    register Namespace *currNsPtr;
+    Namespace *currNsPtr;
 
     if (objc != 1) {
 	Tcl_WrongNumArgs(interp, 1, objv, NULL);
 	return TCL_ERROR;
     }
@@ -3277,11 +3276,11 @@
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Tcl_Namespace *namespacePtr;
     const char *name;
-    register int i;
+    int i;
 
     if (objc < 1) {
 	Tcl_WrongNumArgs(interp, 1, objv, "?name name...?");
 	return TCL_ERROR;
     }
@@ -3447,19 +3446,19 @@
     int result)
 {
     Tcl_Namespace *namespacePtr = data[0];
 
     if (result == TCL_ERROR) {
-	size_t length = strlen(namespacePtr->fullName);
-	unsigned limit = 200;
+	int length = strlen(namespacePtr->fullName);
+	int limit = 200;
 	int overflow = (length > limit);
 	char *cmd = data[1];
 
 	Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 		"\n    (in namespace %s \"%.*s%s\" script line %d)",
 		cmd,
-		(overflow ? limit : (unsigned)length), namespacePtr->fullName,
+		(overflow ? limit : length), namespacePtr->fullName,
 		(overflow ? "..." : ""), Tcl_GetErrorLine(interp)));
     }
 
     /*
      * Restore the previous "current" namespace.
@@ -3575,11 +3574,11 @@
     /*
      * Process the optional "-clear" argument.
      */
 
     firstArg = 1;
-    if (strcmp("-clear", TclGetString(objv[firstArg])) == 0) {
+    if (strcmp("-clear", Tcl_GetString(objv[firstArg])) == 0) {
 	Tcl_Export(interp, NULL, "::", 1);
 	Tcl_ResetResult(interp);
 	firstArg++;
     }
 
@@ -3586,11 +3585,11 @@
     /*
      * Add each pattern to the namespace's export pattern list.
      */
 
     for (i = firstArg;  i < objc;  i++) {
-	int result = Tcl_Export(interp, NULL, TclGetString(objv[i]), 0);
+	int result = Tcl_Export(interp, NULL, Tcl_GetString(objv[i]), 0);
 	if (result != TCL_OK) {
 	    return result;
 	}
     }
     return TCL_OK;
@@ -3632,11 +3631,11 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     const char *pattern;
-    register int i, result;
+    int i, result;
 
     if (objc < 1) {
 	Tcl_WrongNumArgs(interp, 1, objv, "?pattern pattern...?");
 	return TCL_ERROR;
     }
@@ -3698,11 +3697,11 @@
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     int allowOverwrite = 0;
     const char *string, *pattern;
-    register int i, result;
+    int i, result;
     int firstArg;
 
     if (objc < 1) {
 	Tcl_WrongNumArgs(interp, 1, objv, "?-force? ?pattern pattern...?");
 	return TCL_ERROR;
@@ -3851,11 +3850,11 @@
 
     if (objc == 3) {
 	cmdObjPtr = objv[2];
     } else {
 	Tcl_Obj *concatObjv[2];
-	register Tcl_Obj *listPtr;
+	Tcl_Obj *listPtr;
 
 	listPtr = Tcl_NewListObj(0, NULL);
 	for (i = 3;  i < objc;  i++) {
 	    if (Tcl_ListObjAppendElement(interp, listPtr, objv[i]) != TCL_OK){
 		Tcl_DecrRefCount(listPtr);	/* Free unneeded obj. */
@@ -4028,12 +4027,11 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Namespace *nsPtr = (Namespace *) TclGetCurrentNamespace(interp);
-    size_t i;
-    int nsObjc, result = TCL_ERROR;
+    int i, nsObjc, result = TCL_ERROR;
     Tcl_Obj **nsObjv;
     Tcl_Namespace **namespaceList = NULL;
 
     if (objc > 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "?pathList?");
@@ -4066,11 +4064,11 @@
     }
     if (nsObjc != 0) {
 	namespaceList = TclStackAlloc(interp,
 		sizeof(Tcl_Namespace *) * nsObjc);
 
-	for (i=0 ; i<(size_t)nsObjc ; i++) {
+	for (i=0 ; i<nsObjc ; i++) {
 	    if (TclGetNamespaceFromObj(interp, nsObjv[i],
 		    &namespaceList[i]) != TCL_OK) {
 		goto badNamespace;
 	    }
 	}
@@ -4111,17 +4109,17 @@
  */
 
 void
 TclSetNsPath(
     Namespace *nsPtr,		/* Namespace whose path is to be set. */
-    size_t pathLength,		/* Length of pathAry. */
+    int pathLength,		/* Length of pathAry. */
     Tcl_Namespace *pathAry[])	/* Array of namespaces that are the path. */
 {
     if (pathLength != 0) {
 	NamespacePathEntry *tmpPathArray =
-		Tcl_Alloc(sizeof(NamespacePathEntry) * pathLength);
-	size_t i;
+		ckalloc(sizeof(NamespacePathEntry) * pathLength);
+	int i;
 
 	for (i=0 ; i<pathLength ; i++) {
 	    tmpPathArray[i].nsPtr = (Namespace *) pathAry[i];
 	    tmpPathArray[i].creatorNsPtr = nsPtr;
 	    tmpPathArray[i].prevPtr = NULL;
@@ -4168,11 +4166,11 @@
 
 static void
 UnlinkNsPath(
     Namespace *nsPtr)
 {
-    size_t i;
+    int i;
     for (i=0 ; i<nsPtr->commandPathLength ; i++) {
 	NamespacePathEntry *nsPathPtr = &nsPtr->commandPathArray[i];
 
 	if (nsPathPtr->prevPtr != NULL) {
 	    nsPathPtr->prevPtr->nextPtr = nsPathPtr->nextPtr;
@@ -4184,11 +4182,11 @@
 	    if (nsPathPtr->nsPtr->commandPathSourceList == nsPathPtr) {
 		nsPathPtr->nsPtr->commandPathSourceList = nsPathPtr->nextPtr;
 	    }
 	}
     }
-    Tcl_Free(nsPtr->commandPathArray);
+    ckfree(nsPtr->commandPathArray);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -4253,12 +4251,12 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    register const char *name, *p;
-    size_t length;
+    const char *name, *p;
+    int length;
 
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "string");
 	return TCL_ERROR;
     }
@@ -4508,11 +4506,11 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    register const char *name, *p;
+    const char *name, *p;
 
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "string");
 	return TCL_ERROR;
     }
@@ -4711,11 +4709,11 @@
  *----------------------------------------------------------------------
  */
 
 static void
 FreeNsNameInternalRep(
-    register Tcl_Obj *objPtr)	/* nsName object with internal representation
+    Tcl_Obj *objPtr)	/* nsName object with internal representation
 				 * to free. */
 {
     ResolvedNsName *resNamePtr;
 
     NsNameGetIntRep(objPtr, resNamePtr);
@@ -4732,11 +4730,11 @@
 	 * namespace is dead, and there are no more references to it, free
 	 * it.
 	 */
 
 	TclNsDecrRefCount(resNamePtr->nsPtr);
-	Tcl_Free(resNamePtr);
+	ckfree(resNamePtr);
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -4758,11 +4756,11 @@
  */
 
 static void
 DupNsNameInternalRep(
     Tcl_Obj *srcPtr,		/* Object with internal rep to copy. */
-    register Tcl_Obj *copyPtr)	/* Object with internal rep to set. */
+    Tcl_Obj *copyPtr)	/* Object with internal rep to set. */
 {
     ResolvedNsName *resNamePtr;
 
     NsNameGetIntRep(srcPtr, resNamePtr);
     assert(resNamePtr != NULL);
@@ -4794,15 +4792,15 @@
 static int
 SetNsNameFromAny(
     Tcl_Interp *interp,		/* Points to the namespace in which to resolve
 				 * name. Also used for error reporting if not
 				 * NULL. */
-    register Tcl_Obj *objPtr)	/* The object to convert. */
+    Tcl_Obj *objPtr)	/* The object to convert. */
 {
     const char *dummy;
     Namespace *nsPtr, *dummy1Ptr, *dummy2Ptr;
-    register ResolvedNsName *resNamePtr;
+    ResolvedNsName *resNamePtr;
     const char *name;
 
     if (interp == NULL) {
 	return TCL_ERROR;
     }
@@ -4819,11 +4817,11 @@
      * If we found a namespace, then create a new ResolvedNsName structure
      * that holds a reference to it.
      */
 
     nsPtr->refCount++;
-    resNamePtr = Tcl_Alloc(sizeof(ResolvedNsName));
+    resNamePtr = ckalloc(sizeof(ResolvedNsName));
     resNamePtr->nsPtr = nsPtr;
     if ((name[0] == ':') && (name[1] == ':')) {
 	resNamePtr->refNsPtr = NULL;
     } else {
 	resNamePtr->refNsPtr = (Namespace *) TclGetCurrentNamespace(interp);
@@ -4879,11 +4877,11 @@
     Namespace *nPtr = (Namespace *) nsPtr;
 #ifndef BREAK_NAMESPACE_COMPAT
     return &nPtr->childTable;
 #else
     if (nPtr->childTablePtr == NULL) {
-	nPtr->childTablePtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+	nPtr->childTablePtr = ckalloc(sizeof(Tcl_HashTable));
 	Tcl_InitHashTable(nPtr->childTablePtr, TCL_STRING_KEYS);
     }
     return nPtr->childTablePtr;
 #endif
 }
@@ -4915,17 +4913,17 @@
     Tcl_Interp *interp,		/* Interpreter in which to log information. */
     const char *script,		/* First character in script containing
 				 * command (must be <= command). */
     const char *command,	/* First character in command that generated
 				 * the error. */
-    size_t length,			/* Number of bytes in command (-1 means
-				 * use all bytes up to first null byte). */
+    int length,			/* Number of bytes in command (-1 means use
+				 * all bytes up to first null byte). */
     const unsigned char *pc,    /* Current pc of bytecode execution context */
     Tcl_Obj **tosPtr)		/* Current stack of bytecode execution
 				 * context */
 {
-    register const char *p;
+    const char *p;
     Interp *iPtr = (Interp *) interp;
     int overflow, limit = 150;
     Var *varPtr, *arrayPtr;
 
     if (iPtr->flags & ERR_ALREADY_LOGGED) {
@@ -4947,18 +4945,18 @@
 	    if (*p == '\n') {
 		iPtr->errorLine++;
 	    }
 	}
 
-	if (length == TCL_AUTO_LENGTH) {
+	if (length < 0) {
 	    length = strlen(command);
 	}
-	overflow = (length > (size_t)limit);
+	overflow = (length > limit);
 	Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 		"\n    %s\n\"%.*s%s\"", ((iPtr->errorInfo == NULL)
 		? "while executing" : "invoked from within"),
-		(overflow ? limit : (int)length), command,
+		(overflow ? limit : length), command,
 		(overflow ? "..." : "")));
 
 	varPtr = TclObjLookupVarEx(interp, iPtr->eiVar, NULL, TCL_GLOBAL_ONLY,
 		NULL, 0, 0, &arrayPtr);
 	if ((varPtr == NULL) || !TclIsVarTraced(varPtr)) {
@@ -5072,11 +5070,11 @@
 
 void
 TclErrorStackResetIf(
     Tcl_Interp *interp,
     const char *msg,
-    size_t length)
+    int length)
 {
     Interp *iPtr = (Interp *) interp;
 
     if (Tcl_IsShared(iPtr->errorStack)) {
 	Tcl_Obj *newObj;
@@ -5127,11 +5125,11 @@
     Tcl_Interp *interp,		/* Interpreter in which to log information. */
     const char *script,		/* First character in script containing
 				 * command (must be <= command). */
     const char *command,	/* First character in command that generated
 				 * the error. */
-    size_t length)		/* Number of bytes in command (-1 means use
+    int length)			/* Number of bytes in command (-1 means use
 				 * all bytes up to first null byte). */
 {
     TclLogCommandInfo(interp, script, command, length, NULL, NULL);
 }
 

Index: generic/tclNotify.c
==================================================================
--- generic/tclNotify.c
+++ generic/tclNotify.c
@@ -179,11 +179,11 @@
 
     Tcl_MutexLock(&(tsdPtr->queueMutex));
     for (evPtr = tsdPtr->firstEventPtr; evPtr != NULL; ) {
 	hold = evPtr;
 	evPtr = evPtr->nextPtr;
-	Tcl_Free(hold);
+	ckfree(hold);
     }
     tsdPtr->firstEventPtr = NULL;
     tsdPtr->lastEventPtr = NULL;
     Tcl_MutexUnlock(&(tsdPtr->queueMutex));
 
@@ -274,11 +274,11 @@
 				 * happened. */
     ClientData clientData)	/* One-word argument to pass to setupProc and
 				 * checkProc. */
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-    EventSource *sourcePtr = Tcl_Alloc(sizeof(EventSource));
+    EventSource *sourcePtr = ckalloc(sizeof(EventSource));
 
     sourcePtr->setupProc = setupProc;
     sourcePtr->checkProc = checkProc;
     sourcePtr->clientData = clientData;
     sourcePtr->nextPtr = tsdPtr->firstEventSourcePtr;
@@ -328,11 +328,11 @@
 	if (prevPtr == NULL) {
 	    tsdPtr->firstEventSourcePtr = sourcePtr->nextPtr;
 	} else {
 	    prevPtr->nextPtr = sourcePtr->nextPtr;
 	}
-	Tcl_Free(sourcePtr);
+	ckfree(sourcePtr);
 	return;
     }
 }
 
 /*
@@ -353,11 +353,11 @@
 
 void
 Tcl_QueueEvent(
     Tcl_Event *evPtr,		/* Event to add to queue. The storage space
 				 * must have been allocated the caller with
-				 * malloc (Tcl_Alloc), and it becomes the
+				 * malloc (ckalloc), and it becomes the
 				 * property of the event queue. It will be
 				 * freed after the event has been handled. */
     Tcl_QueuePosition position)	/* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD,
 				 * TCL_QUEUE_MARK. */
 {
@@ -385,11 +385,11 @@
 void
 Tcl_ThreadQueueEvent(
     Tcl_ThreadId threadId,	/* Identifier for thread to use. */
     Tcl_Event *evPtr,		/* Event to add to queue. The storage space
 				 * must have been allocated the caller with
-				 * malloc (Tcl_Alloc), and it becomes the
+				 * malloc (ckalloc), and it becomes the
 				 * property of the event queue. It will be
 				 * freed after the event has been handled. */
     Tcl_QueuePosition position)	/* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD,
 				 * TCL_QUEUE_MARK. */
 {
@@ -410,11 +410,11 @@
      */
 
     if (tsdPtr) {
 	QueueEvent(tsdPtr, evPtr, position);
     } else {
-	Tcl_Free(evPtr);
+	ckfree(evPtr);
     }
     Tcl_MutexUnlock(&listLock);
 }
 
 /*
@@ -442,11 +442,11 @@
 QueueEvent(
     ThreadSpecificData *tsdPtr,	/* Handle to thread local data that indicates
 				 * which event queue to use. */
     Tcl_Event *evPtr,		/* Event to add to queue.  The storage space
 				 * must have been allocated the caller with
-				 * malloc (Tcl_Alloc), and it becomes the
+				 * malloc (ckalloc), and it becomes the
 				 * property of the event queue. It will be
 				 * freed after the event has been handled. */
     Tcl_QueuePosition position)	/* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD,
 				 * TCL_QUEUE_MARK. */
 {
@@ -561,11 +561,11 @@
 	     * Delete the event data structure.
 	     */
 
 	    hold = evPtr;
 	    evPtr = evPtr->nextPtr;
-	    Tcl_Free(hold);
+	    ckfree(hold);
 	} else {
 	    /*
 	     * Event is to be retained.
 	     */
 
@@ -700,11 +700,11 @@
 		} else {
 		    evPtr = NULL;
 		}
 	    }
 	    if (evPtr) {
-		Tcl_Free(evPtr);
+		ckfree(evPtr);
 	    }
 	    Tcl_MutexUnlock(&(tsdPtr->queueMutex));
 	    return 1;
 	} else {
 	    /*

Index: generic/tclOO.c
==================================================================
--- generic/tclOO.c
+++ generic/tclOO.c
@@ -298,11 +298,11 @@
     Tcl_Interp *interp)
 {
     static Tcl_ThreadDataKey tsdKey;
     ThreadLocalData *tsdPtr =
 	    Tcl_GetThreadData(&tsdKey, sizeof(ThreadLocalData));
-    Foundation *fPtr = Tcl_Alloc(sizeof(Foundation));
+    Foundation *fPtr = ckalloc(sizeof(Foundation));
     Tcl_Obj *namePtr;
     Tcl_DString buffer;
     Command *cmdPtr;
     int i;
 
@@ -321,11 +321,11 @@
 	    DeletedDefineNamespace);
     fPtr->objdefNs = Tcl_CreateNamespace(interp, "::oo::objdefine", fPtr,
 	    DeletedObjdefNamespace);
     fPtr->helpersNs = Tcl_CreateNamespace(interp, "::oo::Helpers", fPtr,
 	    DeletedHelpersNamespace);
-    fPtr->epoch = 1;
+    fPtr->epoch = 0;
     fPtr->tsdPtr = tsdPtr;
     TclNewLiteralStringObj(fPtr->unknownMethodNameObj, "unknown");
     TclNewLiteralStringObj(fPtr->constructorName, "<constructor>");
     TclNewLiteralStringObj(fPtr->destructorName, "<destructor>");
     TclNewLiteralStringObj(fPtr->clonedName, "<cloned>");
@@ -463,11 +463,11 @@
      * incremented reference count of fPtr->objectCls that was swallowed by
      * fakeObject.
      */
 
     fPtr->objectCls->superclasses.num = 0;
-    Tcl_Free(fPtr->objectCls->superclasses.list);
+    ckfree(fPtr->objectCls->superclasses.list);
     fPtr->objectCls->superclasses.list = NULL;
 
     /*
      * Special initialization for the primordial objects.
      */
@@ -582,11 +582,11 @@
     TclDecrRefCount(fPtr->clonedName);
     TclDecrRefCount(fPtr->defineName);
     TclOODecrRefCount(fPtr->objectCls->thisPtr);
     TclOODecrRefCount(fPtr->classCls->thisPtr);
 
-    Tcl_Free(fPtr);
+    ckfree(fPtr);
 }
 
 /*
  * ----------------------------------------------------------------------
  *
@@ -620,13 +620,13 @@
 {
     Foundation *fPtr = GetFoundation(interp);
     Object *oPtr;
     Command *cmdPtr;
     CommandTrace *tracePtr;
-    size_t creationEpoch;
+    int creationEpoch;
 
-    oPtr = Tcl_Alloc(sizeof(Object));
+    oPtr = ckalloc(sizeof(Object));
     memset(oPtr, 0, sizeof(Object));
 
     /*
      * Every object has a namespace; make one. Note that this also normally
      * computes the creation epoch value for the object, a sequence number
@@ -649,11 +649,11 @@
     }
 
     while (1) {
 	char objName[10 + TCL_INTEGER_SPACE];
 
-	sprintf(objName, "::oo::Obj%" TCL_Z_MODIFIER "u", ++fPtr->tsdPtr->nsCount);
+	sprintf(objName, "::oo::Obj%d", ++fPtr->tsdPtr->nsCount);
 	oPtr->namespacePtr = Tcl_CreateNamespace(interp, objName, oPtr, NULL);
 	if (oPtr->namespacePtr != NULL) {
 	    creationEpoch = fPtr->tsdPtr->nsCount;
 	    break;
 	}
@@ -733,11 +733,11 @@
      * abstractions, it is faster and we're inside Tcl here so we're allowed.
      */
 
     cmdPtr = (Command *) oPtr->command;
     cmdPtr->nreProc = PublicNRObjectCmd;
-    cmdPtr->tracePtr = tracePtr = Tcl_Alloc(sizeof(CommandTrace));
+    cmdPtr->tracePtr = tracePtr = ckalloc(sizeof(CommandTrace));
     tracePtr->traceProc = ObjectRenamedTrace;
     tracePtr->clientData = oPtr;
     tracePtr->flags = TCL_TRACE_RENAME|TCL_TRACE_DELETE;
     tracePtr->nextPtr = NULL;
     tracePtr->refCount = 1;
@@ -787,11 +787,11 @@
 static void
 MyDeleted(
     ClientData clientData)	/* Reference to the object whose [my] has been
 				 * squelched. */
 {
-    register Object *oPtr = clientData;
+    Object *oPtr = clientData;
 
     oPtr->myCommand = NULL;
 }
 
 static void
@@ -887,11 +887,11 @@
 	    }
 	    TclOORemoveFromMixinSubs(mixinSubclassPtr, clsPtr);
 	}
     }
     if (clsPtr->mixinSubs.size > 0) {
-	Tcl_Free(clsPtr->mixinSubs.list);
+	ckfree(clsPtr->mixinSubs.list);
 	clsPtr->mixinSubs.size = 0;
     }
 
     /*
      * Squelch subclasses of this class.
@@ -907,11 +907,11 @@
 	    }
 	    TclOORemoveFromSubclasses(subclassPtr, clsPtr);
 	}
     }
     if (clsPtr->subclasses.size > 0) {
-	Tcl_Free(clsPtr->subclasses.list);
+	ckfree(clsPtr->subclasses.list);
 	clsPtr->subclasses.list = NULL;
 	clsPtr->subclasses.size = 0;
     }
 
     /*
@@ -932,11 +932,11 @@
 	    }
 	    TclOORemoveFromInstances(instancePtr, clsPtr);
 	}
     }
     if (clsPtr->instances.size > 0) {
-	Tcl_Free(clsPtr->instances.list);
+	ckfree(clsPtr->instances.list);
 	clsPtr->instances.list = NULL;
 	clsPtr->instances.size = 0;
     }
 }
 
@@ -1008,11 +1008,11 @@
 
 	FOREACH_HASH_VALUE(callPtr, clsPtr->classChainCache) {
 	    TclOODeleteChain(callPtr);
 	}
 	Tcl_DeleteHashTable(clsPtr->classChainCache);
-	Tcl_Free(clsPtr->classChainCache);
+	ckfree(clsPtr->classChainCache);
 	clsPtr->classChainCache = NULL;
     }
 
     /*
      * Squelch our filter list.
@@ -1022,11 +1022,11 @@
 	Tcl_Obj *filterObj;
 
 	FOREACH(filterObj, clsPtr->filters) {
 	    TclDecrRefCount(filterObj);
 	}
-	Tcl_Free(clsPtr->filters.list);
+	ckfree(clsPtr->filters.list);
 	clsPtr->filters.list = NULL;
 	clsPtr->filters.num = 0;
     }
 
     /*
@@ -1039,30 +1039,30 @@
 
 	FOREACH_HASH(metadataTypePtr, value, clsPtr->metadataPtr) {
 	    metadataTypePtr->deleteProc(value);
 	}
 	Tcl_DeleteHashTable(clsPtr->metadataPtr);
-	Tcl_Free(clsPtr->metadataPtr);
+	ckfree(clsPtr->metadataPtr);
 	clsPtr->metadataPtr = NULL;
     }
 
     if (clsPtr->mixins.num) {
 	FOREACH(tmpClsPtr, clsPtr->mixins) {
 	    TclOORemoveFromMixinSubs(clsPtr, tmpClsPtr);
 	    TclOODecrRefCount(tmpClsPtr->thisPtr);
 	}
-	Tcl_Free(clsPtr->mixins.list);
+	ckfree(clsPtr->mixins.list);
 	clsPtr->mixins.list = NULL;
 	clsPtr->mixins.num = 0;
     }
 
     if (clsPtr->superclasses.num > 0) {
 	FOREACH(tmpClsPtr, clsPtr->superclasses) {
 	    TclOORemoveFromSubclasses(clsPtr, tmpClsPtr);
 	    TclOODecrRefCount(tmpClsPtr->thisPtr);
 	}
-	Tcl_Free(clsPtr->superclasses.list);
+	ckfree(clsPtr->superclasses.list);
 	clsPtr->superclasses.num = 0;
 	clsPtr->superclasses.list = NULL;
     }
 
     FOREACH_HASH_VALUE(mPtr, &clsPtr->classMethods) {
@@ -1074,19 +1074,19 @@
 
     FOREACH(variableObj, clsPtr->variables) {
 	TclDecrRefCount(variableObj);
     }
     if (i) {
-	Tcl_Free(clsPtr->variables.list);
+	ckfree(clsPtr->variables.list);
     }
 
     FOREACH_STRUCT(privateVariable, clsPtr->privateVariables) {
 	TclDecrRefCount(privateVariable->variableObj);
 	TclDecrRefCount(privateVariable->fullNameObj);
     }
     if (i) {
-	Tcl_Free(clsPtr->privateVariables.list);
+	ckfree(clsPtr->privateVariables.list);
     }
 
     if (IsRootClass(oPtr) && !Deleted(fPtr->objectCls->thisPtr)) {
 	Tcl_DeleteCommandFromToken(interp, fPtr->objectCls->thisPtr->command);
     }
@@ -1214,42 +1214,42 @@
 	FOREACH(mixinPtr, oPtr->mixins) {
 	    TclOORemoveFromInstances(oPtr, mixinPtr);
 	    TclOODecrRefCount(mixinPtr->thisPtr);
 	}
 	if (oPtr->mixins.list != NULL) {
-	    Tcl_Free(oPtr->mixins.list);
+	    ckfree(oPtr->mixins.list);
 	}
     }
 
     FOREACH(filterObj, oPtr->filters) {
 	TclDecrRefCount(filterObj);
     }
     if (i) {
-	Tcl_Free(oPtr->filters.list);
+	ckfree(oPtr->filters.list);
     }
 
     if (oPtr->methodsPtr) {
 	FOREACH_HASH_VALUE(mPtr, oPtr->methodsPtr) {
 	    TclOODelMethodRef(mPtr);
 	}
 	Tcl_DeleteHashTable(oPtr->methodsPtr);
-	Tcl_Free(oPtr->methodsPtr);
+	ckfree(oPtr->methodsPtr);
     }
 
     FOREACH(variableObj, oPtr->variables) {
 	TclDecrRefCount(variableObj);
     }
     if (i) {
-	Tcl_Free(oPtr->variables.list);
+	ckfree(oPtr->variables.list);
     }
 
     FOREACH_STRUCT(privateVariable, oPtr->privateVariables) {
 	TclDecrRefCount(privateVariable->variableObj);
 	TclDecrRefCount(privateVariable->fullNameObj);
     }
     if (i) {
-	Tcl_Free(oPtr->privateVariables.list);
+	ckfree(oPtr->privateVariables.list);
     }
 
     if (oPtr->chainCache) {
 	TclOODeleteChainCache(oPtr->chainCache);
     }
@@ -1262,11 +1262,11 @@
 
 	FOREACH_HASH(metadataTypePtr, value, oPtr->metadataPtr) {
 	    metadataTypePtr->deleteProc(value);
 	}
 	Tcl_DeleteHashTable(oPtr->metadataPtr);
-	Tcl_Free(oPtr->metadataPtr);
+	ckfree(oPtr->metadataPtr);
 	oPtr->metadataPtr = NULL;
     }
 
     /*
      * Because an object can be a class that is an instance of itself, the
@@ -1318,13 +1318,13 @@
     Object *oPtr)
 {
     if (oPtr->refCount-- <= 1) {
 
 	if (oPtr->classPtr != NULL) {
-	    Tcl_Free(oPtr->classPtr);
+	    ckfree(oPtr->classPtr);
 	}
-	Tcl_Free(oPtr);
+	ckfree(oPtr);
 	return 1;
     }
     return 0;
 }
 
@@ -1378,13 +1378,13 @@
 				 * present as an instance in the class. */
 {
     if (clsPtr->instances.num >= clsPtr->instances.size) {
 	clsPtr->instances.size += ALLOC_CHUNK;
 	if (clsPtr->instances.size == ALLOC_CHUNK) {
-	    clsPtr->instances.list = Tcl_Alloc(sizeof(Object *) * ALLOC_CHUNK);
+	    clsPtr->instances.list = ckalloc(sizeof(Object *) * ALLOC_CHUNK);
 	} else {
-	    clsPtr->instances.list = Tcl_Realloc(clsPtr->instances.list,
+	    clsPtr->instances.list = ckrealloc(clsPtr->instances.list,
 		    sizeof(Object *) * clsPtr->instances.size);
 	}
     }
     clsPtr->instances.list[clsPtr->instances.num++] = oPtr;
     AddRef(oPtr);
@@ -1417,11 +1417,11 @@
 	    res++;
 	    break;
 	}
     }
     if (oPtr->mixins.num == 0) {
-	Tcl_Free(oPtr->mixins.list);
+	ckfree(oPtr->mixins.list);
 	oPtr->mixins.list = NULL;
     }
     return res;
 }
 
@@ -1477,13 +1477,13 @@
 	return;
     }
     if (superPtr->subclasses.num >= superPtr->subclasses.size) {
 	superPtr->subclasses.size += ALLOC_CHUNK;
 	if (superPtr->subclasses.size == ALLOC_CHUNK) {
-	    superPtr->subclasses.list = Tcl_Alloc(sizeof(Class *) * ALLOC_CHUNK);
+	    superPtr->subclasses.list = ckalloc(sizeof(Class *) * ALLOC_CHUNK);
 	} else {
-	    superPtr->subclasses.list = Tcl_Realloc(superPtr->subclasses.list,
+	    superPtr->subclasses.list = ckrealloc(superPtr->subclasses.list,
 		    sizeof(Class *) * superPtr->subclasses.size);
 	}
     }
     superPtr->subclasses.list[superPtr->subclasses.num++] = subPtr;
     AddRef(subPtr->thisPtr);
@@ -1542,13 +1542,13 @@
 	return;
     }
     if (superPtr->mixinSubs.num >= superPtr->mixinSubs.size) {
 	superPtr->mixinSubs.size += ALLOC_CHUNK;
 	if (superPtr->mixinSubs.size == ALLOC_CHUNK) {
-	    superPtr->mixinSubs.list = Tcl_Alloc(sizeof(Class *) * ALLOC_CHUNK);
+	    superPtr->mixinSubs.list = ckalloc(sizeof(Class *) * ALLOC_CHUNK);
 	} else {
-	    superPtr->mixinSubs.list = Tcl_Realloc(superPtr->mixinSubs.list,
+	    superPtr->mixinSubs.list = ckrealloc(superPtr->mixinSubs.list,
 		    sizeof(Class *) * superPtr->mixinSubs.size);
 	}
     }
     superPtr->mixinSubs.list[superPtr->mixinSubs.num++] = subPtr;
     AddRef(subPtr->thisPtr);
@@ -1590,11 +1590,11 @@
 				 * class. */
     Object *useThisObj)		/* Object that is to act as the class
 				 * representation. */
 {
     Foundation *fPtr = GetFoundation(interp);
-    Class *clsPtr = Tcl_Alloc(sizeof(Class));
+    Class *clsPtr = ckalloc(sizeof(Class));
 
     memset(clsPtr, 0, sizeof(Class));
     clsPtr->thisPtr = useThisObj;
 
     /*
@@ -1607,11 +1607,11 @@
      * Classes are subclasses of oo::object, i.e. the objects they create are
      * objects.
      */
 
     clsPtr->superclasses.num = 1;
-    clsPtr->superclasses.list = Tcl_Alloc(sizeof(Class *));
+    clsPtr->superclasses.list = ckalloc(sizeof(Class *));
     clsPtr->superclasses.list[0] = fPtr->objectCls;
     AddRef(fPtr->objectCls->thisPtr);
 
     /*
      * Finish connecting the class structure to the object structure.
@@ -1650,11 +1650,11 @@
 				 * do not call constructor. */
     Tcl_Obj *const *objv,	/* Argument list. */
     int skip)			/* Number of arguments to _not_ pass to the
 				 * constructor. */
 {
-    register Class *classPtr = (Class *) cls;
+    Class *classPtr = (Class *) cls;
     Object *oPtr;
     ClientData clientData[4];
 
     oPtr = TclNewObjectInstanceCommon(interp, classPtr, nameStr, nsNameStr);
     if (oPtr == NULL) {
@@ -1720,11 +1720,11 @@
     int skip,			/* Number of arguments to _not_ pass to the
 				 * constructor. */
     Tcl_Object *objectPtr)	/* Place to write the object reference upon
 				 * successful allocation. */
 {
-    register Class *classPtr = (Class *) cls;
+    Class *classPtr = (Class *) cls;
     CallContext *contextPtr;
     Tcl_InterpState state;
     Object *oPtr;
 
     oPtr = TclNewObjectInstanceCommon(interp, classPtr, nameStr, nsNameStr);
@@ -1957,11 +1957,11 @@
 	    if (mixinPtr && mixinPtr != o2Ptr->selfCls) {
 		TclOORemoveFromInstances(o2Ptr, mixinPtr);
 	    }
 	    TclOODecrRefCount(mixinPtr->thisPtr);
 	}
-	Tcl_Free(o2Ptr->mixins.list);
+	ckfree(o2Ptr->mixins.list);
     }
     DUPLICATE(o2Ptr->mixins, oPtr->mixins, Class *);
     FOREACH(mixinPtr, o2Ptr->mixins) {
 	if (mixinPtr && mixinPtr != o2Ptr->selfCls) {
 	    TclOOAddToInstances(o2Ptr, mixinPtr);
@@ -2058,15 +2058,15 @@
 	FOREACH(superPtr, cls2Ptr->superclasses) {
 	    TclOORemoveFromSubclasses(cls2Ptr, superPtr);
 	    TclOODecrRefCount(superPtr->thisPtr);
 	}
 	if (cls2Ptr->superclasses.num) {
-	    cls2Ptr->superclasses.list = Tcl_Realloc(cls2Ptr->superclasses.list,
+	    cls2Ptr->superclasses.list = ckrealloc(cls2Ptr->superclasses.list,
 		    sizeof(Class *) * clsPtr->superclasses.num);
 	} else {
 	    cls2Ptr->superclasses.list =
-		    Tcl_Alloc(sizeof(Class *) * clsPtr->superclasses.num);
+		    ckalloc(sizeof(Class *) * clsPtr->superclasses.num);
 	}
 	memcpy(cls2Ptr->superclasses.list, clsPtr->superclasses.list,
 		sizeof(Class *) * clsPtr->superclasses.num);
 	cls2Ptr->superclasses.num = clsPtr->superclasses.num;
 	FOREACH(superPtr, cls2Ptr->superclasses) {
@@ -2113,11 +2113,11 @@
 	if (cls2Ptr->mixins.num != 0) {
 	    FOREACH(mixinPtr, cls2Ptr->mixins) {
 		TclOORemoveFromMixinSubs(cls2Ptr, mixinPtr);
 		TclOODecrRefCount(mixinPtr->thisPtr);
 	    }
-	    Tcl_Free(clsPtr->mixins.list);
+	    ckfree(clsPtr->mixins.list);
 	}
 	DUPLICATE(cls2Ptr->mixins, clsPtr->mixins, Class *);
 	FOREACH(mixinPtr, cls2Ptr->mixins) {
 	    TclOOAddToMixinSubs(cls2Ptr, mixinPtr);
 
@@ -2356,11 +2356,11 @@
 
     if (clsPtr->metadataPtr == NULL) {
 	if (metadata == NULL) {
 	    return;
 	}
-	clsPtr->metadataPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+	clsPtr->metadataPtr = ckalloc(sizeof(Tcl_HashTable));
 	Tcl_InitHashTable(clsPtr->metadataPtr, TCL_ONE_WORD_KEYS);
     }
 
     /*
      * If the metadata is NULL, we're deleting the metadata for the type.
@@ -2436,11 +2436,11 @@
 
     if (oPtr->metadataPtr == NULL) {
 	if (metadata == NULL) {
 	    return;
 	}
-	oPtr->metadataPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+	oPtr->metadataPtr = ckalloc(sizeof(Tcl_HashTable));
 	Tcl_InitHashTable(oPtr->metadataPtr, TCL_ONE_WORD_KEYS);
     }
 
     /*
      * If the metadata is NULL, we're deleting the metadata for the type.
@@ -2654,11 +2654,11 @@
      * Give plugged in code a chance to remap the method name.
      */
 
     methodNamePtr = objv[1];
     if (oPtr->mapMethodNameProc != NULL) {
-	register Class **startClsPtr = &startCls;
+	Class **startClsPtr = &startCls;
 	Tcl_Obj *mappedMethodName = Tcl_DuplicateObj(methodNamePtr);
 
 	result = oPtr->mapMethodNameProc(interp, (Tcl_Object) oPtr,
 		(Tcl_Class *) startClsPtr, mappedMethodName);
 	if (result != TCL_OK) {
@@ -2713,11 +2713,11 @@
      */
 
     if (startCls != NULL) {
 	for (; contextPtr->index < contextPtr->callPtr->numChain;
 		contextPtr->index++) {
-	    register struct MInvoke *miPtr =
+	    struct MInvoke *miPtr =
 		    &contextPtr->callPtr->chain[contextPtr->index];
 
 	    if (miPtr->isFilter) {
 		continue;
 	    }
@@ -2851,11 +2851,11 @@
     Tcl_ObjectContext context,
     int objc,
     Tcl_Obj *const *objv,
     int skip)
 {
-    register CallContext *contextPtr = (CallContext *) context;
+    CallContext *contextPtr = (CallContext *) context;
 
     if (contextPtr->index + 1 >= contextPtr->callPtr->numChain) {
 	/*
 	 * We're at the end of the chain; generate an error message unless the
 	 * interpreter is being torn down, in which case we might be getting

Index: generic/tclOO.decls
==================================================================
--- generic/tclOO.decls
+++ generic/tclOO.decls
@@ -49,24 +49,24 @@
 declare 8 {
     int Tcl_MethodIsPublic(Tcl_Method method)
 }
 declare 9 {
     int Tcl_MethodIsType(Tcl_Method method, const Tcl_MethodType *typePtr,
-	    void **clientDataPtr)
+	    ClientData *clientDataPtr)
 }
 declare 10 {
     Tcl_Obj *Tcl_MethodName(Tcl_Method method)
 }
 declare 11 {
     Tcl_Method Tcl_NewInstanceMethod(Tcl_Interp *interp, Tcl_Object object,
 	    Tcl_Obj *nameObj, int flags, const Tcl_MethodType *typePtr,
-	    void *clientData)
+	    ClientData clientData)
 }
 declare 12 {
     Tcl_Method Tcl_NewMethod(Tcl_Interp *interp, Tcl_Class cls,
 	    Tcl_Obj *nameObj, int flags, const Tcl_MethodType *typePtr,
-	    void *clientData)
+	    ClientData clientData)
 }
 declare 13 {
     Tcl_Object Tcl_NewObjectInstance(Tcl_Interp *interp, Tcl_Class cls,
 	    const char *nameStr, const char *nsNameStr, int objc,
 	    Tcl_Obj *const *objv, int skip)
@@ -85,24 +85,24 @@
 }
 declare 18 {
     int Tcl_ObjectContextSkippedArgs(Tcl_ObjectContext context)
 }
 declare 19 {
-    void *Tcl_ClassGetMetadata(Tcl_Class clazz,
+    ClientData Tcl_ClassGetMetadata(Tcl_Class clazz,
 	    const Tcl_ObjectMetadataType *typePtr)
 }
 declare 20 {
     void Tcl_ClassSetMetadata(Tcl_Class clazz,
-	    const Tcl_ObjectMetadataType *typePtr, void *metadata)
+	    const Tcl_ObjectMetadataType *typePtr, ClientData metadata)
 }
 declare 21 {
-    void *Tcl_ObjectGetMetadata(Tcl_Object object,
+    ClientData Tcl_ObjectGetMetadata(Tcl_Object object,
 	    const Tcl_ObjectMetadataType *typePtr)
 }
 declare 22 {
     void Tcl_ObjectSetMetadata(Tcl_Object object,
-	    const Tcl_ObjectMetadataType *typePtr, void *metadata)
+	    const Tcl_ObjectMetadataType *typePtr, ClientData metadata)
 }
 declare 23 {
     int Tcl_ObjectContextInvokeNext(Tcl_Interp *interp,
 	    Tcl_ObjectContext context, int objc, Tcl_Obj *const *objv,
 	    int skip)
@@ -142,18 +142,18 @@
     Tcl_Object TclOOGetDefineCmdContext(Tcl_Interp *interp)
 }
 declare 1 {
     Tcl_Method TclOOMakeProcInstanceMethod(Tcl_Interp *interp, Object *oPtr,
 	    int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj,
-	    const Tcl_MethodType *typePtr, void *clientData,
+	    const Tcl_MethodType *typePtr, ClientData clientData,
 	    Proc **procPtrPtr)
 }
 declare 2 {
     Tcl_Method TclOOMakeProcMethod(Tcl_Interp *interp, Class *clsPtr,
 	    int flags, Tcl_Obj *nameObj, const char *namePtr,
 	    Tcl_Obj *argsObj, Tcl_Obj *bodyObj, const Tcl_MethodType *typePtr,
-	    void *clientData, Proc **procPtrPtr)
+	    ClientData clientData, Proc **procPtrPtr)
 }
 declare 3 {
     Method *TclOONewProcInstanceMethod(Tcl_Interp *interp, Object *oPtr,
 	    int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj,
 	    ProcedureMethod **pmPtrPtr)
@@ -180,17 +180,17 @@
 }
 declare 9 {
     Tcl_Method TclOONewProcInstanceMethodEx(Tcl_Interp *interp,
 	    Tcl_Object oPtr, TclOO_PreCallProc *preCallPtr,
 	    TclOO_PostCallProc *postCallPtr, ProcErrorProc *errProc,
-	    void *clientData, Tcl_Obj *nameObj, Tcl_Obj *argsObj,
+	    ClientData clientData, Tcl_Obj *nameObj, Tcl_Obj *argsObj,
 	    Tcl_Obj *bodyObj, int flags, void **internalTokenPtr)
 }
 declare 10 {
     Tcl_Method TclOONewProcMethodEx(Tcl_Interp *interp, Tcl_Class clsPtr,
 	    TclOO_PreCallProc *preCallPtr, TclOO_PostCallProc *postCallPtr,
-	    ProcErrorProc *errProc, void *clientData, Tcl_Obj *nameObj,
+	    ProcErrorProc *errProc, ClientData clientData, Tcl_Obj *nameObj,
 	    Tcl_Obj *argsObj, Tcl_Obj *bodyObj, int flags,
 	    void **internalTokenPtr)
 }
 declare 11 {
     int TclOOInvokeObject(Tcl_Interp *interp, Tcl_Object object,

Index: generic/tclOO.h
==================================================================
--- generic/tclOO.h
+++ generic/tclOO.h
@@ -58,16 +58,16 @@
  * Public datatypes for callbacks and structures used in the TIP#257 (OO)
  * implementation. These are used to implement custom types of method calls
  * and to allow the attachment of arbitrary data to objects and classes.
  */
 
-typedef int (Tcl_MethodCallProc)(void *clientData, Tcl_Interp *interp,
+typedef int (Tcl_MethodCallProc)(ClientData clientData, Tcl_Interp *interp,
 	Tcl_ObjectContext objectContext, int objc, Tcl_Obj *const *objv);
-typedef void (Tcl_MethodDeleteProc)(void *clientData);
-typedef int (Tcl_CloneProc)(Tcl_Interp *interp, void *oldClientData,
-	void **newClientData);
-typedef void (Tcl_ObjectMetadataDeleteProc)(void *clientData);
+typedef void (Tcl_MethodDeleteProc)(ClientData clientData);
+typedef int (Tcl_CloneProc)(Tcl_Interp *interp, ClientData oldClientData,
+	ClientData *newClientData);
+typedef void (Tcl_ObjectMetadataDeleteProc)(ClientData clientData);
 typedef int (Tcl_ObjectMapMethodNameProc)(Tcl_Interp *interp,
 	Tcl_Object object, Tcl_Class *startClsPtr, Tcl_Obj *methodNameObj);
 
 /*
  * The type of a method implementation. This describes how to call the method
@@ -93,11 +93,11 @@
 } Tcl_MethodType;
 
 /*
  * The correct value for the version field of the Tcl_MethodType structure.
  * This allows new versions of the structure to be introduced without breaking
- * binary compatibility.
+ * binary compatability.
  */
 
 #define TCL_OO_METHOD_VERSION_CURRENT 1
 
 /*
@@ -129,11 +129,11 @@
 } Tcl_ObjectMetadataType;
 
 /*
  * The correct value for the version field of the Tcl_ObjectMetadataType
  * structure. This allows new versions of the structure to be introduced
- * without breaking binary compatibility.
+ * without breaking binary compatability.
  */
 
 #define TCL_OO_METADATA_VERSION_CURRENT 1
 
 /*

Index: generic/tclOOBasic.c
==================================================================
--- generic/tclOOBasic.c
+++ generic/tclOOBasic.c
@@ -106,11 +106,11 @@
 
     /*
      * Delegate to [oo::define] to do the work.
      */
 
-    invoke = Tcl_Alloc(3 * sizeof(Tcl_Obj *));
+    invoke = ckalloc(3 * sizeof(Tcl_Obj *));
     invoke[0] = oPtr->fPtr->defineName;
     invoke[1] = TclOOObjectName(interp, oPtr);
     invoke[2] = objv[objc-1];
 
     /*
@@ -152,11 +152,11 @@
     Tcl_IncrRefCount(invoke[1]);
     saved = Tcl_SaveInterpState(interp, result);
     code = Tcl_EvalObjv(interp, 2, invoke, 0);
     TclDecrRefCount(invoke[0]);
     TclDecrRefCount(invoke[1]);
-    Tcl_Free(invoke);
+    ckfree(invoke);
     if (code != TCL_OK) {
 	Tcl_DiscardInterpState(saved);
 	return code;
     }
     return Tcl_RestoreInterpState(interp, saved);
@@ -181,11 +181,11 @@
     int objc,			/* Number of arguments. */
     Tcl_Obj *const *objv)	/* The actual arguments. */
 {
     Object *oPtr = (Object *) Tcl_ObjectContextObject(context);
     const char *objName;
-    size_t len;
+    int len;
 
     /*
      * Sanity check; should not be possible to invoke this method on a
      * non-class.
      */
@@ -206,11 +206,11 @@
     if (objc - Tcl_ObjectContextSkippedArgs(context) < 1) {
 	Tcl_WrongNumArgs(interp, Tcl_ObjectContextSkippedArgs(context), objv,
 		"objectName ?arg ...?");
 	return TCL_ERROR;
     }
-    objName = TclGetStringFromObj(
+    objName = Tcl_GetStringFromObj(
 	    objv[Tcl_ObjectContextSkippedArgs(context)], &len);
     if (len == 0) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"object name must not be empty", -1));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "EMPTY_NAME", NULL);
@@ -246,11 +246,11 @@
     int objc,			/* Number of arguments. */
     Tcl_Obj *const *objv)	/* The actual arguments. */
 {
     Object *oPtr = (Object *) Tcl_ObjectContextObject(context);
     const char *objName, *nsName;
-    size_t len;
+    int len;
 
     /*
      * Sanity check; should not be possible to invoke this method on a
      * non-class.
      */
@@ -271,19 +271,19 @@
     if (objc - Tcl_ObjectContextSkippedArgs(context) < 2) {
 	Tcl_WrongNumArgs(interp, Tcl_ObjectContextSkippedArgs(context), objv,
 		"objectName namespaceName ?arg ...?");
 	return TCL_ERROR;
     }
-    objName = TclGetStringFromObj(
+    objName = Tcl_GetStringFromObj(
 	    objv[Tcl_ObjectContextSkippedArgs(context)], &len);
     if (len == 0) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"object name must not be empty", -1));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "EMPTY_NAME", NULL);
 	return TCL_ERROR;
     }
-    nsName = TclGetStringFromObj(
+    nsName = Tcl_GetStringFromObj(
 	    objv[Tcl_ObjectContextSkippedArgs(context)+1], &len);
     if (len == 0) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"namespace name must not be empty", -1));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "EMPTY_NAME", NULL);
@@ -424,11 +424,11 @@
     int objc,			/* Number of arguments. */
     Tcl_Obj *const *objv)	/* The actual arguments. */
 {
     CallContext *contextPtr = (CallContext *) context;
     Tcl_Object object = Tcl_ObjectContextObject(context);
-    register const int skip = Tcl_ObjectContextSkippedArgs(context);
+    const int skip = Tcl_ObjectContextSkippedArgs(context);
     CallFrame *framePtr, **framePtrPtr = &framePtr;
     Tcl_Obj *scriptPtr;
     CmdFrame *invoker;
 
     if (objc-1 < skip) {
@@ -603,11 +603,11 @@
     }
     if (i) {
 	Tcl_AppendToObj(errorMsg, " or ", -1);
     }
     Tcl_AppendToObj(errorMsg, methodNames[i], -1);
-    Tcl_Free((void *)methodNames);
+    ckfree(methodNames);
     Tcl_SetObjResult(interp, errorMsg);
     Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "METHOD",
 	    TclGetString(objv[skip]), NULL);
     return TCL_ERROR;
 }
@@ -742,11 +742,11 @@
 	Tcl_WrongNumArgs(interp, Tcl_ObjectContextSkippedArgs(context), objv,
 		"varName");
 	return TCL_ERROR;
     }
     argPtr = objv[objc-1];
-    arg = TclGetString(argPtr);
+    arg = Tcl_GetString(argPtr);
 
     /*
      * Convert the variable name to fully-qualified form if it wasn't already.
      * This has to be done prior to lookup because we can run into problems
      * with resolvers otherwise. [Bug 3603695]
@@ -779,12 +779,12 @@
 	    PrivateVariableMapping *pvPtr;
 	    int i;
 
 	    if (mPtr->declaringObjectPtr == oPtr) {
 		FOREACH_STRUCT(pvPtr, oPtr->privateVariables) {
-		    if (!strcmp(TclGetString(pvPtr->variableObj),
-			    TclGetString(argPtr))) {
+		    if (!strcmp(Tcl_GetString(pvPtr->variableObj),
+			    Tcl_GetString(argPtr))) {
 			argPtr = pvPtr->fullNameObj;
 			break;
 		    }
 		}
 	    } else if (mPtr->declaringClassPtr &&
@@ -801,12 +801,12 @@
 			}
 		    }
 		}
 		if (isInstance) {
 		    FOREACH_STRUCT(pvPtr, clsPtr->privateVariables) {
-			if (!strcmp(TclGetString(pvPtr->variableObj),
-				TclGetString(argPtr))) {
+			if (!strcmp(Tcl_GetString(pvPtr->variableObj),
+				Tcl_GetString(argPtr))) {
 			    argPtr = pvPtr->fullNameObj;
 			    break;
 			}
 		    }
 		}
@@ -1120,11 +1120,11 @@
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "not inside a filtering context", -1));
 	    Tcl_SetErrorCode(interp, "TCL", "OO", "UNMATCHED_CONTEXT", NULL);
 	    return TCL_ERROR;
 	} else {
-	    register struct MInvoke *miPtr = &CurrentlyInvoked(contextPtr);
+	    struct MInvoke *miPtr = &CurrentlyInvoked(contextPtr);
 	    Object *oPtr;
 	    const char *type;
 
 	    if (miPtr->filterDeclarer != NULL) {
 		oPtr = miPtr->filterDeclarer->thisPtr;

Index: generic/tclOOCall.c
==================================================================
--- generic/tclOOCall.c
+++ generic/tclOOCall.c
@@ -166,11 +166,11 @@
 
 void
 TclOODeleteContext(
     CallContext *contextPtr)
 {
-    register Object *oPtr = contextPtr->oPtr;
+    Object *oPtr = contextPtr->oPtr;
 
     TclOODeleteChain(contextPtr->callPtr);
     if (oPtr != NULL) {
 	TclStackFree(oPtr->fPtr->interp, contextPtr);
 
@@ -203,11 +203,11 @@
 	if (callPtr) {
 	    TclOODeleteChain(callPtr);
 	}
     }
     Tcl_DeleteHashTable(tablePtr);
-    Tcl_Free(tablePtr);
+    ckfree(tablePtr);
 }
 
 /*
  * ----------------------------------------------------------------------
  *
@@ -224,13 +224,13 @@
 {
     if (callPtr == NULL || callPtr->refCount-- > 1) {
 	return;
     }
     if (callPtr->chain != callPtr->staticChain) {
-	Tcl_Free(callPtr->chain);
+	ckfree(callPtr->chain);
     }
-    Tcl_Free(callPtr);
+    ckfree(callPtr);
 }
 
 /*
  * ----------------------------------------------------------------------
  *
@@ -312,11 +312,11 @@
 				 * commands, variables) depending on method
 				 * implementation. */
     int objc,			/* The number of arguments. */
     Tcl_Obj *const objv[])	/* The arguments as actually seen. */
 {
-    register CallContext *const contextPtr = clientData;
+    CallContext *const contextPtr = clientData;
     Method *const mPtr = contextPtr->callPtr->chain[contextPtr->index].mPtr;
     const int isFilter =
 	    contextPtr->callPtr->chain[contextPtr->index].isFilter;
 
     /*
@@ -587,17 +587,17 @@
 				 * circumstances. */
     int flags,			/* Whether we are looking for unexported
 				 * methods. Full private methods are handled
 				 * on insertion to the table. */
     const char ***stringsPtr)	/* Where to store the sorted list of strings
-				 * that we produce. Tcl_Alloced() */
+				 * that we produce. ckalloced() */
 {
     const char **strings;
     FOREACH_HASH_DECLS;
     Tcl_Obj *namePtr;
     void *isWanted;
-    size_t i = 0;
+    int i = 0;
 
     /*
      * See how many (visible) method names there are. If none, we do not (and
      * should not) try to sort the list of them.
      */
@@ -611,11 +611,11 @@
      * We need to build the list of methods to sort. We will be using qsort()
      * for this, because it is very unlikely that the list will be heavily
      * sorted when it is long enough to matter.
      */
 
-    strings = Tcl_Alloc(sizeof(char *) * namesPtr->numEntries);
+    strings = ckalloc(sizeof(char *) * namesPtr->numEntries);
     FOREACH_HASH(namePtr, isWanted, namesPtr) {
 	if (!WANT_PUBLIC(flags) || (PTR2INT(isWanted) & IN_LIST)) {
 	    if (PTR2INT(isWanted) & NO_IMPLEMENTATION) {
 		continue;
 	    }
@@ -633,11 +633,11 @@
 	if (i > 1) {
 	    qsort((void *) strings, i, sizeof(char *), CmpStr);
 	}
 	*stringsPtr = strings;
     } else {
-	Tcl_Free((void *)strings);
+	ckfree(strings);
 	*stringsPtr = NULL;
     }
     return i;
 }
 
@@ -966,11 +966,11 @@
 				 * we're looking to add things from a mixin
 				 * and we have passed a mixin, or we're not
 				 * looking to add things from a mixin and have
 				 * not passed a mixin. */
 {
-    register CallChain *callPtr = cbPtr->callChainPtr;
+    CallChain *callPtr = cbPtr->callChainPtr;
     int i;
 
     /*
      * Return if this is just an entry used to record whether this is a public
      * method. If so, there's nothing real to call and so nothing to add to
@@ -1035,15 +1035,15 @@
      * realloc-ing if the chain gets long.
      */
 
     if (callPtr->numChain == CALL_CHAIN_STATIC_SIZE) {
 	callPtr->chain =
-		Tcl_Alloc(sizeof(struct MInvoke) * (callPtr->numChain + 1));
+		ckalloc(sizeof(struct MInvoke) * (callPtr->numChain + 1));
 	memcpy(callPtr->chain, callPtr->staticChain,
 		sizeof(struct MInvoke) * callPtr->numChain);
     } else if (callPtr->numChain > CALL_CHAIN_STATIC_SIZE) {
-	callPtr->chain = Tcl_Realloc(callPtr->chain,
+	callPtr->chain = ckrealloc(callPtr->chain,
 		sizeof(struct MInvoke) * (callPtr->numChain + 1));
     }
     callPtr->chain[i].mPtr = mPtr;
     callPtr->chain[i].isFilter = (doneFilters != NULL);
     callPtr->chain[i].filterDeclarer = filterDecl;
@@ -1228,11 +1228,11 @@
 	}
 
 	doFilters = 1;
     }
 
-    callPtr = Tcl_Alloc(sizeof(CallChain));
+    callPtr = ckalloc(sizeof(CallChain));
     InitCallChain(callPtr, oPtr, flags);
 
     cb.callChainPtr = callPtr;
     cb.filterLength = 0;
     cb.oPtr = oPtr;
@@ -1246,11 +1246,11 @@
 		oPtr->fPtr->unknownMethodNameObj, &cb, NULL, BUILDING_MIXINS,
 		NULL);
 	AddSimpleChainToCallContext(oPtr, NULL,
 		oPtr->fPtr->unknownMethodNameObj, &cb, NULL, 0, NULL);
 	callPtr->flags |= OO_UNKNOWN_METHOD;
-	callPtr->epoch = 0;
+	callPtr->epoch = -1;
 	if (callPtr->numChain == 0) {
 	    TclOODeleteChain(callPtr);
 	    return NULL;
 	}
 	goto returnContext;
@@ -1323,29 +1323,29 @@
 		oPtr->fPtr->unknownMethodNameObj, &cb, NULL, BUILDING_MIXINS,
 		NULL);
 	AddSimpleChainToCallContext(oPtr, NULL,
 		oPtr->fPtr->unknownMethodNameObj, &cb, NULL, 0, NULL);
 	callPtr->flags |= OO_UNKNOWN_METHOD;
-	callPtr->epoch = 0;
+	callPtr->epoch = -1;
 	if (count == callPtr->numChain) {
 	    TclOODeleteChain(callPtr);
 	    return NULL;
 	}
     } else if (doFilters && !donePrivate) {
 	if (hPtr == NULL) {
 	    if (oPtr->flags & USE_CLASS_CACHE) {
 		if (oPtr->selfCls->classChainCache == NULL) {
 		    oPtr->selfCls->classChainCache =
-			    Tcl_Alloc(sizeof(Tcl_HashTable));
+			    ckalloc(sizeof(Tcl_HashTable));
 
 		    Tcl_InitObjHashTable(oPtr->selfCls->classChainCache);
 		}
 		hPtr = Tcl_CreateHashEntry(oPtr->selfCls->classChainCache,
 			(char *) methodNameObj, &i);
 	    } else {
 		if (oPtr->chainCache == NULL) {
-		    oPtr->chainCache = Tcl_Alloc(sizeof(Tcl_HashTable));
+		    oPtr->chainCache = ckalloc(sizeof(Tcl_HashTable));
 
 		    Tcl_InitObjHashTable(oPtr->chainCache);
 		}
 		hPtr = Tcl_CreateHashEntry(oPtr->chainCache,
 			(char *) methodNameObj, &i);
@@ -1448,11 +1448,11 @@
 	}
     } else {
 	hPtr = NULL;
     }
 
-    callPtr = Tcl_Alloc(sizeof(CallChain));
+    callPtr = ckalloc(sizeof(CallChain));
     memset(callPtr, 0, sizeof(CallChain));
     callPtr->flags = flags & (PUBLIC_METHOD|PRIVATE_METHOD|FILTER_HANDLING);
     callPtr->epoch = fPtr->epoch;
     callPtr->objectCreationEpoch = fPtr->tsdPtr->nsCount;
     callPtr->objectEpoch = clsPtr->thisPtr->epoch;
@@ -1495,19 +1495,19 @@
 	AddSimpleChainToCallContext(&obj, NULL, fPtr->unknownMethodNameObj,
 		&cb, NULL, BUILDING_MIXINS, NULL);
 	AddSimpleChainToCallContext(&obj, NULL, fPtr->unknownMethodNameObj,
 		&cb, NULL, 0, NULL);
 	callPtr->flags |= OO_UNKNOWN_METHOD;
-	callPtr->epoch = 0;
+	callPtr->epoch = -1;
 	if (count == callPtr->numChain) {
 	    TclOODeleteChain(callPtr);
 	    return NULL;
 	}
     } else {
 	if (hPtr == NULL) {
 	    if (clsPtr->classChainCache == NULL) {
-		clsPtr->classChainCache = Tcl_Alloc(sizeof(Tcl_HashTable));
+		clsPtr->classChainCache = ckalloc(sizeof(Tcl_HashTable));
 		Tcl_InitObjHashTable(clsPtr->classChainCache);
 	    }
 	    hPtr = Tcl_CreateHashEntry(clsPtr->classChainCache,
 		    (char *) methodNameObj, &i);
 	}
@@ -1654,11 +1654,11 @@
     if (classPtr == contextCls) {
 	Tcl_HashEntry *hPtr = Tcl_FindHashEntry(&classPtr->classMethods,
 		(char *) methodName);
 
 	if (hPtr != NULL) {
-	    register Method *mPtr = Tcl_GetHashValue(hPtr);
+	    Method *mPtr = Tcl_GetHashValue(hPtr);
 
 	    if (IS_PRIVATE(mPtr)) {
 		AddMethodToCallChain(mPtr, cbPtr, doneFilters, filterDecl,
 			flags);
 		return 1;
@@ -1738,11 +1738,11 @@
 
 	if (classPtr->flags & HAS_PRIVATE_METHODS) {
 	    privateDanger |= 1;
 	}
 	if (hPtr != NULL) {
-	    register Method *mPtr = Tcl_GetHashValue(hPtr);
+	    Method *mPtr = Tcl_GetHashValue(hPtr);
 
 	    if (!IS_PRIVATE(mPtr)) {
 		if (!(flags & KNOWN_STATE)) {
 		    if (flags & PUBLIC_METHOD) {
 			if (!IS_PUBLIC(mPtr)) {
@@ -1920,11 +1920,11 @@
 	    break;
 	}
 	Tcl_ResetResult(interp);
     }
     if (define.list != staticSpace) {
-	Tcl_Free(define.list);
+	ckfree(define.list);
     }
     return nsPtr;
 }
 
 /*
@@ -2085,15 +2085,15 @@
 	definePtr->size *= 2;
 	if (definePtr->num == DEFINE_CHAIN_STATIC_SIZE) {
 	    DefineEntry *staticList = definePtr->list;
 
 	    definePtr->list =
-		    Tcl_Alloc(sizeof(DefineEntry) * definePtr->size);
+		    ckalloc(sizeof(DefineEntry) * definePtr->size);
 	    memcpy(definePtr->list, staticList,
 		    sizeof(DefineEntry) * definePtr->num);
 	} else {
-	    definePtr->list = Tcl_Realloc(definePtr->list,
+	    definePtr->list = ckrealloc(definePtr->list,
 		    sizeof(DefineEntry) * definePtr->size);
 	}
     }
     definePtr->list[i].definerCls = definerCls;
     definePtr->list[i].namespaceName = namespaceName;

Index: generic/tclOODecls.h
==================================================================
--- generic/tclOODecls.h
+++ generic/tclOODecls.h
@@ -51,23 +51,23 @@
 /* 8 */
 TCLAPI int		Tcl_MethodIsPublic(Tcl_Method method);
 /* 9 */
 TCLAPI int		Tcl_MethodIsType(Tcl_Method method,
 				const Tcl_MethodType *typePtr,
-				void **clientDataPtr);
+				ClientData *clientDataPtr);
 /* 10 */
 TCLAPI Tcl_Obj *	Tcl_MethodName(Tcl_Method method);
 /* 11 */
 TCLAPI Tcl_Method	Tcl_NewInstanceMethod(Tcl_Interp *interp,
 				Tcl_Object object, Tcl_Obj *nameObj,
 				int flags, const Tcl_MethodType *typePtr,
-				void *clientData);
+				ClientData clientData);
 /* 12 */
 TCLAPI Tcl_Method	Tcl_NewMethod(Tcl_Interp *interp, Tcl_Class cls,
 				Tcl_Obj *nameObj, int flags,
 				const Tcl_MethodType *typePtr,
-				void *clientData);
+				ClientData clientData);
 /* 13 */
 TCLAPI Tcl_Object	Tcl_NewObjectInstance(Tcl_Interp *interp,
 				Tcl_Class cls, const char *nameStr,
 				const char *nsNameStr, int objc,
 				Tcl_Obj *const *objv, int skip);
@@ -82,23 +82,23 @@
 TCLAPI Tcl_Object	Tcl_ObjectContextObject(Tcl_ObjectContext context);
 /* 18 */
 TCLAPI int		Tcl_ObjectContextSkippedArgs(
 				Tcl_ObjectContext context);
 /* 19 */
-TCLAPI void *		Tcl_ClassGetMetadata(Tcl_Class clazz,
+TCLAPI ClientData	Tcl_ClassGetMetadata(Tcl_Class clazz,
 				const Tcl_ObjectMetadataType *typePtr);
 /* 20 */
 TCLAPI void		Tcl_ClassSetMetadata(Tcl_Class clazz,
 				const Tcl_ObjectMetadataType *typePtr,
-				void *metadata);
+				ClientData metadata);
 /* 21 */
-TCLAPI void *		Tcl_ObjectGetMetadata(Tcl_Object object,
+TCLAPI ClientData	Tcl_ObjectGetMetadata(Tcl_Object object,
 				const Tcl_ObjectMetadataType *typePtr);
 /* 22 */
 TCLAPI void		Tcl_ObjectSetMetadata(Tcl_Object object,
 				const Tcl_ObjectMetadataType *typePtr,
-				void *metadata);
+				ClientData metadata);
 /* 23 */
 TCLAPI int		Tcl_ObjectContextInvokeNext(Tcl_Interp *interp,
 				Tcl_ObjectContext context, int objc,
 				Tcl_Obj *const *objv, int skip);
 /* 24 */
@@ -134,24 +134,24 @@
     Tcl_Object (*tcl_GetObjectFromObj) (Tcl_Interp *interp, Tcl_Obj *objPtr); /* 4 */
     Tcl_Namespace * (*tcl_GetObjectNamespace) (Tcl_Object object); /* 5 */
     Tcl_Class (*tcl_MethodDeclarerClass) (Tcl_Method method); /* 6 */
     Tcl_Object (*tcl_MethodDeclarerObject) (Tcl_Method method); /* 7 */
     int (*tcl_MethodIsPublic) (Tcl_Method method); /* 8 */
-    int (*tcl_MethodIsType) (Tcl_Method method, const Tcl_MethodType *typePtr, void **clientDataPtr); /* 9 */
+    int (*tcl_MethodIsType) (Tcl_Method method, const Tcl_MethodType *typePtr, ClientData *clientDataPtr); /* 9 */
     Tcl_Obj * (*tcl_MethodName) (Tcl_Method method); /* 10 */
-    Tcl_Method (*tcl_NewInstanceMethod) (Tcl_Interp *interp, Tcl_Object object, Tcl_Obj *nameObj, int flags, const Tcl_MethodType *typePtr, void *clientData); /* 11 */
-    Tcl_Method (*tcl_NewMethod) (Tcl_Interp *interp, Tcl_Class cls, Tcl_Obj *nameObj, int flags, const Tcl_MethodType *typePtr, void *clientData); /* 12 */
+    Tcl_Method (*tcl_NewInstanceMethod) (Tcl_Interp *interp, Tcl_Object object, Tcl_Obj *nameObj, int flags, const Tcl_MethodType *typePtr, ClientData clientData); /* 11 */
+    Tcl_Method (*tcl_NewMethod) (Tcl_Interp *interp, Tcl_Class cls, Tcl_Obj *nameObj, int flags, const Tcl_MethodType *typePtr, ClientData clientData); /* 12 */
     Tcl_Object (*tcl_NewObjectInstance) (Tcl_Interp *interp, Tcl_Class cls, const char *nameStr, const char *nsNameStr, int objc, Tcl_Obj *const *objv, int skip); /* 13 */
     int (*tcl_ObjectDeleted) (Tcl_Object object); /* 14 */
     int (*tcl_ObjectContextIsFiltering) (Tcl_ObjectContext context); /* 15 */
     Tcl_Method (*tcl_ObjectContextMethod) (Tcl_ObjectContext context); /* 16 */
     Tcl_Object (*tcl_ObjectContextObject) (Tcl_ObjectContext context); /* 17 */
     int (*tcl_ObjectContextSkippedArgs) (Tcl_ObjectContext context); /* 18 */
-    void * (*tcl_ClassGetMetadata) (Tcl_Class clazz, const Tcl_ObjectMetadataType *typePtr); /* 19 */
-    void (*tcl_ClassSetMetadata) (Tcl_Class clazz, const Tcl_ObjectMetadataType *typePtr, void *metadata); /* 20 */
-    void * (*tcl_ObjectGetMetadata) (Tcl_Object object, const Tcl_ObjectMetadataType *typePtr); /* 21 */
-    void (*tcl_ObjectSetMetadata) (Tcl_Object object, const Tcl_ObjectMetadataType *typePtr, void *metadata); /* 22 */
+    ClientData (*tcl_ClassGetMetadata) (Tcl_Class clazz, const Tcl_ObjectMetadataType *typePtr); /* 19 */
+    void (*tcl_ClassSetMetadata) (Tcl_Class clazz, const Tcl_ObjectMetadataType *typePtr, ClientData metadata); /* 20 */
+    ClientData (*tcl_ObjectGetMetadata) (Tcl_Object object, const Tcl_ObjectMetadataType *typePtr); /* 21 */
+    void (*tcl_ObjectSetMetadata) (Tcl_Object object, const Tcl_ObjectMetadataType *typePtr, ClientData metadata); /* 22 */
     int (*tcl_ObjectContextInvokeNext) (Tcl_Interp *interp, Tcl_ObjectContext context, int objc, Tcl_Obj *const *objv, int skip); /* 23 */
     Tcl_ObjectMapMethodNameProc * (*tcl_ObjectGetMethodNameMapper) (Tcl_Object object); /* 24 */
     void (*tcl_ObjectSetMethodNameMapper) (Tcl_Object object, Tcl_ObjectMapMethodNameProc *mapMethodNameProc); /* 25 */
     void (*tcl_ClassSetConstructor) (Tcl_Interp *interp, Tcl_Class clazz, Tcl_Method method); /* 26 */
     void (*tcl_ClassSetDestructor) (Tcl_Interp *interp, Tcl_Class clazz, Tcl_Method method); /* 27 */

Index: generic/tclOODefineCmds.c
==================================================================
--- generic/tclOODefineCmds.c
+++ generic/tclOODefineCmds.c
@@ -265,11 +265,11 @@
     if (numFilters == 0) {
 	/*
 	 * No list of filters was supplied, so we're deleting filters.
 	 */
 
-	Tcl_Free(oPtr->filters.list);
+	ckfree(oPtr->filters.list);
 	oPtr->filters.list = NULL;
 	oPtr->filters.num = 0;
 	RecomputeClassCacheFlag(oPtr);
     } else {
 	/*
@@ -278,13 +278,13 @@
 
 	Tcl_Obj **filtersList;
 	int size = sizeof(Tcl_Obj *) * numFilters;	/* should be size_t */
 
 	if (oPtr->filters.num == 0) {
-	    filtersList = Tcl_Alloc(size);
+	    filtersList = ckalloc(size);
 	} else {
-	    filtersList = Tcl_Realloc(oPtr->filters.list, size);
+	    filtersList = ckrealloc(oPtr->filters.list, size);
 	}
 	for (i = 0 ; i < numFilters ; i++) {
 	    filtersList[i] = filters[i];
 	    Tcl_IncrRefCount(filters[i]);
 	}
@@ -325,11 +325,11 @@
     if (numFilters == 0) {
 	/*
 	 * No list of filters was supplied, so we're deleting filters.
 	 */
 
-	Tcl_Free(classPtr->filters.list);
+	ckfree(classPtr->filters.list);
 	classPtr->filters.list = NULL;
 	classPtr->filters.num = 0;
     } else {
 	/*
 	 * We've got a list of filters, so we're creating filters.
@@ -337,13 +337,13 @@
 
 	Tcl_Obj **filtersList;
 	int size = sizeof(Tcl_Obj *) * numFilters;	/* should be size_t */
 
 	if (classPtr->filters.num == 0) {
-	    filtersList = Tcl_Alloc(size);
+	    filtersList = ckalloc(size);
 	} else {
-	    filtersList = Tcl_Realloc(classPtr->filters.list, size);
+	    filtersList = ckrealloc(classPtr->filters.list, size);
 	}
 	for (i = 0 ; i < numFilters ; i++) {
 	    filtersList[i] = filters[i];
 	    Tcl_IncrRefCount(filters[i]);
 	}
@@ -381,11 +381,11 @@
 	if (oPtr->mixins.num != 0) {
 	    FOREACH(mixinPtr, oPtr->mixins) {
 		TclOORemoveFromInstances(oPtr, mixinPtr);
 		TclOODecrRefCount(mixinPtr->thisPtr);
 	    }
-	    Tcl_Free(oPtr->mixins.list);
+	    ckfree(oPtr->mixins.list);
 	    oPtr->mixins.num = 0;
 	}
 	RecomputeClassCacheFlag(oPtr);
     } else {
 	if (oPtr->mixins.num != 0) {
@@ -393,14 +393,14 @@
 		if (mixinPtr && mixinPtr != oPtr->selfCls) {
 		    TclOORemoveFromInstances(oPtr, mixinPtr);
 		}
 		TclOODecrRefCount(mixinPtr->thisPtr);
 	    }
-	    oPtr->mixins.list = Tcl_Realloc(oPtr->mixins.list,
+	    oPtr->mixins.list = ckrealloc(oPtr->mixins.list,
 		    sizeof(Class *) * numMixins);
 	} else {
-	    oPtr->mixins.list = Tcl_Alloc(sizeof(Class *) * numMixins);
+	    oPtr->mixins.list = ckalloc(sizeof(Class *) * numMixins);
 	    oPtr->flags &= ~USE_CLASS_CACHE;
 	}
 	oPtr->mixins.num = numMixins;
 	memcpy(oPtr->mixins.list, mixins, sizeof(Class *) * numMixins);
 	FOREACH(mixinPtr, oPtr->mixins) {
@@ -442,23 +442,23 @@
 	if (classPtr->mixins.num != 0) {
 	    FOREACH(mixinPtr, classPtr->mixins) {
 		TclOORemoveFromMixinSubs(classPtr, mixinPtr);
 		TclOODecrRefCount(mixinPtr->thisPtr);
 	    }
-	    Tcl_Free(classPtr->mixins.list);
+	    ckfree(classPtr->mixins.list);
 	    classPtr->mixins.num = 0;
 	}
     } else {
 	if (classPtr->mixins.num != 0) {
 	    FOREACH(mixinPtr, classPtr->mixins) {
 		TclOORemoveFromMixinSubs(classPtr, mixinPtr);
 		TclOODecrRefCount(mixinPtr->thisPtr);
 	    }
-	    classPtr->mixins.list = Tcl_Realloc(classPtr->mixins.list,
+	    classPtr->mixins.list = ckrealloc(classPtr->mixins.list,
 		    sizeof(Class *) * numMixins);
 	} else {
-	    classPtr->mixins.list = Tcl_Alloc(sizeof(Class *) * numMixins);
+	    classPtr->mixins.list = ckalloc(sizeof(Class *) * numMixins);
 	}
 	classPtr->mixins.num = numMixins;
 	memcpy(classPtr->mixins.list, mixins, sizeof(Class *) * numMixins);
 	FOREACH(mixinPtr, classPtr->mixins) {
 	    TclOOAddToMixinSubs(classPtr, mixinPtr);
@@ -498,15 +498,15 @@
     FOREACH(variableObj, *vnlPtr) {
 	Tcl_DecrRefCount(variableObj);
     }
     if (i != varc) {
 	if (varc == 0) {
-	    Tcl_Free(vnlPtr->list);
+	    ckfree(vnlPtr->list);
 	} else if (i) {
-	    vnlPtr->list = Tcl_Realloc(vnlPtr->list, sizeof(Tcl_Obj *) * varc);
+	    vnlPtr->list = ckrealloc(vnlPtr->list, sizeof(Tcl_Obj *) * varc);
 	} else {
-	    vnlPtr->list = Tcl_Alloc(sizeof(Tcl_Obj *) * varc);
+	    vnlPtr->list = ckalloc(sizeof(Tcl_Obj *) * varc);
 	}
     }
     vnlPtr->num = 0;
     if (varc > 0) {
 	Tcl_InitObjHashTable(&uniqueTable);
@@ -523,11 +523,11 @@
 	/*
 	 * Shouldn't be necessary, but maintain num/list invariant.
 	 */
 
 	if (n != varc) {
-	    vnlPtr->list = Tcl_Realloc(vnlPtr->list, sizeof(Tcl_Obj *) * n);
+	    vnlPtr->list = ckrealloc(vnlPtr->list, sizeof(Tcl_Obj *) * n);
 	}
 	Tcl_DeleteHashTable(&uniqueTable);
     }
 }
 
@@ -549,16 +549,16 @@
 	Tcl_DecrRefCount(privatePtr->variableObj);
 	Tcl_DecrRefCount(privatePtr->fullNameObj);
     }
     if (i != varc) {
 	if (varc == 0) {
-	    Tcl_Free(pvlPtr->list);
+	    ckfree(pvlPtr->list);
 	} else if (i) {
-	    pvlPtr->list = Tcl_Realloc(pvlPtr->list,
+	    pvlPtr->list = ckrealloc(pvlPtr->list,
 		    sizeof(PrivateVariableMapping) * varc);
 	} else {
-	    pvlPtr->list = Tcl_Alloc(sizeof(PrivateVariableMapping) * varc);
+	    pvlPtr->list = ckalloc(sizeof(PrivateVariableMapping) * varc);
 	}
     }
 
     pvlPtr->num = 0;
     if (varc > 0) {
@@ -568,11 +568,11 @@
 	    if (created) {
 		privatePtr = &(pvlPtr->list[n++]);
 		privatePtr->variableObj = varv[i];
 		privatePtr->fullNameObj = Tcl_ObjPrintf(
 			PRIVATE_VARIABLE_PATTERN,
-			creationEpoch, TclGetString(varv[i]));
+			creationEpoch, Tcl_GetString(varv[i]));
 		Tcl_IncrRefCount(privatePtr->fullNameObj);
 	    } else {
 		Tcl_DecrRefCount(varv[i]);
 	    }
 	}
@@ -581,11 +581,11 @@
 	/*
 	 * Shouldn't be necessary, but maintain num/list invariant.
 	 */
 
 	if (n != varc) {
-	    pvlPtr->list = Tcl_Realloc(pvlPtr->list,
+	    pvlPtr->list = ckrealloc(pvlPtr->list,
 		    sizeof(PrivateVariableMapping) * n);
 	}
 	Tcl_DeleteHashTable(&uniqueTable);
     }
 }
@@ -701,11 +701,11 @@
     Tcl_Obj *const *objv)
 {
     Namespace *nsPtr = (Namespace *) Tcl_GetCurrentNamespace(interp);
     Tcl_HashSearch search;
     Tcl_HashEntry *hPtr;
-    size_t soughtLen;
+    int soughtLen;
     const char *soughtStr, *matchedStr = NULL;
 
     if (objc < 2) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"bad call of unknown handler", -1));
@@ -775,13 +775,13 @@
 FindCommand(
     Tcl_Interp *interp,
     Tcl_Obj *stringObj,
     Tcl_Namespace *const namespacePtr)
 {
-    size_t length;
+    int length;
     const char *nameStr, *string = TclGetStringFromObj(stringObj, &length);
-    register Namespace *const nsPtr = (Namespace *) namespacePtr;
+    Namespace *const nsPtr = (Namespace *) namespacePtr;
     FOREACH_HASH_DECLS;
     Tcl_Command cmd, cmd2;
 
     /*
      * If someone is playing games, we stop playing right now.
@@ -994,20 +994,20 @@
 				 * could have been renamed... */
     const char *typeOfSubject)	/* Part of the message, saying whether it was
 				 * an object, class or class-as-object that
 				 * was being configured. */
 {
-    size_t length;
+    int length;
     Tcl_Obj *realNameObj = Tcl_ObjectDeleted((Tcl_Object) oPtr)
 	    ? savedNameObj : TclOOObjectName(interp, oPtr);
     const char *objName = TclGetStringFromObj(realNameObj, &length);
-    unsigned limit = OBJNAME_LENGTH_IN_ERRORINFO_LIMIT;
+    int limit = OBJNAME_LENGTH_IN_ERRORINFO_LIMIT;
     int overflow = (length > limit);
 
     Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 	    "\n    (in definition script for %s \"%.*s%s\" line %d)",
-	    typeOfSubject, (overflow ? limit : (unsigned)length), objName,
+	    typeOfSubject, (overflow ? limit : length), objName,
 	    (overflow ? "..." : ""), Tcl_GetErrorLine(interp)));
 }
 
 /*
  * ----------------------------------------------------------------------
@@ -1242,11 +1242,11 @@
     int objc,
     Tcl_Obj *const *objv)
 {
     Tcl_Namespace *nsPtr;
     Object *oPtr;
-    int result, private;
+    int result, isPrivate;
 
     oPtr = (Object *) TclOOGetDefineCmdContext(interp);
     if (oPtr == NULL) {
 	return TCL_ERROR;
     }
@@ -1254,11 +1254,11 @@
     if (objc < 2) {
 	Tcl_SetObjResult(interp, TclOOObjectName(interp, oPtr));
 	return TCL_OK;
     }
 
-    private = IsPrivateDefine(interp);
+    isPrivate = IsPrivateDefine(interp);
 
     /*
      * Make the oo::objdefine namespace the current namespace and evaluate the
      * command(s).
      */
@@ -1265,11 +1265,11 @@
 
     nsPtr = TclOOGetDefineContextNamespace(interp, oPtr, 0);
     if (InitDefineContext(interp, nsPtr, oPtr, objc, objv) != TCL_OK) {
 	return TCL_ERROR;
     }
-    if (private) {
+    if (isPrivate) {
 	((Interp *) interp)->varFramePtr->isProcCallFrame = PRIVATE_FRAME;
     }
 
     AddRef(oPtr);
     if (objc == 2) {
@@ -1494,12 +1494,12 @@
 	    oPtr->fPtr->epoch++;
 	    oPtr->flags |= DONT_DELETE;
 	    TclOODeleteDescendants(interp, oPtr);
 	    oPtr->flags &= ~DONT_DELETE;
 	    TclOOReleaseClassContents(interp, oPtr);
-	    Tcl_Free(oPtr->classPtr);
-	    oPtr->classPtr = NULL;
+		ckfree(oPtr->classPtr);
+		oPtr->classPtr = NULL;
 	} else if (!wasClass && willBeClass) {
 	    TclOOAllocClass(interp, oPtr);
 	}
 
 	if (oPtr->classPtr != NULL) {
@@ -1530,11 +1530,11 @@
     Tcl_Obj *const *objv)
 {
     Object *oPtr;
     Class *clsPtr;
     Tcl_Method method;
-    size_t bodyLength;
+    int bodyLength;
 
     if (objc != 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "arguments body");
 	return TCL_ERROR;
     }
@@ -1548,11 +1548,11 @@
     if (oPtr == NULL) {
 	return TCL_ERROR;
     }
     clsPtr = oPtr->classPtr;
 
-    (void)TclGetStringFromObj(objv[2], &bodyLength);
+    TclGetStringFromObj(objv[2], &bodyLength);
     if (bodyLength > 0) {
 	/*
 	 * Create the method structure.
 	 */
 
@@ -1636,11 +1636,11 @@
     }
     if (objc == 3 && Tcl_GetIndexFromObj(interp, objv[1], kindList, "kind", 0,
 	    &kind) != TCL_OK) {
 	return TCL_ERROR;
     }
-    if (!TclGetString(objv[objc - 1])[0]) {
+    if (!Tcl_GetString(objv[objc - 1])[0]) {
 	nsNamePtr = NULL;
     } else {
 	nsPtr = GetNamespaceInOuterContext(interp, objv[objc - 1]);
 	if (nsPtr == NULL) {
 	    return TCL_ERROR;
@@ -1741,11 +1741,11 @@
     Tcl_Obj *const *objv)
 {
     Object *oPtr;
     Class *clsPtr;
     Tcl_Method method;
-    size_t bodyLength;
+    int bodyLength;
 
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "body");
 	return TCL_ERROR;
     }
@@ -1754,11 +1754,11 @@
     if (oPtr == NULL) {
 	return TCL_ERROR;
     }
     clsPtr = oPtr->classPtr;
 
-    (void)TclGetStringFromObj(objv[1], &bodyLength);
+    TclGetStringFromObj(objv[1], &bodyLength);
     if (bodyLength > 0) {
 	/*
 	 * Create the method structure.
 	 */
 
@@ -1839,11 +1839,11 @@
 	 * their flags member.
 	 */
 
 	if (isInstanceExport) {
 	    if (!oPtr->methodsPtr) {
-		oPtr->methodsPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+		oPtr->methodsPtr = ckalloc(sizeof(Tcl_HashTable));
 		Tcl_InitObjHashTable(oPtr->methodsPtr);
 		oPtr->flags &= ~USE_CLASS_CACHE;
 	    }
 	    hPtr = Tcl_CreateHashEntry(oPtr->methodsPtr, (char *) objv[i],
 		    &isNew);
@@ -1851,11 +1851,11 @@
 	    hPtr = Tcl_CreateHashEntry(&clsPtr->classMethods, (char*) objv[i],
 		    &isNew);
 	}
 
 	if (isNew) {
-	    mPtr = Tcl_Alloc(sizeof(Method));
+	    mPtr = ckalloc(sizeof(Method));
 	    memset(mPtr, 0, sizeof(Method));
 	    mPtr->refCount = 1;
 	    mPtr->namePtr = objv[i];
 	    Tcl_IncrRefCount(objv[i]);
 	    Tcl_SetHashValue(hPtr, mPtr);
@@ -2152,11 +2152,11 @@
 	 * their flags member.
 	 */
 
 	if (isInstanceUnexport) {
 	    if (!oPtr->methodsPtr) {
-		oPtr->methodsPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+		oPtr->methodsPtr = ckalloc(sizeof(Tcl_HashTable));
 		Tcl_InitObjHashTable(oPtr->methodsPtr);
 		oPtr->flags &= ~USE_CLASS_CACHE;
 	    }
 	    hPtr = Tcl_CreateHashEntry(oPtr->methodsPtr, (char *) objv[i],
 		    &isNew);
@@ -2164,11 +2164,11 @@
 	    hPtr = Tcl_CreateHashEntry(&clsPtr->classMethods, (char*) objv[i],
 		    &isNew);
 	}
 
 	if (isNew) {
-	    mPtr = Tcl_Alloc(sizeof(Method));
+	    mPtr = ckalloc(sizeof(Method));
 	    memset(mPtr, 0, sizeof(Method));
 	    mPtr->refCount = 1;
 	    mPtr->namePtr = objv[i];
 	    Tcl_IncrRefCount(objv[i]);
 	    Tcl_SetHashValue(hPtr, mPtr);
@@ -2573,21 +2573,21 @@
 
     /*
      * Allocate some working space.
      */
 
-    superclasses = (Class **) Tcl_Alloc(sizeof(Class *) * superc);
+    superclasses = (Class **) ckalloc(sizeof(Class *) * superc);
 
     /*
      * Parse the arguments to get the class to use as superclasses.
      *
      * Note that zero classes is special, as it is equivalent to just the
      * class of objects. [Bug 9d61624b3d]
      */
 
     if (superc == 0) {
-	superclasses = Tcl_Realloc(superclasses, sizeof(Class *));
+	superclasses = ckrealloc(superclasses, sizeof(Class *));
 	if (TclOOIsReachable(oPtr->fPtr->classCls, oPtr->classPtr)) {
 	    superclasses[0] = oPtr->fPtr->classCls;
 	} else {
 	    superclasses[0] = oPtr->fPtr->objectCls;
 	}
@@ -2616,11 +2616,11 @@
 		Tcl_SetErrorCode(interp, "TCL", "OO", "CIRCULARITY", NULL);
 	    failedAfterAlloc:
 		for (; i > 0; i--) {
 		    TclOODecrRefCount(superclasses[i]->thisPtr);
 		}
-		Tcl_Free(superclasses);
+		ckfree(superclasses);
 		return TCL_ERROR;
 	    }
 
 	    /*
 	     * Corresponding TclOODecrRefCount() is near the end of this
@@ -2641,11 +2641,11 @@
     if (oPtr->classPtr->superclasses.num != 0) {
 	FOREACH(superPtr, oPtr->classPtr->superclasses) {
 	    TclOORemoveFromSubclasses(oPtr->classPtr, superPtr);
 	    TclOODecrRefCount(superPtr->thisPtr);
 	}
-	Tcl_Free(oPtr->classPtr->superclasses.list);
+	ckfree(oPtr->classPtr->superclasses.list);
     }
     oPtr->classPtr->superclasses.list = superclasses;
     oPtr->classPtr->superclasses.num = superc;
     FOREACH(superPtr, oPtr->classPtr->superclasses) {
 	TclOOAddToSubclasses(oPtr->classPtr, superPtr);

Index: generic/tclOOInfo.c
==================================================================
--- generic/tclOOInfo.c
+++ generic/tclOOInfo.c
@@ -610,11 +610,11 @@
 	for (i=0 ; i<numNames ; i++) {
 	    Tcl_ListObjAppendElement(NULL, resultObj,
 		    Tcl_NewStringObj(names[i], -1));
 	}
 	if (numNames > 0) {
-	    Tcl_Free((void *)names);
+	    ckfree(names);
 	}
     } else if (oPtr->methodsPtr) {
 	FOREACH_HASH(namePtr, mPtr, oPtr->methodsPtr) {
 	    if (mPtr->typePtr && (mPtr->flags & SCOPE_FLAGS) == flag) {
 		Tcl_ListObjAppendElement(NULL, resultObj, namePtr);
@@ -807,29 +807,29 @@
     int objc,
     Tcl_Obj *const objv[])
 {
     Object *oPtr;
     Tcl_Obj *resultObj;
-    int i, private = 0;
+    int i, isPrivate = 0;
 
     if (objc != 2 && objc != 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "objName ?-private?");
 	return TCL_ERROR;
     }
     if (objc == 3) {
-	if (strcmp("-private", TclGetString(objv[2])) != 0) {
+	if (strcmp("-private", Tcl_GetString(objv[2])) != 0) {
 	    return TCL_ERROR;
 	}
-	private = 1;
+	isPrivate = 1;
     }
     oPtr = (Object *) Tcl_GetObjectFromObj(interp, objv[1]);
     if (oPtr == NULL) {
 	return TCL_ERROR;
     }
 
     resultObj = Tcl_NewObj();
-    if (private) {
+    if (isPrivate) {
 	PrivateVariableMapping *privatePtr;
 
 	FOREACH_STRUCT(privatePtr, oPtr->privateVariables) {
 	    Tcl_ListObjAppendElement(NULL, resultObj, privatePtr->variableObj);
 	}
@@ -1364,11 +1364,11 @@
 	for (i=0 ; i<numNames ; i++) {
 	    Tcl_ListObjAppendElement(NULL, resultObj,
 		    Tcl_NewStringObj(names[i], -1));
 	}
 	if (numNames > 0) {
-	    Tcl_Free((void *)names);
+	    ckfree(names);
 	}
     } else {
 	FOREACH_HASH_DECLS;
 
 	FOREACH_HASH(namePtr, mPtr, &clsPtr->classMethods) {
@@ -1586,29 +1586,29 @@
     int objc,
     Tcl_Obj *const objv[])
 {
     Class *clsPtr;
     Tcl_Obj *resultObj;
-    int i, private = 0;
+    int i, isPrivate = 0;
 
     if (objc != 2 && objc != 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "className ?-private?");
 	return TCL_ERROR;
     }
     if (objc == 3) {
-	if (strcmp("-private", TclGetString(objv[2])) != 0) {
+	if (strcmp("-private", Tcl_GetString(objv[2])) != 0) {
 	    return TCL_ERROR;
 	}
-	private = 1;
+	isPrivate = 1;
     }
     clsPtr = GetClassFromObj(interp, objv[1]);
     if (clsPtr == NULL) {
 	return TCL_ERROR;
     }
 
     resultObj = Tcl_NewObj();
-    if (private) {
+    if (isPrivate) {
 	PrivateVariableMapping *privatePtr;
 
 	FOREACH_STRUCT(privatePtr, clsPtr->privateVariables) {
 	    Tcl_ListObjAppendElement(NULL, resultObj, privatePtr->variableObj);
 	}

Index: generic/tclOOInt.h
==================================================================
--- generic/tclOOInt.h
+++ generic/tclOOInt.h
@@ -44,11 +44,11 @@
 typedef struct Method {
     const Tcl_MethodType *typePtr;
 				/* The type of method. If NULL, this is a
 				 * special flag record which is just used for
 				 * the setting of the flags field. */
-    size_t refCount;
+    int refCount;
     void *clientData;	/* Type-specific data. */
     Tcl_Obj *namePtr;		/* Name of the method. */
     struct Object *declaringObjectPtr;
 				/* The object that declares this method, or
 				 * NULL if it was declared by a class. */
@@ -63,16 +63,16 @@
 /*
  * Pre- and post-call callbacks, to allow procedure-like methods to be fine
  * tuned in their behaviour.
  */
 
-typedef int (TclOO_PreCallProc)(void *clientData, Tcl_Interp *interp,
+typedef int (TclOO_PreCallProc)(ClientData clientData, Tcl_Interp *interp,
 	Tcl_ObjectContext context, Tcl_CallFrame *framePtr, int *isFinished);
-typedef int (TclOO_PostCallProc)(void *clientData, Tcl_Interp *interp,
+typedef int (TclOO_PostCallProc)(ClientData clientData, Tcl_Interp *interp,
 	Tcl_ObjectContext context, Tcl_Namespace *namespacePtr, int result);
-typedef void (TclOO_PmCDDeleteProc)(void *clientData);
-typedef void *(TclOO_PmCDCloneProc)(void *clientData);
+typedef void (TclOO_PmCDDeleteProc)(ClientData clientData);
+typedef ClientData (TclOO_PmCDCloneProc)(ClientData clientData);
 
 /*
  * Procedure-like methods have the following extra information.
  */
 
@@ -81,11 +81,11 @@
 				 * be 0. */
     Proc *procPtr;		/* Core of the implementation of the method;
 				 * includes the argument definition and the
 				 * body bytecodes. */
     int flags;			/* Flags to control features. */
-    size_t refCount;
+    int refCount;
     void *clientData;
     TclOO_PmCDDeleteProc *deleteClientdataProc;
     TclOO_PmCDCloneProc *cloneClientdataProc;
     ProcErrorProc *errProc;	/* Replacement error handler. */
     TclOO_PreCallProc *preCallProc;
@@ -182,22 +182,22 @@
     LIST_STATIC(Tcl_Obj *) filters;
 				/* List of filter names. */
     struct Class *classPtr;	/* This is non-NULL for all classes, and NULL
 				 *  for everything else. It points to the class
 				 *  structure. */
-    size_t refCount;		/* Number of strong references to this object.
+    int refCount;		/* Number of strong references to this object.
 				 * Note that there may be many more weak
 				 * references; this mechanism exists to
 				 * avoid Tcl_Preserve. */
     int flags;
-    size_t creationEpoch;		/* Unique value to make comparisons of objects
+    int creationEpoch;		/* Unique value to make comparisons of objects
 				 * easier. */
-    size_t epoch;			/* Per-object epoch, incremented when the way
+    int epoch;			/* Per-object epoch, incremented when the way
 				 * an object should resolve call chains is
 				 * changed. */
     Tcl_HashTable *metadataPtr;	/* Mapping from pointers to metadata type to
-				 * the void *values that are the values
+				 * the ClientData values that are the values
 				 * of each piece of attached metadata. This
 				 * field starts out as NULL and is only
 				 * allocated if metadata is attached. */
     Tcl_Obj *cachedNameObj;	/* Cache of the name of the object. */
     Tcl_HashTable *chainCache;	/* Place to keep unused contexts. This table
@@ -284,11 +284,11 @@
     Method *constructorPtr;	/* Method record of the class constructor (if
 				 * any). */
     Method *destructorPtr;	/* Method record of the class destructor (if
 				 * any). */
     Tcl_HashTable *metadataPtr;	/* Mapping from pointers to metadata type to
-				 * the void *values that are the values
+				 * the ClientData values that are the values
 				 * of each piece of attached metadata. This
 				 * field starts out as NULL and is only
 				 * allocated if metadata is attached. */
     struct CallChain *constructorChainPtr;
     struct CallChain *destructorChainPtr;
@@ -330,11 +330,11 @@
  * useful bits and pieces. Probably ought to eventually go in the Interp
  * structure itself.
  */
 
 typedef struct ThreadLocalData {
-    size_t nsCount;		/* Master epoch counter is used for keeping
+    int nsCount;		/* Master epoch counter is used for keeping
 				 * the values used in Tcl_Obj internal
 				 * representations sane. Must be thread-local
 				 * because Tcl_Objs can cross interpreter
 				 * boundaries within a thread (objects don't
 				 * generally cross threads). */
@@ -354,11 +354,11 @@
 				 * "oo::objdefine" command acts as a special
 				 * kind of ensemble for this namespace. */
     Tcl_Namespace *helpersNs;	/* Namespace containing the commands that are
 				 * only valid when executing inside a
 				 * procedural method. */
-    size_t epoch;			/* Used to invalidate method chains when the
+    int epoch;			/* Used to invalidate method chains when the
 				 * class structure changes. */
     ThreadLocalData *tsdPtr;	/* Counter so we can allocate a unique
 				 * namespace to each object. */
     Tcl_Obj *unknownMethodNameObj;
 				/* Shared object containing the name of the
@@ -388,19 +388,19 @@
     Class *filterDeclarer;	/* What class decided to add the filter; if
 				 * NULL, it was added by the object. */
 };
 
 typedef struct CallChain {
-    size_t objectCreationEpoch;	/* The object's creation epoch. Note that the
+    int objectCreationEpoch;	/* The object's creation epoch. Note that the
 				 * object reference is not stored in the call
 				 * chain; it is in the call context. */
-    size_t objectEpoch;		/* Local (object structure) epoch counter
+    int objectEpoch;		/* Local (object structure) epoch counter
 				 * snapshot. */
-    size_t epoch;			/* Global (class structure) epoch counter
+    int epoch;			/* Global (class structure) epoch counter
 				 * snapshot. */
     int flags;			/* Assorted flags, see below. */
-    size_t refCount;		/* Reference count. */
+    int refCount;		/* Reference count. */
     int numChain;		/* Size of the call chain. */
     struct MInvoke *chain;	/* Array of call chain entries. May point to
 				 * staticChain if the number of entries is
 				 * small. */
     struct MInvoke staticChain[CALL_CHAIN_STATIC_SIZE];
@@ -448,124 +448,100 @@
  * Commands relating to OO support.
  *----------------------------------------------------------------
  */
 
 MODULE_SCOPE int	TclOOInit(Tcl_Interp *interp);
-MODULE_SCOPE int	TclOODefineObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOOObjDefObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineConstructorObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineDeleteMethodObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineDestructorObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineExportObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineForwardObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineMethodObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineRenameMethodObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineUnexportObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineClassObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineSelfObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineObjSelfObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOOUnknownDefinition(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOOCopyObjectCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOONextObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOONextToObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineUnexportObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineClassObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineSelfObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefineObjSelfObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOODefinePrivateObjCmd(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOOUnknownDefinition(void *clientData,
-			    Tcl_Interp *interp, int objc,
-			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOOCopyObjectCmd(void *clientData,
+MODULE_SCOPE int	TclOODefineObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOOObjDefObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineConstructorObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const *objv);
 MODULE_SCOPE int	TclOODefineDefnNsObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOONextObjCmd(void *clientData,
+MODULE_SCOPE int	TclOODefineDeleteMethodObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineDestructorObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineExportObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineForwardObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineMethodObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineRenameMethodObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineUnexportObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineClassObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineSelfObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefineObjSelfObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOODefinePrivateObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOOUnknownDefinition(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOOCopyObjectCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOONextObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOONextToObjCmd(void *clientData,
+MODULE_SCOPE int	TclOONextToObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOOSelfObjCmd(void *clientData,
+MODULE_SCOPE int	TclOOSelfObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const *objv);
 
 /*
  * Method implementations (in tclOOBasic.c).
  */
 
-MODULE_SCOPE int	TclOO_Class_Constructor(void *clientData,
-			    Tcl_Interp *interp, Tcl_ObjectContext context,
-			    int objc, Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOO_Class_Create(void *clientData,
-			    Tcl_Interp *interp, Tcl_ObjectContext context,
-			    int objc, Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOO_Class_CreateNs(void *clientData,
-			    Tcl_Interp *interp, Tcl_ObjectContext context,
-			    int objc, Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOO_Class_New(void *clientData,
-			    Tcl_Interp *interp, Tcl_ObjectContext context,
-			    int objc, Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOO_Object_Destroy(void *clientData,
-			    Tcl_Interp *interp, Tcl_ObjectContext context,
-			    int objc, Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOO_Object_Eval(void *clientData,
-			    Tcl_Interp *interp, Tcl_ObjectContext context,
-			    int objc, Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOO_Object_LinkVar(void *clientData,
-			    Tcl_Interp *interp, Tcl_ObjectContext context,
-			    int objc, Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOO_Object_Unknown(void *clientData,
-			    Tcl_Interp *interp, Tcl_ObjectContext context,
-			    int objc, Tcl_Obj *const *objv);
-MODULE_SCOPE int	TclOO_Object_VarName(void *clientData,
+MODULE_SCOPE int	TclOO_Class_Constructor(ClientData clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Class_Create(ClientData clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Class_CreateNs(ClientData clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Class_New(ClientData clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Object_Destroy(ClientData clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Object_Eval(ClientData clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Object_LinkVar(ClientData clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Object_Unknown(ClientData clientData,
+			    Tcl_Interp *interp, Tcl_ObjectContext context,
+			    int objc, Tcl_Obj *const *objv);
+MODULE_SCOPE int	TclOO_Object_VarName(ClientData clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
 
 /*
  * Private definitions, some of which perhaps ought to be exposed properly or
@@ -611,11 +587,11 @@
 MODULE_SCOPE int	TclOOGetSortedMethodList(Object *oPtr,
 			    Object *contextObj, Class *contextCls, int flags,
 			    const char ***stringsPtr);
 MODULE_SCOPE int	TclOOInit(Tcl_Interp *interp);
 MODULE_SCOPE void	TclOOInitInfo(Tcl_Interp *interp);
-MODULE_SCOPE int	TclOOInvokeContext(void *clientData,
+MODULE_SCOPE int	TclOOInvokeContext(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	TclNRObjectContextInvokeNext(Tcl_Interp *interp,
 			    Tcl_ObjectContext context, int objc,
 			    Tcl_Obj *const *objv, int skip);
@@ -693,13 +669,13 @@
  */
 
 #undef DUPLICATE /* prevent possible conflict with definition in WINAPI nb30.h */
 #define DUPLICATE(target,source,type) \
     do { \
-	register size_t len = sizeof(type) * ((target).num=(source).num);\
+	size_t len = sizeof(type) * ((target).num=(source).num);\
 	if (len != 0) { \
-	    memcpy(((target).list=(type*)Tcl_Alloc(len)), (source).list, len); \
+	    memcpy(((target).list=(type*)ckalloc(len)), (source).list, len); \
 	} else { \
 	    (target).list = NULL; \
 	} \
     } while(0)
 

Index: generic/tclOOIntDecls.h
==================================================================
--- generic/tclOOIntDecls.h
+++ generic/tclOOIntDecls.h
@@ -20,18 +20,18 @@
 /* 1 */
 TCLAPI Tcl_Method	TclOOMakeProcInstanceMethod(Tcl_Interp *interp,
 				Object *oPtr, int flags, Tcl_Obj *nameObj,
 				Tcl_Obj *argsObj, Tcl_Obj *bodyObj,
 				const Tcl_MethodType *typePtr,
-				void *clientData, Proc **procPtrPtr);
+				ClientData clientData, Proc **procPtrPtr);
 /* 2 */
 TCLAPI Tcl_Method	TclOOMakeProcMethod(Tcl_Interp *interp,
 				Class *clsPtr, int flags, Tcl_Obj *nameObj,
 				const char *namePtr, Tcl_Obj *argsObj,
 				Tcl_Obj *bodyObj,
 				const Tcl_MethodType *typePtr,
-				void *clientData, Proc **procPtrPtr);
+				ClientData clientData, Proc **procPtrPtr);
 /* 3 */
 TCLAPI Method *		TclOONewProcInstanceMethod(Tcl_Interp *interp,
 				Object *oPtr, int flags, Tcl_Obj *nameObj,
 				Tcl_Obj *argsObj, Tcl_Obj *bodyObj,
 				ProcedureMethod **pmPtrPtr);
@@ -57,23 +57,23 @@
 /* 9 */
 TCLAPI Tcl_Method	TclOONewProcInstanceMethodEx(Tcl_Interp *interp,
 				Tcl_Object oPtr,
 				TclOO_PreCallProc *preCallPtr,
 				TclOO_PostCallProc *postCallPtr,
-				ProcErrorProc *errProc, void *clientData,
-				Tcl_Obj *nameObj, Tcl_Obj *argsObj,
-				Tcl_Obj *bodyObj, int flags,
-				void **internalTokenPtr);
+				ProcErrorProc *errProc,
+				ClientData clientData, Tcl_Obj *nameObj,
+				Tcl_Obj *argsObj, Tcl_Obj *bodyObj,
+				int flags, void **internalTokenPtr);
 /* 10 */
 TCLAPI Tcl_Method	TclOONewProcMethodEx(Tcl_Interp *interp,
 				Tcl_Class clsPtr,
 				TclOO_PreCallProc *preCallPtr,
 				TclOO_PostCallProc *postCallPtr,
-				ProcErrorProc *errProc, void *clientData,
-				Tcl_Obj *nameObj, Tcl_Obj *argsObj,
-				Tcl_Obj *bodyObj, int flags,
-				void **internalTokenPtr);
+				ProcErrorProc *errProc,
+				ClientData clientData, Tcl_Obj *nameObj,
+				Tcl_Obj *argsObj, Tcl_Obj *bodyObj,
+				int flags, void **internalTokenPtr);
 /* 11 */
 TCLAPI int		TclOOInvokeObject(Tcl_Interp *interp,
 				Tcl_Object object, Tcl_Class startCls,
 				int publicPrivate, int objc,
 				Tcl_Obj *const *objv);
@@ -95,20 +95,20 @@
 typedef struct TclOOIntStubs {
     int magic;
     void *hooks;
 
     Tcl_Object (*tclOOGetDefineCmdContext) (Tcl_Interp *interp); /* 0 */
-    Tcl_Method (*tclOOMakeProcInstanceMethod) (Tcl_Interp *interp, Object *oPtr, int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, const Tcl_MethodType *typePtr, void *clientData, Proc **procPtrPtr); /* 1 */
-    Tcl_Method (*tclOOMakeProcMethod) (Tcl_Interp *interp, Class *clsPtr, int flags, Tcl_Obj *nameObj, const char *namePtr, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, const Tcl_MethodType *typePtr, void *clientData, Proc **procPtrPtr); /* 2 */
+    Tcl_Method (*tclOOMakeProcInstanceMethod) (Tcl_Interp *interp, Object *oPtr, int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, const Tcl_MethodType *typePtr, ClientData clientData, Proc **procPtrPtr); /* 1 */
+    Tcl_Method (*tclOOMakeProcMethod) (Tcl_Interp *interp, Class *clsPtr, int flags, Tcl_Obj *nameObj, const char *namePtr, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, const Tcl_MethodType *typePtr, ClientData clientData, Proc **procPtrPtr); /* 2 */
     Method * (*tclOONewProcInstanceMethod) (Tcl_Interp *interp, Object *oPtr, int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, ProcedureMethod **pmPtrPtr); /* 3 */
     Method * (*tclOONewProcMethod) (Tcl_Interp *interp, Class *clsPtr, int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, ProcedureMethod **pmPtrPtr); /* 4 */
     int (*tclOOObjectCmdCore) (Object *oPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv, int publicOnly, Class *startCls); /* 5 */
     int (*tclOOIsReachable) (Class *targetPtr, Class *startPtr); /* 6 */
     Method * (*tclOONewForwardMethod) (Tcl_Interp *interp, Class *clsPtr, int isPublic, Tcl_Obj *nameObj, Tcl_Obj *prefixObj); /* 7 */
     Method * (*tclOONewForwardInstanceMethod) (Tcl_Interp *interp, Object *oPtr, int isPublic, Tcl_Obj *nameObj, Tcl_Obj *prefixObj); /* 8 */
-    Tcl_Method (*tclOONewProcInstanceMethodEx) (Tcl_Interp *interp, Tcl_Object oPtr, TclOO_PreCallProc *preCallPtr, TclOO_PostCallProc *postCallPtr, ProcErrorProc *errProc, void *clientData, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, int flags, void **internalTokenPtr); /* 9 */
-    Tcl_Method (*tclOONewProcMethodEx) (Tcl_Interp *interp, Tcl_Class clsPtr, TclOO_PreCallProc *preCallPtr, TclOO_PostCallProc *postCallPtr, ProcErrorProc *errProc, void *clientData, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, int flags, void **internalTokenPtr); /* 10 */
+    Tcl_Method (*tclOONewProcInstanceMethodEx) (Tcl_Interp *interp, Tcl_Object oPtr, TclOO_PreCallProc *preCallPtr, TclOO_PostCallProc *postCallPtr, ProcErrorProc *errProc, ClientData clientData, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, int flags, void **internalTokenPtr); /* 9 */
+    Tcl_Method (*tclOONewProcMethodEx) (Tcl_Interp *interp, Tcl_Class clsPtr, TclOO_PreCallProc *preCallPtr, TclOO_PostCallProc *postCallPtr, ProcErrorProc *errProc, ClientData clientData, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj, int flags, void **internalTokenPtr); /* 10 */
     int (*tclOOInvokeObject) (Tcl_Interp *interp, Tcl_Object object, Tcl_Class startCls, int publicPrivate, int objc, Tcl_Obj *const *objv); /* 11 */
     void (*tclOOObjectSetFilters) (Object *oPtr, int numFilters, Tcl_Obj *const *filters); /* 12 */
     void (*tclOOClassSetFilters) (Tcl_Interp *interp, Class *classPtr, int numFilters, Tcl_Obj *const *filters); /* 13 */
     void (*tclOOObjectSetMixins) (Object *oPtr, int numMixins, Class *const *mixins); /* 14 */
     void (*tclOOClassSetMixins) (Tcl_Interp *interp, Class *classPtr, int numMixins, Class *const *mixins); /* 15 */

Index: generic/tclOOMethod.c
==================================================================
--- generic/tclOOMethod.c
+++ generic/tclOOMethod.c
@@ -147,29 +147,29 @@
 				 * how to invoke, delete and clone the
 				 * method. */
     void *clientData)	/* Some data associated with the particular
 				 * method to be created. */
 {
-    register Object *oPtr = (Object *) object;
-    register Method *mPtr;
+    Object *oPtr = (Object *) object;
+    Method *mPtr;
     Tcl_HashEntry *hPtr;
     int isNew;
 
     if (nameObj == NULL) {
-	mPtr = Tcl_Alloc(sizeof(Method));
+	mPtr = ckalloc(sizeof(Method));
 	mPtr->namePtr = NULL;
 	mPtr->refCount = 1;
 	goto populate;
     }
     if (!oPtr->methodsPtr) {
-	oPtr->methodsPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+	oPtr->methodsPtr = ckalloc(sizeof(Tcl_HashTable));
 	Tcl_InitObjHashTable(oPtr->methodsPtr);
 	oPtr->flags &= ~USE_CLASS_CACHE;
     }
     hPtr = Tcl_CreateHashEntry(oPtr->methodsPtr, (char *) nameObj, &isNew);
     if (isNew) {
-	mPtr = Tcl_Alloc(sizeof(Method));
+	mPtr = ckalloc(sizeof(Method));
 	mPtr->namePtr = nameObj;
 	mPtr->refCount = 1;
 	Tcl_IncrRefCount(nameObj);
 	Tcl_SetHashValue(hPtr, mPtr);
     } else {
@@ -219,24 +219,24 @@
 				 * how to invoke, delete and clone the
 				 * method. */
     void *clientData)	/* Some data associated with the particular
 				 * method to be created. */
 {
-    register Class *clsPtr = (Class *) cls;
-    register Method *mPtr;
+    Class *clsPtr = (Class *) cls;
+    Method *mPtr;
     Tcl_HashEntry *hPtr;
     int isNew;
 
     if (nameObj == NULL) {
-	mPtr = Tcl_Alloc(sizeof(Method));
+	mPtr = ckalloc(sizeof(Method));
 	mPtr->namePtr = NULL;
 	mPtr->refCount = 1;
 	goto populate;
     }
     hPtr = Tcl_CreateHashEntry(&clsPtr->classMethods, (char *)nameObj,&isNew);
     if (isNew) {
-	mPtr = Tcl_Alloc(sizeof(Method));
+	mPtr = ckalloc(sizeof(Method));
 	mPtr->refCount = 1;
 	mPtr->namePtr = nameObj;
 	Tcl_IncrRefCount(nameObj);
 	Tcl_SetHashValue(hPtr, mPtr);
     } else {
@@ -284,11 +284,11 @@
 	}
 	if (mPtr->namePtr != NULL) {
 	    Tcl_DecrRefCount(mPtr->namePtr);
 	}
 
-	Tcl_Free(mPtr);
+	ckfree(mPtr);
     }
 }
 
 /*
  * ----------------------------------------------------------------------
@@ -342,26 +342,26 @@
 				 * structure to allow for deeper tuning of the
 				 * structure's contents. NULL if caller is not
 				 * interested. */
 {
     int argsLen;
-    register ProcedureMethod *pmPtr;
+    ProcedureMethod *pmPtr;
     Tcl_Method method;
 
     if (Tcl_ListObjLength(interp, argsObj, &argsLen) != TCL_OK) {
 	return NULL;
     }
-    pmPtr = Tcl_Alloc(sizeof(ProcedureMethod));
+    pmPtr = ckalloc(sizeof(ProcedureMethod));
     memset(pmPtr, 0, sizeof(ProcedureMethod));
     pmPtr->version = TCLOO_PROCEDURE_METHOD_VERSION;
     pmPtr->flags = flags & USE_DECLARER_NS;
     pmPtr->refCount = 1;
 
     method = TclOOMakeProcInstanceMethod(interp, oPtr, flags, nameObj,
 	    argsObj, bodyObj, &procMethodType, pmPtr, &pmPtr->procPtr);
     if (method == NULL) {
-	Tcl_Free(pmPtr);
+	ckfree(pmPtr);
     } else if (pmPtrPtr != NULL) {
 	*pmPtrPtr = pmPtr;
     }
     return (Method *) method;
 }
@@ -394,11 +394,11 @@
 				 * structure to allow for deeper tuning of the
 				 * structure's contents. NULL if caller is not
 				 * interested. */
 {
     int argsLen;		/* -1 => delete argsObj before exit */
-    register ProcedureMethod *pmPtr;
+    ProcedureMethod *pmPtr;
     const char *procName;
     Tcl_Method method;
 
     if (argsObj == NULL) {
 	argsLen = -1;
@@ -409,11 +409,11 @@
 	return NULL;
     } else {
 	procName = (nameObj==NULL ? "<constructor>" : TclGetString(nameObj));
     }
 
-    pmPtr = Tcl_Alloc(sizeof(ProcedureMethod));
+    pmPtr = ckalloc(sizeof(ProcedureMethod));
     memset(pmPtr, 0, sizeof(ProcedureMethod));
     pmPtr->version = TCLOO_PROCEDURE_METHOD_VERSION;
     pmPtr->flags = flags & USE_DECLARER_NS;
     pmPtr->refCount = 1;
 
@@ -422,11 +422,11 @@
 
     if (argsLen == -1) {
 	Tcl_DecrRefCount(argsObj);
     }
     if (method == NULL) {
-	Tcl_Free(pmPtr);
+	ckfree(pmPtr);
     } else if (pmPtrPtr != NULL) {
 	*pmPtrPtr = pmPtr;
     }
 
     return (Method *) method;
@@ -503,16 +503,16 @@
 	     */
 
 	    if (context.line
 		    && (context.nline >= 4) && (context.line[3] >= 0)) {
 		int isNew;
-		CmdFrame *cfPtr = Tcl_Alloc(sizeof(CmdFrame));
+		CmdFrame *cfPtr = ckalloc(sizeof(CmdFrame));
 		Tcl_HashEntry *hPtr;
 
 		cfPtr->level = -1;
 		cfPtr->type = context.type;
-		cfPtr->line = Tcl_Alloc(sizeof(int));
+		cfPtr->line = ckalloc(sizeof(int));
 		cfPtr->line[0] = context.line[3];
 		cfPtr->nline = 1;
 		cfPtr->framePtr = NULL;
 		cfPtr->nextPtr = NULL;
 
@@ -616,16 +616,16 @@
 	     */
 
 	    if (context.line
 		    && (context.nline >= 4) && (context.line[3] >= 0)) {
 		int isNew;
-		CmdFrame *cfPtr = Tcl_Alloc(sizeof(CmdFrame));
+		CmdFrame *cfPtr = ckalloc(sizeof(CmdFrame));
 		Tcl_HashEntry *hPtr;
 
 		cfPtr->level = -1;
 		cfPtr->type = context.type;
-		cfPtr->line = Tcl_Alloc(sizeof(int));
+		cfPtr->line = ckalloc(sizeof(int));
 		cfPtr->line[0] = context.line[3];
 		cfPtr->nline = 1;
 		cfPtr->framePtr = NULL;
 		cfPtr->nextPtr = NULL;
 
@@ -794,11 +794,11 @@
     Tcl_Obj *const *objv,	/* Array of arguments. */
     PMFrameData *fdPtr)		/* Place to store information about the call
 				 * frame. */
 {
     Namespace *nsPtr = (Namespace *) contextPtr->oPtr->namespacePtr;
-    register int result;
+    int result;
     const char *namePtr;
     CallFrame **framePtrPtr = &fdPtr->framePtr;
     ByteCode *codePtr;
 
     /*
@@ -827,11 +827,11 @@
      * Magic to enable things like [incr Tcl], which wants methods to run in
      * their class's namespace.
      */
 
     if (pmPtr->flags & USE_DECLARER_NS) {
-	register Method *mPtr =
+	Method *mPtr =
 		contextPtr->callPtr->chain[contextPtr->index].mPtr;
 
 	if (mPtr->declaringClassPtr != NULL) {
 	    nsPtr = (Namespace *)
 		    mPtr->declaringClassPtr->thisPtr->namespacePtr;
@@ -898,11 +898,11 @@
     if (pmPtr->gfivProc != NULL) {
 	fdPtr->efi.fields[1].name = "";
 	fdPtr->efi.fields[1].proc = pmPtr->gfivProc;
 	fdPtr->efi.fields[1].clientData = pmPtr;
     } else {
-	register Tcl_Method method =
+	Tcl_Method method =
 		Tcl_ObjectContextMethod((Tcl_ObjectContext) contextPtr);
 
 	if (Tcl_MethodDeclarerObject(method) != NULL) {
 	    fdPtr->efi.fields[1].name = "object";
 	} else {
@@ -991,12 +991,11 @@
     CallFrame *framePtr = iPtr->varFramePtr;
     CallContext *contextPtr;
     Tcl_Obj *variableObj;
     PrivateVariableMapping *privateVar;
     Tcl_HashEntry *hPtr;
-    int i, isNew, cacheIt;
-    size_t varLen, len;
+    int i, isNew, cacheIt, varLen, len;
     const char *match, *varName;
 
     /*
      * Check that the variable is being requested in a context that is also a
      * method call; if not (i.e. we're evaluating in the object's namespace or
@@ -1099,11 +1098,11 @@
     if (infoPtr->cachedObjectVar) {
 	VarHashRefCount(infoPtr->cachedObjectVar)--;
 	TclCleanupVar((Var *) infoPtr->cachedObjectVar, NULL);
     }
     Tcl_DecrRefCount(infoPtr->variableObj);
-    Tcl_Free(infoPtr);
+    ckfree(infoPtr);
 }
 
 static int
 ProcedureMethodCompiledVarResolver(
     Tcl_Interp *interp,
@@ -1118,17 +1117,17 @@
     /*
      * Do not create resolvers for cases that contain namespace separators or
      * which look like array accesses. Both will lead us astray.
      */
 
-    if (strstr(TclGetString(variableObj), "::") != NULL ||
-	    Tcl_StringMatch(TclGetString(variableObj), "*(*)")) {
+    if (strstr(Tcl_GetString(variableObj), "::") != NULL ||
+	    Tcl_StringMatch(Tcl_GetString(variableObj), "*(*)")) {
 	Tcl_DecrRefCount(variableObj);
 	return TCL_CONTINUE;
     }
 
-    infoPtr = Tcl_Alloc(sizeof(OOResVarInfo));
+    infoPtr = ckalloc(sizeof(OOResVarInfo));
     infoPtr->info.fetchProc = ProcedureMethodCompiledVarConnect;
     infoPtr->info.deleteProc = ProcedureMethodCompiledVarDelete;
     infoPtr->cachedObjectVar = NULL;
     infoPtr->variableObj = variableObj;
     Tcl_IncrRefCount(variableObj);
@@ -1177,18 +1176,18 @@
  * ----------------------------------------------------------------------
  */
 
 #define LIMIT 60
 #define ELLIPSIFY(str,len) \
-	((len) > LIMIT ? LIMIT : (int)(len)), (str), ((len) > LIMIT ? "..." : "")
+	((len) > LIMIT ? LIMIT : (len)), (str), ((len) > LIMIT ? "..." : "")
 
 static void
 MethodErrorHandler(
     Tcl_Interp *interp,
     Tcl_Obj *methodNameObj)
 {
-    size_t nameLen, objectNameLen;
+    int nameLen, objectNameLen;
     CallContext *contextPtr = ((Interp *) interp)->varFramePtr->clientData;
     Method *mPtr = contextPtr->callPtr->chain[contextPtr->index].mPtr;
     const char *objectName, *kindName, *methodName =
 	    TclGetStringFromObj(mPtr->namePtr, &nameLen);
     Object *declarerPtr;
@@ -1202,11 +1201,11 @@
 	}
 	declarerPtr = mPtr->declaringClassPtr->thisPtr;
 	kindName = "class";
     }
 
-    objectName = TclGetStringFromObj(TclOOObjectName(interp, declarerPtr),
+    objectName = Tcl_GetStringFromObj(TclOOObjectName(interp, declarerPtr),
 	    &objectNameLen);
     Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 	    "\n    (%s \"%.*s%s\" method \"%.*s%s\" line %d)",
 	    kindName, ELLIPSIFY(objectName, objectNameLen),
 	    ELLIPSIFY(methodName, nameLen), Tcl_GetErrorLine(interp)));
@@ -1219,11 +1218,11 @@
 {
     CallContext *contextPtr = ((Interp *) interp)->varFramePtr->clientData;
     Method *mPtr = contextPtr->callPtr->chain[contextPtr->index].mPtr;
     Object *declarerPtr;
     const char *objectName, *kindName;
-    size_t objectNameLen;
+    int objectNameLen;
 
     if (mPtr->declaringObjectPtr != NULL) {
 	declarerPtr = mPtr->declaringObjectPtr;
 	kindName = "object";
     } else {
@@ -1232,11 +1231,11 @@
 	}
 	declarerPtr = mPtr->declaringClassPtr->thisPtr;
 	kindName = "class";
     }
 
-    objectName = TclGetStringFromObj(TclOOObjectName(interp, declarerPtr),
+    objectName = Tcl_GetStringFromObj(TclOOObjectName(interp, declarerPtr),
 	    &objectNameLen);
     Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 	    "\n    (%s \"%.*s%s\" constructor line %d)", kindName,
 	    ELLIPSIFY(objectName, objectNameLen), Tcl_GetErrorLine(interp)));
 }
@@ -1248,11 +1247,11 @@
 {
     CallContext *contextPtr = ((Interp *) interp)->varFramePtr->clientData;
     Method *mPtr = contextPtr->callPtr->chain[contextPtr->index].mPtr;
     Object *declarerPtr;
     const char *objectName, *kindName;
-    size_t objectNameLen;
+    int objectNameLen;
 
     if (mPtr->declaringObjectPtr != NULL) {
 	declarerPtr = mPtr->declaringObjectPtr;
 	kindName = "object";
     } else {
@@ -1261,11 +1260,11 @@
 	}
 	declarerPtr = mPtr->declaringClassPtr->thisPtr;
 	kindName = "class";
     }
 
-    objectName = TclGetStringFromObj(TclOOObjectName(interp, declarerPtr),
+    objectName = Tcl_GetStringFromObj(TclOOObjectName(interp, declarerPtr),
 	    &objectNameLen);
     Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 	    "\n    (%s \"%.*s%s\" destructor line %d)", kindName,
 	    ELLIPSIFY(objectName, objectNameLen), Tcl_GetErrorLine(interp)));
 }
@@ -1286,18 +1285,18 @@
 {
     TclProcDeleteProc(pmPtr->procPtr);
     if (pmPtr->deleteClientdataProc) {
 	pmPtr->deleteClientdataProc(pmPtr->clientData);
     }
-    Tcl_Free(pmPtr);
+    ckfree(pmPtr);
 }
 
 static void
 DeleteProcedureMethod(
     void *clientData)
 {
-    register ProcedureMethod *pmPtr = clientData;
+    ProcedureMethod *pmPtr = clientData;
 
     if (pmPtr->refCount-- <= 1) {
 	DeleteProcedureMethodRecord(pmPtr);
     }
 }
@@ -1336,28 +1335,28 @@
      * Must strip the internal representation in order to ensure that any
      * bound references to instance variables are removed. [Bug 3609693]
      */
 
     bodyObj = Tcl_DuplicateObj(pmPtr->procPtr->bodyPtr);
-    TclGetString(bodyObj);
+    Tcl_GetString(bodyObj);
     Tcl_StoreIntRep(pmPtr->procPtr->bodyPtr, &tclByteCodeType, NULL);
 
     /*
      * Create the actual copy of the method record, manufacturing a new proc
      * record.
      */
 
-    pm2Ptr = Tcl_Alloc(sizeof(ProcedureMethod));
+    pm2Ptr = ckalloc(sizeof(ProcedureMethod));
     memcpy(pm2Ptr, pmPtr, sizeof(ProcedureMethod));
     pm2Ptr->refCount = 1;
     Tcl_IncrRefCount(argsObj);
     Tcl_IncrRefCount(bodyObj);
     if (TclCreateProc(interp, NULL, "", argsObj, bodyObj,
 	    &pm2Ptr->procPtr) != TCL_OK) {
 	Tcl_DecrRefCount(argsObj);
 	Tcl_DecrRefCount(bodyObj);
-	Tcl_Free(pm2Ptr);
+	ckfree(pm2Ptr);
 	return TCL_ERROR;
     }
     Tcl_DecrRefCount(argsObj);
     Tcl_DecrRefCount(bodyObj);
 
@@ -1386,11 +1385,11 @@
     Tcl_Obj *nameObj,		/* The name of the method. */
     Tcl_Obj *prefixObj)		/* List of arguments that form the command
 				 * prefix to forward to. */
 {
     int prefixLen;
-    register ForwardMethod *fmPtr;
+    ForwardMethod *fmPtr;
 
     if (Tcl_ListObjLength(interp, prefixObj, &prefixLen) != TCL_OK) {
 	return NULL;
     }
     if (prefixLen < 1) {
@@ -1398,11 +1397,11 @@
 		"method forward prefix must be non-empty", -1));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "BAD_FORWARD", NULL);
 	return NULL;
     }
 
-    fmPtr = Tcl_Alloc(sizeof(ForwardMethod));
+    fmPtr = ckalloc(sizeof(ForwardMethod));
     fmPtr->prefixObj = prefixObj;
     Tcl_IncrRefCount(prefixObj);
     return (Method *) Tcl_NewInstanceMethod(interp, (Tcl_Object) oPtr,
 	    nameObj, flags, &fwdMethodType, fmPtr);
 }
@@ -1425,11 +1424,11 @@
     Tcl_Obj *nameObj,		/* The name of the method. */
     Tcl_Obj *prefixObj)		/* List of arguments that form the command
 				 * prefix to forward to. */
 {
     int prefixLen;
-    register ForwardMethod *fmPtr;
+    ForwardMethod *fmPtr;
 
     if (Tcl_ListObjLength(interp, prefixObj, &prefixLen) != TCL_OK) {
 	return NULL;
     }
     if (prefixLen < 1) {
@@ -1437,11 +1436,11 @@
 		"method forward prefix must be non-empty", -1));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "BAD_FORWARD", NULL);
 	return NULL;
     }
 
-    fmPtr = Tcl_Alloc(sizeof(ForwardMethod));
+    fmPtr = ckalloc(sizeof(ForwardMethod));
     fmPtr->prefixObj = prefixObj;
     Tcl_IncrRefCount(prefixObj);
     return (Method *) Tcl_NewMethod(interp, (Tcl_Class) clsPtr, nameObj,
 	    flags, &fwdMethodType, fmPtr);
 }
@@ -1518,21 +1517,21 @@
     void *clientData)
 {
     ForwardMethod *fmPtr = clientData;
 
     Tcl_DecrRefCount(fmPtr->prefixObj);
-    Tcl_Free(fmPtr);
+    ckfree(fmPtr);
 }
 
 static int
 CloneForwardMethod(
     Tcl_Interp *interp,
     void *clientData,
     void **newClientData)
 {
     ForwardMethod *fmPtr = clientData;
-    ForwardMethod *fm2Ptr = Tcl_Alloc(sizeof(ForwardMethod));
+    ForwardMethod *fm2Ptr = ckalloc(sizeof(ForwardMethod));
 
     fm2Ptr->prefixObj = fmPtr->prefixObj;
     Tcl_IncrRefCount(fm2Ptr->prefixObj);
     *newClientData = fm2Ptr;
     return TCL_OK;

Index: generic/tclObj.c
==================================================================
--- generic/tclObj.c
+++ generic/tclObj.c
@@ -56,11 +56,11 @@
  * Structure for tracking the source file and line number where a given
  * Tcl_Obj was allocated.  We also track the pointer to the Tcl_Obj itself,
  * for sanity checking purposes.
  */
 
-typedef struct {
+typedef struct ObjData {
     Tcl_Obj *objPtr;		/* The pointer to the allocated Tcl_Obj. */
     const char *file;		/* The name of the source file calling this
 				 * function; used for debugging. */
     int line;			/* Line number in the source file; used for
 				 * debugging. */
@@ -176,19 +176,19 @@
  * Macros to pack/unpack a bignum's fields in a Tcl_Obj internal rep
  */
 
 #define PACK_BIGNUM(bignum, objPtr) \
     if ((bignum).used > 0x7fff) {                                       \
-	mp_int *temp = (void *) Tcl_Alloc(sizeof(mp_int));     \
+	mp_int *temp = (void *) ckalloc(sizeof(mp_int));     \
 	*temp = bignum;                                                 \
 	(objPtr)->internalRep.twoPtrValue.ptr1 = temp;                 \
 	(objPtr)->internalRep.twoPtrValue.ptr2 = INT2PTR(-1); \
     } else {                                                            \
 	if ((bignum).alloc > 0x7fff) {                                  \
 	    mp_shrink(&(bignum));                                       \
 	}                                                               \
-	(objPtr)->internalRep.twoPtrValue.ptr1 = (bignum).dp;           \
+	(objPtr)->internalRep.twoPtrValue.ptr1 = (void *) (bignum).dp; \
 	(objPtr)->internalRep.twoPtrValue.ptr2 = INT2PTR( ((bignum).sign << 30) \
 		| ((bignum).alloc << 15) | ((bignum).used));            \
     }
 
 /*
@@ -198,10 +198,13 @@
 static int		ParseBoolean(Tcl_Obj *objPtr);
 static int		SetDoubleFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr);
 static int		SetIntFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr);
 static void		UpdateStringOfDouble(Tcl_Obj *objPtr);
 static void		UpdateStringOfInt(Tcl_Obj *objPtr);
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9 && !defined(TCL_WIDE_INT_IS_LONG)
+static void		UpdateStringOfOldInt(Tcl_Obj *objPtr);
+#endif
 static void		FreeBignum(Tcl_Obj *objPtr);
 static void		DupBignum(Tcl_Obj *objPtr, Tcl_Obj *copyPtr);
 static void		UpdateStringOfBignum(Tcl_Obj *objPtr);
 static int		GetBignumFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 			    int copy, mp_int *bignumValue);
@@ -226,13 +229,22 @@
  * means of functions that can be invoked by generic object code. See also
  * tclStringObj.c, tclListObj.c, tclByteCode.c for other type manager
  * implementations.
  */
 
-const Tcl_ObjType tclBooleanType = {
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+static const Tcl_ObjType oldBooleanType = {
     "boolean",			/* name */
     NULL,			/* freeIntRepProc */
+    NULL,			/* dupIntRepProc */
+    NULL,			/* updateStringProc */
+    TclSetBooleanFromAny		/* setFromAnyProc */
+};
+#endif
+const Tcl_ObjType tclBooleanType = {
+    "booleanString",		/* name */
+    NULL,			/* freeIntRepProc */
     NULL,			/* dupIntRepProc */
     NULL,			/* updateStringProc */
     TclSetBooleanFromAny		/* setFromAnyProc */
 };
 const Tcl_ObjType tclDoubleType = {
@@ -241,16 +253,29 @@
     NULL,			/* dupIntRepProc */
     UpdateStringOfDouble,	/* updateStringProc */
     SetDoubleFromAny		/* setFromAnyProc */
 };
 const Tcl_ObjType tclIntType = {
+#if defined(TCL_NO_DEPRECATED) || TCL_MAJOR_VERSION > 8 || defined(TCL_WIDE_INT_IS_LONG)
     "int",			/* name */
+#else
+    "wideInt",		/* name, keeping maximum compatibility with Tcl 8.6 on 32-bit platforms*/
+#endif
     NULL,			/* freeIntRepProc */
     NULL,			/* dupIntRepProc */
     UpdateStringOfInt,		/* updateStringProc */
     SetIntFromAny		/* setFromAnyProc */
 };
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9 && !defined(TCL_WIDE_INT_IS_LONG)
+static const Tcl_ObjType oldIntType = {
+    "int",			/* name */
+    NULL,			/* freeIntRepProc */
+    NULL,			/* dupIntRepProc */
+    UpdateStringOfOldInt,		/* updateStringProc */
+    SetIntFromAny		/* setFromAnyProc */
+};
+#endif
 const Tcl_ObjType tclBignumType = {
     "bignum",			/* name */
     FreeBignum,			/* freeIntRepProc */
     DupBignum,			/* dupIntRepProc */
     UpdateStringOfBignum,	/* updateStringProc */
@@ -312,21 +337,21 @@
     Command *cmdPtr;		/* A cached Command pointer. */
     Namespace *refNsPtr;	/* Points to the namespace containing the
 				 * reference (not the namespace that contains
 				 * the referenced command). NULL if the name
 				 * is fully qualified.*/
-    size_t refNsId;		/* refNsPtr's unique namespace id. Used to
+    unsigned long refNsId;		/* refNsPtr's unique namespace id. Used to
 				 * verify that refNsPtr is still valid (e.g.,
 				 * it's possible that the cmd's containing
 				 * namespace was deleted and a new one created
 				 * at the same address). */
-    size_t refNsCmdEpoch;	/* Value of the referencing namespace's
+    unsigned int refNsCmdEpoch;	/* Value of the referencing namespace's
 				 * cmdRefEpoch when the pointer was cached.
 				 * Before using the cached pointer, we check
 				 * if the namespace's epoch was incremented;
 				 * if so, this cached pointer is invalid. */
-    size_t cmdEpoch;		/* Value of the command's cmdEpoch when this
+    unsigned int cmdEpoch; /* Value of the command's cmdEpoch when this
 				 * pointer was cached. Before using the cached
 				 * pointer, we check if the cmd's epoch was
 				 * incremented; if so, the cmd was renamed,
 				 * deleted, hidden, or exposed, and so the
 				 * pointer is invalid. */
@@ -370,10 +395,19 @@
     Tcl_RegisterObjType(&tclDictType);
     Tcl_RegisterObjType(&tclByteCodeType);
     Tcl_RegisterObjType(&tclCmdNameType);
     Tcl_RegisterObjType(&tclRegexpType);
     Tcl_RegisterObjType(&tclProcBodyType);
+
+    /* For backward compatibility only ... */
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+    Tcl_RegisterObjType(&tclIntType);
+#if !defined(TCL_WIDE_INT_IS_LONG)
+    Tcl_RegisterObjType(&oldIntType);
+#endif
+    Tcl_RegisterObjType(&oldBooleanType);
+#endif
 
 #ifdef TCL_COMPILE_STATS
     Tcl_MutexLock(&tclObjMutex);
     tclObjsAlloced = 0;
     tclObjsFreed = 0;
@@ -418,16 +452,16 @@
 	for (hPtr = Tcl_FirstHashEntry(tablePtr, &hSearch);
 		hPtr != NULL; hPtr = Tcl_NextHashEntry(&hSearch)) {
 	    ObjData *objData = Tcl_GetHashValue(hPtr);
 
 	    if (objData != NULL) {
-		Tcl_Free(objData);
+		ckfree(objData);
 	    }
 	}
 
 	Tcl_DeleteHashTable(tablePtr);
-	Tcl_Free(tablePtr);
+	ckfree(tablePtr);
 	tsdPtr->objThreadMap = NULL;
     }
 #endif
 }
 
@@ -499,11 +533,11 @@
      */
 
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     if (!tsdPtr->lineCLPtr) {
-	tsdPtr->lineCLPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+	tsdPtr->lineCLPtr = ckalloc(sizeof(Tcl_HashTable));
 	Tcl_InitHashTable(tsdPtr->lineCLPtr, TCL_ONE_WORD_KEYS);
 	Tcl_CreateThreadExitHandler(TclThreadFinalizeContLines,NULL);
     }
     return tsdPtr;
 }
@@ -534,11 +568,11 @@
 {
     int newEntry;
     ThreadSpecificData *tsdPtr = TclGetContLineTable();
     Tcl_HashEntry *hPtr =
 	    Tcl_CreateHashEntry(tsdPtr->lineCLPtr, objPtr, &newEntry);
-    ContLineLoc *clLocPtr = Tcl_Alloc(sizeof(ContLineLoc) + num*sizeof(int));
+    ContLineLoc *clLocPtr = ckalloc(sizeof(ContLineLoc) + num*sizeof(int));
 
     if (!newEntry) {
 	/*
 	 * We're entering ContLineLoc data for the same value more than one
 	 * time. Taking care not to leak the old entry.
@@ -558,11 +592,11 @@
 	 * returning the stored entry would rebase them a second time, or
 	 * more, hosing the data. It is easier to simply replace, as we are
 	 * doing.
 	 */
 
-	Tcl_Free(Tcl_GetHashValue(hPtr));
+	ckfree(Tcl_GetHashValue(hPtr));
     }
 
     clLocPtr->num = num;
     memcpy(&clLocPtr->loc, loc, num*sizeof(int));
     clLocPtr->loc[num] = CLL_END;       /* Sentinel */
@@ -594,12 +628,11 @@
 TclContinuationsEnterDerived(
     Tcl_Obj *objPtr,
     int start,
     int *clNext)
 {
-    size_t length;
-    int end, num;
+    int length, end, num;
     int *wordCLLast = clNext;
 
     /*
      * We have to handle invisible continuations lines here as well, despite
      * the code we have in TclSubstTokens (TST) for that. Why ?  Nesting. If
@@ -622,11 +655,11 @@
     /*
      * First compute the range of the word within the script. (Is there a
      * better way which doesn't shimmer?)
      */
 
-    (void)TclGetStringFromObj(objPtr, &length);
+    TclGetStringFromObj(objPtr, &length);
     end = start + length;       /* First char after the word */
 
     /*
      * Then compute the table slice covering the range of the word.
      */
@@ -763,24 +796,24 @@
     Tcl_HashEntry *hPtr;
     Tcl_HashSearch hSearch;
 
     for (hPtr = Tcl_FirstHashEntry(tsdPtr->lineCLPtr, &hSearch);
 	    hPtr != NULL; hPtr = Tcl_NextHashEntry(&hSearch)) {
-	Tcl_Free(Tcl_GetHashValue(hPtr));
+	ckfree(Tcl_GetHashValue(hPtr));
 	Tcl_DeleteHashEntry(hPtr);
     }
     Tcl_DeleteHashTable(tsdPtr->lineCLPtr);
-    Tcl_Free(tsdPtr->lineCLPtr);
+    ckfree(tsdPtr->lineCLPtr);
     tsdPtr->lineCLPtr = NULL;
 }
 
 /*
  *--------------------------------------------------------------
  *
  * Tcl_RegisterObjType --
  *
- *	This function is called to register a new Tcl object type in the table
+ *	This function is called to a new Tcl object type in the table
  *	of all object types supported by Tcl.
  *
  * Results:
  *	None.
  *
@@ -835,11 +868,11 @@
     Tcl_Interp *interp,		/* Interpreter used for error reporting. */
     Tcl_Obj *objPtr)		/* Points to the Tcl object onto which the
 				 * name of each registered type is appended as
 				 * a list element. */
 {
-    register Tcl_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     Tcl_HashSearch search;
     int numElems;
 
     /*
      * Get the test for a valid list out of the way first.
@@ -883,11 +916,11 @@
 
 const Tcl_ObjType *
 Tcl_GetObjType(
     const char *typeName)	/* Name of Tcl object type to look up. */
 {
-    register Tcl_HashEntry *hPtr;
+    Tcl_HashEntry *hPtr;
     const Tcl_ObjType *typePtr = NULL;
 
     Tcl_MutexLock(&tableMutex);
     hPtr = Tcl_FindHashEntry(&typeTable, typeName);
     if (hPtr != NULL) {
@@ -973,11 +1006,11 @@
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     tablePtr = tsdPtr->objThreadMap;
 
     if (tablePtr != NULL) {
-	fprintf(outFile, "total objects: %" TCL_Z_MODIFIER "u\n", tablePtr->numEntries);
+	fprintf(outFile, "total objects: %d\n", tablePtr->numEntries);
 	for (hPtr = Tcl_FirstHashEntry(tablePtr, &hSearch); hPtr != NULL;
 		hPtr = Tcl_NextHashEntry(&hSearch)) {
 	    ObjData *objData = Tcl_GetHashValue(hPtr);
 
 	    if (objData != NULL) {
@@ -1013,14 +1046,14 @@
  */
 
 #ifdef TCL_MEM_DEBUG
 void
 TclDbInitNewObj(
-    register Tcl_Obj *objPtr,
-    register const char *file,	/* The name of the source file calling this
+    Tcl_Obj *objPtr,
+    const char *file,	/* The name of the source file calling this
 				 * function; used for debugging. */
-    register int line)		/* Line number in the source file; used for
+    int line)		/* Line number in the source file; used for
 				 * debugging. */
 {
     objPtr->refCount = 0;
     objPtr->typePtr = NULL;
     TclInitStringRep(objPtr, NULL, 0);
@@ -1037,11 +1070,11 @@
 	int isNew;
 	ObjData *objData;
 	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
 	if (tsdPtr->objThreadMap == NULL) {
-	    tsdPtr->objThreadMap = Tcl_Alloc(sizeof(Tcl_HashTable));
+	    tsdPtr->objThreadMap = ckalloc(sizeof(Tcl_HashTable));
 	    Tcl_InitHashTable(tsdPtr->objThreadMap, TCL_ONE_WORD_KEYS);
 	}
 	tablePtr = tsdPtr->objThreadMap;
 	hPtr = Tcl_CreateHashEntry(tablePtr, objPtr, &isNew);
 	if (!isNew) {
@@ -1050,11 +1083,11 @@
 
 	/*
 	 * Record the debugging information.
 	 */
 
-	objData = Tcl_Alloc(sizeof(ObjData));
+	objData = ckalloc(sizeof(ObjData));
 	objData->objPtr = objPtr;
 	objData->file = file;
 	objData->line = line;
 	Tcl_SetHashValue(hPtr, objData);
     }
@@ -1100,11 +1133,11 @@
 #else /* if not TCL_MEM_DEBUG */
 
 Tcl_Obj *
 Tcl_NewObj(void)
 {
-    register Tcl_Obj *objPtr;
+    Tcl_Obj *objPtr;
 
     /*
      * Use the macro defined in tclInt.h - it will use the correct allocator.
      */
 
@@ -1142,16 +1175,16 @@
 
 #ifdef TCL_MEM_DEBUG
 
 Tcl_Obj *
 Tcl_DbNewObj(
-    register const char *file,	/* The name of the source file calling this
+    const char *file,	/* The name of the source file calling this
 				 * function; used for debugging. */
-    register int line)		/* Line number in the source file; used for
+    int line)		/* Line number in the source file; used for
 				 * debugging. */
 {
-    register Tcl_Obj *objPtr;
+    Tcl_Obj *objPtr;
 
     /*
      * Use the macro defined in tclInt.h - it will use the correct allocator.
      */
 
@@ -1175,11 +1208,11 @@
  *----------------------------------------------------------------------
  *
  * TclAllocateFreeObjects --
  *
  *	Function to allocate a number of free Tcl_Objs. This is done using a
- *	single Tcl_Alloc to reduce the overhead for Tcl_Obj allocation.
+ *	single ckalloc to reduce the overhead for Tcl_Obj allocation.
  *
  *	Assumes mutex is held.
  *
  * Results:
  *	None.
@@ -1197,23 +1230,23 @@
 void
 TclAllocateFreeObjects(void)
 {
     size_t bytesToAlloc = (OBJS_TO_ALLOC_EACH_TIME * sizeof(Tcl_Obj));
     char *basePtr;
-    register Tcl_Obj *prevPtr, *objPtr;
-    register int i;
+    Tcl_Obj *prevPtr, *objPtr;
+    int i;
 
     /*
      * This has been noted by Purify to be a potential leak. The problem is
      * that Tcl, when not TCL_MEM_DEBUG compiled, keeps around all allocated
      * Tcl_Obj's, pointed to by tclFreeObjList, when freed instead of actually
-     * freeing the memory. TclFinalizeObjects() does not Tcl_Free() this memory,
+     * freeing the memory. TclFinalizeObjects() does not ckfree() this memory,
      * but leaves it to Tcl's memory subsystem finalization to release it.
      * Purify apparently can't figure that out, and fires a false alarm.
      */
 
-    basePtr = Tcl_Alloc(bytesToAlloc);
+    basePtr = ckalloc(bytesToAlloc);
 
     prevPtr = NULL;
     objPtr = (Tcl_Obj *) basePtr;
     for (i = 0; i < OBJS_TO_ALLOC_EACH_TIME; i++) {
 	objPtr->internalRep.twoPtrValue.ptr1 = prevPtr;
@@ -1249,13 +1282,13 @@
  */
 
 #ifdef TCL_MEM_DEBUG
 void
 TclFreeObj(
-    register Tcl_Obj *objPtr)	/* The object to be freed. */
+    Tcl_Obj *objPtr)	/* The object to be freed. */
 {
-    register const Tcl_ObjType *typePtr = objPtr->typePtr;
+    const Tcl_ObjType *typePtr = objPtr->typePtr;
 
     /*
      * This macro declares a variable, so must come here...
      */
 
@@ -1284,11 +1317,11 @@
 	     */
 
 	    ObjData *objData = Tcl_GetHashValue(hPtr);
 
 	    if (objData != NULL) {
-		Tcl_Free(objData);
+		ckfree(objData);
 	    }
 
 	    Tcl_DeleteHashEntry(hPtr);
 	}
     }
@@ -1298,28 +1331,28 @@
      * Check for a double free of the same value.  This is slightly tricky
      * because it is customary to free a Tcl_Obj when its refcount falls
      * either from 1 to 0, or from 0 to -1.  Falling from -1 to -2, though,
      * and so on, is always a sign of a botch in the caller.
      */
-    if (objPtr->refCount == (size_t)-2) {
+    if (objPtr->refCount < -1) {
 	Tcl_Panic("Reference count for %p was negative", objPtr);
     }
     /*
      * Now, in case we just approved drop from 1 to 0 as acceptable, make
      * sure we do not accept a second free when falling from 0 to -1.
      * Skip that possibility so any double free will trigger the panic.
      */
-    objPtr->refCount = TCL_AUTO_LENGTH;
+    objPtr->refCount = -1;
 
     /*
      * Invalidate the string rep first so we can use the bytes value for our
      * pointer chain, and signal an obj deletion (as opposed to shimmering)
-     * with 'length == TCL_AUTO_LENGTH'.
+     * with 'length == -1'.
      */
 
     TclInvalidateStringRep(objPtr);
-    objPtr->length = TCL_AUTO_LENGTH;
+    objPtr->length = -1;
 
     if (ObjDeletePending(context)) {
 	PushObjToDelete(context, objPtr);
     } else {
 	TCL_DTRACE_OBJ_FREE(objPtr);
@@ -1328,11 +1361,11 @@
 	    typePtr->freeIntRepProc(objPtr);
 	    ObjDeletionUnlock(context);
 	}
 
 	Tcl_MutexLock(&tclObjMutex);
-	Tcl_Free(objPtr);
+	ckfree(objPtr);
 	Tcl_MutexUnlock(&tclObjMutex);
 	TclIncrObjsFreed();
 	ObjDeletionLock(context);
 	while (ObjOnStack(context)) {
 	    Tcl_Obj *objToFree;
@@ -1340,11 +1373,11 @@
 	    PopObjToDelete(context, objToFree);
 	    TCL_DTRACE_OBJ_FREE(objToFree);
 	    TclFreeIntRep(objToFree);
 
 	    Tcl_MutexLock(&tclObjMutex);
-	    Tcl_Free(objToFree);
+	    ckfree(objToFree);
 	    Tcl_MutexUnlock(&tclObjMutex);
 	    TclIncrObjsFreed();
 	}
 	ObjDeletionUnlock(context);
     }
@@ -1364,30 +1397,30 @@
         Tcl_HashEntry *hPtr;
 
 	if (tsdPtr->lineCLPtr) {
             hPtr = Tcl_FindHashEntry(tsdPtr->lineCLPtr, objPtr);
 	    if (hPtr) {
-		Tcl_Free(Tcl_GetHashValue(hPtr));
+		ckfree(Tcl_GetHashValue(hPtr));
 		Tcl_DeleteHashEntry(hPtr);
 	    }
 	}
     }
 }
 #else /* TCL_MEM_DEBUG */
 
 void
 TclFreeObj(
-    register Tcl_Obj *objPtr)	/* The object to be freed. */
+    Tcl_Obj *objPtr)	/* The object to be freed. */
 {
     /*
      * Invalidate the string rep first so we can use the bytes value for our
      * pointer chain, and signal an obj deletion (as opposed to shimmering)
      * with 'length == -1'.
      */
 
     TclInvalidateStringRep(objPtr);
-    objPtr->length = TCL_AUTO_LENGTH;
+    objPtr->length = -1;
 
     if (!objPtr->typePtr || !objPtr->typePtr->freeIntRepProc) {
 	/*
 	 * objPtr can be freed safely, as it will not attempt to free any
 	 * other objects: it will not cause recursive calls to this function.
@@ -1455,11 +1488,11 @@
         Tcl_HashEntry *hPtr;
 
 	if (tsdPtr->lineCLPtr) {
             hPtr = Tcl_FindHashEntry(tsdPtr->lineCLPtr, objPtr);
 	    if (hPtr) {
-		Tcl_Free(Tcl_GetHashValue(hPtr));
+		ckfree(Tcl_GetHashValue(hPtr));
 		Tcl_DeleteHashEntry(hPtr);
 	    }
 	}
     }
 }
@@ -1485,11 +1518,11 @@
 
 int
 TclObjBeingDeleted(
     Tcl_Obj *objPtr)
 {
-    return (objPtr->length == TCL_AUTO_LENGTH);
+    return (objPtr->length == -1);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1583,11 +1616,11 @@
  *----------------------------------------------------------------------
  */
 
 char *
 Tcl_GetString(
-    register Tcl_Obj *objPtr)	/* Object whose string rep byte pointer should
+    Tcl_Obj *objPtr)	/* Object whose string rep byte pointer should
 				 * be returned. */
 {
     if (objPtr->bytes == NULL) {
 	/*
 	 * Note we do not check for objPtr->typePtr == NULL.  An invariant
@@ -1604,11 +1637,11 @@
 	     */
 	    Tcl_Panic("UpdateStringProc should not be invoked for type %s",
 		    objPtr->typePtr->name);
 	}
 	objPtr->typePtr->updateStringProc(objPtr);
-	if (objPtr->bytes == NULL || objPtr->length == TCL_AUTO_LENGTH
+	if (objPtr->bytes == NULL || objPtr->length < 0
 		|| objPtr->bytes[objPtr->length] != '\0') {
 	    Tcl_Panic("UpdateStringProc for type '%s' "
 		    "failed to create a valid string rep",
 		    objPtr->typePtr->name);
 	}
@@ -1639,13 +1672,13 @@
  *----------------------------------------------------------------------
  */
 
 char *
 Tcl_GetStringFromObj(
-    register Tcl_Obj *objPtr,	/* Object whose string rep byte pointer should
+    Tcl_Obj *objPtr,	/* Object whose string rep byte pointer should
 				 * be returned. */
-    register int *lengthPtr)	/* If non-NULL, the location where the string
+    int *lengthPtr)	/* If non-NULL, the location where the string
 				 * rep's byte array length should * be stored.
 				 * If NULL, no length is stored. */
 {
     if (objPtr->bytes == NULL) {
 	/*
@@ -1663,19 +1696,19 @@
 	     */
 	    Tcl_Panic("UpdateStringProc should not be invoked for type %s",
 		    objPtr->typePtr->name);
 	}
 	objPtr->typePtr->updateStringProc(objPtr);
-	if (objPtr->bytes == NULL || objPtr->length == TCL_AUTO_LENGTH
+	if (objPtr->bytes == NULL || objPtr->length < 0
 		|| objPtr->bytes[objPtr->length] != '\0') {
 	    Tcl_Panic("UpdateStringProc for type '%s' "
 		    "failed to create a valid string rep",
 		    objPtr->typePtr->name);
 	}
     }
     if (lengthPtr != NULL) {
-	*lengthPtr = (objPtr->length < INT_MAX)? objPtr->length: INT_MAX;
+	*lengthPtr = objPtr->length;
     }
     return objPtr->bytes;
 }
 
 /*
@@ -1685,28 +1718,28 @@
  *
  *	This function is called in several configurations to provide all
  *	the tools needed to set an object's string representation. The
  *	function is determined by the arguments.
  *
- *	(objPtr->bytes != NULL && bytes != NULL) || (numBytes == -1)
+ *	(objPtr->bytes != NULL && bytes != NULL) || (numBytes < 0)
  *	    Invalid call -- panic!
  *
- *	objPtr->bytes == NULL && bytes == NULL && numBytes != -1
+ *	objPtr->bytes == NULL && bytes == NULL && numBytes >= 0
  *	    Allocation only - allocate space for (numBytes+1) chars.
  *	    store in objPtr->bytes and return. Also sets
  *	    objPtr->length to 0 and objPtr->bytes[0] to NUL.
  *
- *	objPtr->bytes == NULL && bytes != NULL && numBytes != -1
+ *	objPtr->bytes == NULL && bytes != NULL && numBytes >= 0
  *	    Allocate and copy. bytes is assumed to point to chars to
  *	    copy into the string rep. objPtr->length = numBytes. Allocate
  *	    array of (numBytes + 1) chars. store in objPtr->bytes. Copy
  *	    numBytes chars from bytes to objPtr->bytes; Set
  *	    objPtr->bytes[numBytes] to NUL and return objPtr->bytes.
  *	    Caller must guarantee there are numBytes chars at bytes to
  *	    be copied.
  *
- *	objPtr->bytes != NULL && bytes == NULL && numBytes != -1
+ *	objPtr->bytes != NULL && bytes == NULL && numBytes >= 0
  *	    Truncate.  Set objPtr->length to numBytes and
  *	    objPr->bytes[numBytes] to NUL.  Caller has to guarantee
  *	    that a prior allocating call allocated enough bytes for
  *	    this to be valid. Return objPtr->bytes.
  *
@@ -1724,35 +1757,39 @@
 
 char *
 Tcl_InitStringRep(
     Tcl_Obj *objPtr,	/* Object whose string rep is to be set */
     const char *bytes,
-    size_t numBytes)
+    unsigned int numBytes)
 {
     assert(objPtr->bytes == NULL || bytes == NULL);
+
+    if (numBytes > INT_MAX) {
+	Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
+    }
 
     /* Allocate */
     if (objPtr->bytes == NULL) {
 	/* Allocate only as empty - extend later if bytes copied */
 	objPtr->length = 0;
 	if (numBytes) {
-	    objPtr->bytes = Tcl_AttemptAlloc(numBytes + 1);
+	    objPtr->bytes = attemptckalloc(numBytes + 1);
 	    if (objPtr->bytes == NULL) {
 		return NULL;
 	    }
 	    if (bytes) {
 		/* Copy */
 		memcpy(objPtr->bytes, bytes, numBytes);
-		objPtr->length = numBytes;
+		objPtr->length = (int) numBytes;
 	    }
 	} else {
 	    TclInitStringRep(objPtr, NULL, 0);
 	}
     } else {
 	/* objPtr->bytes != NULL bytes == NULL - Truncate */
-	objPtr->bytes = Tcl_Realloc(objPtr->bytes, numBytes + 1);
-	objPtr->length = numBytes;
+	objPtr->bytes = ckrealloc(objPtr->bytes, numBytes + 1);
+	objPtr->length = (int)numBytes;
     }
 
     /* Terminate */
     objPtr->bytes[objPtr->length] = '\0';
 
@@ -1777,11 +1814,11 @@
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_InvalidateStringRep(
-    register Tcl_Obj *objPtr)	/* Object whose string rep byte pointer should
+    Tcl_Obj *objPtr)	/* Object whose string rep byte pointer should
 				 * be freed. */
 {
     TclInvalidateStringRep(objPtr);
 }
 
@@ -1897,10 +1934,151 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
+ * Tcl_NewBooleanObj --
+ *
+ *	This function is normally called when not debugging: i.e., when
+ *	TCL_MEM_DEBUG is not defined. It creates a new Tcl_Obj and
+ *	initializes it from the argument boolean value. A nonzero "boolValue"
+ *	is coerced to 1.
+ *
+ *	When TCL_MEM_DEBUG is defined, this function just returns the result
+ *	of calling the debugging version Tcl_DbNewLongObj.
+ *
+ * Results:
+ *	The newly created object is returned. This object will have an invalid
+ *	string representation. The returned object has ref count 0.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#undef Tcl_NewBooleanObj
+#ifdef TCL_MEM_DEBUG
+
+Tcl_Obj *
+Tcl_NewBooleanObj(
+    int boolValue)	/* Boolean used to initialize new object. */
+{
+    return Tcl_DbNewWideIntObj(boolValue!=0, "unknown", 0);
+}
+
+#else /* if not TCL_MEM_DEBUG */
+
+Tcl_Obj *
+Tcl_NewBooleanObj(
+    int boolValue)	/* Boolean used to initialize new object. */
+{
+    Tcl_Obj *objPtr;
+
+    TclNewIntObj(objPtr, boolValue!=0);
+    return objPtr;
+}
+#endif /* TCL_MEM_DEBUG */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_DbNewBooleanObj --
+ *
+ *	This function is normally called when debugging: i.e., when
+ *	TCL_MEM_DEBUG is defined. It creates new boolean objects. It is the
+ *	same as the Tcl_NewBooleanObj function above except that it calls
+ *	Tcl_DbCkalloc directly with the file name and line number from its
+ *	caller. This simplifies debugging since then the [memory active]
+ *	command will report the correct file name and line number when
+ *	reporting objects that haven't been freed.
+ *
+ *	When TCL_MEM_DEBUG is not defined, this function just returns the
+ *	result of calling Tcl_NewBooleanObj.
+ *
+ * Results:
+ *	The newly created object is returned. This object will have an invalid
+ *	string representation. The returned object has ref count 0.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_DbNewBooleanObj
+#ifdef TCL_MEM_DEBUG
+
+Tcl_Obj *
+Tcl_DbNewBooleanObj(
+    int boolValue,	/* Boolean used to initialize new object. */
+    const char *file,		/* The name of the source file calling this
+				 * function; used for debugging. */
+    int line)			/* Line number in the source file; used for
+				 * debugging. */
+{
+    Tcl_Obj *objPtr;
+
+    TclDbNewObj(objPtr, file, line);
+    /* Optimized TclInvalidateStringRep() */
+    objPtr->bytes = NULL;
+
+    objPtr->internalRep.wideValue = (boolValue != 0);
+    objPtr->typePtr = &tclIntType;
+    return objPtr;
+}
+
+#else /* if not TCL_MEM_DEBUG */
+
+Tcl_Obj *
+Tcl_DbNewBooleanObj(
+    int boolValue,	/* Boolean used to initialize new object. */
+    const char *file,		/* The name of the source file calling this
+				 * function; used for debugging. */
+    int line)			/* Line number in the source file; used for
+				 * debugging. */
+{
+    return Tcl_NewBooleanObj(boolValue);
+}
+#endif /* TCL_MEM_DEBUG */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetBooleanObj --
+ *
+ *	Modify an object to be a boolean object and to have the specified
+ *	boolean value. A nonzero "boolValue" is coerced to 1.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The object's old string rep, if any, is freed. Also, any old internal
+ *	rep is freed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#undef Tcl_SetBooleanObj
+void
+Tcl_SetBooleanObj(
+    Tcl_Obj *objPtr,	/* Object whose internal rep to init. */
+    int boolValue)	/* Boolean used to set object's value. */
+{
+    if (Tcl_IsShared(objPtr)) {
+	Tcl_Panic("%s called with shared object", "Tcl_SetBooleanObj");
+    }
+
+    TclSetIntObj(objPtr, boolValue!=0);
+}
+#endif /* TCL_NO_DEPRECATED */
+
+/*
+ *----------------------------------------------------------------------
+ *
  * Tcl_GetBooleanFromObj --
  *
  *	Attempt to return a boolean from the Tcl object "objPtr". This
  *	includes conversion from any of Tcl's numeric types.
  *
@@ -1916,17 +2094,21 @@
  */
 
 int
 Tcl_GetBooleanFromObj(
     Tcl_Interp *interp,         /* Used for error reporting if not NULL. */
-    register Tcl_Obj *objPtr,	/* The object from which to get boolean. */
-    register int *boolPtr)	/* Place to store resulting boolean. */
+    Tcl_Obj *objPtr,	/* The object from which to get boolean. */
+    int *boolPtr)	/* Place to store resulting boolean. */
 {
     do {
-	if (objPtr->typePtr == &tclIntType || objPtr->typePtr == &tclBooleanType) {
+	if (objPtr->typePtr == &tclIntType) {
 	    *boolPtr = (objPtr->internalRep.wideValue != 0);
 	    return TCL_OK;
+	}
+	if (objPtr->typePtr == &tclBooleanType) {
+	    *boolPtr = objPtr->internalRep.longValue != 0;
+	    return TCL_OK;
 	}
 	if (objPtr->typePtr == &tclDoubleType) {
 	    /*
 	     * Caution: Don't be tempted to check directly for the "double"
 	     * Tcl_ObjType and then compare the intrep to 0.0. This isn't
@@ -1965,19 +2147,24 @@
  *	conversion, an error message is left in the interpreter's result
  *	unless "interp" is NULL.
  *
  * Side effects:
  *	If no error occurs, an integer 1 or 0 is stored as "objPtr"s internal
- *	representation and the type of "objPtr" is set to boolean or int.
+ *	representation and the type of "objPtr" is set to boolean or int/wideInt.
+ *
+ *  Warning: If the returned type is "wideInt" (32-bit platforms) and your
+ *  platform is bigendian, you cannot use internalRep.longValue to distinguish
+ *  between false and true. On Windows and most other platforms this still will
+ *  work fine, but basically it is non-portable.
  *
  *----------------------------------------------------------------------
  */
 
 int
 TclSetBooleanFromAny(
     Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
-    register Tcl_Obj *objPtr)	/* The object to convert. */
+    Tcl_Obj *objPtr)	/* The object to convert. */
 {
     /*
      * For some "pure" numeric Tcl_ObjTypes (no string rep), we can determine
      * whether a boolean conversion is possible without generating the string
      * rep.
@@ -2004,11 +2191,11 @@
 	return TCL_OK;
     }
 
   badBoolean:
     if (interp != NULL) {
-	size_t length;
+	int length;
 	const char *str = TclGetStringFromObj(objPtr, &length);
 	Tcl_Obj *msg;
 
 	TclNewLiteralStringObj(msg, "expected boolean value but got \"");
 	Tcl_AppendLimitedToObj(msg, str, length, 50, "");
@@ -2019,16 +2206,16 @@
     return TCL_ERROR;
 }
 
 static int
 ParseBoolean(
-    register Tcl_Obj *objPtr)	/* The object to parse/convert. */
+    Tcl_Obj *objPtr)	/* The object to parse/convert. */
 {
     int newBool;
     char lowerCase[6];
-    size_t i, length;
-    const char *str = TclGetStringFromObj(objPtr, &length);
+    const char *str = TclGetString(objPtr);
+    size_t i, length = objPtr->length;
 
     if ((length == 0) || (length > 5)) {
 	/*
          * Longest valid boolean string rep. is "false".
          */
@@ -2123,11 +2310,11 @@
      * Tcl_GetStringFromObj, to use that old internalRep.
      */
 
   goodBoolean:
     TclFreeIntRep(objPtr);
-    objPtr->internalRep.wideValue = newBool;
+    objPtr->internalRep.longValue = newBool;
     objPtr->typePtr = &tclBooleanType;
     return TCL_OK;
 
   numericBoolean:
     TclFreeIntRep(objPtr);
@@ -2161,22 +2348,22 @@
 #ifdef TCL_MEM_DEBUG
 #undef Tcl_NewDoubleObj
 
 Tcl_Obj *
 Tcl_NewDoubleObj(
-    register double dblValue)	/* Double used to initialize the object. */
+    double dblValue)	/* Double used to initialize the object. */
 {
     return Tcl_DbNewDoubleObj(dblValue, "unknown", 0);
 }
 
 #else /* if not TCL_MEM_DEBUG */
 
 Tcl_Obj *
 Tcl_NewDoubleObj(
-    register double dblValue)	/* Double used to initialize the object. */
+    double dblValue)	/* Double used to initialize the object. */
 {
-    register Tcl_Obj *objPtr;
+    Tcl_Obj *objPtr;
 
     TclNewDoubleObj(objPtr, dblValue);
     return objPtr;
 }
 #endif /* if TCL_MEM_DEBUG */
@@ -2209,17 +2396,17 @@
 
 #ifdef TCL_MEM_DEBUG
 
 Tcl_Obj *
 Tcl_DbNewDoubleObj(
-    register double dblValue,	/* Double used to initialize the object. */
+    double dblValue,	/* Double used to initialize the object. */
     const char *file,		/* The name of the source file calling this
 				 * function; used for debugging. */
     int line)			/* Line number in the source file; used for
 				 * debugging. */
 {
-    register Tcl_Obj *objPtr;
+    Tcl_Obj *objPtr;
 
     TclDbNewObj(objPtr, file, line);
     /* Optimized TclInvalidateStringRep() */
     objPtr->bytes = NULL;
 
@@ -2230,11 +2417,11 @@
 
 #else /* if not TCL_MEM_DEBUG */
 
 Tcl_Obj *
 Tcl_DbNewDoubleObj(
-    register double dblValue,	/* Double used to initialize the object. */
+    double dblValue,	/* Double used to initialize the object. */
     const char *file,		/* The name of the source file calling this
 				 * function; used for debugging. */
     int line)			/* Line number in the source file; used for
 				 * debugging. */
 {
@@ -2260,12 +2447,12 @@
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_SetDoubleObj(
-    register Tcl_Obj *objPtr,	/* Object whose internal rep to init. */
-    register double dblValue)	/* Double used to set the object's value. */
+    Tcl_Obj *objPtr,	/* Object whose internal rep to init. */
+    double dblValue)	/* Double used to set the object's value. */
 {
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetDoubleObj");
     }
 
@@ -2293,12 +2480,12 @@
  */
 
 int
 Tcl_GetDoubleFromObj(
     Tcl_Interp *interp,         /* Used for error reporting if not NULL. */
-    register Tcl_Obj *objPtr,	/* The object from which to get a double. */
-    register double *dblPtr)	/* Place to store resulting double. */
+    Tcl_Obj *objPtr,	/* The object from which to get a double. */
+    double *dblPtr)	/* Place to store resulting double. */
 {
     do {
 	if (objPtr->typePtr == &tclDoubleType) {
 	    if (TclIsNaN(objPtr->internalRep.doubleValue)) {
 		if (interp != NULL) {
@@ -2348,11 +2535,11 @@
  */
 
 static int
 SetDoubleFromAny(
     Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
-    register Tcl_Obj *objPtr)	/* The object to convert. */
+    Tcl_Obj *objPtr)	/* The object to convert. */
 {
     return TclParseNumber(interp, objPtr, "floating-point number", NULL, -1,
 	    NULL, 0);
 }
 
@@ -2360,11 +2547,12 @@
  *----------------------------------------------------------------------
  *
  * UpdateStringOfDouble --
  *
  *	Update the string representation for a double-precision floating point
- *	object. Note: This function does not free an
+ *	object. This must obey the current tcl_precision value for
+ *	double-to-string conversions. Note: This function does not free an
  *	existing old string rep so storage will be lost if this has not
  *	already been done.
  *
  * Results:
  *	None.
@@ -2376,11 +2564,11 @@
  *----------------------------------------------------------------------
  */
 
 static void
 UpdateStringOfDouble(
-    register Tcl_Obj *objPtr)	/* Double obj with string rep to update. */
+    Tcl_Obj *objPtr)	/* Double obj with string rep to update. */
 {
     char *dst = Tcl_InitStringRep(objPtr, NULL, TCL_DOUBLE_SPACE);
 
     TclOOM(dst, TCL_DOUBLE_SPACE + 1);
 
@@ -2389,41 +2577,125 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
+ * Tcl_NewIntObj --
+ *
+ *	If a client is compiled with TCL_MEM_DEBUG defined, calls to
+ *	Tcl_NewIntObj to create a new integer object end up calling the
+ *	debugging function Tcl_DbNewLongObj instead.
+ *
+ *	Otherwise, if the client is compiled without TCL_MEM_DEBUG defined,
+ *	calls to Tcl_NewIntObj result in a call to one of the two
+ *	Tcl_NewIntObj implementations below. We provide two implementations so
+ *	that the Tcl core can be compiled to do memory debugging of the core
+ *	even if a client does not request it for itself.
+ *
+ *	Integer and long integer objects share the same "integer" type
+ *	implementation. We store all integers as longs and Tcl_GetIntFromObj
+ *	checks whether the current value of the long can be represented by an
+ *	int.
+ *
+ * Results:
+ *	The newly created object is returned. This object will have an invalid
+ *	string representation. The returned object has ref count 0.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_NewIntObj
+#ifdef TCL_MEM_DEBUG
+
+Tcl_Obj *
+Tcl_NewIntObj(
+    int intValue)	/* Int used to initialize the new object. */
+{
+    return Tcl_DbNewWideIntObj((long)intValue, "unknown", 0);
+}
+
+#else /* if not TCL_MEM_DEBUG */
+
+Tcl_Obj *
+Tcl_NewIntObj(
+    int intValue)	/* Int used to initialize the new object. */
+{
+    Tcl_Obj *objPtr;
+
+    TclNewIntObj(objPtr, intValue);
+    return objPtr;
+}
+#endif /* if TCL_MEM_DEBUG */
+#endif /* TCL_NO_DEPRECATED */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetIntObj --
+ *
+ *	Modify an object to be an integer and to have the specified integer
+ *	value.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The object's old string rep, if any, is freed. Also, any old internal
+ *	rep is freed.
+ *
+ *----------------------------------------------------------------------
+ */
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_SetIntObj
+void
+Tcl_SetIntObj(
+    Tcl_Obj *objPtr,	/* Object whose internal rep to init. */
+    int intValue)	/* Integer used to set object's value. */
+{
+    if (Tcl_IsShared(objPtr)) {
+	Tcl_Panic("%s called with shared object", "Tcl_SetIntObj");
+    }
+
+    TclSetIntObj(objPtr, intValue);
+}
+#endif /* TCL_NO_DEPRECATED */
+
+/*
+ *----------------------------------------------------------------------
+ *
  * Tcl_GetIntFromObj --
  *
- *	Retrieve the integer value of 'objPtr'.
- *
- * Value
- *
- *	TCL_OK
- *
- *	    Success.
- *
- *	TCL_ERROR
- *
- *	    An error occurred during conversion or the integral value can not
- *	    be represented as an integer (it might be too large). An error
- *	    message is left in the interpreter's result if 'interp' is not
- *	    NULL.
- *
- * Effect
- *
- *	'objPtr' is converted to an integer if necessary if it is not one
- *	already.  The conversion frees any previously-existing internal
- *	representation.
+ *	Attempt to return an int from the Tcl object "objPtr". If the object
+ *	is not already an int, an attempt will be made to convert it to one.
+ *
+ *	Integer and long integer objects share the same "integer" type
+ *	implementation. We store all integers as longs and Tcl_GetIntFromObj
+ *	checks whether the current value of the long can be represented by an
+ *	int.
+ *
+ * Results:
+ *	The return value is a standard Tcl object result. If an error occurs
+ *	during conversion or if the long integer held by the object can not be
+ *	represented by an int, an error message is left in the interpreter's
+ *	result unless "interp" is NULL.
+ *
+ * Side effects:
+ *	If the object is not already an int, the conversion will free any old
+ *	internal representation.
  *
  *----------------------------------------------------------------------
  */
 
 int
 Tcl_GetIntFromObj(
     Tcl_Interp *interp,         /* Used for error reporting if not NULL. */
-    register Tcl_Obj *objPtr,	/* The object from which to get a int. */
-    register int *intPtr)	/* Place to store resulting int. */
+    Tcl_Obj *objPtr,	/* The object from which to get a int. */
+    int *intPtr)	/* Place to store resulting int. */
 {
 #if (LONG_MAX == INT_MAX)
     return TclGetLongFromObj(interp, objPtr, (long *) intPtr);
 #else
     long l;
@@ -2489,18 +2761,31 @@
  *----------------------------------------------------------------------
  */
 
 static void
 UpdateStringOfInt(
-    register Tcl_Obj *objPtr)	/* Int object whose string rep to update. */
+    Tcl_Obj *objPtr)	/* Int object whose string rep to update. */
 {
     char *dst = Tcl_InitStringRep( objPtr, NULL, TCL_INTEGER_SPACE);
 
     TclOOM(dst, TCL_INTEGER_SPACE + 1);
     (void) Tcl_InitStringRep(objPtr, NULL,
 	    TclFormatInt(dst, objPtr->internalRep.wideValue));
 }
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9 && !defined(TCL_WIDE_INT_IS_LONG)
+static void
+UpdateStringOfOldInt(
+    Tcl_Obj *objPtr)	/* Int object whose string rep to update. */
+{
+    char *dst = Tcl_InitStringRep( objPtr, NULL, TCL_INTEGER_SPACE);
+
+    TclOOM(dst, TCL_INTEGER_SPACE + 1);
+    (void) Tcl_InitStringRep(objPtr, NULL,
+	    TclFormatInt(dst, objPtr->internalRep.longValue));
+}
+#endif
 
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_NewLongObj --
@@ -2534,24 +2819,24 @@
 #undef Tcl_NewLongObj
 #ifdef TCL_MEM_DEBUG
 
 Tcl_Obj *
 Tcl_NewLongObj(
-    register long longValue)	/* Long integer used to initialize the
+    long longValue)	/* Long integer used to initialize the
 				 * new object. */
 {
     return Tcl_DbNewWideIntObj(longValue, "unknown", 0);
 }
 
 #else /* if not TCL_MEM_DEBUG */
 
 Tcl_Obj *
 Tcl_NewLongObj(
-    register long longValue)	/* Long integer used to initialize the
+    long longValue)	/* Long integer used to initialize the
 				 * new object. */
 {
-    register Tcl_Obj *objPtr;
+    Tcl_Obj *objPtr;
 
     TclNewIntObj(objPtr, longValue);
     return objPtr;
 }
 #endif /* if TCL_MEM_DEBUG */
@@ -2593,18 +2878,18 @@
 #undef Tcl_DbNewLongObj
 #ifdef TCL_MEM_DEBUG
 
 Tcl_Obj *
 Tcl_DbNewLongObj(
-    register long longValue,	/* Long integer used to initialize the new
+    long longValue,	/* Long integer used to initialize the new
 				 * object. */
     const char *file,		/* The name of the source file calling this
 				 * function; used for debugging. */
     int line)			/* Line number in the source file; used for
 				 * debugging. */
 {
-    register Tcl_Obj *objPtr;
+    Tcl_Obj *objPtr;
 
     TclDbNewObj(objPtr, file, line);
     /* Optimized TclInvalidateStringRep */
     objPtr->bytes = NULL;
 
@@ -2615,20 +2900,54 @@
 
 #else /* if not TCL_MEM_DEBUG */
 
 Tcl_Obj *
 Tcl_DbNewLongObj(
-    register long longValue,	/* Long integer used to initialize the new
+    long longValue,	/* Long integer used to initialize the new
 				 * object. */
     const char *file,		/* The name of the source file calling this
 				 * function; used for debugging. */
     int line)			/* Line number in the source file; used for
 				 * debugging. */
 {
     return Tcl_NewWideIntObj(longValue);
 }
 #endif /* TCL_MEM_DEBUG */
+#endif /* TCL_NO_DEPRECATED */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetLongObj --
+ *
+ *	Modify an object to be an integer object and to have the specified
+ *	long integer value.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The object's old string rep, if any, is freed. Also, any old internal
+ *	rep is freed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_SetLongObj
+void
+Tcl_SetLongObj(
+    Tcl_Obj *objPtr,	/* Object whose internal rep to init. */
+    long longValue)	/* Long integer used to initialize the
+				 * object's value. */
+{
+    if (Tcl_IsShared(objPtr)) {
+	Tcl_Panic("%s called with shared object", "Tcl_SetLongObj");
+    }
+
+    TclSetIntObj(objPtr, longValue);
+}
 #endif /* TCL_NO_DEPRECATED */
 
 /*
  *----------------------------------------------------------------------
  *
@@ -2651,12 +2970,12 @@
  */
 
 int
 Tcl_GetLongFromObj(
     Tcl_Interp *interp,         /* Used for error reporting if not NULL. */
-    register Tcl_Obj *objPtr,	/* The object from which to get a long. */
-    register long *longPtr)	/* Place to store resulting long. */
+    Tcl_Obj *objPtr,	/* The object from which to get a long. */
+    long *longPtr)	/* Place to store resulting long. */
 {
     do {
 #ifdef TCL_WIDE_INT_IS_LONG
 	if (objPtr->typePtr == &tclIntType) {
 	    *longPtr = objPtr->internalRep.wideValue;
@@ -2765,11 +3084,11 @@
 #ifdef TCL_MEM_DEBUG
 #undef Tcl_NewWideIntObj
 
 Tcl_Obj *
 Tcl_NewWideIntObj(
-    register Tcl_WideInt wideValue)
+    Tcl_WideInt wideValue)
 				/* Wide integer used to initialize the new
 				 * object. */
 {
     return Tcl_DbNewWideIntObj(wideValue, "unknown", 0);
 }
@@ -2776,15 +3095,15 @@
 
 #else /* if not TCL_MEM_DEBUG */
 
 Tcl_Obj *
 Tcl_NewWideIntObj(
-    register Tcl_WideInt wideValue)
+    Tcl_WideInt wideValue)
 				/* Wide integer used to initialize the new
 				 * object. */
 {
-    register Tcl_Obj *objPtr;
+    Tcl_Obj *objPtr;
 
     TclNewObj(objPtr);
     TclSetIntObj(objPtr, wideValue);
     return objPtr;
 }
@@ -2824,19 +3143,19 @@
 
 #ifdef TCL_MEM_DEBUG
 
 Tcl_Obj *
 Tcl_DbNewWideIntObj(
-    register Tcl_WideInt wideValue,
+    Tcl_WideInt wideValue,
 				/* Wide integer used to initialize the new
 				 * object. */
     const char *file,		/* The name of the source file calling this
 				 * function; used for debugging. */
     int line)			/* Line number in the source file; used for
 				 * debugging. */
 {
-    register Tcl_Obj *objPtr;
+    Tcl_Obj *objPtr;
 
     TclDbNewObj(objPtr, file, line);
     TclSetIntObj(objPtr, wideValue);
     return objPtr;
 }
@@ -2843,11 +3162,11 @@
 
 #else /* if not TCL_MEM_DEBUG */
 
 Tcl_Obj *
 Tcl_DbNewWideIntObj(
-    register Tcl_WideInt wideValue,
+    Tcl_WideInt wideValue,
 				/* Long integer used to initialize the new
 				 * object. */
     const char *file,		/* The name of the source file calling this
 				 * function; used for debugging. */
     int line)			/* Line number in the source file; used for
@@ -2875,12 +3194,12 @@
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_SetWideIntObj(
-    register Tcl_Obj *objPtr,	/* Object w. internal rep to init. */
-    register Tcl_WideInt wideValue)
+    Tcl_Obj *objPtr,	/* Object w. internal rep to init. */
+    Tcl_WideInt wideValue)
 				/* Wide integer used to initialize the
 				 * object's value. */
 {
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetWideIntObj");
@@ -2911,12 +3230,12 @@
  */
 
 int
 Tcl_GetWideIntFromObj(
     Tcl_Interp *interp,         /* Used for error reporting if not NULL. */
-    register Tcl_Obj *objPtr,	/* Object from which to get a wide int. */
-    register Tcl_WideInt *wideIntPtr)
+    Tcl_Obj *objPtr,	/* Object from which to get a wide int. */
+    Tcl_WideInt *wideIntPtr)
 				/* Place to store resulting long. */
 {
     do {
 	if (objPtr->typePtr == &tclIntType) {
 	    *wideIntPtr = objPtr->internalRep.wideValue;
@@ -3058,11 +3377,11 @@
     mp_int toFree;		/* Bignum to free */
 
     TclUnpackBignum(objPtr, toFree);
     mp_clear(&toFree);
     if (PTR2INT(objPtr->internalRep.twoPtrValue.ptr2) < 0) {
-	Tcl_Free(objPtr->internalRep.twoPtrValue.ptr1);
+	ckfree(objPtr->internalRep.twoPtrValue.ptr1);
     }
     objPtr->typePtr = NULL;
 }
 
 /*
@@ -3503,11 +3822,12 @@
 	    *clientDataPtr = &objPtr->internalRep.wideValue;
 	    return TCL_OK;
 	}
 	if (objPtr->typePtr == &tclBignumType) {
 	    static Tcl_ThreadDataKey bignumKey;
-	    mp_int *bigPtr = Tcl_GetThreadData(&bignumKey, sizeof(mp_int));
+	    mp_int *bigPtr = Tcl_GetThreadData(&bignumKey,
+		    (int) sizeof(mp_int));
 
 	    TclUnpackBignum(objPtr, *bigPtr);
 	    *typePtr = TCL_NUMBER_BIG;
 	    *clientDataPtr = bigPtr;
 	    return TCL_OK;
@@ -3577,11 +3897,11 @@
 #undef Tcl_IsShared
 int
 Tcl_IsShared(
     Tcl_Obj *objPtr)	/* The object to test for being shared. */
 {
-    return ((objPtr)->refCount + 1 > 2);
+    return ((objPtr)->refCount > 1);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -3603,11 +3923,11 @@
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_DbIncrRefCount(
-    register Tcl_Obj *objPtr,	/* The object we are registering a reference
+    Tcl_Obj *objPtr,	/* The object we are registering a reference
 				 * to. */
     const char *file,		/* The name of the source file calling this
 				 * function; used for debugging. */
     int line)			/* Line number in the source file; used for
 				 * debugging. */
@@ -3666,11 +3986,11 @@
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_DbDecrRefCount(
-    register Tcl_Obj *objPtr,	/* The object we are releasing a reference
+    Tcl_Obj *objPtr,	/* The object we are releasing a reference
 				 * to. */
     const char *file,		/* The name of the source file calling this
 				 * function; used for debugging. */
     int line)			/* Line number in the source file; used for
 				 * debugging. */
@@ -3732,11 +4052,11 @@
  *----------------------------------------------------------------------
  */
 
 int
 Tcl_DbIsShared(
-    register Tcl_Obj *objPtr,	/* The object to test for being shared. */
+    Tcl_Obj *objPtr,	/* The object to test for being shared. */
     const char *file,		/* The name of the source file calling this
 				 * function; used for debugging. */
     int line)			/* Line number in the source file; used for
 				 * debugging. */
 {
@@ -3804,11 +4124,11 @@
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_InitObjHashTable(
-    register Tcl_HashTable *tablePtr)
+    Tcl_HashTable *tablePtr)
 				/* Pointer to table record, which is supplied
 				 * by the caller. */
 {
     Tcl_InitCustomHashTable(tablePtr, TCL_CUSTOM_PTR_KEYS,
 	    &tclObjHashKeyType);
@@ -3833,12 +4153,12 @@
 static Tcl_HashEntry *
 AllocObjEntry(
     Tcl_HashTable *tablePtr,	/* Hash table. */
     void *keyPtr)		/* Key to store in the hash table entry. */
 {
-    Tcl_Obj *objPtr = (Tcl_Obj *)keyPtr;
-    Tcl_HashEntry *hPtr = Tcl_Alloc(sizeof(Tcl_HashEntry));
+    Tcl_Obj *objPtr = keyPtr;
+    Tcl_HashEntry *hPtr = ckalloc(sizeof(Tcl_HashEntry));
 
     hPtr->key.objPtr = objPtr;
     Tcl_IncrRefCount(objPtr);
     hPtr->clientData = NULL;
 
@@ -3865,14 +4185,14 @@
 int
 TclCompareObjKeys(
     void *keyPtr,		/* New key to compare. */
     Tcl_HashEntry *hPtr)	/* Existing key to compare. */
 {
-    Tcl_Obj *objPtr1 = (Tcl_Obj *) keyPtr;
+    Tcl_Obj *objPtr1 = keyPtr;
     Tcl_Obj *objPtr2 = (Tcl_Obj *) hPtr->key.oneWordValue;
-    register const char *p1, *p2;
-    register size_t l1, l2;
+    const char *p1, *p2;
+    size_t l1, l2;
 
     /*
      * If the object pointers are the same then they match.
      * OPT: this comparison was moved to the caller
 
@@ -3928,11 +4248,11 @@
     Tcl_HashEntry *hPtr)	/* Hash entry to free. */
 {
     Tcl_Obj *objPtr = (Tcl_Obj *) hPtr->key.oneWordValue;
 
     Tcl_DecrRefCount(objPtr);
-    Tcl_Free(hPtr);
+    ckfree(hPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -3954,14 +4274,14 @@
 TCL_HASH_TYPE
 TclHashObjKey(
     Tcl_HashTable *tablePtr,	/* Hash table. */
     void *keyPtr)		/* Key from which to compute hash value. */
 {
-    Tcl_Obj *objPtr = (Tcl_Obj *)keyPtr;
-    const char *string = TclGetString(objPtr);
-    size_t length = objPtr->length;
-    TCL_HASH_TYPE result = 0;
+    Tcl_Obj *objPtr = keyPtr;
+    int length;
+    const char *string = TclGetStringFromObj(objPtr, &length);
+    unsigned int result = 0;
 
     /*
      * I tried a zillion different hash functions and asked many other people
      * for advice. Many people had their own favorite functions, all
      * different, but no-one had much idea why they were good ones. I chose
@@ -3993,17 +4313,17 @@
      * See also HashString in tclLiteral.c.
      *
      * See [tcl-Feature Request #2958832]
      */
 
-    if (length) {
+    if (length > 0) {
 	result = UCHAR(*string);
 	while (--length) {
 	    result += (result << 3) + UCHAR(*++string);
 	}
     }
-    return result;
+    return (TCL_HASH_TYPE) result;
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -4025,17 +4345,17 @@
 
 Tcl_Command
 Tcl_GetCommandFromObj(
     Tcl_Interp *interp,		/* The interpreter in which to resolve the
 				 * command and to report errors. */
-    register Tcl_Obj *objPtr)	/* The object containing the command's name.
+    Tcl_Obj *objPtr)	/* The object containing the command's name.
 				 * If the name starts with "::", will be
 				 * looked up in global namespace. Else, looked
 				 * up first in the current namespace, then in
 				 * global namespace. */
 {
-    register ResolvedCmdName *resPtr;
+    ResolvedCmdName *resPtr;
 
     /*
      * Get the internal representation, converting to a command type if
      * needed. The internal representation is a ResolvedCmdName that points to
      * the actual command.
@@ -4054,16 +4374,16 @@
      * to discard the old rep and create a new one.
      */
 
     resPtr = objPtr->internalRep.twoPtrValue.ptr1;
     if (objPtr->typePtr == &tclCmdNameType) {
-        register Command *cmdPtr = resPtr->cmdPtr;
+        Command *cmdPtr = resPtr->cmdPtr;
 
         if ((cmdPtr->cmdEpoch == resPtr->cmdEpoch)
                 && (interp == cmdPtr->nsPtr->interp)
                 && !(cmdPtr->nsPtr->flags & NS_DYING)) {
-            register Namespace *refNsPtr = (Namespace *)
+            Namespace *refNsPtr = (Namespace *)
                     TclGetCurrentNamespace(interp);
 
             if ((resPtr->refNsPtr == NULL)
                 || ((refNsPtr == resPtr->refNsPtr)
                     && (resPtr->refNsId == refNsPtr->nsId)
@@ -4118,11 +4438,11 @@
     const char *name = TclGetString(objPtr);
 
     if (resPtr) {
 	fillPtr = resPtr;
     } else {
-	fillPtr = Tcl_Alloc(sizeof(ResolvedCmdName));
+	fillPtr = ckalloc(sizeof(ResolvedCmdName));
 	fillPtr->refCount = 1;
     }
 
     fillPtr->cmdPtr = cmdPtr;
     cmdPtr->refCount++;
@@ -4161,16 +4481,16 @@
 
 void
 TclSetCmdNameObj(
     Tcl_Interp *interp,		/* Points to interpreter containing command
 				 * that should be cached in objPtr. */
-    register Tcl_Obj *objPtr,	/* Points to Tcl object to be changed to a
+    Tcl_Obj *objPtr,	/* Points to Tcl object to be changed to a
 				 * CmdName object. */
     Command *cmdPtr)		/* Points to Command structure that the
 				 * CmdName object should refer to. */
 {
-    register ResolvedCmdName *resPtr;
+    ResolvedCmdName *resPtr;
 
     if (objPtr->typePtr == &tclCmdNameType) {
 	resPtr = objPtr->internalRep.twoPtrValue.ptr1;
 	if (resPtr != NULL && resPtr->cmdPtr == cmdPtr) {
 	    return;
@@ -4201,14 +4521,14 @@
  *----------------------------------------------------------------------
  */
 
 static void
 FreeCmdNameInternalRep(
-    register Tcl_Obj *objPtr)	/* CmdName object with internal
+    Tcl_Obj *objPtr)	/* CmdName object with internal
 				 * representation to free. */
 {
-    register ResolvedCmdName *resPtr = objPtr->internalRep.twoPtrValue.ptr1;
+    ResolvedCmdName *resPtr = objPtr->internalRep.twoPtrValue.ptr1;
 
 	/*
 	 * Decrement the reference count of the ResolvedCmdName structure. If
 	 * there are no more uses, free the ResolvedCmdName structure.
 	 */
@@ -4221,11 +4541,11 @@
 	     */
 
 	    Command *cmdPtr = resPtr->cmdPtr;
 
 	    TclCleanupCommandMacro(cmdPtr);
-	    Tcl_Free(resPtr);
+	    ckfree(resPtr);
 	}
     objPtr->typePtr = NULL;
 }
 
 /*
@@ -4249,13 +4569,13 @@
  */
 
 static void
 DupCmdNameInternalRep(
     Tcl_Obj *srcPtr,		/* Object with internal rep to copy. */
-    register Tcl_Obj *copyPtr)	/* Object with internal rep to set. */
+    Tcl_Obj *copyPtr)	/* Object with internal rep to set. */
 {
-    register ResolvedCmdName *resPtr = srcPtr->internalRep.twoPtrValue.ptr1;
+    ResolvedCmdName *resPtr = srcPtr->internalRep.twoPtrValue.ptr1;
 
     copyPtr->internalRep.twoPtrValue.ptr1 = resPtr;
     copyPtr->internalRep.twoPtrValue.ptr2 = NULL;
 	resPtr->refCount++;
     copyPtr->typePtr = &tclCmdNameType;
@@ -4283,15 +4603,15 @@
  */
 
 static int
 SetCmdNameFromAny(
     Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
-    register Tcl_Obj *objPtr)	/* The object to convert. */
+    Tcl_Obj *objPtr)	/* The object to convert. */
 {
     const char *name;
-    register Command *cmdPtr;
-    register ResolvedCmdName *resPtr;
+    Command *cmdPtr;
+    ResolvedCmdName *resPtr;
 
     if (interp == NULL) {
 	return TCL_ERROR;
     }
 
@@ -4370,11 +4690,11 @@
      * Value is a bignum with a refcount of 14, object pointer at 0x12345678,
      * internal representation 0x45671234:0x98765432, string representation
      * "1872361827361287"
      */
 
-    descObj = Tcl_ObjPrintf("value is a %s with a refcount of %" TCL_Z_MODIFIER "u,"
+    descObj = Tcl_ObjPrintf("value is a %s with a refcount of %d,"
 	    " object pointer at %p",
 	    objv[1]->typePtr ? objv[1]->typePtr->name : "pure string",
 	    objv[1]->refCount, objv[1]);
 
     if (objv[1]->typePtr) {

Index: generic/tclOptimize.c
==================================================================
--- generic/tclOptimize.c
+++ generic/tclOptimize.c
@@ -229,11 +229,11 @@
 		blank = size + InstLength(nextInst);
 	    } else if (nextInst == INST_STR_CONCAT1
 		    && TclGetUInt1AtPtr(currentInstPtr + size + 1) == 2) {
 		Tcl_Obj *litPtr = TclFetchLiteral(envPtr,
 			TclGetUInt1AtPtr(currentInstPtr + 1));
-		size_t numBytes;
+		int numBytes;
 
 		(void) TclGetStringFromObj(litPtr, &numBytes);
 		if (numBytes == 0) {
 		    blank = size + InstLength(nextInst);
 		}
@@ -244,11 +244,11 @@
 		blank = size + 1;
 	    } else if (nextInst == INST_STR_CONCAT1
 		    && TclGetUInt1AtPtr(currentInstPtr + size + 1) == 2) {
 		Tcl_Obj *litPtr = TclFetchLiteral(envPtr,
 			TclGetUInt4AtPtr(currentInstPtr + 1));
-		size_t numBytes;
+		int numBytes;
 
 		(void) TclGetStringFromObj(litPtr, &numBytes);
 		if (numBytes == 0) {
 		    blank = size + InstLength(nextInst);
 		}
@@ -285,10 +285,12 @@
 	    case INST_INCR_SCALAR1:
 	    case INST_INCR_ARRAY1:
 	    case INST_INCR_ARRAY_STK:
 	    case INST_INCR_SCALAR_STK:
 	    case INST_INCR_STK:
+	    case INST_LOR:
+	    case INST_LAND:
 	    case INST_EQ:
 	    case INST_NEQ:
 	    case INST_LT:
 	    case INST_LE:
 	    case INST_GT:

Index: generic/tclPanic.c
==================================================================
--- generic/tclPanic.c
+++ generic/tclPanic.c
@@ -13,19 +13,23 @@
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  */
 
 #include "tclInt.h"
 #if defined(_WIN32) || defined(__CYGWIN__)
-    MODULE_SCOPE void tclWinDebugPanic(const char *format, ...);
+    MODULE_SCOPE TCL_NORETURN void tclWinDebugPanic(const char *format, ...);
 #endif
 
 /*
  * The panicProc variable contains a pointer to an application specific panic
  * procedure.
  */
 
+#if defined(__CYGWIN__) || (defined(_WIN32) && (defined(TCL_NO_DEPRECATED) || TCL_MAJOR_VERSION > 8))
+static TCL_NORETURN1 Tcl_PanicProc *panicProc = tclWinDebugPanic;
+#else
 static TCL_NORETURN1 Tcl_PanicProc *panicProc = NULL;
+#endif
 
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_SetPanicProc --
@@ -43,12 +47,85 @@
 
 void
 Tcl_SetPanicProc(
     TCL_NORETURN1 Tcl_PanicProc *proc)
 {
+#if defined(_WIN32)
+    /* tclWinDebugPanic only installs if there is no panicProc yet. */
+    if ((proc != tclWinDebugPanic) || (panicProc == NULL))
+#elif defined(__CYGWIN__)
+    if (proc == NULL)
+	panicProc = tclWinDebugPanic;
+    else
+#endif
     panicProc = proc;
-    TclInitSubsystems();
+    Tcl_InitSubsystems();
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_PanicVA --
+ *
+ *	Print an error message and kill the process.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The process dies, entering the debugger if possible.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_PanicVA(
+    const char *format,		/* Format string, suitable for passing to
+				 * fprintf. */
+    va_list argList)		/* Variable argument list. */
+{
+    char *arg1, *arg2, *arg3;	/* Additional arguments (variable in number)
+				 * to pass to fprintf. */
+    char *arg4, *arg5, *arg6, *arg7, *arg8;
+
+    arg1 = va_arg(argList, char *);
+    arg2 = va_arg(argList, char *);
+    arg3 = va_arg(argList, char *);
+    arg4 = va_arg(argList, char *);
+    arg5 = va_arg(argList, char *);
+    arg6 = va_arg(argList, char *);
+    arg7 = va_arg(argList, char *);
+    arg8 = va_arg(argList, char *);
+
+    if (panicProc != NULL) {
+	panicProc(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+#ifdef _WIN32
+    } else if (IsDebuggerPresent()) {
+	tclWinDebugPanic(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+#endif
+    } else {
+	fprintf(stderr, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7,
+		arg8);
+	fprintf(stderr, "\n");
+	fflush(stderr);
+#if defined(_WIN32) || defined(__CYGWIN__)
+#   if defined(__GNUC__)
+	__builtin_trap();
+#   elif defined(_WIN64)
+	__debugbreak();
+#   elif defined(_MSC_VER) && defined (_M_IX86)
+	_asm {int 3}
+#   else
+	DebugBreak();
+#   endif
+#endif
+#if defined(_WIN32)
+	ExitProcess(1);
+#else
+	abort();
+#endif
+    }
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -63,11 +140,12 @@
  *	The process dies, entering the debugger if possible.
  *
  *----------------------------------------------------------------------
  */
 
-	/* ARGSUSED */
+/* ARGSUSED */
+
 /*
  * The following comment is here so that Coverity's static analizer knows that
  * a Tcl_Panic() call can never return and avoids lots of false positives.
  */
 
@@ -76,56 +154,18 @@
 Tcl_Panic(
     const char *format,
     ...)
 {
     va_list argList;
-    char *arg1, *arg2, *arg3;	/* Additional arguments (variable in number)
-				 * to pass to fprintf. */
-    char *arg4, *arg5, *arg6, *arg7, *arg8;
-
 
     va_start(argList, format);
-    arg1 = va_arg(argList, char *);
-    arg2 = va_arg(argList, char *);
-    arg3 = va_arg(argList, char *);
-    arg4 = va_arg(argList, char *);
-    arg5 = va_arg(argList, char *);
-    arg6 = va_arg(argList, char *);
-    arg7 = va_arg(argList, char *);
-    arg8 = va_arg(argList, char *);
+    Tcl_PanicVA(format, argList);
     va_end (argList);
-
-    if (panicProc != NULL) {
-	panicProc(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-    } else {
-#if defined(_WIN32) || defined(__CYGWIN__)
-    tclWinDebugPanic(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
-#else
-	fprintf(stderr, format, arg1, arg2, arg3, arg4, arg5, arg6, arg7,
-		arg8);
-	fprintf(stderr, "\n");
-	fflush(stderr);
-#endif
-#   if defined(__GNUC__)
-	__builtin_trap();
-#   elif defined(_WIN64)
-	__debugbreak();
-#   elif defined(_MSC_VER) && defined (_M_IX86)
-	_asm {int 3}
-#   elif defined(_WIN32)
-	DebugBreak();
-#   endif
-#if defined(_WIN32)
-	ExitProcess(1);
-#else
-	abort();
-#endif
-    }
 }
 
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 4
  * fill-column: 78
  * End:
  */

Index: generic/tclParse.c
==================================================================
--- generic/tclParse.c
+++ generic/tclParse.c
@@ -117,18 +117,18 @@
 
 /*
  * Prototypes for local functions defined in this file:
  */
 
-static inline int	CommandComplete(const char *script, size_t numBytes);
-static size_t		ParseComment(const char *src, size_t numBytes,
+static inline int	CommandComplete(const char *script, int numBytes);
+static int		ParseComment(const char *src, int numBytes,
 			    Tcl_Parse *parsePtr);
-static int		ParseTokens(const char *src, size_t numBytes, int mask,
+static int		ParseTokens(const char *src, int numBytes, int mask,
 			    int flags, Tcl_Parse *parsePtr);
-static size_t		ParseWhiteSpace(const char *src, size_t numBytes,
+static int		ParseWhiteSpace(const char *src, int numBytes,
 			    int *incompletePtr, char *typePtr);
-static size_t		ParseAllWhiteSpace(const char *src, size_t numBytes,
+static int		ParseAllWhiteSpace(const char *src, int numBytes,
 			    int *incompletePtr);
 
 /*
  *----------------------------------------------------------------------
  *
@@ -147,11 +147,11 @@
 
 void
 TclParseInit(
     Tcl_Interp *interp,		/* Interpreter to use for error reporting */
     const char *start,		/* Start of string to be parsed. */
-    size_t numBytes,		/* Total number of bytes in string. If -1,
+    int numBytes,		/* Total number of bytes in string. If < 0,
 				 * the script consists of all bytes up to the
 				 * first null character. */
     Tcl_Parse *parsePtr)	/* Points to struct to initialize */
 {
     parsePtr->numWords = 0;
@@ -193,11 +193,11 @@
 Tcl_ParseCommand(
     Tcl_Interp *interp,		/* Interpreter to use for error reporting; if
 				 * NULL, then no error message is provided. */
     const char *start,		/* First character of string containing one or
 				 * more Tcl commands. */
-    size_t numBytes,		/* Total number of bytes in string. If -1,
+    int numBytes,	/* Total number of bytes in string. If < 0,
 				 * the script consists of all bytes up to the
 				 * first null character. */
     int nested,			/* Non-zero means this is a nested command:
 				 * close bracket should be considered a
 				 * command terminator. If zero, then close
@@ -205,29 +205,29 @@
     Tcl_Parse *parsePtr)
 				/* Structure to fill in with information about
 				 * the parsed command; any previous
 				 * information in the structure is ignored. */
 {
-    const char *src;		/* Points to current character in the
+    const char *src;	/* Points to current character in the
 				 * command. */
     char type;			/* Result returned by CHAR_TYPE(*src). */
     Tcl_Token *tokenPtr;	/* Pointer to token being filled in. */
     int wordIndex;		/* Index of word token for current word. */
     int terminators;		/* CHAR_TYPE bits that indicate the end of a
 				 * command. */
     const char *termPtr;	/* Set by Tcl_ParseBraces/QuotedString to
 				 * point to char after terminating one. */
-    size_t scanned;
+    int scanned;
 
     if ((start == NULL) && (numBytes != 0)) {
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "can't parse a NULL pointer", -1));
 	}
 	return TCL_ERROR;
     }
-    if (numBytes == TCL_AUTO_LENGTH) {
+    if (numBytes < 0) {
 	numBytes = strlen(start);
     }
     TclParseInit(interp, start, numBytes, parsePtr);
     parsePtr->commentStart = NULL;
     parsePtr->commentSize = 0;
@@ -342,11 +342,11 @@
 	    expPtr = &parsePtr->tokenPtr[expIdx];
 	    if ((0 == expandWord)
 		    /* Haven't seen prefix already */
 		    && (1 == parsePtr->numTokens - expIdx)
 		    /* Only one token */
-		    && (((1 == expPtr->size)
+		    && (((1 == (size_t) expPtr->size)
 			    /* Same length as prefix */
 			    && (expPtr->start[0] == '*')))
 			    /* Is the prefix */
 		    && (numBytes > 0) && (0 == ParseWhiteSpace(termPtr,
 			    numBytes, &parsePtr->incomplete, &type))
@@ -377,12 +377,11 @@
 
 	tokenPtr = &parsePtr->tokenPtr[wordIndex];
 	tokenPtr->size = src - tokenPtr->start;
 	tokenPtr->numComponents = parsePtr->numTokens - (wordIndex + 1);
 	if (expandWord) {
-	    size_t i;
-	    int isLiteral = 1;
+	    int i, isLiteral = 1;
 
 	    /*
 	     * When a command includes a word that is an expanded literal; for
 	     * example, {*}{1 2 3}, the parser performs that expansion
 	     * immediately, generating several TCL_TOKEN_SIMPLE_WORDs instead
@@ -424,11 +423,11 @@
 		 * Step through the literal string, parsing and counting list
 		 * elements.
 		 */
 
 		while (nextElem < listEnd) {
-		    size_t size;
+		    int size;
 
 		    code = TclFindElement(NULL, nextElem, listEnd - nextElem,
 			    &elemStart, &nextElem, &size, &literal);
 		    if ((code != TCL_OK) || !literal) {
 			break;
@@ -616,21 +615,21 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-static size_t
+static int
 ParseWhiteSpace(
     const char *src,		/* First character to parse. */
-    size_t numBytes,		/* Max number of bytes to scan. */
+    int numBytes,	/* Max number of bytes to scan. */
     int *incompletePtr,		/* Set this boolean memory to true if parsing
 				 * indicates an incomplete command. */
     char *typePtr)		/* Points to location to store character type
 				 * of character that ends run of whitespace */
 {
-    register char type = TYPE_NORMAL;
-    register const char *p = src;
+    char type = TYPE_NORMAL;
+    const char *p = src;
 
     while (1) {
 	while (numBytes && ((type = CHAR_TYPE(*p)) & TYPE_SPACE)) {
 	    numBytes--;
 	    p++;
@@ -670,32 +669,32 @@
  *	Returns the number of bytes recognized as white space.
  *
  *----------------------------------------------------------------------
  */
 
-static size_t
+static int
 ParseAllWhiteSpace(
     const char *src,		/* First character to parse. */
-    size_t numBytes,		/* Max number of byes to scan */
+    int numBytes,		/* Max number of byes to scan */
     int *incompletePtr)		/* Set true if parse is incomplete. */
 {
     char type;
     const char *p = src;
 
     do {
-	size_t scanned = ParseWhiteSpace(p, numBytes, incompletePtr, &type);
+	int scanned = ParseWhiteSpace(p, numBytes, incompletePtr, &type);
 
 	p += scanned;
 	numBytes -= scanned;
     } while (numBytes && (*p == '\n') && (p++, --numBytes));
     return (p-src);
 }
 
-size_t
+int
 TclParseAllWhiteSpace(
     const char *src,		/* First character to parse. */
-    size_t numBytes)		/* Max number of byes to scan */
+    int numBytes)		/* Max number of byes to scan */
 {
     int dummy;
     return ParseAllWhiteSpace(src, numBytes, &dummy);
 }
 
@@ -722,17 +721,17 @@
  */
 
 int
 TclParseHex(
     const char *src,		/* First character to parse. */
-    size_t numBytes,		/* Max number of byes to scan */
-    int *resultPtr)		/* Points to storage provided by caller where
+    int numBytes,		/* Max number of byes to scan */
+    int *resultPtr)	/* Points to storage provided by caller where
 				 * the character resulting from the
 				 * conversion is to be written. */
 {
     int result = 0;
-    register const char *p = src;
+    const char *p = src;
 
     while (numBytes--) {
 	unsigned char digit = UCHAR(*p);
 
 	if (!isxdigit(digit) || (result > 0x10fff)) {
@@ -778,22 +777,21 @@
 
 int
 TclParseBackslash(
     const char *src,		/* Points to the backslash character of a a
 				 * backslash sequence. */
-    size_t numBytes,		/* Max number of bytes to scan. */
-    size_t *readPtr,		/* NULL, or points to storage where the number
+    int numBytes,		/* Max number of bytes to scan. */
+    int *readPtr,		/* NULL, or points to storage where the number
 				 * of bytes scanned should be written. */
     char *dst)			/* NULL, or points to buffer where the UTF-8
 				 * encoding of the backslash sequence is to be
-				 * written. At most TCL_UTF_MAX bytes will be
-				 * written there. */
+				 * written. At most 4 bytes will be written there. */
 {
-    register const char *p = src+1;
+    const char *p = src+1;
     Tcl_UniChar unichar = 0;
     int result;
-    size_t count;
+    int count;
     char buf[4] = "";
 
     if (numBytes == 0) {
 	if (readPtr != NULL) {
 	    *readPtr = 0;
@@ -963,23 +961,23 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-static size_t
+static int
 ParseComment(
     const char *src,		/* First character to parse. */
-    size_t numBytes,		/* Max number of bytes to scan. */
+    int numBytes,	/* Max number of bytes to scan. */
     Tcl_Parse *parsePtr)	/* Information about parse in progress.
 				 * Updated if parsing indicates an incomplete
 				 * command. */
 {
-    register const char *p = src;
+    const char *p = src;
     int incomplete = parsePtr->incomplete;
 
     while (numBytes) {
-	size_t scanned = ParseAllWhiteSpace(p, numBytes, &incomplete);
+	int scanned = ParseAllWhiteSpace(p, numBytes, &incomplete);
 	p += scanned;
 	numBytes -= scanned;
 
 	if ((numBytes == 0) || (*p != '#')) {
 	    break;
@@ -1038,12 +1036,12 @@
  *----------------------------------------------------------------------
  */
 
 static int
 ParseTokens(
-    register const char *src,	/* First character to parse. */
-    size_t numBytes,		/* Max number of bytes to scan. */
+    const char *src,	/* First character to parse. */
+    int numBytes,	/* Max number of bytes to scan. */
     int mask,			/* Specifies when to stop parsing. The parse
 				 * stops at the first unquoted character whose
 				 * CHAR_TYPE contains any of the bits in
 				 * mask. */
     int flags,			/* OR-ed bits indicating what substitutions to
@@ -1279,11 +1277,11 @@
 Tcl_FreeParse(
     Tcl_Parse *parsePtr)	/* Structure that was filled in by a previous
 				 * call to Tcl_ParseCommand. */
 {
     if (parsePtr->tokenPtr != parsePtr->staticTokens) {
-	Tcl_Free(parsePtr->tokenPtr);
+	ckfree(parsePtr->tokenPtr);
 	parsePtr->tokenPtr = parsePtr->staticTokens;
     }
 }
 
 /*
@@ -1317,11 +1315,11 @@
 Tcl_ParseVarName(
     Tcl_Interp *interp,		/* Interpreter to use for error reporting; if
 				 * NULL, then no error message is provided. */
     const char *start,		/* Start of variable substitution string.
 				 * First character must be "$". */
-    size_t numBytes,		/* Total number of bytes in string. If -1,
+    int numBytes,	/* Total number of bytes in string. If < 0,
 				 * the string consists of all bytes up to the
 				 * first null character. */
     Tcl_Parse *parsePtr,	/* Structure to fill in with information about
 				 * the variable name. */
     int append)			/* Non-zero means append tokens to existing
@@ -1328,18 +1326,18 @@
 				 * information in parsePtr; zero means ignore
 				 * existing tokens in parsePtr and
 				 * reinitialize it. */
 {
     Tcl_Token *tokenPtr;
-    register const char *src;
+    const char *src;
     int varIndex;
     unsigned array;
 
     if ((numBytes == 0) || (start == NULL)) {
 	return TCL_ERROR;
     }
-    if (numBytes == TCL_AUTO_LENGTH) {
+    if (numBytes < 0) {
 	numBytes = strlen(start);
     }
 
     if (!append) {
 	TclParseInit(interp, start, numBytes, parsePtr);
@@ -1510,17 +1508,17 @@
  */
 
 const char *
 Tcl_ParseVar(
     Tcl_Interp *interp,		/* Context for looking up variable. */
-    register const char *start,	/* Start of variable substitution. First
+    const char *start,	/* Start of variable substitution. First
 				 * character must be "$". */
     const char **termPtr)	/* If non-NULL, points to word to fill in with
 				 * character just after last one in the
 				 * variable specifier. */
 {
-    register Tcl_Obj *objPtr;
+    Tcl_Obj *objPtr;
     int code;
     Tcl_Parse *parsePtr = TclStackAlloc(interp, sizeof(Tcl_Parse));
 
     if (Tcl_ParseVarName(interp, start, -1, parsePtr, 0) != TCL_OK) {
 	TclStackFree(interp, parsePtr);
@@ -1595,14 +1593,14 @@
 Tcl_ParseBraces(
     Tcl_Interp *interp,		/* Interpreter to use for error reporting; if
 				 * NULL, then no error message is provided. */
     const char *start,		/* Start of string enclosed in braces. The
 				 * first character must be {'. */
-    size_t numBytes,		/* Total number of bytes in string. If -1,
+    int numBytes,	/* Total number of bytes in string. If < 0,
 				 * the string consists of all bytes up to the
 				 * first null character. */
-    register Tcl_Parse *parsePtr,
+    Tcl_Parse *parsePtr,
 				/* Structure to fill in with information about
 				 * the string. */
     int append,			/* Non-zero means append tokens to existing
 				 * information in parsePtr; zero means ignore
 				 * existing tokens in parsePtr and
@@ -1611,18 +1609,17 @@
 				 * store a pointer to the character just after
 				 * the terminating '}' if the parse was
 				 * successful. */
 {
     Tcl_Token *tokenPtr;
-    register const char *src;
-    int startIndex, level;
-    size_t length;
+    const char *src;
+    int startIndex, level, length;
 
     if ((numBytes == 0) || (start == NULL)) {
 	return TCL_ERROR;
     }
-    if (numBytes == TCL_AUTO_LENGTH) {
+    if (numBytes < 0) {
 	numBytes = strlen(start);
     }
 
     if (!append) {
 	TclParseInit(interp, start, numBytes, parsePtr);
@@ -1738,11 +1735,11 @@
      * aren't performing a full Tcl parse, just look for an open brace
      * preceded by a '<whitespace>#' on the same line.
      */
 
     {
-	register int openBrace = 0;
+	int openBrace = 0;
 
 	while (--src > start) {
 	    switch (*src) {
 	    case '{':
 		openBrace = 1;
@@ -1798,14 +1795,14 @@
 Tcl_ParseQuotedString(
     Tcl_Interp *interp,		/* Interpreter to use for error reporting; if
 				 * NULL, then no error message is provided. */
     const char *start,		/* Start of the quoted string. The first
 				 * character must be '"'. */
-    size_t numBytes,		/* Total number of bytes in string. If -1,
+    int numBytes,	/* Total number of bytes in string. If < 0,
 				 * the string consists of all bytes up to the
 				 * first null character. */
-    register Tcl_Parse *parsePtr,
+    Tcl_Parse *parsePtr,
 				/* Structure to fill in with information about
 				 * the string. */
     int append,			/* Non-zero means append tokens to existing
 				 * information in parsePtr; zero means ignore
 				 * existing tokens in parsePtr and
@@ -1816,11 +1813,11 @@
 				 * if the parse succeeds. */
 {
     if ((numBytes == 0) || (start == NULL)) {
 	return TCL_ERROR;
     }
-    if (numBytes == TCL_AUTO_LENGTH) {
+    if (numBytes < 0) {
 	numBytes = strlen(start);
     }
 
     if (!append) {
 	TclParseInit(interp, start, numBytes, parsePtr);
@@ -1880,16 +1877,16 @@
 
 void
 TclSubstParse(
     Tcl_Interp *interp,
     const char *bytes,
-    size_t numBytes,
+    int numBytes,
     int flags,
     Tcl_Parse *parsePtr,
     Tcl_InterpState *statePtr)
 {
-    size_t length = numBytes;
+    int length = numBytes;
     const char *p = bytes;
 
     TclParseInit(interp, p, length, parsePtr);
 
     /*
@@ -2142,11 +2139,11 @@
 	}
     }
 
     if (isLiteral) {
 	maxNumCL = NUM_STATIC_POS;
-	clPosition = Tcl_Alloc(maxNumCL * sizeof(int));
+	clPosition = ckalloc(maxNumCL * sizeof(int));
     }
 
     adjust = 0;
     result = NULL;
     for (; count>0 && code==TCL_OK ; count--, tokenPtr++) {
@@ -2182,21 +2179,21 @@
 	     */
 
 	    if ((appendByteLength == 1) && (utfCharBytes[0] == ' ')
 		    && (tokenPtr->start[1] == '\n')) {
 		if (isLiteral) {
-		    size_t clPos;
+		    int clPos;
 
 		    if (result == 0) {
 			clPos = 0;
 		    } else {
-			(void)TclGetStringFromObj(result, &clPos);
+			TclGetStringFromObj(result, &clPos);
 		    }
 
 		    if (numCL >= maxNumCL) {
 			maxNumCL *= 2;
-			clPosition = Tcl_Realloc(clPosition,
+			clPosition = ckrealloc(clPosition,
 				maxNumCL * sizeof(int));
 		    }
 		    clPosition[numCL] = clPos;
 		    numCL++;
 		}
@@ -2350,11 +2347,11 @@
 	     * Release the temp table we used to collect the locations of
 	     * continuation lines, if any.
 	     */
 
 	    if (maxNumCL) {
-		Tcl_Free(clPosition);
+		ckfree(clPosition);
 	    }
 	} else {
 	    Tcl_ResetResult(interp);
 	}
     }
@@ -2388,11 +2385,11 @@
  */
 
 static inline int
 CommandComplete(
     const char *script,		/* Script to check. */
-    size_t numBytes)		/* Number of bytes in script. */
+    int numBytes)		/* Number of bytes in script. */
 {
     Tcl_Parse parse;
     const char *p, *end;
     int result;
 
@@ -2462,11 +2459,11 @@
 int
 TclObjCommandComplete(
     Tcl_Obj *objPtr)		/* Points to object holding script to
 				 * check. */
 {
-    size_t length;
+    int length;
     const char *script = TclGetStringFromObj(objPtr, &length);
 
     return CommandComplete(script, length);
 }
 

Index: generic/tclPathObj.c
==================================================================
--- generic/tclPathObj.c
+++ generic/tclPathObj.c
@@ -23,11 +23,11 @@
 static void		DupFsPathInternalRep(Tcl_Obj *srcPtr,
 			    Tcl_Obj *copyPtr);
 static void		FreeFsPathInternalRep(Tcl_Obj *pathPtr);
 static void		UpdateStringOfFsPath(Tcl_Obj *pathPtr);
 static int		SetFsPathFromAny(Tcl_Interp *interp, Tcl_Obj *pathPtr);
-static size_t	FindSplitPos(const char *path, int separator);
+static int		FindSplitPos(const char *path, int separator);
 static int		IsSeparatorOrNull(int ch);
 static Tcl_Obj *	GetExtension(Tcl_Obj *pathPtr);
 static int		MakePathFromNormalized(Tcl_Interp *interp,
 			    Tcl_Obj *pathPtr);
 
@@ -65,11 +65,11 @@
  * Now, this is a path like 'file join $dir $tail' where, cwdPtr is the $dir
  * and normPathPtr is the $tail.
  *
  */
 
-typedef struct {
+typedef struct FsPath {
     Tcl_Obj *translatedPathPtr; /* Name without any ~user sequences. If this
 				 * is NULL, then this is a pure normalized,
 				 * absolute path object, in which the parent
 				 * Tcl_Obj's string rep is already both
 				 * translated and normalized. */
@@ -80,11 +80,11 @@
 				 * have a refCount on the object. */
     int flags;			/* Flags to describe interpretation - see
 				 * below. */
     ClientData nativePathPtr;	/* Native representation of this path, which
 				 * is filesystem dependent. */
-    size_t filesystemEpoch;	/* Used to ensure the path representation was
+    int filesystemEpoch;	/* Used to ensure the path representation was
 				 * generated during the correct filesystem
 				 * epoch. The epoch changes when
 				 * filesystem-mounts are changed. */
     const Tcl_Filesystem *fsPtr;/* The Tcl_Filesystem that claims this path */
 } FsPath;
@@ -219,18 +219,18 @@
 	again:
 	    if (IsSeparatorOrNull(dirSep[2])) {
 		/*
 		 * Need to skip '.' in the path.
 		 */
-		size_t curLen;
+		int curLen;
 
 		if (retVal == NULL) {
 		    const char *path = TclGetString(pathPtr);
 		    retVal = Tcl_NewStringObj(path, dirSep - path);
 		    Tcl_IncrRefCount(retVal);
 		}
-		(void)TclGetStringFromObj(retVal, &curLen);
+		TclGetStringFromObj(retVal, &curLen);
 		if (curLen == 0) {
 		    Tcl_AppendToObj(retVal, dirSep, 1);
 		}
 		dirSep += 2;
 		oldDirSep = dirSep;
@@ -239,11 +239,11 @@
 		}
 		continue;
 	    }
 	    if (dirSep[2] == '.' && IsSeparatorOrNull(dirSep[3])) {
 		Tcl_Obj *linkObj;
-		size_t curLen;
+		int curLen;
 		char *linkStr;
 
 		/*
 		 * Have '..' so need to skip previous directory.
 		 */
@@ -252,11 +252,11 @@
 		    const char *path = TclGetString(pathPtr);
 
 		    retVal = Tcl_NewStringObj(path, dirSep - path);
 		    Tcl_IncrRefCount(retVal);
 		}
-		(void)TclGetStringFromObj(retVal, &curLen);
+		TclGetStringFromObj(retVal, &curLen);
 		if (curLen == 0) {
 		    Tcl_AppendToObj(retVal, dirSep, 1);
 		}
 		if (!first || (tclPlatform == TCL_PLATFORM_UNIX)) {
 		    linkObj = Tcl_FSLink(retVal, NULL, 0);
@@ -285,11 +285,11 @@
 			     */
 
 			    const char *path =
 				    TclGetStringFromObj(retVal, &curLen);
 
-			    while (curLen-- > 0) {
+			    while (--curLen >= 0) {
 				if (IsSeparatorOrNull(path[curLen])) {
 				    break;
 				}
 			    }
 
@@ -318,11 +318,11 @@
 			    /*
 			     * Convert to forward-slashes on windows.
 			     */
 
 			    if (tclPlatform == TCL_PLATFORM_WINDOWS) {
-				size_t i;
+				int i;
 
 				for (i = 0; i < curLen; i++) {
 				    if (linkStr[i] == '\\') {
 					linkStr[i] = '/';
 				    }
@@ -336,11 +336,11 @@
 		    /*
 		     * Either way, we now remove the last path element (but
 		     * not the first character of the path).
 		     */
 
-		    while (curLen-- > 0) {
+		    while (--curLen >= 0) {
 			if (IsSeparatorOrNull(linkStr[curLen])) {
 			    if (curLen) {
 				Tcl_SetObjLength(retVal, curLen);
 			    } else {
 				Tcl_SetObjLength(retVal, 1);
@@ -398,11 +398,11 @@
     /*
      * Ensure a windows drive like C:/ has a trailing separator.
      */
 
     if (tclPlatform == TCL_PLATFORM_WINDOWS) {
-	size_t len;
+	int len;
 	const char *path = TclGetStringFromObj(retVal, &len);
 
 	if (len == 2 && path[0] != 0 && path[1] == ':') {
 	    if (Tcl_IsShared(retVal)) {
 		TclDecrRefCount(retVal);
@@ -572,12 +572,13 @@
 		 * part with the dirname of the joined-on bit. We could handle
 		 * that special case here, but we don't, and instead just use
 		 * the standardPath code.
 		 */
 
-		size_t numBytes;
-		const char *rest = TclGetStringFromObj(fsPathPtr->normPathPtr, &numBytes);
+		int numBytes;
+		const char *rest =
+			TclGetStringFromObj(fsPathPtr->normPathPtr, &numBytes);
 
 		if (strchr(rest, '/') != NULL) {
 		    goto standardPath;
 		}
 		/*
@@ -609,12 +610,13 @@
 		 * it. If so, the 'tail' would be only the part following the
 		 * last delimiter. We could handle that special case here, but
 		 * we don't, and instead just use the standardPath code.
 		 */
 
-		size_t numBytes;
-		const char *rest = TclGetStringFromObj(fsPathPtr->normPathPtr, &numBytes);
+		int numBytes;
+		const char *rest =
+			TclGetStringFromObj(fsPathPtr->normPathPtr, &numBytes);
 
 		if (strchr(rest, '/') != NULL) {
 		    goto standardPath;
 		}
 		/*
@@ -637,11 +639,11 @@
 	    }
 	    case TCL_PATH_EXTENSION:
 		return GetExtension(fsPathPtr->normPathPtr);
 	    case TCL_PATH_ROOT: {
 		const char *fileName, *extension;
-		size_t length;
+		int length;
 
 		fileName = TclGetStringFromObj(fsPathPtr->normPathPtr,
 			&length);
 		extension = TclGetExtension(fileName);
 		if (extension == NULL) {
@@ -660,11 +662,11 @@
 		     * the tail.
 		     */
 
 		    Tcl_Obj *resultPtr =
 			    TclNewFSPathObj(fsPathPtr->cwdPtr, fileName,
-			    length - strlen(extension));
+			    (int)(length - strlen(extension)));
 
 		    Tcl_IncrRefCount(resultPtr);
 		    return resultPtr;
 		}
 	    }
@@ -688,21 +690,21 @@
     standardPath:
 	resultPtr = NULL;
 	if (portion == TCL_PATH_EXTENSION) {
 	    return GetExtension(pathPtr);
 	} else if (portion == TCL_PATH_ROOT) {
-	    size_t length;
+	    int length;
 	    const char *fileName, *extension;
 
 	    fileName = TclGetStringFromObj(pathPtr, &length);
 	    extension = TclGetExtension(fileName);
 	    if (extension == NULL) {
 		Tcl_IncrRefCount(pathPtr);
 		return pathPtr;
 	    } else {
 		Tcl_Obj *root = Tcl_NewStringObj(fileName,
-			length - strlen(extension));
+			(int) (length - strlen(extension)));
 
 		Tcl_IncrRefCount(root);
 		return root;
 	    }
 	}
@@ -881,11 +883,11 @@
 	    /* if forceRelative - second path is relative */
 	    type = forceRelative ? TCL_PATH_RELATIVE :
 		    TclGetPathType(tailObj, NULL, NULL, NULL);
 	    if (type == TCL_PATH_RELATIVE) {
 		const char *str;
-		size_t len;
+		int len;
 
 		str = TclGetStringFromObj(tailObj, &len);
 		if (len == 0) {
 		    /*
 		     * This happens if we try to handle the root volume '/'.
@@ -912,11 +914,11 @@
 		     * all backslashes to forward slashes, so the base part
 		     * cannot have backslashes either.
 		     */
 
 		    if ((tclPlatform != TCL_PLATFORM_WINDOWS)
-			    || (strchr(TclGetString(elt), '\\') == NULL)) {
+			    || (strchr(Tcl_GetString(elt), '\\') == NULL)) {
 
 			if (PATHFLAGS(elt)) {
 			    return TclNewFSPathObj(elt, str, len);
 			}
 			if (TCL_PATH_ABSOLUTE != Tcl_FSGetPathType(elt)) {
@@ -948,12 +950,11 @@
     }
 
     assert ( res == NULL );
 
     for (i = 0; i < elements; i++) {
-	int driveNameLength;
-	size_t strEltLen, length;
+	int driveNameLength, strEltLen, length;
 	Tcl_PathType type;
 	char *strElt, *ptr;
 	Tcl_Obj *driveName = NULL;
 	Tcl_Obj *elt = objv[i];
 
@@ -1097,13 +1098,13 @@
 		}
 	    }
 
 	    if (length > 0 && ptr[length -1] != '/') {
 		Tcl_AppendToObj(res, &separator, 1);
-		(void)TclGetStringFromObj(res, &length);
+		TclGetStringFromObj(res, &length);
 	    }
-	    Tcl_SetObjLength(res, length + strlen(strElt));
+	    Tcl_SetObjLength(res, length + (int) strlen(strElt));
 
 	    ptr = TclGetString(res) + length;
 	    for (; *strElt != '\0'; strElt++) {
 		if (*strElt == separator) {
 		    while (strElt[1] == separator) {
@@ -1201,11 +1202,11 @@
  * Helper function for SetFsPathFromAny. Returns position of first directory
  * delimiter in the path. If no separator is found, then returns the position
  * of the end of the string.
  */
 
-static size_t
+static int
 FindSplitPos(
     const char *path,
     int separator)
 {
     int count = 0;
@@ -1255,11 +1256,11 @@
 
 Tcl_Obj *
 TclNewFSPathObj(
     Tcl_Obj *dirPtr,
     const char *addStrRep,
-    size_t len)
+    int len)
 {
     FsPath *fsPathPtr;
     Tcl_Obj *pathPtr;
     const char *p;
     int state = 0, count = 0;
@@ -1287,11 +1288,11 @@
 	Tcl_DecrRefCount(tail);
 	return pathPtr;
     }
 
     pathPtr = Tcl_NewObj();
-    fsPathPtr = Tcl_Alloc(sizeof(FsPath));
+    fsPathPtr = ckalloc(sizeof(FsPath));
 
     /*
      * Set up the path.
      */
 
@@ -1312,16 +1313,16 @@
      * Look for path components made up of only "."
      * This is overly conservative analysis to keep simple. It may mark some
      * things as needing more aggressive normalization that don't actually
      * need it. No harm done.
      */
-    for (p = addStrRep; len+1 > 1; p++, len--) {
+    for (p = addStrRep; len > 0; p++, len--) {
 	switch (state) {
 	case 0:		/* So far only "." since last dirsep or start */
 	    switch (*p) {
 	    case '.':
-		count = 1;
+		count++;
 		break;
 	    case '/':
 	    case '\\':
 	    case ':':
 		if (count) {
@@ -1354,24 +1355,24 @@
 static Tcl_Obj *
 AppendPath(
     Tcl_Obj *head,
     Tcl_Obj *tail)
 {
+    int numBytes;
     const char *bytes;
     Tcl_Obj *copy = Tcl_DuplicateObj(head);
-    size_t length;
 
     /*
      * This is likely buggy when dealing with virtual filesystem drivers
      * that use some character other than "/" as a path separator.  I know
      * of no evidence that such a foolish thing exists.  This solution was
      * chosen so that "JoinPath" operations that pass through either path
      * intrep produce the same results; that is, bugward compatibility.  If
      * we need to fix that bug here, it needs fixing in TclJoinPath() too.
      */
-    bytes = TclGetStringFromObj(tail, &length);
-    if (length == 0) {
+    bytes = TclGetStringFromObj(tail, &numBytes);
+    if (numBytes == 0) {
 	Tcl_AppendToObj(copy, "/", 1);
     } else {
 	TclpNativeJoinPath(copy, bytes);
     }
     return copy;
@@ -1403,11 +1404,11 @@
 TclFSMakePathRelative(
     Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
     Tcl_Obj *pathPtr,		/* The path we have. */
     Tcl_Obj *cwdPtr)		/* Make it relative to this. */
 {
-    size_t cwdLen, len;
+    int cwdLen, len;
     const char *tempStr;
     Tcl_ObjIntRep *irPtr = TclFetchIntRep(pathPtr, &fsPathType);
 
     if (irPtr) {
 	FsPath *fsPathPtr = PATHOBJ(pathPtr);
@@ -1479,11 +1480,11 @@
 
     if (TclHasIntRep(pathPtr, &fsPathType)) {
 	return TCL_OK;
     }
 
-    fsPathPtr = Tcl_Alloc(sizeof(FsPath));
+    fsPathPtr = ckalloc(sizeof(FsPath));
 
     /*
      * It's a pure normalized absolute path.
      */
 
@@ -1514,11 +1515,11 @@
  *	efficient way of creating the appropriate path object type.
  *
  *	Any memory which is allocated for 'clientData' should be retained
  *	until clientData is passed to the filesystem's freeInternalRepProc
  *	when it can be freed. The built in platform-specific filesystems use
- *	'Tcl_Alloc' to allocate clientData, and Tcl_Free to free it.
+ *	'ckalloc' to allocate clientData, and ckfree to free it.
  *
  * Results:
  *	NULL or a valid path object pointer, with refCount zero.
  *
  * Side effects:
@@ -1547,11 +1548,11 @@
      * Free old representation; shouldn't normally be any, but best to be
      * safe.
      */
 
     Tcl_StoreIntRep(pathPtr, &fsPathType, NULL);
-    fsPathPtr = Tcl_Alloc(sizeof(FsPath));
+    fsPathPtr = ckalloc(sizeof(FsPath));
 
     fsPathPtr->translatedPathPtr = NULL;
 
     Tcl_IncrRefCount(fsPathPtr->normPathPtr = Tcl_DuplicateObj(pathPtr));
     fsPathPtr->cwdPtr = NULL;
@@ -1672,13 +1673,13 @@
     Tcl_Obj *pathPtr)
 {
     Tcl_Obj *transPtr = Tcl_FSGetTranslatedPath(interp, pathPtr);
 
     if (transPtr != NULL) {
-	size_t len;
+	int len;
 	const char *orig = TclGetStringFromObj(transPtr, &len);
-	char *result = Tcl_Alloc(len+1);
+	char *result = ckalloc(len+1);
 
 	memcpy(result, orig, len+1);
 	TclDecrRefCount(transPtr);
 	return result;
     }
@@ -1722,22 +1723,21 @@
 	 * This is a special path object which is the result of something like
 	 * 'file join'
 	 */
 
 	Tcl_Obj *dir, *copy;
-	size_t tailLen, cwdLen;
-	int pathType;
+	int tailLen, cwdLen, pathType;
 
 	pathType = Tcl_FSGetPathType(fsPathPtr->cwdPtr);
 	dir = Tcl_FSGetNormalizedPath(interp, fsPathPtr->cwdPtr);
 	if (dir == NULL) {
 	    return NULL;
 	}
 	/* TODO: Figure out why this is needed. */
 	TclGetString(pathPtr);
 
-	(void)TclGetStringFromObj(fsPathPtr->normPathPtr, &tailLen);
+	TclGetStringFromObj(fsPathPtr->normPathPtr, &tailLen);
 	if (tailLen) {
 	    copy = AppendPath(dir, fsPathPtr->normPathPtr);
 	} else {
 	    copy = Tcl_DuplicateObj(dir);
 	}
@@ -1833,17 +1833,17 @@
 	    if (SetFsPathFromAny(interp, pathPtr) != TCL_OK) {
 		return NULL;
 	    }
 	    fsPathPtr = PATHOBJ(pathPtr);
 	} else if (fsPathPtr->normPathPtr == NULL) {
-	    size_t cwdLen;
+	    int cwdLen;
 	    Tcl_Obj *copy;
 
 	    copy = AppendPath(fsPathPtr->cwdPtr, pathPtr);
 
 	    (void) TclGetStringFromObj(fsPathPtr->cwdPtr, &cwdLen);
-	    cwdLen += (TclGetString(copy)[cwdLen] == '/');
+	    cwdLen += (Tcl_GetString(copy)[cwdLen] == '/');
 
 	    /*
 	     * Normalize the combined string, but only starting after the end
 	     * of the previously normalized 'dir'. This should be much faster!
 	     */
@@ -2178,12 +2178,11 @@
 Tcl_FSEqualPaths(
     Tcl_Obj *firstPtr,
     Tcl_Obj *secondPtr)
 {
     const char *firstStr, *secondStr;
-    size_t firstLen, secondLen;
-    int tempErrno;
+    int firstLen, secondLen, tempErrno;
 
     if (firstPtr == secondPtr) {
 	return 1;
     }
 
@@ -2238,14 +2237,14 @@
 static int
 SetFsPathFromAny(
     Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
     Tcl_Obj *pathPtr)		/* The object to convert. */
 {
-    size_t len;
+    int len;
     FsPath *fsPathPtr;
     Tcl_Obj *transPtr;
-    char *name;
+    const char *name;
 
     if (TclHasIntRep(pathPtr, &fsPathType)) {
 	return TCL_OK;
     }
 
@@ -2269,11 +2268,11 @@
      * Handle tilde substitutions, if needed.
      */
 
     if (len && name[0] == '~') {
 	Tcl_DString temp;
-	size_t split;
+	int split;
 	char separator = '/';
 
 	/*
 	 * We have multiple cases '~/foo/bar...', '~user/foo/bar...', etc.
 	 * split becomes value 1 for '~/...' as well as for '~'.
@@ -2357,12 +2356,11 @@
 		 * Skip '~'. It's replaced by its expansion.
 		 */
 
 		objc--; objv++;
 		while (objc--) {
-		    TclpNativeJoinPath(transPtr, TclGetString(*objv));
-		    objv++;
+		    TclpNativeJoinPath(transPtr, Tcl_GetString(*objv++));
 		}
 		TclDecrRefCount(parts);
 	    } else {
 		Tcl_Obj *pair[2];
 
@@ -2384,11 +2382,11 @@
     /*
      * Now we have a translated filename in 'transPtr'. This will have forward
      * slashes on Windows, and will not contain any ~user sequences.
      */
 
-    fsPathPtr = Tcl_Alloc(sizeof(FsPath));
+    fsPathPtr = ckalloc(sizeof(FsPath));
 
     if (transPtr == pathPtr) {
         transPtr = Tcl_DuplicateObj(pathPtr);
         fsPathPtr->filesystemEpoch = 0;
     } else {
@@ -2435,20 +2433,20 @@
 	    freeProc(fsPathPtr->nativePathPtr);
 	    fsPathPtr->nativePathPtr = NULL;
 	}
     }
 
-    Tcl_Free(fsPathPtr);
+    ckfree(fsPathPtr);
 }
 
 static void
 DupFsPathInternalRep(
     Tcl_Obj *srcPtr,		/* Path obj with internal rep to copy. */
     Tcl_Obj *copyPtr)		/* Path obj with internal rep to set. */
 {
     FsPath *srcFsPathPtr = PATHOBJ(srcPtr);
-    FsPath *copyFsPathPtr = Tcl_Alloc(sizeof(FsPath));
+    FsPath *copyFsPathPtr = ckalloc(sizeof(FsPath));
 
     SETPATHOBJ(copyPtr, copyFsPathPtr);
 
     copyFsPathPtr->translatedPathPtr = srcFsPathPtr->translatedPathPtr;
     if (copyFsPathPtr->translatedPathPtr != NULL) {
@@ -2501,14 +2499,14 @@
  *---------------------------------------------------------------------------
  */
 
 static void
 UpdateStringOfFsPath(
-    register Tcl_Obj *pathPtr)	/* path obj with string rep to update. */
+    Tcl_Obj *pathPtr)	/* path obj with string rep to update. */
 {
     FsPath *fsPathPtr = PATHOBJ(pathPtr);
-    size_t cwdLen;
+    int cwdLen;
     Tcl_Obj *copy;
 
     if (PATHFLAGS(pathPtr) == 0 || fsPathPtr->cwdPtr == NULL) {
 	Tcl_Panic("Called UpdateStringOfFsPath with invalid object");
     }
@@ -2576,11 +2574,11 @@
 	 * It is somewhat unusual to reach this code path without the object
 	 * being of fsPathType. However, we do our best to deal with the
 	 * situation.
 	 */
 
-	size_t len;
+	int len;
 
 	(void) TclGetStringFromObj(pathPtr, &len);
 	if (len == 0) {
 	    /*
 	     * We reject the empty path "".

Index: generic/tclPipe.c
==================================================================
--- generic/tclPipe.c
+++ generic/tclPipe.c
@@ -181,16 +181,16 @@
 Tcl_DetachPids(
     int numPids,		/* Number of pids to detach: gives size of
 				 * array pointed to by pidPtr. */
     Tcl_Pid *pidPtr)		/* Array of pids to detach. */
 {
-    register Detached *detPtr;
+    Detached *detPtr;
     int i;
 
     Tcl_MutexLock(&pipeMutex);
     for (i = 0; i < numPids; i++) {
-	detPtr = Tcl_Alloc(sizeof(Detached));
+	detPtr = ckalloc(sizeof(Detached));
 	detPtr->pid = pidPtr[i];
 	detPtr->nextPtr = detList;
 	detList = detPtr;
     }
     Tcl_MutexUnlock(&pipeMutex);
@@ -217,11 +217,11 @@
  */
 
 void
 Tcl_ReapDetachedProcs(void)
 {
-    register Detached *detPtr;
+    Detached *detPtr;
     Detached *nextPtr, *prevPtr;
     int status, code;
 
     Tcl_MutexLock(&pipeMutex);
     for (detPtr = detList, prevPtr = NULL; detPtr != NULL; ) {
@@ -236,11 +236,11 @@
 	if (prevPtr == NULL) {
 	    detList = detPtr->nextPtr;
 	} else {
 	    prevPtr->nextPtr = detPtr->nextPtr;
 	}
-	Tcl_Free(detPtr);
+	ckfree(detPtr);
 	detPtr = nextPtr;
     }
     Tcl_MutexUnlock(&pipeMutex);
 }
 
@@ -334,11 +334,11 @@
 	    Tcl_Obj *objPtr;
 
 	    Tcl_Seek(errorChan, 0, SEEK_SET);
 	    objPtr = Tcl_NewObj();
 	    count = Tcl_ReadChars(errorChan, objPtr, -1, 0);
-	    if (count == -1) {
+	    if (count < 0) {
 		result = TCL_ERROR;
 		Tcl_DecrRefCount(objPtr);
 		Tcl_ResetResult(interp);
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"error reading stderr output file: %s",
@@ -411,11 +411,11 @@
 				 * redirection in the command). The file id
 				 * with which to write to this pipe is stored
 				 * at *inPipePtr. NULL means command specified
 				 * its own input source. */
     TclFile *outPipePtr,	/* If non-NULL, output to the pipeline goes to
-				 * a pipe, unless overriden by redirection in
+				 * a pipe, unless overridden by redirection in
 				 * the command. The file id with which to read
 				 * frome this pipe is stored at *outPipePtr.
 				 * NULL means command specified its own output
 				 * sink. */
     TclFile *errFilePtr)	/* If non-NULL, all stderr output from the
@@ -822,11 +822,11 @@
      * Scan through the argc array, creating a process for each group of
      * arguments between the "|" characters.
      */
 
     Tcl_ReapDetachedProcs();
-    pidPtr = Tcl_Alloc(cmdCount * sizeof(Tcl_Pid));
+    pidPtr = ckalloc(cmdCount * sizeof(Tcl_Pid));
 
     curInFile = inputFile;
 
     for (i = 0; i < argc; i = lastArg + 1) {
 	int result, joinThisError;
@@ -976,11 +976,11 @@
 	for (i = 0; i < numPids; i++) {
 	    if (pidPtr[i] != (Tcl_Pid) -1) {
 		Tcl_DetachPids(1, &pidPtr[i]);
 	    }
 	}
-	Tcl_Free(pidPtr);
+	ckfree(pidPtr);
     }
     numPids = -1;
     goto cleanup;
 }
 
@@ -1080,11 +1080,11 @@
     return channel;
 
   error:
     if (numPids > 0) {
 	Tcl_DetachPids(numPids, pidPtr);
-	Tcl_Free(pidPtr);
+	ckfree(pidPtr);
     }
     if (inPipe != NULL) {
 	TclpCloseFile(inPipe);
     }
     if (outPipe != NULL) {

Index: generic/tclPkg.c
==================================================================
--- generic/tclPkg.c
+++ generic/tclPkg.c
@@ -55,11 +55,11 @@
  * record of the following type. These records are stored in the
  * "packageTable" hash table in the interpreter, keyed by package name such as
  * "Tk" (no version number).
  */
 
-typedef struct {
+typedef struct Package {
     Tcl_Obj *version;
     PkgAvail *availPtr;		/* First in list of all available versions of
 				 * this package. */
     const void *clientData;	/* Client data. */
 } Package;
@@ -109,11 +109,11 @@
 /*
  * Helper macros.
  */
 
 #define DupBlock(v,s,len) \
-    ((v) = Tcl_Alloc(len), memcpy((v),(s),(len)))
+    ((v) = ckalloc(len), memcpy((v),(s),(len)))
 #define DupString(v,s) \
     do { \
 	size_t local__len = strlen(s) + 1; \
 	DupBlock((v),(s),local__len); \
     } while (0)
@@ -173,17 +173,17 @@
 
     if (CheckVersionAndConvert(interp, Tcl_GetString(pkgPtr->version), &pvi,
 	    NULL) != TCL_OK) {
 	return TCL_ERROR;
     } else if (CheckVersionAndConvert(interp, version, &vi, NULL) != TCL_OK) {
-	Tcl_Free(pvi);
+	ckfree(pvi);
 	return TCL_ERROR;
     }
 
     res = CompareVersions(pvi, vi, NULL);
-    Tcl_Free(pvi);
-    Tcl_Free(vi);
+    ckfree(pvi);
+    ckfree(vi);
 
     if (res == 0) {
 	if (clientData != NULL) {
 	    pkgPtr->clientData = clientData;
 	}
@@ -234,21 +234,21 @@
 
     while (pkgFiles->names) {
 	PkgName *name = pkgFiles->names;
 
 	pkgFiles->names = name->nextPtr;
-	Tcl_Free(name);
+	ckfree(name);
     }
     entry = Tcl_FirstHashEntry(&pkgFiles->table, &search);
     while (entry) {
 	Tcl_Obj *obj = (Tcl_Obj *)Tcl_GetHashValue(entry);
 
 	Tcl_DecrRefCount(obj);
 	entry = Tcl_NextHashEntry(&search);
     }
     Tcl_DeleteHashTable(&pkgFiles->table);
-    Tcl_Free(pkgFiles);
+    ckfree(pkgFiles);
     return;
 }
 
 void *
 TclInitPkgFiles(
@@ -259,11 +259,11 @@
      */
 
     PkgFiles *pkgFiles = Tcl_GetAssocData(interp, "tclPkgFiles", NULL);
 
     if (!pkgFiles) {
-	pkgFiles = Tcl_Alloc(sizeof(PkgFiles));
+	pkgFiles = ckalloc(sizeof(PkgFiles));
 	pkgFiles->names = NULL;
 	Tcl_InitHashTable(&pkgFiles->table, TCL_STRING_KEYS);
 	Tcl_SetAssocData(interp, "tclPkgFiles", PkgFilesCleanupProc, pkgFiles);
     }
     return pkgFiles;
@@ -278,15 +278,15 @@
 	    Tcl_GetAssocData(interp, "tclPkgFiles", NULL);
 
     if (pkgFiles && pkgFiles->names) {
 	const char *name = pkgFiles->names->name;
 	Tcl_HashTable *table = &pkgFiles->table;
-	int new;
-	Tcl_HashEntry *entry = Tcl_CreateHashEntry(table, name, &new);
+	int isNew;
+	Tcl_HashEntry *entry = Tcl_CreateHashEntry(table, name, &isNew);
 	Tcl_Obj *list;
 
-	if (new) {
+	if (isNew) {
 	    list = Tcl_NewObj();
 	    Tcl_SetHashValue(entry, list);
 	    Tcl_IncrRefCount(list);
 	} else {
 	    list = Tcl_GetHashValue(entry);
@@ -468,11 +468,11 @@
     Require *reqPtr;
 
     if (code != TCL_OK) {
 	return code;
     }
-    reqPtr = Tcl_Alloc(sizeof(Require));
+    reqPtr = ckalloc(sizeof(Require));
     Tcl_NRAddCallback(interp, PkgRequireCoreCleanup, reqPtr, NULL, NULL, NULL);
     reqPtr->clientDataPtr = data[3];
     reqPtr->name = name;
     reqPtr->pkgPtr = FindPackage(interp, name);
     if (reqPtr->pkgPtr->version == NULL) {
@@ -608,11 +608,11 @@
     if (reqc != 0) {
 	CheckVersionAndConvert(interp, Tcl_GetString(reqPtr->pkgPtr->version),
 		&pkgVersionI, NULL);
 	satisfies = SomeRequirementSatisfied(pkgVersionI, reqc, reqv);
 
-	Tcl_Free(pkgVersionI);
+	ckfree(pkgVersionI);
 
 	if (!satisfies) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "version conflict for package \"%s\": have %s, need",
 		    name, Tcl_GetString(reqPtr->pkgPtr->version)));
@@ -636,11 +636,11 @@
 PkgRequireCoreCleanup(
     ClientData data[],
     Tcl_Interp *interp,
     int result)
 {
-    Tcl_Free(data[0]);
+    ckfree(data[0]);
     return result;
 }
 
 static int
 SelectPackage(
@@ -705,11 +705,11 @@
 	 */
 
 	if (reqc > 0) {
 	    satisfies = SomeRequirementSatisfied(availVersion, reqc, reqv);
 	    if (!satisfies) {
-		Tcl_Free(availVersion);
+		ckfree(availVersion);
 		availVersion = NULL;
 		continue;
 	    }
 	}
 
@@ -724,11 +724,11 @@
 		/*
 		 * The version of the package sought is better than the
 		 * currently selected version.
 		 */
 
-		Tcl_Free(bestVersion);
+		ckfree(bestVersion);
 		bestVersion = NULL;
 		goto newbest;
 	    }
 	} else {
 	newbest:
@@ -739,11 +739,11 @@
 	    bestPtr = availPtr;
 	    CheckVersionAndConvert(interp, bestPtr->version, &bestVersion, NULL);
 	}
 
 	if (!availStable) {
-	    Tcl_Free(availVersion);
+	    ckfree(availVersion);
 	    availVersion = NULL;
 	    continue;
 	}
 
 	if (bestStablePtr != NULL) {
@@ -757,11 +757,11 @@
 		/*
 		 * This stable version of the package sought is better than
 		 * the currently selected stable version.
 		 */
 
-		Tcl_Free(bestStableVersion);
+		ckfree(bestStableVersion);
 		bestStableVersion = NULL;
 		goto newstable;
 	    }
 	} else {
 	newstable:
@@ -773,25 +773,25 @@
 	    bestStablePtr = availPtr;
 	    CheckVersionAndConvert(interp, bestStablePtr->version,
 		    &bestStableVersion, NULL);
 	}
 
-	Tcl_Free(availVersion);
+	ckfree(availVersion);
 	availVersion = NULL;
     } /* end for */
 
     /*
      * Clean up memorized internal reps, if any.
      */
 
     if (bestVersion != NULL) {
-	Tcl_Free(bestVersion);
+	ckfree(bestVersion);
 	bestVersion = NULL;
     }
 
     if (bestStableVersion != NULL) {
-	Tcl_Free(bestStableVersion);
+	ckfree(bestStableVersion);
 	bestStableVersion = NULL;
     }
 
     /*
      * Now choose a version among the two best. For 'latest' we simply take
@@ -826,11 +826,11 @@
 
 	/*
 	 * Push "ifneeded" package name in "tclPkgFiles" assocdata.
 	 */
 
-	pkgName = Tcl_Alloc(sizeof(PkgName) + strlen(name));
+	pkgName = ckalloc(sizeof(PkgName) + strlen(name));
 	pkgName->nextPtr = pkgFiles->names;
 	strcpy(pkgName->name, name);
 	pkgFiles->names = pkgName;
 	if (bestPtr->pkgIndex) {
 	    TclPkgFileSeen(interp, bestPtr->pkgIndex);
@@ -862,11 +862,11 @@
      */
 
     PkgFiles *pkgFiles = Tcl_GetAssocData(interp, "tclPkgFiles", NULL);
     PkgName *pkgName = pkgFiles->names;
     pkgFiles->names = pkgName->nextPtr;
-    Tcl_Free(pkgName);
+    ckfree(pkgName);
 
     reqPtr->pkgPtr = FindPackage(interp, name);
     if (result == TCL_OK) {
 	Tcl_ResetResult(interp);
 	if (reqPtr->pkgPtr->version == NULL) {
@@ -883,17 +883,17 @@
 	    if (TCL_OK != CheckVersionAndConvert(interp,
 		    Tcl_GetString(reqPtr->pkgPtr->version), &pvi, NULL)) {
 		result = TCL_ERROR;
 	    } else if (CheckVersionAndConvert(interp,
 		    versionToProvide, &vi, NULL) != TCL_OK) {
-		Tcl_Free(pvi);
+		ckfree(pvi);
 		result = TCL_ERROR;
 	    } else {
 		int res = CompareVersions(pvi, vi, NULL);
 
-		Tcl_Free(pvi);
-		Tcl_Free(vi);
+		ckfree(pvi);
+		ckfree(vi);
 		if (res != 0) {
 		    result = TCL_ERROR;
 		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			    "attempt to provide package %s %s failed:"
 			    " package %s %s provided instead",
@@ -1107,13 +1107,12 @@
 	    Tcl_WrongNumArgs(interp, 2, objv, "package");
 	    return TCL_ERROR;
 	}
 	pkgFiles = (PkgFiles *) Tcl_GetAssocData(interp, "tclPkgFiles", NULL);
 	if (pkgFiles) {
-	    Tcl_HashEntry *entry = Tcl_FindHashEntry(&pkgFiles->table,
-		    TclGetString(objv[2]));
-
+	    Tcl_HashEntry *entry =
+		    Tcl_FindHashEntry(&pkgFiles->table, Tcl_GetString(objv[2]));
 	    if (entry) {
 		Tcl_SetObjResult(interp, (Tcl_Obj *)Tcl_GetHashValue(entry));
 	    }
 	}
 	break;
@@ -1150,19 +1149,18 @@
 		Tcl_EventuallyFree(availPtr->script, TCL_DYNAMIC);
 		if (availPtr->pkgIndex) {
 		    Tcl_EventuallyFree(availPtr->pkgIndex, TCL_DYNAMIC);
 		    availPtr->pkgIndex = NULL;
 		}
-		Tcl_Free(availPtr);
+		ckfree(availPtr);
 	    }
-	    Tcl_Free(pkgPtr);
+	    ckfree(pkgPtr);
 	}
 	break;
     }
     case PKG_IFNEEDED: {
-	size_t length;
-	int res;
+	int length, res;
 	char *argv3i, *avi;
 
 	if ((objc != 4) && (objc != 5)) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "package version ?script?");
 	    return TCL_ERROR;
@@ -1173,11 +1171,11 @@
 	}
 	argv2 = TclGetString(objv[2]);
 	if (objc == 4) {
 	    hPtr = Tcl_FindHashEntry(&iPtr->packageTable, argv2);
 	    if (hPtr == NULL) {
-		Tcl_Free(argv3i);
+		ckfree(argv3i);
 		return TCL_OK;
 	    }
 	    pkgPtr = Tcl_GetHashValue(hPtr);
 	} else {
 	    pkgPtr = FindPackage(interp, argv2);
@@ -1186,20 +1184,20 @@
 
 	for (availPtr = pkgPtr->availPtr, prevPtr = NULL; availPtr != NULL;
 		prevPtr = availPtr, availPtr = availPtr->nextPtr) {
 	    if (CheckVersionAndConvert(interp, availPtr->version, &avi,
 		    NULL) != TCL_OK) {
-		Tcl_Free(argv3i);
+		ckfree(argv3i);
 		return TCL_ERROR;
 	    }
 
 	    res = CompareVersions(avi, argv3i, NULL);
-	    Tcl_Free(avi);
+	    ckfree(avi);
 
 	    if (res == 0) {
 		if (objc == 4) {
-		    Tcl_Free(argv3i);
+		    ckfree(argv3i);
 		    Tcl_SetObjResult(interp,
 			    Tcl_NewStringObj(availPtr->script, -1));
 		    return TCL_OK;
 		}
 		Tcl_EventuallyFree(availPtr->script, TCL_DYNAMIC);
@@ -1208,17 +1206,17 @@
 		    availPtr->pkgIndex = NULL;
 		}
 		break;
 	    }
 	}
-	Tcl_Free(argv3i);
+	ckfree(argv3i);
 
 	if (objc == 4) {
 	    return TCL_OK;
 	}
 	if (availPtr == NULL) {
-	    availPtr = Tcl_Alloc(sizeof(PkgAvail));
+	    availPtr = ckalloc(sizeof(PkgAvail));
 	    availPtr->pkgIndex = NULL;
 	    DupBlock(availPtr->version, argv3, length + 1);
 
 	    if (prevPtr == NULL) {
 		availPtr->nextPtr = pkgPtr->availPtr;
@@ -1396,20 +1394,20 @@
 		    newObjvPtr, NULL);
 	    return TCL_OK;
 	}
 	break;
     case PKG_UNKNOWN: {
-	size_t length;
+	int length;
 
 	if (objc == 2) {
 	    if (iPtr->packageUnknown != NULL) {
 		Tcl_SetObjResult(interp,
 			Tcl_NewStringObj(iPtr->packageUnknown, -1));
 	    }
 	} else if (objc == 3) {
 	    if (iPtr->packageUnknown != NULL) {
-		Tcl_Free(iPtr->packageUnknown);
+		ckfree(iPtr->packageUnknown);
 	    }
 	    argv2 = TclGetStringFromObj(objv[2], &length);
 	    if (argv2[0] == 0) {
 		iPtr->packageUnknown = NULL;
 	    } else {
@@ -1466,11 +1464,11 @@
 	argv3 = TclGetString(objv[3]);
 	argv2 = TclGetString(objv[2]);
 	if (CheckVersionAndConvert(interp, argv2, &iva, NULL) != TCL_OK ||
 		CheckVersionAndConvert(interp, argv3, &ivb, NULL) != TCL_OK) {
 	    if (iva != NULL) {
-		Tcl_Free(iva);
+		ckfree(iva);
 	    }
 
 	    /*
 	     * ivb cannot be set in this branch.
 	     */
@@ -1482,12 +1480,12 @@
 	 * Comparison is done on the internal representation.
 	 */
 
 	Tcl_SetObjResult(interp,
 		Tcl_NewIntObj(CompareVersions(iva, ivb, NULL)));
-	Tcl_Free(iva);
-	Tcl_Free(ivb);
+	ckfree(iva);
+	ckfree(ivb);
 	break;
     case PKG_VERSIONS:
 	if (objc != 3) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "package");
 	    return TCL_ERROR;
@@ -1517,16 +1515,16 @@
 
 	argv2 = TclGetString(objv[2]);
 	if (CheckVersionAndConvert(interp, argv2, &argv2i, NULL) != TCL_OK) {
 	    return TCL_ERROR;
 	} else if (CheckAllRequirements(interp, objc-3, objv+3) != TCL_OK) {
-	    Tcl_Free(argv2i);
+	    ckfree(argv2i);
 	    return TCL_ERROR;
 	}
 
 	satisfies = SomeRequirementSatisfied(argv2i, objc-3, objv+3);
-	Tcl_Free(argv2i);
+	ckfree(argv2i);
 
 	Tcl_SetObjResult(interp, Tcl_NewBooleanObj(satisfies));
 	break;
     }
     default:
@@ -1574,11 +1572,11 @@
     int isNew;
     Package *pkgPtr;
 
     hPtr = Tcl_CreateHashEntry(&iPtr->packageTable, name, &isNew);
     if (isNew) {
-	pkgPtr = Tcl_Alloc(sizeof(Package));
+	pkgPtr = ckalloc(sizeof(Package));
 	pkgPtr->version = NULL;
 	pkgPtr->availPtr = NULL;
 	pkgPtr->clientData = NULL;
 	Tcl_SetHashValue(hPtr, pkgPtr);
     } else {
@@ -1626,17 +1624,17 @@
 	    Tcl_EventuallyFree(availPtr->script, TCL_DYNAMIC);
 	    if (availPtr->pkgIndex) {
 		Tcl_EventuallyFree(availPtr->pkgIndex, TCL_DYNAMIC);
 		availPtr->pkgIndex = NULL;
 	    }
-	    Tcl_Free(availPtr);
+	    ckfree(availPtr);
 	}
-	Tcl_Free(pkgPtr);
+	ckfree(pkgPtr);
     }
     Tcl_DeleteHashTable(&iPtr->packageTable);
     if (iPtr->packageUnknown != NULL) {
-	Tcl_Free(iPtr->packageUnknown);
+	ckfree(iPtr->packageUnknown);
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1672,11 +1670,11 @@
     int hasunstable = 0;
     /*
      * 4* assuming that each char is a separator (a,b become ' -x ').
      * 4+ to have spce for an additional -2 at the end
      */
-    char *ibuf = Tcl_Alloc(4 + 4*strlen(string));
+    char *ibuf = ckalloc(4 + 4*strlen(string));
     char *ip = ibuf;
 
     /*
      * Basic rules
      * (1) First character has to be a digit.
@@ -1740,20 +1738,20 @@
     if (prevChar!='.' && prevChar!='a' && prevChar!='b') {
 	*ip = '\0';
 	if (internal != NULL) {
 	    *internal = ibuf;
 	} else {
-	    Tcl_Free(ibuf);
+	    ckfree(ibuf);
 	}
 	if (stable != NULL) {
 	    *stable = !hasunstable;
 	}
 	return TCL_OK;
     }
 
   error:
-    Tcl_Free(ibuf);
+    ckfree(ibuf);
     Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 	    "expected version number but got \"%s\"", string));
     Tcl_SetErrorCode(interp, "TCL", "VALUE", "VERSION", NULL);
     return TCL_ERROR;
 }
@@ -2023,11 +2021,11 @@
 
     /*
      * Exactly one dash is present. Copy the string, split at the location of
      * dash and check that both parts are versions. Note that the max part can
      * be empty. Also note that the string allocated with strdup() must be
-     * freed with free() and not Tcl_Free().
+     * freed with free() and not ckfree().
      */
 
     DupString(buf, string);
     dash = buf + (dash - string);
     *dash = '\0';		/* buf now <=> min part */
@@ -2034,15 +2032,15 @@
     dash++;			/* dash now <=> max part */
 
     if ((CheckVersionAndConvert(interp, buf, NULL, NULL) != TCL_OK) ||
 	    ((*dash != '\0') &&
 	    (CheckVersionAndConvert(interp, dash, NULL, NULL) != TCL_OK))) {
-	Tcl_Free(buf);
+	ckfree(buf);
 	return TCL_ERROR;
     }
 
-    Tcl_Free(buf);
+    ckfree(buf);
     return TCL_OK;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -2067,12 +2065,11 @@
 				 * version. */
     Tcl_Obj *const reqv[])	/* 0 means to use the latest version
 				 * available. */
 {
     Tcl_Obj *result = Tcl_GetObjResult(interp);
-    int i;
-    size_t length;
+    int i, length;
 
     for (i = 0; i < reqc; i++) {
 	const char *v = TclGetStringFromObj(reqv[i], &length);
 
 	if ((length & 0x1) && (v[length/2] == '-')
@@ -2204,11 +2201,11 @@
 
 	CheckVersionAndConvert(NULL, req, &reqi, NULL);
 	strcat(reqi, " -2");
 	res = CompareVersions(havei, reqi, &thisIsMajor);
 	satisfied = (res == 0) || ((res == 1) && !thisIsMajor);
-	Tcl_Free(reqi);
+	ckfree(reqi);
 	return satisfied;
     }
 
     /*
      * Exactly one dash is present (Assumption of valid syntax). Copy the req,
@@ -2228,12 +2225,12 @@
 	 */
 
 	CheckVersionAndConvert(NULL, buf, &min, NULL);
 	strcat(min, " -2");
 	satisfied = (CompareVersions(havei, min, NULL) >= 0);
-	Tcl_Free(min);
-	Tcl_Free(buf);
+	ckfree(min);
+	ckfree(buf);
 	return satisfied;
     }
 
     /*
      * We have both min and max, and generate their internal reps. When
@@ -2251,13 +2248,13 @@
 	strcat(max, " -2");
 	satisfied = ((CompareVersions(min, havei, NULL) <= 0) &&
 		(CompareVersions(havei, max, NULL) < 0));
     }
 
-    Tcl_Free(min);
-    Tcl_Free(max);
-    Tcl_Free(buf);
+    ckfree(min);
+    ckfree(max);
+    ckfree(buf);
     return satisfied;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -2282,11 +2279,11 @@
 Tcl_PkgInitStubsCheck(
     Tcl_Interp *interp,
     const char * version,
     int exact)
 {
-    const char *actualVersion = Tcl_PkgPresentEx(interp, "Tcl", version, 0, NULL);
+    const char *actualVersion = Tcl_PkgPresent(interp, "Tcl", version, 0);
 
     if ((exact&1) && actualVersion) {
 	const char *p = version;
 	int count = 0;
 
@@ -2294,15 +2291,15 @@
 	    count += !isdigit(UCHAR(*p++));
 	}
 	if (count == 1) {
 	    if (0 != strncmp(version, actualVersion, strlen(version))) {
 		/* Construct error message */
-		Tcl_PkgPresentEx(interp, "Tcl", version, 1, NULL);
+		Tcl_PkgPresent(interp, "Tcl", version, 1);
 		return NULL;
 	    }
 	} else {
-	    return Tcl_PkgPresentEx(interp, "Tcl", version, 1, NULL);
+	    return Tcl_PkgPresent(interp, "Tcl", version, 1);
 	}
     }
     return actualVersion;
 }
 /*

Index: generic/tclPlatDecls.h
==================================================================
--- generic/tclPlatDecls.h
+++ generic/tclPlatDecls.h
@@ -50,40 +50,40 @@
  * Exported function declarations:
  */
 
 #if defined(_WIN32) || defined(__CYGWIN__) /* WIN */
 /* 0 */
-EXTERN TCHAR *		Tcl_WinUtfToTChar(const char *str, size_t len,
+EXTERN TCHAR *		Tcl_WinUtfToTChar(const char *str, int len,
 				Tcl_DString *dsPtr);
 /* 1 */
-EXTERN char *		Tcl_WinTCharToUtf(const TCHAR *str, size_t len,
+EXTERN char *		Tcl_WinTCharToUtf(const TCHAR *str, int len,
 				Tcl_DString *dsPtr);
 #endif /* WIN */
 #ifdef MAC_OSX_TCL /* MACOSX */
 /* 0 */
 EXTERN int		Tcl_MacOSXOpenBundleResources(Tcl_Interp *interp,
 				const char *bundleName, int hasResourceFile,
-				size_t maxPathLen, char *libraryPath);
+				int maxPathLen, char *libraryPath);
 /* 1 */
 EXTERN int		Tcl_MacOSXOpenVersionedBundleResources(
 				Tcl_Interp *interp, const char *bundleName,
 				const char *bundleVersion,
-				int hasResourceFile, size_t maxPathLen,
+				int hasResourceFile, int maxPathLen,
 				char *libraryPath);
 #endif /* MACOSX */
 
 typedef struct TclPlatStubs {
     int magic;
     void *hooks;
 
 #if defined(_WIN32) || defined(__CYGWIN__) /* WIN */
-    TCHAR * (*tcl_WinUtfToTChar) (const char *str, size_t len, Tcl_DString *dsPtr); /* 0 */
-    char * (*tcl_WinTCharToUtf) (const TCHAR *str, size_t len, Tcl_DString *dsPtr); /* 1 */
+    TCHAR * (*tcl_WinUtfToTChar) (const char *str, int len, Tcl_DString *dsPtr); /* 0 */
+    char * (*tcl_WinTCharToUtf) (const TCHAR *str, int len, Tcl_DString *dsPtr); /* 1 */
 #endif /* WIN */
 #ifdef MAC_OSX_TCL /* MACOSX */
-    int (*tcl_MacOSXOpenBundleResources) (Tcl_Interp *interp, const char *bundleName, int hasResourceFile, size_t maxPathLen, char *libraryPath); /* 0 */
-    int (*tcl_MacOSXOpenVersionedBundleResources) (Tcl_Interp *interp, const char *bundleName, const char *bundleVersion, int hasResourceFile, size_t maxPathLen, char *libraryPath); /* 1 */
+    int (*tcl_MacOSXOpenBundleResources) (Tcl_Interp *interp, const char *bundleName, int hasResourceFile, int maxPathLen, char *libraryPath); /* 0 */
+    int (*tcl_MacOSXOpenVersionedBundleResources) (Tcl_Interp *interp, const char *bundleName, const char *bundleVersion, int hasResourceFile, int maxPathLen, char *libraryPath); /* 1 */
 #endif /* MACOSX */
 } TclPlatStubs;
 
 extern const TclPlatStubs *tclPlatStubsPtr;
 

Index: generic/tclPreserve.c
==================================================================
--- generic/tclPreserve.c
+++ generic/tclPreserve.c
@@ -35,13 +35,13 @@
  * Global data structures used to hold the list of preserved data references.
  * These variables are protected by "preserveMutex".
  */
 
 static Reference *refArray = NULL;	/* First in array of references. */
-static size_t spaceAvl = 0;	/* Total number of structures available at
+static int spaceAvl = 0;	/* Total number of structures available at
 				 * *firstRefPtr. */
-static size_t inUse = 0;		/* Count of structures currently in use in
+static int inUse = 0;		/* Count of structures currently in use in
 				 * refArray. */
 TCL_DECLARE_MUTEX(preserveMutex)/* To protect the above statics */
 
 #define INITIAL_SIZE	2	/* Initial number of reference slots to make */
 
@@ -51,11 +51,11 @@
  * avoid the more time-expensive algorithm of Tcl_Preserve(). This mechanism
  * is mainly used when we have lots of references to a few big, expensive
  * objects that we don't want to live any longer than necessary.
  */
 
-typedef struct {
+typedef struct HandleStruct {
     void *ptr;			/* Pointer to the memory block being tracked.
 				 * This field will become NULL when the memory
 				 * block is deleted. This field must be the
 				 * first in the structure. */
 #ifdef TCL_MEM_DEBUG
@@ -87,11 +87,11 @@
 void
 TclFinalizePreserve(void)
 {
     Tcl_MutexLock(&preserveMutex);
     if (spaceAvl != 0) {
-	Tcl_Free(refArray);
+	ckfree(refArray);
 	refArray = NULL;
 	inUse = 0;
 	spaceAvl = 0;
     }
     Tcl_MutexUnlock(&preserveMutex);
@@ -119,11 +119,11 @@
 void
 Tcl_Preserve(
     ClientData clientData)	/* Pointer to malloc'ed block of memory. */
 {
     Reference *refPtr;
-    size_t i;
+    int i;
 
     /*
      * See if there is already a reference for this pointer. If so, just
      * increment its reference count.
      */
@@ -142,11 +142,11 @@
      * if it is full.
      */
 
     if (inUse == spaceAvl) {
 	spaceAvl = spaceAvl ? 2*spaceAvl : INITIAL_SIZE;
-	refArray = Tcl_Realloc(refArray, spaceAvl * sizeof(Reference));
+	refArray = ckrealloc(refArray, spaceAvl * sizeof(Reference));
     }
 
     /*
      * Make a new entry for the new reference.
      */
@@ -182,11 +182,11 @@
 void
 Tcl_Release(
     ClientData clientData)	/* Pointer to malloc'ed block of memory. */
 {
     Reference *refPtr;
-    size_t i;
+    int i;
 
     Tcl_MutexLock(&preserveMutex);
     for (i=0, refPtr=refArray ; i<inUse ; i++, refPtr++) {
 	int mustFree;
 	Tcl_FreeProc *freeProc;
@@ -222,11 +222,11 @@
 	 */
 
 	Tcl_MutexUnlock(&preserveMutex);
 	if (mustFree) {
 	    if (freeProc == TCL_DYNAMIC) {
-		Tcl_Free(clientData);
+		ckfree(clientData);
 	    } else {
 		freeProc(clientData);
 	    }
 	}
 	return;
@@ -262,11 +262,11 @@
 Tcl_EventuallyFree(
     ClientData clientData,	/* Pointer to malloc'ed block of memory. */
     Tcl_FreeProc *freeProc)	/* Function to actually do free. */
 {
     Reference *refPtr;
-    size_t i;
+    int i;
 
     /*
      * See if there is a reference for this pointer. If so, set its "mustFree"
      * flag (the flag had better not be set already!).
      */
@@ -289,11 +289,11 @@
     /*
      * No reference for this block.  Free it now.
      */
 
     if (freeProc == TCL_DYNAMIC) {
-	Tcl_Free(clientData);
+	ckfree(clientData);
     } else {
 	freeProc(clientData);
     }
 }
 
@@ -325,11 +325,11 @@
 TclHandleCreate(
     void *ptr)			/* Pointer to an arbitrary block of memory to
 				 * be tracked for deletion. Must not be
 				 * NULL. */
 {
-    HandleStruct *handlePtr = Tcl_Alloc(sizeof(HandleStruct));
+    HandleStruct *handlePtr = ckalloc(sizeof(HandleStruct));
 
     handlePtr->ptr = ptr;
 #ifdef TCL_MEM_DEBUG
     handlePtr->ptr2 = ptr;
 #endif
@@ -375,11 +375,11 @@
 		handlePtr, handlePtr->ptr2, handlePtr->ptr);
     }
 #endif
     handlePtr->ptr = NULL;
     if (handlePtr->refCount == 0) {
-	Tcl_Free(handlePtr);
+	ckfree(handlePtr);
     }
 }
 
 /*
  *---------------------------------------------------------------------------
@@ -458,11 +458,11 @@
 	Tcl_Panic("someone has changed the block referenced by the handle %p\nfrom %p to %p",
 		handlePtr, handlePtr->ptr2, handlePtr->ptr);
     }
 #endif
     if ((handlePtr->refCount-- <= 1) && (handlePtr->ptr == NULL)) {
-	Tcl_Free(handlePtr);
+	ckfree(handlePtr);
     }
 }
 
 /*
  * Local Variables:

Index: generic/tclProc.c
==================================================================
--- generic/tclProc.c
+++ generic/tclProc.c
@@ -155,11 +155,11 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
     Proc *procPtr;
     const char *procName;
     const char *simpleName, *procArgs, *procBody;
     Namespace *nsPtr, *altNsPtr, *cxtNsPtr;
     Tcl_Command cmd;
@@ -261,15 +261,15 @@
 
 	    if (contextPtr->line
 		    && (contextPtr->nline >= 4) && (contextPtr->line[3] >= 0)) {
 		int isNew;
 		Tcl_HashEntry *hePtr;
-		CmdFrame *cfPtr = Tcl_Alloc(sizeof(CmdFrame));
+		CmdFrame *cfPtr = ckalloc(sizeof(CmdFrame));
 
 		cfPtr->level = -1;
 		cfPtr->type = contextPtr->type;
-		cfPtr->line = Tcl_Alloc(sizeof(int));
+		cfPtr->line = ckalloc(sizeof(int));
 		cfPtr->line[0] = contextPtr->line[3];
 		cfPtr->nline = 1;
 		cfPtr->framePtr = NULL;
 		cfPtr->nextPtr = NULL;
 
@@ -293,13 +293,13 @@
 
 		    if (cfOldPtr->type == TCL_LOCATION_SOURCE) {
 			Tcl_DecrRefCount(cfOldPtr->data.eval.path);
 			cfOldPtr->data.eval.path = NULL;
 		    }
-		    Tcl_Free(cfOldPtr->line);
+		    ckfree(cfOldPtr->line);
 		    cfOldPtr->line = NULL;
-		    Tcl_Free(cfOldPtr);
+		    ckfree(cfOldPtr);
 		}
 		Tcl_SetHashValue(hePtr, cfPtr);
 	    }
 
 	    /*
@@ -327,11 +327,11 @@
      *	 - could be enhanced to handle also non-empty bodies that contain only
      *	   comments; however, parsing the body will slow down the compilation
      *	   of all procs whose argument list is just _args_
      */
 
-    if (objv[3]->typePtr == &tclProcBodyType) {
+    if (TclHasIntRep(objv[3], &tclProcBodyType)) {
 	goto done;
     }
 
     procArgs = TclGetString(objv[2]);
 
@@ -338,11 +338,11 @@
     while (*procArgs == ' ') {
 	procArgs++;
     }
 
     if ((procArgs[0] == 'a') && (strncmp(procArgs, "args", 4) == 0)) {
-	size_t numBytes;
+	int numBytes;
 
 	procArgs +=4;
 	while (*procArgs != '\0') {
 	    if (*procArgs != ' ') {
 		goto done;
@@ -403,13 +403,13 @@
     Tcl_Obj *bodyPtr,		/* Command body. */
     Proc **procPtrPtr)		/* Returns: pointer to proc data. */
 {
     Interp *iPtr = (Interp *) interp;
 
-    register Proc *procPtr = NULL;
+    Proc *procPtr = NULL;
     int i, result, numArgs;
-    register CompiledLocal *localPtr = NULL;
+    CompiledLocal *localPtr = NULL;
     Tcl_Obj **argArray;
     int precompiled = 0;
 
     ProcGetIntRep(bodyPtr, procPtr);
     if (procPtr != NULL) {
@@ -444,11 +444,11 @@
 	 * not want any bytecode internal representation.
 	 */
 
 	if (Tcl_IsShared(bodyPtr)) {
 	    const char *bytes;
-	    size_t length;
+	    int length;
 	    Tcl_Obj *sharedBodyPtr = bodyPtr;
 
 	    bytes = TclGetStringFromObj(bodyPtr, &length);
 	    bodyPtr = Tcl_NewStringObj(bytes, length);
 
@@ -467,11 +467,11 @@
 	 * will be a reference to it in the Proc structure.
 	 */
 
 	Tcl_IncrRefCount(bodyPtr);
 
-	procPtr = Tcl_Alloc(sizeof(Proc));
+	procPtr = ckalloc(sizeof(Proc));
 	procPtr->iPtr = iPtr;
 	procPtr->refCount = 1;
 	procPtr->bodyPtr = bodyPtr;
 	procPtr->numArgs = 0;	/* Actual argument count is set below. */
 	procPtr->numCompiledLocals = 0;
@@ -507,12 +507,11 @@
 	procPtr->numCompiledLocals = numArgs;
     }
 
     for (i = 0; i < numArgs; i++) {
 	const char *argname, *argnamei, *argnamelast;
-	int fieldCount;
-	size_t nameLength;
+	int fieldCount, nameLength;
 	Tcl_Obj **fieldValues;
 
 	/*
 	 * Now divide the specifier up into name and default.
 	 */
@@ -538,11 +537,11 @@
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "PROC",
 		    "FORMALARGUMENTFORMAT", NULL);
 	    goto procError;
 	}
 
-	argname = TclGetStringFromObj(fieldValues[0], &nameLength);
+	argname = Tcl_GetStringFromObj(fieldValues[0], &nameLength);
 
 	/*
 	 * Check that the formal parameter name is a scalar.
 	 */
 
@@ -551,11 +550,11 @@
 	while (argnamei < argnamelast) {
 	    if (*argnamei == '(') {
 		if (*argnamelast == ')') { /* We have an array element. */
 		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			    "formal parameter \"%s\" is an array element",
-			    TclGetString(fieldValues[0])));
+			    Tcl_GetString(fieldValues[0])));
 		    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "PROC",
 			    "FORMALARGUMENTFORMAT", NULL);
 		    goto procError;
 		}
 	    } else if (*argnamei == ':' && *(argnamei+1) == ':') {
@@ -600,13 +599,14 @@
 	    /*
 	     * Compare the default value if any.
 	     */
 
 	    if (localPtr->defValuePtr != NULL) {
-		size_t tmpLength, valueLength;
-		const char *tmpPtr = TclGetStringFromObj(localPtr->defValuePtr, &tmpLength);
-		const char *value = TclGetStringFromObj(fieldValues[1], &valueLength);
+		const char *tmpPtr = TclGetString(localPtr->defValuePtr);
+		size_t tmpLength = localPtr->defValuePtr->length;
+		const char *value = TclGetString(fieldValues[1]);
+		size_t valueLength = fieldValues[1]->length;
 
 		if ((valueLength != tmpLength)
 		     || memcmp(value, tmpPtr, tmpLength) != 0
 		) {
 		    Tcl_Obj *errorObj = Tcl_ObjPrintf(
@@ -632,11 +632,11 @@
 	    /*
 	     * Allocate an entry in the runtime procedure frame's array of
 	     * local variables for the argument.
 	     */
 
-	    localPtr = Tcl_Alloc(offsetof(CompiledLocal, name) + fieldValues[0]->length +1);
+	    localPtr = ckalloc(offsetof(CompiledLocal, name) + fieldValues[0]->length +1);
 	    if (procPtr->firstLocalPtr == NULL) {
 		procPtr->firstLocalPtr = procPtr->lastLocalPtr = localPtr;
 	    } else {
 		procPtr->lastLocalPtr->nextPtr = localPtr;
 		procPtr->lastLocalPtr = localPtr;
@@ -677,13 +677,13 @@
 
 	    if (localPtr->defValuePtr != NULL) {
 		Tcl_DecrRefCount(localPtr->defValuePtr);
 	    }
 
-	    Tcl_Free(localPtr);
+	    ckfree(localPtr);
 	}
-	Tcl_Free(procPtr);
+	ckfree(procPtr);
     }
     return TCL_ERROR;
 }
 
 /*
@@ -759,11 +759,11 @@
     Tcl_Interp *interp,		/* Interpreter in which to find frame. */
     Tcl_Obj *objPtr,		/* Object describing frame. */
     CallFrame **framePtrPtr)	/* Store pointer to frame here (or NULL if
 				 * global frame indicated). */
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
     int curLevel, level, result;
     const Tcl_ObjIntRep *irPtr;
     const char *name = NULL;
     Tcl_WideInt w;
 
@@ -896,11 +896,11 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
 
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
     CmdFrame *invoker = NULL;
     int word = 0;
     int result;
     CallFrame *savedVarFramePtr, *framePtr;
     Tcl_Obj *objPtr;
@@ -1036,11 +1036,11 @@
 ProcWrongNumArgs(
     Tcl_Interp *interp,
     int skip)
 {
     CallFrame *framePtr = ((Interp *)interp)->varFramePtr;
-    register Proc *procPtr = framePtr->procPtr;
+    Proc *procPtr = framePtr->procPtr;
     int localCt = procPtr->numCompiledLocals, numArgs, i;
     Tcl_Obj **desiredObjs;
     const char *final = NULL;
 
     /*
@@ -1052,16 +1052,20 @@
 	    (int) sizeof(Tcl_Obj *) * (numArgs+1));
 
     if (framePtr->isProcCallFrame & FRAME_IS_LAMBDA) {
 	desiredObjs[0] = Tcl_NewStringObj("lambdaExpr", -1);
     } else {
+#ifdef AVOID_HACKS_FOR_ITCL
 	desiredObjs[0] = framePtr->objv[skip-1];
+#else
+	desiredObjs[0] = Tcl_NewListObj(1, framePtr->objv + skip - 1);
+#endif /* AVOID_HACKS_FOR_ITCL */
     }
     Tcl_IncrRefCount(desiredObjs[0]);
 
     if (localCt > 0) {
-	register Var *defPtr = (Var *) (&framePtr->localCachePtr->varName0 + localCt);
+	Var *defPtr = (Var *) (&framePtr->localCachePtr->varName0 + localCt);
 
 	for (i=1 ; i<=numArgs ; i++, defPtr++) {
 	    Tcl_Obj *argObj;
 	    Tcl_Obj *namePtr = localName(framePtr, i-1);
 
@@ -1192,11 +1196,11 @@
     for (; localPtr != NULL; localPtr = localPtr->nextPtr) {
 	if (localPtr->resolveInfo) {
 	    if (localPtr->resolveInfo->deleteProc) {
 		localPtr->resolveInfo->deleteProc(localPtr->resolveInfo);
 	    } else {
-		Tcl_Free(localPtr->resolveInfo);
+		ckfree(localPtr->resolveInfo);
 	    }
 	    localPtr->resolveInfo = NULL;
 	}
 	localPtr->flags &= ~VAR_RESOLVED;
 
@@ -1248,11 +1252,11 @@
 	 * should be used.
 	 */
 
 	resVarInfo = localPtr->resolveInfo;
 	if (resVarInfo && resVarInfo->fetchProc) {
-	    register Var *resolvedVarPtr = (Var *)
+	    Var *resolvedVarPtr = (Var *)
 		    resVarInfo->fetchProc(interp, resVarInfo);
 
 	    if (resolvedVarPtr) {
 		if (TclIsVarInHash(resolvedVarPtr)) {
 		    VarHashRefCount(resolvedVarPtr)++;
@@ -1271,18 +1275,18 @@
 {
     int i;
     Tcl_Obj **namePtrPtr = &localCachePtr->varName0;
 
     for (i = 0; i < localCachePtr->numVars; i++, namePtrPtr++) {
-	register Tcl_Obj *objPtr = *namePtrPtr;
+	Tcl_Obj *objPtr = *namePtrPtr;
 
 	if (objPtr) {
 	    /* TclReleaseLiteral calls Tcl_DecrRefCount for us */
 	    TclReleaseLiteral(interp, objPtr);
 	}
     }
-    Tcl_Free(localCachePtr);
+    ckfree(localCachePtr);
 }
 
 static void
 InitLocalCache(
     Proc *procPtr)
@@ -1294,21 +1298,21 @@
 
     Tcl_Obj **namePtr;
     Var *varPtr;
     LocalCache *localCachePtr;
     CompiledLocal *localPtr;
-    int new;
+    int isNew;
 
     ByteCodeGetIntRep(procPtr->bodyPtr, &tclByteCodeType, codePtr);
 
     /*
      * Cache the names and initial values of local variables; store the
      * cache in both the framePtr for this execution and in the codePtr
      * for future calls.
      */
 
-    localCachePtr = Tcl_Alloc(sizeof(LocalCache)
+    localCachePtr = ckalloc(sizeof(LocalCache)
 	    + (localCt - 1) * sizeof(Tcl_Obj *)
 	    + numArgs * sizeof(Var));
 
     namePtr = &localCachePtr->varName0;
     varPtr = (Var *) (namePtr + localCt);
@@ -1316,12 +1320,12 @@
     while (localPtr) {
 	if (TclIsVarTemporary(localPtr)) {
 	    *namePtr = NULL;
 	} else {
 	    *namePtr = TclCreateLiteral(iPtr, localPtr->name,
-		    localPtr->nameLength, /* hash */ -1,
-		    &new, /* nsPtr */ NULL, 0, NULL);
+		    localPtr->nameLength, /* hash */ (unsigned int) -1,
+		    &isNew, /* nsPtr */ NULL, 0, NULL);
 	    Tcl_IncrRefCount(*namePtr);
 	}
 
 	if (i < numArgs) {
 	    varPtr->flags = (localPtr->flags & VAR_IS_ARGS);
@@ -1357,20 +1361,20 @@
  *----------------------------------------------------------------------
  */
 
 static int
 InitArgsAndLocals(
-    register Tcl_Interp *interp,/* Interpreter in which procedure was
+    Tcl_Interp *interp,/* Interpreter in which procedure was
 				 * invoked. */
     Tcl_Obj *procNameObj,	/* Procedure name for error reporting. */
     int skip)			/* Number of initial arguments to be skipped,
 				 * i.e., words in the "command name". */
 {
     CallFrame *framePtr = ((Interp *)interp)->varFramePtr;
-    register Proc *procPtr = framePtr->procPtr;
+    Proc *procPtr = framePtr->procPtr;
     ByteCode *codePtr;
-    register Var *varPtr, *defPtr;
+    Var *varPtr, *defPtr;
     int localCt = procPtr->numCompiledLocals, numArgs, argCt, i, imax;
     Tcl_Obj *const *argObjs;
 
     ByteCodeGetIntRep(procPtr->bodyPtr, &tclByteCodeType, codePtr);
 
@@ -1524,11 +1528,11 @@
 
 int
 TclPushProcCallFrame(
     ClientData clientData,	/* Record describing procedure to be
 				 * interpreted. */
-    register Tcl_Interp *interp,/* Interpreter in which procedure was
+    Tcl_Interp *interp,/* Interpreter in which procedure was
 				 * invoked. */
     int objc,			/* Count of number of arguments to this
 				 * procedure. */
     Tcl_Obj *const objv[],	/* Argument value objects. */
     int isLambda)		/* 1 if this is a call by ApplyObjCmd: it
@@ -1616,11 +1620,11 @@
 
 int
 TclObjInterpProc(
     ClientData clientData,	/* Record describing procedure to be
 				 * interpreted. */
-    register Tcl_Interp *interp,/* Interpreter in which procedure was
+    Tcl_Interp *interp,/* Interpreter in which procedure was
 				 * invoked. */
     int objc,			/* Count of number of arguments to this
 				 * procedure. */
     Tcl_Obj *const objv[])	/* Argument value objects. */
 {
@@ -1633,11 +1637,11 @@
 
 int
 TclNRInterpProc(
     ClientData clientData,	/* Record describing procedure to be
 				 * interpreted. */
-    register Tcl_Interp *interp,/* Interpreter in which procedure was
+    Tcl_Interp *interp,/* Interpreter in which procedure was
 				 * invoked. */
     int objc,			/* Count of number of arguments to this
 				 * procedure. */
     Tcl_Obj *const objv[])	/* Argument value objects. */
 {
@@ -1668,20 +1672,20 @@
  *----------------------------------------------------------------------
  */
 
 int
 TclNRInterpProcCore(
-    register Tcl_Interp *interp,/* Interpreter in which procedure was
+    Tcl_Interp *interp,/* Interpreter in which procedure was
 				 * invoked. */
     Tcl_Obj *procNameObj,	/* Procedure name for error reporting. */
     int skip,			/* Number of initial arguments to be skipped,
 				 * i.e., words in the "command name". */
     ProcErrorProc *errorProc)	/* How to convert results from the script into
 				 * results of the overall procedure. */
 {
     Interp *iPtr = (Interp *) interp;
-    register Proc *procPtr = iPtr->varFramePtr->procPtr;
+    Proc *procPtr = iPtr->varFramePtr->procPtr;
     int result;
     CallFrame *freePtr;
     ByteCode *codePtr;
 
     result = InitArgsAndLocals(interp, procNameObj, skip);
@@ -1694,12 +1698,12 @@
 	return TCL_ERROR;
     }
 
 #if defined(TCL_COMPILE_DEBUG)
     if (tclTraceExec >= 1) {
-	register CallFrame *framePtr = iPtr->varFramePtr;
-	register int i;
+	CallFrame *framePtr = iPtr->varFramePtr;
+	int i;
 
 	if (framePtr->isProcCallFrame & FRAME_IS_LAMBDA) {
 	    fprintf(stdout, "Calling lambda ");
 	} else {
 	    fprintf(stdout, "Calling proc ");
@@ -1841,13 +1845,11 @@
 		"invoked \"%s\" outside of a loop",
 		((result == TCL_BREAK) ? "break" : "continue")));
 	Tcl_SetErrorCode(interp, "TCL", "RESULT", "UNEXPECTED", NULL);
 	result = TCL_ERROR;
 
-	/*
-	 * Fall through to the TCL_ERROR handling code.
-	 */
+	/* FALLTHRU */
 
     case TCL_ERROR:
 	/*
 	 * Now it _must_ be an error, so we need to log it as such. This means
 	 * filling out the error trace. Luckily, we just hand this off to the
@@ -1989,14 +1991,14 @@
 		clPtr = clPtr->nextPtr;
 		if (toFree->resolveInfo) {
 		    if (toFree->resolveInfo->deleteProc) {
 			toFree->resolveInfo->deleteProc(toFree->resolveInfo);
 		    } else {
-			Tcl_Free(toFree->resolveInfo);
+			ckfree(toFree->resolveInfo);
 		    }
 		}
-		Tcl_Free(toFree);
+		ckfree(toFree);
 	    }
 	    procPtr->numCompiledLocals = procPtr->numArgs;
 	}
 
 	(void) TclPushStackFrame(interp, &framePtr, (Tcl_Namespace *) nsPtr,
@@ -2053,18 +2055,17 @@
     Tcl_Interp *interp,		/* The interpreter in which the procedure was
 				 * called. */
     Tcl_Obj *procNameObj)	/* Name of the procedure. Used for error
 				 * messages and trace information. */
 {
-    unsigned int overflow, limit = 60;
-    size_t nameLen;
+    int overflow, limit = 60, nameLen;
     const char *procName = TclGetStringFromObj(procNameObj, &nameLen);
 
     overflow = (nameLen > limit);
     Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 	    "\n    (procedure \"%.*s%s\" line %d)",
-	    (int)(overflow ? limit :nameLen), procName,
+	    (overflow ? limit : nameLen), procName,
 	    (overflow ? "..." : ""), Tcl_GetErrorLine(interp)));
 }
 
 /*
  *----------------------------------------------------------------------
@@ -2114,13 +2115,13 @@
  *----------------------------------------------------------------------
  */
 
 void
 TclProcCleanupProc(
-    register Proc *procPtr)	/* Procedure to be deleted. */
+    Proc *procPtr)	/* Procedure to be deleted. */
 {
-    register CompiledLocal *localPtr;
+    CompiledLocal *localPtr;
     Tcl_Obj *bodyPtr = procPtr->bodyPtr;
     Tcl_Obj *defPtr;
     Tcl_ResolvedVarInfo *resVarInfo;
     Tcl_HashEntry *hePtr = NULL;
     CmdFrame *cfPtr = NULL;
@@ -2135,22 +2136,22 @@
 	resVarInfo = localPtr->resolveInfo;
 	if (resVarInfo) {
 	    if (resVarInfo->deleteProc) {
 		resVarInfo->deleteProc(resVarInfo);
 	    } else {
-		Tcl_Free(resVarInfo);
+		ckfree(resVarInfo);
 	    }
 	}
 
 	if (localPtr->defValuePtr != NULL) {
 	    defPtr = localPtr->defValuePtr;
 	    Tcl_DecrRefCount(defPtr);
 	}
-	Tcl_Free(localPtr);
+	ckfree(localPtr);
 	localPtr = nextPtr;
     }
-    Tcl_Free(procPtr);
+    ckfree(procPtr);
 
     /*
      * TIP #280: Release the location data associated with this Proc
      * structure, if any. The interpreter may not exist (For example for
      * procbody structures created by tbcload.
@@ -2170,13 +2171,13 @@
     if (cfPtr) {
 	if (cfPtr->type == TCL_LOCATION_SOURCE) {
 	    Tcl_DecrRefCount(cfPtr->data.eval.path);
 	    cfPtr->data.eval.path = NULL;
 	}
-	Tcl_Free(cfPtr->line);
+	ckfree(cfPtr->line);
 	cfPtr->line = NULL;
-	Tcl_Free(cfPtr);
+	ckfree(cfPtr);
     }
     Tcl_DeleteHashEntry(hePtr);
 }
 
 /*
@@ -2365,11 +2366,11 @@
  */
 
 static void
 DupLambdaInternalRep(
     Tcl_Obj *srcPtr,		/* Object with internal rep to copy. */
-    register Tcl_Obj *copyPtr)	/* Object with internal rep to set. */
+    Tcl_Obj *copyPtr)	/* Object with internal rep to set. */
 {
     Proc *procPtr;
     Tcl_Obj *nsObjPtr;
 
     LambdaGetIntRep(srcPtr, procPtr, nsObjPtr);
@@ -2380,11 +2381,11 @@
     LambdaSetIntRep(copyPtr, procPtr, nsObjPtr);
 }
 
 static void
 FreeLambdaInternalRep(
-    register Tcl_Obj *objPtr)	/* CmdName object with internal representation
+    Tcl_Obj *objPtr)	/* CmdName object with internal representation
 				 * to free. */
 {
     Proc *procPtr;
     Tcl_Obj *nsObjPtr;
 
@@ -2398,11 +2399,11 @@
 }
 
 static int
 SetLambdaFromAny(
     Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
-    register Tcl_Obj *objPtr)	/* The object to convert. */
+    Tcl_Obj *objPtr)	/* The object to convert. */
 {
     Interp *iPtr = (Interp *) interp;
     const char *name;
     Tcl_Obj *argsPtr, *bodyPtr, *nsObjPtr, **objv;
     int isNew, objc, result;
@@ -2420,11 +2421,11 @@
 
     result = TclListObjGetElements(NULL, objPtr, &objc, &objv);
     if ((result != TCL_OK) || ((objc != 2) && (objc != 3))) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"can't interpret \"%s\" as a lambda expression",
-		TclGetString(objPtr)));
+		Tcl_GetString(objPtr)));
 	Tcl_SetErrorCode(interp, "TCL", "VALUE", "LAMBDA", NULL);
 	return TCL_ERROR;
     }
 
     argsPtr = objv[0];
@@ -2506,16 +2507,16 @@
 		/*
 		 * Move from approximation (line of list cmd word) to actual
 		 * location (line of 2nd list element).
 		 */
 
-		cfPtr = Tcl_Alloc(sizeof(CmdFrame));
+		cfPtr = ckalloc(sizeof(CmdFrame));
 		TclListLines(objPtr, contextPtr->line[1], 2, buf, NULL);
 
 		cfPtr->level = -1;
 		cfPtr->type = contextPtr->type;
-		cfPtr->line = Tcl_Alloc(sizeof(int));
+		cfPtr->line = ckalloc(sizeof(int));
 		cfPtr->line[0] = buf[1];
 		cfPtr->nline = 1;
 		cfPtr->framePtr = NULL;
 		cfPtr->nextPtr = NULL;
 
@@ -2724,18 +2725,17 @@
     Tcl_Interp *interp,		/* The interpreter in which the procedure was
 				 * called. */
     Tcl_Obj *procNameObj)	/* Name of the procedure. Used for error
 				 * messages and trace information. */
 {
-    unsigned int overflow, limit = 60;
-    size_t nameLen;
+    int overflow, limit = 60, nameLen;
     const char *procName = TclGetStringFromObj(procNameObj, &nameLen);
 
     overflow = (nameLen > limit);
     Tcl_AppendObjToErrorInfo(interp, Tcl_ObjPrintf(
 	    "\n    (lambda term \"%.*s%s\" line %d)",
-	    (int)(overflow ? limit : nameLen), procName,
+	    (overflow ? limit : nameLen), procName,
 	    (overflow ? "..." : ""), Tcl_GetErrorLine(interp)));
 }
 
 /*
  *----------------------------------------------------------------------

Index: generic/tclProcess.c
==================================================================
--- generic/tclProcess.c
+++ generic/tclProcess.c
@@ -45,11 +45,11 @@
 
 static void		InitProcessInfo(ProcessInfo *info, Tcl_Pid pid,
 			    int resolvedPid);
 static void		FreeProcessInfo(ProcessInfo *info);
 static int		RefreshProcessInfo(ProcessInfo *info, int options);
-static TclProcessWaitStatus WaitProcessStatus(Tcl_Pid pid, size_t resolvedPid,
+static TclProcessWaitStatus WaitProcessStatus(Tcl_Pid pid, int resolvedPid,
 			    int options, int *codePtr, Tcl_Obj **msgPtr,
 			    Tcl_Obj **errorObjPtr);
 static Tcl_Obj *	BuildProcessStatusObj(ProcessInfo *info);
 static int		ProcessListObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
@@ -128,11 +128,11 @@
 
     /*
      * Free allocated structure.
      */
 
-    Tcl_Free(info);
+    ckfree(info);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -191,11 +191,11 @@
  */
 
 TclProcessWaitStatus
 WaitProcessStatus(
     Tcl_Pid pid,		/* Process id. */
-    size_t resolvedPid,		/* Resolved process id. */
+    int resolvedPid,		/* Resolved process id. */
     int options,		/* Options passed to Tcl_WaitPid. */
     int *codePtr,		/* If non-NULL, will receive either:
 				 *  - 0 for normal exit.
 				 *  - errno in case of error.
 				 *  - non-zero exit code for abormal exit.
@@ -797,11 +797,11 @@
 
 void
 TclProcessCreated(
     Tcl_Pid pid)		/* Process id. */
 {
-    size_t resolvedPid;
+    int resolvedPid;
     Tcl_HashEntry *entry, *entry2;
     int isNew;
     ProcessInfo *info;
 
     /*
@@ -831,11 +831,11 @@
 
     /*
      * Allocate and initialize info structure.
      */
 
-    info = (ProcessInfo *) Tcl_Alloc(sizeof(ProcessInfo));
+    info = (ProcessInfo *) ckalloc(sizeof(ProcessInfo));
     InitProcessInfo(info, pid, resolvedPid);
 
     /*
      * Add entry to tables.
      */

Index: generic/tclRegexp.c
==================================================================
--- generic/tclRegexp.c
+++ generic/tclRegexp.c
@@ -68,11 +68,11 @@
 typedef struct {
     int initialized;		/* Set to 1 when the module is initialized. */
     char *patterns[NUM_REGEXPS];/* Strings corresponding to compiled regular
 				 * expression patterns. NULL means that this
 				 * slot isn't used. Malloc-ed. */
-    size_t patLengths[NUM_REGEXPS];/* Number of non-null characters in
+    int patLengths[NUM_REGEXPS];/* Number of non-null characters in
 				 * corresponding entry in patterns. -1 means
 				 * entry isn't used. */
     struct TclRegexp *regexps[NUM_REGEXPS];
 				/* Compiled forms of above strings. Also
 				 * malloc-ed, or NULL if not in use yet. */
@@ -83,19 +83,19 @@
 /*
  * Declarations for functions used only in this file.
  */
 
 static TclRegexp *	CompileRegexp(Tcl_Interp *interp, const char *pattern,
-			    size_t length, int flags);
+			    int length, int flags);
 static void		DupRegexpInternalRep(Tcl_Obj *srcPtr,
 			    Tcl_Obj *copyPtr);
 static void		FinalizeRegexp(ClientData clientData);
 static void		FreeRegexp(TclRegexp *regexpPtr);
 static void		FreeRegexpInternalRep(Tcl_Obj *objPtr);
 static int		RegExpExecUniChar(Tcl_Interp *interp, Tcl_RegExp re,
-			    const Tcl_UniChar *uniString, size_t numChars,
-			    size_t nmatches, int flags);
+			    const Tcl_UniChar *uniString, int numChars,
+			    int nmatches, int flags);
 static int		SetRegexpFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr);
 
 /*
  * The regular expression Tcl object type. This serves as a cache of the
  * compiled form of the regular expression.
@@ -188,12 +188,11 @@
     const char *text,		/* Text against which to match re. */
     const char *start)		/* If text is part of a larger string, this
 				 * identifies beginning of larger string, so
 				 * that "^" won't match. */
 {
-    int flags, result;
-    size_t numChars;
+    int flags, result, numChars;
     TclRegexp *regexp = (TclRegexp *) re;
     Tcl_DString ds;
     const Tcl_UniChar *ustr;
 
     /*
@@ -249,11 +248,11 @@
 
 void
 Tcl_RegExpRange(
     Tcl_RegExp re,		/* Compiled regular expression that has been
 				 * passed to Tcl_RegExpExec. */
-    size_t index,			/* 0 means give the range of the entire match,
+    int index,			/* 0 means give the range of the entire match,
 				 * > 0 means give the range of a matching
 				 * subrange. */
     const char **startPtr,	/* Store address of first character in
 				 * (sub-)range here. */
     const char **endPtr)	/* Store address of character just after last
@@ -260,11 +259,11 @@
 				 * in (sub-)range here. */
 {
     TclRegexp *regexpPtr = (TclRegexp *) re;
     const char *string;
 
-    if (index > regexpPtr->re.re_nsub) {
+    if ((size_t) index > regexpPtr->re.re_nsub) {
 	*startPtr = *endPtr = NULL;
     } else if (regexpPtr->matches[index].rm_so == TCL_INDEX_NONE) {
 	*startPtr = *endPtr = NULL;
     } else {
 	if (regexpPtr->objPtr) {
@@ -301,25 +300,27 @@
 RegExpExecUniChar(
     Tcl_Interp *interp,		/* Interpreter to use for error reporting. */
     Tcl_RegExp re,		/* Compiled regular expression; returned by a
 				 * previous call to Tcl_GetRegExpFromObj */
     const Tcl_UniChar *wString,	/* String against which to match re. */
-    size_t numChars,		/* Length of Tcl_UniChar string. */
-    size_t nm,		/* How many subexpression matches (counting
+    int numChars,		/* Length of Tcl_UniChar string (must be
+				 * >=0). */
+    int nmatches,		/* How many subexpression matches (counting
 				 * the whole match as subexpression 0) are of
 				 * interest. -1 means "don't know". */
     int flags)			/* Regular expression flags. */
 {
     int status;
     TclRegexp *regexpPtr = (TclRegexp *) re;
     size_t last = regexpPtr->re.re_nsub + 1;
+    size_t nm = last;
 
-    if (nm >= last) {
-	nm = last;
+    if (nmatches >= 0 && (size_t) nmatches < nm) {
+	nm = (size_t) nmatches;
     }
 
-    status = TclReExec(&regexpPtr->re, wString, numChars,
+    status = TclReExec(&regexpPtr->re, wString, (size_t) numChars,
 	    &regexpPtr->details, nm, regexpPtr->matches, flags);
 
     /*
      * Check for errors.
      */
@@ -359,25 +360,25 @@
 
 void
 TclRegExpRangeUniChar(
     Tcl_RegExp re,		/* Compiled regular expression that has been
 				 * passed to Tcl_RegExpExec. */
-    size_t index,			/* 0 means give the range of the entire match,
+    int index,			/* 0 means give the range of the entire match,
 				 * > 0 means give the range of a matching
 				 * subrange, TCL_INDEX_NONE means the range of the
 				 * rm_extend field. */
-    size_t *startPtr,		/* Store address of first character in
+    int *startPtr,		/* Store address of first character in
 				 * (sub-)range here. */
-    size_t *endPtr)		/* Store address of character just after last
+    int *endPtr)		/* Store address of character just after last
 				 * in (sub-)range here. */
 {
     TclRegexp *regexpPtr = (TclRegexp *) re;
 
     if ((regexpPtr->flags&REG_EXPECT) && (index == TCL_INDEX_NONE)) {
 	*startPtr = regexpPtr->details.rm_extend.rm_so;
 	*endPtr = regexpPtr->details.rm_extend.rm_eo;
-    } else if (index + 1 > regexpPtr->re.re_nsub + 1) {
+    } else if ((size_t) index > regexpPtr->re.re_nsub) {
 	*startPtr = TCL_INDEX_NONE;
 	*endPtr = TCL_INDEX_NONE;
     } else {
 	*startPtr = regexpPtr->matches[index].rm_so;
 	*endPtr = regexpPtr->matches[index].rm_eo;
@@ -439,20 +440,20 @@
     Tcl_Interp *interp,		/* Interpreter to use for error reporting. */
     Tcl_RegExp re,		/* Compiled regular expression; must have been
 				 * returned by previous call to
 				 * Tcl_GetRegExpFromObj. */
     Tcl_Obj *textObj,		/* Text against which to match re. */
-    size_t offset,			/* Character index that marks where matching
+    int offset,			/* Character index that marks where matching
 				 * should begin. */
-    size_t nmatches,		/* How many subexpression matches (counting
+    int nmatches,		/* How many subexpression matches (counting
 				 * the whole match as subexpression 0) are of
 				 * interest. -1 means all of them. */
     int flags)			/* Regular expression execution flags. */
 {
     TclRegexp *regexpPtr = (TclRegexp *) re;
     Tcl_UniChar *udata;
-    size_t length;
+    int length;
     int reflags = regexpPtr->flags;
 #define TCL_REG_GLOBOK_FLAGS \
 	(TCL_REG_ADVANCED | TCL_REG_NOSUB | TCL_REG_NOCASE)
 
     /*
@@ -479,11 +480,11 @@
      */
 
     regexpPtr->string = NULL;
     regexpPtr->objPtr = textObj;
 
-    udata = TclGetUnicodeFromObj(textObj, &length);
+    udata = Tcl_GetUnicodeFromObj(textObj, &length);
 
     if (offset > length) {
 	offset = length;
     }
     udata += offset;
@@ -591,11 +592,11 @@
 				 * expression pattern. Internal rep will be
 				 * changed to compiled form of this regular
 				 * expression. */
     int flags)			/* Regular expression compilation flags. */
 {
-    size_t length;
+    int length;
     TclRegexp *regexpPtr;
     const char *pattern;
 
     RegexpGetIntRep(objPtr, regexpPtr);
 
@@ -675,11 +676,11 @@
      * well and Tcl has other limits that constrain things as well...
      */
 
     resultObj = Tcl_NewObj();
     Tcl_ListObjAppendElement(NULL, resultObj,
-	    TclNewWideIntObjFromSize(regexpPtr->re.re_nsub));
+	    Tcl_NewWideIntObj((Tcl_WideInt) regexpPtr->re.re_nsub));
 
     /*
      * Now append a list of all the bit-flags set for the RE.
      */
 
@@ -722,16 +723,16 @@
     char cbuf[TCL_INTEGER_SPACE];
     size_t n;
     const char *p;
 
     Tcl_ResetResult(interp);
-    n = TclReError(status, NULL, buf, sizeof(buf));
+    n = TclReError(status, buf, sizeof(buf));
     p = (n > sizeof(buf)) ? "..." : "";
     Tcl_SetObjResult(interp, Tcl_ObjPrintf("%s%s%s", msg, buf, p));
 
     sprintf(cbuf, "%d", status);
-    (void) TclReError(REG_ITOA, NULL, cbuf, sizeof(cbuf));
+    (void) TclReError(REG_ITOA, cbuf, sizeof(cbuf));
     Tcl_SetErrorCode(interp, "REGEXP", cbuf, buf, NULL);
 }
 
 /*
  *----------------------------------------------------------------------
@@ -855,11 +856,11 @@
 
 static TclRegexp *
 CompileRegexp(
     Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
     const char *string,		/* The regexp to compile (UTF-8). */
-    size_t length,			/* The length of the string in bytes. */
+    int length,			/* The length of the string in bytes. */
     int flags)			/* Compilation flags. */
 {
     TclRegexp *regexpPtr;
     const Tcl_UniChar *uniString;
     int numChars, status, i, exact;
@@ -913,11 +914,11 @@
 
     /*
      * This is a new expression, so compile it and add it to the cache.
      */
 
-    regexpPtr = Tcl_Alloc(sizeof(TclRegexp));
+    regexpPtr = ckalloc(sizeof(TclRegexp));
     regexpPtr->objPtr = NULL;
     regexpPtr->string = NULL;
     regexpPtr->details.rm_extend.rm_so = -1;
     regexpPtr->details.rm_extend.rm_eo = -1;
 
@@ -940,11 +941,11 @@
     if (status != REG_OKAY) {
 	/*
 	 * Clean up and report errors in the interpreter, if possible.
 	 */
 
-	Tcl_Free(regexpPtr);
+	ckfree(regexpPtr);
 	if (interp) {
 	    TclRegError(interp,
 		    "couldn't compile regular expression pattern: ", status);
 	}
 	return NULL;
@@ -968,11 +969,11 @@
      * Allocate enough space for all of the subexpressions, plus one extra for
      * the entire pattern.
      */
 
     regexpPtr->matches =
-	    Tcl_Alloc(sizeof(regmatch_t) * (regexpPtr->re.re_nsub + 1));
+	    ckalloc(sizeof(regmatch_t) * (regexpPtr->re.re_nsub + 1));
 
     /*
      * Initialize the refcount to one initially, since it is in the cache.
      */
 
@@ -987,18 +988,18 @@
 	TclRegexp *oldRegexpPtr = tsdPtr->regexps[NUM_REGEXPS-1];
 
 	if (oldRegexpPtr->refCount-- <= 1) {
 	    FreeRegexp(oldRegexpPtr);
 	}
-	Tcl_Free(tsdPtr->patterns[NUM_REGEXPS-1]);
+	ckfree(tsdPtr->patterns[NUM_REGEXPS-1]);
     }
     for (i = NUM_REGEXPS - 2; i >= 0; i--) {
 	tsdPtr->patterns[i+1] = tsdPtr->patterns[i];
 	tsdPtr->patLengths[i+1] = tsdPtr->patLengths[i];
 	tsdPtr->regexps[i+1] = tsdPtr->regexps[i];
     }
-    tsdPtr->patterns[0] = Tcl_Alloc(length + 1);
+    tsdPtr->patterns[0] = ckalloc(length + 1);
     memcpy(tsdPtr->patterns[0], string, length + 1);
     tsdPtr->patLengths[0] = length;
     tsdPtr->regexps[0] = regexpPtr;
 
     return regexpPtr;
@@ -1027,13 +1028,13 @@
     TclReFree(&regexpPtr->re);
     if (regexpPtr->globObjPtr) {
 	TclDecrRefCount(regexpPtr->globObjPtr);
     }
     if (regexpPtr->matches) {
-	Tcl_Free(regexpPtr->matches);
+	ckfree(regexpPtr->matches);
     }
-    Tcl_Free(regexpPtr);
+    ckfree(regexpPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1061,11 +1062,11 @@
     for (i = 0; (i < NUM_REGEXPS) && (tsdPtr->patterns[i] != NULL); i++) {
 	regexpPtr = tsdPtr->regexps[i];
 	if (regexpPtr->refCount-- <= 1) {
 	    FreeRegexp(regexpPtr);
 	}
-	Tcl_Free(tsdPtr->patterns[i]);
+	ckfree(tsdPtr->patterns[i]);
 	tsdPtr->patterns[i] = NULL;
     }
 
     /*
      * We may find ourselves reinitialized if another finalization routine

Index: generic/tclResolve.c
==================================================================
--- generic/tclResolve.c
+++ generic/tclResolve.c
@@ -99,13 +99,13 @@
     /*
      * Otherwise, this is a new scheme. Add it to the FRONT of the linked
      * list, so that it overrides existing schemes.
      */
 
-    resPtr = Tcl_Alloc(sizeof(ResolverScheme));
+    resPtr = ckalloc(sizeof(ResolverScheme));
     len = strlen(name) + 1;
-    resPtr->name = Tcl_Alloc(len);
+    resPtr->name = ckalloc(len);
     memcpy(resPtr->name, name, len);
     resPtr->cmdResProc = cmdProc;
     resPtr->varResProc = varProc;
     resPtr->compiledVarResProc = compiledVarProc;
     resPtr->nextPtr = iPtr->resolverPtr;
@@ -223,12 +223,12 @@
 	if (resPtr->cmdResProc) {
 	    BumpCmdRefEpochs(iPtr->globalNsPtr);
 	}
 
 	*prevPtrPtr = resPtr->nextPtr;
-	Tcl_Free(resPtr->name);
-	Tcl_Free(resPtr);
+	ckfree(resPtr->name);
+	ckfree(resPtr);
 
 	return 1;
     }
     return 0;
 }

Index: generic/tclResult.c
==================================================================
--- generic/tclResult.c
+++ generic/tclResult.c
@@ -25,10 +25,13 @@
  */
 
 static Tcl_Obj **	GetKeys(void);
 static void		ReleaseKeys(ClientData clientData);
 static void		ResetObjResult(Interp *iPtr);
+#ifndef TCL_NO_DEPRECATED
+static void		SetupAppendBuffer(Interp *iPtr, int newSpace);
+#endif /* !TCL_NO_DEPRECATED */
 
 /*
  * This structure is used to take a snapshot of the interpreter state in
  * Tcl_SaveInterpState. You can snapshot the state, execute a command, and
  * then back up to the result or the error that was previously in progress.
@@ -72,11 +75,11 @@
 Tcl_SaveInterpState(
     Tcl_Interp *interp,		/* Interpreter's state to be saved */
     int status)			/* status code for current operation */
 {
     Interp *iPtr = (Interp *) interp;
-    InterpState *statePtr = Tcl_Alloc(sizeof(InterpState));
+    InterpState *statePtr = ckalloc(sizeof(InterpState));
 
     statePtr->status = status;
     statePtr->flags = iPtr->flags & ERR_ALREADY_LOGGED;
     statePtr->returnLevel = iPtr->returnLevel;
     statePtr->returnCode = iPtr->returnCode;
@@ -202,12 +205,302 @@
     }
     if (statePtr->errorStack) {
 	Tcl_DecrRefCount(statePtr->errorStack);
     }
     Tcl_DecrRefCount(statePtr->objResult);
-    Tcl_Free(statePtr);
+    ckfree(statePtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SaveResult --
+ *
+ *	Takes a snapshot of the current result state of the interpreter. The
+ *	snapshot can be restored at any point by Tcl_RestoreResult. Note that
+ *	this routine does not preserve the errorCode, errorInfo, or flags
+ *	fields so it should not be used if an error is in progress.
+ *
+ *	Once a snapshot is saved, it must be restored by calling
+ *	Tcl_RestoreResult, or discarded by calling Tcl_DiscardResult.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Resets the interpreter result.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_SaveResult
+void
+Tcl_SaveResult(
+    Tcl_Interp *interp,		/* Interpreter to save. */
+    Tcl_SavedResult *statePtr)	/* Pointer to state structure. */
+{
+    Interp *iPtr = (Interp *) interp;
+
+    /*
+     * Move the result object into the save state. Note that we don't need to
+     * change its refcount because we're moving it, not adding a new
+     * reference. Put an empty object into the interpreter.
+     */
+
+    statePtr->objResultPtr = iPtr->objResultPtr;
+    iPtr->objResultPtr = Tcl_NewObj();
+    Tcl_IncrRefCount(iPtr->objResultPtr);
+
+    /*
+     * Save the string result.
+     */
+
+    statePtr->freeProc = iPtr->freeProc;
+    if (iPtr->result == iPtr->resultSpace) {
+	/*
+	 * Copy the static string data out of the interp buffer.
+	 */
+
+	statePtr->result = statePtr->resultSpace;
+	strcpy(statePtr->result, iPtr->result);
+	statePtr->appendResult = NULL;
+    } else if (iPtr->result == iPtr->appendResult) {
+	/*
+	 * Move the append buffer out of the interp.
+	 */
+
+	statePtr->appendResult = iPtr->appendResult;
+	statePtr->appendAvl = iPtr->appendAvl;
+	statePtr->appendUsed = iPtr->appendUsed;
+	statePtr->result = statePtr->appendResult;
+	iPtr->appendResult = NULL;
+	iPtr->appendAvl = 0;
+	iPtr->appendUsed = 0;
+    } else {
+	/*
+	 * Move the dynamic or static string out of the interpreter.
+	 */
+
+	statePtr->result = iPtr->result;
+	statePtr->appendResult = NULL;
+    }
+
+    iPtr->result = iPtr->resultSpace;
+    iPtr->resultSpace[0] = 0;
+    iPtr->freeProc = 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_RestoreResult --
+ *
+ *	Restores the state of the interpreter to a snapshot taken by
+ *	Tcl_SaveResult. After this call, the token for the interpreter state
+ *	is no longer valid.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Restores the interpreter result.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#undef Tcl_RestoreResult
+void
+Tcl_RestoreResult(
+    Tcl_Interp *interp,		/* Interpreter being restored. */
+    Tcl_SavedResult *statePtr)	/* State returned by Tcl_SaveResult. */
+{
+    Interp *iPtr = (Interp *) interp;
+
+    Tcl_ResetResult(interp);
+
+    /*
+     * Restore the string result.
+     */
+
+    iPtr->freeProc = statePtr->freeProc;
+    if (statePtr->result == statePtr->resultSpace) {
+	/*
+	 * Copy the static string data into the interp buffer.
+	 */
+
+	iPtr->result = iPtr->resultSpace;
+	strcpy(iPtr->result, statePtr->result);
+    } else if (statePtr->result == statePtr->appendResult) {
+	/*
+	 * Move the append buffer back into the interp.
+	 */
+
+	if (iPtr->appendResult != NULL) {
+	    ckfree(iPtr->appendResult);
+	}
+
+	iPtr->appendResult = statePtr->appendResult;
+	iPtr->appendAvl = statePtr->appendAvl;
+	iPtr->appendUsed = statePtr->appendUsed;
+	iPtr->result = iPtr->appendResult;
+    } else {
+	/*
+	 * Move the dynamic or static string back into the interpreter.
+	 */
+
+	iPtr->result = statePtr->result;
+    }
+
+    /*
+     * Restore the object result.
+     */
+
+    Tcl_DecrRefCount(iPtr->objResultPtr);
+    iPtr->objResultPtr = statePtr->objResultPtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_DiscardResult --
+ *
+ *	Frees the memory associated with an interpreter snapshot taken by
+ *	Tcl_SaveResult. If the snapshot is not restored, this function must be
+ *	called to discard it, or the memory will be lost.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#undef Tcl_DiscardResult
+void
+Tcl_DiscardResult(
+    Tcl_SavedResult *statePtr)	/* State returned by Tcl_SaveResult. */
+{
+    TclDecrRefCount(statePtr->objResultPtr);
+
+    if (statePtr->result == statePtr->appendResult) {
+	ckfree(statePtr->appendResult);
+    } else if (statePtr->freeProc == TCL_DYNAMIC) {
+        ckfree(statePtr->result);
+    } else if (statePtr->freeProc) {
+        statePtr->freeProc(statePtr->result);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetResult --
+ *
+ *	Arrange for "result" to be the Tcl return value.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	interp->result is left pointing either to "result" or to a copy of it.
+ *	Also, the object result is reset.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_SetResult(
+    Tcl_Interp *interp,		/* Interpreter with which to associate the
+				 * return value. */
+    char *result,	/* Value to be returned. If NULL, the result
+				 * is set to an empty string. */
+    Tcl_FreeProc *freeProc)	/* Gives information about the string:
+				 * TCL_STATIC, TCL_VOLATILE, or the address of
+				 * a Tcl_FreeProc such as free. */
+{
+    Interp *iPtr = (Interp *) interp;
+    Tcl_FreeProc *oldFreeProc = iPtr->freeProc;
+    char *oldResult = iPtr->result;
+
+    if (result == NULL) {
+	iPtr->resultSpace[0] = 0;
+	iPtr->result = iPtr->resultSpace;
+	iPtr->freeProc = 0;
+    } else if (freeProc == TCL_VOLATILE) {
+	int length = strlen(result);
+
+	if (length > TCL_RESULT_SIZE) {
+	    iPtr->result = ckalloc(length + 1);
+	    iPtr->freeProc = TCL_DYNAMIC;
+	} else {
+	    iPtr->result = iPtr->resultSpace;
+	    iPtr->freeProc = 0;
+	}
+	memcpy(iPtr->result, result, length+1);
+    } else {
+	iPtr->result = (char *) result;
+	iPtr->freeProc = freeProc;
+    }
+
+    /*
+     * If the old result was dynamically-allocated, free it up. Do it here,
+     * rather than at the beginning, in case the new result value was part of
+     * the old result value.
+     */
+
+    if (oldFreeProc != 0) {
+	if (oldFreeProc == TCL_DYNAMIC) {
+	    ckfree(oldResult);
+	} else {
+	    oldFreeProc(oldResult);
+	}
+    }
+
+    /*
+     * Reset the object result since we just set the string result.
+     */
+
+    ResetObjResult(iPtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetStringResult --
+ *
+ *	Returns an interpreter's result value as a string.
+ *
+ * Results:
+ *	The interpreter's result as a string.
+ *
+ * Side effects:
+ *	If the string result is empty, the object result is moved to the
+ *	string result, then the object result is reset.
+ *
+ *----------------------------------------------------------------------
+ */
+
+const char *
+Tcl_GetStringResult(
+    Tcl_Interp *interp)/* Interpreter whose result to return. */
+{
+    Interp *iPtr = (Interp *) interp;
+    /*
+     * If the string result is empty, move the object result to the string
+     * result, then reset the object result.
+     */
+
+    if (*(iPtr->result) == 0) {
+	Tcl_SetResult(interp, TclGetString(Tcl_GetObjResult(interp)),
+		TCL_VOLATILE);
+    }
+    return iPtr->result;
 }
+#endif /* !TCL_NO_DEPRECATED */
 
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_SetObjResult --
@@ -228,15 +521,15 @@
 
 void
 Tcl_SetObjResult(
     Tcl_Interp *interp,		/* Interpreter with which to associate the
 				 * return object value. */
-    register Tcl_Obj *objPtr)	/* Tcl object to be returned. If NULL, the obj
+    Tcl_Obj *objPtr)	/* Tcl object to be returned. If NULL, the obj
 				 * result is made an empty string object. */
 {
-    register Interp *iPtr = (Interp *) interp;
-    register Tcl_Obj *oldObjResult = iPtr->objResultPtr;
+    Interp *iPtr = (Interp *) interp;
+    Tcl_Obj *oldObjResult = iPtr->objResultPtr;
 
     iPtr->objResultPtr = objPtr;
     Tcl_IncrRefCount(objPtr);	/* since interp result is a reference */
 
     /*
@@ -243,10 +536,27 @@
      * We wait until the end to release the old object result, in case we are
      * setting the result to itself.
      */
 
     TclDecrRefCount(oldObjResult);
+
+#ifndef TCL_NO_DEPRECATED
+    /*
+     * Reset the string result since we just set the result object.
+     */
+
+    if (iPtr->freeProc != NULL) {
+	if (iPtr->freeProc == TCL_DYNAMIC) {
+	    ckfree(iPtr->result);
+	} else {
+	    iPtr->freeProc(iPtr->result);
+	}
+	iPtr->freeProc = 0;
+    }
+    iPtr->result = iPtr->resultSpace;
+    iPtr->resultSpace[0] = 0;
+#endif
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -270,14 +580,76 @@
 
 Tcl_Obj *
 Tcl_GetObjResult(
     Tcl_Interp *interp)		/* Interpreter whose result to return. */
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
+#ifndef TCL_NO_DEPRECATED
+    Tcl_Obj *objResultPtr;
+    int length;
 
+    /*
+     * If the string result is non-empty, move the string result to the object
+     * result, then reset the string result.
+     */
+
+    if (iPtr->result[0] != 0) {
+	ResetObjResult(iPtr);
+
+	objResultPtr = iPtr->objResultPtr;
+	length = strlen(iPtr->result);
+	TclInitStringRep(objResultPtr, iPtr->result, length);
+
+	if (iPtr->freeProc != NULL) {
+	    if (iPtr->freeProc == TCL_DYNAMIC) {
+		ckfree(iPtr->result);
+	    } else {
+		iPtr->freeProc(iPtr->result);
+	    }
+	    iPtr->freeProc = 0;
+	}
+	iPtr->result = iPtr->resultSpace;
+	iPtr->result[0] = 0;
+    }
+#endif /* !TCL_NO_DEPRECATED */
     return iPtr->objResultPtr;
 }
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_AppendResultVA --
+ *
+ *	Append a variable number of strings onto the interpreter's result.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The result of the interpreter given by the first argument is extended
+ *	by the strings in the va_list (up to a terminating NULL argument).
+ *
+ *	If the string result is non-empty, the object result forced to be a
+ *	duplicate of it first. There will be a string result afterwards.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_AppendResultVA(
+    Tcl_Interp *interp,		/* Interpreter with which to associate the
+				 * return value. */
+    va_list argList)		/* Variable argument list. */
+{
+    Tcl_Obj *objPtr = Tcl_GetObjResult(interp);
+
+    if (Tcl_IsShared(objPtr)) {
+	objPtr = Tcl_DuplicateObj(objPtr);
+    }
+    Tcl_AppendStringsToObjVA(objPtr, argList);
+    Tcl_SetObjResult(interp, objPtr);
+}
 
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_AppendResult --
@@ -301,27 +673,13 @@
 void
 Tcl_AppendResult(
     Tcl_Interp *interp, ...)
 {
     va_list argList;
-    Tcl_Obj *objPtr;
 
     va_start(argList, interp);
-    objPtr = Tcl_GetObjResult(interp);
-
-    if (Tcl_IsShared(objPtr)) {
-	objPtr = Tcl_DuplicateObj(objPtr);
-    }
-    while (1) {
-	const char *bytes = va_arg(argList, char *);
-
-	if (bytes == NULL) {
-	    break;
-	}
-	Tcl_AppendToObj(objPtr, bytes, -1);
-    }
-    Tcl_SetObjResult(interp, objPtr);
+    Tcl_AppendResultVA(interp, argList);
     va_end(argList);
 }
 
 /*
  *----------------------------------------------------------------------
@@ -352,53 +710,192 @@
 				 * extended. */
     const char *element)	/* String to convert to list element and add
 				 * to result. */
 {
     Interp *iPtr = (Interp *) interp;
+#ifdef TCL_NO_DEPRECATED
     Tcl_Obj *elementPtr = Tcl_NewStringObj(element, -1);
     Tcl_Obj *listPtr = Tcl_NewListObj(1, &elementPtr);
     const char *bytes;
-    size_t length;
 
     if (Tcl_IsShared(iPtr->objResultPtr)) {
 	Tcl_SetObjResult(interp, Tcl_DuplicateObj(iPtr->objResultPtr));
     }
-    bytes = TclGetStringFromObj(iPtr->objResultPtr, &length);
-    if (TclNeedSpace(bytes, bytes + length)) {
+    bytes = TclGetString(iPtr->objResultPtr);
+    if (TclNeedSpace(bytes, bytes+iPtr->objResultPtr->length)) {
 	Tcl_AppendToObj(iPtr->objResultPtr, " ", 1);
     }
     Tcl_AppendObjToObj(iPtr->objResultPtr, listPtr);
     Tcl_DecrRefCount(listPtr);
+#else
+    char *dst;
+    int size;
+    int flags;
+
+    /*
+     * If the string result is empty, move the object result to the string
+     * result, then reset the object result.
+     */
+
+    (void) Tcl_GetStringResult(interp);
+
+    /*
+     * See how much space is needed, and grow the append buffer if needed to
+     * accommodate the list element.
+     */
+
+    size = Tcl_ScanElement(element, &flags) + 1;
+    if ((iPtr->result != iPtr->appendResult)
+	    || (iPtr->appendResult[iPtr->appendUsed] != 0)
+	    || ((size + iPtr->appendUsed) >= iPtr->appendAvl)) {
+	SetupAppendBuffer(iPtr, size+iPtr->appendUsed);
+    }
+
+    /*
+     * Convert the string into a list element and copy it to the buffer that's
+     * forming, with a space separator if needed.
+     */
+
+    dst = iPtr->appendResult + iPtr->appendUsed;
+    if (TclNeedSpace(iPtr->appendResult, dst)) {
+	iPtr->appendUsed++;
+	*dst = ' ';
+	dst++;
+
+	/*
+	 * If we need a space to separate this element from preceding stuff,
+	 * then this element will not lead a list, and need not have it's
+	 * leading '#' quoted.
+	 */
+
+	flags |= TCL_DONT_QUOTE_HASH;
+    }
+    iPtr->appendUsed += Tcl_ConvertElement(element, dst, flags);
+#endif /* !TCL_NO_DEPRECATED */
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * SetupAppendBuffer --
+ *
+ *	This function makes sure that there is an append buffer properly
+ *	initialized, if necessary, from the interpreter's result, and that it
+ *	has at least enough room to accommodate newSpace new bytes of
+ *	information.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+static void
+SetupAppendBuffer(
+    Interp *iPtr,		/* Interpreter whose result is being set up. */
+    int newSpace)		/* Make sure that at least this many bytes of
+				 * new information may be added. */
+{
+    int totalSpace;
+
+    /*
+     * Make the append buffer larger, if that's necessary, then copy the
+     * result into the append buffer and make the append buffer the official
+     * Tcl result.
+     */
+
+    if (iPtr->result != iPtr->appendResult) {
+	/*
+	 * If an oversized buffer was used recently, then free it up so we go
+	 * back to a smaller buffer. This avoids tying up memory forever after
+	 * a large operation.
+	 */
+
+	if (iPtr->appendAvl > 500) {
+	    ckfree(iPtr->appendResult);
+	    iPtr->appendResult = NULL;
+	    iPtr->appendAvl = 0;
+	}
+	iPtr->appendUsed = strlen(iPtr->result);
+    } else if (iPtr->result[iPtr->appendUsed] != 0) {
+	/*
+	 * Most likely someone has modified a result created by
+	 * Tcl_AppendResult et al. so that it has a different size. Just
+	 * recompute the size.
+	 */
+
+	iPtr->appendUsed = strlen(iPtr->result);
+    }
+
+    totalSpace = newSpace + iPtr->appendUsed;
+    if (totalSpace >= iPtr->appendAvl) {
+	char *newSpace;
+
+	if (totalSpace < 100) {
+	    totalSpace = 200;
+	} else {
+	    totalSpace *= 2;
+	}
+	newSpace = ckalloc(totalSpace);
+	strcpy(newSpace, iPtr->result);
+	if (iPtr->appendResult != NULL) {
+	    ckfree(iPtr->appendResult);
+	}
+	iPtr->appendResult = newSpace;
+	iPtr->appendAvl = totalSpace;
+    } else if (iPtr->result != iPtr->appendResult) {
+	strcpy(iPtr->appendResult, iPtr->result);
+    }
+
+    Tcl_FreeResult((Tcl_Interp *) iPtr);
+    iPtr->result = iPtr->appendResult;
 }
+#endif /* !TCL_NO_DEPRECATED */
 
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_FreeResult --
  *
  *	This function frees up the memory associated with an interpreter's
- *	result, resetting the interpreter's result object.  Tcl_FreeResult is
- *	most commonly used when a function is about to replace one result
- *	value with another.
+ *	string result. It also resets the interpreter's result object.
+ *	Tcl_FreeResult is most commonly used when a function is about to
+ *	replace one result value with another.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Frees the memory associated with interp's result but does not change
- *	any part of the error dictionary (i.e., the errorinfo and errorcode
- *	remain the same).
+ *	Frees the memory associated with interp's string result and sets
+ *	interp->freeProc to zero, but does not change interp->result or clear
+ *	error state. Resets interp's result object to an unshared empty
+ *	object.
  *
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_FreeResult(
-    register Tcl_Interp *interp)/* Interpreter for which to free result. */
+    Tcl_Interp *interp)/* Interpreter for which to free result. */
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
 
+#ifndef TCL_NO_DEPRECATED
+    if (iPtr->freeProc != NULL) {
+	if (iPtr->freeProc == TCL_DYNAMIC) {
+	    ckfree(iPtr->result);
+	} else {
+	    iPtr->freeProc(iPtr->result);
+	}
+	iPtr->freeProc = 0;
+    }
+
+#endif /* !TCL_NO_DEPRECATED */
     ResetObjResult(iPtr);
 }
 
 /*
  *----------------------------------------------------------------------
@@ -419,15 +916,27 @@
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_ResetResult(
-    register Tcl_Interp *interp)/* Interpreter for which to clear result. */
+    Tcl_Interp *interp)/* Interpreter for which to clear result. */
 {
-    register Interp *iPtr = (Interp *) interp;
+    Interp *iPtr = (Interp *) interp;
 
     ResetObjResult(iPtr);
+#ifndef TCL_NO_DEPRECATED
+    if (iPtr->freeProc != NULL) {
+	if (iPtr->freeProc == TCL_DYNAMIC) {
+	    ckfree(iPtr->result);
+	} else {
+	    iPtr->freeProc(iPtr->result);
+	}
+	iPtr->freeProc = 0;
+    }
+    iPtr->result = iPtr->resultSpace;
+    iPtr->resultSpace[0] = 0;
+#endif /* !TCL_NO_DEPRECATED */
     if (iPtr->errorCode) {
 	/* Legacy support */
 	if (iPtr->flags & ERR_LEGACY_COPY) {
 	    Tcl_ObjSetVar2(interp, iPtr->ecVar, NULL,
 		    iPtr->errorCode, TCL_GLOBAL_ONLY);
@@ -472,31 +981,73 @@
  *----------------------------------------------------------------------
  */
 
 static void
 ResetObjResult(
-    register Interp *iPtr)	/* Points to the interpreter whose result
+    Interp *iPtr)	/* Points to the interpreter whose result
 				 * object should be reset. */
 {
-    register Tcl_Obj *objResultPtr = iPtr->objResultPtr;
+    Tcl_Obj *objResultPtr = iPtr->objResultPtr;
 
     if (Tcl_IsShared(objResultPtr)) {
 	TclDecrRefCount(objResultPtr);
 	TclNewObj(objResultPtr);
 	Tcl_IncrRefCount(objResultPtr);
 	iPtr->objResultPtr = objResultPtr;
     } else {
 	if (objResultPtr->bytes != &tclEmptyString) {
 	    if (objResultPtr->bytes) {
-		Tcl_Free(objResultPtr->bytes);
+		ckfree(objResultPtr->bytes);
 	    }
 	    objResultPtr->bytes = &tclEmptyString;
 	    objResultPtr->length = 0;
 	}
 	TclFreeIntRep(objResultPtr);
     }
 }
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetErrorCodeVA --
+ *
+ *	This function is called to record machine-readable information about
+ *	an error that is about to be returned.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The errorCode field of the interp is modified to hold all of the
+ *	arguments to this function, in a list form with each argument becoming
+ *	one element of the list.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_SetErrorCodeVA(
+    Tcl_Interp *interp,		/* Interpreter in which to set errorCode */
+    va_list argList)		/* Variable argument list. */
+{
+    Tcl_Obj *errorObj = Tcl_NewObj();
+
+    /*
+     * Scan through the arguments one at a time, appending them to the
+     * errorCode field as list elements.
+     */
+
+    while (1) {
+	char *elem = va_arg(argList, char *);
+
+	if (elem == NULL) {
+	    break;
+	}
+	Tcl_ListObjAppendElement(NULL, errorObj, Tcl_NewStringObj(elem, -1));
+    }
+    Tcl_SetObjErrorCode(interp, errorObj);
+}
 
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_SetErrorCode --
@@ -518,34 +1069,18 @@
 void
 Tcl_SetErrorCode(
     Tcl_Interp *interp, ...)
 {
     va_list argList;
-    Tcl_Obj *errorObj;
 
     /*
      * Scan through the arguments one at a time, appending them to the
      * errorCode field as list elements.
      */
 
     va_start(argList, interp);
-    errorObj = Tcl_NewObj();
-
-    /*
-     * Scan through the arguments one at a time, appending them to the
-     * errorCode field as list elements.
-     */
-
-    while (1) {
-	char *elem = va_arg(argList, char *);
-
-	if (elem == NULL) {
-	    break;
-	}
-	Tcl_ListObjAppendElement(NULL, errorObj, Tcl_NewStringObj(elem, -1));
-    }
-    Tcl_SetObjErrorCode(interp, errorObj);
+    Tcl_SetErrorCodeVA(interp, argList);
     va_end(argList);
 }
 
 /*
  *----------------------------------------------------------------------
@@ -587,10 +1122,11 @@
  *      Returns the line number associated with the current error.
  *
  *----------------------------------------------------------------------
  */
 
+#undef Tcl_GetErrorLine
 int
 Tcl_GetErrorLine(
     Tcl_Interp *interp)
 {
     return ((Interp *) interp)->errorLine;
@@ -604,10 +1140,11 @@
  *      Sets the line number associated with the current error.
  *
  *----------------------------------------------------------------------
  */
 
+#undef Tcl_SetErrorLine
 void
 Tcl_SetErrorLine(
     Tcl_Interp *interp,
     int value)
 {
@@ -749,14 +1286,12 @@
 	    iPtr->errorInfo = NULL;
 	}
 	Tcl_DictObjGet(NULL, iPtr->returnOpts, keys[KEY_ERRORINFO],
                 &valuePtr);
 	if (valuePtr != NULL) {
-	    size_t length;
-
-	    (void) TclGetStringFromObj(valuePtr, &length);
-	    if (length) {
+	    (void) TclGetString(valuePtr);
+	    if (valuePtr->length) {
 		iPtr->errorInfo = valuePtr;
 		Tcl_IncrRefCount(iPtr->errorInfo);
 		iPtr->flags |= ERR_ALREADY_LOGGED;
 	    }
 	}

Index: generic/tclScan.c
==================================================================
--- generic/tclScan.c
+++ generic/tclScan.c
@@ -27,11 +27,11 @@
 /*
  * The following structure contains the information associated with a
  * character set.
  */
 
-typedef struct {
+typedef struct CharSet {
     int exclude;		/* 1 if this is an exclusion set. */
     int nchars;
     Tcl_UniChar *chars;
     int nranges;
     struct Range {
@@ -100,13 +100,13 @@
 	    nranges++;
 	}
 	end += TclUtfToUniChar(end, &ch);
     }
 
-    cset->chars = Tcl_Alloc(sizeof(Tcl_UniChar) * (end - format - 1));
+    cset->chars = ckalloc(sizeof(Tcl_UniChar) * (end - format - 1));
     if (nranges > 0) {
-	cset->ranges = Tcl_Alloc(sizeof(struct Range) * nranges);
+	cset->ranges = ckalloc(sizeof(struct Range) * nranges);
     } else {
 	cset->ranges = NULL;
     }
 
     /*
@@ -222,13 +222,13 @@
 
 static void
 ReleaseCharSet(
     CharSet *cset)
 {
-    Tcl_Free(cset->chars);
+    ckfree(cset->chars);
     if (cset->ranges) {
-	Tcl_Free(cset->ranges);
+	ckfree(cset->ranges);
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -361,12 +361,14 @@
 		flags |= SCAN_BIG;
 		format += 1;
 		format += TclUtfToUniChar(format, &ch);
 		break;
 	    }
+	    /* FALLTHRU */
 	case 'L':
 	    flags |= SCAN_LONGER;
+	    /* FALLTHRU */
 	case 'h':
 	    format += TclUtfToUniChar(format, &ch);
 	}
 
 	if (!(flags & SCAN_SUPPRESS) && numVars && (objIndex >= numVars)) {
@@ -384,13 +386,11 @@
 			"field width may not be specified in %c conversion",
 			-1));
 		Tcl_SetErrorCode(interp, "TCL", "FORMAT", "BADWIDTH", NULL);
 		goto error;
 	    }
-	    /*
-	     * Fall through!
-	     */
+	    /* FALLTHRU */
 	case 'n':
 	case 's':
 	    if (flags & (SCAN_LONGER|SCAN_BIG)) {
 	    invalidFieldSize:
 		buf[Tcl_UniCharToUtf(ch, buf)] = '\0';
@@ -587,11 +587,11 @@
 	Tcl_WrongNumArgs(interp, 1, objv,
 		"string format ?varName ...?");
 	return TCL_ERROR;
     }
 
-    format = TclGetString(objv[2]);
+    format = Tcl_GetString(objv[2]);
     numVars = objc-3;
 
     /*
      * Check for errors in the format string.
      */
@@ -603,17 +603,17 @@
     /*
      * Allocate space for the result objects.
      */
 
     if (totalVars > 0) {
-	objs = Tcl_Alloc(sizeof(Tcl_Obj *) * totalVars);
+	objs = ckalloc(sizeof(Tcl_Obj *) * totalVars);
 	for (i = 0; i < totalVars; i++) {
 	    objs[i] = NULL;
 	}
     }
 
-    string = TclGetString(objv[1]);
+    string = Tcl_GetString(objv[1]);
     baseString = string;
 
     /*
      * Iterate over the format string filling in the result objects until we
      * reach the end of input, the end of the format string, or there is a
@@ -701,15 +701,14 @@
 		flags |= SCAN_BIG;
 		format += 1;
 		format += TclUtfToUniChar(format, &ch);
 		break;
 	    }
+	    /* FALLTHRU */
 	case 'L':
 	    flags |= SCAN_LONGER;
-	    /*
-	     * Fall through so we skip to the next character.
-	     */
+	    /* FALLTHRU */
 	case 'h':
 	    format += TclUtfToUniChar(format, &ch);
 	}
 
 	/*
@@ -949,11 +948,11 @@
 			mp_clear(&big);
 		    }
 
 		    if (code == TCL_ERROR) {
 			if (objs != NULL) {
-			    Tcl_Free(objs);
+			    ckfree(objs);
 			}
 			Tcl_DecrRefCount(objPtr);
 			Tcl_SetObjResult(interp, Tcl_NewStringObj(
 				"unsigned bignum scans are invalid", -1));
 			Tcl_SetErrorCode(interp, "TCL", "FORMAT",
@@ -1074,11 +1073,11 @@
 		Tcl_ListObjAppendElement(NULL, objPtr, Tcl_NewObj());
 	    }
 	}
     }
     if (objs != NULL) {
-	Tcl_Free(objs);
+	ckfree(objs);
     }
     if (code == TCL_OK) {
 	if (underflow && (nconversions == 0)) {
 	    if (numVars) {
 		objPtr = Tcl_NewWideIntObj(-1);

Index: generic/tclStrToD.c
==================================================================
--- generic/tclStrToD.c
+++ generic/tclStrToD.c
@@ -472,20 +472,20 @@
     const char *expected,	/* Description of the type of number the
 				 * caller expects to be able to parse
 				 * ("integer", "boolean value", etc.). */
     const char *bytes,		/* Pointer to the start of the string to
 				 * scan. */
-    size_t numBytes,		/* Maximum number of bytes to scan, see
+    int numBytes,		/* Maximum number of bytes to scan, see
 				 * above. */
     const char **endPtrPtr,	/* Place to store pointer to the character
 				 * that terminated the scan. */
     int flags)			/* Flags governing the parse. */
 {
     enum State {
 	INITIAL, SIGNUM, ZERO, ZERO_X,
 	ZERO_O, ZERO_B, ZERO_D, BINARY,
-	HEXADECIMAL, OCTAL, DECIMAL,
+	HEXADECIMAL, OCTAL, BAD_OCTAL, DECIMAL,
 	LEADING_RADIX_POINT, FRACTION,
 	EXPONENT_START, EXPONENT_SIGNUM, EXPONENT,
 	sI, sIN, sINF, sINFI, sINFIN, sINFINI, sINFINIT, sINFINITY
 #ifdef IEEE_FLOATING_POINT
 	, sN, sNA, sNAN, sNANPAREN, sNANHEX, sNANFINISH
@@ -526,10 +526,11 @@
 				 * point. */
     int status = TCL_OK;	/* Status to return to caller. */
     char d = 0;			/* Last hexadecimal digit scanned; initialized
 				 * to avoid a compiler warning. */
     int shift = 0;		/* Amount to shift when accumulating binary */
+    int explicitOctal = 0;
 
 #define ALL_BITS	((Tcl_WideUInt)-1)
 #define MOST_BITS	(ALL_BITS >> 1)
 
     /*
@@ -657,18 +658,22 @@
 	    }
 	    if (flags & TCL_PARSE_BINARY_ONLY) {
 		goto zerob;
 	    }
 	    if (c == 'o' || c == 'O') {
+		explicitOctal = 1;
 		state = ZERO_O;
 		break;
 	    }
 	    if (c == 'd' || c == 'D') {
 		state = ZERO_D;
 		break;
 	    }
+#ifdef TCL_NO_DEPRECATED
 	    goto decimal;
+#endif
+	    /* FALLTHROUGH */
 
 	case OCTAL:
 	    /*
 	     * Scanned an optional + or -, followed by a string of octal
 	     * digits. Acceptable inputs are more digits, period, or E. If 8
@@ -727,10 +732,62 @@
 		}
 		numTrailZeros = 0;
 		state = OCTAL;
 		break;
 	    }
+	    /* FALLTHROUGH */
+
+	case BAD_OCTAL:
+	    if (explicitOctal) {
+		/*
+		 * No forgiveness for bad digits in explicitly octal numbers.
+		 */
+
+		goto endgame;
+	    }
+	    if (flags & TCL_PARSE_INTEGER_ONLY) {
+		/*
+		 * No seeking floating point when parsing only integer.
+		 */
+
+		goto endgame;
+	    }
+#ifndef TCL_NO_DEPRECATED
+
+	    /*
+	     * Scanned a number with a leading zero that contains an 8, 9,
+	     * radix point or E. This is an invalid octal number, but might
+	     * still be floating point.
+	     */
+
+	    if (c == '0') {
+		numTrailZeros++;
+		state = BAD_OCTAL;
+		break;
+	    } else if (isdigit(UCHAR(c))) {
+		if (objPtr != NULL) {
+		    significandOverflow = AccumulateDecimalDigit(
+			    (unsigned)(c-'0'), numTrailZeros,
+			    &significandWide, &significandBig,
+			    significandOverflow);
+		}
+		if (numSigDigs != 0) {
+		    numSigDigs += (numTrailZeros + 1);
+		} else {
+		    numSigDigs = 1;
+		}
+		numTrailZeros = 0;
+		state = BAD_OCTAL;
+		break;
+	    } else if (c == '.') {
+		state = FRACTION;
+		break;
+	    } else if (c == 'E' || c == 'e') {
+		state = EXPONENT_START;
+		break;
+	    }
+#endif
 	    goto endgame;
 
 	    /*
 	     * Scanned 0x. If state is HEXADECIMAL, scanned at least one
 	     * character following the 0x. The only acceptable inputs are
@@ -841,11 +898,13 @@
 	    /*
 	     * Scanned an optional + or - followed by a string of decimal
 	     * digits.
 	     */
 
+#ifdef TCL_NO_DEPRECATED
 	decimal:
+#endif
 	    acceptState = state;
 	    acceptPoint = p;
 	    acceptLen = len;
 	    if (c == '0') {
 		numTrailZeros++;
@@ -1109,11 +1168,11 @@
 		p++;
 		len--;
 	    }
 	}
 	if (endPtrPtr == NULL) {
-	    if ((len != 0) && ((numBytes + 1 > 1) || (*p != '\0'))) {
+	    if ((len != 0) && ((numBytes > 0) || (*p != '\0'))) {
 		status = TCL_ERROR;
 	    }
 	} else {
 	    *endPtrPtr = p;
 	}
@@ -1125,10 +1184,11 @@
 
     if (status == TCL_OK && objPtr != NULL) {
 	TclFreeIntRep(objPtr);
 	switch (acceptState) {
 	case SIGNUM:
+	case BAD_OCTAL:
 	case ZERO_X:
 	case ZERO_O:
 	case ZERO_B:
 	case ZERO_D:
 	case LEADING_RADIX_POINT:
@@ -1322,10 +1382,13 @@
 	    Tcl_Obj *msg = Tcl_ObjPrintf("expected %s but got \"",
 		    expected);
 
 	    Tcl_AppendLimitedToObj(msg, bytes, numBytes, 50, "");
 	    Tcl_AppendToObj(msg, "\"", -1);
+	    if (state == BAD_OCTAL) {
+		Tcl_AppendToObj(msg, " (looks like invalid octal number)", -1);
+	    }
 	    Tcl_SetObjResult(interp, msg);
 	    Tcl_SetErrorCode(interp, "TCL", "VALUE", "NUMBER", NULL);
 	}
     }
 
@@ -2108,11 +2171,11 @@
  *
  *	Bailout for formatting infinities and Not-A-Number.
  *
  * Results:
  *	Returns one of the strings 'Infinity' and 'NaN'.  The string returned
- *	must be freed by the caller using 'Tcl_Free'.
+ *	must be freed by the caller using 'ckfree'.
  *
  * Side effects:
  *	Stores 9999 in *decpt, and sets '*endPtr' to designate the terminating
  *	NUL byte of the string if 'endPtr' is not NULL.
  *
@@ -2127,17 +2190,17 @@
 {
     char *retval;
 
     *decpt = 9999;
     if (!(d->w.word1) && !(d->w.word0 & HI_ORDER_SIG_MASK)) {
-	retval = Tcl_Alloc(9);
+	retval = ckalloc(9);
 	strcpy(retval, "Infinity");
 	if (endPtr) {
 	    *endPtr = retval + 8;
 	}
     } else {
-	retval = Tcl_Alloc(4);
+	retval = ckalloc(4);
 	strcpy(retval, "NaN");
 	if (endPtr) {
 	    *endPtr = retval + 3;
 	}
     }
@@ -2164,11 +2227,11 @@
 static inline char *
 FormatZero(
     int *decpt,			/* Location of the decimal point. */
     char **endPtr)		/* Pointer to the end of the formatted data */
 {
-    char *retval = Tcl_Alloc(2);
+    char *retval = ckalloc(2);
 
     strcpy(retval, "0");
     if (endPtr) {
 	*endPtr = retval+1;
     }
@@ -2710,11 +2773,11 @@
 
     /*
      * Handle the peculiar case where the result has no significant digits.
      */
 
-    retval = Tcl_Alloc(len + 1);
+    retval = ckalloc(len + 1);
     if (ilim == 0) {
 	d -= 5.;
 	if (d > eps.d) {
 	    *retval = '1';
 	    *decpt = k;
@@ -2721,11 +2784,11 @@
 	    return retval;
 	} else if (d < -eps.d) {
 	    *decpt = k;
 	    return retval;
 	} else {
-	    Tcl_Free(retval);
+	    ckfree(retval);
 	    return NULL;
 	}
     }
 
     /*
@@ -2736,11 +2799,11 @@
 	end = ShorteningQuickFormat(d, k, ilim, eps.d, retval, decpt);
     } else {
 	end = StrictQuickFormat(d, k, ilim, eps.d, retval, decpt);
     }
     if (end == NULL) {
-	Tcl_Free(retval);
+	ckfree(retval);
 	return NULL;
     }
     *end = '\0';
     if (endPtr != NULL) {
 	*endPtr = end;
@@ -2821,11 +2884,11 @@
     int ilim1,			/* Number of digits to convert if b < s */
     int *decpt,			/* OUTPUT: Position of the decimal point. */
     char **endPtr)		/* OUTPUT: Position of the terminal '\0' at
 				 *	   the end of the returned string. */
 {
-    char *retval = Tcl_Alloc(len + 1);
+    char *retval = ckalloc(len + 1);
 				/* Output buffer. */
     Tcl_WideUInt b = (bw * wuipow5[b5]) << b2;
 				/* Numerator of the fraction being
 				 * converted. */
     Tcl_WideUInt S = wuipow5[s5] << s2;
@@ -2985,11 +3048,11 @@
     int ilim1,			/* Number of digits to convert if b < s */
     int *decpt,			/* OUTPUT: Position of the decimal point. */
     char **endPtr)		/* OUTPUT: Position of the terminal '\0' at
 				 *	   the end of the returned string. */
 {
-    char *retval = Tcl_Alloc(len + 1);
+    char *retval = ckalloc(len + 1);
 				/* Output buffer. */
     Tcl_WideUInt b = (bw * wuipow5[b5]) << b2;
 				/* Numerator of the fraction being
 				 * converted. */
     Tcl_WideUInt S = wuipow5[s5] << s2;
@@ -3186,11 +3249,11 @@
     int ilim1,			/* Number of digits to convert if b < s */
     int *decpt,			/* OUTPUT: Position of the decimal point. */
     char **endPtr)		/* OUTPUT: Position of the terminal '\0' at
 				 *	   the end of the returned string. */
 {
-    char *retval = Tcl_Alloc(len + 1);
+    char *retval = ckalloc(len + 1);
 				/* Output buffer. */
     mp_int b;			/* Numerator of the fraction being
 				 * converted. */
     mp_int mplus, mminus;	/* Bounds for roundoff. */
     mp_digit digit;		/* Current output digit. */
@@ -3374,11 +3437,11 @@
     int ilim1,			/* Number of digits to convert if b < s */
     int *decpt,			/* OUTPUT: Position of the decimal point. */
     char **endPtr)		/* OUTPUT: Position of the terminal '\0' at
 				 *	   the end of the returned string. */
 {
-    char *retval = Tcl_Alloc(len + 1);
+    char *retval = ckalloc(len + 1);
 				/* Output buffer. */
     mp_int b;			/* Numerator of the fraction being
 				 * converted. */
     mp_digit digit;		/* Current output digit. */
     char *s = retval;		/* Cursor in the output buffer. */
@@ -3568,11 +3631,11 @@
     int ilim,			/* Number of digits to convert if b >= s */
     int ilim1,			/* Number of digits to convert if b < s */
     int *decpt,			/* OUTPUT: Position of the decimal point. */
     char **endPtr)		/* OUTPUT: Pointer to the end of the number */
 {
-    char *retval = Tcl_Alloc(len+1);
+    char *retval = ckalloc(len+1);
 				/* Buffer of digits to return. */
     char *s = retval;		/* Cursor in the return value. */
     mp_int b;			/* Numerator of the result. */
     mp_int mminus;		/* 1/2 ulp below the result. */
     mp_int mplus;		/* 1/2 ulp above the result. */
@@ -3779,11 +3842,11 @@
     int ilim,			/* Number of digits to convert if b >= s */
     int ilim1,			/* Number of digits to convert if b < s */
     int *decpt,			/* OUTPUT: Position of the decimal point. */
     char **endPtr)		/* OUTPUT: Pointer to the end of the number */
 {
-    char *retval = Tcl_Alloc(len+1);
+    char *retval = ckalloc(len+1);
 				/* Buffer of digits to return. */
     char *s = retval;		/* Cursor in the return value. */
     mp_int b;			/* Numerator of the result. */
     mp_int S;			/* Denominator of the result. */
     mp_int dig;			/* Current digit of the result. */
@@ -3931,18 +3994,19 @@
  *	sign (or no sign) should appear.
  *
  * This function is a service routine that produces the string of digits for
  * floating-point-to-decimal conversion. It can do a number of things
  * according to the 'flags' argument. Valid values for 'flags' include:
- *	TCL_DD_SHORTEST - This is the default for floating point conversion.
- *		It constructs the shortest string of
+ *	TCL_DD_SHORTEST - This is the default for floating point conversion if
+ *		::tcl_precision is 0. It constructs the shortest string of
  *		digits that will reconvert to the given number when scanned.
  *		For floating point numbers that are exactly between two
  *		decimal numbers, it resolves using the 'round to even' rule.
  *		With this value, the 'ndigits' parameter is ignored.
  *	TCL_DD_E_FORMAT - This value is used to prepare numbers for %e format
- *		conversion. It constructs a string of at most 'ndigits' digits,
+ *		conversion (or for default floating->string if tcl_precision
+ *		is not 0). It constructs a string of at most 'ndigits' digits,
  *		choosing the one that is closest to the given number (and
  *		resolving ties with 'round to even').  It is allowed to return
  *		fewer than 'ndigits' if the number converts exactly; if the
  *		TCL_DD_E_FORMAT|TCL_DD_SHORTEN_FLAG is supplied instead, it
  *		also returns fewer digits if the shorter string will still
@@ -4272,11 +4336,11 @@
      * Initialize table of powers of 10 expressed as wide integers.
      */
 
     maxpow10_wide = (int)
 	    floor(sizeof(Tcl_WideUInt) * CHAR_BIT * log(2.) / log(10.));
-    pow10_wide = Tcl_Alloc((maxpow10_wide + 1) * sizeof(Tcl_WideUInt));
+    pow10_wide = ckalloc((maxpow10_wide + 1) * sizeof(Tcl_WideUInt));
     u = 1;
     for (i = 0; i < maxpow10_wide; ++i) {
 	pow10_wide[i] = u;
 	u *= 10;
     }
@@ -4379,11 +4443,11 @@
 void
 TclFinalizeDoubleConversion(void)
 {
     int i;
 
-    Tcl_Free(pow10_wide);
+    ckfree(pow10_wide);
     for (i=0; i<9; ++i) {
 	mp_clear(pow5 + i);
     }
     for (i=0; i < 5; ++i) {
 	mp_clear(pow5_13 + i);

Index: generic/tclStringObj.c
==================================================================
--- generic/tclStringObj.c
+++ generic/tclStringObj.c
@@ -44,32 +44,32 @@
  */
 
 static void		AppendPrintfToObjVA(Tcl_Obj *objPtr,
 			    const char *format, va_list argList);
 static void		AppendUnicodeToUnicodeRep(Tcl_Obj *objPtr,
-			    const Tcl_UniChar *unicode, size_t appendNumChars);
+			    const Tcl_UniChar *unicode, int appendNumChars);
 static void		AppendUnicodeToUtfRep(Tcl_Obj *objPtr,
-			    const Tcl_UniChar *unicode, size_t numChars);
+			    const Tcl_UniChar *unicode, int numChars);
 static void		AppendUtfToUnicodeRep(Tcl_Obj *objPtr,
-			    const char *bytes, size_t numBytes);
+			    const char *bytes, int numBytes);
 static void		AppendUtfToUtfRep(Tcl_Obj *objPtr,
-			    const char *bytes, size_t numBytes);
+			    const char *bytes, int numBytes);
 static void		DupStringInternalRep(Tcl_Obj *objPtr,
 			    Tcl_Obj *copyPtr);
-static size_t		ExtendStringRepWithUnicode(Tcl_Obj *objPtr,
-			    const Tcl_UniChar *unicode, size_t numChars);
+static int		ExtendStringRepWithUnicode(Tcl_Obj *objPtr,
+			    const Tcl_UniChar *unicode, int numChars);
 static void		ExtendUnicodeRepWithString(Tcl_Obj *objPtr,
-			    const char *bytes, size_t numBytes,
-			    size_t numAppendChars);
+			    const char *bytes, int numBytes,
+			    int numAppendChars);
 static void		FillUnicodeRep(Tcl_Obj *objPtr);
 static void		FreeStringInternalRep(Tcl_Obj *objPtr);
-static void		GrowStringBuffer(Tcl_Obj *objPtr, size_t needed, int flag);
-static void		GrowUnicodeBuffer(Tcl_Obj *objPtr, size_t needed);
+static void		GrowStringBuffer(Tcl_Obj *objPtr, int needed, int flag);
+static void		GrowUnicodeBuffer(Tcl_Obj *objPtr, int needed);
 static int		SetStringFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr);
 static void		SetUnicodeObj(Tcl_Obj *objPtr,
-			    const Tcl_UniChar *unicode, size_t numChars);
-static size_t		UnicodeLength(const Tcl_UniChar *unicode);
+			    const Tcl_UniChar *unicode, int numChars);
+static int		UnicodeLength(const Tcl_UniChar *unicode);
 static void		UpdateStringOfString(Tcl_Obj *objPtr);
 
 /*
  * The structure below defines the string Tcl object type by means of
  * functions that can be invoked by generic object code.
@@ -121,11 +121,11 @@
 #endif
 
 static void
 GrowStringBuffer(
     Tcl_Obj *objPtr,
-    size_t needed,
+    int needed,
     int flag)
 {
     /*
      * Pre-conditions:
      *	objPtr->typePtr == &tclStringType
@@ -133,75 +133,82 @@
      *	flag || objPtr->bytes != NULL
      */
 
     String *stringPtr = GET_STRING(objPtr);
     char *ptr = NULL;
-    size_t attempt;
+    int attempt;
 
     if (objPtr->bytes == &tclEmptyString) {
 	objPtr->bytes = NULL;
     }
     if (flag == 0 || stringPtr->allocated > 0) {
-	attempt = 2 * needed;
-	ptr = Tcl_AttemptRealloc(objPtr->bytes, attempt + 1);
+	if (needed <= INT_MAX / 2) {
+	    attempt = 2 * needed;
+	    ptr = attemptckrealloc(objPtr->bytes, attempt + 1);
+	}
 	if (ptr == NULL) {
 	    /*
 	     * Take care computing the amount of modest growth to avoid
 	     * overflow into invalid argument values for attempt.
 	     */
 
-	    size_t limit = INT_MAX - needed;
-	    size_t extra = needed - objPtr->length + TCL_MIN_GROWTH;
-	    size_t growth = (extra > limit) ? limit : extra;
+	    unsigned int limit = INT_MAX - needed;
+	    unsigned int extra = needed - objPtr->length + TCL_MIN_GROWTH;
+	    int growth = (int) ((extra > limit) ? limit : extra);
 
 	    attempt = needed + growth;
-	    ptr = Tcl_AttemptRealloc(objPtr->bytes, attempt + 1);
+	    ptr = attemptckrealloc(objPtr->bytes, attempt + 1);
 	}
     }
     if (ptr == NULL) {
 	/*
 	 * First allocation - just big enough; or last chance fallback.
 	 */
 
 	attempt = needed;
-	ptr = Tcl_Realloc(objPtr->bytes, attempt + 1);
+	ptr = ckrealloc(objPtr->bytes, attempt + 1);
     }
     objPtr->bytes = ptr;
     stringPtr->allocated = attempt;
 }
 
 static void
 GrowUnicodeBuffer(
     Tcl_Obj *objPtr,
-    size_t needed)
+    int needed)
 {
     /*
      * Pre-conditions:
      *	objPtr->typePtr == &tclStringType
      *	needed > stringPtr->maxChars
+     *	needed < STRING_MAXCHARS
      */
 
     String *ptr = NULL, *stringPtr = GET_STRING(objPtr);
-    size_t attempt;
+    int attempt;
 
     if (stringPtr->maxChars > 0) {
 	/*
 	 * Subsequent appends - apply the growth algorithm.
 	 */
 
-	attempt = 2 * needed;
-	ptr = stringAttemptRealloc(stringPtr, attempt);
+	if (needed <= STRING_MAXCHARS / 2) {
+	    attempt = 2 * needed;
+	    ptr = stringAttemptRealloc(stringPtr, attempt);
+	}
 	if (ptr == NULL) {
 	    /*
 	     * Take care computing the amount of modest growth to avoid
 	     * overflow into invalid argument values for attempt.
 	     */
 
-	    size_t extra = needed - stringPtr->numChars
+	    unsigned int limit = STRING_MAXCHARS - needed;
+	    unsigned int extra = needed - stringPtr->numChars
 		    + TCL_MIN_UNICHAR_GROWTH;
+	    int growth = (int) ((extra > limit) ? limit : extra);
 
-	    attempt = needed + extra;
+	    attempt = needed + growth;
 	    ptr = stringAttemptRealloc(stringPtr, attempt);
 	}
     }
     if (ptr == NULL) {
 	/*
@@ -245,11 +252,11 @@
 #undef Tcl_NewStringObj
 Tcl_Obj *
 Tcl_NewStringObj(
     const char *bytes,		/* Points to the first of the length bytes
 				 * used to initialize the new object. */
-    size_t length)			/* The number of bytes to copy from "bytes"
+    int length)			/* The number of bytes to copy from "bytes"
 				 * when initializing the new object. If
 				 * negative, use bytes up to the first NUL
 				 * byte. */
 {
     return Tcl_DbNewStringObj(bytes, length, "unknown", 0);
@@ -257,17 +264,18 @@
 #else /* if not TCL_MEM_DEBUG */
 Tcl_Obj *
 Tcl_NewStringObj(
     const char *bytes,		/* Points to the first of the length bytes
 				 * used to initialize the new object. */
-    size_t length)		/* The number of bytes to copy from "bytes"
-				 * when initializing the new object. If -1,
-				 * use bytes up to the first NUL byte. */
+    int length)			/* The number of bytes to copy from "bytes"
+				 * when initializing the new object. If
+				 * negative, use bytes up to the first NUL
+				 * byte. */
 {
     Tcl_Obj *objPtr;
 
-    if (length == TCL_AUTO_LENGTH) {
+    if (length < 0) {
 	length = (bytes? strlen(bytes) : 0);
     }
     TclNewStringObj(objPtr, bytes, length);
     return objPtr;
 }
@@ -305,21 +313,22 @@
 #ifdef TCL_MEM_DEBUG
 Tcl_Obj *
 Tcl_DbNewStringObj(
     const char *bytes,		/* Points to the first of the length bytes
 				 * used to initialize the new object. */
-    size_t length,		/* The number of bytes to copy from "bytes"
-				 * when initializing the new object. If -1,
-				 * use bytes up to the first NUL byte. */
+    int length,			/* The number of bytes to copy from "bytes"
+				 * when initializing the new object. If
+				 * negative, use bytes up to the first NUL
+				 * byte. */
     const char *file,		/* The name of the source file calling this
 				 * function; used for debugging. */
     int line)			/* Line number in the source file; used for
 				 * debugging. */
 {
     Tcl_Obj *objPtr;
 
-    if (length == TCL_AUTO_LENGTH) {
+    if (length < 0) {
 	length = (bytes? strlen(bytes) : 0);
     }
     TclDbNewObj(objPtr, file, line);
     TclInitStringRep(objPtr, bytes, length);
     return objPtr;
@@ -327,13 +336,14 @@
 #else /* if not TCL_MEM_DEBUG */
 Tcl_Obj *
 Tcl_DbNewStringObj(
     const char *bytes,		/* Points to the first of the length bytes
 				 * used to initialize the new object. */
-    size_t length,		/* The number of bytes to copy from "bytes"
-				 * when initializing the new object. If -1,
-				 * use bytes up to the first NUL byte. */
+    int length,			/* The number of bytes to copy from "bytes"
+				 * when initializing the new object. If
+				 * negative, use bytes up to the first NUL
+				 * byte. */
     const char *file,		/* The name of the source file calling this
 				 * function; used for debugging. */
     int line)			/* Line number in the source file; used for
 				 * debugging. */
 {
@@ -362,11 +372,11 @@
 
 Tcl_Obj *
 Tcl_NewUnicodeObj(
     const Tcl_UniChar *unicode,	/* The unicode string used to initialize the
 				 * new object. */
-    size_t numChars)		/* Number of characters in the unicode
+    int numChars)		/* Number of characters in the unicode
 				 * string. */
 {
     Tcl_Obj *objPtr;
 
     TclNewObj(objPtr);
@@ -389,17 +399,17 @@
  *	rep.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_GetCharLength(
     Tcl_Obj *objPtr)		/* The String object to get the num chars
 				 * of. */
 {
     String *stringPtr;
-    size_t numChars = 0;
+    int numChars;
 
     /*
      * Quick, no-shimmer return for short string reps.
      */
 
@@ -418,12 +428,14 @@
      * but there's no value in that. We *want* to shimmer an improper bytearray
      * because improper bytearrays have worthless internal reps.
      */
 
     if (TclIsPureByteArray(objPtr)) {
-	(void) TclGetByteArrayFromObj(objPtr, &numChars);
-	return numChars;
+	int length;
+
+	(void) Tcl_GetByteArrayFromObj(objPtr, &length);
+	return length;
     }
 
     /*
      * OK, need to work with the object as a string.
      */
@@ -434,11 +446,11 @@
 
     /*
      * If numChars is unknown, compute it.
      */
 
-    if (numChars == TCL_AUTO_LENGTH) {
+    if (numChars == -1) {
 	TclNumUtfChars(numChars, objPtr->bytes, objPtr->length);
 	stringPtr->numChars = numChars;
     }
     return numChars;
 }
@@ -505,28 +517,31 @@
 
 int
 Tcl_GetUniChar(
     Tcl_Obj *objPtr,		/* The object to get the Unicode charater
 				 * from. */
-    size_t index)		/* Get the index'th Unicode character. */
+    int index)			/* Get the index'th Unicode character. */
 {
     String *stringPtr;
-    int ch;
+    int ch, length;
+
+    if (index < 0) {
+	return -1;
+    }
 
     /*
      * Optimize the case where we're really dealing with a bytearray object
      * we don't need to convert to a string to perform the indexing operation.
      */
 
     if (TclIsPureByteArray(objPtr)) {
-	size_t length = 0;
-	unsigned char *bytes = TclGetByteArrayFromObj(objPtr, &length);
+	unsigned char *bytes = Tcl_GetByteArrayFromObj(objPtr, &length);
 	if (index >= length) {
 		return -1;
 	}
 
-	return bytes[index];
+	return (int) bytes[index];
     }
 
     /*
      * OK, need to work with the object as a string.
      */
@@ -537,11 +552,11 @@
     if (stringPtr->hasUnicode == 0) {
 	/*
 	 * If numChars is unknown, compute it.
 	 */
 
-	if (stringPtr->numChars == TCL_AUTO_LENGTH) {
+	if (stringPtr->numChars == -1) {
 	    TclNumUtfChars(stringPtr->numChars, objPtr->bytes, objPtr->length);
 	}
 	if (stringPtr->numChars == objPtr->length) {
 	    return (Tcl_UniChar) objPtr->bytes[index];
 	}
@@ -570,10 +585,40 @@
     }
 #endif
     return ch;
 }
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_GetUnicode --
+ *
+ *	Get the Unicode form of the String object. If the object is not
+ *	already a String object, it will be converted to one. If the String
+ *	object does not have a Unicode rep, then one is created from the UTF
+ *	string format.
+ *
+ * Results:
+ *	Returns a pointer to the object's internal Unicode string.
+ *
+ * Side effects:
+ *	Converts the object to have the String internal rep.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_GetUnicode
+Tcl_UniChar *
+Tcl_GetUnicode(
+    Tcl_Obj *objPtr)		/* The object to find the unicode string
+				 * for. */
+{
+    return Tcl_GetUnicodeFromObj(objPtr, NULL);
+}
+#endif /* TCL_NO_DEPRECATED */
+
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_GetUnicodeFromObj --
  *
@@ -635,31 +680,28 @@
  */
 
 Tcl_Obj *
 Tcl_GetRange(
     Tcl_Obj *objPtr,		/* The Tcl object to find the range of. */
-    size_t first,			/* First index of the range. */
-    size_t last)			/* Last index of the range. */
+    int first,			/* First index of the range. */
+    int last)			/* Last index of the range. */
 {
     Tcl_Obj *newObjPtr;		/* The Tcl object to find the range of. */
     String *stringPtr;
-    size_t length = 0;
+    int length;
 
-    if (first == TCL_INDEX_NONE) {
-	first = TCL_INDEX_START;
-    }
-    if (last + 2 <= first + 1) {
-	return Tcl_NewObj();
+    if (first < 0) {
+	first = 0;
     }
 
     /*
      * Optimize the case where we're really dealing with a bytearray object
      * we don't need to convert to a string to perform the substring operation.
      */
 
     if (TclIsPureByteArray(objPtr)) {
-	unsigned char *bytes = TclGetByteArrayFromObj(objPtr, &length);
+	unsigned char *bytes = Tcl_GetByteArrayFromObj(objPtr, &length);
 
 	if (last >= length) {
 	    last = length - 1;
 	}
 	if (last < first) {
@@ -678,11 +720,11 @@
     if (stringPtr->hasUnicode == 0) {
 	/*
 	 * If numChars is unknown, compute it.
 	 */
 
-	if (stringPtr->numChars == TCL_AUTO_LENGTH) {
+	if (stringPtr->numChars == -1) {
 	    TclNumUtfChars(stringPtr->numChars, objPtr->bytes, objPtr->length);
 	}
 	if (stringPtr->numChars == objPtr->length) {
 	    if (last >= stringPtr->numChars) {
 		last = stringPtr->numChars - 1;
@@ -710,15 +752,15 @@
     if (last < first) {
 	return Tcl_NewObj();
     }
 #if TCL_UTF_MAX <= 4
     /* See: bug [11ae2be95dac9417] */
-    if ((first + 1 > 1) && ((stringPtr->unicode[first] & 0xFC00) == 0xDC00)
+    if ((first > 0) && ((stringPtr->unicode[first] & 0xFC00) == 0xDC00)
 	    && ((stringPtr->unicode[first-1] & 0xFC00) == 0xD800)) {
 	++first;
     }
-    if ((last + 2 < stringPtr->numChars + 1)
+    if ((last + 1 < stringPtr->numChars)
 	    && ((stringPtr->unicode[last+1] & 0xFC00) == 0xDC00)
 	    && ((stringPtr->unicode[last] & 0xFC00) == 0xD800)) {
 	++last;
     }
 #endif
@@ -749,12 +791,12 @@
 void
 Tcl_SetStringObj(
     Tcl_Obj *objPtr,		/* Object whose internal rep to init. */
     const char *bytes,		/* Points to the first of the length bytes
 				 * used to initialize the object. */
-    size_t length)		/* The number of bytes to copy from "bytes"
-				 * when initializing the object. If -1,
+    int length)			/* The number of bytes to copy from "bytes"
+				 * when initializing the object. If negative,
 				 * use bytes up to the first NUL byte.*/
 {
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetStringObj");
     }
@@ -769,11 +811,11 @@
      * Free any old string rep, then set the string rep to a copy of the
      * length bytes starting at "bytes".
      */
 
     TclInvalidateStringRep(objPtr);
-    if (length == TCL_AUTO_LENGTH) {
+    if (length < 0) {
 	length = (bytes? strlen(bytes) : 0);
     }
     TclInitStringRep(objPtr, bytes, length);
 }
 
@@ -802,16 +844,25 @@
 
 void
 Tcl_SetObjLength(
     Tcl_Obj *objPtr,		/* Pointer to object. This object must not
 				 * currently be shared. */
-    size_t length)		/* Number of bytes desired for string
+    int length)			/* Number of bytes desired for string
 				 * representation of object, not including
 				 * terminating null byte. */
 {
     String *stringPtr;
 
+    if (length < 0) {
+	/*
+	 * Setting to a negative length is nonsense. This is probably the
+	 * result of overflowing the signed integer range.
+	 */
+
+	Tcl_Panic("Tcl_SetObjLength: negative length requested: "
+		"%d (integer overflow?)", length);
+    }
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetObjLength");
     }
 
     if (objPtr->bytes && objPtr->length == length) {
@@ -828,13 +879,13 @@
 	if (length > stringPtr->allocated) {
 	    /*
 	     * Need to enlarge the buffer.
 	     */
 	    if (objPtr->bytes == &tclEmptyString) {
-		objPtr->bytes = Tcl_Alloc(length + 1);
+		objPtr->bytes = ckalloc(length + 1);
 	    } else {
-		objPtr->bytes = Tcl_Realloc(objPtr->bytes, length + 1);
+		objPtr->bytes = ckrealloc(objPtr->bytes, length + 1);
 	    }
 	    stringPtr->allocated = length;
 	}
 
 	objPtr->length = length;
@@ -842,13 +893,18 @@
 
 	/*
 	 * Invalidate the unicode data.
 	 */
 
-	stringPtr->numChars = TCL_AUTO_LENGTH;
+	stringPtr->numChars = -1;
 	stringPtr->hasUnicode = 0;
     } else {
+	/*
+	 * Changing length of pure unicode string.
+	 */
+
+	stringCheckLimits(length);
 	if (length > stringPtr->maxChars) {
 	    stringPtr = stringRealloc(stringPtr, length);
 	    SET_STRING(objPtr, stringPtr);
 	    stringPtr->maxChars = length;
 	}
@@ -893,16 +949,24 @@
 
 int
 Tcl_AttemptSetObjLength(
     Tcl_Obj *objPtr,		/* Pointer to object. This object must not
 				 * currently be shared. */
-    size_t length)		/* Number of bytes desired for string
+    int length)			/* Number of bytes desired for string
 				 * representation of object, not including
 				 * terminating null byte. */
 {
     String *stringPtr;
 
+    if (length < 0) {
+	/*
+	 * Setting to a negative length is nonsense. This is probably the
+	 * result of overflowing the signed integer range.
+	 */
+
+	return 0;
+    }
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_AttemptSetObjLength");
     }
     if (objPtr->bytes && objPtr->length == length) {
 	return 1;
@@ -921,13 +985,13 @@
 	     */
 
 	    char *newBytes;
 
 	    if (objPtr->bytes == &tclEmptyString) {
-		newBytes = Tcl_AttemptAlloc(length + 1);
+		newBytes = attemptckalloc(length + 1);
 	    } else {
-		newBytes = Tcl_AttemptRealloc(objPtr->bytes, length + 1);
+		newBytes = attemptckrealloc(objPtr->bytes, length + 1);
 	    }
 	    if (newBytes == NULL) {
 		return 0;
 	    }
 	    objPtr->bytes = newBytes;
@@ -939,17 +1003,20 @@
 
 	/*
 	 * Invalidate the unicode data.
 	 */
 
-	stringPtr->numChars = TCL_AUTO_LENGTH;
+	stringPtr->numChars = -1;
 	stringPtr->hasUnicode = 0;
     } else {
 	/*
 	 * Changing length of pure unicode string.
 	 */
 
+	if (length > STRING_MAXCHARS) {
+	    return 0;
+	}
 	if (length > stringPtr->maxChars) {
 	    stringPtr = stringAttemptRealloc(stringPtr, length);
 	    if (stringPtr == NULL) {
 		return 0;
 	    }
@@ -992,52 +1059,54 @@
 void
 Tcl_SetUnicodeObj(
     Tcl_Obj *objPtr,		/* The object to set the string of. */
     const Tcl_UniChar *unicode,	/* The unicode string used to initialize the
 				 * object. */
-    size_t numChars)		/* Number of characters in the unicode
+    int numChars)		/* Number of characters in the unicode
 				 * string. */
 {
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetUnicodeObj");
     }
     TclFreeIntRep(objPtr);
     SetUnicodeObj(objPtr, unicode, numChars);
 }
 
-static size_t
+static int
 UnicodeLength(
     const Tcl_UniChar *unicode)
 {
-    size_t numChars = 0;
+    int numChars = 0;
 
     if (unicode) {
-	while ((numChars != TCL_AUTO_LENGTH) && (unicode[numChars] != 0)) {
+	while (numChars >= 0 && unicode[numChars] != 0) {
 	    numChars++;
 	}
     }
+    stringCheckLimits(numChars);
     return numChars;
 }
 
 static void
 SetUnicodeObj(
     Tcl_Obj *objPtr,		/* The object to set the string of. */
     const Tcl_UniChar *unicode,	/* The unicode string used to initialize the
 				 * object. */
-    size_t numChars)		/* Number of characters in the unicode
+    int numChars)		/* Number of characters in the unicode
 				 * string. */
 {
     String *stringPtr;
 
-    if (numChars == TCL_AUTO_LENGTH) {
+    if (numChars < 0) {
 	numChars = UnicodeLength(unicode);
     }
 
     /*
      * Allocate enough space for the String structure + Unicode string.
      */
 
+    stringCheckLimits(numChars);
     stringPtr = stringAlloc(numChars);
     SET_STRING(objPtr, stringPtr);
     objPtr->typePtr = &tclStringType;
 
     stringPtr->maxChars = numChars;
@@ -1071,27 +1140,27 @@
 void
 Tcl_AppendLimitedToObj(
     Tcl_Obj *objPtr,		/* Points to the object to append to. */
     const char *bytes,		/* Points to the bytes to append to the
 				 * object. */
-    size_t length,		/* The number of bytes available to be
-				 * appended from "bytes". If -1, then
-				 * all bytes up to a NUL byte are available. */
-    size_t limit,		/* The maximum number of bytes to append to
+    int length,			/* The number of bytes available to be
+				 * appended from "bytes". If < 0, then all
+				 * bytes up to a NUL byte are available. */
+    int limit,			/* The maximum number of bytes to append to
 				 * the object. */
     const char *ellipsis)	/* Ellipsis marker string, appended to the
 				 * object to indicate not all available bytes
 				 * at "bytes" were appended. */
 {
     String *stringPtr;
-    size_t toCopy = 0;
+    int toCopy = 0;
 
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_AppendLimitedToObj");
     }
 
-    if (length == TCL_AUTO_LENGTH) {
+    if (length < 0) {
 	length = (bytes ? strlen(bytes) : 0);
     }
     if (length == 0) {
 	return;
     }
@@ -1101,11 +1170,11 @@
     } else {
 	if (ellipsis == NULL) {
 	    ellipsis = "...";
 	}
 	toCopy = (bytes == NULL) ? limit
-		: (size_t)(Tcl_UtfPrev(bytes+limit+1-strlen(ellipsis), bytes) - bytes);
+		: Tcl_UtfPrev(bytes+limit+1-strlen(ellipsis), bytes) - bytes;
     }
 
     /*
      * If objPtr has a valid Unicode rep, then append the Unicode conversion
      * of "bytes" to the objPtr's Unicode rep, otherwise append "bytes" to
@@ -1113,11 +1182,11 @@
      */
 
     SetStringFromAny(NULL, objPtr);
     stringPtr = GET_STRING(objPtr);
 
-    if (stringPtr->hasUnicode && (stringPtr->numChars+1) > 1) {
+    if (stringPtr->hasUnicode && stringPtr->numChars > 0) {
 	AppendUtfToUnicodeRep(objPtr, bytes, toCopy);
     } else {
 	AppendUtfToUtfRep(objPtr, bytes, toCopy);
     }
 
@@ -1124,11 +1193,11 @@
     if (length <= limit) {
 	return;
     }
 
     stringPtr = GET_STRING(objPtr);
-    if (stringPtr->hasUnicode && (stringPtr->numChars+1) > 1) {
+    if (stringPtr->hasUnicode && stringPtr->numChars > 0) {
 	AppendUtfToUnicodeRep(objPtr, ellipsis, strlen(ellipsis));
     } else {
 	AppendUtfToUtfRep(objPtr, ellipsis, strlen(ellipsis));
     }
 }
@@ -1153,15 +1222,15 @@
 void
 Tcl_AppendToObj(
     Tcl_Obj *objPtr,		/* Points to the object to append to. */
     const char *bytes,		/* Points to the bytes to append to the
 				 * object. */
-    size_t length)		/* The number of bytes to append from "bytes".
-				 * If -1, then append all bytes up to NUL
+    int length)			/* The number of bytes to append from "bytes".
+				 * If < 0, then append all bytes up to NUL
 				 * byte. */
 {
-    Tcl_AppendLimitedToObj(objPtr, bytes, length, TCL_AUTO_LENGTH, NULL);
+    Tcl_AppendLimitedToObj(objPtr, bytes, length, INT_MAX, NULL);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1182,11 +1251,11 @@
 void
 Tcl_AppendUnicodeToObj(
     Tcl_Obj *objPtr,		/* Points to the object to append to. */
     const Tcl_UniChar *unicode,	/* The unicode string to append to the
 				 * object. */
-    size_t length)		/* Number of chars in "unicode". */
+    int length)			/* Number of chars in "unicode". */
 {
     String *stringPtr;
 
     if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_AppendUnicodeToObj");
@@ -1236,12 +1305,11 @@
 Tcl_AppendObjToObj(
     Tcl_Obj *objPtr,		/* Points to the object to append to. */
     Tcl_Obj *appendObjPtr)	/* Object to append. */
 {
     String *stringPtr;
-    size_t length = 0, numChars;
-    size_t appendNumChars = TCL_AUTO_LENGTH;
+    int length, numChars, appendNumChars = -1;
     const char *bytes;
 
     /*
      * Special case: second object is standard-empty is fast case. We know
      * that appending nothing to anything leaves that starting anything...
@@ -1261,11 +1329,11 @@
     if ((TclIsPureByteArray(objPtr) || objPtr->bytes == &tclEmptyString)
 	    && TclIsPureByteArray(appendObjPtr)) {
 	/*
 	 * You might expect the code here to be
 	 *
-	 *  bytes = TclGetByteArrayFromObj(appendObjPtr, &length);
+	 *  bytes = Tcl_GetByteArrayFromObj(appendObjPtr, &length);
 	 *  TclAppendBytesToByteArray(objPtr, bytes, length);
 	 *
 	 * and essentially all of the time that would be fine. However, it
 	 * would run into trouble in the case where objPtr and appendObjPtr
 	 * point to the same thing. That may never be a good idea. It seems to
@@ -1277,14 +1345,14 @@
 	 * cases.
 	 *
 	 * First, get the lengths.
 	 */
 
-	size_t lengthSrc = 0;
+	int lengthSrc;
 
-	(void) TclGetByteArrayFromObj(objPtr, &length);
-	(void) TclGetByteArrayFromObj(appendObjPtr, &lengthSrc);
+	(void) Tcl_GetByteArrayFromObj(objPtr, &length);
+	(void) Tcl_GetByteArrayFromObj(appendObjPtr, &lengthSrc);
 
 	/*
 	 * Grow buffer enough for the append.
 	 */
 
@@ -1323,11 +1391,11 @@
 	 * If appendObjPtr is not of the "String" type, don't convert it.
 	 */
 
 	if (TclHasIntRep(appendObjPtr, &tclStringType)) {
 	    Tcl_UniChar *unicode =
-		    TclGetUnicodeFromObj(appendObjPtr, &numChars);
+		    Tcl_GetUnicodeFromObj(appendObjPtr, &numChars);
 
 	    AppendUnicodeToUnicodeRep(objPtr, unicode, numChars);
 	} else {
 	    bytes = TclGetStringFromObj(appendObjPtr, &length);
 	    AppendUtfToUnicodeRep(objPtr, bytes, length);
@@ -1342,19 +1410,19 @@
      */
 
     bytes = TclGetStringFromObj(appendObjPtr, &length);
 
     numChars = stringPtr->numChars;
-    if ((numChars != TCL_AUTO_LENGTH) && TclHasIntRep(appendObjPtr, &tclStringType)) {
+    if ((numChars >= 0) && TclHasIntRep(appendObjPtr, &tclStringType)) {
 	String *appendStringPtr = GET_STRING(appendObjPtr);
 
 	appendNumChars = appendStringPtr->numChars;
     }
 
     AppendUtfToUtfRep(objPtr, bytes, length);
 
-    if ((numChars != TCL_AUTO_LENGTH) && (appendNumChars != TCL_AUTO_LENGTH)) {
+    if (numChars >= 0 && appendNumChars >= 0) {
 	stringPtr->numChars = numChars + appendNumChars;
     }
 }
 
 /*
@@ -1376,16 +1444,16 @@
 
 static void
 AppendUnicodeToUnicodeRep(
     Tcl_Obj *objPtr,		/* Points to the object to append to. */
     const Tcl_UniChar *unicode,	/* String to append. */
-    size_t appendNumChars)		/* Number of chars of "unicode" to append. */
+    int appendNumChars)		/* Number of chars of "unicode" to append. */
 {
     String *stringPtr;
-    size_t numChars;
+    int numChars;
 
-    if (appendNumChars == TCL_AUTO_LENGTH) {
+    if (appendNumChars < 0) {
 	appendNumChars = UnicodeLength(unicode);
     }
     if (appendNumChars == 0) {
 	return;
     }
@@ -1400,34 +1468,35 @@
      * "TCL STRING GROWTH ALGORITHM" comment at the top of this file for an
      * explanation of this growth algorithm.
      */
 
     numChars = stringPtr->numChars + appendNumChars;
+    stringCheckLimits(numChars);
 
     if (numChars > stringPtr->maxChars) {
-	size_t index = TCL_INDEX_NONE;
+	int offset = -1;
 
 	/*
 	 * Protect against case where unicode points into the existing
 	 * stringPtr->unicode array. Force it to follow any relocations due to
 	 * the reallocs below.
 	 */
 
 	if (unicode && unicode >= stringPtr->unicode
 		&& unicode <= stringPtr->unicode + stringPtr->maxChars) {
-	    index = unicode - stringPtr->unicode;
+	    offset = unicode - stringPtr->unicode;
 	}
 
 	GrowUnicodeBuffer(objPtr, numChars);
 	stringPtr = GET_STRING(objPtr);
 
 	/*
 	 * Relocate unicode if needed; see above.
 	 */
 
-	if (index != TCL_INDEX_NONE) {
-	    unicode = stringPtr->unicode + index;
+	if (offset >= 0) {
+	    unicode = stringPtr->unicode + offset;
 	}
     }
 
     /*
      * Copy the new string onto the end of the old string, then add the
@@ -1464,17 +1533,17 @@
 
 static void
 AppendUnicodeToUtfRep(
     Tcl_Obj *objPtr,		/* Points to the object to append to. */
     const Tcl_UniChar *unicode,	/* String to convert to UTF. */
-    size_t numChars)		/* Number of chars of "unicode" to convert. */
+    int numChars)		/* Number of chars of "unicode" to convert. */
 {
     String *stringPtr = GET_STRING(objPtr);
 
     numChars = ExtendStringRepWithUnicode(objPtr, unicode, numChars);
 
-    if (stringPtr->numChars != TCL_AUTO_LENGTH) {
+    if (stringPtr->numChars != -1) {
 	stringPtr->numChars += numChars;
     }
 }
 
 /*
@@ -1497,11 +1566,11 @@
 
 static void
 AppendUtfToUnicodeRep(
     Tcl_Obj *objPtr,		/* Points to the object to append to. */
     const char *bytes,		/* String to convert to Unicode. */
-    size_t numBytes)		/* Number of bytes of "bytes" to convert. */
+    int numBytes)		/* Number of bytes of "bytes" to convert. */
 {
     String *stringPtr;
 
     if (numBytes == 0) {
 	return;
@@ -1533,14 +1602,14 @@
 
 static void
 AppendUtfToUtfRep(
     Tcl_Obj *objPtr,		/* Points to the object to append to. */
     const char *bytes,		/* String to append. */
-    size_t numBytes)		/* Number of bytes of "bytes" to append. */
+    int numBytes)		/* Number of bytes of "bytes" to append. */
 {
     String *stringPtr;
-    size_t newLength, oldLength;
+    int newLength, oldLength;
 
     if (numBytes == 0) {
 	return;
     }
 
@@ -1552,14 +1621,17 @@
     if (objPtr->bytes == NULL) {
 	objPtr->length = 0;
     }
     oldLength = objPtr->length;
     newLength = numBytes + oldLength;
+    if (newLength < 0) {
+	Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
+    }
 
     stringPtr = GET_STRING(objPtr);
     if (newLength > stringPtr->allocated) {
-	size_t offset = TCL_AUTO_LENGTH;
+	int offset = -1;
 
 	/*
 	 * Protect against case where unicode points into the existing
 	 * stringPtr->unicode array. Force it to follow any relocations due to
 	 * the reallocs below.
@@ -1579,28 +1651,65 @@
 
 	/*
 	 * Relocate bytes if needed; see above.
 	 */
 
-	if (offset != TCL_AUTO_LENGTH) {
+	if (offset >= 0) {
 	    bytes = objPtr->bytes + offset;
 	}
     }
 
     /*
      * Invalidate the unicode data.
      */
 
-    stringPtr->numChars = TCL_AUTO_LENGTH;
+    stringPtr->numChars = -1;
     stringPtr->hasUnicode = 0;
 
     if (bytes) {
 	memmove(objPtr->bytes + oldLength, bytes, numBytes);
     }
     objPtr->bytes[newLength] = 0;
     objPtr->length = newLength;
 }
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_AppendStringsToObjVA --
+ *
+ *	This function appends one or more null-terminated strings to an
+ *	object.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	The contents of all the string arguments are appended to the string
+ *	representation of objPtr.
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+Tcl_AppendStringsToObjVA(
+    Tcl_Obj *objPtr,		/* Points to the object to append to. */
+    va_list argList)		/* Variable argument list. */
+{
+    if (Tcl_IsShared(objPtr)) {
+	Tcl_Panic("%s called with shared object", "Tcl_AppendStringsToObj");
+    }
+
+    while (1) {
+	const char *bytes = va_arg(argList, char *);
+
+	if (bytes == NULL) {
+	    break;
+	}
+	Tcl_AppendToObj(objPtr, bytes, -1);
+    }
+}
 
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_AppendStringsToObj --
@@ -1624,22 +1733,11 @@
     ...)
 {
     va_list argList;
 
     va_start(argList, objPtr);
-    if (Tcl_IsShared(objPtr)) {
-	Tcl_Panic("%s called with shared object", "Tcl_AppendStringsToObj");
-    }
-
-    while (1) {
-	const char *bytes = va_arg(argList, char *);
-
-	if (bytes == NULL) {
-	    break;
-	}
-	Tcl_AppendToObj(objPtr, bytes, -1);
-    }
+    Tcl_AppendStringsToObjVA(objPtr, argList);
     va_end(argList);
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1668,12 +1766,12 @@
     const char *format,
     int objc,
     Tcl_Obj *const objv[])
 {
     const char *span = format, *msg, *errCode;
-    int objIndex = 0, gotXpg = 0, gotSequential = 0;
-    size_t originalLength, limit, numBytes = 0;
+    int numBytes = 0, objIndex = 0, gotXpg = 0, gotSequential = 0;
+    int originalLength, limit;
     Tcl_UniChar ch = 0;
     static const char *mixedXPG =
 	    "cannot mix \"%\" and \"%n$\" conversion specifiers";
     static const char *const badIndex[2] = {
 	"not enough arguments for all format specifiers",
@@ -1682,12 +1780,12 @@
     static const char *overflow = "max size for a Tcl value exceeded";
 
     if (Tcl_IsShared(appendObj)) {
 	Tcl_Panic("%s called with shared object", "Tcl_AppendFormatToObj");
     }
-    (void)TclGetStringFromObj(appendObj, &originalLength);
-    limit = (size_t)INT_MAX - originalLength;
+    TclGetStringFromObj(appendObj, &originalLength);
+    limit = INT_MAX - originalLength;
 
     /*
      * Format string is NUL-terminated.
      */
 
@@ -1696,12 +1794,11 @@
 	int gotMinus = 0, gotHash = 0, gotZero = 0, gotSpace = 0, gotPlus = 0;
 	int width, gotPrecision, precision, sawFlag, useShort = 0, useBig = 0;
 #ifndef TCL_WIDE_INT_IS_LONG
 	int useWide = 0;
 #endif
-	int newXpg, numChars, allocSegment = 0, segmentLimit;
-	size_t segmentNumBytes;
+	int newXpg, numChars, allocSegment = 0, segmentLimit, segmentNumBytes;
 	Tcl_Obj *segment;
 	int step = TclUtfToUniChar(format, &ch);
 
 	format += step;
 	if (ch != '%') {
@@ -1829,11 +1926,11 @@
 	    }
 	    objIndex++;
 	    format += step;
 	    step = TclUtfToUniChar(format, &ch);
 	}
-	if (width > (int) limit) {
+	if (width > limit) {
 	    msg = overflow;
 	    errCode = "OVERFLOW";
 	    goto errorMsg;
 	}
 
@@ -1960,10 +2057,11 @@
 	    allocSegment = 1;
 	    break;
 	}
 
 	case 'u':
+	    /* FALLTHRU */
 	case 'd':
 	case 'o':
 	case 'p':
 	case 'x':
 	case 'X':
@@ -2054,16 +2152,24 @@
 		    break;
 		case 'b':
 		    Tcl_AppendToObj(segment, "0b", 2);
 		    segmentLimit -= 2;
 		    break;
+#if TCL_MAJOR_VERSION < 9
+		case 'd':
+		    if (gotZero) {
+			Tcl_AppendToObj(segment, "0d", 2);
+			segmentLimit -= 2;
+		    }
+		    break;
+#endif
 		}
 	    }
 
 	    switch (ch) {
 	    case 'd': {
-		size_t length;
+		int length;
 		Tcl_Obj *pure;
 		const char *bytes;
 
 		if (useShort) {
 		    pure = Tcl_NewWideIntObj(s);
@@ -2094,25 +2200,25 @@
 		 * entirely of one-byte encoded characters, so "length" is the
 		 * number of chars.
 		 */
 
 		if (gotPrecision) {
-		    if (length < (size_t)precision) {
+		    if (length < precision) {
 			segmentLimit -= precision - length;
 		    }
-		    while (length < (size_t)precision) {
+		    while (length < precision) {
 			Tcl_AppendToObj(segment, "0", 1);
 			length++;
 		    }
 		    gotZero = 0;
 		}
 		if (gotZero) {
 		    length += Tcl_GetCharLength(segment);
-		    if (length < (size_t)width) {
+		    if (length < width) {
 			segmentLimit -= width - length;
 		    }
-		    while (length < (size_t)width) {
+		    while (length < width) {
 			Tcl_AppendToObj(segment, "0", 1);
 			length++;
 		    }
 		}
 		if (toAppend > segmentLimit) {
@@ -2129,14 +2235,13 @@
 	    case 'o':
 	    case 'p':
 	    case 'x':
 	    case 'X':
 	    case 'b': {
-		Tcl_WideUInt bits = 0;
-		Tcl_WideInt numDigits = 0;
-		int numBits = 4, base = 16, index = 0, shift = 0;
-		size_t length;
+		Tcl_WideUInt bits = (Tcl_WideUInt) 0;
+		Tcl_WideInt numDigits = (Tcl_WideInt) 0;
+		int length, numBits = 4, base = 16, index = 0, shift = 0;
 		Tcl_Obj *pure;
 		char *bytes;
 
 		if (ch == 'u') {
 		    base = 10;
@@ -2196,13 +2301,13 @@
 
 		if (numDigits == 0) {
 		    numDigits = 1;
 		}
 		pure = Tcl_NewObj();
-		Tcl_SetObjLength(pure, numDigits);
+		Tcl_SetObjLength(pure, (int) numDigits);
 		bytes = TclGetString(pure);
-		toAppend = length = numDigits;
+		toAppend = length = (int) numDigits;
 		while (numDigits--) {
 		    int digitOffset;
 
 		    if (useBig && big.used) {
 			if (index < big.used && (size_t) shift <
@@ -2210,11 +2315,11 @@
 			    bits |= ((Tcl_WideUInt) big.dp[index++]) << shift;
 			    shift += MP_DIGIT_BIT;
 			}
 			shift -= numBits;
 		    }
-		    digitOffset = bits % base;
+		    digitOffset = (int) (bits % base);
 		    if (digitOffset > 9) {
 			if (ch == 'X') {
 			    bytes[numDigits] = 'A' + digitOffset - 10;
 			} else {
 			    bytes[numDigits] = 'a' + digitOffset - 10;
@@ -2226,25 +2331,25 @@
 		}
 		if (useBig) {
 		    mp_clear(&big);
 		}
 		if (gotPrecision) {
-		    if (length < (size_t)precision) {
+		    if (length < precision) {
 			segmentLimit -= precision - length;
 		    }
-		    while (length < (size_t)precision) {
+		    while (length < precision) {
 			Tcl_AppendToObj(segment, "0", 1);
 			length++;
 		    }
 		    gotZero = 0;
 		}
 		if (gotZero) {
 		    length += Tcl_GetCharLength(segment);
-		    if (length < (size_t)width) {
+		    if (length < width) {
 			segmentLimit -= width - length;
 		    }
-		    while (length < (size_t)width) {
+		    while (length < width) {
 			Tcl_AppendToObj(segment, "0", 1);
 			length++;
 		    }
 		}
 		if (toAppend > segmentLimit) {
@@ -2359,11 +2464,11 @@
 		Tcl_AppendToObj(appendObj, (gotZero ? "0" : " "), 1);
 		numChars++;
 	    }
 	}
 
-	(void)TclGetStringFromObj(segment, &segmentNumBytes);
+	TclGetStringFromObj(segment, &segmentNumBytes);
 	if (segmentNumBytes > limit) {
 	    if (allocSegment) {
 		Tcl_DecrRefCount(segment);
 	    }
 	    msg = overflow;
@@ -2502,11 +2607,11 @@
 		 * copy only whole characters, and avoid copying any partial
 		 * multi-byte characters.
 		 */
 
 		q = Tcl_UtfPrev(end, bytes);
-		if (!Tcl_UtfCharComplete(q, (end - q))) {
+		if (!Tcl_UtfCharComplete(q, (int)(end - q))) {
 		    end = q;
 		}
 
 		q = bytes + TCL_UTF_MAX;
 		while ((bytes < end) && (bytes < q)
@@ -2513,11 +2618,11 @@
 			&& ((*bytes & 0xC0) == 0x80)) {
 		    bytes++;
 		}
 
 		Tcl_ListObjAppendElement(NULL, list,
-			Tcl_NewStringObj(bytes , (end - bytes)));
+			Tcl_NewStringObj(bytes , (int)(end - bytes)));
 
 		break;
 	    }
 	    case 'c':
 	    case 'i':
@@ -2563,19 +2668,19 @@
 				va_arg(argList, double)));
 		}
 		seekingConversion = 0;
 		break;
 	    case '*':
-		lastNum = va_arg(argList, int);
+		lastNum = (int) va_arg(argList, int);
 		Tcl_ListObjAppendElement(NULL, list, Tcl_NewWideIntObj(lastNum));
 		p++;
 		break;
 	    case '0': case '1': case '2': case '3': case '4':
 	    case '5': case '6': case '7': case '8': case '9': {
 		char *end;
 
-		lastNum = strtoul(p, &end, 10);
+		lastNum = (int) strtoul(p, &end, 10);
 		p = end;
 		break;
 	    }
 	    case '.':
 		gotPrecision = 1;
@@ -2612,10 +2717,11 @@
 		size = 3;
 		p++;
 		break;
 	    case 'h':
 		size = -1;
+		/* FALLTHRU */
 	    default:
 		p++;
 	    }
 	} while (seekingConversion);
     }
@@ -2622,11 +2728,11 @@
     TclListObjGetElements(NULL, list, &objc, &objv);
     code = Tcl_AppendFormatToObj(NULL, objPtr, format, objc, objv);
     if (code != TCL_OK) {
 	Tcl_AppendPrintfToObj(objPtr,
 		"Unable to format \"%s\" with supplied arguments: %s",
-		format, TclGetString(list));
+		format, Tcl_GetString(list));
     }
     Tcl_DecrRefCount(list);
 }
 
 /*
@@ -2702,16 +2808,16 @@
  */
 
 char *
 TclGetStringStorage(
     Tcl_Obj *objPtr,
-    size_t *sizePtr)
+    unsigned int *sizePtr)
 {
     String *stringPtr;
 
     if (!TclHasIntRep(objPtr, &tclStringType) || objPtr->bytes == NULL) {
-	return TclGetStringFromObj(objPtr, sizePtr);
+	return TclGetStringFromObj(objPtr, (int *)sizePtr);
     }
 
     stringPtr = GET_STRING(objPtr);
     *sizePtr = stringPtr->allocated;
     return objPtr->bytes;
@@ -2736,16 +2842,16 @@
 
 Tcl_Obj *
 TclStringRepeat(
     Tcl_Interp *interp,
     Tcl_Obj *objPtr,
-    size_t count,
+    int count,
     int flags)
 {
     Tcl_Obj *objResultPtr;
     int inPlace = flags & TCL_STRING_IN_PLACE;
-    size_t length = 0, unichar = 0, done = 1;
+    int length = 0, unichar = 0, done = 1;
     int binary = TclIsPureByteArray(objPtr);
 
     /* assert (count >= 2) */
 
     /*
@@ -2764,17 +2870,17 @@
 	}
     }
 
     if (binary) {
 	/* Result will be pure byte array. Pre-size it */
-	(void)TclGetByteArrayFromObj(objPtr, &length);
+	Tcl_GetByteArrayFromObj(objPtr, &length);
     } else if (unichar) {
 	/* Result will be pure Tcl_UniChar array. Pre-size it. */
-	(void)TclGetUnicodeFromObj(objPtr, &length);
+	Tcl_GetUnicodeFromObj(objPtr, &length);
     } else {
 	/* Result will be concat of string reps. Pre-size it. */
-	(void)TclGetStringFromObj(objPtr, &length);
+	Tcl_GetStringFromObj(objPtr, &length);
     }
 
     if (length == 0) {
 	/* Any repeats of empty is empty. */
 	return objPtr;
@@ -2836,19 +2942,19 @@
 	/*
 	 * Efficiently concatenate string reps.
 	 */
 
 	if (!inPlace || Tcl_IsShared(objPtr)) {
-	    objResultPtr = Tcl_NewStringObj(TclGetString(objPtr), length);
+	    objResultPtr = Tcl_NewStringObj(Tcl_GetString(objPtr), length);
 	} else {
 	    TclFreeIntRep(objPtr);
 	    objResultPtr = objPtr;
 	}
         if (0 == Tcl_AttemptSetObjLength(objResultPtr, count*length)) {
 	    if (interp) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-			"string size overflow: unable to alloc %" TCL_Z_MODIFIER "u bytes",
+			"string size overflow: unable to alloc %u bytes",
 			count*length));
 		Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
 	    }
 	    return NULL;
 	}
@@ -2855,11 +2961,11 @@
 	Tcl_SetObjLength(objResultPtr, length);
 	while (count - done > done) {
 	    Tcl_AppendObjToObj(objResultPtr, objResultPtr);
 	    done *= 2;
 	}
-	Tcl_AppendToObj(objResultPtr, TclGetString(objResultPtr),
+	Tcl_AppendToObj(objResultPtr, Tcl_GetString(objResultPtr),
 		(count - done) * length);
     }
     return objResultPtr;
 }
 
@@ -2886,12 +2992,11 @@
     int objc,
     Tcl_Obj * const objv[],
     int flags)
 {
     Tcl_Obj *objResultPtr, * const *ov;
-    int oc, binary = 1;
-	size_t length = 0;
+    int oc, length = 0, binary = 1;
     int allowUniChar = 1, requestUniChar = 0;
     int first = objc - 1;	/* Index of first value possibly not empty */
     int last = 0;		/* Index of last value possibly not empty */
     int inPlace = flags & TCL_STRING_IN_PLACE;
 
@@ -2947,11 +3052,11 @@
     if (binary) {
 	/*
 	 * Result will be pure byte array. Pre-size it
 	 */
 
-	size_t numBytes = 0;
+	int numBytes;
 	ov = objv;
 	oc = objc;
 	do {
 	    Tcl_Obj *objPtr = *ov++;
 
@@ -2960,16 +3065,18 @@
 	     * value we know we can safely use, or it is an empty string.
 	     * We don't need to count bytes for the empty strings.
 	     */
 
 	    if (TclIsPureByteArray(objPtr)) {
-		(void)TclGetByteArrayFromObj(objPtr, &numBytes); /* PANIC? */
+		Tcl_GetByteArrayFromObj(objPtr, &numBytes); /* PANIC? */
 
 		if (numBytes) {
 		    last = objc - oc;
 		    if (length == 0) {
 			first = last;
+		    } else if (numBytes > INT_MAX - length) {
+			goto overflow;
 		    }
 		    length += numBytes;
 		}
 	    }
 	} while (--oc);
@@ -2982,17 +3089,19 @@
 	oc = objc;
 	do {
 	    Tcl_Obj *objPtr = *ov++;
 
 	    if ((objPtr->bytes == NULL) || (objPtr->length)) {
-		size_t numChars;
+		int numChars;
 
-		(void)TclGetUnicodeFromObj(objPtr, &numChars); /* PANIC? */
+		Tcl_GetUnicodeFromObj(objPtr, &numChars); /* PANIC? */
 		if (numChars) {
 		    last = objc - oc;
 		    if (length == 0) {
 			first = last;
+		    } else if (numChars > INT_MAX - length) {
+			goto overflow;
 		    }
 		    length += numChars;
 		}
 	    }
 	} while (--oc);
@@ -3015,11 +3124,11 @@
 
 		if (objPtr->bytes == NULL) {
 		    /* No string rep; Take the chance we can avoid making it */
 		    pendingPtr = objPtr;
 		} else {
-		    (void)TclGetStringFromObj(objPtr, &length); /* PANIC? */
+		    Tcl_GetStringFromObj(objPtr, &length); /* PANIC? */
 		}
 	    } while (--oc && (length == 0) && (pendingPtr == NULL));
 
 	    /*
  	     * Either we found a possibly non-empty value, and we remember
@@ -3029,11 +3138,11 @@
  	     */
 
 	    first = last = objc - oc - 1;
 
 	    if (oc && (length == 0)) {
-		size_t numBytes;
+		int numBytes;
 
 		/* assert ( pendingPtr != NULL ) */
 
 		/*
 		 * There's a pending value followed by more values.  Loop over
@@ -3041,41 +3150,40 @@
 		 * is found, or the pending value gets its string generated.
 		 */
 
 		do {
 		    Tcl_Obj *objPtr = *ov++;
-		    (void)TclGetStringFromObj(objPtr, &numBytes); /* PANIC? */
+		    Tcl_GetStringFromObj(objPtr, &numBytes); /* PANIC? */
 		} while (--oc && numBytes == 0 && pendingPtr->bytes == NULL);
 
 		if (numBytes) {
 		    last = objc -oc -1;
 		}
 		if (oc || numBytes) {
-		    (void)TclGetStringFromObj(pendingPtr, &length);
+		    Tcl_GetStringFromObj(pendingPtr, &length);
 		}
 		if (length == 0) {
 		    if (numBytes) {
 			first = last;
 		    }
-		} else if (numBytes + length > (size_t)INT_MAX) {
+		} else if (numBytes > INT_MAX - length) {
 		    goto overflow;
 		}
 		length += numBytes;
 	    }
 	} while (oc && (length == 0));
 
 	while (oc) {
-	    size_t numBytes;
+	    int numBytes;
 	    Tcl_Obj *objPtr = *ov++;
 
 	    /* assert ( length > 0 && pendingPtr == NULL )  */
 
-	    TclGetString(objPtr); /* PANIC? */
-	    numBytes = objPtr->length;
+	    Tcl_GetStringFromObj(objPtr, &numBytes); /* PANIC? */
 	    if (numBytes) {
 		last = objc - oc;
-		if (numBytes + length > (size_t)INT_MAX) {
+		if (numBytes > INT_MAX - length) {
 		    goto overflow;
 		}
 		length += numBytes;
 	    }
 	    --oc;
@@ -3098,14 +3206,14 @@
 	 * Broken interface! Byte array value routines offer no way to handle
 	 * failure to allocate enough space. Following stanza may panic.
 	 */
 
 	if (inPlace && !Tcl_IsShared(*objv)) {
-	    size_t start = 0;
+	    int start;
 
 	    objResultPtr = *objv++; objc--;
-	    (void)TclGetByteArrayFromObj(objResultPtr, &start);
+	    Tcl_GetByteArrayFromObj(objResultPtr, &start);
 	    dst = Tcl_SetByteArrayLength(objResultPtr, length) + start;
 	} else {
 	    objResultPtr = Tcl_NewByteArrayObj(NULL, length);
 	    dst = Tcl_SetByteArrayLength(objResultPtr, length);
 	}
@@ -3117,27 +3225,27 @@
 	     * value we know we can safely use, or it is an empty string.
 	     * We don't need to copy bytes from the empty strings.
 	     */
 
 	    if (TclIsPureByteArray(objPtr)) {
-		size_t more = 0;
-		unsigned char *src = TclGetByteArrayFromObj(objPtr, &more);
+		int more;
+		unsigned char *src = Tcl_GetByteArrayFromObj(objPtr, &more);
 		memcpy(dst, src, more);
 		dst += more;
 	    }
 	}
     } else if (allowUniChar && requestUniChar) {
 	/* Efficiently produce a pure Tcl_UniChar array result */
 	Tcl_UniChar *dst;
 
 	if (inPlace && !Tcl_IsShared(*objv)) {
-	    size_t start;
+	    int start;
 
 	    objResultPtr = *objv++; objc--;
 
 	    /* Ugly interface! Force resize of the unicode array. */
-	    (void)TclGetUnicodeFromObj(objResultPtr, &start);
+	    Tcl_GetUnicodeFromObj(objResultPtr, &start);
 	    Tcl_InvalidateStringRep(objResultPtr);
 	    if (0 == Tcl_AttemptSetObjLength(objResultPtr, length)) {
 		if (interp) {
 		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    	"concatenation failed: unable to alloc %"
@@ -3168,59 +3276,59 @@
 	}
 	while (objc--) {
 	    Tcl_Obj *objPtr = *objv++;
 
 	    if ((objPtr->bytes == NULL) || (objPtr->length)) {
-		size_t more;
-		Tcl_UniChar *src = TclGetUnicodeFromObj(objPtr, &more);
+		int more;
+		Tcl_UniChar *src = Tcl_GetUnicodeFromObj(objPtr, &more);
 		memcpy(dst, src, more * sizeof(Tcl_UniChar));
 		dst += more;
 	    }
 	}
     } else {
 	/* Efficiently concatenate string reps */
 	char *dst;
 
 	if (inPlace && !Tcl_IsShared(*objv)) {
-	    size_t start;
+	    int start;
 
 	    objResultPtr = *objv++; objc--;
 
-	    (void)TclGetStringFromObj(objResultPtr, &start);
+	    Tcl_GetStringFromObj(objResultPtr, &start);
 	    if (0 == Tcl_AttemptSetObjLength(objResultPtr, length)) {
 		if (interp) {
 		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		    	"concatenation failed: unable to alloc %" TCL_Z_MODIFIER "u bytes",
+		    	"concatenation failed: unable to alloc %u bytes",
 			length));
 		    Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
 		}
 		return NULL;
 	    }
-	    dst = TclGetString(objResultPtr) + start;
+	    dst = Tcl_GetString(objResultPtr) + start;
 
 	    /* assert ( length > start ) */
 	    TclFreeIntRep(objResultPtr);
 	} else {
 	    objResultPtr = Tcl_NewObj();	/* PANIC? */
 	    if (0 == Tcl_AttemptSetObjLength(objResultPtr, length)) {
 		Tcl_DecrRefCount(objResultPtr);
 		if (interp) {
 		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		    	"concatenation failed: unable to alloc %" TCL_Z_MODIFIER "u bytes",
+		    	"concatenation failed: unable to alloc %u bytes",
 			length));
 		    Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
 		}
 		return NULL;
 	    }
-	    dst = TclGetString(objResultPtr);
+	    dst = Tcl_GetString(objResultPtr);
 	}
 	while (objc--) {
 	    Tcl_Obj *objPtr = *objv++;
 
 	    if ((objPtr->bytes == NULL) || (objPtr->length)) {
-		size_t more;
-		char *src = TclGetStringFromObj(objPtr, &more);
+		int more;
+		char *src = Tcl_GetStringFromObj(objPtr, &more);
 
 		memcpy(dst, src, more);
 		dst += more;
 	    }
 	}
@@ -3258,15 +3366,14 @@
 TclStringCmp(
     Tcl_Obj *value1Ptr,
     Tcl_Obj *value2Ptr,
     int checkEq,		/* comparison is only for equality */
     int nocase,			/* comparison is not case sensitive */
-    size_t reqlength)		/* requested length */
+    int reqlength)		/* requested length */
 {
     char *s1, *s2;
-    int empty, match;
-    size_t length, s1len = 0, s2len = 0;
+    int empty, length, match, s1len, s2len;
     memCmpFn_t memCmpFn;
 
     if ((reqlength == 0) || (value1Ptr == value2Ptr)) {
 	/*
 	 * Always match at 0 chars of if it is the same obj.
@@ -3280,12 +3387,12 @@
 	     * type conversions and it is much faster. Only do this if we're
 	     * case-sensitive (which is all that really makes sense with byte
 	     * arrays anyway, and we have no memcasecmp() for some reason... :^)
 	     */
 
-	    s1 = (char *) TclGetByteArrayFromObj(value1Ptr, &s1len);
-	    s2 = (char *) TclGetByteArrayFromObj(value2Ptr, &s2len);
+	    s1 = (char *) Tcl_GetByteArrayFromObj(value1Ptr, &s1len);
+	    s2 = (char *) Tcl_GetByteArrayFromObj(value2Ptr, &s2len);
 	    memCmpFn = memcmp;
 	} else if (TclHasIntRep(value1Ptr, &tclStringType)
 		&& TclHasIntRep(value2Ptr, &tclStringType)) {
 	    /*
 	     * Do a unicode-specific comparison if both of the args are of
@@ -3293,12 +3400,12 @@
 	     * memcmp. In benchmark testing this proved the most efficient
 	     * check between the unicode and string comparison operations.
 	     */
 
 	    if (nocase) {
-		s1 = (char *) TclGetUnicodeFromObj(value1Ptr, &s1len);
-		s2 = (char *) TclGetUnicodeFromObj(value2Ptr, &s2len);
+		s1 = (char *) Tcl_GetUnicodeFromObj(value1Ptr, &s1len);
+		s2 = (char *) Tcl_GetUnicodeFromObj(value2Ptr, &s2len);
 		memCmpFn = (memCmpFn_t)Tcl_UniCharNcasecmp;
 	    } else {
 		s1len = Tcl_GetCharLength(value1Ptr);
 		s2len = Tcl_GetCharLength(value2Ptr);
 		if ((s1len == value1Ptr->length)
@@ -3377,11 +3484,11 @@
 		 * (\xC0\x80 in Tcl's utf rep). We can use the more efficient
 		 * TclpUtfNcmp2 if we are case-sensitive and no specific
 		 * length was requested.
 		 */
 
-		if ((reqlength == TCL_AUTO_LENGTH) && !nocase) {
+		if ((reqlength < 0) && !nocase) {
 		    memCmpFn = (memCmpFn_t) TclpUtfNcmp2;
 		} else {
 		    s1len = Tcl_NumUtfChars(s1, s1len);
 		    s2len = Tcl_NumUtfChars(s2, s2len);
 		    memCmpFn = (memCmpFn_t)
@@ -3389,19 +3496,19 @@
 		}
 	    }
 	}
 
 	length = (s1len < s2len) ? s1len : s2len;
-	if (reqlength == TCL_AUTO_LENGTH) {
+	if (reqlength > 0 && reqlength < length) {
+	    length = reqlength;
+	} else if (reqlength < 0) {
 	    /*
 	     * The requested length is negative, so we ignore it by setting it
 	     * to length + 1 so we correct the match var.
 	     */
 
 	    reqlength = length + 1;
-	} else if (reqlength > 0 && reqlength < length) {
-	    length = reqlength;
 	}
 
 	if (checkEq && (s1len != s2len)) {
 	    match = 1;		/* This will be reversed below. */
 	} else {
@@ -3408,11 +3515,11 @@
 	    /*
 	     * The comparison function should compare up to the minimum byte
 	     * length only.
 	     */
 
-	    match = memCmpFn(s1, s2, length);
+	    match = memCmpFn(s1, s2, (size_t) length);
 	}
 	if ((match == 0) && (reqlength > length)) {
 	    match = s1len - s2len;
 	}
 	match = (match > 0) ? 1 : (match < 0) ? -1 : 0;
@@ -3429,69 +3536,69 @@
  *	Implements the [string first] operation.
  *
  * Results:
  *	If needle is found as a substring of haystack, the index of the
  *	first instance of such a find is returned.  If needle is not present
- *	as a substring of haystack, TCL_IO_FAILURE is returned.
+ *	as a substring of haystack, -1 is returned.
  *
  * Side effects:
  *	needle and haystack may have their Tcl_ObjType changed.
  *
  *---------------------------------------------------------------------------
  */
 
-size_t
+int
 TclStringFirst(
     Tcl_Obj *needle,
     Tcl_Obj *haystack,
-    size_t start)
+    int start)
 {
-    size_t lh = 0, ln = Tcl_GetCharLength(needle);
+    int lh, ln = Tcl_GetCharLength(needle);
 
-    if (start == TCL_AUTO_LENGTH) {
+    if (start < 0) {
 	start = 0;
     }
     if (ln == 0) {
 	/* We don't find empty substrings.  Bizarre!
 	 * Whenever this routine is turned into a proper substring
 	 * finder, change to `return start` after limits imposed. */
-	return TCL_IO_FAILURE;
+	return -1;
     }
 
     if (TclIsPureByteArray(needle) && TclIsPureByteArray(haystack)) {
-	unsigned char *end, *try, *bh;
-	unsigned char *bn = TclGetByteArrayFromObj(needle, &ln);
+	unsigned char *end, *check, *bh;
+	unsigned char *bn = Tcl_GetByteArrayFromObj(needle, &ln);
 
 	/* Find bytes in bytes */
-	bh = TclGetByteArrayFromObj(haystack, &lh);
+	bh = Tcl_GetByteArrayFromObj(haystack, &lh);
 	if ((lh < ln) || (start > lh - ln)) {
 	    /* Don't start the loop if there cannot be a valid answer */
-	    return TCL_IO_FAILURE;
+	    return -1;
 	}
 	end = bh + lh;
 
-	try = bh + start;
-	while (try + ln <= end) {
+	check = bh + start;
+	while (check + ln <= end) {
 	    /*
 	     * Look for the leading byte of the needle in the haystack
-	     * starting at try and stopping when there's not enough room
+	     * starting at check and stopping when there's not enough room
 	     * for the needle left.
 	     */
-	    try = memchr(try, bn[0], (end + 1 - ln) - try);
-	    if (try == NULL) {
+	    check = memchr(check, bn[0], (end + 1 - ln) - check);
+	    if (check == NULL) {
 		/* Leading byte not found -> needle cannot be found. */
-		return TCL_IO_FAILURE;
+		return -1;
 	    }
 	    /* Leading byte found, check rest of needle. */
-	    if (0 == memcmp(try+1, bn+1, ln-1)) {
+	    if (0 == memcmp(check+1, bn+1, ln-1)) {
 		/* Checks! Return the successful index. */
-		return (try - bh);
+		return (check - bh);
 	    }
 	    /* Rest of needle match failed; Iterate to continue search. */
-	    try++;
+	    check++;
 	}
-	return TCL_IO_FAILURE;
+	return -1;
     }
 
     /*
      * TODO: It might be nice to support some cases where it is not
      * necessary to shimmer to &tclStringType to compute the result,
@@ -3503,27 +3610,27 @@
      * what supported results for the objPtr->bytes values.  For now,
      * do only the well-defined Tcl_UniChar array search.
      */
 
     {
-	Tcl_UniChar *try, *end, *uh;
-	Tcl_UniChar *un = TclGetUnicodeFromObj(needle, &ln);
+	Tcl_UniChar *check, *end, *uh;
+	Tcl_UniChar *un = Tcl_GetUnicodeFromObj(needle, &ln);
 
-	uh = TclGetUnicodeFromObj(haystack, &lh);
+	uh = Tcl_GetUnicodeFromObj(haystack, &lh);
 	if ((lh < ln) || (start > lh - ln)) {
 	    /* Don't start the loop if there cannot be a valid answer */
-	    return TCL_IO_FAILURE;
+	    return -1;
 	}
 	end = uh + lh;
 
-	for (try = uh + start; try + ln <= end; try++) {
-	    if ((*try == *un) && (0 ==
-		    memcmp(try + 1, un + 1, (ln-1) * sizeof(Tcl_UniChar)))) {
-		return (try - uh);
+	for (check = uh + start; check + ln <= end; check++) {
+	    if ((*check == *un) && (0 ==
+		    memcmp(check + 1, un + 1, (ln-1) * sizeof(Tcl_UniChar)))) {
+		return (check - uh);
 	    }
 	}
-	return TCL_IO_FAILURE;
+	return -1;
     }
 }
 
 /*
  *---------------------------------------------------------------------------
@@ -3533,79 +3640,79 @@
  *	Implements the [string last] operation.
  *
  * Results:
  *	If needle is found as a substring of haystack, the index of the
  *	last instance of such a find is returned.  If needle is not present
- *	as a substring of haystack, TCL_IO_FAILURE is returned.
+ *	as a substring of haystack, -1 is returned.
  *
  * Side effects:
  *	needle and haystack may have their Tcl_ObjType changed.
  *
  *---------------------------------------------------------------------------
  */
 
-size_t
+int
 TclStringLast(
     Tcl_Obj *needle,
     Tcl_Obj *haystack,
-    size_t last)
+    int last)
 {
-    size_t lh = 0, ln = Tcl_GetCharLength(needle);
+    int lh, ln = Tcl_GetCharLength(needle);
 
     if (ln == 0) {
 	/*
 	 * 	We don't find empty substrings.  Bizarre!
 	 *
 	 * 	TODO: When we one day make this a true substring
 	 * 	finder, change this to "return last", after limitation.
 	 */
-	return TCL_IO_FAILURE;
-    }
-
-    if (TclIsPureByteArray(needle) && TclIsPureByteArray(haystack)) {
-	unsigned char *try, *bh = TclGetByteArrayFromObj(haystack, &lh);
-	unsigned char *bn = TclGetByteArrayFromObj(needle, &ln);
-
-	if (last + 1 >= lh + 1) {
-	    last = lh - 1;
-	}
-	if (last + 1 < ln) {
-	    /* Don't start the loop if there cannot be a valid answer */
-	    return TCL_IO_FAILURE;
-	}
-	try = bh + last + 1 - ln;
-
-	while (try >= bh) {
-	    if ((*try == bn[0])
-		    && (0 == memcmp(try+1, bn+1, ln-1))) {
-		return (try - bh);
-	    }
-	    try--;
-	}
-	return TCL_IO_FAILURE;
-    }
-
-    {
-	Tcl_UniChar *try, *uh = TclGetUnicodeFromObj(haystack, &lh);
-	Tcl_UniChar *un = TclGetUnicodeFromObj(needle, &ln);
-
-	if (last + 1 >= lh + 1) {
-	    last = lh - 1;
-	}
-	if (last + 1 < ln) {
-	    /* Don't start the loop if there cannot be a valid answer */
-	    return TCL_IO_FAILURE;
-	}
-	try = uh + last + 1 - ln;
-	while (try >= uh) {
-	    if ((*try == un[0])
-		    && (0 == memcmp(try+1, un+1, (ln-1)*sizeof(Tcl_UniChar)))) {
-		return (try - uh);
-	    }
-	    try--;
-	}
-	return TCL_IO_FAILURE;
+	return -1;
+    }
+
+    if (TclIsPureByteArray(needle) && TclIsPureByteArray(haystack)) {
+	unsigned char *check, *bh = Tcl_GetByteArrayFromObj(haystack, &lh);
+	unsigned char *bn = Tcl_GetByteArrayFromObj(needle, &ln);
+
+	if (last >= lh) {
+	    last = lh - 1;
+	}
+	if (last + 1 < ln) {
+	    /* Don't start the loop if there cannot be a valid answer */
+	    return -1;
+	}
+	check = bh + last + 1 - ln;
+
+	while (check >= bh) {
+	    if ((*check == bn[0])
+		    && (0 == memcmp(check+1, bn+1, ln-1))) {
+		return (check - bh);
+	    }
+	    check--;
+	}
+	return -1;
+    }
+
+    {
+	Tcl_UniChar *check, *uh = Tcl_GetUnicodeFromObj(haystack, &lh);
+	Tcl_UniChar *un = Tcl_GetUnicodeFromObj(needle, &ln);
+
+	if (last >= lh) {
+	    last = lh - 1;
+	}
+	if (last + 1 < ln) {
+	    /* Don't start the loop if there cannot be a valid answer */
+	    return -1;
+	}
+	check = uh + last + 1 - ln;
+	while (check >= uh) {
+	    if ((*check == un[0])
+		    && (0 == memcmp(check+1, un+1, (ln-1)*sizeof(Tcl_UniChar)))) {
+		return (check - uh);
+	    }
+	    check--;
+	}
+	return -1;
     }
 }
 
 /*
  *---------------------------------------------------------------------------
@@ -3627,11 +3734,11 @@
 
 static void
 ReverseBytes(
     unsigned char *to,		/* Copy bytes into here... */
     unsigned char *from,	/* ...from here... */
-    size_t count)		/* Until this many are copied, */
+    int count)			/* Until this many are copied, */
 				/* reversing as you go. */
 {
     unsigned char *src = from + count;
 
     if (to == from) {
@@ -3657,12 +3764,12 @@
     String *stringPtr;
     Tcl_UniChar ch = 0;
     int inPlace = flags & TCL_STRING_IN_PLACE;
 
     if (TclIsPureByteArray(objPtr)) {
-	size_t numBytes = 0;
-	unsigned char *from = TclGetByteArrayFromObj(objPtr, &numBytes);
+	int numBytes;
+	unsigned char *from = Tcl_GetByteArrayFromObj(objPtr, &numBytes);
 
 	if (!inPlace || Tcl_IsShared(objPtr)) {
 	    objPtr = Tcl_NewByteArrayObj(NULL, numBytes);
 	}
 	ReverseBytes(Tcl_GetByteArrayFromObj(objPtr, NULL), from, numBytes);
@@ -3702,41 +3809,41 @@
 	    }
 	}
     }
 
     if (objPtr->bytes) {
-	size_t numChars = stringPtr->numChars;
-	size_t numBytes = objPtr->length;
+	int numChars = stringPtr->numChars;
+	int numBytes = objPtr->length;
 	char *to, *from = objPtr->bytes;
 
 	if (!inPlace || Tcl_IsShared(objPtr)) {
 	    objPtr = Tcl_NewObj();
 	    Tcl_SetObjLength(objPtr, numBytes);
 	}
 	to = objPtr->bytes;
 
-	if ((numChars == TCL_AUTO_LENGTH) || (numChars < numBytes)) {
+	if (numChars < numBytes) {
 	    /*
 	     * Either numChars == -1 and we don't know how many chars are
 	     * represented by objPtr->bytes and we need Pass 1 just in case,
 	     * or numChars >= 0 and we know we have fewer chars than bytes, so
 	     * we know there's a multibyte character needing Pass 1.
 	     *
 	     * Pass 1. Reverse the bytes of each multi-byte character.
 	     */
 
-	    size_t charCount = 0;
-	    size_t bytesLeft = numBytes;
+	    int charCount = 0;
+	    int bytesLeft = numBytes;
 
 	    while (bytesLeft) {
 		/*
 		 * NOTE: We know that the from buffer is NUL-terminated. It's
 		 * part of the contract for objPtr->bytes values. Thus, we can
 		 * skip calling Tcl_UtfCharComplete() here.
 		 */
 
-		size_t bytesInChar = TclUtfToUniChar(from, &ch);
+		int bytesInChar = TclUtfToUniChar(from, &ch);
 
 		ReverseBytes((unsigned char *)to, (unsigned char *)from,
 			bytesInChar);
 		to += bytesInChar;
 		from += bytesInChar;
@@ -3782,17 +3889,21 @@
 
 Tcl_Obj *
 TclStringReplace(
     Tcl_Interp *interp,		/* For error reporting, may be NULL */
     Tcl_Obj *objPtr,		/* String to act upon */
-    size_t first,		/* First index to replace */
-    size_t count,		/* How many chars to replace */
+    int first,			/* First index to replace */
+    int count,			/* How many chars to replace */
     Tcl_Obj *insertPtr,		/* Replacement string, may be NULL */
     int flags)			/* TCL_STRING_IN_PLACE => attempt in-place */
 {
     int inPlace = flags & TCL_STRING_IN_PLACE;
     Tcl_Obj *result;
+
+    /* Caller is expected to pass sensible arguments */
+    assert ( count >= 0 ) ;
+    assert ( first >= 0 ) ;
 
     /* Replace nothing with nothing */
     if ((insertPtr == NULL) && (count == 0)) {
 	if (inPlace) {
 	    return objPtr;
@@ -3807,12 +3918,12 @@
      * objPtr is either a proper "bytearray" or a "string" or else it has
      * a known and short string rep.
      */
 
     if (TclIsPureByteArray(objPtr)) {
-	size_t numBytes = 0;
-	unsigned char *bytes = TclGetByteArrayFromObj(objPtr, &numBytes);
+	int numBytes;
+	unsigned char *bytes = Tcl_GetByteArrayFromObj(objPtr, &numBytes);
 
 	if (insertPtr == NULL) {
 	    /* Replace something with nothing. */
 
 	    assert ( first <= numBytes ) ;
@@ -3830,13 +3941,13 @@
 	if ((first == 0) && (count == numBytes)) {
 	    return insertPtr;
 	}
 
 	if (TclIsPureByteArray(insertPtr)) {
-	    size_t newBytes = 0;
+	    int newBytes;
 	    unsigned char *iBytes
-		    = TclGetByteArrayFromObj(insertPtr, &newBytes);
+		    = Tcl_GetByteArrayFromObj(insertPtr, &newBytes);
 
 	    if (count == newBytes && inPlace && !Tcl_IsShared(objPtr)) {
 		/*
 		 * Removal count and replacement count are equal.
 		 * Other conditions permit. Do in-place splice.
@@ -3845,11 +3956,11 @@
 		memcpy(bytes + first, iBytes, count);
 		Tcl_InvalidateStringRep(objPtr);
 		return objPtr;
 	    }
 
-	    if ((size_t)newBytes > INT_MAX - (numBytes - count)) {
+	    if (newBytes > INT_MAX - (numBytes - count)) {
 		if (interp) {
 		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			    "max size for a Tcl value (%d bytes) exceeded",
 			    INT_MAX));
 		    Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
@@ -3875,20 +3986,20 @@
      * all single-byte characters so we can index it directly.
      */
 
     /* The traditional implementation... */
     {
-	size_t numChars;
-	Tcl_UniChar *ustring = TclGetUnicodeFromObj(objPtr, &numChars);
+	int numChars;
+	Tcl_UniChar *ustring = Tcl_GetUnicodeFromObj(objPtr, &numChars);
 
 	/* TODO: Is there an in-place option worth pursuing here? */
 
 	result = Tcl_NewUnicodeObj(ustring, first);
 	if (insertPtr) {
 	    Tcl_AppendObjToObj(result, insertPtr);
 	}
-	if (first + count < (size_t)numChars) {
+	if (first + count < numChars) {
 	    Tcl_AppendUnicodeToObj(result, ustring + first + count,
 		    numChars - first - count);
 	}
 
 	return result;
@@ -3925,24 +4036,25 @@
 
 static void
 ExtendUnicodeRepWithString(
     Tcl_Obj *objPtr,
     const char *bytes,
-    size_t numBytes,
-    size_t numAppendChars)
+    int numBytes,
+    int numAppendChars)
 {
     String *stringPtr = GET_STRING(objPtr);
-    size_t needed, numOrigChars = 0;
+    int needed, numOrigChars = 0;
     Tcl_UniChar *dst, unichar = 0;
 
     if (stringPtr->hasUnicode) {
 	numOrigChars = stringPtr->numChars;
     }
-    if (numAppendChars == TCL_AUTO_LENGTH) {
+    if (numAppendChars == -1) {
 	TclNumUtfChars(numAppendChars, bytes, numBytes);
     }
     needed = numOrigChars + numAppendChars;
+    stringCheckLimits(needed);
 
     if (needed > stringPtr->maxChars) {
 	GrowUnicodeBuffer(objPtr, needed);
 	stringPtr = GET_STRING(objPtr);
     }
@@ -3986,11 +4098,11 @@
 				 * currently have an internal rep.*/
 {
     String *srcStringPtr = GET_STRING(srcPtr);
     String *copyStringPtr = NULL;
 
-    if (srcStringPtr->numChars == TCL_AUTO_LENGTH) {
+    if (srcStringPtr->numChars == -1) {
 	/*
 	 * The String struct in the source value holds zero useful data. Don't
 	 * bother copying it. Don't even bother allocating space in which to
 	 * copy it. Just let the copy be untyped.
 	 */
@@ -4122,25 +4234,25 @@
 	(void) ExtendStringRepWithUnicode(objPtr, stringPtr->unicode,
 		stringPtr->numChars);
     }
 }
 
-static size_t
+static int
 ExtendStringRepWithUnicode(
     Tcl_Obj *objPtr,
     const Tcl_UniChar *unicode,
-    size_t numChars)
+    int numChars)
 {
     /*
      * Pre-condition: this is the "string" Tcl_ObjType.
      */
 
-    size_t i, origLength, size = 0;
+    int i, origLength, size = 0;
     char *dst;
     String *stringPtr = GET_STRING(objPtr);
 
-    if (numChars == TCL_AUTO_LENGTH) {
+    if (numChars < 0) {
 	numChars = UnicodeLength(unicode);
     }
 
     if (numChars == 0) {
 	return 0;
@@ -4158,13 +4270,16 @@
     if (numChars <= (INT_MAX - size)/TCL_UTF_MAX
 	    && stringPtr->allocated >= size + numChars * TCL_UTF_MAX) {
 	goto copyBytes;
     }
 
-    for (i = 0; i < numChars; i++) {
+    for (i = 0; i < numChars && size >= 0; i++) {
 	size += TclUtfCount(unicode[i]);
     }
+    if (size < 0) {
+	Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
+    }
 
     /*
      * Grow space if needed.
      */
 
@@ -4201,11 +4316,11 @@
 
 static void
 FreeStringInternalRep(
     Tcl_Obj *objPtr)		/* Object with internal rep to free. */
 {
-    Tcl_Free(GET_STRING(objPtr));
+    ckfree(GET_STRING(objPtr));
     objPtr->typePtr = NULL;
 }
 
 /*
  * Local Variables:

Index: generic/tclStringRep.h
==================================================================
--- generic/tclStringRep.h
+++ generic/tclStringRep.h
@@ -29,14 +29,10 @@
  * Copyright (c) 1999 by Scriptics Corporation.
  *
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  */
-
-#ifndef _TCLSTRINGREP
-#define _TCLSTRINGREP
-
 
 /*
  * The following structure is the internal rep for a String object. It keeps
  * track of how much memory has been used and how much has been allocated for
  * the Unicode and UTF string to enable growing and shrinking of the UTF and
@@ -49,46 +45,54 @@
  * can be officially modified by altering the definition of Tcl_UniChar in
  * tcl.h, but do not do that unless you are sure what you're doing!
  */
 
 typedef struct {
-    size_t numChars;		/* The number of chars in the string. -1 means
-				 * this value has not been calculated. Any other
+    int numChars;		/* The number of chars in the string. -1 means
+				 * this value has not been calculated. >= 0
 				 * means that there is a valid Unicode rep, or
 				 * that the number of UTF bytes == the number
 				 * of chars. */
-    size_t allocated;		/* The amount of space actually allocated for
+    int allocated;		/* The amount of space actually allocated for
 				 * the UTF string (minus 1 byte for the
 				 * termination char). */
-    size_t maxChars;		/* Max number of chars that can fit in the
+    int maxChars;		/* Max number of chars that can fit in the
 				 * space allocated for the unicode array. */
     int hasUnicode;		/* Boolean determining whether the string has
 				 * a Unicode representation. */
     Tcl_UniChar unicode[1];	/* The array of Unicode chars. The actual size
 				 * of this field depends on the 'maxChars'
 				 * field above. */
 } String;
 
+#define STRING_MAXCHARS \
+    (int)(((size_t)UINT_MAX - sizeof(String))/sizeof(Tcl_UniChar))
 #define STRING_SIZE(numChars) \
     (sizeof(String) + ((numChars) * sizeof(Tcl_UniChar)))
+#define stringCheckLimits(numChars) \
+    do {								\
+	if ((numChars) < 0 || (numChars) > STRING_MAXCHARS) {		\
+	    Tcl_Panic("max length for a Tcl unicode value (%d chars) exceeded", \
+		      (int)STRING_MAXCHARS);					\
+	}								\
+    } while (0)
 #define stringAttemptAlloc(numChars) \
-    (String *) Tcl_AttemptAlloc(STRING_SIZE(numChars))
+    (String *) attemptckalloc(STRING_SIZE(numChars))
 #define stringAlloc(numChars) \
-    (String *) Tcl_Alloc(STRING_SIZE(numChars))
+    (String *) ckalloc(STRING_SIZE(numChars))
 #define stringRealloc(ptr, numChars) \
-    (String *) Tcl_Realloc((ptr), STRING_SIZE(numChars))
+    (String *) ckrealloc((ptr), STRING_SIZE(numChars))
 #define stringAttemptRealloc(ptr, numChars) \
-    (String *) Tcl_AttemptRealloc((ptr), STRING_SIZE(numChars))
+    (String *) attemptckrealloc((ptr), STRING_SIZE(numChars))
 #define GET_STRING(objPtr) \
     ((String *) (objPtr)->internalRep.twoPtrValue.ptr1)
 #define SET_STRING(objPtr, stringPtr) \
     ((objPtr)->internalRep.twoPtrValue.ptr2 = NULL),			\
     ((objPtr)->internalRep.twoPtrValue.ptr1 = (void *) (stringPtr))
 
-#endif /*  _TCLSTRINGREP */
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 4
  * fill-column: 78
  * End:
  */

Index: generic/tclStubInit.c
==================================================================
--- generic/tclStubInit.c
+++ generic/tclStubInit.c
@@ -27,51 +27,167 @@
  */
 
 #undef Tcl_Alloc
 #undef Tcl_Free
 #undef Tcl_Realloc
+#undef Tcl_NewBooleanObj
 #undef Tcl_NewByteArrayObj
 #undef Tcl_NewDoubleObj
+#undef Tcl_NewIntObj
 #undef Tcl_NewListObj
 #undef Tcl_NewLongObj
 #undef Tcl_DbNewLongObj
 #undef Tcl_NewObj
 #undef Tcl_NewStringObj
 #undef Tcl_GetUnicode
 #undef Tcl_DumpActiveMemory
 #undef Tcl_ValidateAllMemory
+#undef Tcl_FindHashEntry
+#undef Tcl_CreateHashEntry
+#undef Tcl_Panic
+#undef Tcl_FindExecutable
 #undef Tcl_SetExitProc
 #undef Tcl_SetPanicProc
 #undef TclpGetPid
+#undef TclSockMinimumBuffers
+#undef Tcl_SetIntObj
+#undef Tcl_SetLongObj
+#undef TclpInetNtoa
+#undef TclWinGetServByName
+#undef TclWinGetSockOpt
+#undef TclWinSetSockOpt
+#undef TclWinNToHS
 #undef TclStaticPackage
+#undef TclBNInitBignumFromLong
 #undef Tcl_BackgroundError
 #define TclStaticPackage Tcl_StaticPackage
 
-#ifdef TCL_MEM_DEBUG
-#   define Tcl_Alloc TclpAlloc
-#   define Tcl_Free TclpFree
-#   define Tcl_Realloc TclpRealloc
-#   undef Tcl_AttemptAlloc
-#   define Tcl_AttemptAlloc TclpAlloc
-#   undef Tcl_AttemptRealloc
-#   define Tcl_AttemptRealloc TclpRealloc
+#undef TclBN_mp_tc_and
+#undef TclBN_mp_tc_or
+#undef TclBN_mp_tc_xor
+#define TclBN_mp_tc_and TclBN_mp_and
+#define TclBN_mp_tc_or TclBN_mp_or
+#define TclBN_mp_tc_xor TclBN_mp_xor
+
+/* See bug 510001: TclSockMinimumBuffers needs plat imp */
+#if defined(_WIN64) || defined(TCL_NO_DEPRECATED) || TCL_MAJOR_VERSION > 8
+#   define TclSockMinimumBuffersOld 0
+#else
+#define TclSockMinimumBuffersOld sockMinimumBuffersOld
+static int TclSockMinimumBuffersOld(int sock, int size)
+{
+    return TclSockMinimumBuffers(INT2PTR(sock), size);
+}
+#endif
+
+#if defined(TCL_NO_DEPRECATED) || TCL_MAJOR_VERSION > 8
+#   define TclSetStartupScriptPath 0
+#   define TclGetStartupScriptPath 0
+#   define TclSetStartupScriptFileName 0
+#   define TclGetStartupScriptFileName 0
+#   define TclPrecTraceProc 0
+#   define TclpInetNtoa 0
+#   define TclWinGetServByName 0
+#   define TclWinGetSockOpt 0
+#   define TclWinSetSockOpt 0
+#   define TclWinNToHS 0
+#   define TclWinGetPlatformId 0
+#   define TclWinResetInterfaces 0
+#   define TclWinSetInterfaces 0
+#   define TclWinGetPlatformId 0
+#   define TclBNInitBignumFromWideUInt 0
+#   define TclBNInitBignumFromWideInt 0
+#   define TclBNInitBignumFromLong 0
+#   define Tcl_Backslash 0
+#   define Tcl_GetDefaultEncodingDir 0
+#   define Tcl_SetDefaultEncodingDir 0
+#   define Tcl_EvalTokens 0
+#   define Tcl_CreateMathFunc 0
+#   define Tcl_GetMathFuncInfo 0
+#   define Tcl_ListMathFuncs 0
+#   define Tcl_SetIntObj 0
+#   define Tcl_SetLongObj 0
+#   define Tcl_NewIntObj 0
+#   define Tcl_NewLongObj 0
+#   define Tcl_DbNewLongObj 0
+#   define Tcl_BackgroundError 0
+#else
+#define TclBNInitBignumFromLong initBignumFromLong
+static void TclBNInitBignumFromLong(mp_int *a, long b)
+{
+    TclInitBignumFromWideInt(a, b);
+}
+#define TclSetStartupScriptPath setStartupScriptPath
+static void TclSetStartupScriptPath(Tcl_Obj *path)
+{
+    Tcl_SetStartupScript(path, NULL);
+}
+#define TclGetStartupScriptPath getStartupScriptPath
+static Tcl_Obj *TclGetStartupScriptPath(void)
+{
+    return Tcl_GetStartupScript(NULL);
+}
+#define TclSetStartupScriptFileName setStartupScriptFileName
+static void TclSetStartupScriptFileName(
+    const char *fileName)
+{
+    Tcl_SetStartupScript(Tcl_NewStringObj(fileName,-1), NULL);
+}
+#define TclGetStartupScriptFileName getStartupScriptFileName
+static const char *TclGetStartupScriptFileName(void)
+{
+    Tcl_Obj *path = Tcl_GetStartupScript(NULL);
+    if (path == NULL) {
+	return NULL;
+    }
+    return Tcl_GetString(path);
+}
+#if defined(_WIN32) || defined(__CYGWIN__)
+#undef TclWinNToHS
+#undef TclWinGetPlatformId
+#undef TclWinResetInterfaces
+#undef TclWinSetInterfaces
+static void
+doNothing(void)
+{
+    /* dummy implementation, no need to do anything */
+}
+#define TclWinNToHS winNToHS
+static unsigned short TclWinNToHS(unsigned short ns) {
+	return ntohs(ns);
+}
+#define TclWinGetPlatformId winGetPlatformId
+static int
+TclWinGetPlatformId(void)
+{
+    return 2; /* VER_PLATFORM_WIN32_NT */;
+}
+#define TclWinResetInterfaces doNothing
+#define TclWinSetInterfaces (void (*) (int)) doNothing
 #endif
+#   define TclBNInitBignumFromWideUInt TclInitBignumFromWideUInt
+#   define TclBNInitBignumFromWideInt TclInitBignumFromWideInt
+#endif /* TCL_NO_DEPRECATED */
 
 #ifdef _WIN32
 #   define TclUnixWaitForFile 0
 #   define TclUnixCopyFile 0
 #   define TclUnixOpenTemporaryFile 0
+#   define TclpReaddir 0
 #   define TclpIsAtty 0
 #elif defined(__CYGWIN__)
 #   define TclpIsAtty TclPlatIsAtty
+#if defined(TCL_NO_DEPRECATED) || TCL_MAJOR_VERSION > 8
 static void
 doNothing(void)
 {
     /* dummy implementation, no need to do anything */
 }
-#   define TclWinAddProcess (void (*) (void *, size_t)) doNothing
+#endif
+#   define TclWinAddProcess (void (*) (void *, unsigned int)) doNothing
 #   define TclWinFlushDirtyChannels doNothing
+
 static int
 TclpIsAtty(int fd)
 {
     return isatty(fd);
 }
@@ -81,10 +197,35 @@
     void *hInstance = NULL;
     GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
 	    (const char *)&TclpIsAtty, &hInstance);
     return hInstance;
 }
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+#define TclWinSetSockOpt winSetSockOpt
+static int
+TclWinSetSockOpt(SOCKET s, int level, int optname,
+	    const char *optval, int optlen)
+{
+    return setsockopt((int) s, level, optname, optval, optlen);
+}
+
+#define TclWinGetSockOpt winGetSockOpt
+static int
+TclWinGetSockOpt(SOCKET s, int level, int optname,
+	    char *optval, int *optlen)
+{
+    return getsockopt((int) s, level, optname, optval, optlen);
+}
+
+#define TclWinGetServByName winGetServByName
+static struct servent *
+TclWinGetServByName(const char *name, const char *proto)
+{
+    return getservbyname(name, proto);
+}
+#endif /* TCL_NO_DEPRECATED */
 
 #define TclWinNoBackslash winNoBackslash
 static char *
 TclWinNoBackslash(char *path)
 {
@@ -96,20 +237,20 @@
 	}
     }
     return path;
 }
 
-size_t
+int
 TclpGetPid(Tcl_Pid pid)
 {
-    return (size_t) pid;
+    return (int) (size_t) pid;
 }
 
 char *
 Tcl_WinUtfToTChar(
     const char *string,
-    size_t len,
+    int len,
     Tcl_DString *dsPtr)
 {
     Tcl_DStringInit(dsPtr);
     if (!string) {
 	return NULL;
@@ -118,18 +259,18 @@
 }
 
 char *
 Tcl_WinTCharToUtf(
     const char *string,
-    size_t len,
+    int len,
     Tcl_DString *dsPtr)
 {
     Tcl_DStringInit(dsPtr);
     if (!string) {
 	return NULL;
     }
-    if (len == TCL_AUTO_LENGTH) {
+    if (len < 0) {
 	len = wcslen((wchar_t *)string);
     } else {
 	len /= 2;
     }
     return TclWCharToUtfDString((const WCHAR *)string, len, dsPtr);
@@ -171,14 +312,175 @@
 	}
     }
     return result;
 }
 #define Tcl_ExprLongObj (int(*)(Tcl_Interp*,Tcl_Obj*,long*))exprIntObj
+static int uniCharNcmp(const Tcl_UniChar *ucs, const Tcl_UniChar *uct, unsigned int n){
+   return Tcl_UniCharNcmp(ucs, uct, (unsigned long)n);
+}
+#define Tcl_UniCharNcmp (int(*)(const Tcl_UniChar*,const Tcl_UniChar*,unsigned long))uniCharNcmp
+static int utfNcmp(const char *s1, const char *s2, unsigned int n){
+   return Tcl_UtfNcmp(s1, s2, (unsigned long)n);
+}
+#define Tcl_UtfNcmp (int(*)(const char*,const char*,unsigned long))utfNcmp
+static int utfNcasecmp(const char *s1, const char *s2, unsigned int n){
+   return Tcl_UtfNcasecmp(s1, s2, (unsigned long)n);
+}
+#define Tcl_UtfNcasecmp (int(*)(const char*,const char*,unsigned long))utfNcasecmp
+static int uniCharNcasecmp(const Tcl_UniChar *ucs, const Tcl_UniChar *uct, unsigned int n){
+   return Tcl_UniCharNcasecmp(ucs, uct, (unsigned long)n);
+}
+#define Tcl_UniCharNcasecmp (int(*)(const Tcl_UniChar*,const Tcl_UniChar*,unsigned long))uniCharNcasecmp
+
 #endif /* TCL_WIDE_INT_IS_LONG */
 
 #endif /* __CYGWIN__ */
 
+#if defined(TCL_NO_DEPRECATED)
+#   define Tcl_SeekOld 0
+#   define Tcl_TellOld 0
+#   undef Tcl_SetBooleanObj
+#   define Tcl_SetBooleanObj 0
+#   undef Tcl_PkgPresent
+#   define Tcl_PkgPresent 0
+#   undef Tcl_PkgProvide
+#   define Tcl_PkgProvide 0
+#   undef Tcl_PkgRequire
+#   define Tcl_PkgRequire 0
+#   undef Tcl_GetIndexFromObj
+#   define Tcl_GetIndexFromObj 0
+#   define Tcl_NewBooleanObj 0
+#   undef Tcl_DbNewBooleanObj
+#   define Tcl_DbNewBooleanObj 0
+#   undef Tcl_SetBooleanObj
+#   define Tcl_SetBooleanObj 0
+#   undef Tcl_SetVar
+#   define Tcl_SetVar 0
+#   undef Tcl_UnsetVar
+#   define Tcl_UnsetVar 0
+#   undef Tcl_GetVar
+#   define Tcl_GetVar 0
+#   undef Tcl_TraceVar
+#   define Tcl_TraceVar 0
+#   undef Tcl_UntraceVar
+#   define Tcl_UntraceVar 0
+#   undef Tcl_VarTraceInfo
+#   define Tcl_VarTraceInfo 0
+#   undef Tcl_UpVar
+#   define Tcl_UpVar 0
+#   undef Tcl_AddErrorInfo
+#   define Tcl_AddErrorInfo 0
+#   undef Tcl_AddObjErrorInfo
+#   define Tcl_AddObjErrorInfo 0
+#   undef Tcl_Eval
+#   define Tcl_Eval 0
+#   undef Tcl_GlobalEval
+#   define Tcl_GlobalEval 0
+#   undef Tcl_GetStringResult
+#   define Tcl_GetStringResult 0
+#   undef Tcl_SaveResult
+#   define Tcl_SaveResult 0
+#   undef Tcl_RestoreResult
+#   define Tcl_RestoreResult 0
+#   undef Tcl_DiscardResult
+#   define Tcl_DiscardResult 0
+#   undef Tcl_SetResult
+#   define Tcl_SetResult 0
+#   undef Tcl_EvalObj
+#   define Tcl_EvalObj 0
+#   undef Tcl_GlobalEvalObj
+#   define Tcl_GlobalEvalObj 0
+#   define TclBackgroundException 0
+#   undef TclpReaddir
+#   define TclpReaddir 0
+#   define TclSetStartupScript 0
+#   define TclGetStartupScript 0
+#   define TclGetIntForIndex 0
+#   define TclCreateNamespace 0
+#   define TclDeleteNamespace 0
+#   define TclAppendExportList 0
+#   define TclExport 0
+#   define TclImport 0
+#   define TclForgetImport 0
+#   define TclGetCurrentNamespace_ 0
+#   define TclGetGlobalNamespace_ 0
+#   define TclFindNamespace 0
+#   define TclFindCommand 0
+#   define TclGetCommandFromObj 0
+#   define TclGetCommandFullName 0
+#   define TclCopyChannelOld 0
+#   define Tcl_AppendResultVA 0
+#   define Tcl_AppendStringsToObjVA 0
+#   define Tcl_SetErrorCodeVA 0
+#   define Tcl_PanicVA 0
+#   define Tcl_VarEvalVA 0
+#   undef TclpGetDate
+#   define TclpGetDate 0
+#   undef TclpLocaltime
+#   define TclpLocaltime 0
+#   undef TclpGmtime
+#   define TclpGmtime 0
+#   define TclpLocaltime_unix 0
+#   define TclpGmtime_unix 0
+#   define Tcl_SetExitProc 0
+#   define Tcl_SetPanicProc 0
+#   define Tcl_FindExecutable 0
+#   define Tcl_GetUnicode 0
+#   define TclOldFreeObj 0
+#   undef Tcl_StringMatch
+#   define Tcl_StringMatch 0
+#   define TclBN_reverse 0
+#   define TclBN_fast_s_mp_mul_digs 0
+#   define TclBN_fast_s_mp_sqr 0
+#   define TclBN_mp_karatsuba_mul 0
+#   define TclBN_mp_karatsuba_sqr 0
+#   define TclBN_mp_toom_mul 0
+#   define TclBN_mp_toom_sqr 0
+#   define TclBN_s_mp_add 0
+#   define TclBN_s_mp_mul_digs 0
+#   define TclBN_s_mp_sqr 0
+#   define TclBN_s_mp_sub 0
+#else /* TCL_NO_DEPRECATED */
+#   define Tcl_SeekOld seekOld
+#   define Tcl_TellOld tellOld
+#   define TclBackgroundException Tcl_BackgroundException
+#   define TclSetStartupScript Tcl_SetStartupScript
+#   define TclGetStartupScript Tcl_GetStartupScript
+#   define TclGetIntForIndex Tcl_GetIntForIndex
+#   define TclCreateNamespace Tcl_CreateNamespace
+#   define TclDeleteNamespace Tcl_DeleteNamespace
+#   define TclAppendExportList Tcl_AppendExportList
+#   define TclExport Tcl_Export
+#   define TclImport Tcl_Import
+#   define TclForgetImport Tcl_ForgetImport
+#   define TclGetCurrentNamespace_ Tcl_GetCurrentNamespace
+#   define TclGetGlobalNamespace_ Tcl_GetGlobalNamespace
+#   define TclFindNamespace Tcl_FindNamespace
+#   define TclFindCommand Tcl_FindCommand
+#   define TclGetCommandFromObj Tcl_GetCommandFromObj
+#   define TclGetCommandFullName Tcl_GetCommandFullName
+#   define TclpLocaltime_unix TclpLocaltime
+#   define TclpGmtime_unix TclpGmtime
+#   define TclOldFreeObj TclFreeObj
+
+static int
+seekOld(
+    Tcl_Channel chan,		/* The channel on which to seek. */
+    int offset,			/* Offset to seek to. */
+    int mode)			/* Relative to which location to seek? */
+{
+    return Tcl_Seek(chan, offset, mode);
+}
+
+static int
+tellOld(
+    Tcl_Channel chan)		/* The channel to return pos for. */
+{
+    return Tcl_Tell(chan);
+}
+#endif /* !TCL_NO_DEPRECATED */
+
 /*
  * WARNING: The contents of this file is automatically generated by the
  * tools/genStubs.tcl script. Any modifications to the function declarations
  * below should be made in the generic/tcl.decls script.
  */
@@ -206,11 +508,11 @@
     TclAllocateFreeObjects, /* 3 */
     0, /* 4 */
     TclCleanupChildren, /* 5 */
     TclCleanupCommand, /* 6 */
     TclCopyAndCollapse, /* 7 */
-    0, /* 8 */
+    TclCopyChannelOld, /* 8 */
     TclCreatePipeline, /* 9 */
     TclCreateProc, /* 10 */
     TclDeleteCompiledLocalVars, /* 11 */
     TclDeleteVars, /* 12 */
     0, /* 13 */
@@ -232,11 +534,11 @@
     0, /* 29 */
     0, /* 30 */
     TclGetExtension, /* 31 */
     TclGetFrame, /* 32 */
     0, /* 33 */
-    0, /* 34 */
+    TclGetIntForIndex, /* 34 */
     0, /* 35 */
     0, /* 36 */
     TclGetLoadedPackages, /* 37 */
     TclGetNamespaceForQualName, /* 38 */
     TclGetObjInterpProc, /* 39 */
@@ -275,11 +577,11 @@
     0, /* 72 */
     0, /* 73 */
     TclpFree, /* 74 */
     TclpGetClicks, /* 75 */
     TclpGetSeconds, /* 76 */
-    0, /* 77 */
+    TclpGetTime, /* 77 */
     0, /* 78 */
     0, /* 79 */
     0, /* 80 */
     TclpRealloc, /* 81 */
     0, /* 82 */
@@ -286,11 +588,11 @@
     0, /* 83 */
     0, /* 84 */
     0, /* 85 */
     0, /* 86 */
     0, /* 87 */
-    0, /* 88 */
+    TclPrecTraceProc, /* 88 */
     TclPreventAliasLoop, /* 89 */
     0, /* 90 */
     TclProcCleanupProc, /* 91 */
     TclProcCompileProc, /* 92 */
     TclProcDeleteProc, /* 93 */
@@ -302,40 +604,40 @@
     0, /* 99 */
     0, /* 100 */
     TclSetPreInitScript, /* 101 */
     TclSetupEnv, /* 102 */
     TclSockGetPort, /* 103 */
-    0, /* 104 */
+    TclSockMinimumBuffersOld, /* 104 */
     0, /* 105 */
     0, /* 106 */
     0, /* 107 */
     TclTeardownNamespace, /* 108 */
     TclUpdateReturnInfo, /* 109 */
     TclSockMinimumBuffers, /* 110 */
     Tcl_AddInterpResolvers, /* 111 */
-    0, /* 112 */
-    0, /* 113 */
-    0, /* 114 */
-    0, /* 115 */
-    0, /* 116 */
-    0, /* 117 */
+    TclAppendExportList, /* 112 */
+    TclCreateNamespace, /* 113 */
+    TclDeleteNamespace, /* 114 */
+    TclExport, /* 115 */
+    TclFindCommand, /* 116 */
+    TclFindNamespace, /* 117 */
     Tcl_GetInterpResolvers, /* 118 */
     Tcl_GetNamespaceResolvers, /* 119 */
     Tcl_FindNamespaceVar, /* 120 */
-    0, /* 121 */
-    0, /* 122 */
-    0, /* 123 */
-    0, /* 124 */
-    0, /* 125 */
+    TclForgetImport, /* 121 */
+    TclGetCommandFromObj, /* 122 */
+    TclGetCommandFullName, /* 123 */
+    TclGetCurrentNamespace_, /* 124 */
+    TclGetGlobalNamespace_, /* 125 */
     Tcl_GetVariableFullName, /* 126 */
-    0, /* 127 */
+    TclImport, /* 127 */
     Tcl_PopCallFrame, /* 128 */
     Tcl_PushCallFrame, /* 129 */
     Tcl_RemoveInterpResolvers, /* 130 */
     Tcl_SetNamespaceResolvers, /* 131 */
     TclpHasSockets, /* 132 */
-    0, /* 133 */
+    TclpGetDate, /* 133 */
     0, /* 134 */
     0, /* 135 */
     0, /* 136 */
     0, /* 137 */
     TclGetEnv, /* 138 */
@@ -356,36 +658,36 @@
     TclGetLibraryPath, /* 153 */
     0, /* 154 */
     0, /* 155 */
     TclRegError, /* 156 */
     TclVarTraceExists, /* 157 */
-    0, /* 158 */
-    0, /* 159 */
+    TclSetStartupScriptFileName, /* 158 */
+    TclGetStartupScriptFileName, /* 159 */
     0, /* 160 */
     TclChannelTransform, /* 161 */
     TclChannelEventScriptInvoker, /* 162 */
     TclGetInstructionTable, /* 163 */
     TclExpandCodeArray, /* 164 */
     TclpSetInitialEncodings, /* 165 */
     TclListObjSetElement, /* 166 */
-    0, /* 167 */
-    0, /* 168 */
+    TclSetStartupScriptPath, /* 167 */
+    TclGetStartupScriptPath, /* 168 */
     TclpUtfNcmp2, /* 169 */
     TclCheckInterpTraces, /* 170 */
     TclCheckExecutionTraces, /* 171 */
     TclInThreadExit, /* 172 */
     TclUniCharMatch, /* 173 */
     0, /* 174 */
     TclCallVarTraces, /* 175 */
     TclCleanupVar, /* 176 */
     TclVarErrMsg, /* 177 */
-    0, /* 178 */
-    0, /* 179 */
+    TclSetStartupScript, /* 178 */
+    TclGetStartupScript, /* 179 */
     0, /* 180 */
     0, /* 181 */
-    0, /* 182 */
-    0, /* 183 */
+    TclpLocaltime, /* 182 */
+    TclpGmtime, /* 183 */
     0, /* 184 */
     0, /* 185 */
     0, /* 186 */
     0, /* 187 */
     0, /* 188 */
@@ -434,11 +736,11 @@
     TclGetNamespaceFromObj, /* 231 */
     TclEvalObjEx, /* 232 */
     TclGetSrcInfoForPc, /* 233 */
     TclVarHashCreateVar, /* 234 */
     TclInitVarHashTable, /* 235 */
-    0, /* 236 */
+    TclBackgroundException, /* 236 */
     TclResetCancellation, /* 237 */
     TclNRInterpProc, /* 238 */
     TclNRInterpProcCore, /* 239 */
     TclNRRunCallbacks, /* 240 */
     TclNREvalObjEx, /* 241 */
@@ -473,14 +775,14 @@
     0, /* 5 */
     TclpMakeFile, /* 6 */
     TclpOpenFile, /* 7 */
     TclUnixWaitForFile, /* 8 */
     TclpCreateTempFile, /* 9 */
-    0, /* 10 */
-    0, /* 11 */
-    0, /* 12 */
-    0, /* 13 */
+    TclpReaddir, /* 10 */
+    TclpLocaltime_unix, /* 11 */
+    TclpGmtime_unix, /* 12 */
+    TclpInetNtoa, /* 13 */
     TclUnixCopyFile, /* 14 */
     0, /* 15 */
     0, /* 16 */
     0, /* 17 */
     0, /* 18 */
@@ -497,20 +799,20 @@
     TclWinCPUID, /* 29 */
     TclUnixOpenTemporaryFile, /* 30 */
 #endif /* UNIX */
 #if defined(_WIN32) || defined(__CYGWIN__) /* WIN */
     TclWinConvertError, /* 0 */
-    0, /* 1 */
-    0, /* 2 */
-    0, /* 3 */
+    TclWinConvertWSAError, /* 1 */
+    TclWinGetServByName, /* 2 */
+    TclWinGetSockOpt, /* 3 */
     TclWinGetTclInstance, /* 4 */
     TclUnixWaitForFile, /* 5 */
-    0, /* 6 */
-    0, /* 7 */
+    TclWinNToHS, /* 6 */
+    TclWinSetSockOpt, /* 7 */
     TclpGetPid, /* 8 */
-    0, /* 9 */
-    0, /* 10 */
+    TclWinGetPlatformId, /* 9 */
+    TclpReaddir, /* 10 */
     TclGetAndDetachPids, /* 11 */
     TclpCloseFile, /* 12 */
     TclpCreateCommandChannel, /* 13 */
     TclpCreatePipe, /* 14 */
     TclpCreateProcess, /* 15 */
@@ -517,18 +819,18 @@
     TclpIsAtty, /* 16 */
     TclUnixCopyFile, /* 17 */
     TclpMakeFile, /* 18 */
     TclpOpenFile, /* 19 */
     TclWinAddProcess, /* 20 */
-    0, /* 21 */
+    TclpInetNtoa, /* 21 */
     TclpCreateTempFile, /* 22 */
     0, /* 23 */
     TclWinNoBackslash, /* 24 */
     0, /* 25 */
-    0, /* 26 */
+    TclWinSetInterfaces, /* 26 */
     TclWinFlushDirtyChannels, /* 27 */
-    0, /* 28 */
+    TclWinResetInterfaces, /* 28 */
     TclWinCPUID, /* 29 */
     TclUnixOpenTemporaryFile, /* 30 */
 #endif /* WIN */
 #ifdef MAC_OSX_TCL /* MACOSX */
     TclGetAndDetachPids, /* 0 */
@@ -539,14 +841,14 @@
     0, /* 5 */
     TclpMakeFile, /* 6 */
     TclpOpenFile, /* 7 */
     TclUnixWaitForFile, /* 8 */
     TclpCreateTempFile, /* 9 */
-    0, /* 10 */
-    0, /* 11 */
-    0, /* 12 */
-    0, /* 13 */
+    TclpReaddir, /* 10 */
+    TclpLocaltime_unix, /* 11 */
+    TclpGmtime_unix, /* 12 */
+    TclpInetNtoa, /* 13 */
     TclUnixCopyFile, /* 14 */
     TclMacOSXGetFileAttribute, /* 15 */
     TclMacOSXSetFileAttribute, /* 16 */
     TclMacOSXCopyFileAttributes, /* 17 */
     TclMacOSXMatchType, /* 18 */
@@ -629,36 +931,36 @@
     TclBN_mp_to_unsigned_bin_n, /* 45 */
     TclBN_mp_toradix_n, /* 46 */
     TclBN_mp_unsigned_bin_size, /* 47 */
     TclBN_mp_xor, /* 48 */
     TclBN_mp_zero, /* 49 */
-    0, /* 50 */
-    0, /* 51 */
-    0, /* 52 */
-    0, /* 53 */
-    0, /* 54 */
-    0, /* 55 */
-    0, /* 56 */
-    0, /* 57 */
-    0, /* 58 */
-    0, /* 59 */
-    0, /* 60 */
+    TclBN_reverse, /* 50 */
+    TclBN_fast_s_mp_mul_digs, /* 51 */
+    TclBN_fast_s_mp_sqr, /* 52 */
+    TclBN_mp_karatsuba_mul, /* 53 */
+    TclBN_mp_karatsuba_sqr, /* 54 */
+    TclBN_mp_toom_mul, /* 55 */
+    TclBN_mp_toom_sqr, /* 56 */
+    TclBN_s_mp_add, /* 57 */
+    TclBN_s_mp_mul_digs, /* 58 */
+    TclBN_s_mp_sqr, /* 59 */
+    TclBN_s_mp_sub, /* 60 */
     TclBN_mp_init_set_int, /* 61 */
     TclBN_mp_set_int, /* 62 */
     TclBN_mp_cnt_lsb, /* 63 */
-    0, /* 64 */
-    0, /* 65 */
-    0, /* 66 */
+    TclBNInitBignumFromLong, /* 64 */
+    TclBNInitBignumFromWideInt, /* 65 */
+    TclBNInitBignumFromWideUInt, /* 66 */
     TclBN_mp_expt_d_ex, /* 67 */
     TclBN_mp_set_long_long, /* 68 */
     TclBN_mp_get_long_long, /* 69 */
     TclBN_mp_set_long, /* 70 */
     TclBN_mp_get_long, /* 71 */
     TclBN_mp_get_int, /* 72 */
-    0, /* 73 */
-    0, /* 74 */
-    0, /* 75 */
+    TclBN_mp_tc_and, /* 73 */
+    TclBN_mp_tc_or, /* 74 */
+    TclBN_mp_tc_xor, /* 75 */
     TclBN_mp_signed_rsh, /* 76 */
     TclBN_mp_get_bit, /* 77 */
 };
 
 static const TclStubHooks tclStubHooks = {
@@ -706,25 +1008,25 @@
     Tcl_ConcatObj, /* 17 */
     Tcl_ConvertToType, /* 18 */
     Tcl_DbDecrRefCount, /* 19 */
     Tcl_DbIncrRefCount, /* 20 */
     Tcl_DbIsShared, /* 21 */
-    0, /* 22 */
+    Tcl_DbNewBooleanObj, /* 22 */
     Tcl_DbNewByteArrayObj, /* 23 */
     Tcl_DbNewDoubleObj, /* 24 */
     Tcl_DbNewListObj, /* 25 */
-    0, /* 26 */
+    Tcl_DbNewLongObj, /* 26 */
     Tcl_DbNewObj, /* 27 */
     Tcl_DbNewStringObj, /* 28 */
     Tcl_DuplicateObj, /* 29 */
-    0, /* 30 */
+    TclOldFreeObj, /* 30 */
     Tcl_GetBoolean, /* 31 */
     Tcl_GetBooleanFromObj, /* 32 */
     Tcl_GetByteArrayFromObj, /* 33 */
     Tcl_GetDouble, /* 34 */
     Tcl_GetDoubleFromObj, /* 35 */
-    0, /* 36 */
+    Tcl_GetIndexFromObj, /* 36 */
     Tcl_GetInt, /* 37 */
     Tcl_GetIntFromObj, /* 38 */
     Tcl_GetLongFromObj, /* 39 */
     Tcl_GetObjType, /* 40 */
     Tcl_GetStringFromObj, /* 41 */
@@ -733,39 +1035,39 @@
     Tcl_ListObjAppendElement, /* 44 */
     Tcl_ListObjGetElements, /* 45 */
     Tcl_ListObjIndex, /* 46 */
     Tcl_ListObjLength, /* 47 */
     Tcl_ListObjReplace, /* 48 */
-    0, /* 49 */
+    Tcl_NewBooleanObj, /* 49 */
     Tcl_NewByteArrayObj, /* 50 */
     Tcl_NewDoubleObj, /* 51 */
-    0, /* 52 */
+    Tcl_NewIntObj, /* 52 */
     Tcl_NewListObj, /* 53 */
-    0, /* 54 */
+    Tcl_NewLongObj, /* 54 */
     Tcl_NewObj, /* 55 */
     Tcl_NewStringObj, /* 56 */
-    0, /* 57 */
+    Tcl_SetBooleanObj, /* 57 */
     Tcl_SetByteArrayLength, /* 58 */
     Tcl_SetByteArrayObj, /* 59 */
     Tcl_SetDoubleObj, /* 60 */
-    0, /* 61 */
+    Tcl_SetIntObj, /* 61 */
     Tcl_SetListObj, /* 62 */
-    0, /* 63 */
+    Tcl_SetLongObj, /* 63 */
     Tcl_SetObjLength, /* 64 */
     Tcl_SetStringObj, /* 65 */
-    0, /* 66 */
-    0, /* 67 */
+    Tcl_AddErrorInfo, /* 66 */
+    Tcl_AddObjErrorInfo, /* 67 */
     Tcl_AllowExceptions, /* 68 */
     Tcl_AppendElement, /* 69 */
     Tcl_AppendResult, /* 70 */
     Tcl_AsyncCreate, /* 71 */
     Tcl_AsyncDelete, /* 72 */
     Tcl_AsyncInvoke, /* 73 */
     Tcl_AsyncMark, /* 74 */
     Tcl_AsyncReady, /* 75 */
-    0, /* 76 */
-    0, /* 77 */
+    Tcl_BackgroundError, /* 76 */
+    Tcl_Backslash, /* 77 */
     Tcl_BadChannelOption, /* 78 */
     Tcl_CallWhenDeleted, /* 79 */
     Tcl_CancelIdleCall, /* 80 */
     Tcl_Close, /* 81 */
     Tcl_CommandComplete, /* 82 */
@@ -779,11 +1081,11 @@
     Tcl_CreateCloseHandler, /* 90 */
     Tcl_CreateCommand, /* 91 */
     Tcl_CreateEventSource, /* 92 */
     Tcl_CreateExitHandler, /* 93 */
     Tcl_CreateInterp, /* 94 */
-    0, /* 95 */
+    Tcl_CreateMathFunc, /* 95 */
     Tcl_CreateObjCommand, /* 96 */
     Tcl_CreateSlave, /* 97 */
     Tcl_CreateTimerHandler, /* 98 */
     Tcl_CreateTrace, /* 99 */
     Tcl_DeleteAssocData, /* 100 */
@@ -813,13 +1115,13 @@
     Tcl_DStringSetLength, /* 124 */
     Tcl_DStringStartSublist, /* 125 */
     Tcl_Eof, /* 126 */
     Tcl_ErrnoId, /* 127 */
     Tcl_ErrnoMsg, /* 128 */
-    0, /* 129 */
+    Tcl_Eval, /* 129 */
     Tcl_EvalFile, /* 130 */
-    0, /* 131 */
+    Tcl_EvalObj, /* 131 */
     Tcl_EventuallyFree, /* 132 */
     Tcl_Exit, /* 133 */
     Tcl_ExposeCommand, /* 134 */
     Tcl_ExprBoolean, /* 135 */
     Tcl_ExprBooleanObj, /* 136 */
@@ -828,11 +1130,11 @@
     Tcl_ExprLong, /* 139 */
     Tcl_ExprLongObj, /* 140 */
     Tcl_ExprObj, /* 141 */
     Tcl_ExprString, /* 142 */
     Tcl_Finalize, /* 143 */
-    0, /* 144 */
+    Tcl_FindExecutable, /* 144 */
     Tcl_FirstHashEntry, /* 145 */
     Tcl_Flush, /* 146 */
     Tcl_FreeResult, /* 147 */
     Tcl_GetAlias, /* 148 */
     Tcl_GetAliasObj, /* 149 */
@@ -866,15 +1168,15 @@
     Tcl_Gets, /* 169 */
     Tcl_GetsObj, /* 170 */
     Tcl_GetServiceMode, /* 171 */
     Tcl_GetSlave, /* 172 */
     Tcl_GetStdChannel, /* 173 */
-    0, /* 174 */
-    0, /* 175 */
+    Tcl_GetStringResult, /* 174 */
+    Tcl_GetVar, /* 175 */
     Tcl_GetVar2, /* 176 */
-    0, /* 177 */
-    0, /* 178 */
+    Tcl_GlobalEval, /* 177 */
+    Tcl_GlobalEvalObj, /* 178 */
     Tcl_HideCommand, /* 179 */
     Tcl_Init, /* 180 */
     Tcl_InitHashTable, /* 181 */
     Tcl_InputBlocked, /* 182 */
     Tcl_InputBuffered, /* 183 */
@@ -912,69 +1214,69 @@
     Tcl_RegExpRange, /* 215 */
     Tcl_Release, /* 216 */
     Tcl_ResetResult, /* 217 */
     Tcl_ScanElement, /* 218 */
     Tcl_ScanCountedElement, /* 219 */
-    0, /* 220 */
+    Tcl_SeekOld, /* 220 */
     Tcl_ServiceAll, /* 221 */
     Tcl_ServiceEvent, /* 222 */
     Tcl_SetAssocData, /* 223 */
     Tcl_SetChannelBufferSize, /* 224 */
     Tcl_SetChannelOption, /* 225 */
     Tcl_SetCommandInfo, /* 226 */
     Tcl_SetErrno, /* 227 */
     Tcl_SetErrorCode, /* 228 */
     Tcl_SetMaxBlockTime, /* 229 */
-    0, /* 230 */
+    Tcl_SetPanicProc, /* 230 */
     Tcl_SetRecursionLimit, /* 231 */
-    0, /* 232 */
+    Tcl_SetResult, /* 232 */
     Tcl_SetServiceMode, /* 233 */
     Tcl_SetObjErrorCode, /* 234 */
     Tcl_SetObjResult, /* 235 */
     Tcl_SetStdChannel, /* 236 */
-    0, /* 237 */
+    Tcl_SetVar, /* 237 */
     Tcl_SetVar2, /* 238 */
     Tcl_SignalId, /* 239 */
     Tcl_SignalMsg, /* 240 */
     Tcl_SourceRCFile, /* 241 */
     Tcl_SplitList, /* 242 */
     Tcl_SplitPath, /* 243 */
-    0, /* 244 */
-    0, /* 245 */
-    0, /* 246 */
-    0, /* 247 */
+    Tcl_StaticPackage, /* 244 */
+    Tcl_StringMatch, /* 245 */
+    Tcl_TellOld, /* 246 */
+    Tcl_TraceVar, /* 247 */
     Tcl_TraceVar2, /* 248 */
     Tcl_TranslateFileName, /* 249 */
     Tcl_Ungets, /* 250 */
     Tcl_UnlinkVar, /* 251 */
     Tcl_UnregisterChannel, /* 252 */
-    0, /* 253 */
+    Tcl_UnsetVar, /* 253 */
     Tcl_UnsetVar2, /* 254 */
-    0, /* 255 */
+    Tcl_UntraceVar, /* 255 */
     Tcl_UntraceVar2, /* 256 */
     Tcl_UpdateLinkedVar, /* 257 */
-    0, /* 258 */
+    Tcl_UpVar, /* 258 */
     Tcl_UpVar2, /* 259 */
     Tcl_VarEval, /* 260 */
-    0, /* 261 */
+    Tcl_VarTraceInfo, /* 261 */
     Tcl_VarTraceInfo2, /* 262 */
     Tcl_Write, /* 263 */
     Tcl_WrongNumArgs, /* 264 */
     Tcl_DumpActiveMemory, /* 265 */
     Tcl_ValidateAllMemory, /* 266 */
-    0, /* 267 */
-    0, /* 268 */
+    Tcl_AppendResultVA, /* 267 */
+    Tcl_AppendStringsToObjVA, /* 268 */
     Tcl_HashStats, /* 269 */
     Tcl_ParseVar, /* 270 */
-    0, /* 271 */
+    Tcl_PkgPresent, /* 271 */
     Tcl_PkgPresentEx, /* 272 */
-    0, /* 273 */
-    0, /* 274 */
-    0, /* 275 */
-    0, /* 276 */
+    Tcl_PkgProvide, /* 273 */
+    Tcl_PkgRequire, /* 274 */
+    Tcl_SetErrorCodeVA, /* 275 */
+    Tcl_VarEvalVA, /* 276 */
     Tcl_WaitPid, /* 277 */
-    0, /* 278 */
+    Tcl_PanicVA, /* 278 */
     Tcl_GetVersion, /* 279 */
     Tcl_InitMemory, /* 280 */
     Tcl_StackChannel, /* 281 */
     Tcl_UnstackChannel, /* 282 */
     Tcl_GetStackedChannel, /* 283 */
@@ -982,11 +1284,11 @@
     0, /* 285 */
     Tcl_AppendObjToObj, /* 286 */
     Tcl_CreateEncoding, /* 287 */
     Tcl_CreateThreadExitHandler, /* 288 */
     Tcl_DeleteThreadExitHandler, /* 289 */
-    0, /* 290 */
+    Tcl_DiscardResult, /* 290 */
     Tcl_EvalEx, /* 291 */
     Tcl_EvalObjv, /* 292 */
     Tcl_EvalObjEx, /* 293 */
     Tcl_ExitThread, /* 294 */
     Tcl_ExternalToUtf, /* 295 */
@@ -1006,12 +1308,12 @@
     Tcl_MutexUnlock, /* 309 */
     Tcl_ConditionNotify, /* 310 */
     Tcl_ConditionWait, /* 311 */
     Tcl_NumUtfChars, /* 312 */
     Tcl_ReadChars, /* 313 */
-    0, /* 314 */
-    0, /* 315 */
+    Tcl_RestoreResult, /* 314 */
+    Tcl_SaveResult, /* 315 */
     Tcl_SetSystemEncoding, /* 316 */
     Tcl_SetVar2Ex, /* 317 */
     Tcl_ThreadAlert, /* 318 */
     Tcl_ThreadQueueEvent, /* 319 */
     Tcl_UniCharAtIndex, /* 320 */
@@ -1033,12 +1335,12 @@
     Tcl_UtfToUniChar, /* 336 */
     Tcl_UtfToUpper, /* 337 */
     Tcl_WriteChars, /* 338 */
     Tcl_WriteObj, /* 339 */
     Tcl_GetString, /* 340 */
-    0, /* 341 */
-    0, /* 342 */
+    Tcl_GetDefaultEncodingDir, /* 341 */
+    Tcl_SetDefaultEncodingDir, /* 342 */
     Tcl_AlertNotifier, /* 343 */
     Tcl_ServiceModeHook, /* 344 */
     Tcl_UniCharIsAlnum, /* 345 */
     Tcl_UniCharIsAlpha, /* 346 */
     Tcl_UniCharIsDigit, /* 347 */
@@ -1049,11 +1351,11 @@
     Tcl_UniCharLen, /* 352 */
     Tcl_UniCharNcmp, /* 353 */
     Tcl_UniCharToUtfDString, /* 354 */
     Tcl_UtfToUniCharDString, /* 355 */
     Tcl_GetRegExpFromObj, /* 356 */
-    0, /* 357 */
+    Tcl_EvalTokens, /* 357 */
     Tcl_FreeParse, /* 358 */
     Tcl_LogCommandInfo, /* 359 */
     Tcl_ParseBraces, /* 360 */
     Tcl_ParseCommand, /* 361 */
     Tcl_ParseExpr, /* 362 */
@@ -1074,11 +1376,11 @@
     Tcl_RegExpGetInfo, /* 377 */
     Tcl_NewUnicodeObj, /* 378 */
     Tcl_SetUnicodeObj, /* 379 */
     Tcl_GetCharLength, /* 380 */
     Tcl_GetUniChar, /* 381 */
-    0, /* 382 */
+    Tcl_GetUnicode, /* 382 */
     Tcl_GetRange, /* 383 */
     Tcl_AppendUnicodeToObj, /* 384 */
     Tcl_RegExpMatchObj, /* 385 */
     Tcl_SetNotifier, /* 386 */
     Tcl_GetAllocMutex, /* 387 */
@@ -1113,12 +1415,12 @@
     Tcl_SpliceChannel, /* 416 */
     Tcl_ClearChannelHandlers, /* 417 */
     Tcl_IsChannelExisting, /* 418 */
     Tcl_UniCharNcasecmp, /* 419 */
     Tcl_UniCharCaseMatch, /* 420 */
-    0, /* 421 */
-    0, /* 422 */
+    Tcl_FindHashEntry, /* 421 */
+    Tcl_CreateHashEntry, /* 422 */
     Tcl_InitCustomHashTable, /* 423 */
     Tcl_InitObjHashTable, /* 424 */
     Tcl_CommandTraceInfo, /* 425 */
     Tcl_TraceCommand, /* 426 */
     Tcl_UntraceCommand, /* 427 */
@@ -1127,12 +1429,12 @@
     Tcl_AttemptRealloc, /* 430 */
     Tcl_AttemptDbCkrealloc, /* 431 */
     Tcl_AttemptSetObjLength, /* 432 */
     Tcl_GetChannelThread, /* 433 */
     Tcl_GetUnicodeFromObj, /* 434 */
-    0, /* 435 */
-    0, /* 436 */
+    Tcl_GetMathFuncInfo, /* 435 */
+    Tcl_ListMathFuncs, /* 436 */
     Tcl_SubstObj, /* 437 */
     Tcl_DetachChannel, /* 438 */
     Tcl_IsStandardChannel, /* 439 */
     Tcl_FSCopyFile, /* 440 */
     Tcl_FSCopyDirectory, /* 441 */
@@ -1211,11 +1513,11 @@
     Tcl_FindNamespace, /* 514 */
     Tcl_FindCommand, /* 515 */
     Tcl_GetCommandFromObj, /* 516 */
     Tcl_GetCommandFullName, /* 517 */
     Tcl_FSEvalFileEx, /* 518 */
-    0, /* 519 */
+    Tcl_SetExitProc, /* 519 */
     Tcl_LimitAddHandler, /* 520 */
     Tcl_LimitRemoveHandler, /* 521 */
     Tcl_LimitReady, /* 522 */
     Tcl_LimitCheck, /* 523 */
     Tcl_LimitExceeded, /* 524 */

Index: generic/tclStubLib.c
==================================================================
--- generic/tclStubLib.c
+++ generic/tclStubLib.c
@@ -64,12 +64,12 @@
      * prevents apps from being able to load/unload Tcl dynamically multiple
      * times. [Bug 615304]
      */
 
     if (!stubsPtr || (stubsPtr->magic != (((exact&0xff00) >= 0x900) ? magic : TCL_STUB_MAGIC))) {
-	iPtr->legacyResult = "interpreter uses an incompatible stubs mechanism";
-	iPtr->legacyFreeProc = 0; /* TCL_STATIC */
+	iPtr->result = (char *)"interpreter uses an incompatible stubs mechanism";
+	iPtr->freeProc = 0;
 	return NULL;
     }
 
     actualVersion = stubsPtr->tcl_PkgRequireEx(interp, "Tcl", version, 0, &pkgData);
     if (actualVersion == NULL) {

Index: generic/tclTest.c
==================================================================
--- generic/tclTest.c
+++ generic/tclTest.c
@@ -26,15 +26,10 @@
 /*
  * Required for Testregexp*Cmd
  */
 #include "tclRegexp.h"
 
-/*
- * Required for TestlocaleCmd
- */
-#include <locale.h>
-
 /*
  * Required for the TestChannelCmd and TestChannelEventCmd
  */
 #include "tclIO.h"
 
@@ -219,14 +214,17 @@
 			    Tcl_Interp *interp, int level, const char *command,
 			    Tcl_Command commandToken, int objc,
 			    Tcl_Obj *const objv[]);
 static void		ObjTraceDeleteProc(void *clientData);
 static void		PrintParse(Tcl_Interp *interp, Tcl_Parse *parsePtr);
-static void		SpecialFree(void *blockPtr);
+static void		SpecialFree(char *blockPtr);
 static int		StaticInitProc(Tcl_Interp *interp);
 static int		TestasyncCmd(void *dummy,
 			    Tcl_Interp *interp, int argc, const char **argv);
+static int		TestbumpinterpepochObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
 static int		TestbytestringObjCmd(void *clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 static int		TestpurebytesobjObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
@@ -343,15 +341,15 @@
 			    Tcl_Obj *const objv[]);
 static int		TestreturnObjCmd(void *dummy,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 static void		TestregexpXflags(const char *string,
-			    size_t length, int *cflagsPtr, int *eflagsPtr);
+			    int length, int *cflagsPtr, int *eflagsPtr);
 static int		TestsaveresultCmd(void *dummy,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-static void		TestsaveresultFree(void *blockPtr);
+static void		TestsaveresultFree(char *blockPtr);
 static int		TestsetassocdataCmd(void *dummy,
 			    Tcl_Interp *interp, int argc, const char **argv);
 static int		TestsetCmd(void *dummy,
 			    Tcl_Interp *interp, int argc, const char **argv);
 static int		Testset2Cmd(void *dummy,
@@ -599,10 +597,12 @@
     Tcl_CreateObjCommand(interp, "testsimplefilesystem", TestSimpleFilesystemObjCmd,
 	    NULL, NULL);
     Tcl_CreateObjCommand(interp, "testgetindexfromobjstruct",
 	    TestGetIndexFromObjStructObjCmd, NULL, NULL);
     Tcl_CreateCommand(interp, "testasync", TestasyncCmd, NULL, NULL);
+    Tcl_CreateObjCommand(interp, "testbumpinterpepoch",
+	    TestbumpinterpepochObjCmd, NULL, NULL);
     Tcl_CreateCommand(interp, "testchannel", TestChannelCmd,
 	    NULL, NULL);
     Tcl_CreateCommand(interp, "testchannelevent", TestChannelEventCmd,
 	    NULL, NULL);
     Tcl_CreateCommand(interp, "testcmdtoken", TestcmdtokenCmd, NULL,
@@ -849,12 +849,12 @@
     }
     if (strcmp(argv[1], "create") == 0) {
 	if (argc != 3) {
 	    goto wrongNumArgs;
 	}
-	asyncPtr = Tcl_Alloc(sizeof(TestAsyncHandler));
-	asyncPtr->command = Tcl_Alloc(strlen(argv[2]) + 1);
+	asyncPtr = ckalloc(sizeof(TestAsyncHandler));
+	asyncPtr->command = ckalloc(strlen(argv[2]) + 1);
 	strcpy(asyncPtr->command, argv[2]);
         Tcl_MutexLock(&asyncTestMutex);
 	asyncPtr->id = nextId;
 	nextId++;
 	asyncPtr->handler = Tcl_AsyncCreate(AsyncHandlerProc,
@@ -868,12 +868,12 @@
             Tcl_MutexLock(&asyncTestMutex);
 	    while (firstHandler != NULL) {
 		asyncPtr = firstHandler;
 		firstHandler = asyncPtr->nextPtr;
 		Tcl_AsyncDelete(asyncPtr->handler);
-		Tcl_Free(asyncPtr->command);
-		Tcl_Free(asyncPtr);
+		ckfree(asyncPtr->command);
+		ckfree(asyncPtr);
 	    }
             Tcl_MutexUnlock(&asyncTestMutex);
 	    return TCL_OK;
 	}
 	if (argc != 3) {
@@ -892,12 +892,12 @@
 		firstHandler = asyncPtr->nextPtr;
 	    } else {
 		prevPtr->nextPtr = asyncPtr->nextPtr;
 	    }
 	    Tcl_AsyncDelete(asyncPtr->handler);
-	    Tcl_Free(asyncPtr->command);
-	    Tcl_Free(asyncPtr);
+	    ckfree(asyncPtr->command);
+	    ckfree(asyncPtr);
 	    break;
 	}
         Tcl_MutexUnlock(&asyncTestMutex);
     } else if (strcmp(argv[1], "mark") == 0) {
 	if (argc != 5) {
@@ -964,12 +964,11 @@
 				 * executed, or NULL. */
     int code)			/* Current return code from command. */
 {
     TestAsyncHandler *asyncPtr;
     int id = PTR2INT(clientData);
-    const char *listArgv[4];
-    char *cmd;
+    const char *listArgv[4], *cmd;
     char string[TCL_INTEGER_SPACE];
 
     Tcl_MutexLock(&asyncTestMutex);
     for (asyncPtr = firstHandler; asyncPtr != NULL;
             asyncPtr = asyncPtr->nextPtr) {
@@ -984,11 +983,11 @@
         return TCL_OK;
     }
 
     TclFormatInt(string, code);
     listArgv[0] = asyncPtr->command;
-    listArgv[1] = Tcl_GetStringResult(interp);
+    listArgv[1] = Tcl_GetString(Tcl_GetObjResult(interp));
     listArgv[2] = string;
     listArgv[3] = NULL;
     cmd = Tcl_Merge(3, listArgv);
     if (interp != NULL) {
 	code = Tcl_EvalEx(interp, cmd, -1, 0);
@@ -996,11 +995,11 @@
 	/*
 	 * this should not happen, but by definition of how async handlers are
 	 * invoked, it's possible.  Better error checking is needed here.
 	 */
     }
-    Tcl_Free(cmd);
+    ckfree(cmd);
     return code;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1039,10 +1038,26 @@
     Tcl_MutexUnlock(&asyncTestMutex);
     Tcl_ExitThread(TCL_OK);
     TCL_THREAD_CREATE_RETURN;
 }
 #endif
+
+static int
+TestbumpinterpepochObjCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    Interp *iPtr = (Interp *)interp;
+    if (objc != 1) {
+	Tcl_WrongNumArgs(interp, 1, objv, "");
+	return TCL_ERROR;
+    }
+    iPtr->compileEpoch++;
+    return TCL_OK;
+}
 
 /*
  *----------------------------------------------------------------------
  *
  * TestcmdinfoCmd --
@@ -1624,13 +1639,13 @@
     slave = Tcl_GetSlave(interp, argv[1]);
     if (slave == NULL) {
 	return TCL_ERROR;
     }
 
-    dPtr = Tcl_Alloc(sizeof(DelCmd));
+    dPtr = ckalloc(sizeof(DelCmd));
     dPtr->interp = interp;
-    dPtr->deleteCmd = Tcl_Alloc(strlen(argv[3]) + 1);
+    dPtr->deleteCmd = ckalloc(strlen(argv[3]) + 1);
     strcpy(dPtr->deleteCmd, argv[3]);
 
     Tcl_CreateCommand(slave, argv[2], DelCmdProc, dPtr,
 	    DelDeleteProc);
     return TCL_OK;
@@ -1644,12 +1659,12 @@
     const char **argv)		/* Argument strings. */
 {
     DelCmd *dPtr = (DelCmd *) clientData;
 
     Tcl_AppendResult(interp, dPtr->deleteCmd, NULL);
-    Tcl_Free(dPtr->deleteCmd);
-    Tcl_Free(dPtr);
+    ckfree(dPtr->deleteCmd);
+    ckfree(dPtr);
     return TCL_OK;
 }
 
 static void
 DelDeleteProc(
@@ -1657,12 +1672,12 @@
 {
     DelCmd *dPtr = clientData;
 
     Tcl_EvalEx(dPtr->interp, dPtr->deleteCmd, -1, 0);
     Tcl_ResetResult(dPtr->interp);
-    Tcl_Free(dPtr->deleteCmd);
-    Tcl_Free(dPtr);
+    ckfree(dPtr->deleteCmd);
+    ckfree(dPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1780,11 +1795,11 @@
 	}
 	type |= TCL_DD_SHORTEN_FLAG;
     }
     str = TclDoubleDigits(d, ndigits, type, &decpt, &signum, &endPtr);
     strObj = Tcl_NewStringObj(str, endPtr-str);
-    Tcl_Free(str);
+    ckfree(str);
     retval = Tcl_NewListObj(1, &strObj);
     Tcl_ListObjAppendElement(NULL, retval, Tcl_NewIntObj(decpt));
     strObj = Tcl_NewStringObj(signum ? "-" : "+", 1);
     Tcl_ListObjAppendElement(NULL, retval, strObj);
     Tcl_SetObjResult(interp, retval);
@@ -1858,15 +1873,15 @@
 	if (strcmp(argv[2], "staticsmall") == 0) {
 	    Tcl_AppendResult(interp, "short", NULL);
 	} else if (strcmp(argv[2], "staticlarge") == 0) {
 	    Tcl_AppendResult(interp, "first0 first1 first2 first3 first4 first5 first6 first7 first8 first9\nsecond0 second1 second2 second3 second4 second5 second6 second7 second8 second9\nthird0 third1 third2 third3 third4 third5 third6 third7 third8 third9\nfourth0 fourth1 fourth2 fourth3 fourth4 fourth5 fourth6 fourth7 fourth8 fourth9\nfifth0 fifth1 fifth2 fifth3 fifth4 fifth5 fifth6 fifth7 fifth8 fifth9\nsixth0 sixth1 sixth2 sixth3 sixth4 sixth5 sixth6 sixth7 sixth8 sixth9\nseventh0 seventh1 seventh2 seventh3 seventh4 seventh5 seventh6 seventh7 seventh8 seventh9\n", NULL);
 	} else if (strcmp(argv[2], "free") == 0) {
-	    char *s = Tcl_Alloc(100);
+	    char *s = ckalloc(100);
 	    strcpy(s, "This is a malloc-ed string");
 	    Tcl_SetResult(interp, s, TCL_DYNAMIC);
 	} else if (strcmp(argv[2], "special") == 0) {
-	    char *s = (char*)Tcl_Alloc(100) + 16;
+	    char *s = (char*)ckalloc(100) + 16;
 	    strcpy(s, "This is a specially-allocated string");
 	    Tcl_SetResult(interp, s, SpecialFree);
 	} else {
 	    Tcl_AppendResult(interp, "bad gresult option \"", argv[2],
 		    "\": must be staticsmall, staticlarge, free, or special",
@@ -1911,13 +1926,13 @@
  * The procedure below is used as a special freeProc to test how well
  * Tcl_DStringGetResult handles freeProc's other than free.
  */
 
 static void SpecialFree(blockPtr)
-    void *blockPtr;			/* Block to free. */
+    char *blockPtr;			/* Block to free. */
 {
-    Tcl_Free(((char *)blockPtr) - 16);
+    ckfree(blockPtr - 16);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1964,19 +1979,19 @@
 	Tcl_EncodingType type;
 
 	if (objc != 5) {
 	    return TCL_ERROR;
 	}
-	encodingPtr = Tcl_Alloc(sizeof(TclEncoding));
+	encodingPtr = ckalloc(sizeof(TclEncoding));
 	encodingPtr->interp = interp;
 
 	string = Tcl_GetStringFromObj(objv[3], &length);
-	encodingPtr->toUtfCmd = Tcl_Alloc(length + 1);
+	encodingPtr->toUtfCmd = ckalloc(length + 1);
 	memcpy(encodingPtr->toUtfCmd, string, length + 1);
 
 	string = Tcl_GetStringFromObj(objv[4], &length);
-	encodingPtr->fromUtfCmd = Tcl_Alloc(length + 1);
+	encodingPtr->fromUtfCmd = ckalloc(length + 1);
 	memcpy(encodingPtr->fromUtfCmd, string, length + 1);
 
 	string = Tcl_GetStringFromObj(objv[2], &length);
 
 	type.encodingName = string;
@@ -2072,13 +2087,13 @@
 EncodingFreeProc(
     void *clientData)	/* ClientData associated with type. */
 {
     TclEncoding *encodingPtr = clientData;
 
-    Tcl_Free(encodingPtr->toUtfCmd);
-    Tcl_Free(encodingPtr->fromUtfCmd);
-    Tcl_Free(encodingPtr);
+    ckfree(encodingPtr->toUtfCmd);
+    ckfree(encodingPtr->fromUtfCmd);
+    ckfree(encodingPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -2229,11 +2244,11 @@
 	}
 	if (Tcl_GetIndexFromObj(interp, objv[3], positions,
 		"position specifier", TCL_EXACT, &posIndex) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	ev = Tcl_Alloc(sizeof(TestEvent));
+	ev = ckalloc(sizeof(TestEvent));
 	ev->header.proc = TesteventProc;
 	ev->header.nextPtr = NULL;
 	ev->interp = interp;
 	ev->command = objv[4];
 	Tcl_IncrRefCount(ev->command);
@@ -2403,29 +2418,29 @@
 static void
 ExitProcOdd(
     void *clientData)	/* Integer value to print. */
 {
     char buf[16 + TCL_INTEGER_SPACE];
-    size_t len;
+    int len;
 
-    sprintf(buf, "odd %" TCL_Z_MODIFIER "d\n", (size_t)PTR2INT(clientData));
+    sprintf(buf, "odd %d\n", (int)PTR2INT(clientData));
     len = strlen(buf);
-    if (len != (size_t) write(1, buf, len)) {
+    if (len != (int) write(1, buf, len)) {
 	Tcl_Panic("ExitProcOdd: unable to write to stdout");
     }
 }
 
 static void
 ExitProcEven(
     void *clientData)	/* Integer value to print. */
 {
     char buf[16 + TCL_INTEGER_SPACE];
-    size_t len;
+    int len;
 
-    sprintf(buf, "even %" TCL_Z_MODIFIER "d\n", (size_t)PTR2INT(clientData));
+    sprintf(buf, "even %d\n", (int)PTR2INT(clientData));
     len = strlen(buf);
-    if (len != (size_t) write(1, buf, len)) {
+    if (len != (int) write(1, buf, len)) {
 	Tcl_Panic("ExitProcEven: unable to write to stdout");
     }
 }
 
 /*
@@ -3082,16 +3097,16 @@
 		return TCL_ERROR;
 	    }
 	}
 	if (argv[5][0] != 0) {
 	    if (stringVar != NULL) {
-		Tcl_Free(stringVar);
+		ckfree(stringVar);
 	    }
 	    if (strcmp(argv[5], "-") == 0) {
 		stringVar = NULL;
 	    } else {
-		stringVar = Tcl_Alloc(strlen(argv[5]) + 1);
+		stringVar = ckalloc(strlen(argv[5]) + 1);
 		strcpy(stringVar, argv[5]);
 	    }
 	}
 	if (argv[6][0] != 0) {
 	    tmp = Tcl_NewStringObj(argv[6], -1);
@@ -3189,16 +3204,16 @@
 	    }
 	    Tcl_UpdateLinkedVar(interp, "bool");
 	}
 	if (argv[5][0] != 0) {
 	    if (stringVar != NULL) {
-		Tcl_Free(stringVar);
+		ckfree(stringVar);
 	    }
 	    if (strcmp(argv[5], "-") == 0) {
 		stringVar = NULL;
 	    } else {
-		stringVar = Tcl_Alloc(strlen(argv[5]) + 1);
+		stringVar = ckalloc(strlen(argv[5]) + 1);
 		strcpy(stringVar, argv[5]);
 	    }
 	    Tcl_UpdateLinkedVar(interp, "string");
 	}
 	if (argv[6][0] != 0) {
@@ -3486,11 +3501,11 @@
 static void
 CleanupTestSetassocdataTests(
     void *clientData,	/* Data to be released. */
     Tcl_Interp *interp)		/* Interpreter being deleted. */
 {
-    Tcl_Free(clientData);
+    ckfree(clientData);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -3891,12 +3906,11 @@
     void *dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    int i, indices, stringLength, match, about;
-    size_t ii;
+    int i, ii, indices, stringLength, match, about;
     int hasxflags, cflags, eflags;
     Tcl_RegExp regExpr;
     const char *string;
     Tcl_Obj *objPtr;
     Tcl_RegExpInfo info;
@@ -4005,16 +4019,16 @@
 
 	Tcl_SetIntObj(Tcl_GetObjResult(interp), 0);
 	if (objc > 2 && (cflags&REG_EXPECT) && indices) {
 	    const char *varName;
 	    const char *value;
-	    size_t start, end;
+	    int start, end;
 	    char resinfo[TCL_INTEGER_SPACE * 2];
 
 	    varName = Tcl_GetString(objv[2]);
 	    TclRegExpRangeUniChar(regExpr, -1, &start, &end);
-	    sprintf(resinfo, "%" TCL_LL_MODIFIER "d %" TCL_LL_MODIFIER "d", TclWideIntFromSize(start), TclWideIntFromSize(end-1));
+	    sprintf(resinfo, "%d %d", start, end-1);
 	    value = Tcl_SetVar2(interp, varName, NULL, resinfo, 0);
 	    if (value == NULL) {
 		Tcl_AppendResult(interp, "couldn't set variable \"",
 			varName, "\"", NULL);
 		return TCL_ERROR;
@@ -4024,11 +4038,11 @@
 	    const char *value;
 	    char resinfo[TCL_INTEGER_SPACE * 2];
 
 	    Tcl_RegExpGetInfo(regExpr, &info);
 	    varName = Tcl_GetString(objv[2]);
-	    sprintf(resinfo, "%" TCL_LL_MODIFIER "d", TclWideIntFromSize(info.extendStart));
+	    sprintf(resinfo, "%ld", info.extendStart);
 	    value = Tcl_SetVar2(interp, varName, NULL, resinfo, 0);
 	    if (value == NULL) {
 		Tcl_AppendResult(interp, "couldn't set variable \"",
 			varName, "\"", NULL);
 		return TCL_ERROR;
@@ -4045,23 +4059,23 @@
     objc -= 2;
     objv += 2;
 
     Tcl_RegExpGetInfo(regExpr, &info);
     for (i = 0; i < objc; i++) {
-	size_t start, end;
+	int start, end;
 	Tcl_Obj *newPtr, *varPtr, *valuePtr;
 
 	varPtr = objv[i];
-	ii = ((cflags&REG_EXPECT) && i == objc-1) ? TCL_INDEX_NONE : (size_t)i;
+	ii = ((cflags&REG_EXPECT) && i == objc-1) ? -1 : i;
 	if (indices) {
 	    Tcl_Obj *objs[2];
 
-	    if (ii == TCL_INDEX_NONE) {
+	    if (ii == -1) {
 		TclRegExpRangeUniChar(regExpr, ii, &start, &end);
 	    } else if (ii > info.nsubs) {
-		start = TCL_INDEX_NONE;
-		end = TCL_INDEX_NONE;
+		start = -1;
+		end = -1;
 	    } else {
 		start = info.matches[ii].start;
 		end = info.matches[ii].end;
 	    }
 
@@ -4068,20 +4082,20 @@
 	    /*
 	     * Adjust index so it refers to the last character in the match
 	     * instead of the first character after the match.
 	     */
 
-	    if (end != TCL_INDEX_NONE) {
+	    if (end >= 0) {
 		end--;
 	    }
 
-	    objs[0] = TclNewWideIntObjFromSize(start);
-	    objs[1] = TclNewWideIntObjFromSize(end);
+	    objs[0] = Tcl_NewWideIntObj(start);
+	    objs[1] = Tcl_NewWideIntObj(end);
 
 	    newPtr = Tcl_NewListObj(2, objs);
 	} else {
-	    if (ii == TCL_INDEX_NONE) {
+	    if (ii == -1) {
 		TclRegExpRangeUniChar(regExpr, ii, &start, &end);
 		newPtr = Tcl_GetRange(objPtr, start, end);
 	    } else if (ii > info.nsubs) {
 		newPtr = Tcl_NewObj();
 	    } else {
@@ -4121,16 +4135,15 @@
  */
 
 static void
 TestregexpXflags(
     const char *string,	/* The string of flags. */
-    size_t length,			/* The length of the string in bytes. */
+    int length,			/* The length of the string in bytes. */
     int *cflagsPtr,		/* compile flags word */
     int *eflagsPtr)		/* exec flags word */
 {
-    size_t i;
-    int cflags, eflags;
+    int i, cflags, eflags;
 
     cflags = *cflagsPtr;
     eflags = *eflagsPtr;
     for (i = 0; i < length; i++) {
 	switch (string[i]) {
@@ -4254,21 +4267,21 @@
 	Tcl_AppendResult(interp, "wrong # arguments: should be \"", argv[0],
 		" data_key data_item\"", NULL);
 	return TCL_ERROR;
     }
 
-    buf = Tcl_Alloc(strlen(argv[2]) + 1);
+    buf = ckalloc(strlen(argv[2]) + 1);
     strcpy(buf, argv[2]);
 
     /*
      * If we previously associated a malloced value with the variable,
      * free it before associating a new value.
      */
 
     oldData = (char *) Tcl_GetAssocData(interp, argv[1], &procPtr);
     if ((oldData != NULL) && (procPtr == CleanupTestSetassocdataTests)) {
-	Tcl_Free(oldData);
+	ckfree(oldData);
     }
 
     Tcl_SetAssocData(interp, argv[1], CleanupTestSetassocdataTests,	buf);
     return TCL_OK;
 }
@@ -4654,11 +4667,11 @@
      *  Append all of the arguments together separated by spaces
      */
 
     argString = Tcl_Merge(argc-1, argv+1);
     Tcl_Panic("%s", argString);
-    Tcl_Free(argString);
+    ckfree(argString);
 
     return TCL_OK;
 }
 
 static int
@@ -4834,33 +4847,33 @@
 
     /* alloc & free 100000 times */
     fprintf(stderr, "alloc & free 100000 6 word items\n");
     Tcl_GetTime(&start);
     for (i = 0;  i < 100000;  i++) {
-	objPtr = Tcl_Alloc(sizeof(Tcl_Obj));
-	Tcl_Free(objPtr);
+	objPtr = ckalloc(sizeof(Tcl_Obj));
+	ckfree(objPtr);
     }
     Tcl_GetTime(&stop);
     timePer = (stop.sec - start.sec)*1000000 + (stop.usec - start.usec);
     fprintf(stderr, "   %.3f usec per alloc+free\n", timePer/100000);
 
     /* alloc 5000 times */
     fprintf(stderr, "alloc 5000 6 word items\n");
-    objv = Tcl_Alloc(5000 * sizeof(Tcl_Obj *));
+    objv = ckalloc(5000 * sizeof(Tcl_Obj *));
     Tcl_GetTime(&start);
     for (i = 0;  i < 5000;  i++) {
-	objv[i] = Tcl_Alloc(sizeof(Tcl_Obj));
+	objv[i] = ckalloc(sizeof(Tcl_Obj));
     }
     Tcl_GetTime(&stop);
     timePer = (stop.sec - start.sec)*1000000 + (stop.usec - start.usec);
     fprintf(stderr, "   %.3f usec per alloc\n", timePer/5000);
 
     /* free 5000 times */
     fprintf(stderr, "free 5000 6 word items\n");
     Tcl_GetTime(&start);
     for (i = 0;  i < 5000;  i++) {
-	Tcl_Free(objv[i]);
+	ckfree(objv[i]);
     }
     Tcl_GetTime(&stop);
     timePer = (stop.sec - start.sec)*1000000 + (stop.usec - start.usec);
     fprintf(stderr, "   %.3f usec per free\n", timePer/5000);
 
@@ -4882,11 +4895,11 @@
 	Tcl_DecrRefCount(objPtr);
     }
     Tcl_GetTime(&stop);
     timePer = (stop.sec - start.sec)*1000000 + (stop.usec - start.usec);
     fprintf(stderr, "   %.3f usec per Tcl_DecrRefCount\n", timePer/5000);
-    Tcl_Free(objv);
+    ckfree(objv);
 
     /* TclGetString 100000 times */
     fprintf(stderr, "TclGetStringFromObj of \"12345\" 100000 times\n");
     objPtr = Tcl_NewStringObj("12345", -1);
     Tcl_GetTime(&start);
@@ -5108,11 +5121,11 @@
     */
     memset(&objPtr->internalRep, 0, sizeof(objPtr->internalRep));
     if (objc == 2) {
 	const char *s = Tcl_GetString(objv[1]);
 	objPtr->length = objv[1]->length;
-	objPtr->bytes = Tcl_Alloc(objPtr->length + 1);
+	objPtr->bytes = ckalloc(objPtr->length + 1);
 	memcpy(objPtr->bytes, s, objPtr->length);
 	objPtr->bytes[objPtr->length] = 0;
     }
     Tcl_SetObjResult(interp, objPtr);
     return TCL_OK;
@@ -5177,11 +5190,11 @@
 
 	/* ARGSUSED */
 static int
 TestsetCmd(
     void *data,		/* Additional flags for Get/SetVar2. */
-    register Tcl_Interp *interp,/* Current interpreter. */
+    Tcl_Interp *interp,/* Current interpreter. */
     int argc,			/* Number of arguments. */
     const char **argv)		/* Argument strings. */
 {
     int flags = PTR2INT(data);
     const char *value;
@@ -5209,11 +5222,11 @@
     }
 }
 static int
 Testset2Cmd(
     void *data,		/* Additional flags for Get/SetVar2. */
-    register Tcl_Interp *interp,/* Current interpreter. */
+    Tcl_Interp *interp,/* Current interpreter. */
     int argc,			/* Number of arguments. */
     const char **argv)		/* Argument strings. */
 {
     int flags = PTR2INT(data);
     const char *value;
@@ -5260,14 +5273,15 @@
 
 	/* ARGSUSED */
 static int
 TestsaveresultCmd(
     void *dummy,		/* Not used. */
-    register Tcl_Interp *interp,/* Current interpreter. */
+    Tcl_Interp *interp,/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* The argument objects. */
 {
+    Interp* iPtr = (Interp*) interp;
     int discard, result, index;
     Tcl_SavedResult state;
     Tcl_Obj *objPtr;
     static const char *const optionStrings[] = {
 	"append", "dynamic", "free", "object", "small", NULL
@@ -5300,11 +5314,11 @@
 	break;
     case RESULT_APPEND:
 	Tcl_AppendResult(interp, "append result", NULL);
 	break;
     case RESULT_FREE: {
-	char *buf = Tcl_Alloc(200);
+	char *buf = ckalloc(200);
 
 	strcpy(buf, "free result");
 	Tcl_SetResult(interp, buf, TCL_DYNAMIC);
 	break;
     }
@@ -5331,13 +5345,16 @@
 	Tcl_RestoreResult(interp, &state);
 	result = TCL_OK;
     }
 
     switch ((enum options) index) {
-    case RESULT_DYNAMIC:
-	Tcl_AppendElement(interp, freeCount ? "freed" : "leak");
+    case RESULT_DYNAMIC: {
+	int presentOrFreed = (iPtr->freeProc == TestsaveresultFree) ^ freeCount;
+
+	Tcl_AppendElement(interp, presentOrFreed ? "presentOrFreed" : "missingOrLeak");
 	break;
+    }
     case RESULT_OBJECT:
 	Tcl_AppendElement(interp, Tcl_GetObjResult(interp) == objPtr
 		? "same" : "different");
 	break;
     default:
@@ -5362,11 +5379,11 @@
  *----------------------------------------------------------------------
  */
 
 static void
 TestsaveresultFree(
-    void *blockPtr)
+    char *blockPtr)
 {
     freeCount++;
 }
 
 /*
@@ -5387,11 +5404,11 @@
  */
 
 static int
 TestmainthreadCmd(
     void *dummy,		/* Not used. */
-    register Tcl_Interp *interp,/* Current interpreter. */
+    Tcl_Interp *interp,/* Current interpreter. */
     int argc,			/* Number of arguments. */
     const char **argv)		/* Argument strings. */
 {
     if (argc == 1) {
 	Tcl_Obj *idObj = Tcl_NewWideIntObj((Tcl_WideInt)(size_t)Tcl_GetCurrentThread());
@@ -5448,11 +5465,11 @@
  */
 
 static int
 TestsetmainloopCmd(
     void *dummy,		/* Not used. */
-    register Tcl_Interp *interp,/* Current interpreter. */
+    Tcl_Interp *interp,/* Current interpreter. */
     int argc,			/* Number of arguments. */
     const char **argv)		/* Argument strings. */
 {
   exitMainLoop = 0;
   Tcl_SetMainLoop(MainLoop);
@@ -5477,11 +5494,11 @@
  */
 
 static int
 TestexitmainloopCmd(
     void *dummy,		/* Not used. */
-    register Tcl_Interp *interp,/* Current interpreter. */
+    Tcl_Interp *interp,/* Current interpreter. */
     int argc,			/* Number of arguments. */
     const char **argv)		/* Argument strings. */
 {
   exitMainLoop = 1;
   return TCL_OK;
@@ -5549,11 +5566,11 @@
 
 		if (strcmp(argv[2], Tcl_GetChannelName(curPtr->chan)) == 0) {
 		    *nextPtrPtr = curPtr->nextPtr;
 		    curPtr->nextPtr = NULL;
 		    chan = curPtr->chan;
-		    Tcl_Free(curPtr);
+		    ckfree(curPtr);
 		    break;
 		}
 	    }
 	} else {
 	    chan = Tcl_GetChannel(interp, argv[2], &mode);
@@ -5619,11 +5636,11 @@
 
 	Tcl_CutChannel(chan);
 
 	/* Remember the channel in the pool of detached channels */
 
-	det = Tcl_Alloc(sizeof(TestChannel));
+	det = ckalloc(sizeof(TestChannel));
 	det->chan     = chan;
 	det->nextPtr  = firstDetached;
 	firstDetached = det;
 
 	return TCL_OK;
@@ -6017,11 +6034,11 @@
 	    Tcl_AppendResult(interp, "bad event name \"", argv[3],
 		    "\": must be readable, writable, or none", NULL);
 	    return TCL_ERROR;
 	}
 
-	esPtr = Tcl_Alloc(sizeof(EventScriptRecord));
+	esPtr = ckalloc(sizeof(EventScriptRecord));
 	esPtr->nextPtr = statePtr->scriptRecordPtr;
 	statePtr->scriptRecordPtr = esPtr;
 
 	esPtr->chanPtr = chanPtr;
 	esPtr->interp = interp;
@@ -6074,11 +6091,11 @@
 	    prevEsPtr->nextPtr = esPtr->nextPtr;
 	}
 	Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
 		TclChannelEventScriptInvoker, esPtr);
 	Tcl_DecrRefCount(esPtr->scriptPtr);
-	Tcl_Free(esPtr);
+	ckfree(esPtr);
 
 	return TCL_OK;
     }
 
     if ((cmd[0] == 'l') && (strncmp(cmd, "list", len) == 0)) {
@@ -6115,11 +6132,11 @@
 	     esPtr = nextEsPtr) {
 	    nextEsPtr = esPtr->nextPtr;
 	    Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr,
 		    TclChannelEventScriptInvoker, esPtr);
 	    Tcl_DecrRefCount(esPtr->scriptPtr);
-	    Tcl_Free(esPtr);
+	    ckfree(esPtr);
 	}
 	statePtr->scriptRecordPtr = NULL;
 	return TCL_OK;
     }
 
@@ -7059,11 +7076,11 @@
 	    return TCL_ERROR;
 	}
 	Tcl_SetHashValue(hPtr, INT2PTR(i+42));
     }
 
-    if (hash.numEntries != (size_t)limit) {
+    if (hash.numEntries != limit) {
 	Tcl_AppendResult(interp, "unexpected maximal size", NULL);
 	Tcl_DeleteHashTable(&hash);
 	return TCL_ERROR;
     }
 
@@ -7135,11 +7152,11 @@
 {
     if (argc != 1) {
 	Tcl_AppendResult(interp, "wrong # args", NULL);
 	return TCL_ERROR;
     }
-    Tcl_SetObjResult(interp, Tcl_NewIntObj(sizeof(long)));
+    Tcl_SetObjResult(interp, Tcl_NewIntObj((int)sizeof(long)));
     return TCL_OK;
 }
 
 static int
 NREUnwind_callback(
@@ -7158,13 +7175,13 @@
     } else if (data[2] == INT2PTR(-1)) {
         Tcl_NRAddCallback(interp, NREUnwind_callback, data[0], data[1],
                 &none, NULL);
     } else {
         Tcl_Obj *idata[3];
-        idata[0] = Tcl_NewIntObj(((char *) data[1] - (char *) data[0]));
-        idata[1] = Tcl_NewIntObj(((char *) data[2] - (char *) data[0]));
-        idata[2] = Tcl_NewIntObj(((char *) &none   - (char *) data[0]));
+        idata[0] = Tcl_NewIntObj((int) ((char *) data[1] - (char *) data[0]));
+        idata[1] = Tcl_NewIntObj((int) ((char *) data[2] - (char *) data[0]));
+        idata[2] = Tcl_NewIntObj((int) ((char *) &none   - (char *) data[0]));
         Tcl_SetObjResult(interp, Tcl_NewListObj(3, idata));
     }
     return TCL_OK;
 }
 
@@ -7560,11 +7577,11 @@
     }
     result[0] = Tcl_NewIntObj(foo);
     result[1] = Tcl_NewIntObj(count);
     result[2] = Tcl_NewListObj(count, remObjv);
     Tcl_SetObjResult(interp, Tcl_NewListObj(3, result));
-    Tcl_Free(remObjv);
+    ckfree(remObjv);
     return TCL_OK;
 }
 
 /**
  * Test harness for command and variable resolvers.
@@ -7687,11 +7704,11 @@
 static inline void
 HashVarFree(
     Tcl_Var var)
 {
     if (VarHashRefCount(var) < 2) {
-        Tcl_Free(var);
+        ckfree(var);
     } else {
         VarHashRefCount(var)--;
     }
 }
 
@@ -7703,11 +7720,11 @@
 
     Tcl_DecrRefCount(resVarInfo->nameObj);
     if (resVarInfo->var) {
         HashVarFree(resVarInfo->var);
     }
-    Tcl_Free(vInfoPtr);
+    ckfree(vInfoPtr);
 }
 
 #define TclVarHashGetValue(hPtr) \
     ((Var *) ((char *)hPtr - offsetof(VarInHash, entry)))
 
@@ -7746,11 +7763,11 @@
         var = NULL;
     }
     resVarInfo->var = var;
 
     /*
-     * Increment the reference counter to avoid Tcl_Free() of the variable in
+     * Increment the reference counter to avoid ckfree() of the variable in
      * Tcl's FreeVarEntry(); for cleanup, we provide our own HashVarFree();
      */
 
     VarHashRefCount(var)++;
     return var;
@@ -7763,11 +7780,11 @@
     int length,
     Tcl_Namespace *context,
     Tcl_ResolvedVarInfo **rPtr)
 {
     if (*name == 'T') {
- 	MyResolvedVarInfo *resVarInfo = Tcl_Alloc(sizeof(MyResolvedVarInfo));
+ 	MyResolvedVarInfo *resVarInfo = ckalloc(sizeof(MyResolvedVarInfo));
 
  	resVarInfo->vInfo.fetchProc = MyCompiledVarFetch;
  	resVarInfo->vInfo.deleteProc = MyCompiledVarFree;
  	resVarInfo->var = NULL;
  	resVarInfo->nameObj = Tcl_NewStringObj(name, -1);

Index: generic/tclTestObj.c
==================================================================
--- generic/tclTestObj.c
+++ generic/tclTestObj.c
@@ -51,17 +51,17 @@
 #define VARPTR_KEY "TCLOBJTEST_VARPTR"
 #define NUMBER_OF_OBJECT_VARS 20
 
 static void VarPtrDeleteProc(ClientData clientData, Tcl_Interp *interp)
 {
-    register int i;
+    int i;
     Tcl_Obj **varPtr = (Tcl_Obj **) clientData;
     for (i = 0;  i < NUMBER_OF_OBJECT_VARS;  i++) {
 	if (varPtr[i]) Tcl_DecrRefCount(varPtr[i]);
     }
     Tcl_DeleteAssocData(interp, VARPTR_KEY);
-    Tcl_Free(varPtr);
+    ckfree(varPtr);
 }
 
 static Tcl_Obj **GetVarPtr(Tcl_Interp *interp)
 {
     Tcl_InterpDeleteProc *proc;
@@ -89,19 +89,19 @@
 
 int
 TclObjTest_Init(
     Tcl_Interp *interp)
 {
-    register int i;
+    int i;
     /*
      * An array of Tcl_Obj pointers used in the commands that operate on or get
      * the values of Tcl object-valued variables. varPtr[i] is the i-th variable's
      * Tcl_Obj *.
      */
     Tcl_Obj **varPtr;
 
-    varPtr = (Tcl_Obj **) Tcl_Alloc(NUMBER_OF_OBJECT_VARS *sizeof(varPtr[0]));
+    varPtr = (Tcl_Obj **) ckalloc(NUMBER_OF_OBJECT_VARS *sizeof(varPtr[0]));
     if (!varPtr) {
 	return TCL_ERROR;
     }
     Tcl_SetAssocData(interp, VARPTR_KEY, VarPtrDeleteProc, varPtr);
     for (i = 0;  i < NUMBER_OF_OBJECT_VARS;  i++) {
@@ -574,12 +574,12 @@
     /*
      * Keep this structure declaration in sync with tclIndexObj.c
      */
     struct IndexRep {
 	void *tablePtr;		/* Pointer to the table of strings. */
-	size_t offset;		/* Offset between table entries. */
-	size_t index;		/* Selected index into table. */
+	int offset;		/* Offset between table entries. */
+	int index;		/* Selected index into table. */
     };
     struct IndexRep *indexRep;
 
     if ((objc == 3) && (strcmp(Tcl_GetString(objv[1]),
 	    "check") == 0)) {
@@ -614,20 +614,20 @@
     }
     if (Tcl_GetBooleanFromObj(interp, objv[2], &allowAbbrev) != TCL_OK) {
 	return TCL_ERROR;
     }
 
-    argv = Tcl_Alloc((objc-3) * sizeof(char *));
+    argv = ckalloc((objc-3) * sizeof(char *));
     for (i = 4; i < objc; i++) {
 	argv[i-4] = Tcl_GetString(objv[i]);
     }
     argv[objc-4] = NULL;
 
     result = Tcl_GetIndexFromObj((setError? interp : NULL), objv[3],
 	    argv, "token", INDEX_TEMP_TABLE|(allowAbbrev? 0 : TCL_EXACT),
 	    &index);
-    Tcl_Free((void *)argv);
+    ckfree(argv);
     if (result == TCL_OK) {
 	Tcl_SetIntObj(Tcl_GetObjResult(interp), index);
     }
     return result;
 }
@@ -1176,12 +1176,12 @@
     const char *index, *string, *strings[MAX_STRINGS+1];
     String *strPtr;
     Tcl_Obj **varPtr;
     static const char *const options[] = {
 	"append", "appendstrings", "get", "get2", "length", "length2",
-	"set", "set2", "setlength", "maxchars", "getunicode",
-	"appendself", "appendself2", NULL
+	"set", "set2", "setlength", "maxchars", "appendself",
+	"appendself2", NULL
     };
 
     if (objc < 3) {
 	wrongNumArgs:
 	Tcl_WrongNumArgs(interp, 1, objv, "option arg ?arg ...?");
@@ -1271,12 +1271,12 @@
 	    break;
 	case 4:				/* length */
 	    if (objc != 3) {
 		goto wrongNumArgs;
 	    }
-	    Tcl_SetWideIntObj(Tcl_GetObjResult(interp), (varPtr[varIndex] != NULL)
-		    ? (Tcl_WideInt)varPtr[varIndex]->length : (Tcl_WideInt)-1);
+	    Tcl_SetIntObj(Tcl_GetObjResult(interp), (varPtr[varIndex] != NULL)
+		    ? varPtr[varIndex]->length : -1);
 	    break;
 	case 5:				/* length2 */
 	    if (objc != 3) {
 		goto wrongNumArgs;
 	    }
@@ -1342,17 +1342,11 @@
 	    } else {
 		length = -1;
 	    }
 	    Tcl_SetIntObj(Tcl_GetObjResult(interp), length);
 	    break;
-	case 10:			/* getunicode */
-	    if (objc != 3) {
-		goto wrongNumArgs;
-	    }
-	    Tcl_GetUnicode(varPtr[varIndex]);
-	    break;
-	case 11:			/* appendself */
+	case 10:			/* appendself */
 	    if (objc != 4) {
 		goto wrongNumArgs;
 	    }
 	    if (varPtr[varIndex] == NULL) {
 		SetVarToObj(varPtr, varIndex, Tcl_NewObj());
@@ -1379,11 +1373,11 @@
 	    }
 
 	    Tcl_AppendToObj(varPtr[varIndex], string + i, length - i);
 	    Tcl_SetObjResult(interp, varPtr[varIndex]);
 	    break;
-	case 12:			/* appendself2 */
+	case 11:			/* appendself2 */
 	    if (objc != 4) {
 		goto wrongNumArgs;
 	    }
 	    if (varPtr[varIndex] == NULL) {
 		SetVarToObj(varPtr, varIndex, Tcl_NewObj());

Index: generic/tclTestProcBodyObj.c
==================================================================
--- generic/tclTestProcBodyObj.c
+++ generic/tclTestProcBodyObj.c
@@ -33,11 +33,11 @@
 /*
  * this struct describes an entry in the table of command names and command
  * procs
  */
 
-typedef struct {
+typedef struct CmdTable {
     const char *cmdName;		/* command name */
     Tcl_ObjCmdProc *proc;	/* command proc */
     int exportIt;		/* if 1, export the command */
 } CmdTable;
 
@@ -49,11 +49,11 @@
 			Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
 static int	ProcBodyTestCheckObjCmd(ClientData dummy,
 			Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
 static int	ProcBodyTestInitInternal(Tcl_Interp *interp, int isSafe);
 static int	RegisterCommand(Tcl_Interp* interp,
-			const char *namespace, const CmdTable *cmdTablePtr);
+			const char *namesp, const CmdTable *cmdTablePtr);
 
 /*
  * List of commands to create when the package is loaded; must go after the
  * declarations of the enable command procedure.
  */
@@ -137,25 +137,25 @@
 
 static int
 RegisterCommand(
     Tcl_Interp* interp,		/* the Tcl interpreter for which the operation
 				 * is performed */
-    const char *namespace,		/* the namespace in which the command is
+    const char *namesp,		/* the namespace in which the command is
 				 * registered */
     const CmdTable *cmdTablePtr)/* the command to register */
 {
     char buf[128];
 
     if (cmdTablePtr->exportIt) {
 	sprintf(buf, "namespace eval %s { namespace export %s }",
-		namespace, cmdTablePtr->cmdName);
+		namesp, cmdTablePtr->cmdName);
 	if (Tcl_EvalEx(interp, buf, -1, 0) != TCL_OK) {
 	    return TCL_ERROR;
 	}
     }
 
-    sprintf(buf, "%s::%s", namespace, cmdTablePtr->cmdName);
+    sprintf(buf, "%s::%s", namesp, cmdTablePtr->cmdName);
     Tcl_CreateObjCommand(interp, buf, cmdTablePtr->proc, 0, 0);
     return TCL_OK;
 }
 
 /*
@@ -188,11 +188,11 @@
 	if (RegisterCommand(interp, packageName, cmdTablePtr) != TCL_OK) {
 	    return TCL_ERROR;
 	}
     }
 
-    return Tcl_PkgProvideEx(interp, packageName, packageVersion, NULL);
+    return Tcl_PkgProvide(interp, packageName, packageVersion);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -337,11 +337,11 @@
     if (objc != 1) {
 	Tcl_WrongNumArgs(interp, 1, objv, "");
 	return TCL_ERROR;
     }
 
-    version = Tcl_PkgPresentEx(interp, packageName, packageVersion, 1, NULL);
+    version = Tcl_PkgPresent(interp, packageName, packageVersion, 1);
     Tcl_SetObjResult(interp, Tcl_NewWideIntObj(
 	    strcmp(version, packageVersion) == 0));
     return TCL_OK;
 }
 

Index: generic/tclThread.c
==================================================================
--- generic/tclThread.c
+++ generic/tclThread.c
@@ -59,11 +59,11 @@
  */
 
 void *
 Tcl_GetThreadData(
     Tcl_ThreadDataKey *keyPtr,	/* Identifier for the data chunk */
-    size_t size)		/* Size of storage block */
+    int size)			/* Size of storage block */
 {
     void *result;
 #if TCL_THREADS
     /*
      * Initialize the key for this thread.
@@ -70,17 +70,17 @@
      */
 
     result = TclThreadStorageKeyGet(keyPtr);
 
     if (result == NULL) {
-	result = Tcl_Alloc(size);
+	result = ckalloc(size);
 	memset(result, 0, size);
 	TclThreadStorageKeySet(keyPtr, result);
     }
 #else /* TCL_THREADS */
     if (*keyPtr == NULL) {
-	result = Tcl_Alloc(size);
+	result = ckalloc(size);
 	memset(result, 0, size);
 	*keyPtr = result;
 	RememberSyncObject(keyPtr, &keyRecord);
     } else {
 	result = *keyPtr;
@@ -162,18 +162,18 @@
      * pointers to the new list.
      */
 
     if (recPtr->num >= recPtr->max) {
 	recPtr->max += 8;
-	newList = Tcl_Alloc(recPtr->max * sizeof(void *));
+	newList = ckalloc(recPtr->max * sizeof(void *));
 	for (i=0,j=0 ; i<recPtr->num ; i++) {
 	    if (recPtr->list[i] != NULL) {
 		newList[j++] = recPtr->list[i];
 	    }
 	}
 	if (recPtr->list != NULL) {
-	    Tcl_Free(recPtr->list);
+	    ckfree(recPtr->list);
 	}
 	recPtr->list = newList;
 	recPtr->num = j;
     }
 
@@ -390,13 +390,13 @@
 
     if (keyRecord.list != NULL) {
 	for (i=0 ; i<keyRecord.num ; i++) {
 	    keyPtr = (Tcl_ThreadDataKey *) keyRecord.list[i];
 	    blockPtr = *keyPtr;
-	    Tcl_Free(blockPtr);
+	    ckfree(blockPtr);
 	}
-	Tcl_Free(keyRecord.list);
+	ckfree(keyRecord.list);
 	keyRecord.list = NULL;
     }
     keyRecord.max = 0;
     keyRecord.num = 0;
 
@@ -412,11 +412,11 @@
 	if (mutexPtr != NULL) {
 	    TclpFinalizeMutex(mutexPtr);
 	}
     }
     if (mutexRecord.list != NULL) {
-	Tcl_Free(mutexRecord.list);
+	ckfree(mutexRecord.list);
 	mutexRecord.list = NULL;
     }
     mutexRecord.max = 0;
     mutexRecord.num = 0;
 
@@ -425,11 +425,11 @@
 	if (condPtr != NULL) {
 	    TclpFinalizeCondition(condPtr);
 	}
     }
     if (condRecord.list != NULL) {
-	Tcl_Free(condRecord.list);
+	ckfree(condRecord.list);
 	condRecord.list = NULL;
     }
     condRecord.max = 0;
     condRecord.num = 0;
 

Index: generic/tclThreadAlloc.c
==================================================================
--- generic/tclThreadAlloc.c
+++ generic/tclThreadAlloc.c
@@ -80,22 +80,22 @@
 /*
  * The following structure defines a bucket of blocks with various accounting
  * and statistics information.
  */
 
-typedef struct {
+typedef struct Bucket {
     Block *firstPtr;		/* First block available */
     Block *lastPtr;		/* End of block list */
-    size_t numFree;		/* Number of blocks available */
+    long numFree;		/* Number of blocks available */
 
     /* All fields below for accounting only */
 
-    size_t numRemoves;		/* Number of removes from bucket */
-    size_t numInserts;		/* Number of inserts into bucket */
-    size_t numWaits;		/* Number of waits to acquire a lock */
-    size_t numLocks;		/* Number of locks acquired */
-    size_t totalAssigned;	/* Total space assigned to bucket */
+    long numRemoves;		/* Number of removes from bucket */
+    long numInserts;		/* Number of inserts into bucket */
+    long numWaits;		/* Number of waits to acquire a lock */
+    long numLocks;		/* Number of locks acquired */
+    long totalAssigned;		/* Total space assigned to bucket */
 } Bucket;
 
 /*
  * The following structure defines a cache of buckets and objs, of which there
  * will be (at most) one per thread. Any changes need to be reflected in the
@@ -118,12 +118,12 @@
  * values are statically initialized to avoid calculating them repeatedly.
  */
 
 static struct {
     size_t blockSize;		/* Bucket blocksize. */
-    size_t maxBlocks;		/* Max blocks before move to share. */
-    size_t numMove;			/* Num blocks to move to share. */
+    int maxBlocks;		/* Max blocks before move to share. */
+    int numMove;		/* Num blocks to move to share. */
     Tcl_Mutex *lockPtr;		/* Share bucket lock. */
 } bucketInfo[NBUCKETS];
 
 /*
  * Static functions defined in this file.
@@ -209,11 +209,11 @@
      * Get this thread's cache, allocating if necessary.
      */
 
     cachePtr = TclpGetAllocCache();
     if (cachePtr == NULL) {
-	cachePtr = TclpSysAlloc(sizeof(Cache));
+	cachePtr = TclpSysAlloc(sizeof(Cache), 0);
 	if (cachePtr == NULL) {
 	    Tcl_Panic("alloc: could not allocate new cache");
 	}
         memset(cachePtr, 0, sizeof(Cache));
 	Tcl_MutexLock(listLockPtr);
@@ -246,11 +246,11 @@
 TclFreeAllocCache(
     void *arg)
 {
     Cache *cachePtr = arg;
     Cache **nextPtrPtr;
-    register unsigned int bucket;
+    unsigned int bucket;
 
     /*
      * Flush blocks.
      */
 
@@ -297,18 +297,31 @@
  *	May allocate more blocks for a bucket.
  *
  *----------------------------------------------------------------------
  */
 
-void *
+char *
 TclpAlloc(
-    size_t reqSize)
+    unsigned int reqSize)
 {
     Cache *cachePtr;
     Block *blockPtr;
-    register int bucket;
+    int bucket;
     size_t size;
+
+#ifndef __LP64__
+    if (sizeof(int) >= sizeof(size_t)) {
+	/* An unsigned int overflow can also be a size_t overflow */
+	const size_t zero = 0;
+	const size_t max = ~zero;
+
+	if (((size_t) reqSize) > max - sizeof(Block) - RCHECK) {
+	    /* Requested allocation exceeds memory */
+	    return NULL;
+	}
+    }
+#endif
 
     GETCACHE(cachePtr);
 
     /*
      * Increment the requested size to include room for the Block structure.
@@ -322,11 +335,11 @@
 #if RCHECK
     size++;
 #endif
     if (size > MAXALLOC) {
 	bucket = NBUCKETS;
-	blockPtr = TclpSysAlloc(size);
+	blockPtr = TclpSysAlloc(size, 0);
 	if (blockPtr != NULL) {
 	    cachePtr->totalAssigned += reqSize;
 	}
     } else {
 	bucket = 0;
@@ -363,11 +376,11 @@
  *----------------------------------------------------------------------
  */
 
 void
 TclpFree(
-    void *ptr)
+    char *ptr)
 {
     Cache *cachePtr;
     Block *blockPtr;
     int bucket;
 
@@ -420,14 +433,14 @@
  *	Previous memory, if any, may be freed.
  *
  *----------------------------------------------------------------------
  */
 
-void *
+char *
 TclpRealloc(
-    void *ptr,
-    size_t reqSize)
+    char *ptr,
+    unsigned int reqSize)
 {
     Cache *cachePtr;
     Block *blockPtr;
     void *newPtr;
     size_t size, min;
@@ -434,10 +447,23 @@
     int bucket;
 
     if (ptr == NULL) {
 	return TclpAlloc(reqSize);
     }
+
+#ifndef __LP64__
+    if (sizeof(int) >= sizeof(size_t)) {
+	/* An unsigned int overflow can also be a size_t overflow */
+	const size_t zero = 0;
+	const size_t max = ~zero;
+
+	if (((size_t) reqSize) > max - sizeof(Block) - RCHECK) {
+	    /* Requested allocation exceeds memory */
+	    return NULL;
+	}
+    }
+#endif
 
     GETCACHE(cachePtr);
 
     /*
      * If the block is not a system block and fits in place, simply return the
@@ -509,22 +535,22 @@
  */
 
 Tcl_Obj *
 TclThreadAllocObj(void)
 {
-    register Cache *cachePtr;
-    register Tcl_Obj *objPtr;
+    Cache *cachePtr;
+    Tcl_Obj *objPtr;
 
     GETCACHE(cachePtr);
 
     /*
      * Get this thread's obj list structure and move or allocate new objs if
      * necessary.
      */
 
     if (cachePtr->numObjects == 0) {
-	register int numMove;
+	int numMove;
 
 	Tcl_MutexLock(objLockPtr);
 	numMove = sharedPtr->numObjects;
 	if (numMove > 0) {
 	    if (numMove > NOBJALLOC) {
@@ -535,11 +561,11 @@
 	Tcl_MutexUnlock(objLockPtr);
 	if (cachePtr->numObjects == 0) {
 	    Tcl_Obj *newObjsPtr;
 
 	    cachePtr->numObjects = numMove = NOBJALLOC;
-	    newObjsPtr = TclpSysAlloc(sizeof(Tcl_Obj) * numMove);
+	    newObjsPtr = TclpSysAlloc(sizeof(Tcl_Obj) * numMove, 0);
 	    if (newObjsPtr == NULL) {
 		Tcl_Panic("alloc: could not allocate %d new objects", numMove);
 	    }
 	    cachePtr->lastPtr = newObjsPtr + numMove - 1;
 	    objPtr = cachePtr->firstObjPtr;	/* NULL */
@@ -643,12 +669,12 @@
 	} else {
 	    sprintf(buf, "thread%p", cachePtr->owner);
 	    Tcl_DStringAppendElement(dsPtr, buf);
 	}
 	for (n = 0; n < NBUCKETS; ++n) {
-	    sprintf(buf, "%" TCL_Z_MODIFIER "u %" TCL_Z_MODIFIER "u %" TCL_Z_MODIFIER "u %" TCL_Z_MODIFIER "u %" TCL_Z_MODIFIER "u %" TCL_Z_MODIFIER "u %" TCL_Z_MODIFIER "u",
-		    bucketInfo[n].blockSize,
+	    sprintf(buf, "%lu %ld %ld %ld %ld %ld %ld",
+		    (unsigned long) bucketInfo[n].blockSize,
 		    cachePtr->buckets[n].numFree,
 		    cachePtr->buckets[n].numRemoves,
 		    cachePtr->buckets[n].numInserts,
 		    cachePtr->buckets[n].totalAssigned,
 		    cachePtr->buckets[n].numLocks,
@@ -681,11 +707,11 @@
 MoveObjs(
     Cache *fromPtr,
     Cache *toPtr,
     int numMove)
 {
-    register Tcl_Obj *objPtr = fromPtr->firstObjPtr;
+    Tcl_Obj *objPtr = fromPtr->firstObjPtr;
     Tcl_Obj *fromFirstObjPtr = objPtr;
 
     toPtr->numObjects += numMove;
     fromPtr->numObjects -= numMove;
 
@@ -782,11 +808,11 @@
 Block2Ptr(
     Block *blockPtr,
     int bucket,
     unsigned int reqSize)
 {
-    register void *ptr;
+    void *ptr;
 
     blockPtr->magicNum1 = blockPtr->magicNum2 = MAGIC;
     blockPtr->sourceBucket = bucket;
     blockPtr->blockReqSize = reqSize;
     ptr = ((void *) (blockPtr + 1));
@@ -798,11 +824,11 @@
 
 static Block *
 Ptr2Block(
     char *ptr)
 {
-    register Block *blockPtr;
+    Block *blockPtr;
 
     blockPtr = (((Block *) ptr) - 1);
     if (blockPtr->magicNum1 != MAGIC || blockPtr->magicNum2 != MAGIC) {
 	Tcl_Panic("alloc: invalid block: %p: %x %x",
 		blockPtr, blockPtr->magicNum1, blockPtr->magicNum2);
@@ -932,12 +958,12 @@
 static int
 GetBlocks(
     Cache *cachePtr,
     int bucket)
 {
-    register Block *blockPtr;
-    register size_t n;
+    Block *blockPtr;
+    int n;
 
     /*
      * First, atttempt to move blocks from the shared cache. Note the
      * potentially dirty read of numFree before acquiring the lock which is a
      * slight performance enhancement. The value is verified after the lock is
@@ -978,21 +1004,21 @@
 	}
 	UnlockBucket(cachePtr, bucket);
     }
 
     if (cachePtr->buckets[bucket].numFree == 0) {
-	register size_t size;
+	size_t size;
 
 	/*
 	 * If no blocks could be moved from shared, first look for a larger
 	 * block in this cache to split up.
 	 */
 
 	blockPtr = NULL;
 	n = NBUCKETS;
 	size = 0; /* lint */
-	while (--n > (size_t)bucket) {
+	while (--n > bucket) {
 	    if (cachePtr->buckets[n].numFree > 0) {
 		size = bucketInfo[n].blockSize;
 		blockPtr = cachePtr->buckets[n].firstPtr;
 		cachePtr->buckets[n].firstPtr = blockPtr->nextBlock;
 		cachePtr->buckets[n].numFree--;
@@ -1004,11 +1030,11 @@
 	 * Otherwise, allocate a big new block directly.
 	 */
 
 	if (blockPtr == NULL) {
 	    size = MAXALLOC;
-	    blockPtr = TclpSysAlloc(size);
+	    blockPtr = TclpSysAlloc(size, 0);
 	    if (blockPtr == NULL) {
 		return 0;
 	    }
 	}
 
@@ -1034,11 +1060,11 @@
  *----------------------------------------------------------------------
  *
  * TclInitThreadAlloc --
  *
  *	Initializes the allocator cache-maintenance structures.
- *      It is done early and protected during the TclInitSubsystems().
+ *      It is done early and protected during the Tcl_InitSubsystems().
  *
  * Results:
  *	None.
  *
  * Side effects:
@@ -1054,11 +1080,11 @@
 
     listLockPtr = TclpNewAllocMutex();
     objLockPtr = TclpNewAllocMutex();
     for (i = 0; i < NBUCKETS; ++i) {
 	bucketInfo[i].blockSize = MINALLOC << i;
-	bucketInfo[i].maxBlocks = ((size_t)1) << (NBUCKETS - 1 - i);
+	bucketInfo[i].maxBlocks = 1 << (NBUCKETS - 1 - i);
 	bucketInfo[i].numMove = i < NBUCKETS - 1 ?
 		1 << (NBUCKETS - 2 - i) : 1;
 	bucketInfo[i].lockPtr = TclpNewAllocMutex();
     }
     TclpInitAllocCache();

Index: generic/tclThreadJoin.c
==================================================================
--- generic/tclThreadJoin.c
+++ generic/tclThreadJoin.c
@@ -199,11 +199,11 @@
 
     *result = threadPtr->result;
 
     Tcl_ConditionFinalize(&threadPtr->cond);
     Tcl_MutexFinalize(&threadPtr->threadMutex);
-    Tcl_Free(threadPtr);
+    ckfree(threadPtr);
 
     return TCL_OK;
 }
 
 /*
@@ -228,11 +228,11 @@
 TclRememberJoinableThread(
     Tcl_ThreadId id)		/* The thread to remember as joinable */
 {
     JoinableThread *threadPtr;
 
-    threadPtr = Tcl_Alloc(sizeof(JoinableThread));
+    threadPtr = ckalloc(sizeof(JoinableThread));
     threadPtr->id = id;
     threadPtr->done = 0;
     threadPtr->waitedUpon = 0;
     threadPtr->threadMutex = (Tcl_Mutex) NULL;
     threadPtr->cond = (Tcl_Condition) NULL;

Index: generic/tclThreadStorage.c
==================================================================
--- generic/tclThreadStorage.c
+++ generic/tclThreadStorage.c
@@ -45,11 +45,11 @@
 
 /*
  * The type of the data held per thread in a system TSD.
  */
 
-typedef struct {
+typedef struct TSDTable {
     ClientData *tablePtr;	/* The table of Tcl TSDs. */
     sig_atomic_t allocated;	/* The size of the table in the current
 				 * thread. */
 } TSDTable;
 
@@ -83,18 +83,18 @@
 TSDTableCreate(void)
 {
     TSDTable *tsdTablePtr;
     sig_atomic_t i;
 
-    tsdTablePtr = TclpSysAlloc(sizeof(TSDTable));
+    tsdTablePtr = TclpSysAlloc(sizeof(TSDTable), 0);
     if (tsdTablePtr == NULL) {
 	Tcl_Panic("unable to allocate TSDTable");
     }
 
     tsdTablePtr->allocated = 8;
     tsdTablePtr->tablePtr =
-	    TclpSysAlloc(sizeof(void *) * tsdTablePtr->allocated);
+	    TclpSysAlloc(sizeof(void *) * tsdTablePtr->allocated, 0);
     if (tsdTablePtr->tablePtr == NULL) {
 	Tcl_Panic("unable to allocate TSDTable");
     }
 
     for (i = 0; i < tsdTablePtr->allocated; ++i) {
@@ -115,11 +115,11 @@
 	    /*
 	     * These values were allocated in Tcl_GetThreadData in tclThread.c
 	     * and must now be deallocated or they will leak.
 	     */
 
-	    Tcl_Free(tsdTablePtr->tablePtr[i]);
+	    ckfree(tsdTablePtr->tablePtr[i]);
 	}
     }
 
     TclpSysFree(tsdTablePtr->tablePtr);
     TclpSysFree(tsdTablePtr);

Index: generic/tclThreadTest.c
==================================================================
--- generic/tclThreadTest.c
+++ generic/tclThreadTest.c
@@ -292,11 +292,11 @@
 	     */
 
 	    script = Tcl_GetStringFromObj(objv[2], &len);
 
 	    if ((len > 1) && (script[0] == '-') && (script[1] == 'j') &&
-		    (0 == strncmp(script, "-joinable", len))) {
+		    (0 == strncmp(script, "-joinable", (size_t) len))) {
 		joinable = 1;
 		script = "testthread wait";	/* Just enter event loop */
 	    } else {
 		/*
 		 * Remember the script
@@ -309,11 +309,11 @@
 	     * Definitely a script available, but is the flag -joinable?
 	     */
 
 	    script = Tcl_GetStringFromObj(objv[2], &len);
 	    joinable = ((len > 1) && (script[0] == '-') && (script[1] == 'j')
-		    && (0 == strncmp(script, "-joinable", len)));
+		    && (0 == strncmp(script, "-joinable", (size_t) len)));
 	    script = Tcl_GetString(objv[3]);
 	} else {
 	    Tcl_WrongNumArgs(interp, 2, objv, "?-joinable? ?script?");
 	    return TCL_ERROR;
 	}
@@ -430,14 +430,14 @@
 	    return TCL_ERROR;
 	}
 	Tcl_MutexLock(&threadMutex);
 	errorThreadId = Tcl_GetCurrentThread();
 	if (errorProcString) {
-	    Tcl_Free(errorProcString);
+	    ckfree(errorProcString);
 	}
 	proc = Tcl_GetString(objv[2]);
-	errorProcString = Tcl_Alloc(strlen(proc) + 1);
+	errorProcString = ckalloc(strlen(proc) + 1);
 	strcpy(errorProcString, proc);
 	Tcl_MutexUnlock(&threadMutex);
 	return TCL_OK;
     }
     case THREAD_WAIT:
@@ -593,11 +593,11 @@
     /*
      * We need to keep a pointer to the alloc'ed mem of the script we are
      * eval'ing, for the case that we exit during evaluation
      */
 
-    threadEvalScript = Tcl_Alloc(strlen(ctrlPtr->script) + 1);
+    threadEvalScript = ckalloc(strlen(ctrlPtr->script) + 1);
     strcpy(threadEvalScript, ctrlPtr->script);
 
     Tcl_CreateThreadExitHandler(ThreadExitProc, threadEvalScript);
 
     /*
@@ -668,11 +668,11 @@
 	argv[0] = errorProcString;
 	argv[1] = buf;
 	argv[2] = errorInfo;
 	script = Tcl_Merge(3, argv);
 	ThreadSend(interp, errorThreadId, script, 0);
-	Tcl_Free(script);
+	ckfree(script);
     }
 }
 
 
 /*
@@ -838,17 +838,17 @@
 
     /*
      * Create the event for its event queue.
      */
 
-    threadEventPtr = Tcl_Alloc(sizeof(ThreadEvent));
-    threadEventPtr->script = Tcl_Alloc(strlen(script) + 1);
+    threadEventPtr = ckalloc(sizeof(ThreadEvent));
+    threadEventPtr->script = ckalloc(strlen(script) + 1);
     strcpy(threadEventPtr->script, script);
     if (!wait) {
 	resultPtr = threadEventPtr->resultPtr = NULL;
     } else {
-	resultPtr = Tcl_Alloc(sizeof(ThreadEventResult));
+	resultPtr = ckalloc(sizeof(ThreadEventResult));
 	threadEventPtr->resultPtr = resultPtr;
 
 	/*
 	 * Initialize the result fields.
 	 */
@@ -916,23 +916,23 @@
     Tcl_MutexUnlock(&threadMutex);
 
     if (resultPtr->code != TCL_OK) {
 	if (resultPtr->errorCode) {
 	    Tcl_SetErrorCode(interp, resultPtr->errorCode, NULL);
-	    Tcl_Free(resultPtr->errorCode);
+	    ckfree(resultPtr->errorCode);
 	}
 	if (resultPtr->errorInfo) {
 	    Tcl_AddErrorInfo(interp, resultPtr->errorInfo);
-	    Tcl_Free(resultPtr->errorInfo);
+	    ckfree(resultPtr->errorInfo);
 	}
     }
     Tcl_AppendResult(interp, resultPtr->result, NULL);
     Tcl_ConditionFinalize(&resultPtr->done);
     code = resultPtr->code;
 
-    Tcl_Free(resultPtr->result);
-    Tcl_Free(resultPtr);
+    ckfree(resultPtr->result);
+    ckfree(resultPtr);
 
     return code;
 }
 
 /*
@@ -1036,22 +1036,22 @@
 	} else {
 	    errorCode = errorInfo = NULL;
 	}
 	result = Tcl_GetStringResult(interp);
     }
-    Tcl_Free(threadEventPtr->script);
+    ckfree(threadEventPtr->script);
     if (resultPtr) {
 	Tcl_MutexLock(&threadMutex);
 	resultPtr->code = code;
-	resultPtr->result = Tcl_Alloc(strlen(result) + 1);
+	resultPtr->result = ckalloc(strlen(result) + 1);
 	strcpy(resultPtr->result, result);
 	if (errorCode != NULL) {
-	    resultPtr->errorCode = Tcl_Alloc(strlen(errorCode) + 1);
+	    resultPtr->errorCode = ckalloc(strlen(errorCode) + 1);
 	    strcpy(resultPtr->errorCode, errorCode);
 	}
 	if (errorInfo != NULL) {
-	    resultPtr->errorInfo = Tcl_Alloc(strlen(errorInfo) + 1);
+	    resultPtr->errorInfo = ckalloc(strlen(errorInfo) + 1);
 	    strcpy(resultPtr->errorInfo, errorInfo);
 	}
 	Tcl_ConditionNotify(&resultPtr->done);
 	Tcl_MutexUnlock(&threadMutex);
     }
@@ -1082,11 +1082,11 @@
 static void
 ThreadFreeProc(
     ClientData clientData)
 {
     if (clientData) {
-	Tcl_Free(clientData);
+	ckfree(clientData);
     }
 }
 
 /*
  *------------------------------------------------------------------------
@@ -1110,11 +1110,11 @@
 ThreadDeleteEvent(
     Tcl_Event *eventPtr,	/* Really ThreadEvent */
     ClientData clientData)	/* dummy */
 {
     if (eventPtr->proc == ThreadEventProc) {
-	Tcl_Free(((ThreadEvent *) eventPtr)->script);
+	ckfree(((ThreadEvent *) eventPtr)->script);
 	return 1;
     }
 
     /*
      * If it was NULL, we were in the middle of servicing the event and it
@@ -1157,18 +1157,18 @@
 
     Tcl_MutexLock(&threadMutex);
 
     if (self == errorThreadId) {
 	if (errorProcString) {	/* Extra safety */
-	    Tcl_Free(errorProcString);
+	    ckfree(errorProcString);
 	    errorProcString = NULL;
 	}
 	errorThreadId = 0;
     }
 
     if (threadEvalScript) {
-	Tcl_Free(threadEvalScript);
+	ckfree(threadEvalScript);
 	threadEvalScript = NULL;
     }
     Tcl_DeleteEvents((Tcl_EventDeleteProc *) ThreadDeleteEvent, NULL);
 
     for (resultPtr = resultList ; resultPtr ; resultPtr = nextPtr) {
@@ -1187,21 +1187,21 @@
 	    if (resultPtr->nextPtr) {
 		resultPtr->nextPtr->prevPtr = resultPtr->prevPtr;
 	    }
 	    resultPtr->nextPtr = resultPtr->prevPtr = 0;
 	    resultPtr->eventPtr->resultPtr = NULL;
-	    Tcl_Free(resultPtr);
+	    ckfree(resultPtr);
 	} else if (resultPtr->dstThreadId == self) {
 	    /*
 	     * Dang. The target is going away. Unblock the caller. The result
 	     * string must be dynamically allocated because the main thread is
 	     * going to call free on it.
 	     */
 
 	    const char *msg = "target thread died";
 
-	    resultPtr->result = Tcl_Alloc(strlen(msg) + 1);
+	    resultPtr->result = ckalloc(strlen(msg) + 1);
 	    strcpy(resultPtr->result, msg);
 	    resultPtr->code = TCL_ERROR;
 	    Tcl_ConditionNotify(&resultPtr->done);
 	}
     }

Index: generic/tclTimer.c
==================================================================
--- generic/tclTimer.c
+++ generic/tclTimer.c
@@ -215,16 +215,16 @@
 {
     ThreadSpecificData *tsdPtr = TclThreadDataKeyGet(&dataKey);
 
     Tcl_DeleteEventSource(TimerSetupProc, TimerCheckProc, NULL);
     if (tsdPtr != NULL) {
-	register TimerHandler *timerHandlerPtr;
+	TimerHandler *timerHandlerPtr;
 
 	timerHandlerPtr = tsdPtr->firstTimerHandlerPtr;
 	while (timerHandlerPtr != NULL) {
 	    tsdPtr->firstTimerHandlerPtr = timerHandlerPtr->nextPtr;
-	    Tcl_Free(timerHandlerPtr);
+	    ckfree(timerHandlerPtr);
 	    timerHandlerPtr = tsdPtr->firstTimerHandlerPtr;
 	}
     }
 }
 
@@ -292,14 +292,14 @@
 TclCreateAbsoluteTimerHandler(
     Tcl_Time *timePtr,
     Tcl_TimerProc *proc,
     ClientData clientData)
 {
-    register TimerHandler *timerHandlerPtr, *tPtr2, *prevPtr;
+    TimerHandler *timerHandlerPtr, *tPtr2, *prevPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    timerHandlerPtr = Tcl_Alloc(sizeof(TimerHandler));
+    timerHandlerPtr = ckalloc(sizeof(TimerHandler));
 
     /*
      * Fill in fields for the event.
      */
 
@@ -353,11 +353,11 @@
 void
 Tcl_DeleteTimerHandler(
     Tcl_TimerToken token)	/* Result previously returned by
 				 * Tcl_DeleteTimerHandler. */
 {
-    register TimerHandler *timerHandlerPtr, *prevPtr;
+    TimerHandler *timerHandlerPtr, *prevPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
 
     if (token == NULL) {
 	return;
     }
@@ -371,11 +371,11 @@
 	if (prevPtr == NULL) {
 	    tsdPtr->firstTimerHandlerPtr = timerHandlerPtr->nextPtr;
 	} else {
 	    prevPtr->nextPtr = timerHandlerPtr->nextPtr;
 	}
-	Tcl_Free(timerHandlerPtr);
+	ckfree(timerHandlerPtr);
 	return;
     }
 }
 
 /*
@@ -486,11 +486,11 @@
 	 */
 
 	if (blockTime.sec == 0 && blockTime.usec == 0 &&
 		!tsdPtr->timerPending) {
 	    tsdPtr->timerPending = 1;
-	    timerEvPtr = Tcl_Alloc(sizeof(Tcl_Event));
+	    timerEvPtr = ckalloc(sizeof(Tcl_Event));
 	    timerEvPtr->proc = TimerHandlerEventProc;
 	    Tcl_QueueEvent(timerEvPtr, TCL_QUEUE_TAIL);
 	}
     }
 }
@@ -589,11 +589,11 @@
 	 * potential reentrancy problems.
 	 */
 
 	*nextPtrPtr = timerHandlerPtr->nextPtr;
 	timerHandlerPtr->proc(timerHandlerPtr->clientData);
-	Tcl_Free(timerHandlerPtr);
+	ckfree(timerHandlerPtr);
     }
     TimerSetupProc(NULL, TCL_TIMER_EVENTS);
     return 1;
 }
 
@@ -619,15 +619,15 @@
 void
 Tcl_DoWhenIdle(
     Tcl_IdleProc *proc,		/* Function to invoke. */
     ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
-    register IdleHandler *idlePtr;
+    IdleHandler *idlePtr;
     Tcl_Time blockTime;
     ThreadSpecificData *tsdPtr = InitTimer();
 
-    idlePtr = Tcl_Alloc(sizeof(IdleHandler));
+    idlePtr = ckalloc(sizeof(IdleHandler));
     idlePtr->proc = proc;
     idlePtr->clientData = clientData;
     idlePtr->generation = tsdPtr->idleGeneration;
     idlePtr->nextPtr = NULL;
     if (tsdPtr->lastIdlePtr == NULL) {
@@ -663,20 +663,20 @@
 void
 Tcl_CancelIdleCall(
     Tcl_IdleProc *proc,		/* Function that was previously registered. */
     ClientData clientData)	/* Arbitrary value to pass to proc. */
 {
-    register IdleHandler *idlePtr, *prevPtr;
+    IdleHandler *idlePtr, *prevPtr;
     IdleHandler *nextPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
 
     for (prevPtr = NULL, idlePtr = tsdPtr->idleList; idlePtr != NULL;
 	    prevPtr = idlePtr, idlePtr = idlePtr->nextPtr) {
 	while ((idlePtr->proc == proc)
 		&& (idlePtr->clientData == clientData)) {
 	    nextPtr = idlePtr->nextPtr;
-	    Tcl_Free(idlePtr);
+	    ckfree(idlePtr);
 	    idlePtr = nextPtr;
 	    if (prevPtr == NULL) {
 		tsdPtr->idleList = idlePtr;
 	    } else {
 		prevPtr->nextPtr = idlePtr;
@@ -747,11 +747,11 @@
 	tsdPtr->idleList = idlePtr->nextPtr;
 	if (tsdPtr->idleList == NULL) {
 	    tsdPtr->lastIdlePtr = NULL;
 	}
 	idlePtr->proc(idlePtr->clientData);
-	Tcl_Free(idlePtr);
+	ckfree(idlePtr);
     }
     if (tsdPtr->idleList) {
 	blockTime.sec = 0;
 	blockTime.usec = 0;
 	Tcl_SetMaxBlockTime(&blockTime);
@@ -786,11 +786,11 @@
 {
     Tcl_WideInt ms = 0;		/* Number of milliseconds to wait */
     Tcl_Time wakeup;
     AfterInfo *afterPtr;
     AfterAssocData *assocPtr;
-    size_t length;
+    int length;
     int index = -1;
     static const char *const afterSubCmds[] = {
 	"cancel", "idle", "info", NULL
     };
     enum afterSubCmds {AFTER_CANCEL, AFTER_IDLE, AFTER_INFO};
@@ -806,11 +806,11 @@
      * doesn't already exist.
      */
 
     assocPtr = Tcl_GetAssocData(interp, "tclAfter", NULL);
     if (assocPtr == NULL) {
-	assocPtr = Tcl_Alloc(sizeof(AfterAssocData));
+	assocPtr = ckalloc(sizeof(AfterAssocData));
 	assocPtr->interp = interp;
 	assocPtr->firstAfterPtr = NULL;
 	Tcl_SetAssocData(interp, "tclAfter", AfterCleanupProc, assocPtr);
     }
 
@@ -819,11 +819,11 @@
      */
 
     if (Tcl_GetWideIntFromObj(NULL, objv[1], &ms) != TCL_OK) {
 	if (Tcl_GetIndexFromObj(NULL, objv[1], afterSubCmds, "", 0, &index)
 		!= TCL_OK) {
-            const char *arg = TclGetString(objv[1]);
+            const char *arg = Tcl_GetString(objv[1]);
 
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
                     "bad argument \"%s\": must be"
                     " cancel, idle, info, or an integer", arg));
             Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "INDEX", "argument",
@@ -843,11 +843,11 @@
 	    ms = 0;
 	}
 	if (objc == 2) {
 	    return AfterDelay(interp, ms);
 	}
-	afterPtr = Tcl_Alloc(sizeof(AfterInfo));
+	afterPtr = ckalloc(sizeof(AfterInfo));
 	afterPtr->assocPtr = assocPtr;
 	if (objc == 3) {
 	    afterPtr->commandPtr = objv[2];
 	} else {
 	    afterPtr->commandPtr = Tcl_ConcatObj(objc-2, objv+2);
@@ -881,11 +881,11 @@
 	return TCL_OK;
     }
     case AFTER_CANCEL: {
 	Tcl_Obj *commandPtr;
 	const char *command, *tempCommand;
-	size_t tempLength;
+	int tempLength;
 
 	if (objc < 3) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "id|command");
 	    return TCL_ERROR;
 	}
@@ -923,11 +923,11 @@
     case AFTER_IDLE:
 	if (objc < 3) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "script ?script ...?");
 	    return TCL_ERROR;
 	}
-	afterPtr = Tcl_Alloc(sizeof(AfterInfo));
+	afterPtr = ckalloc(sizeof(AfterInfo));
 	afterPtr->assocPtr = assocPtr;
 	if (objc == 3) {
 	    afterPtr->commandPtr = objv[2];
 	} else {
 	    afterPtr->commandPtr = Tcl_ConcatObj(objc-2, objv+2);
@@ -1188,11 +1188,11 @@
     /*
      * Free the memory for the callback.
      */
 
     Tcl_DecrRefCount(afterPtr->commandPtr);
-    Tcl_Free(afterPtr);
+    ckfree(afterPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1226,11 +1226,11 @@
 	    /* Empty loop body. */
 	}
 	prevPtr->nextPtr = afterPtr->nextPtr;
     }
     Tcl_DecrRefCount(afterPtr->commandPtr);
-    Tcl_Free(afterPtr);
+    ckfree(afterPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1265,13 +1265,13 @@
 	    Tcl_DeleteTimerHandler(afterPtr->token);
 	} else {
 	    Tcl_CancelIdleCall(AfterProc, afterPtr);
 	}
 	Tcl_DecrRefCount(afterPtr->commandPtr);
-	Tcl_Free(afterPtr);
+	ckfree(afterPtr);
     }
-    Tcl_Free(assocPtr);
+    ckfree(assocPtr);
 }
 
 /*
  * Local Variables:
  * mode: c

Index: generic/tclTomMath.decls
==================================================================
--- generic/tclTomMath.decls
+++ generic/tclTomMath.decls
@@ -172,10 +172,47 @@
     int TclBN_mp_xor(const mp_int *a, const mp_int *b, mp_int *c)
 }
 declare 49 {
     void TclBN_mp_zero(mp_int *a)
 }
+
+# internal routines to libtommath - should not be called but must be
+# exported to accommodate the "tommath" extension
+
+declare 50 {deprecated {is private function in libtommath}} {
+    void TclBN_reverse(unsigned char *s, int len)
+}
+declare 51 {deprecated {is private function in libtommath}} {
+    int TclBN_fast_s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
+}
+declare 52 {deprecated {is private function in libtommath}} {
+    int TclBN_fast_s_mp_sqr(const mp_int *a, mp_int *b)
+}
+declare 53 {deprecated {is private function in libtommath}} {
+    int TclBN_mp_karatsuba_mul(const mp_int *a, const mp_int *b, mp_int *c)
+}
+declare 54 {deprecated {is private function in libtommath}} {
+    int TclBN_mp_karatsuba_sqr(const mp_int *a, mp_int *b)
+}
+declare 55 {deprecated {is private function in libtommath}} {
+    int TclBN_mp_toom_mul(const mp_int *a, const mp_int *b, mp_int *c)
+}
+declare 56 {deprecated {is private function in libtommath}} {
+    int TclBN_mp_toom_sqr(const mp_int *a, mp_int *b)
+}
+declare 57 {deprecated {is private function in libtommath}} {
+    int TclBN_s_mp_add(const mp_int *a, const mp_int *b, mp_int *c)
+}
+declare 58 {deprecated {is private function in libtommath}} {
+    int TclBN_s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs)
+}
+declare 59 {deprecated {is private function in libtommath}} {
+    int TclBN_s_mp_sqr(const mp_int *a, mp_int *b)
+}
+declare 60 {deprecated {is private function in libtommath}} {
+    int TclBN_s_mp_sub(const mp_int *a, const mp_int *b, mp_int *c)
+}
 declare 61 {
     int TclBN_mp_init_set_int(mp_int *a, unsigned long i)
 }
 declare 62 {
     int TclBN_mp_set_int(mp_int *a, unsigned long i)
@@ -184,22 +221,19 @@
     int TclBN_mp_cnt_lsb(const mp_int *a)
 }
 
 # Formerly internal API to allow initialisation of bignums without knowing the
 # typedefs of how a bignum works internally.
-# Removed in 9.0
-#declare 64 {
-#    void TclBNInitBignumFromLong(mp_int *bignum, long initVal)
-#}
-# Removed in 9.0
-#declare 65 {
-#    void TclBNInitBignumFromWideInt(mp_int *bignum, Tcl_WideInt initVal)
-#}
-# Removed in 9.0
-#declare 66 {
-#    void TclBNInitBignumFromWideUInt(mp_int *bignum, Tcl_WideUInt initVal)
-#}
+declare 64 {deprecated {Use mp_init() + mp_set_long_long()}} {
+    void TclBNInitBignumFromLong(mp_int *bignum, long initVal)
+}
+declare 65 {deprecated {Use mp_init() + mp_set_long_long()}} {
+    void TclBNInitBignumFromWideInt(mp_int *bignum, Tcl_WideInt initVal)
+}
+declare 66 {deprecated {Use mp_init() + mp_set_long_long()}} {
+    void TclBNInitBignumFromWideUInt(mp_int *bignum, Tcl_WideUInt initVal)
+}
 
 # Added in libtommath 1.0
 declare 67 {
     int TclBN_mp_expt_d_ex(const mp_int *a, mp_digit b, mp_int *c, int fast)
 }
@@ -219,22 +253,19 @@
 declare 72 {
     unsigned long TclBN_mp_get_int(const mp_int *a)
 }
 
 # Added in libtommath 1.1.0
-# No longer in use: replaced by mp_and()
-#declare 73 {
-#    int TclBN_mp_tc_and(const mp_int *a, const mp_int *b, mp_int *c)
-#}
-# No longer in use: replaced by mp_or()
-#declare 74 {
-#    int TclBN_mp_tc_or(const mp_int *a, const mp_int *b, mp_int *c)
-#}
-# No longer in use: replaced by mp_xor()
-#declare 75 {
-#    int TclBN_mp_tc_xor(const mp_int *a, const mp_int *b, mp_int *c)
-#}
+declare 73 {
+    int TclBN_mp_tc_and(const mp_int *a, const mp_int *b, mp_int *c)
+}
+declare 74 {
+    int TclBN_mp_tc_or(const mp_int *a, const mp_int *b, mp_int *c)
+}
+declare 75 {
+    int TclBN_mp_tc_xor(const mp_int *a, const mp_int *b, mp_int *c)
+}
 declare 76 {
     int TclBN_mp_signed_rsh(const mp_int *a, int b, mp_int *c)
 }
 declare 77 {
     int TclBN_mp_get_bit(const mp_int *a, int b)

Index: generic/tclTomMathDecls.h
==================================================================
--- generic/tclTomMathDecls.h
+++ generic/tclTomMathDecls.h
@@ -28,17 +28,16 @@
     (TclTomMathInitializeStubs((interp),(version),\
                                TCLTOMMATH_EPOCH,TCLTOMMATH_REVISION))
 
 /* Define custom memory allocation for libtommath */
 
-
 /* MODULE_SCOPE void* TclBNAlloc( size_t ); */
-#define TclBNAlloc(s) ((void*)Tcl_Alloc((size_t)(s)))
+#define TclBNAlloc(s) ((void*)ckalloc((size_t)(s)))
 /* MODULE_SCOPE void* TclBNRealloc( void*, size_t ); */
-#define TclBNRealloc(x,s) ((void*)Tcl_Realloc((char*)(x),(size_t)(s)))
+#define TclBNRealloc(x,s) ((void*)ckrealloc((char*)(x),(size_t)(s)))
 /* MODULE_SCOPE void  TclBNFree( void* ); */
-#define TclBNFree(x) (Tcl_Free((char*)(x)))
+#define TclBNFree(x) (ckfree((char*)(x)))
 
 #define XMALLOC(size)                   TclBNAlloc(size)
 #define XFREE(mem, size)                TclBNFree(mem)
 #define XREALLOC(mem, oldsize, newsize) TclBNRealloc(mem, newsize)
 
@@ -69,10 +68,11 @@
 #define mp_div_3 TclBN_mp_div_3
 #define mp_div_d TclBN_mp_div_d
 #define mp_exch TclBN_mp_exch
 #define mp_expt_d TclBN_mp_expt_d
 #define mp_expt_d_ex TclBN_mp_expt_d_ex
+#define mp_get_bit TclBN_mp_get_bit
 #define mp_get_int TclBN_mp_get_int
 #define mp_get_long TclBN_mp_get_long
 #define mp_get_long_long TclBN_mp_get_long_long
 #define mp_grow TclBN_mp_grow
 #define s_mp_get_bit TclBN_mp_get_bit
@@ -107,10 +107,14 @@
 #define mp_sqr TclBN_mp_sqr
 #define mp_sqrt TclBN_mp_sqrt
 #define mp_sub TclBN_mp_sub
 #define mp_sub_d TclBN_mp_sub_d
 #define mp_signed_rsh TclBN_mp_signed_rsh
+#define mp_tc_and TclBN_mp_and
+#define mp_tc_div_2d TclBN_mp_signed_rsh
+#define mp_tc_or TclBN_mp_or
+#define mp_tc_xor TclBN_mp_xor
 #define mp_to_unsigned_bin TclBN_mp_to_unsigned_bin
 #define mp_to_unsigned_bin_n TclBN_mp_to_unsigned_bin_n
 #define mp_toom_mul TclBN_mp_toom_mul
 #define s_mp_toom_mul TclBN_mp_toom_mul
 #define mp_toom_sqr TclBN_mp_toom_sqr
@@ -122,28 +126,10 @@
 #define s_mp_add TclBN_s_mp_add
 #define s_mp_mul_digs TclBN_s_mp_mul_digs
 #define s_mp_sqr TclBN_s_mp_sqr
 #define s_mp_sub TclBN_s_mp_sub
 
-MODULE_SCOPE void TclBN_reverse(unsigned char *s, int len);
-MODULE_SCOPE int TclBN_fast_s_mp_mul_digs(const mp_int *a,
-				const mp_int *b, mp_int *c, int digs);
-MODULE_SCOPE int TclBN_fast_s_mp_sqr(const mp_int *a, mp_int *b);
-MODULE_SCOPE int TclBN_mp_karatsuba_mul(const mp_int *a,
-				const mp_int *b, mp_int *c);
-MODULE_SCOPE int TclBN_mp_karatsuba_sqr(const mp_int *a, mp_int *b);
-MODULE_SCOPE int TclBN_mp_toom_mul(const mp_int *a, const mp_int *b,
-				mp_int *c);
-MODULE_SCOPE int TclBN_mp_toom_sqr(const mp_int *a, mp_int *b);
-MODULE_SCOPE int TclBN_s_mp_add(const mp_int *a, const mp_int *b,
-				mp_int *c);
-MODULE_SCOPE int TclBN_s_mp_mul_digs(const mp_int *a, const mp_int *b,
-				mp_int *c, int digs);
-MODULE_SCOPE int TclBN_s_mp_sqr(const mp_int *a, mp_int *b);
-MODULE_SCOPE int TclBN_s_mp_sub(const mp_int *a, const mp_int *b,
-				mp_int *c);
-
 #undef TCL_STORAGE_CLASS
 #ifdef BUILD_tcl
 #   define TCL_STORAGE_CLASS DLLEXPORT
 #else
 #   ifdef USE_TCL_STUBS
@@ -287,30 +273,66 @@
 /* 48 */
 EXTERN int		TclBN_mp_xor(const mp_int *a, const mp_int *b,
 				mp_int *c);
 /* 49 */
 EXTERN void		TclBN_mp_zero(mp_int *a);
-/* Slot 50 is reserved */
-/* Slot 51 is reserved */
-/* Slot 52 is reserved */
-/* Slot 53 is reserved */
-/* Slot 54 is reserved */
-/* Slot 55 is reserved */
-/* Slot 56 is reserved */
-/* Slot 57 is reserved */
-/* Slot 58 is reserved */
-/* Slot 59 is reserved */
-/* Slot 60 is reserved */
+/* 50 */
+TCL_DEPRECATED("is private function in libtommath")
+void			TclBN_reverse(unsigned char *s, int len);
+/* 51 */
+TCL_DEPRECATED("is private function in libtommath")
+int			TclBN_fast_s_mp_mul_digs(const mp_int *a,
+				const mp_int *b, mp_int *c, int digs);
+/* 52 */
+TCL_DEPRECATED("is private function in libtommath")
+int			TclBN_fast_s_mp_sqr(const mp_int *a, mp_int *b);
+/* 53 */
+TCL_DEPRECATED("is private function in libtommath")
+int			TclBN_mp_karatsuba_mul(const mp_int *a,
+				const mp_int *b, mp_int *c);
+/* 54 */
+TCL_DEPRECATED("is private function in libtommath")
+int			TclBN_mp_karatsuba_sqr(const mp_int *a, mp_int *b);
+/* 55 */
+TCL_DEPRECATED("is private function in libtommath")
+int			TclBN_mp_toom_mul(const mp_int *a, const mp_int *b,
+				mp_int *c);
+/* 56 */
+TCL_DEPRECATED("is private function in libtommath")
+int			TclBN_mp_toom_sqr(const mp_int *a, mp_int *b);
+/* 57 */
+TCL_DEPRECATED("is private function in libtommath")
+int			TclBN_s_mp_add(const mp_int *a, const mp_int *b,
+				mp_int *c);
+/* 58 */
+TCL_DEPRECATED("is private function in libtommath")
+int			TclBN_s_mp_mul_digs(const mp_int *a, const mp_int *b,
+				mp_int *c, int digs);
+/* 59 */
+TCL_DEPRECATED("is private function in libtommath")
+int			TclBN_s_mp_sqr(const mp_int *a, mp_int *b);
+/* 60 */
+TCL_DEPRECATED("is private function in libtommath")
+int			TclBN_s_mp_sub(const mp_int *a, const mp_int *b,
+				mp_int *c);
 /* 61 */
 EXTERN int		TclBN_mp_init_set_int(mp_int *a, unsigned long i);
 /* 62 */
 EXTERN int		TclBN_mp_set_int(mp_int *a, unsigned long i);
 /* 63 */
 EXTERN int		TclBN_mp_cnt_lsb(const mp_int *a);
-/* Slot 64 is reserved */
-/* Slot 65 is reserved */
-/* Slot 66 is reserved */
+/* 64 */
+TCL_DEPRECATED("Use mp_init() + mp_set_long_long()")
+void			TclBNInitBignumFromLong(mp_int *bignum, long initVal);
+/* 65 */
+TCL_DEPRECATED("Use mp_init() + mp_set_long_long()")
+void			TclBNInitBignumFromWideInt(mp_int *bignum,
+				Tcl_WideInt initVal);
+/* 66 */
+TCL_DEPRECATED("Use mp_init() + mp_set_long_long()")
+void			TclBNInitBignumFromWideUInt(mp_int *bignum,
+				Tcl_WideUInt initVal);
 /* 67 */
 EXTERN int		TclBN_mp_expt_d_ex(const mp_int *a, mp_digit b,
 				mp_int *c, int fast);
 /* 68 */
 EXTERN int		TclBN_mp_set_long_long(mp_int *a, Tcl_WideUInt i);
@@ -320,13 +342,19 @@
 EXTERN int		TclBN_mp_set_long(mp_int *a, unsigned long i);
 /* 71 */
 EXTERN unsigned long	TclBN_mp_get_long(const mp_int *a);
 /* 72 */
 EXTERN unsigned long	TclBN_mp_get_int(const mp_int *a);
-/* Slot 73 is reserved */
-/* Slot 74 is reserved */
-/* Slot 75 is reserved */
+/* 73 */
+EXTERN int		TclBN_mp_tc_and(const mp_int *a, const mp_int *b,
+				mp_int *c);
+/* 74 */
+EXTERN int		TclBN_mp_tc_or(const mp_int *a, const mp_int *b,
+				mp_int *c);
+/* 75 */
+EXTERN int		TclBN_mp_tc_xor(const mp_int *a, const mp_int *b,
+				mp_int *c);
 /* 76 */
 EXTERN int		TclBN_mp_signed_rsh(const mp_int *a, int b,
 				mp_int *c);
 /* 77 */
 EXTERN int		TclBN_mp_get_bit(const mp_int *a, int b);
@@ -383,36 +411,36 @@
     int (*tclBN_mp_to_unsigned_bin_n) (const mp_int *a, unsigned char *b, unsigned long *outlen); /* 45 */
     int (*tclBN_mp_toradix_n) (const mp_int *a, char *str, int radix, int maxlen); /* 46 */
     int (*tclBN_mp_unsigned_bin_size) (const mp_int *a); /* 47 */
     int (*tclBN_mp_xor) (const mp_int *a, const mp_int *b, mp_int *c); /* 48 */
     void (*tclBN_mp_zero) (mp_int *a); /* 49 */
-    void (*reserved50)(void);
-    void (*reserved51)(void);
-    void (*reserved52)(void);
-    void (*reserved53)(void);
-    void (*reserved54)(void);
-    void (*reserved55)(void);
-    void (*reserved56)(void);
-    void (*reserved57)(void);
-    void (*reserved58)(void);
-    void (*reserved59)(void);
-    void (*reserved60)(void);
+    TCL_DEPRECATED_API("is private function in libtommath") void (*tclBN_reverse) (unsigned char *s, int len); /* 50 */
+    TCL_DEPRECATED_API("is private function in libtommath") int (*tclBN_fast_s_mp_mul_digs) (const mp_int *a, const mp_int *b, mp_int *c, int digs); /* 51 */
+    TCL_DEPRECATED_API("is private function in libtommath") int (*tclBN_fast_s_mp_sqr) (const mp_int *a, mp_int *b); /* 52 */
+    TCL_DEPRECATED_API("is private function in libtommath") int (*tclBN_mp_karatsuba_mul) (const mp_int *a, const mp_int *b, mp_int *c); /* 53 */
+    TCL_DEPRECATED_API("is private function in libtommath") int (*tclBN_mp_karatsuba_sqr) (const mp_int *a, mp_int *b); /* 54 */
+    TCL_DEPRECATED_API("is private function in libtommath") int (*tclBN_mp_toom_mul) (const mp_int *a, const mp_int *b, mp_int *c); /* 55 */
+    TCL_DEPRECATED_API("is private function in libtommath") int (*tclBN_mp_toom_sqr) (const mp_int *a, mp_int *b); /* 56 */
+    TCL_DEPRECATED_API("is private function in libtommath") int (*tclBN_s_mp_add) (const mp_int *a, const mp_int *b, mp_int *c); /* 57 */
+    TCL_DEPRECATED_API("is private function in libtommath") int (*tclBN_s_mp_mul_digs) (const mp_int *a, const mp_int *b, mp_int *c, int digs); /* 58 */
+    TCL_DEPRECATED_API("is private function in libtommath") int (*tclBN_s_mp_sqr) (const mp_int *a, mp_int *b); /* 59 */
+    TCL_DEPRECATED_API("is private function in libtommath") int (*tclBN_s_mp_sub) (const mp_int *a, const mp_int *b, mp_int *c); /* 60 */
     int (*tclBN_mp_init_set_int) (mp_int *a, unsigned long i); /* 61 */
     int (*tclBN_mp_set_int) (mp_int *a, unsigned long i); /* 62 */
     int (*tclBN_mp_cnt_lsb) (const mp_int *a); /* 63 */
-    void (*reserved64)(void);
-    void (*reserved65)(void);
-    void (*reserved66)(void);
+    TCL_DEPRECATED_API("Use mp_init() + mp_set_long_long()") void (*tclBNInitBignumFromLong) (mp_int *bignum, long initVal); /* 64 */
+    TCL_DEPRECATED_API("Use mp_init() + mp_set_long_long()") void (*tclBNInitBignumFromWideInt) (mp_int *bignum, Tcl_WideInt initVal); /* 65 */
+    TCL_DEPRECATED_API("Use mp_init() + mp_set_long_long()") void (*tclBNInitBignumFromWideUInt) (mp_int *bignum, Tcl_WideUInt initVal); /* 66 */
     int (*tclBN_mp_expt_d_ex) (const mp_int *a, mp_digit b, mp_int *c, int fast); /* 67 */
     int (*tclBN_mp_set_long_long) (mp_int *a, Tcl_WideUInt i); /* 68 */
     Tcl_WideUInt (*tclBN_mp_get_long_long) (const mp_int *a); /* 69 */
     int (*tclBN_mp_set_long) (mp_int *a, unsigned long i); /* 70 */
     unsigned long (*tclBN_mp_get_long) (const mp_int *a); /* 71 */
     unsigned long (*tclBN_mp_get_int) (const mp_int *a); /* 72 */
-    void (*reserved73)(void);
-    void (*reserved74)(void);
-    void (*reserved75)(void);
+    int (*tclBN_mp_tc_and) (const mp_int *a, const mp_int *b, mp_int *c); /* 73 */
+    int (*tclBN_mp_tc_or) (const mp_int *a, const mp_int *b, mp_int *c); /* 74 */
+    int (*tclBN_mp_tc_xor) (const mp_int *a, const mp_int *b, mp_int *c); /* 75 */
     int (*tclBN_mp_signed_rsh) (const mp_int *a, int b, mp_int *c); /* 76 */
     int (*tclBN_mp_get_bit) (const mp_int *a, int b); /* 77 */
 } TclTomMathStubs;
 
 extern const TclTomMathStubs *tclTomMathStubsPtr;
@@ -525,30 +553,44 @@
 	(tclTomMathStubsPtr->tclBN_mp_unsigned_bin_size) /* 47 */
 #define TclBN_mp_xor \
 	(tclTomMathStubsPtr->tclBN_mp_xor) /* 48 */
 #define TclBN_mp_zero \
 	(tclTomMathStubsPtr->tclBN_mp_zero) /* 49 */
-/* Slot 50 is reserved */
-/* Slot 51 is reserved */
-/* Slot 52 is reserved */
-/* Slot 53 is reserved */
-/* Slot 54 is reserved */
-/* Slot 55 is reserved */
-/* Slot 56 is reserved */
-/* Slot 57 is reserved */
-/* Slot 58 is reserved */
-/* Slot 59 is reserved */
-/* Slot 60 is reserved */
+#define TclBN_reverse \
+	(tclTomMathStubsPtr->tclBN_reverse) /* 50 */
+#define TclBN_fast_s_mp_mul_digs \
+	(tclTomMathStubsPtr->tclBN_fast_s_mp_mul_digs) /* 51 */
+#define TclBN_fast_s_mp_sqr \
+	(tclTomMathStubsPtr->tclBN_fast_s_mp_sqr) /* 52 */
+#define TclBN_mp_karatsuba_mul \
+	(tclTomMathStubsPtr->tclBN_mp_karatsuba_mul) /* 53 */
+#define TclBN_mp_karatsuba_sqr \
+	(tclTomMathStubsPtr->tclBN_mp_karatsuba_sqr) /* 54 */
+#define TclBN_mp_toom_mul \
+	(tclTomMathStubsPtr->tclBN_mp_toom_mul) /* 55 */
+#define TclBN_mp_toom_sqr \
+	(tclTomMathStubsPtr->tclBN_mp_toom_sqr) /* 56 */
+#define TclBN_s_mp_add \
+	(tclTomMathStubsPtr->tclBN_s_mp_add) /* 57 */
+#define TclBN_s_mp_mul_digs \
+	(tclTomMathStubsPtr->tclBN_s_mp_mul_digs) /* 58 */
+#define TclBN_s_mp_sqr \
+	(tclTomMathStubsPtr->tclBN_s_mp_sqr) /* 59 */
+#define TclBN_s_mp_sub \
+	(tclTomMathStubsPtr->tclBN_s_mp_sub) /* 60 */
 #define TclBN_mp_init_set_int \
 	(tclTomMathStubsPtr->tclBN_mp_init_set_int) /* 61 */
 #define TclBN_mp_set_int \
 	(tclTomMathStubsPtr->tclBN_mp_set_int) /* 62 */
 #define TclBN_mp_cnt_lsb \
 	(tclTomMathStubsPtr->tclBN_mp_cnt_lsb) /* 63 */
-/* Slot 64 is reserved */
-/* Slot 65 is reserved */
-/* Slot 66 is reserved */
+#define TclBNInitBignumFromLong \
+	(tclTomMathStubsPtr->tclBNInitBignumFromLong) /* 64 */
+#define TclBNInitBignumFromWideInt \
+	(tclTomMathStubsPtr->tclBNInitBignumFromWideInt) /* 65 */
+#define TclBNInitBignumFromWideUInt \
+	(tclTomMathStubsPtr->tclBNInitBignumFromWideUInt) /* 66 */
 #define TclBN_mp_expt_d_ex \
 	(tclTomMathStubsPtr->tclBN_mp_expt_d_ex) /* 67 */
 #define TclBN_mp_set_long_long \
 	(tclTomMathStubsPtr->tclBN_mp_set_long_long) /* 68 */
 #define TclBN_mp_get_long_long \
@@ -557,13 +599,16 @@
 	(tclTomMathStubsPtr->tclBN_mp_set_long) /* 70 */
 #define TclBN_mp_get_long \
 	(tclTomMathStubsPtr->tclBN_mp_get_long) /* 71 */
 #define TclBN_mp_get_int \
 	(tclTomMathStubsPtr->tclBN_mp_get_int) /* 72 */
-/* Slot 73 is reserved */
-/* Slot 74 is reserved */
-/* Slot 75 is reserved */
+#define TclBN_mp_tc_and \
+	(tclTomMathStubsPtr->tclBN_mp_tc_and) /* 73 */
+#define TclBN_mp_tc_or \
+	(tclTomMathStubsPtr->tclBN_mp_tc_or) /* 74 */
+#define TclBN_mp_tc_xor \
+	(tclTomMathStubsPtr->tclBN_mp_tc_xor) /* 75 */
 #define TclBN_mp_signed_rsh \
 	(tclTomMathStubsPtr->tclBN_mp_signed_rsh) /* 76 */
 #define TclBN_mp_get_bit \
 	(tclTomMathStubsPtr->tclBN_mp_get_bit) /* 77 */
 

Index: generic/tclTomMathInterface.c
==================================================================
--- generic/tclTomMathInterface.c
+++ generic/tclTomMathInterface.c
@@ -112,11 +112,11 @@
     Tcl_WideInt v)		/* Initial value */
 {
 	if (mp_init(a) != MP_OKAY) {
 		Tcl_Panic("initialization failure in TclInitBignumFromWideInt");
 	}
-    if (v < (Tcl_WideInt)0) {
+    if (v < 0) {
 	mp_set_long_long(a, (Tcl_WideUInt)(-v));
 	mp_neg(a, a);
     } else {
 	mp_set_long_long(a, (Tcl_WideUInt)v);
     }

Index: generic/tclTrace.c
==================================================================
--- generic/tclTrace.c
+++ generic/tclTrace.c
@@ -119,11 +119,11 @@
 /*
  * Declarations for local functions to this file:
  */
 
 static int		CallTraceFunction(Tcl_Interp *interp, Trace *tracePtr,
-			    Command *cmdPtr, const char *command, size_t numChars,
+			    Command *cmdPtr, const char *command, int numChars,
 			    int objc, Tcl_Obj *const objv[]);
 static char *		TraceVarProc(ClientData clientData, Tcl_Interp *interp,
 			    const char *name1, const char *name2, int flags);
 static void		TraceCommandProc(ClientData clientData,
 			    Tcl_Interp *interp, const char *oldName,
@@ -134,11 +134,11 @@
 			    const char *command, Tcl_Command commandInfo,
 			    int objc, Tcl_Obj *const objv[]);
 static void		StringTraceDeleteProc(ClientData clientData);
 static void		DisposeTraceResult(int flags, char *result);
 static int		TraceVarEx(Tcl_Interp *interp, const char *part1,
-			    const char *part2, register VarTrace *tracePtr);
+			    const char *part2, VarTrace *tracePtr);
 
 /*
  * The following structure holds the client data for string-based
  * trace procs
  */
@@ -269,12 +269,11 @@
 #ifndef TCL_REMOVE_OBSOLETE_TRACES
     case TRACE_OLD_VARIABLE:
     case TRACE_OLD_VDELETE: {
 	Tcl_Obj *copyObjv[6];
 	Tcl_Obj *opsList;
-	int code;
-	size_t numFlags;
+	int code, numFlags;
 
 	if (objc != 5) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "name ops command");
 	    return TCL_ERROR;
 	}
@@ -322,11 +321,11 @@
 	if (objc != 3) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "name");
 	    return TCL_ERROR;
 	}
 	resultListPtr = Tcl_NewObj();
-	name = TclGetString(objv[2]);
+	name = Tcl_GetString(objv[2]);
 	FOREACH_VAR_TRACE(interp, name, clientData) {
 	    TraceVarInfo *tvarPtr = clientData;
 	    char *q = ops;
 
 	    pairObjPtr = Tcl_NewListObj(0, NULL);
@@ -402,13 +401,13 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int optionIndex,		/* Add, info or remove */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    int index;
+    int commandLength, index;
     const char *name, *command;
-    size_t commandLength, length;
+    size_t length;
     enum traceOptions {
 	TRACE_ADD, TRACE_INFO, TRACE_REMOVE
     };
     static const char *const opStrings[] = {
 	"enter", "leave", "enterstep", "leavestep", NULL
@@ -466,13 +465,13 @@
 		flags |= TCL_TRACE_LEAVE_DURING_EXEC;
 		break;
 	    }
 	}
 	command = TclGetStringFromObj(objv[5], &commandLength);
-	length = commandLength;
+	length = (size_t) commandLength;
 	if ((enum traceOptions) optionIndex == TRACE_ADD) {
-	    TraceCommandInfo *tcmdPtr = Tcl_Alloc(
+	    TraceCommandInfo *tcmdPtr = ckalloc(
 		    offsetof(TraceCommandInfo, command) + 1 + length);
 
 	    tcmdPtr->flags = flags;
 	    tcmdPtr->stepTrace = NULL;
 	    tcmdPtr->startLevel = 0;
@@ -483,14 +482,14 @@
 	    if (flags & (TCL_TRACE_ENTER_DURING_EXEC |
 		    TCL_TRACE_LEAVE_DURING_EXEC)) {
 		flags |= (TCL_TRACE_ENTER_EXEC | TCL_TRACE_LEAVE_EXEC);
 	    }
 	    memcpy(tcmdPtr->command, command, length+1);
-	    name = TclGetString(objv[3]);
+	    name = Tcl_GetString(objv[3]);
 	    if (Tcl_TraceCommand(interp, name, flags, TraceCommandProc,
 		    tcmdPtr) != TCL_OK) {
-		Tcl_Free(tcmdPtr);
+		ckfree(tcmdPtr);
 		return TCL_ERROR;
 	    }
 	} else {
 	    /*
 	     * Search through all of our traces on this command to see if
@@ -502,11 +501,11 @@
 
 	    /*
 	     * First ensure the name given is valid.
 	     */
 
-	    name = TclGetString(objv[3]);
+	    name = Tcl_GetString(objv[3]);
 	    if (Tcl_FindCommand(interp,name,NULL,TCL_LEAVE_ERR_MSG) == NULL) {
 		return TCL_ERROR;
 	    }
 
 	    FOREACH_COMMAND_TRACE(interp, name, clientData) {
@@ -520,11 +519,11 @@
 
 		if ((tcmdPtr->length == length)
 			&& ((tcmdPtr->flags & (TCL_TRACE_ANY_EXEC |
 				TCL_TRACE_RENAME | TCL_TRACE_DELETE)) == flags)
 			&& (strncmp(command, tcmdPtr->command,
-				length) == 0)) {
+				(size_t) length) == 0)) {
 		    flags |= TCL_TRACE_DELETE;
 		    if (flags & (TCL_TRACE_ENTER_DURING_EXEC |
 			    TCL_TRACE_LEAVE_DURING_EXEC)) {
 			flags |= (TCL_TRACE_ENTER_EXEC | TCL_TRACE_LEAVE_EXEC);
 		    }
@@ -536,21 +535,21 @@
 			 * we created to allow 'step' traces.
 			 */
 
 			Tcl_DeleteTrace(interp, tcmdPtr->stepTrace);
 			tcmdPtr->stepTrace = NULL;
-			Tcl_Free(tcmdPtr->startCmd);
+			ckfree(tcmdPtr->startCmd);
 		    }
 		    if (tcmdPtr->flags & TCL_TRACE_EXEC_IN_PROGRESS) {
 			/*
 			 * Postpone deletion.
 			 */
 
 			tcmdPtr->flags = 0;
 		    }
 		    if (tcmdPtr->refCount-- <= 1) {
-			Tcl_Free(tcmdPtr);
+			ckfree(tcmdPtr);
 		    }
 		    break;
 		}
 	    }
 	}
@@ -563,11 +562,11 @@
 	if (objc != 4) {
 	    Tcl_WrongNumArgs(interp, 3, objv, "name");
 	    return TCL_ERROR;
 	}
 
-	name = TclGetString(objv[3]);
+	name = Tcl_GetString(objv[3]);
 
 	/*
 	 * First ensure the name given is valid.
 	 */
 
@@ -650,13 +649,13 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int optionIndex,		/* Add, info or remove */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    int index;
+    int commandLength, index;
     const char *name, *command;
-    size_t commandLength, length;
+    size_t length;
     enum traceOptions { TRACE_ADD, TRACE_INFO, TRACE_REMOVE };
     static const char *const opStrings[] = { "delete", "rename", NULL };
     enum operations { TRACE_CMD_DELETE, TRACE_CMD_RENAME };
 
     switch ((enum traceOptions) optionIndex) {
@@ -703,13 +702,13 @@
 		break;
 	    }
 	}
 
 	command = TclGetStringFromObj(objv[5], &commandLength);
-	length = commandLength;
+	length = (size_t) commandLength;
 	if ((enum traceOptions) optionIndex == TRACE_ADD) {
-	    TraceCommandInfo *tcmdPtr = Tcl_Alloc(
+	    TraceCommandInfo *tcmdPtr = ckalloc(
 		    offsetof(TraceCommandInfo, command) + 1 + length);
 
 	    tcmdPtr->flags = flags;
 	    tcmdPtr->stepTrace = NULL;
 	    tcmdPtr->startLevel = 0;
@@ -716,14 +715,14 @@
 	    tcmdPtr->startCmd = NULL;
 	    tcmdPtr->length = length;
 	    tcmdPtr->refCount = 1;
 	    flags |= TCL_TRACE_DELETE;
 	    memcpy(tcmdPtr->command, command, length+1);
-	    name = TclGetString(objv[3]);
+	    name = Tcl_GetString(objv[3]);
 	    if (Tcl_TraceCommand(interp, name, flags, TraceCommandProc,
 		    tcmdPtr) != TCL_OK) {
-		Tcl_Free(tcmdPtr);
+		ckfree(tcmdPtr);
 		return TCL_ERROR;
 	    }
 	} else {
 	    /*
 	     * Search through all of our traces on this command to see if
@@ -735,26 +734,26 @@
 
 	    /*
 	     * First ensure the name given is valid.
 	     */
 
-	    name = TclGetString(objv[3]);
+	    name = Tcl_GetString(objv[3]);
 	    if (Tcl_FindCommand(interp,name,NULL,TCL_LEAVE_ERR_MSG) == NULL) {
 		return TCL_ERROR;
 	    }
 
 	    FOREACH_COMMAND_TRACE(interp, name, clientData) {
 		TraceCommandInfo *tcmdPtr = clientData;
 
 		if ((tcmdPtr->length == length) && (tcmdPtr->flags == flags)
 			&& (strncmp(command, tcmdPtr->command,
-				length) == 0)) {
+				(size_t) length) == 0)) {
 		    Tcl_UntraceCommand(interp, name, flags | TCL_TRACE_DELETE,
 			    TraceCommandProc, clientData);
 		    tcmdPtr->flags |= TCL_TRACE_DESTROYED;
 		    if (tcmdPtr->refCount-- <= 1) {
-			Tcl_Free(tcmdPtr);
+			ckfree(tcmdPtr);
 		    }
 		    break;
 		}
 	    }
 	}
@@ -771,11 +770,11 @@
 
 	/*
 	 * First ensure the name given is valid.
 	 */
 
-	name = TclGetString(objv[3]);
+	name = Tcl_GetString(objv[3]);
 	if (Tcl_FindCommand(interp, name, NULL, TCL_LEAVE_ERR_MSG) == NULL) {
 	    return TCL_ERROR;
 	}
 
 	resultListPtr = Tcl_NewListObj(0, NULL);
@@ -844,13 +843,13 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int optionIndex,		/* Add, info or remove */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    int index;
+    int commandLength, index;
     const char *name, *command;
-    size_t commandLength, length;
+    size_t length;
     ClientData clientData;
     enum traceOptions { TRACE_ADD, TRACE_INFO, TRACE_REMOVE };
     static const char *const opStrings[] = {
 	"array", "read", "unset", "write", NULL
     };
@@ -906,13 +905,13 @@
 		flags |= TCL_TRACE_WRITES;
 		break;
 	    }
 	}
 	command = TclGetStringFromObj(objv[5], &commandLength);
-	length = commandLength;
+	length = (size_t) commandLength;
 	if ((enum traceOptions) optionIndex == TRACE_ADD) {
-	    CombinedTraceVarInfo *ctvarPtr = Tcl_Alloc(
+	    CombinedTraceVarInfo *ctvarPtr = ckalloc(
 		    offsetof(CombinedTraceVarInfo, traceCmdInfo.command)
 		    + 1 + length);
 
 	    ctvarPtr->traceCmdInfo.flags = flags;
 #ifndef TCL_REMOVE_OBSOLETE_TRACES
@@ -924,24 +923,24 @@
 	    flags |= TCL_TRACE_UNSETS | TCL_TRACE_RESULT_OBJECT;
 	    memcpy(ctvarPtr->traceCmdInfo.command, command, length+1);
 	    ctvarPtr->traceInfo.traceProc = TraceVarProc;
 	    ctvarPtr->traceInfo.clientData = &ctvarPtr->traceCmdInfo;
 	    ctvarPtr->traceInfo.flags = flags;
-	    name = TclGetString(objv[3]);
+	    name = Tcl_GetString(objv[3]);
 	    if (TraceVarEx(interp, name, NULL, (VarTrace *) ctvarPtr)
 		    != TCL_OK) {
-		Tcl_Free(ctvarPtr);
+		ckfree(ctvarPtr);
 		return TCL_ERROR;
 	    }
 	} else {
 	    /*
 	     * Search through all of our traces on this variable to see if
 	     * there's one with the given command. If so, then delete the
 	     * first one that matches.
 	     */
 
-	    name = TclGetString(objv[3]);
+	    name = Tcl_GetString(objv[3]);
 	    FOREACH_VAR_TRACE(interp, name, clientData) {
 		TraceVarInfo *tvarPtr = clientData;
 
 		if ((tvarPtr->length == length)
 			&& ((tvarPtr->flags
@@ -948,11 +947,11 @@
 #ifndef TCL_REMOVE_OBSOLETE_TRACES
 & ~TCL_TRACE_OLD_STYLE
 #endif
 						)==flags)
 			&& (strncmp(command, tvarPtr->command,
-				length) == 0)) {
+				(size_t) length) == 0)) {
 		    Tcl_UntraceVar2(interp, name, NULL,
 			    flags | TCL_TRACE_UNSETS | TCL_TRACE_RESULT_OBJECT,
 			    TraceVarProc, clientData);
 		    break;
 		}
@@ -967,11 +966,11 @@
 	    Tcl_WrongNumArgs(interp, 3, objv, "name");
 	    return TCL_ERROR;
 	}
 
 	resultListPtr = Tcl_NewObj();
-	name = TclGetString(objv[3]);
+	name = Tcl_GetString(objv[3]);
 	FOREACH_VAR_TRACE(interp, name, clientData) {
 	    Tcl_Obj *opObjPtr, *eachTraceObjPtr, *elemObjPtr;
 	    TraceVarInfo *tvarPtr = clientData;
 
 	    /*
@@ -1048,11 +1047,11 @@
 				 * this function, so this call will return the
 				 * next trace after that one. If NULL, this
 				 * call will return the first trace. */
 {
     Command *cmdPtr;
-    register CommandTrace *tracePtr;
+    CommandTrace *tracePtr;
 
     cmdPtr = (Command *) Tcl_FindCommand(interp, cmdName, NULL,
 	    TCL_LEAVE_ERR_MSG);
     if (cmdPtr == NULL) {
 	return NULL;
@@ -1113,11 +1112,11 @@
     Tcl_CommandTraceProc *proc,	/* Function to call when specified ops are
 				 * invoked upon cmdName. */
     ClientData clientData)	/* Arbitrary argument to pass to proc. */
 {
     Command *cmdPtr;
-    register CommandTrace *tracePtr;
+    CommandTrace *tracePtr;
 
     cmdPtr = (Command *) Tcl_FindCommand(interp, cmdName, NULL,
 	    TCL_LEAVE_ERR_MSG);
     if (cmdPtr == NULL) {
 	return TCL_ERROR;
@@ -1125,11 +1124,11 @@
 
     /*
      * Set up trace information.
      */
 
-    tracePtr = Tcl_Alloc(sizeof(CommandTrace));
+    tracePtr = ckalloc(sizeof(CommandTrace));
     tracePtr->traceProc = proc;
     tracePtr->clientData = clientData;
     tracePtr->flags = flags &
 	    (TCL_TRACE_RENAME | TCL_TRACE_DELETE | TCL_TRACE_ANY_EXEC);
     tracePtr->nextPtr = cmdPtr->tracePtr;
@@ -1176,11 +1175,11 @@
 				 * TCL_TRACE_RENAME, TCL_TRACE_DELETE, and any
 				 * of the TRACE_*_EXEC flags */
     Tcl_CommandTraceProc *proc,	/* Function assocated with trace. */
     ClientData clientData)	/* Arbitrary argument to pass to proc. */
 {
-    register CommandTrace *tracePtr;
+    CommandTrace *tracePtr;
     CommandTrace *prevPtr;
     Command *cmdPtr;
     Interp *iPtr = (Interp *) interp;
     ActiveCommandTrace *activePtr;
     int hasExecTraces = 0;
@@ -1231,11 +1230,11 @@
 	prevPtr->nextPtr = tracePtr->nextPtr;
     }
     tracePtr->flags = 0;
 
     if (tracePtr->refCount-- <= 1) {
-	Tcl_Free(tracePtr);
+	ckfree(tracePtr);
     }
 
     if (hasExecTraces) {
 	for (tracePtr = cmdPtr->tracePtr, prevPtr = NULL; tracePtr != NULL ;
 		prevPtr = tracePtr, tracePtr = tracePtr->nextPtr) {
@@ -1304,11 +1303,11 @@
 	 * Generate a command to execute by appending list elements for the
 	 * old and new command name and the operation.
 	 */
 
 	Tcl_DStringInit(&cmd);
-	Tcl_DStringAppend(&cmd, tcmdPtr->command, tcmdPtr->length);
+	Tcl_DStringAppend(&cmd, tcmdPtr->command, (int) tcmdPtr->length);
 	Tcl_DStringAppendElement(&cmd, oldName);
 	Tcl_DStringAppendElement(&cmd, (newName ? newName : ""));
 	if (flags & TCL_TRACE_RENAME) {
 	    TclDStringAppendLiteral(&cmd, " rename");
 	} else if (flags & TCL_TRACE_DELETE) {
@@ -1346,11 +1345,11 @@
 	Tcl_InterpState state;
 
 	if (tcmdPtr->stepTrace != NULL) {
 	    Tcl_DeleteTrace(interp, tcmdPtr->stepTrace);
 	    tcmdPtr->stepTrace = NULL;
-	    Tcl_Free(tcmdPtr->startCmd);
+	    ckfree(tcmdPtr->startCmd);
 	}
 	if (tcmdPtr->flags & TCL_TRACE_EXEC_IN_PROGRESS) {
 	    /*
 	     * Postpone deletion, until exec trace returns.
 	     */
@@ -1388,11 +1387,11 @@
 		TraceCommandProc, clientData);
 	Tcl_RestoreInterpState(interp, state);
 	tcmdPtr->refCount--;
     }
     if (tcmdPtr->refCount-- <= 1) {
-	Tcl_Free(tcmdPtr);
+	ckfree(tcmdPtr);
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1422,11 +1421,11 @@
 int
 TclCheckExecutionTraces(
     Tcl_Interp *interp,		/* The current interpreter. */
     const char *command,	/* Pointer to beginning of the current command
 				 * string. */
-    size_t numChars,		/* The number of characters in 'command' which
+    int numChars,		/* The number of characters in 'command' which
 				 * are part of the command string. */
     Command *cmdPtr,		/* Points to command's Command struct. */
     int code,			/* The current result code. */
     int traceFlags,		/* Current tracing situation. */
     int objc,			/* Number of arguments for the command. */
@@ -1480,11 +1479,11 @@
 		    state = Tcl_SaveInterpState(interp, code);
 		}
 		traceCode = TraceExecutionProc(tcmdPtr, interp, curLevel,
 			command, (Tcl_Command) cmdPtr, objc, objv);
 		if (tcmdPtr->refCount-- <= 1) {
-		    Tcl_Free(tcmdPtr);
+		    ckfree(tcmdPtr);
 		}
 	    }
 	}
 	if (active.nextTracePtr) {
 	    lastTracePtr = active.nextTracePtr->nextPtr;
@@ -1528,11 +1527,11 @@
 int
 TclCheckInterpTraces(
     Tcl_Interp *interp,		/* The current interpreter. */
     const char *command,	/* Pointer to beginning of the current command
 				 * string. */
-    size_t numChars,		/* The number of characters in 'command' which
+    int numChars,		/* The number of characters in 'command' which
 				 * are part of the command string. */
     Command *cmdPtr,		/* Points to command's Command struct. */
     int code,			/* The current result code. */
     int traceFlags,		/* Current tracing situation. */
     int objc,			/* Number of arguments for the command. */
@@ -1671,17 +1670,17 @@
  */
 
 static int
 CallTraceFunction(
     Tcl_Interp *interp,		/* The current interpreter. */
-    register Trace *tracePtr,	/* Describes the trace function to call. */
+    Trace *tracePtr,	/* Describes the trace function to call. */
     Command *cmdPtr,		/* Points to command's Command struct. */
     const char *command,	/* Points to the first character of the
 				 * command's source before substitutions. */
-    size_t numChars,		/* The number of characters in the command's
+    int numChars,		/* The number of characters in the command's
 				 * source. */
-    register int objc,		/* Number of arguments for the command. */
+    int objc,		/* Number of arguments for the command. */
     Tcl_Obj *const objv[])	/* Pointers to Tcl_Obj of each argument. */
 {
     Interp *iPtr = (Interp *) interp;
     char *commandCopy;
     int traceCode;
@@ -1727,11 +1726,11 @@
     ClientData clientData)
 {
     TraceCommandInfo *tcmdPtr = clientData;
 
     if (tcmdPtr->refCount-- <= 1) {
-	Tcl_Free(tcmdPtr);
+	ckfree(tcmdPtr);
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1809,11 +1808,11 @@
 	if ((flags & TCL_TRACE_LEAVE_EXEC) && (tcmdPtr->stepTrace != NULL)
 		&& (level == tcmdPtr->startLevel)
 		&& (strcmp(command, tcmdPtr->startCmd) == 0)) {
 	    Tcl_DeleteTrace(interp, tcmdPtr->stepTrace);
 	    tcmdPtr->stepTrace = NULL;
-	    Tcl_Free(tcmdPtr->startCmd);
+	    ckfree(tcmdPtr->startCmd);
 	}
 
 	/*
 	 * Second, create the tcl callback, if required.
 	 */
@@ -1821,19 +1820,19 @@
 	if (call) {
 	    Tcl_DString cmd, sub;
 	    int i, saveInterpFlags;
 
 	    Tcl_DStringInit(&cmd);
-	    Tcl_DStringAppend(&cmd, tcmdPtr->command, tcmdPtr->length);
+	    Tcl_DStringAppend(&cmd, tcmdPtr->command, (int)tcmdPtr->length);
 
 	    /*
 	     * Append command with arguments.
 	     */
 
 	    Tcl_DStringInit(&sub);
 	    for (i = 0; i < objc; i++) {
-		Tcl_DStringAppendElement(&sub, TclGetString(objv[i]));
+		Tcl_DStringAppendElement(&sub, Tcl_GetString(objv[i]));
 	    }
 	    Tcl_DStringAppendElement(&cmd, Tcl_DStringValue(&sub));
 	    Tcl_DStringFree(&sub);
 
 	    if (flags & TCL_TRACE_ENTER_EXEC) {
@@ -1853,11 +1852,11 @@
 		/*
 		 * Append result code.
 		 */
 
 		resultCode = Tcl_NewIntObj(code);
-		resultCodeStr = TclGetString(resultCode);
+		resultCodeStr = Tcl_GetString(resultCode);
 		Tcl_DStringAppendElement(&cmd, resultCodeStr);
 		Tcl_DecrRefCount(resultCode);
 
 		/*
 		 * Append result string.
@@ -1919,14 +1918,14 @@
 	 */
 
 	if ((flags & TCL_TRACE_ENTER_EXEC) && (tcmdPtr->stepTrace == NULL)
 		&& (tcmdPtr->flags & (TCL_TRACE_ENTER_DURING_EXEC |
 			TCL_TRACE_LEAVE_DURING_EXEC))) {
-	    register unsigned len = strlen(command) + 1;
+	    size_t len = strlen(command) + 1;
 
 	    tcmdPtr->startLevel = level;
-	    tcmdPtr->startCmd = Tcl_Alloc(len);
+	    tcmdPtr->startCmd = ckalloc(len);
 	    memcpy(tcmdPtr->startCmd, command, len);
 	    tcmdPtr->refCount++;
 	    tcmdPtr->stepTrace = Tcl_CreateObjTrace(interp, 0,
 		   (tcmdPtr->flags & TCL_TRACE_ANY_EXEC) >> 2,
 		   TraceExecutionProc, tcmdPtr, CommandObjTraceDeleted);
@@ -1934,16 +1933,16 @@
     }
     if (flags & TCL_TRACE_DESTROYED) {
 	if (tcmdPtr->stepTrace != NULL) {
 	    Tcl_DeleteTrace(interp, tcmdPtr->stepTrace);
 	    tcmdPtr->stepTrace = NULL;
-	    Tcl_Free(tcmdPtr->startCmd);
+	    ckfree(tcmdPtr->startCmd);
 	}
     }
     if (call) {
 	if (tcmdPtr->refCount-- <= 1) {
-	    Tcl_Free(tcmdPtr);
+	    ckfree(tcmdPtr);
 	}
     }
     return traceCode;
 }
 
@@ -1990,18 +1989,18 @@
      */
 
     result = NULL;
     if ((tvarPtr->flags & flags) && !Tcl_InterpDeleted(interp)
 	    && !Tcl_LimitExceeded(interp)) {
-	if (tvarPtr->length) {
+	if (tvarPtr->length != (size_t) 0) {
 	    /*
 	     * Generate a command to execute by appending list elements for
 	     * the two variable names and the operation.
 	     */
 
 	    Tcl_DStringInit(&cmd);
-	    Tcl_DStringAppend(&cmd, tvarPtr->command, tvarPtr->length);
+	    Tcl_DStringAppend(&cmd, tvarPtr->command, (int) tvarPtr->length);
 	    Tcl_DStringAppendElement(&cmd, name1);
 	    Tcl_DStringAppendElement(&cmd, (name2 ? name2 : ""));
 #ifndef TCL_REMOVE_OBSOLETE_TRACES
 	    if (tvarPtr->flags & TCL_TRACE_OLD_STYLE) {
 		if (flags & TCL_TRACE_ARRAY) {
@@ -2064,11 +2063,11 @@
 	    }
 	    Tcl_DStringFree(&cmd);
 	}
     }
     if (destroy && result != NULL) {
-	register Tcl_Obj *errMsgObj = (Tcl_Obj *) result;
+	Tcl_Obj *errMsgObj = (Tcl_Obj *) result;
 
 	Tcl_DecrRefCount(errMsgObj);
 	result = NULL;
     }
     return result;
@@ -2141,12 +2140,12 @@
     Tcl_CmdObjTraceProc *proc,	/* Trace callback */
     ClientData clientData,	/* Client data for the callback */
     Tcl_CmdObjTraceDeleteProc *delProc)
 				/* Function to call when trace is deleted */
 {
-    register Trace *tracePtr;
-    register Interp *iPtr = (Interp *) interp;
+    Trace *tracePtr;
+    Interp *iPtr = (Interp *) interp;
 
     /*
      * Test if this trace allows inline compilation of commands.
      */
 
@@ -2166,11 +2165,11 @@
 	    iPtr->flags |= DONT_COMPILE_CMDS_INLINE;
 	}
 	iPtr->tracesForbiddingInline++;
     }
 
-    tracePtr = Tcl_Alloc(sizeof(Trace));
+    tracePtr = ckalloc(sizeof(Trace));
     tracePtr->level = level;
     tracePtr->proc = proc;
     tracePtr->clientData = clientData;
     tracePtr->delProc = delProc;
     tracePtr->nextPtr = iPtr->tracePtr;
@@ -2229,11 +2228,11 @@
 				 * level<=argument level (1=>top level). */
     Tcl_CmdTraceProc *proc,	/* Function to call before executing each
 				 * command. */
     ClientData clientData)	/* Arbitrary value word to pass to proc. */
 {
-    StringTraceData *data = Tcl_Alloc(sizeof(StringTraceData));
+    StringTraceData *data = ckalloc(sizeof(StringTraceData));
 
     data->clientData = clientData;
     data->proc = proc;
     return Tcl_CreateObjTrace(interp, level, 0, StringTraceProc,
 	    data, StringTraceDeleteProc);
@@ -2276,11 +2275,11 @@
      */
 
     argv = (const char **) TclStackAlloc(interp,
 	    (objc + 1) * sizeof(const char *));
     for (i = 0; i < objc; i++) {
-	argv[i] = TclGetString(objv[i]);
+	argv[i] = Tcl_GetString(objv[i]);
     }
     argv[objc] = 0;
 
     /*
      * Invoke the command function. Note that we cast away const-ness on two
@@ -2313,11 +2312,11 @@
 
 static void
 StringTraceDeleteProc(
     ClientData clientData)
 {
-    Tcl_Free(clientData);
+    ckfree(clientData);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -2341,11 +2340,11 @@
     Tcl_Trace trace)		/* Token for trace (returned previously by
 				 * Tcl_CreateTrace). */
 {
     Interp *iPtr = (Interp *) interp;
     Trace *prevPtr, *tracePtr = (Trace *) trace;
-    register Trace **tracePtr2 = &iPtr->tracePtr;
+    Trace **tracePtr2 = &iPtr->tracePtr;
     ActiveInterpTrace *activePtr;
 
     /*
      * Locate the trace entry in the interpreter's trace list, and remove it
      * from the list.
@@ -2533,11 +2532,11 @@
  */
 
 int
 TclObjCallVarTraces(
     Interp *iPtr,		/* Interpreter containing variable. */
-    register Var *arrayPtr,	/* Pointer to array variable that contains the
+    Var *arrayPtr,	/* Pointer to array variable that contains the
 				 * variable, or NULL if the variable isn't an
 				 * element of an array. */
     Var *varPtr,		/* Variable whose traces are to be invoked. */
     Tcl_Obj *part1Ptr,
     Tcl_Obj *part2Ptr,		/* Variable's two-part name. */
@@ -2567,11 +2566,11 @@
 }
 
 int
 TclCallVarTraces(
     Interp *iPtr,		/* Interpreter containing variable. */
-    register Var *arrayPtr,	/* Pointer to array variable that contains the
+    Var *arrayPtr,	/* Pointer to array variable that contains the
 				 * variable, or NULL if the variable isn't an
 				 * element of an array. */
     Var *varPtr,		/* Variable whose traces are to be invoked. */
     const char *part1,
     const char *part2,		/* Variable's two-part name. */
@@ -2580,11 +2579,11 @@
 				 * TCL_GLOBAL_ONLY or TCL_NAMESPACE_ONLY */
     int leaveErrMsg)		/* If true, and one of the traces indicates an
 				 * error, then leave an error message and
 				 * stack trace information in *iPTr. */
 {
-    register VarTrace *tracePtr;
+    VarTrace *tracePtr;
     ActiveVarTrace active;
     char *result;
     const char *openParen, *p;
     Tcl_DString nameCopy;
     int copiedName;
@@ -2779,11 +2778,11 @@
 		    "\n    (%s trace on \"%s%s%s%s\")", type, part1,
 		    (part2 ? "(" : ""), (part2 ? part2 : ""),
 		    (part2 ? ")" : "") ));
 	    if (disposeFlags & TCL_TRACE_RESULT_OBJECT) {
 		TclVarErrMsg((Tcl_Interp *) iPtr, part1, part2, verb,
-			TclGetString((Tcl_Obj *) result));
+			Tcl_GetString((Tcl_Obj *) result));
 	    } else {
 		TclVarErrMsg((Tcl_Interp *) iPtr, part1, part2, verb, result);
 	    }
 	    iPtr->flags &= ~(ERR_ALREADY_LOGGED);
 	    Tcl_DiscardInterpState(state);
@@ -2838,16 +2837,51 @@
 				 * proper disposal method. */
     char *result)		/* The result returned from a trace function
 				 * to be disposed. */
 {
     if (flags & TCL_TRACE_RESULT_DYNAMIC) {
-	Tcl_Free(result);
+	ckfree(result);
     } else if (flags & TCL_TRACE_RESULT_OBJECT) {
 	Tcl_DecrRefCount((Tcl_Obj *) result);
     }
 }
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_UntraceVar --
+ *
+ *	Remove a previously-created trace for a variable.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	If there exists a trace for the variable given by varName with the
+ *	given flags, proc, and clientData, then that trace is removed.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_UntraceVar
+void
+Tcl_UntraceVar(
+    Tcl_Interp *interp,		/* Interpreter containing variable. */
+    const char *varName,	/* Name of variable; may end with "(index)" to
+				 * signify an array reference. */
+    int flags,			/* OR-ed collection of bits describing current
+				 * trace, including any of TCL_TRACE_READS,
+				 * TCL_TRACE_WRITES, TCL_TRACE_UNSETS,
+				 * TCL_GLOBAL_ONLY and TCL_NAMESPACE_ONLY. */
+    Tcl_VarTraceProc *proc,	/* Function assocated with trace. */
+    ClientData clientData)	/* Arbitrary argument to pass to proc. */
+{
+    Tcl_UntraceVar2(interp, varName, NULL, flags, proc, clientData);
+}
+#endif /* TCL_NO_DEPRECATED */
+
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_UntraceVar2 --
  *
@@ -2875,11 +2909,11 @@
 				 * TCL_TRACE_WRITES, TCL_TRACE_UNSETS,
 				 * TCL_GLOBAL_ONLY, and TCL_NAMESPACE_ONLY. */
     Tcl_VarTraceProc *proc,	/* Function assocated with trace. */
     ClientData clientData)	/* Arbitrary argument to pass to proc. */
 {
-    register VarTrace *tracePtr;
+    VarTrace *tracePtr;
     VarTrace *prevPtr, *nextPtr;
     Var *varPtr, *arrayPtr;
     Interp *iPtr = (Interp *) interp;
     ActiveVarTrace *activePtr;
     int flagMask, allFlags = 0;
@@ -2977,10 +3011,53 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
+ * Tcl_VarTraceInfo --
+ *
+ *	Return the clientData value associated with a trace on a variable.
+ *	This function can also be used to step through all of the traces on a
+ *	particular variable that have the same trace function.
+ *
+ * Results:
+ *	The return value is the clientData value associated with a trace on
+ *	the given variable. Information will only be returned for a trace with
+ *	proc as trace function. If the clientData argument is NULL then the
+ *	first such trace is returned; otherwise, the next relevant one after
+ *	the one given by clientData will be returned. If the variable doesn't
+ *	exist, or if there are no (more) traces for it, then NULL is returned.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_VarTraceInfo
+ClientData
+Tcl_VarTraceInfo(
+    Tcl_Interp *interp,		/* Interpreter containing variable. */
+    const char *varName,	/* Name of variable; may end with "(index)" to
+				 * signify an array reference. */
+    int flags,			/* OR-ed combo or TCL_GLOBAL_ONLY,
+				 * TCL_NAMESPACE_ONLY (can be 0). */
+    Tcl_VarTraceProc *proc,	/* Function assocated with trace. */
+    ClientData prevClientData)	/* If non-NULL, gives last value returned by
+				 * this function, so this call will return the
+				 * next trace after that one. If NULL, this
+				 * call will return the first trace. */
+{
+    return Tcl_VarTraceInfo2(interp, varName, NULL, flags, proc,
+	    prevClientData);
+}
+#endif /* TCL_NO_DEPRECATED */
+
+/*
+ *----------------------------------------------------------------------
+ *
  * Tcl_VarTraceInfo2 --
  *
  *	Same as Tcl_VarTraceInfo, except takes name in two pieces instead of
  *	one.
  *
@@ -3024,11 +3101,11 @@
      */
 
     hPtr = Tcl_FindHashEntry(&iPtr->varTraces, (char *) varPtr);
 
     if (hPtr) {
-	register VarTrace *tracePtr = Tcl_GetHashValue(hPtr);
+	VarTrace *tracePtr = Tcl_GetHashValue(hPtr);
 
 	if (prevClientData != NULL) {
 	    for (; tracePtr != NULL; tracePtr = tracePtr->nextPtr) {
 		if ((tracePtr->clientData == prevClientData)
 			&& (tracePtr->traceProc == proc)) {
@@ -3044,10 +3121,51 @@
 	}
     }
     return NULL;
 }
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_TraceVar --
+ *
+ *	Arrange for reads and/or writes to a variable to cause a function to
+ *	be invoked, which can monitor the operations and/or change their
+ *	actions.
+ *
+ * Results:
+ *	A standard Tcl return value.
+ *
+ * Side effects:
+ *	A trace is set up on the variable given by varName, such that future
+ *	references to the variable will be intermediated by proc. See the
+ *	manual entry for complete details on the calling sequence for proc.
+ *     The variable's flags are updated.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_TraceVar
+int
+Tcl_TraceVar(
+    Tcl_Interp *interp,		/* Interpreter in which variable is to be
+				 * traced. */
+    const char *varName,	/* Name of variable; may end with "(index)" to
+				 * signify an array reference. */
+    int flags,			/* OR-ed collection of bits, including any of
+				 * TCL_TRACE_READS, TCL_TRACE_WRITES,
+				 * TCL_TRACE_UNSETS, TCL_GLOBAL_ONLY, and
+				 * TCL_NAMESPACE_ONLY. */
+    Tcl_VarTraceProc *proc,	/* Function to call when specified ops are
+				 * invoked upon varName. */
+    ClientData clientData)	/* Arbitrary argument to pass to proc. */
+{
+    return Tcl_TraceVar2(interp, varName, NULL, flags, proc, clientData);
+}
+#endif /* TCL_NO_DEPRECATED */
+
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_TraceVar2 --
  *
@@ -3081,22 +3199,22 @@
 				 * TCL_NAMESPACE_ONLY. */
     Tcl_VarTraceProc *proc,	/* Function to call when specified ops are
 				 * invoked upon varName. */
     ClientData clientData)	/* Arbitrary argument to pass to proc. */
 {
-    register VarTrace *tracePtr;
+    VarTrace *tracePtr;
     int result;
 
-    tracePtr = Tcl_Alloc(sizeof(VarTrace));
+    tracePtr = ckalloc(sizeof(VarTrace));
     tracePtr->traceProc = proc;
     tracePtr->clientData = clientData;
     tracePtr->flags = flags;
 
     result = TraceVarEx(interp, part1, part2, tracePtr);
 
     if (result != TCL_OK) {
-	Tcl_Free(tracePtr);
+	ckfree(tracePtr);
     }
     return result;
 }
 
 /*
@@ -3126,13 +3244,13 @@
 				 * traced. */
     const char *part1,		/* Name of scalar variable or array. */
     const char *part2,		/* Name of element within array; NULL means
 				 * trace applies to scalar variable or array
 				 * as-a-whole. */
-    register VarTrace *tracePtr)/* Structure containing flags, traceProc and
+    VarTrace *tracePtr)/* Structure containing flags, traceProc and
 				 * clientData fields. Others should be left
-				 * blank. Will be Tcl_Free()d (eventually) if
+				 * blank. Will be ckfree()d (eventually) if
 				 * this function returns TCL_OK, and up to
 				 * caller to free if this function returns
 				 * TCL_ERROR. */
 {
     Interp *iPtr = (Interp *) interp;

Index: generic/tclUtf.c
==================================================================
--- generic/tclUtf.c
+++ generic/tclUtf.c
@@ -84,11 +84,11 @@
  *	None.
  *
  *---------------------------------------------------------------------------
  */
 
-size_t
+int
 TclUtfCount(
     int ch)			/* The Unicode character whose size is returned. */
 {
     if ((unsigned)(ch - 1) < (UNICODE_SELF - 1)) {
 	return 1;
@@ -222,19 +222,18 @@
  */
 
 char *
 Tcl_UniCharToUtfDString(
     const Tcl_UniChar *uniStr,	/* Unicode string to convert to UTF-8. */
-    size_t uniLength,		/* Length of Unicode string in Tcl_UniChars
+    int uniLength,		/* Length of Unicode string in Tcl_UniChars
 				 * (must be >= 0). */
     Tcl_DString *dsPtr)		/* UTF-8 representation of string is appended
 				 * to this previously initialized DString. */
 {
     const Tcl_UniChar *w, *wEnd;
     char *p, *string;
-    size_t oldLength;
-    int len = 1;
+    int oldLength, len = 1;
 
     /*
      * UTF-8 string length in bytes will be <= Unicode string length * 4.
      */
 
@@ -351,12 +350,12 @@
    0x2DC, 0x2122, 0x0161, 0x203A, 0x0153,   0x9D, 0x017E, 0x0178
 };
 
 int
 Tcl_UtfToUniChar(
-    register const char *src,	/* The UTF-8 string. */
-    register Tcl_UniChar *chPtr)/* Filled with the Tcl_UniChar represented by
+    const char *src,	/* The UTF-8 string. */
+    Tcl_UniChar *chPtr)/* Filled with the Tcl_UniChar represented by
 				 * the UTF-8 string. */
 {
     Tcl_UniChar byte;
 
     /*
@@ -582,21 +581,21 @@
  */
 
 Tcl_UniChar *
 Tcl_UtfToUniCharDString(
     const char *src,		/* UTF-8 string to convert to Unicode. */
-    size_t length,			/* Length of UTF-8 string in bytes, or -1 for
+    int length,			/* Length of UTF-8 string in bytes, or -1 for
 				 * strlen(). */
     Tcl_DString *dsPtr)		/* Unicode representation of string is
 				 * appended to this previously initialized
 				 * DString. */
 {
     Tcl_UniChar ch = 0, *w, *wString;
     const char *p, *end;
-    size_t oldLength;
+    int oldLength;
 
-    if (length == TCL_AUTO_LENGTH) {
+    if (length < 0) {
 	length = strlen(src);
     }
 
     /*
      * Unicode string length in Tcl_UniChars will be <= UTF-8 string length in
@@ -705,13 +704,13 @@
 
 int
 Tcl_UtfCharComplete(
     const char *src,		/* String to check if first few bytes contain
 				 * a complete UTF-8 character. */
-    size_t length)			/* Length of above string in bytes. */
+    int length)			/* Length of above string in bytes. */
 {
-   return length >= totalBytes[(unsigned char)*src];
+    return length >= totalBytes[(unsigned char)*src];
 }
 
 /*
  *---------------------------------------------------------------------------
  *
@@ -728,33 +727,34 @@
  *	None.
  *
  *---------------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_NumUtfChars(
-    register const char *src,	/* The UTF-8 string to measure. */
-    size_t length)			/* The length of the string in bytes, or -1
+    const char *src,	/* The UTF-8 string to measure. */
+    int length)			/* The length of the string in bytes, or -1
 				 * for strlen(string). */
 {
     Tcl_UniChar ch = 0;
-    register size_t i = 0;
+    int i = 0;
 
     /*
      * The separate implementations are faster.
      *
      * Since this is a time-sensitive function, we also do the check for the
      * single-byte char case specially.
      */
 
-    if (length == TCL_AUTO_LENGTH) {
+    if (length < 0) {
 	while (*src != '\0') {
 	    src += TclUtfToUniChar(src, &ch);
 	    i++;
 	}
+	if (i < 0) i = INT_MAX; /* Bug [2738427] */
     } else {
-	register const char *endPtr = src + length - 4;
+	const char *endPtr = src + length - 4;
 
 	while (src < endPtr) {
 	    src += TclUtfToUniChar(src, &ch);
 	    i++;
 	}
@@ -792,12 +792,11 @@
 const char *
 Tcl_UtfFindFirst(
     const char *src,		/* The UTF-8 string to be searched. */
     int ch)			/* The Unicode character to search for. */
 {
-    size_t len;
-    int fullchar;
+    int len, fullchar;
     Tcl_UniChar find = 0;
 
     while (1) {
 	len = TclUtfToUniChar(src, &find);
 	fullchar = find;
@@ -839,12 +838,11 @@
 const char *
 Tcl_UtfFindLast(
     const char *src,		/* The UTF-8 string to be searched. */
     int ch)			/* The Unicode character to search for. */
 {
-    size_t len;
-    int fullchar;
+    int len, fullchar;
     Tcl_UniChar find = 0;
     const char *last;
 
     last = NULL;
     while (1) {
@@ -889,11 +887,11 @@
 const char *
 Tcl_UtfNext(
     const char *src)		/* The current location in the string. */
 {
     Tcl_UniChar ch = 0;
-    size_t len = TclUtfToUniChar(src, &ch);
+    int len = TclUtfToUniChar(src, &ch);
 
 #if TCL_UTF_MAX <= 4
     if ((ch >= 0xD800) && (len < 3)) {
 	len += TclUtfToUniChar(src + len, &ch);
     }
@@ -968,21 +966,20 @@
  *---------------------------------------------------------------------------
  */
 
 int
 Tcl_UniCharAtIndex(
-    register const char *src,	/* The UTF-8 string to dereference. */
-    register size_t index)		/* The position of the desired character. */
+    const char *src,	/* The UTF-8 string to dereference. */
+    int index)		/* The position of the desired character. */
 {
     Tcl_UniChar ch = 0;
     int fullchar = 0;
 #if TCL_UTF_MAX <= 4
-	size_t len = 0;
+	int len = 0;
 #endif
 
-    src += TclUtfToUniChar(src, &ch);
-    while (index--) {
+    while (index-- >= 0) {
 #if TCL_UTF_MAX <= 4
 	src += (len = TclUtfToUniChar(src, &ch));
 #else
 	src += TclUtfToUniChar(src, &ch);
 #endif
@@ -1017,33 +1014,26 @@
  *---------------------------------------------------------------------------
  */
 
 const char *
 Tcl_UtfAtIndex(
-    register const char *src,	/* The UTF-8 string. */
-    register size_t index)		/* The position of the desired character. */
+    const char *src,	/* The UTF-8 string. */
+    int index)		/* The position of the desired character. */
 {
     Tcl_UniChar ch = 0;
-#if TCL_UTF_MAX <= 4
-    size_t len = 0;
-#endif
-
-    if (index != TCL_INDEX_NONE) {
-	while (index--) {
-#if TCL_UTF_MAX <= 4
-	    src += (len = TclUtfToUniChar(src, &ch));
-#else
-	    src += TclUtfToUniChar(src, &ch);
-#endif
-	}
+    int len = 0;
+
+    while (index-- > 0) {
+	len = TclUtfToUniChar(src, &ch);
+	src += len;
+    }
 #if TCL_UTF_MAX <= 4
     if ((ch >= 0xD800) && (len < 3)) {
 	/* Index points at character following high Surrogate */
 	src += TclUtfToUniChar(src, &ch);
     }
 #endif
-    }
     return src;
 }
 
 /*
  *---------------------------------------------------------------------------
@@ -1052,11 +1042,11 @@
  *
  *	Figure out how to handle a backslash sequence.
  *
  * Results:
  *	Stores the bytes represented by the backslash sequence in dst and
- *	returns the number of bytes written to dst. At most TCL_UTF_MAX bytes
+ *	returns the number of bytes written to dst. At most 4 bytes
  *	are written to dst; dst must have been large enough to accept those
  *	bytes. If readPtr isn't NULL then it is filled in with a count of the
  *	number of bytes in the backslash sequence.
  *
  * Side effects:
@@ -1069,29 +1059,30 @@
  *	buffer overruns should occur.
  *
  *---------------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_UtfBackslash(
     const char *src,		/* Points to the backslash character of a
 				 * backslash sequence. */
     int *readPtr,		/* Fill in with number of characters read from
 				 * src, unless NULL. */
     char *dst)			/* Filled with the bytes represented by the
 				 * backslash sequence. */
 {
 #define LINE_LENGTH 128
-    size_t numRead, result;
+    int numRead;
+    int result;
 
     result = TclParseBackslash(src, LINE_LENGTH, &numRead, dst);
     if (numRead == LINE_LENGTH) {
 	/*
 	 * We ate a whole line. Pay the price of a strlen()
 	 */
 
-	result = TclParseBackslash(src, strlen(src), &numRead, dst);
+	result = TclParseBackslash(src, (int)strlen(src), &numRead, dst);
     }
     if (readPtr != NULL) {
 	*readPtr = numRead;
     }
     return result;
@@ -1120,11 +1111,11 @@
     char *str)			/* String to convert in place. */
 {
     Tcl_UniChar ch = 0;
     int upChar;
     char *src, *dst;
-    size_t len;
+    int len;
 
     /*
      * Iterate over the string until we hit the terminating null.
      */
 
@@ -1182,11 +1173,11 @@
     char *str)			/* String to convert in place. */
 {
     Tcl_UniChar ch = 0;
     int lowChar;
     char *src, *dst;
-    size_t len;
+    int len;
 
     /*
      * Iterate over the string until we hit the terminating null.
      */
 
@@ -1245,11 +1236,11 @@
     char *str)			/* String to convert in place. */
 {
     Tcl_UniChar ch = 0;
     int titleChar, lowChar;
     char *src, *dst;
-    size_t len;
+    int len;
 
     /*
      * Capitalize the first character and then lowercase the rest of the
      * characters until we get to a null.
      */
@@ -1322,19 +1313,19 @@
 
 int
 TclpUtfNcmp2(
     const char *cs,		/* UTF string to compare to ct. */
     const char *ct,		/* UTF string cs is compared to. */
-    size_t numBytes)	/* Number of *bytes* to compare. */
+    unsigned long numBytes)	/* Number of *bytes* to compare. */
 {
     /*
      * We can't simply call 'memcmp(cs, ct, numBytes);' because we need to
      * check for Tcl's \xC0\x80 non-utf-8 null encoding. Otherwise utf-8 lexes
      * fine in the strcmp manner.
      */
 
-    register int result = 0;
+    int result = 0;
 
     for ( ; numBytes != 0; numBytes--, cs++, ct++) {
 	if (*cs != *ct) {
 	    result = UCHAR(*cs) - UCHAR(*ct);
 	    break;
@@ -1369,11 +1360,11 @@
 
 int
 Tcl_UtfNcmp(
     const char *cs,		/* UTF string to compare to ct. */
     const char *ct,		/* UTF string cs is compared to. */
-    size_t numChars)	/* Number of UTF chars to compare. */
+    unsigned long numChars)	/* Number of UTF chars to compare. */
 {
     Tcl_UniChar ch1 = 0, ch2 = 0;
 
     /*
      * Cannot use 'memcmp(cs, ct, n);' as byte representation of \u0000 (the
@@ -1427,11 +1418,11 @@
 
 int
 Tcl_UtfNcasecmp(
     const char *cs,		/* UTF string to compare to ct. */
     const char *ct,		/* UTF string cs is compared to. */
-    size_t numChars)	/* Number of UTF chars to compare. */
+    unsigned long numChars)	/* Number of UTF chars to compare. */
 {
     Tcl_UniChar ch1 = 0, ch2 = 0;
 
     while (numChars-- > 0) {
 	/*
@@ -1673,15 +1664,15 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_UniCharLen(
     const Tcl_UniChar *uniStr)	/* Unicode string to find length of. */
 {
-    size_t len = 0;
+    int len = 0;
 
     while (*uniStr != '\0') {
 	len++;
 	uniStr++;
     }
@@ -1707,11 +1698,11 @@
 
 int
 Tcl_UniCharNcmp(
     const Tcl_UniChar *ucs,	/* Unicode string to compare to uct. */
     const Tcl_UniChar *uct,	/* Unicode string ucs is compared to. */
-    size_t numChars)	/* Number of unichars to compare. */
+    unsigned long numChars)	/* Number of unichars to compare. */
 {
 #ifdef WORDS_BIGENDIAN
     /*
      * We are definitely on a big-endian machine; memcmp() is safe
      */
@@ -1752,11 +1743,11 @@
 
 int
 Tcl_UniCharNcasecmp(
     const Tcl_UniChar *ucs,	/* Unicode string to compare to uct. */
     const Tcl_UniChar *uct,	/* Unicode string ucs is compared to. */
-    size_t numChars)	/* Number of unichars to compare. */
+    unsigned long numChars)	/* Number of unichars to compare. */
 {
     for ( ; numChars != 0; numChars--, ucs++, uct++) {
 	if (*ucs != *uct) {
 	    Tcl_UniChar lcs = Tcl_UniCharToLower(*ucs);
 	    Tcl_UniChar lct = Tcl_UniCharToLower(*uct);
@@ -2290,14 +2281,14 @@
  */
 
 int
 TclUniCharMatch(
     const Tcl_UniChar *string,	/* Unicode String. */
-    size_t strLen,			/* Length of String */
+    int strLen,			/* Length of String */
     const Tcl_UniChar *pattern,	/* Pattern, which may contain special
 				 * characters. */
-    size_t ptnLen,			/* Length of Pattern */
+    int ptnLen,			/* Length of Pattern */
     int nocase)			/* 0 for case sensitive, 1 for insensitive */
 {
     const Tcl_UniChar *stringEnd, *patternEnd;
     Tcl_UniChar p;
 

Index: generic/tclUtil.c
==================================================================
--- generic/tclUtil.c
+++ generic/tclUtil.c
@@ -92,10 +92,17 @@
 #define CONVERT_BRACE	2
 #define CONVERT_ESCAPE	4
 #define CONVERT_MASK	(CONVERT_BRACE | CONVERT_ESCAPE)
 #define CONVERT_ANY	16
 
+/*
+ * The following key is used by Tcl_PrintDouble and TclPrecTraceProc to
+ * access the precision to be used for double formatting.
+ */
+
+static Tcl_ThreadDataKey precisionKey;
+
 /*
  * Prototypes for functions defined later in this file.
  */
 
 static void		ClearHash(Tcl_HashTable *tablePtr);
@@ -107,11 +114,11 @@
 static int		GetWideForIndex(Tcl_Interp *interp, Tcl_Obj *objPtr,
 			    size_t endValue, Tcl_WideInt *widePtr);
 static int		FindElement(Tcl_Interp *interp, const char *string,
 			    int stringLength, const char *typeStr,
 			    const char *typeCode, const char **elementPtr,
-			    const char **nextPtr, size_t *sizePtr,
+			    const char **nextPtr, int *sizePtr,
 			    int *literalPtr);
 /*
  * The following is the Tcl object type definition for an object that
  * represents a list index in the form, "end-offset". It is used as a
  * performance optimization in Tcl_GetIntForIndex. The internal rep is
@@ -385,16 +392,16 @@
  */
 
 int
 TclMaxListLength(
     const char *bytes,
-    size_t numBytes,
+    int numBytes,
     const char **endPtr)
 {
-    size_t count = 0;
+    int count = 0;
 
-    if ((numBytes == 0) || ((numBytes == TCL_AUTO_LENGTH) && (*bytes == '\0'))) {
+    if ((numBytes == 0) || ((numBytes == -1) && (*bytes == '\0'))) {
 	/* Empty string case - quick exit */
 	goto done;
     }
 
     /*
@@ -406,11 +413,11 @@
     /*
      * Count white space runs as potential element separators.
      */
 
     while (numBytes) {
-	if ((numBytes == TCL_AUTO_LENGTH) && (*bytes == '\0')) {
+	if ((numBytes == -1) && (*bytes == '\0')) {
 	    break;
 	}
 	if (TclIsSpaceProc(*bytes)) {
 	    /*
 	     * Space run started; bump count.
@@ -417,22 +424,22 @@
 	     */
 
 	    count++;
 	    do {
 		bytes++;
-		numBytes -= (numBytes != TCL_AUTO_LENGTH);
+		numBytes -= (numBytes != -1);
 	    } while (numBytes && TclIsSpaceProc(*bytes));
-	    if ((numBytes == 0) || ((numBytes == TCL_AUTO_LENGTH) && (*bytes == '\0'))) {
+	    if ((numBytes == 0) || ((numBytes == -1) && (*bytes == '\0'))) {
 		break;
 	    }
 
 	    /*
 	     * (*bytes) is non-space; return to counting state.
 	     */
 	}
 	bytes++;
-	numBytes -= (numBytes != TCL_AUTO_LENGTH);
+	numBytes -= (numBytes != -1);
     }
 
     /*
      * No list element following trailing white space.
      */
@@ -497,11 +504,11 @@
     const char **elementPtr,	/* Where to put address of first significant
 				 * character in first element of list. */
     const char **nextPtr,	/* Fill in with location of character just
 				 * after all white space following end of
 				 * argument (next arg or end of list). */
-    size_t *sizePtr,		/* If non-zero, fill in with size of
+    int *sizePtr,		/* If non-zero, fill in with size of
 				 * element. */
     int *literalPtr)		/* If non-zero, fill in with non-zero/zero to
 				 * indicate that the substring of *sizePtr
 				 * bytes starting at **elementPtr is/is not
 				 * the literal list element and therefore
@@ -526,11 +533,11 @@
 				 * character in the first element (i.e., key
 				 * or value) of dict. */
     const char **nextPtr,	/* Fill in with location of character just
 				 * after all white space following end of
 				 * element (next arg or end of list). */
-    size_t *sizePtr,		/* If non-zero, fill in with size of
+    int *sizePtr,		/* If non-zero, fill in with size of
 				 * element. */
     int *literalPtr)		/* If non-zero, fill in with non-zero/zero to
 				 * indicate that the substring of *sizePtr
 				 * bytes starting at **elementPtr is/is not
 				 * the literal key or value and therefore
@@ -558,11 +565,11 @@
     const char **elementPtr,	/* Where to put address of first significant
 				 * character in first element. */
     const char **nextPtr,	/* Fill in with location of character just
 				 * after all white space following end of
 				 * argument (next arg or end of list/dict). */
-    size_t *sizePtr,		/* If non-zero, fill in with size of
+    int *sizePtr,		/* If non-zero, fill in with size of
 				 * element. */
     int *literalPtr)		/* If non-zero, fill in with non-zero/zero to
 				 * indicate that the substring of *sizePtr
 				 * bytes starting at **elementPtr is/is not
 				 * the literal list/dict element and therefore
@@ -573,11 +580,11 @@
     const char *elemStart;	/* Points to first byte of first element. */
     const char *limit;		/* Points just after list/dict's last byte. */
     int openBraces = 0;		/* Brace nesting level during parse. */
     int inQuotes = 0;
     int size = 0;		/* lint. */
-    size_t numChars;
+    int numChars;
     int literal = 1;
     const char *p2;
 
     /*
      * Skim off leading white space and check for an opening brace or quote.
@@ -784,24 +791,24 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 TclCopyAndCollapse(
-    size_t count,			/* Number of byte to copy from src. */
+    int count,			/* Number of byte to copy from src. */
     const char *src,		/* Copy from here... */
     char *dst)			/* ... to here. */
 {
-    size_t newCount = 0;
+    int newCount = 0;
 
     while (count > 0) {
 	char c = *src;
 
 	if (c == '\\') {
-	    size_t numRead;
-	    size_t backslashCount = TclParseBackslash(src, count, &numRead, dst);
+	    int numRead;
+	    int backslashCount = TclParseBackslash(src, count, &numRead, dst);
 
 	    dst += backslashCount;
 	    newCount += backslashCount;
 	    src += numRead;
 	    count -= numRead;
@@ -855,12 +862,11 @@
     const char ***argvPtr)	/* Pointer to place to store pointer to array
 				 * of pointers to list elements. */
 {
     const char **argv, *end, *element;
     char *p;
-    int length, size, i, result;
-    size_t elSize;
+    int length, size, i, result, elSize;
 
     /*
      * Allocate enough space to work in. A (const char *) for each (possible)
      * list element plus one more for terminating NULL, plus as many bytes as
      * in the original string value, plus one more for a terminating '\0'.
@@ -868,11 +874,11 @@
      * string gets re-purposed to hold '\0' characters in the argv array.
      */
 
     size = TclMaxListLength(list, -1, &end) + 1;
     length = end - list;
-    argv = Tcl_Alloc((size * sizeof(char *)) + length + 1);
+    argv = ckalloc((size * sizeof(char *)) + length + 1);
 
     for (i = 0, p = ((char *) argv) + size*sizeof(char *);
 	    *list != 0;  i++) {
 	const char *prevList = list;
 	int literal;
@@ -879,18 +885,18 @@
 
 	result = TclFindElement(interp, list, length, &element, &list,
 		&elSize, &literal);
 	length -= (list - prevList);
 	if (result != TCL_OK) {
-	    Tcl_Free((void *)argv);
+	    ckfree(argv);
 	    return result;
 	}
 	if (*element == 0) {
 	    break;
 	}
 	if (i >= size) {
-	    Tcl_Free((void *)argv);
+	    ckfree(argv);
 	    if (interp != NULL) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"internal error in Tcl_SplitList", -1));
 		Tcl_SetErrorCode(interp, "TCL", "INTERNAL", "Tcl_SplitList",
 			NULL);
@@ -933,15 +939,15 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_ScanElement(
     const char *src,	/* String to convert to list element. */
     int *flagPtr)	/* Where to store information to guide
-			 * Tcl_ConvertCountedElement. */
+				 * Tcl_ConvertCountedElement. */
 {
     return Tcl_ScanCountedElement(src, -1, flagPtr);
 }
 
 /*
@@ -965,14 +971,14 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_ScanCountedElement(
     const char *src,		/* String to convert to Tcl list element. */
-    size_t length,		/* Number of bytes in src, or -1. */
+    int length,			/* Number of bytes in src, or -1. */
     int *flagPtr)		/* Where to store information to guide
 				 * Tcl_ConvertElement. */
 {
     char flags = CONVERT_ANY;
     int numBytes = TclScanElement(src, length, &flags);
@@ -1009,14 +1015,14 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 TclScanElement(
     const char *src,		/* String to convert to Tcl list element. */
-    size_t length,		/* Number of bytes in src, or -1. */
+    int length,			/* Number of bytes in src, or -1. */
     char *flagPtr)		/* Where to store information to guide
 				 * Tcl_ConvertElement. */
 {
     const char *p = src;
     int nestingLevel = 0;	/* Brace nesting count */
@@ -1025,19 +1031,19 @@
     int requireEscape = 0;	/* Force use of CONVERT_ESCAPE mode.  For some
 				 * reason bare or brace-quoted form fails. */
     int extra = 0;		/* Count of number of extra bytes needed for
 				 * formatted element, assuming we use escape
 				 * sequences in formatting. */
-    size_t bytesNeeded;		/* Buffer length computed to complete the
+    int bytesNeeded;		/* Buffer length computed to complete the
 				 * element formatting in the selected mode. */
 #if COMPAT
     int preferEscape = 0;	/* Use preferences to track whether to use */
     int preferBrace = 0;	/* CONVERT_MASK mode. */
     int braceCount = 0;		/* Count of all braces '{' '}' seen. */
 #endif /* COMPAT */
 
-    if ((p == NULL) || (length == 0) || ((*p == '\0') && (length == TCL_AUTO_LENGTH))) {
+    if ((p == NULL) || (length == 0) || ((*p == '\0') && (length == -1))) {
 	/*
 	 * Empty string element must be brace quoted.
 	 */
 
 	*flagPtr = CONVERT_BRACE;
@@ -1122,11 +1128,11 @@
 	    preferBrace = 1;
 #endif /* COMPAT */
 	    break;
 	case '\\':	/* TYPE_SUBS */
 	    extra++;				/* Escape '\' => '\\' */
-	    if ((length == 1) || ((length == TCL_AUTO_LENGTH) && (p[1] == '\0'))) {
+	    if ((length == 1) || ((length == -1) && (p[1] == '\0'))) {
 		/*
 		 * Final backslash. Cannot format with brace quoting.
 		 */
 
 		requireEscape = 1;
@@ -1153,18 +1159,18 @@
 #if COMPAT
 	    preferBrace = 1;
 #endif /* COMPAT */
 	    break;
 	case '\0':	/* TYPE_SUBS */
-	    if (length == TCL_AUTO_LENGTH) {
+	    if (length == -1) {
 		goto endOfString;
 	    }
 	    /* TODO: Panic on improper encoding? */
 	    break;
 	}
       }
-	length -= (length+1 > 1);
+	length -= (length > 0);
 	p++;
     }
 
   endOfString:
     if (nestingLevel != 0) {
@@ -1195,11 +1201,11 @@
 
 	if ((*src == '#') && !(*flagPtr & TCL_DONT_QUOTE_HASH)) {
 	    bytesNeeded++;
 	}
 	*flagPtr = CONVERT_ESCAPE;
-	return bytesNeeded;
+	goto overflowCheck;
     }
     if (*flagPtr & CONVERT_ANY) {
 	/*
 	 * The caller has not let us know what flags it will pass to
 	 * TclConvertElement() so compute the max size we might need for any
@@ -1243,11 +1249,11 @@
 
 	    if (*flagPtr & TCL_DONT_USE_BRACES) {
 		bytesNeeded += braceCount;
 	    }
 	    *flagPtr = CONVERT_MASK;
-	    return bytesNeeded;
+	    goto overflowCheck;
 	}
 #endif /* COMPAT */
 	if (*flagPtr & TCL_DONT_USE_BRACES) {
 	    /*
 	     * If the caller reports it will direct TclConvertElement() to
@@ -1269,11 +1275,11 @@
 	     */
 
 	    bytesNeeded += 2;
 	}
 	*flagPtr = CONVERT_BRACE;
-	return bytesNeeded;
+	goto overflowCheck;
     }
 
     /*
      * So far, no need to quote or escape anything.
      */
@@ -1284,10 +1290,15 @@
 	 */
 
 	bytesNeeded += 2;
     }
     *flagPtr = CONVERT_NONE;
+
+  overflowCheck:
+    if (bytesNeeded < 0) {
+	Tcl_Panic("TclScanElement: string length overflow");
+    }
     return bytesNeeded;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1308,11 +1319,11 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_ConvertElement(
     const char *src,	/* Source information for list element. */
     char *dst,		/* Place to put list-ified element. */
     int flags)		/* Flags produced by Tcl_ScanElement. */
 {
@@ -1338,18 +1349,18 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 Tcl_ConvertCountedElement(
-    register const char *src,	/* Source information for list element. */
-    size_t length,		/* Number of bytes in src, or -1. */
+    const char *src,	/* Source information for list element. */
+    int length,			/* Number of bytes in src, or -1. */
     char *dst,			/* Place to put list-ified element. */
     int flags)			/* Flags produced by Tcl_ScanElement. */
 {
-    size_t numBytes = TclConvertElement(src, length, dst, flags);
+    int numBytes = TclConvertElement(src, length, dst, flags);
     dst[numBytes] = '\0';
     return numBytes;
 }
 
 /*
@@ -1371,14 +1382,14 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 TclConvertElement(
-    register const char *src,	/* Source information for list element. */
-    size_t length,		/* Number of bytes in src, or -1. */
+    const char *src,	/* Source information for list element. */
+    int length,			/* Number of bytes in src, or -1. */
     char *dst,			/* Place to put list-ified element. */
     int flags)			/* Flags produced by Tcl_ScanElement. */
 {
     int conversion = flags & CONVERT_MASK;
     char *p = dst;
@@ -1393,11 +1404,11 @@
 
     /*
      * No matter what the caller demands, empty string must be braced!
      */
 
-    if ((src == NULL) || (length == 0) || (*src == '\0' && length == TCL_AUTO_LENGTH)) {
+    if ((src == NULL) || (length == 0) || (*src == '\0' && length == -1)) {
 	p[0] = '{';
 	p[1] = '}';
 	return 2;
     }
 
@@ -1409,11 +1420,11 @@
 	if (conversion == CONVERT_ESCAPE) {
 	    p[0] = '\\';
 	    p[1] = '#';
 	    p += 2;
 	    src++;
-	    length -= (length+1 > 1);
+	    length -= (length > 0);
 	} else {
 	    conversion = CONVERT_BRACE;
 	}
     }
 
@@ -1420,11 +1431,11 @@
     /*
      * No escape or quoting needed.  Copy the literal string value.
      */
 
     if (conversion == CONVERT_NONE) {
-	if (length == TCL_AUTO_LENGTH) {
+	if (length == -1) {
 	    /* TODO: INT_MAX overflow? */
 	    while (*src) {
 		*p++ = *src++;
 	    }
 	    return p - dst;
@@ -1439,11 +1450,11 @@
      */
 
     if (conversion == CONVERT_BRACE) {
 	*p = '{';
 	p++;
-	if (length == TCL_AUTO_LENGTH) {
+	if (length == -1) {
 	    /* TODO: INT_MAX overflow? */
 	    while (*src) {
 		*p++ = *src++;
 	    }
 	} else {
@@ -1450,20 +1461,20 @@
 	    memcpy(p, src, length);
 	    p += length;
 	}
 	*p = '}';
 	p++;
-	return (size_t)(p - dst);
+	return p - dst;
     }
 
     /* conversion == CONVERT_ESCAPE or CONVERT_MASK */
 
     /*
      * Formatted string is original string converted to escape sequences.
      */
 
-    for ( ; length; src++, length -= (length+1 > 1)) {
+    for ( ; length; src++, length -= (length > 0)) {
 	switch (*src) {
 	case ']':
 	case '[':
 	case '$':
 	case ';':
@@ -1512,12 +1523,12 @@
 	    p++;
 	    *p = 'v';
 	    p++;
 	    continue;
 	case '\0':
-	    if (length == TCL_AUTO_LENGTH) {
-		return (size_t)(p - dst);
+	    if (length == -1) {
+		return p - dst;
 	    }
 
 	    /*
 	     * If we reach this point, there's an embedded NULL in the string
 	     * range being processed, which should not happen when the
@@ -1529,11 +1540,11 @@
 	    break;
 	}
 	*p = *src;
 	p++;
     }
-    return (size_t)(p - dst);
+    return p - dst;
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1559,21 +1570,20 @@
     int argc,			/* How many strings to merge. */
     const char *const *argv)	/* Array of string values. */
 {
 #define LOCAL_SIZE 64
     char localFlags[LOCAL_SIZE], *flagPtr = NULL;
-    int i;
-    size_t bytesNeeded = 0;
+    int i, bytesNeeded = 0;
     char *result, *dst;
 
     /*
      * Handle empty list case first, so logic of the general case can be
      * simpler.
      */
 
     if (argc == 0) {
-	result = Tcl_Alloc(1);
+	result = ckalloc(1);
 	result[0] = '\0';
 	return result;
     }
 
     /*
@@ -1581,23 +1591,29 @@
      */
 
     if (argc <= LOCAL_SIZE) {
 	flagPtr = localFlags;
     } else {
-	flagPtr = Tcl_Alloc(argc);
+	flagPtr = ckalloc(argc);
     }
     for (i = 0; i < argc; i++) {
 	flagPtr[i] = ( i ? TCL_DONT_QUOTE_HASH : 0 );
 	bytesNeeded += TclScanElement(argv[i], -1, &flagPtr[i]);
+	if (bytesNeeded < 0) {
+	    Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
+	}
+    }
+    if (bytesNeeded > INT_MAX - argc + 1) {
+	Tcl_Panic("max size for a Tcl value (%d bytes) exceeded", INT_MAX);
     }
     bytesNeeded += argc;
 
     /*
      * Pass two: copy into the result area.
      */
 
-    result = Tcl_Alloc(bytesNeeded);
+    result = ckalloc(bytesNeeded);
     dst = result;
     for (i = 0; i < argc; i++) {
 	flagPtr[i] |= ( i ? TCL_DONT_QUOTE_HASH : 0 );
 	dst += TclConvertElement(argv[i], -1, dst, flagPtr[i]);
 	*dst = ' ';
@@ -1604,14 +1620,50 @@
 	dst++;
     }
     dst[-1] = 0;
 
     if (flagPtr != localFlags) {
-	Tcl_Free(flagPtr);
+	ckfree(flagPtr);
     }
     return result;
 }
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_Backslash --
+ *
+ *	Figure out how to handle a backslash sequence.
+ *
+ * Results:
+ *	The return value is the character that should be substituted in place
+ *	of the backslash sequence that starts at src. If readPtr isn't NULL
+ *	then it is filled in with a count of the number of characters in the
+ *	backslash sequence.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+char
+Tcl_Backslash(
+    const char *src,		/* Points to the backslash character of a
+				 * backslash sequence. */
+    int *readPtr)		/* Fill in with number of characters read from
+				 * src, unless NULL. */
+{
+    char buf[4] = "";
+    Tcl_UniChar ch = 0;
+
+    Tcl_UtfBackslash(src, readPtr, buf);
+    TclUtfToUniChar(buf, &ch);
+    return (char) ch;
+}
+#endif /* !TCL_NO_DEPRECATED */
 
 /*
  *----------------------------------------------------------------------
  *
  * UtfWellFormedEnd --
@@ -1662,38 +1714,38 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-static inline size_t
+static inline int
 TrimRight(
     const char *bytes,		/* String to be trimmed... */
-    size_t numBytes,		/* ...and its length in bytes */
+    int numBytes,		/* ...and its length in bytes */
     const char *trim,		/* String of trim characters... */
-    size_t numTrim)		/* ...and its length in bytes */
+    int numTrim)		/* ...and its length in bytes */
 {
     const char *p = bytes + numBytes;
-    size_t pInc;
+    int pInc;
     Tcl_UniChar ch1 = 0, ch2 = 0;
 
     /*
      * Outer loop: iterate over string to be trimmed.
      */
 
     do {
 	const char *q = trim;
-	size_t bytesLeft = numTrim;
+	int bytesLeft = numTrim;
 
 	p = Tcl_UtfPrev(p, bytes);
  	pInc = TclUtfToUniChar(p, &ch1);
 
 	/*
 	 * Inner loop: scan trim string for match to current character.
 	 */
 
 	do {
-	    size_t qInc = TclUtfToUniChar(q, &ch2);
+	    int qInc = TclUtfToUniChar(q, &ch2);
 
 	    if (ch1 == ch2) {
 		break;
 	    }
 
@@ -1712,18 +1764,18 @@
     } while (p > bytes);
 
     return numBytes - (p - bytes);
 }
 
-size_t
+int
 TclTrimRight(
     const char *bytes,	/* String to be trimmed... */
-    size_t numBytes,	/* ...and its length in bytes */
+    int numBytes,	/* ...and its length in bytes */
     const char *trim,	/* String of trim characters... */
-    size_t numTrim)	/* ...and its length in bytes */
+    int numTrim)	/* ...and its length in bytes */
 {
-    size_t res;
+    int res;
     Tcl_DString bytesBuf, trimBuf;
 
     /* Empty strings -> nothing to do */
     if ((numBytes == 0) || (numTrim == 0)) {
 	return 0;
@@ -1761,35 +1813,35 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-static inline size_t
+static inline int
 TrimLeft(
     const char *bytes,		/* String to be trimmed... */
-    size_t numBytes,		/* ...and its length in bytes */
+    int numBytes,		/* ...and its length in bytes */
     const char *trim,		/* String of trim characters... */
-    size_t numTrim)		/* ...and its length in bytes */
+    int numTrim)		/* ...and its length in bytes */
 {
     const char *p = bytes;
 	Tcl_UniChar ch1 = 0, ch2 = 0;
 
     /*
      * Outer loop: iterate over string to be trimmed.
      */
 
     do {
-	size_t pInc = TclUtfToUniChar(p, &ch1);
+	int pInc = TclUtfToUniChar(p, &ch1);
 	const char *q = trim;
-	size_t bytesLeft = numTrim;
+	int bytesLeft = numTrim;
 
 	/*
 	 * Inner loop: scan trim string for match to current character.
 	 */
 
 	do {
-	    size_t qInc = TclUtfToUniChar(q, &ch2);
+	    int qInc = TclUtfToUniChar(q, &ch2);
 
 	    if (ch1 == ch2) {
 		break;
 	    }
 
@@ -1810,18 +1862,18 @@
     } while (numBytes > 0);
 
     return p - bytes;
 }
 
-size_t
+int
 TclTrimLeft(
     const char *bytes,	/* String to be trimmed... */
-    size_t numBytes,	/* ...and its length in bytes */
+    int numBytes,	/* ...and its length in bytes */
     const char *trim,	/* String of trim characters... */
-    size_t numTrim)	/* ...and its length in bytes */
+    int numTrim)	/* ...and its length in bytes */
 {
-    size_t res;
+    int res;
     Tcl_DString bytesBuf, trimBuf;
 
     /* Empty strings -> nothing to do */
     if ((numBytes == 0) || (numTrim == 0)) {
 	return 0;
@@ -1857,19 +1909,19 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 TclTrim(
     const char *bytes,	/* String to be trimmed... */
-    size_t numBytes,	/* ...and its length in bytes */
+    int numBytes,	/* ...and its length in bytes */
     const char *trim,	/* String of trim characters... */
-    size_t numTrim,	/* ...and its length in bytes */
-    size_t *trimRight)		/* Offset from the end of the string. */
+    int numTrim,	/* ...and its length in bytes */
+    int *trimRight)		/* Offset from the end of the string. */
 {
-    size_t trimLeft;
+    int trimLeft;
     Tcl_DString bytesBuf, trimBuf;
 
     *trimRight = 0;
     /* Empty strings -> nothing to do */
     if ((numBytes == 0) || (numTrim == 0)) {
@@ -1919,27 +1971,26 @@
  *
  *----------------------------------------------------------------------
  */
 
 /* The whitespace characters trimmed during [concat] operations */
-#define CONCAT_WS_SIZE (sizeof(CONCAT_TRIM_SET "") - 1)
+#define CONCAT_WS_SIZE (int) (sizeof(CONCAT_TRIM_SET "") - 1)
 
 char *
 Tcl_Concat(
     int argc,			/* Number of strings to concatenate. */
     const char *const *argv)	/* Array of strings to concatenate. */
 {
-    int i;
-    size_t needSpace = 0, bytesNeeded = 0;
+    int i, needSpace = 0, bytesNeeded = 0;
     char *result, *p;
 
     /*
      * Dispose of the empty result corner case first to simplify later code.
      */
 
     if (argc == 0) {
-	result = (char *) Tcl_Alloc(1);
+	result = (char *) ckalloc(1);
 	result[0] = '\0';
 	return result;
     }
 
     /*
@@ -1946,20 +1997,31 @@
      * First allocate the result buffer at the size required.
      */
 
     for (i = 0;  i < argc;  i++) {
 	bytesNeeded += strlen(argv[i]);
+	if (bytesNeeded < 0) {
+	    Tcl_Panic("Tcl_Concat: max size of Tcl value exceeded");
+	}
+    }
+    if (bytesNeeded + argc - 1 < 0) {
+	/*
+	 * Panic test could be tighter, but not going to bother for this
+	 * legacy routine.
+	 */
+
+	Tcl_Panic("Tcl_Concat: max size of Tcl value exceeded");
     }
 
     /*
      * All element bytes + (argc - 1) spaces + 1 terminating NULL.
      */
 
-    result = Tcl_Alloc(bytesNeeded + argc);
+    result = ckalloc(bytesNeeded + argc);
 
     for (p = result, i = 0;  i < argc;  i++) {
-	size_t triml, trimr, elemLength;
+	int triml, trimr, elemLength;
 	const char *element;
 
 	element = argv[i];
 	elemLength = strlen(argv[i]);
 
@@ -2016,12 +2078,11 @@
 Tcl_Obj *
 Tcl_ConcatObj(
     int objc,			/* Number of objects to concatenate. */
     Tcl_Obj *const objv[])	/* Array of objects to concatenate. */
 {
-    int i, needSpace = 0;
-    size_t bytesNeeded = 0, elemLength;
+    int i, elemLength, needSpace = 0, bytesNeeded = 0;
     const char *element;
     Tcl_Obj *objPtr, *resPtr;
 
     /*
      * Check first to see if all the items are of list type or empty. If so,
@@ -2028,17 +2089,17 @@
      * we will concat them together as lists, and return a list object. This
      * is only valid when the lists are in canonical form.
      */
 
     for (i = 0;  i < objc;  i++) {
-	size_t length;
+	int length;
 
 	objPtr = objv[i];
 	if (TclListObjIsCanonical(objPtr)) {
 	    continue;
 	}
-	(void)TclGetStringFromObj(objPtr, &length);
+	TclGetStringFromObj(objPtr, &length);
 	if (length > 0) {
 	    break;
 	}
     }
     if (i == objc) {
@@ -2073,10 +2134,13 @@
      */
 
     for (i = 0;  i < objc;  i++) {
 	element = TclGetStringFromObj(objv[i], &elemLength);
 	bytesNeeded += elemLength;
+	if (bytesNeeded < 0) {
+	    break;
+	}
     }
 
     /*
      * Does not matter if this fails, will simply try later to build up the
      * string with each Append reallocating as needed with the usual string
@@ -2086,11 +2150,11 @@
     TclNewObj(resPtr);
     (void) Tcl_AttemptSetObjLength(resPtr, bytesNeeded + objc - 1);
     Tcl_SetObjLength(resPtr, 0);
 
     for (i = 0;  i < objc;  i++) {
-	size_t triml, trimr;
+	int triml, trimr;
 
 	element = TclGetStringFromObj(objv[i], &elemLength);
 
 	/* Trim away the leading/trailing whitespace. */
 	triml = TclTrim(element, elemLength, CONCAT_TRIM_SET,
@@ -2120,10 +2184,39 @@
 	needSpace = 1;
     }
     return resPtr;
 }
 
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_StringMatch --
+ *
+ *	See if a particular string matches a particular pattern.
+ *
+ * Results:
+ *	The return value is 1 if string matches pattern, and 0 otherwise. The
+ *	matching operation permits the following special characters in the
+ *	pattern: *?\[] (see the manual entry for details on what these mean).
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#undef Tcl_StringMatch
+int
+Tcl_StringMatch(
+    const char *str,		/* String. */
+    const char *pattern)	/* Pattern, which may contain special
+				 * characters. */
+{
+    return Tcl_StringCaseMatch(str, pattern, 0);
+}
+#endif /* TCL_NO_DEPRECATED */
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_StringCaseMatch --
  *
@@ -2375,15 +2468,15 @@
  */
 
 int
 TclByteArrayMatch(
     const unsigned char *string,/* String. */
-    size_t strLen,			/* Length of String */
+    int strLen,			/* Length of String */
     const unsigned char *pattern,
 				/* Pattern, which may contain special
 				 * characters. */
-    size_t ptnLen,			/* Length of Pattern */
+    int ptnLen,			/* Length of Pattern */
     int flags)
 {
     const unsigned char *stringEnd, *patternEnd;
     unsigned char p;
 
@@ -2556,12 +2649,11 @@
     Tcl_Obj *strObj,		/* string object. */
     Tcl_Obj *ptnObj,		/* pattern object. */
     int flags)			/* Only TCL_MATCH_NOCASE should be passed, or
 				 * 0. */
 {
-    int match;
-    size_t length = 0, plen = 0;
+    int match, length, plen;
 
     /*
      * Promote based on the type of incoming object.
      * XXX: Currently doesn't take advantage of exact-ness that
      * XXX: TclReToGlob tells us about
@@ -2569,19 +2661,19 @@
      */
 
     if (TclHasIntRep(strObj, &tclStringType) || (strObj->typePtr == NULL)) {
 	Tcl_UniChar *udata, *uptn;
 
-	udata = TclGetUnicodeFromObj(strObj, &length);
-	uptn  = TclGetUnicodeFromObj(ptnObj, &plen);
+	udata = Tcl_GetUnicodeFromObj(strObj, &length);
+	uptn  = Tcl_GetUnicodeFromObj(ptnObj, &plen);
 	match = TclUniCharMatch(udata, length, uptn, plen, flags);
     } else if (TclIsPureByteArray(strObj) && TclIsPureByteArray(ptnObj)
 		&& !flags) {
 	unsigned char *data, *ptn;
 
-	data = TclGetByteArrayFromObj(strObj, &length);
-	ptn  = TclGetByteArrayFromObj(ptnObj, &plen);
+	data = Tcl_GetByteArrayFromObj(strObj, &length);
+	ptn  = Tcl_GetByteArrayFromObj(ptnObj, &plen);
 	match = TclByteArrayMatch(data, length, ptn, plen, 0);
     } else {
 	match = Tcl_StringCaseMatch(TclGetString(strObj),
 		TclGetString(ptnObj), flags);
     }
@@ -2635,19 +2727,19 @@
  */
 
 char *
 Tcl_DStringAppend(
     Tcl_DString *dsPtr,		/* Structure describing dynamic string. */
-    const char *bytes,		/* String to append. If length is
-				 * TCL_AUTO_LENGTH then this must be null-terminated. */
-    size_t length)			/* Number of bytes from "bytes" to append. If
-				 * TCL_AUTO_LENGTH, then append all of bytes, up to null
+    const char *bytes,		/* String to append. If length is -1 then this
+				 * must be null-terminated. */
+    int length)			/* Number of bytes from "bytes" to append. If
+				 * < 0, then append all of bytes, up to null
 				 * at end. */
 {
-    size_t newSize;
+    int newSize;
 
-    if (length == TCL_AUTO_LENGTH) {
+    if (length < 0) {
 	length = strlen(bytes);
     }
     newSize = length + dsPtr->length;
 
     /*
@@ -2657,27 +2749,27 @@
      */
 
     if (newSize >= dsPtr->spaceAvl) {
 	dsPtr->spaceAvl = newSize * 2;
 	if (dsPtr->string == dsPtr->staticSpace) {
-	    char *newString = Tcl_Alloc(dsPtr->spaceAvl);
+	    char *newString = ckalloc(dsPtr->spaceAvl);
 
 	    memcpy(newString, dsPtr->string, dsPtr->length);
 	    dsPtr->string = newString;
 	} else {
-	    size_t index = TCL_INDEX_NONE;
+	    int offset = -1;
 
 	    /* See [16896d49fd] */
 	    if (bytes >= dsPtr->string
 		    && bytes <= dsPtr->string + dsPtr->length) {
-		index = bytes - dsPtr->string;
+		offset = bytes - dsPtr->string;
 	    }
 
-	    dsPtr->string = Tcl_Realloc(dsPtr->string, dsPtr->spaceAvl);
+	    dsPtr->string = ckrealloc(dsPtr->string, dsPtr->spaceAvl);
 
-	    if (index != TCL_INDEX_NONE) {
-		bytes = dsPtr->string + index;
+	    if (offset >= 0) {
+		bytes = dsPtr->string + offset;
 	    }
 	}
     }
 
     /*
@@ -2704,12 +2796,12 @@
 char *
 TclDStringAppendObj(
     Tcl_DString *dsPtr,
     Tcl_Obj *objPtr)
 {
-    size_t length;
-    const char *bytes = TclGetStringFromObj(objPtr, &length);
+    int length;
+    char *bytes = TclGetStringFromObj(objPtr, &length);
 
     return Tcl_DStringAppend(dsPtr, bytes, length);
 }
 
 char *
@@ -2746,11 +2838,11 @@
 				 * null-terminated. */
 {
     char *dst = dsPtr->string + dsPtr->length;
     int needSpace = TclNeedSpace(dsPtr->string, dst);
     char flags = needSpace ? TCL_DONT_QUOTE_HASH : 0;
-    size_t newSize = dsPtr->length + needSpace
+    int newSize = dsPtr->length + needSpace
 	    + TclScanElement(element, -1, &flags);
 
     /*
      * Allocate a larger buffer for the string if the current one isn't large
      * enough. Allocate extra space in the new buffer so that there will be
@@ -2760,11 +2852,11 @@
      */
 
     if (newSize >= dsPtr->spaceAvl) {
 	dsPtr->spaceAvl = newSize * 2;
 	if (dsPtr->string == dsPtr->staticSpace) {
-	    char *newString = Tcl_Alloc(dsPtr->spaceAvl);
+	    char *newString = ckalloc(dsPtr->spaceAvl);
 
 	    memcpy(newString, dsPtr->string, dsPtr->length);
 	    dsPtr->string = newString;
 	} else {
 	    int offset = -1;
@@ -2773,11 +2865,11 @@
 	    if (element >= dsPtr->string
 		    && element <= dsPtr->string + dsPtr->length) {
 		offset = element - dsPtr->string;
 	    }
 
-	    dsPtr->string = Tcl_Realloc(dsPtr->string, dsPtr->spaceAvl);
+	    dsPtr->string = ckrealloc(dsPtr->string, dsPtr->spaceAvl);
 
 	    if (offset >= 0) {
 		element = dsPtr->string + offset;
 	    }
 	}
@@ -2818,22 +2910,26 @@
  * Results:
  *	None.
  *
  * Side effects:
  *	The length of dsPtr is changed to length and a null byte is stored at
- *	that position in the string.
+ *	that position in the string. If length is larger than the space
+ *	allocated for dsPtr, then a panic occurs.
  *
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_DStringSetLength(
     Tcl_DString *dsPtr,		/* Structure describing dynamic string. */
-    size_t length)			/* New length for dynamic string. */
+    int length)			/* New length for dynamic string. */
 {
-    size_t newsize;
+    int newsize;
 
+    if (length < 0) {
+	length = 0;
+    }
     if (length >= dsPtr->spaceAvl) {
 	/*
 	 * There are two interesting cases here. In the first case, the user
 	 * may be trying to allocate a large buffer of a specific size. It
 	 * would be wasteful to overallocate that buffer, so we just allocate
@@ -2850,16 +2946,16 @@
 	    dsPtr->spaceAvl = newsize;
 	} else {
 	    dsPtr->spaceAvl = length + 1;
 	}
 	if (dsPtr->string == dsPtr->staticSpace) {
-	    char *newString = Tcl_Alloc(dsPtr->spaceAvl);
+	    char *newString = ckalloc(dsPtr->spaceAvl);
 
 	    memcpy(newString, dsPtr->string, dsPtr->length);
 	    dsPtr->string = newString;
 	} else {
-	    dsPtr->string = Tcl_Realloc(dsPtr->string, dsPtr->spaceAvl);
+	    dsPtr->string = ckrealloc(dsPtr->string, dsPtr->spaceAvl);
 	}
     }
     dsPtr->length = length;
     dsPtr->string[length] = 0;
 }
@@ -2885,11 +2981,11 @@
 void
 Tcl_DStringFree(
     Tcl_DString *dsPtr)		/* Structure describing dynamic string. */
 {
     if (dsPtr->string != dsPtr->staticSpace) {
-	Tcl_Free(dsPtr->string);
+	ckfree(dsPtr->string);
     }
     dsPtr->string = dsPtr->staticSpace;
     dsPtr->length = 0;
     dsPtr->spaceAvl = TCL_DSTRING_STATIC_SIZE;
     dsPtr->staticSpace[0] = '\0';
@@ -2947,16 +3043,90 @@
 Tcl_DStringGetResult(
     Tcl_Interp *interp,		/* Interpreter whose result is to be reset. */
     Tcl_DString *dsPtr)		/* Dynamic string that is to become the result
 				 * of interp. */
 {
+#ifdef TCL_NO_DEPRECATED
     Tcl_Obj *obj = Tcl_GetObjResult(interp);
-    char *bytes = TclGetString(obj);
+    const char *bytes = TclGetString(obj);
 
     Tcl_DStringFree(dsPtr);
     Tcl_DStringAppend(dsPtr, bytes, obj->length);
     Tcl_ResetResult(interp);
+#else
+    Interp *iPtr = (Interp *) interp;
+
+    if (dsPtr->string != dsPtr->staticSpace) {
+	ckfree(dsPtr->string);
+    }
+
+    /*
+     * Do more efficient transfer when we know the result is a Tcl_Obj. When
+     * there's no string result, we only have to deal with two cases:
+     *
+     *  1. When the string rep is the empty string, when we don't copy but
+     *     instead use the staticSpace in the DString to hold an empty string.
+
+     *  2. When the string rep is not there or there's a real string rep, when
+     *     we use Tcl_GetString to fetch (or generate) the string rep - which
+     *     we know to have been allocated with ckalloc() - and use it to
+     *     populate the DString space. Then, we free the internal rep. and set
+     *     the object's string representation back to the canonical empty
+     *     string.
+     */
+
+    if (!iPtr->result[0] && iPtr->objResultPtr
+	    && !Tcl_IsShared(iPtr->objResultPtr)) {
+	if (iPtr->objResultPtr->bytes == &tclEmptyString) {
+	    dsPtr->string = dsPtr->staticSpace;
+	    dsPtr->string[0] = 0;
+	    dsPtr->length = 0;
+	    dsPtr->spaceAvl = TCL_DSTRING_STATIC_SIZE;
+	} else {
+	    dsPtr->string = TclGetString(iPtr->objResultPtr);
+	    dsPtr->length = iPtr->objResultPtr->length;
+	    dsPtr->spaceAvl = dsPtr->length + 1;
+	    TclFreeIntRep(iPtr->objResultPtr);
+	    iPtr->objResultPtr->bytes = &tclEmptyString;
+	    iPtr->objResultPtr->length = 0;
+	}
+	return;
+    }
+
+    /*
+     * If the string result is empty, move the object result to the string
+     * result, then reset the object result.
+     */
+
+    (void) Tcl_GetStringResult(interp);
+
+    dsPtr->length = strlen(iPtr->result);
+    if (iPtr->freeProc != NULL) {
+	if (iPtr->freeProc == TCL_DYNAMIC) {
+	    dsPtr->string = iPtr->result;
+	    dsPtr->spaceAvl = dsPtr->length+1;
+	} else {
+	    dsPtr->string = ckalloc(dsPtr->length+1);
+	    memcpy(dsPtr->string, iPtr->result, dsPtr->length+1);
+	    iPtr->freeProc(iPtr->result);
+	}
+	dsPtr->spaceAvl = dsPtr->length+1;
+	iPtr->freeProc = NULL;
+    } else {
+	if (dsPtr->length < TCL_DSTRING_STATIC_SIZE) {
+	    dsPtr->string = dsPtr->staticSpace;
+	    dsPtr->spaceAvl = TCL_DSTRING_STATIC_SIZE;
+	} else {
+	    dsPtr->string = ckalloc(dsPtr->length+1);
+	    dsPtr->spaceAvl = dsPtr->length + 1;
+	}
+	memcpy(dsPtr->string, iPtr->result, dsPtr->length+1);
+    }
+
+    iPtr->result = iPtr->resultSpace;
+    iPtr->resultSpace[0] = 0;
+#endif /* !TCL_NO_DEPRECATED */
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -3078,32 +3248,36 @@
  *
  *	Given a floating-point value, this function converts it to an ASCII
  *	string using.
  *
  * Results:
- *	The ASCII equivalent of "value" is written at "dst". It is guaranteed
- *	to contain a decimal point or exponent, so that it looks like a
- *	floating-point value and not an integer.
+ *	The ASCII equivalent of "value" is written at "dst". It is written
+ *	using the current precision, and it is guaranteed to contain a decimal
+ *	point or exponent, so that it looks like a floating-point value and
+ *	not an integer.
  *
  * Side effects:
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
 void
 Tcl_PrintDouble(
-    Tcl_Interp *interp,		/* Not used */
+    Tcl_Interp *interp,		/* Interpreter whose tcl_precision variable
+				 * used to be used to control printing. It's
+				 * ignored now. */
     double value,		/* Value to print as string. */
     char *dst)			/* Where to store converted value; must have
 				 * at least TCL_DOUBLE_SPACE characters. */
 {
     char *p, c;
     int exponent;
     int signum;
     char *digits;
     char *end;
+    int *precisionPtr = Tcl_GetThreadData(&precisionKey, sizeof(int));
 
     /*
      * Handle NaN.
      */
 
@@ -3131,12 +3305,57 @@
 
     /*
      * Ordinary (normal and denormal) values.
      */
 
-    digits = TclDoubleDigits(value, -1, TCL_DD_SHORTEST,
-	    &exponent, &signum, &end);
+    if (*precisionPtr == 0) {
+	digits = TclDoubleDigits(value, -1, TCL_DD_SHORTEST,
+		&exponent, &signum, &end);
+    } else {
+	/*
+	 * There are at least two possible interpretations for tcl_precision.
+	 *
+	 * The first is, "choose the decimal representation having
+	 * $tcl_precision digits of significance that is nearest to the given
+	 * number, breaking ties by rounding to even, and then trimming
+	 * trailing zeros." This gives the greatest possible precision in the
+	 * decimal string, but offers the anomaly that [expr 0.1] will be
+	 * "0.10000000000000001".
+	 *
+	 * The second is "choose the decimal representation having at most
+	 * $tcl_precision digits of significance that is nearest to the given
+	 * number. If no such representation converts exactly to the given
+	 * number, choose the one that is closest, breaking ties by rounding
+	 * to even. If more than one such representation converts exactly to
+	 * the given number, choose the shortest, breaking ties in favour of
+	 * the nearest, breaking remaining ties in favour of the one ending in
+	 * an even digit."
+	 *
+	 * Tcl 8.4 implements the first of these, which gives rise to
+	 * anomalies in formatting:
+	 *
+	 *	% expr 0.1
+	 *	0.10000000000000001
+	 *	% expr 0.01
+	 *	0.01
+	 *	% expr 1e-7
+	 *	9.9999999999999995e-08
+	 *
+	 * For human readability, it appears better to choose the second rule,
+	 * and let [expr 0.1] return 0.1. But for 8.4 compatibility, we prefer
+	 * the first (the recommended zero value for tcl_precision avoids the
+	 * problem entirely).
+	 *
+	 * Uncomment TCL_DD_SHORTEN_FLAG in the next call to prefer the method
+	 * that allows floating point values to be shortened if it can be done
+	 * without loss of precision.
+	 */
+
+	digits = TclDoubleDigits(value, *precisionPtr,
+		TCL_DD_E_FORMAT /* | TCL_DD_SHORTEN_FLAG */,
+		&exponent, &signum, &end);
+    }
     if (signum) {
 	*dst++ = '-';
     }
     p = digits;
     if (exponent < -4 || exponent > 16) {
@@ -3152,11 +3371,20 @@
 		*dst++ = c;
 		c = *++p;
 	    }
 	}
 
-	sprintf(dst, "e%+d", exponent);
+	/*
+	 * Tcl 8.4 appears to format with at least a two-digit exponent;
+	 * preserve that behaviour when tcl_precision != 0
+	 */
+
+	if (*precisionPtr == 0) {
+	    sprintf(dst, "e%+d", exponent);
+	} else {
+	    sprintf(dst, "e%+03d", exponent);
+	}
     } else {
 	/*
 	 * F format for others.
 	 */
 
@@ -3184,12 +3412,92 @@
 		c = *++p;
 	    }
 	}
 	*dst++ = '\0';
     }
-    Tcl_Free(digits);
+    ckfree(digits);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclPrecTraceProc --
+ *
+ *	This function is invoked whenever the variable "tcl_precision" is
+ *	written.
+ *
+ * Results:
+ *	Returns NULL if all went well, or an error message if the new value
+ *	for the variable doesn't make sense.
+ *
+ * Side effects:
+ *	If the new value doesn't make sense then this function undoes the
+ *	effect of the variable modification. Otherwise it modifies the format
+ *	string that's used by Tcl_PrintDouble.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 9
+	/* ARGSUSED */
+char *
+TclPrecTraceProc(
+    ClientData clientData,	/* Not used. */
+    Tcl_Interp *interp,		/* Interpreter containing variable. */
+    const char *name1,		/* Name of variable. */
+    const char *name2,		/* Second part of variable name. */
+    int flags)			/* Information about what happened. */
+{
+    Tcl_Obj *value;
+    Tcl_WideInt prec;
+    int *precisionPtr = Tcl_GetThreadData(&precisionKey, sizeof(int));
+
+    /*
+     * If the variable is unset, then recreate the trace.
+     */
+
+    if (flags & TCL_TRACE_UNSETS) {
+	if ((flags & TCL_TRACE_DESTROYED) && !Tcl_InterpDeleted(interp)) {
+	    Tcl_TraceVar2(interp, name1, name2,
+		    TCL_GLOBAL_ONLY|TCL_TRACE_READS|TCL_TRACE_WRITES
+		    |TCL_TRACE_UNSETS, TclPrecTraceProc, clientData);
+	}
+	return NULL;
+    }
+
+    /*
+     * When the variable is read, reset its value from our shared value. This
+     * is needed in case the variable was modified in some other interpreter
+     * so that this interpreter's value is out of date.
+     */
+
+
+    if (flags & TCL_TRACE_READS) {
+	Tcl_SetVar2Ex(interp, name1, name2, Tcl_NewWideIntObj(*precisionPtr),
+		flags & TCL_GLOBAL_ONLY);
+	return NULL;
+    }
+
+    /*
+     * The variable is being written. Check the new value and disallow it if
+     * it isn't reasonable or if this is a safe interpreter (we don't want
+     * safe interpreters messing up the precision of other interpreters).
+     */
+
+    if (Tcl_IsSafe(interp)) {
+	return (char *) "can't modify precision from a safe interpreter";
+    }
+    value = Tcl_GetVar2Ex(interp, name1, name2, flags & TCL_GLOBAL_ONLY);
+    if (value == NULL
+	    || Tcl_GetWideIntFromObj(NULL, value, &prec) != TCL_OK
+	    || prec < 0 || prec > TCL_MAX_PREC) {
+	return (char *) "improper value for precision";
+    }
+    *precisionPtr = (int)prec;
+    return NULL;
 }
+#endif /* !TCL_NO_DEPRECATED)*/
 
 /*
  *----------------------------------------------------------------------
  *
  * TclNeedSpace --
@@ -3299,18 +3607,19 @@
  *	the "buffer" argument.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 TclFormatInt(
     char *buffer,		/* Points to the storage into which the
 				 * formatted characters are written. */
     Tcl_WideInt n)			/* The integer to format. */
 {
-    Tcl_WideInt intVal;
-    size_t i, numFormatted, j;
+	Tcl_WideInt intVal;
+    int i;
+    int numFormatted, j;
     const char *digits = "0123456789";
 
     /*
      * Check first whether "n" is zero.
      */
@@ -3390,15 +3699,15 @@
  */
 
 static int
 GetWideForIndex(
     Tcl_Interp *interp,         /* Interpreter to use for error reporting. If
-				 * NULL, then no error message is left after
-				 * errors. */
+                                 * NULL, then no error message is left after
+                                 * errors. */
     Tcl_Obj *objPtr,            /* Points to the value to be parsed */
     size_t endValue,            /* The value to be stored at *widePtr if
-				 * objPtr holds "end".
+                                 * objPtr holds "end".
                                  * NOTE: this value may be TCL_INDEX_NONE. */
     Tcl_WideInt *widePtr)       /* Location filled in with a wide integer
                                  * representing an index. */
 {
     ClientData cd;
@@ -3552,10 +3861,11 @@
                 "bad index \"%s\": must be integer?[+-]integer? or"
                 " end?[+-]integer?", bytes));
         if (!strncmp(bytes, "end-", 4)) {
             bytes += 4;
         }
+        TclCheckBadOctal(interp, bytes);
         Tcl_SetErrorCode(interp, "TCL", "VALUE", "INDEX", NULL);
     }
     return TCL_ERROR;
 }
 
@@ -3562,30 +3872,25 @@
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_GetIntForIndex --
  *
- *	Provides an integer corresponding to the list index held in a Tcl
- *	object. The string value 'objPtr' is expected have the format
- *	integer([+-]integer)? or end([+-]integer)?.
- *
- * Value
- * 	TCL_OK
- *
- * 	    The index is stored at the address given by by 'indexPtr'. If
- * 	    'objPtr' has the value "end", the value stored is 'endValue'.
- *
- * 	TCL_ERROR
- *
- * 	    The value of 'objPtr' does not have one of the expected formats. If
- * 	    'interp' is non-NULL, an error message is left in the interpreter's
- * 	    result object.
- *
- * Effect
- *
- * 	The object referenced by 'objPtr' is converted, as needed, to an
- * 	integer, wide integer, or end-based-index object.
+ *	This function returns an integer corresponding to the list index held
+ *	in a Tcl object. The Tcl object's value is expected to be in the
+ *	format integer([+-]integer)? or the format end([+-]integer)?.
+ *
+ * Results:
+ *	The return value is normally TCL_OK, which means that the index was
+ *	successfully stored into the location referenced by "indexPtr". If the
+ *	Tcl object referenced by "objPtr" has the value "end", the value
+ *	stored is "endValue". If "objPtr"s values is not of one of the
+ *	expected formats, TCL_ERROR is returned and, if "interp" is non-NULL,
+ *	an error message is left in the interpreter's result object.
+ *
+ * Side effects:
+ *	The object referenced by "objPtr" might be converted to an integer,
+ *	wide integer, or end-based-index object.
  *
  *----------------------------------------------------------------------
  */
 
 int
@@ -3593,28 +3898,26 @@
     Tcl_Interp *interp,		/* Interpreter to use for error reporting. If
 				 * NULL, then no error message is left after
 				 * errors. */
     Tcl_Obj *objPtr,		/* Points to an object containing either "end"
 				 * or an integer. */
-    size_t endValue,		/* The value to be stored at "indexPtr" if
+    int endValue,		/* The value to be stored at "indexPtr" if
 				 * "objPtr" holds "end". */
-    size_t *indexPtr)		/* Location filled in with an integer
+    int *indexPtr)		/* Location filled in with an integer
 				 * representing an index. */
 {
     Tcl_WideInt wide;
 
-    /* Use platform-related size_t to wide-int to consider negative value
-     * TCL_INDEX_NONE if wide-int and size_t have different dimensions. */
     if (GetWideForIndex(interp, objPtr, endValue, &wide) == TCL_ERROR) {
 	return TCL_ERROR;
     }
     if (wide < 0) {
-	*indexPtr = TCL_INDEX_NONE;
-    } else if ((Tcl_WideUInt)wide > TCL_INDEX_END) {
-	*indexPtr = TCL_INDEX_END;
+	*indexPtr = -1;
+    } else if (wide > INT_MAX) {
+	*indexPtr = INT_MAX;
     } else {
-	*indexPtr = (size_t) wide;
+	*indexPtr = (int) wide;
     }
     return TCL_OK;
 }
 /*
  *----------------------------------------------------------------------
@@ -3644,11 +3947,11 @@
     Tcl_ObjIntRep *irPtr;
     Tcl_WideInt offset = 0;	/* Offset in the "end-offset" expression */
 
     while ((irPtr = TclFetchIntRep(objPtr, &endOffsetType)) == NULL) {
 	Tcl_ObjIntRep ir;
-	size_t length;
+	int length;
 	const char *bytes = TclGetStringFromObj(objPtr, &length);
 
 	if ((length < 3) || (length == 4)) {
 	    /* Too short to be "end" or to be "end-$integer" */
 	    return TCL_ERROR;
@@ -3704,11 +4007,11 @@
 	Tcl_StoreIntRep(objPtr, &endOffsetType, &ir);
     }
 
     offset = irPtr->wideValue;
 
-    if (endValue == TCL_INDEX_NONE) {
+    if (endValue == (size_t)-1) {
         *widePtr = offset - 1;
     } else if (offset < 0) {
         /* Different signs, sum cannot overflow */
         *widePtr = endValue + offset;
     } else if (endValue < (Tcl_WideUInt)WIDE_MAX - offset) {
@@ -3776,12 +4079,12 @@
 
 int
 TclIndexEncode(
     Tcl_Interp *interp,	/* For error reporting, may be NULL */
     Tcl_Obj *objPtr,	/* Index value to parse */
-    size_t before,		/* Value to return for index before beginning */
-    size_t after,		/* Value to return for index after end */
+    int before,		/* Value to return for index before beginning */
+    int after,		/* Value to return for index after end */
     int *indexPtr)	/* Where to write the encoded answer, not NULL */
 {
     ClientData cd;
     Tcl_WideInt wide;
     int idx, numType, code = TclGetNumberFromObj(NULL, objPtr, &cd, &numType);
@@ -3788,11 +4091,11 @@
 
     if ((code == TCL_OK) && (numType == TCL_NUMBER_INT)) {
         /* We parsed a value in the range WIDE_MIN...WIDE_MAX */
 	wide = (*(Tcl_WideInt *)cd);
     integerEncode:
-        if (wide < 0) {
+        if (wide < TCL_INDEX_START) {
             /* All negative absolute indices are "before the beginning" */
             idx = before;
         } else if (wide >= INT_MAX) {
             /* This index value is always "after the end" */
             idx = after;
@@ -3805,20 +4108,20 @@
          * We parsed an end+offset index value.
          * wide holds the offset value in the range WIDE_MIN...WIDE_MAX.
          */
         if (wide > 0) {
             /*
-             * All end+positive or end-negative expressions
+             * All end+postive or end-negative expressions
              * always indicate "after the end".
              */
-            idx = (int) after;
-        } else if (wide < INT_MIN - (int) TCL_INDEX_END) {
+            idx = after;
+        } else if (wide < INT_MIN - TCL_INDEX_END) {
             /* These indices always indicate "before the beginning */
-            idx = (int) before;
+            idx = before;
         } else {
             /* Encoded end-positive (or end+negative) are offset */
-            idx = (int) wide + (int) TCL_INDEX_END;
+            idx = (int)wide + TCL_INDEX_END;
         }
 
     /* TODO: Consider flag to suppress repeated end-offset parse. */
     } else if (TCL_OK == GetWideForIndex(interp, objPtr, 0, &wide)) {
         /*
@@ -3848,23 +4151,91 @@
  *	The decoded index value.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 TclIndexDecode(
     int encoded,	/* Value to decode */
-    size_t endValue)	/* Meaning of "end" to use, > TCL_INDEX_END */
+    int endValue)	/* Meaning of "end" to use, > TCL_INDEX_END */
 {
-    if (encoded > (int)TCL_INDEX_END) {
+    if (encoded > TCL_INDEX_END) {
 	return encoded;
     }
-    if (endValue >= TCL_INDEX_END - encoded) {
-	return endValue + encoded - TCL_INDEX_END;
+    endValue += encoded - TCL_INDEX_END;
+    if (endValue >= 0) {
+	return endValue;
     }
     return TCL_INDEX_NONE;
 }
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclCheckBadOctal --
+ *
+ *	This function checks for a bad octal value and appends a meaningful
+ *	error to the interp's result.
+ *
+ * Results:
+ *	1 if the argument was a bad octal, else 0.
+ *
+ * Side effects:
+ *	The interpreter's result is modified.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+TclCheckBadOctal(
+    Tcl_Interp *interp,		/* Interpreter to use for error reporting. If
+				 * NULL, then no error message is left after
+				 * errors. */
+    const char *value)		/* String to check. */
+{
+    const char *p = value;
+
+    /*
+     * A frequent mistake is invalid octal values due to an unwanted leading
+     * zero. Try to generate a meaningful error message.
+     */
+
+    while (TclIsSpaceProc(*p)) {
+	p++;
+    }
+    if (*p == '+' || *p == '-') {
+	p++;
+    }
+    if (*p == '0') {
+	if ((p[1] == 'o') || p[1] == 'O') {
+	    p += 2;
+	}
+	while (isdigit(UCHAR(*p))) {	/* INTL: digit. */
+	    p++;
+	}
+	while (TclIsSpaceProc(*p)) {
+	    p++;
+	}
+	if (*p == '\0') {
+	    /*
+	     * Reached end of string.
+	     */
+
+	    if (interp != NULL) {
+		/*
+		 * Don't reset the result here because we want this result to
+		 * be added to an existing error message as extra info.
+		 */
+
+		Tcl_AppendToObj(Tcl_GetObjResult(interp),
+			" (looks like invalid octal number)", -1);
+	    }
+	    return 1;
+	}
+    }
+    return 0;
+}
 
 /*
  *----------------------------------------------------------------------
  *
  * ClearHash --
@@ -3914,11 +4285,11 @@
 {
     Tcl_HashTable **tablePtrPtr =
 	    Tcl_GetThreadData(keyPtr, sizeof(Tcl_HashTable *));
 
     if (NULL == *tablePtrPtr) {
-	*tablePtrPtr = Tcl_Alloc(sizeof(Tcl_HashTable));
+	*tablePtrPtr = ckalloc(sizeof(Tcl_HashTable));
 	Tcl_CreateThreadExitHandler(FreeThreadHash, *tablePtrPtr);
 	Tcl_InitHashTable(*tablePtrPtr, TCL_ONE_WORD_KEYS);
     }
     return *tablePtrPtr;
 }
@@ -3943,11 +4314,11 @@
 {
     Tcl_HashTable *tablePtr = clientData;
 
     ClearHash(tablePtr);
     Tcl_DeleteHashTable(tablePtr);
-    Tcl_Free(tablePtr);
+    ckfree(tablePtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -3965,11 +4336,11 @@
 {
     ProcessGlobalValue *pgvPtr = clientData;
 
     pgvPtr->epoch++;
     pgvPtr->numBytes = 0;
-    Tcl_Free(pgvPtr->value);
+    ckfree(pgvPtr->value);
     pgvPtr->value = NULL;
     if (pgvPtr->encoding) {
 	Tcl_FreeEncoding(pgvPtr->encoding);
 	pgvPtr->encoding = NULL;
     }
@@ -4004,17 +4375,17 @@
      * Fill the global string value.
      */
 
     pgvPtr->epoch++;
     if (NULL != pgvPtr->value) {
-	Tcl_Free(pgvPtr->value);
+	ckfree(pgvPtr->value);
     } else {
 	Tcl_CreateExitHandler(FreeProcessGlobalValue, pgvPtr);
     }
     bytes = TclGetString(newValue);
     pgvPtr->numBytes = newValue->length;
-    pgvPtr->value = Tcl_Alloc(pgvPtr->numBytes + 1);
+    pgvPtr->value = ckalloc(pgvPtr->numBytes + 1);
     memcpy(pgvPtr->value, bytes, pgvPtr->numBytes + 1);
     if (pgvPtr->encoding) {
 	Tcl_FreeEncoding(pgvPtr->encoding);
     }
     pgvPtr->encoding = encoding;
@@ -4026,11 +4397,11 @@
      */
 
     Tcl_IncrRefCount(newValue);
     cacheMap = GetThreadHash(&pgvPtr->key);
     ClearHash(cacheMap);
-    hPtr = Tcl_CreateHashEntry(cacheMap, (void *)(pgvPtr->epoch), &dummy);
+    hPtr = Tcl_CreateHashEntry(cacheMap, (void *)(size_t)(pgvPtr->epoch), &dummy);
     Tcl_SetHashValue(hPtr, newValue);
     Tcl_MutexUnlock(&pgvPtr->mutex);
 }
 
 /*
@@ -4052,11 +4423,11 @@
     ProcessGlobalValue *pgvPtr)
 {
     Tcl_Obj *value = NULL;
     Tcl_HashTable *cacheMap;
     Tcl_HashEntry *hPtr;
-    size_t epoch = pgvPtr->epoch;
+    unsigned int epoch = pgvPtr->epoch;
 
     if (pgvPtr->encoding) {
 	Tcl_Encoding current = Tcl_GetEncoding(NULL, NULL);
 
 	if (pgvPtr->encoding != current) {
@@ -4073,12 +4444,12 @@
 	    Tcl_UtfToExternalDString(pgvPtr->encoding, pgvPtr->value,
 		    pgvPtr->numBytes, &native);
 	    Tcl_ExternalToUtfDString(current, Tcl_DStringValue(&native),
 	    Tcl_DStringLength(&native), &newValue);
 	    Tcl_DStringFree(&native);
-	    Tcl_Free(pgvPtr->value);
-	    pgvPtr->value = Tcl_Alloc(Tcl_DStringLength(&newValue) + 1);
+	    ckfree(pgvPtr->value);
+	    pgvPtr->value = ckalloc(Tcl_DStringLength(&newValue) + 1);
 	    memcpy(pgvPtr->value, Tcl_DStringValue(&newValue),
 		    Tcl_DStringLength(&newValue) + 1);
 	    Tcl_DStringFree(&newValue);
 	    Tcl_FreeEncoding(pgvPtr->encoding);
 	    pgvPtr->encoding = current;
@@ -4086,11 +4457,11 @@
 	} else {
 	    Tcl_FreeEncoding(current);
 	}
     }
     cacheMap = GetThreadHash(&pgvPtr->key);
-    hPtr = Tcl_FindHashEntry(cacheMap, (void *) (epoch));
+    hPtr = Tcl_FindHashEntry(cacheMap, (void *)(size_t)epoch);
     if (NULL == hPtr) {
 	int dummy;
 
 	/*
 	 * No cache for the current epoch - must be a new one.
@@ -4119,11 +4490,11 @@
 	 * Store a copy of the shared value in our epoch-indexed cache.
 	 */
 
 	value = Tcl_NewStringObj(pgvPtr->value, pgvPtr->numBytes);
 	hPtr = Tcl_CreateHashEntry(cacheMap,
-		(void *)(pgvPtr->epoch), &dummy);
+		(void *)(size_t)(pgvPtr->epoch), &dummy);
 	Tcl_MutexUnlock(&pgvPtr->mutex);
 	Tcl_SetHashValue(hPtr, value);
 	Tcl_IncrRefCount(value);
     }
     return Tcl_GetHashValue(hPtr);
@@ -4214,10 +4585,35 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
+ * TclpGetTime --
+ *
+ *	Deprecated synonym for Tcl_GetTime. This function is provided for the
+ *	benefit of extensions written before Tcl_GetTime was exported from the
+ *	library.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Stores current time in the buffer designated by "timePtr"
+ *
+ *----------------------------------------------------------------------
+ */
+
+void
+TclpGetTime(
+    Tcl_Time *timePtr)
+{
+    Tcl_GetTime(timePtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * TclGetPlatform --
  *
  *	This is a kludge that allows the test library to get access the
  *	internal tclPlatform variable.
  *
@@ -4258,11 +4654,11 @@
 
 int
 TclReToGlob(
     Tcl_Interp *interp,
     const char *reStr,
-    size_t reStrLen,
+    int reStrLen,
     Tcl_DString *dsPtr,
     int *exactPtr,
     int *quantifiersFoundPtr)
 {
     int anchorLeft, anchorRight, lastIsStar, numStars;

Index: generic/tclVar.c
==================================================================
--- generic/tclVar.c
+++ generic/tclVar.c
@@ -341,11 +341,11 @@
 static int
 NotArrayError(
     Tcl_Interp *interp,
     Tcl_Obj *name)
 {
-    const char *nameStr = TclGetString(name);
+    const char *nameStr = Tcl_GetString(name);
 
     Tcl_SetObjResult(interp,
 	    Tcl_ObjPrintf("\"%s\" isn't an array", nameStr));
     Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "ARRAY", nameStr, NULL);
     return TCL_ERROR;
@@ -383,21 +383,21 @@
     if (TclIsVarUndefined(varPtr) && TclIsVarInHash(varPtr)
 	    && !TclIsVarTraced(varPtr)
 	    && (VarHashRefCount(varPtr) == (unsigned)
 		    !TclIsVarDeadHash(varPtr))) {
 	if (VarHashRefCount(varPtr) == 0) {
-	    Tcl_Free(varPtr);
+	    ckfree(varPtr);
 	} else {
 	    VarHashDeleteEntry(varPtr);
 	}
     }
     if (arrayPtr != NULL && TclIsVarUndefined(arrayPtr) &&
 	    TclIsVarInHash(arrayPtr) && !TclIsVarTraced(arrayPtr) &&
 	    (VarHashRefCount(arrayPtr) == (unsigned)
 		    !TclIsVarDeadHash(arrayPtr))) {
 	if (VarHashRefCount(arrayPtr) == 0) {
-	    Tcl_Free(arrayPtr);
+	    ckfree(arrayPtr);
 	} else {
 	    VarHashDeleteEntry(arrayPtr);
 	}
     }
 }
@@ -530,11 +530,11 @@
  */
 
 Var *
 TclObjLookupVar(
     Tcl_Interp *interp,		/* Interpreter to use for lookup. */
-    register Tcl_Obj *part1Ptr,	/* If part2 isn't NULL, this is the name of an
+    Tcl_Obj *part1Ptr,	/* If part2 isn't NULL, this is the name of an
 				 * array. Otherwise, this is a full variable
 				 * name that could include a parenthesized
 				 * array element. */
     const char *part2,		/* Name of element within array, or NULL. */
     int flags,			/* Only TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
@@ -603,11 +603,11 @@
 				 * address of array variable. Otherwise this
 				 * is set to NULL. */
 {
     Interp *iPtr = (Interp *) interp;
     CallFrame *varFramePtr = iPtr->varFramePtr;
-    register Var *varPtr;	/* Points to the variable's in-frame Var
+    Var *varPtr;	/* Points to the variable's in-frame Var
 				 * structure. */
     const char *errMsg = NULL;
     int index, parsed = 0;
 
     int localIndex;
@@ -663,11 +663,11 @@
     if (!parsed) {
 	/*
 	 * part1Ptr is possibly an unparsed array element.
 	 */
 
-	size_t len;
+	int len;
 	const char *part1 = TclGetStringFromObj(part1Ptr, &len);
 
 	if ((len > 1) && (part1[len - 1] == ')')) {
 	    const char *part2 = strchr(part1, '(');
 
@@ -845,12 +845,11 @@
     Tcl_Var var;		/* Used to search for global names. */
     Var *varPtr;		/* Points to the Var structure returned for
 				 * the variable. */
     Namespace *varNsPtr, *cxtNsPtr, *dummy1Ptr, *dummy2Ptr;
     ResolverScheme *resPtr;
-    int isNew, i, result;
-    size_t varLen;
+    int isNew, i, result, varLen;
     const char *varName = TclGetStringFromObj(varNamePtr, &varLen);
 
     varPtr = NULL;
     varNsPtr = NULL;		/* Set non-NULL if a nonlocal variable. */
     *indexPtr = -3;
@@ -919,12 +918,16 @@
 
 	if (lookGlobal) {
 	    *indexPtr = -1;
 	    flags = (flags | TCL_GLOBAL_ONLY) & ~TCL_NAMESPACE_ONLY;
 	} else {
-	    flags = (flags | TCL_NAMESPACE_ONLY);
-	    *indexPtr = -2;
+	    if (flags & TCL_AVOID_RESOLVERS) {
+		flags = (flags | TCL_NAMESPACE_ONLY);
+	    }
+	    if (flags & TCL_NAMESPACE_ONLY) {
+		*indexPtr = -2;
+	    }
 	}
 
 	/*
 	 * Don't pass TCL_LEAVE_ERR_MSG, we may yet create the variable, or
 	 * otherwise generate our own error!
@@ -976,14 +979,14 @@
 	int localCt = varFramePtr->numCompiledLocals;
 
 	if (localCt > 0) {
 	    Tcl_Obj **objPtrPtr = &varFramePtr->localCachePtr->varName0;
 	    const char *localNameStr;
-	    size_t localLen;
+	    int localLen;
 
 	    for (i=0 ; i<localCt ; i++, objPtrPtr++) {
-		register Tcl_Obj *objPtr = *objPtrPtr;
+		Tcl_Obj *objPtr = *objPtrPtr;
 
 		if (objPtr) {
 		    localNameStr = TclGetStringFromObj(objPtr, &localLen);
 
 		    if ((varLen == localLen) && (varName[0] == localNameStr[0])
@@ -995,11 +998,11 @@
 	    }
 	}
 	tablePtr = varFramePtr->varTablePtr;
 	if (create) {
 	    if (tablePtr == NULL) {
-		tablePtr = Tcl_Alloc(sizeof(TclVarHashTable));
+		tablePtr = ckalloc(sizeof(TclVarHashTable));
 		TclInitVarHashTable(tablePtr, NULL);
 		varFramePtr->varTablePtr = tablePtr;
 	    }
 	    varPtr = VarHashCreateVar(tablePtr, varNamePtr, &isNew);
 	} else {
@@ -1143,10 +1146,55 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
+ * Tcl_GetVar --
+ *
+ *	Return the value of a Tcl variable as a string.
+ *
+ * Results:
+ *	The return value points to the current value of varName as a string.
+ *	If the variable is not defined or can't be read because of a clash in
+ *	array usage then a NULL pointer is returned and an error message is
+ *	left in the interp's result if the TCL_LEAVE_ERR_MSG flag is set.
+ *	Note: the return value is only valid up until the next change to the
+ *	variable; if you depend on the value lasting longer than that, then
+ *	make yourself a private copy.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_GetVar
+const char *
+Tcl_GetVar(
+    Tcl_Interp *interp,		/* Command interpreter in which varName is to
+				 * be looked up. */
+    const char *varName,	/* Name of a variable in interp. */
+    int flags)			/* OR-ed combination of TCL_GLOBAL_ONLY,
+				 * TCL_NAMESPACE_ONLY or TCL_LEAVE_ERR_MSG
+				 * bits. */
+{
+    Tcl_Obj *varNamePtr = Tcl_NewStringObj(varName, -1);
+    Tcl_Obj *resultPtr = Tcl_ObjGetVar2(interp, varNamePtr, NULL, flags);
+
+    TclDecrRefCount(varNamePtr);
+
+    if (resultPtr == NULL) {
+	return NULL;
+    }
+    return TclGetString(resultPtr);
+}
+#endif /* TCL_NO_DEPRECATED */
+
+/*
+ *----------------------------------------------------------------------
+ *
  * Tcl_GetVar2 --
  *
  *	Return the value of a Tcl variable as a string, given a two-part name
  *	consisting of array name and element within array.
  *
@@ -1275,14 +1323,14 @@
 
 Tcl_Obj *
 Tcl_ObjGetVar2(
     Tcl_Interp *interp,		/* Command interpreter in which variable is to
 				 * be looked up. */
-    register Tcl_Obj *part1Ptr,	/* Points to an object holding the name of an
+    Tcl_Obj *part1Ptr,	/* Points to an object holding the name of an
 				 * array (if part2 is non-NULL) or the name of
 				 * a variable. */
-    register Tcl_Obj *part2Ptr,	/* If non-null, points to an object holding
+    Tcl_Obj *part2Ptr,	/* If non-null, points to an object holding
 				 * the name of an element in the array
 				 * part1Ptr. */
     int flags)			/* OR-ed combination of TCL_GLOBAL_ONLY and
 				 * TCL_LEAVE_ERR_MSG bits. */
 {
@@ -1373,11 +1421,11 @@
 
 Tcl_Obj *
 TclPtrGetVarIdx(
     Tcl_Interp *interp,		/* Command interpreter in which variable is to
 				 * be looked up. */
-    register Var *varPtr,	/* The variable to be read.*/
+    Var *varPtr,	/* The variable to be read.*/
     Var *arrayPtr,		/* NULL for scalar variables, pointer to the
 				 * containing array otherwise. */
     Tcl_Obj *part1Ptr,		/* Name of an array (if part2 is non-NULL) or
 				 * the name of a variable. */
     Tcl_Obj *part2Ptr,		/* If non-NULL, gives the name of an element
@@ -1479,11 +1527,11 @@
 
 	/* ARGSUSED */
 int
 Tcl_SetObjCmd(
     ClientData dummy,		/* Not used. */
-    register Tcl_Interp *interp,/* Current interpreter. */
+    Tcl_Interp *interp,/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Tcl_Obj *varValueObj;
 
@@ -1506,10 +1554,57 @@
 	Tcl_WrongNumArgs(interp, 1, objv, "varName ?newValue?");
 	return TCL_ERROR;
     }
 }
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_SetVar --
+ *
+ *	Change the value of a variable.
+ *
+ * Results:
+ *	Returns a pointer to the malloc'ed string which is the character
+ *	representation of the variable's new value. The caller must not modify
+ *	this string. If the write operation was disallowed then NULL is
+ *	returned; if the TCL_LEAVE_ERR_MSG flag is set, then an explanatory
+ *	message will be left in the interp's result. Note that the returned
+ *	string may not be the same as newValue; this is because variable
+ *	traces may modify the variable's value.
+ *
+ * Side effects:
+ *	If varName is defined as a local or global variable in interp, its
+ *	value is changed to newValue. If varName isn't currently defined, then
+ *	a new global variable by that name is created.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_SetVar
+const char *
+Tcl_SetVar(
+    Tcl_Interp *interp,		/* Command interpreter in which varName is to
+				 * be looked up. */
+    const char *varName,	/* Name of a variable in interp. */
+    const char *newValue,	/* New value for varName. */
+    int flags)			/* Various flags that tell how to set value:
+				 * any of TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
+				 * TCL_APPEND_VALUE, TCL_LIST_ELEMENT,
+				 * TCL_LEAVE_ERR_MSG. */
+{
+    Tcl_Obj *varValuePtr = Tcl_SetVar2Ex(interp, varName, NULL,
+	    Tcl_NewStringObj(newValue, -1), flags);
+
+    if (varValuePtr == NULL) {
+	return NULL;
+    }
+    return TclGetString(varValuePtr);
+}
+#endif /* TCL_NO_DEPRECATED */
+
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_SetVar2 --
  *
@@ -1656,14 +1751,14 @@
 
 Tcl_Obj *
 Tcl_ObjSetVar2(
     Tcl_Interp *interp,		/* Command interpreter in which variable is to
 				 * be found. */
-    register Tcl_Obj *part1Ptr,	/* Points to an object holding the name of an
+    Tcl_Obj *part1Ptr,	/* Points to an object holding the name of an
 				 * array (if part2 is non-NULL) or the name of
 				 * a variable. */
-    register Tcl_Obj *part2Ptr,	/* If non-NULL, points to an object holding
+    Tcl_Obj *part2Ptr,	/* If non-NULL, points to an object holding
 				 * the name of an element in the array
 				 * part1Ptr. */
     Tcl_Obj *newValuePtr,	/* New value for variable. */
     int flags)			/* Various flags that tell how to set value:
 				 * any of TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
@@ -1896,11 +1991,11 @@
 
 Tcl_Obj *
 TclPtrSetVarIdx(
     Tcl_Interp *interp,		/* Command interpreter in which variable is to
 				 * be looked up. */
-    register Var *varPtr,	/* Reference to the variable to set. */
+    Var *varPtr,	/* Reference to the variable to set. */
     Var *arrayPtr,		/* Reference to the array containing the
 				 * variable, or NULL if the variable is a
 				 * scalar. */
     Tcl_Obj *part1Ptr,		/* Name of an array (if part2 is non-NULL) or
 				 * the name of a variable. NULL if the 'index'
@@ -2216,11 +2311,11 @@
 				 * TCL_LEAVE_ERR_MSG. */
     int index)			/* Index into the local variable table of the
 				 * variable, or -1. Only used when part1Ptr is
 				 * NULL. */
 {
-    register Tcl_Obj *varValuePtr;
+    Tcl_Obj *varValuePtr;
 
     if (TclIsVarInHash(varPtr)) {
 	VarHashRefCount(varPtr)++;
     }
     varValuePtr = TclPtrGetVarIdx(interp, varPtr, arrayPtr, part1Ptr,
@@ -2258,10 +2353,61 @@
 	    return NULL;
 	}
     }
 }
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_UnsetVar --
+ *
+ *	Delete a variable, so that it may not be accessed anymore.
+ *
+ * Results:
+ *	Returns TCL_OK if the variable was successfully deleted, TCL_ERROR if
+ *	the variable can't be unset. In the event of an error, if the
+ *	TCL_LEAVE_ERR_MSG flag is set then an error message is left in the
+ *	interp's result.
+ *
+ * Side effects:
+ *	If varName is defined as a local or global variable in interp, it is
+ *	deleted.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_UnsetVar
+int
+Tcl_UnsetVar(
+    Tcl_Interp *interp,		/* Command interpreter in which varName is to
+				 * be looked up. */
+    const char *varName,	/* Name of a variable in interp. May be either
+				 * a scalar name or an array name or an
+				 * element in an array. */
+    int flags)			/* OR-ed combination of any of
+				 * TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY or
+				 * TCL_LEAVE_ERR_MSG. */
+{
+    int result;
+    Tcl_Obj *varNamePtr;
+
+    varNamePtr = Tcl_NewStringObj(varName, -1);
+    Tcl_IncrRefCount(varNamePtr);
+
+    /*
+     * Filter to pass through only the flags this interface supports.
+     */
+
+    flags &= (TCL_GLOBAL_ONLY|TCL_NAMESPACE_ONLY|TCL_LEAVE_ERR_MSG);
+    result = TclObjUnsetVar2(interp, varNamePtr, NULL, flags);
+
+    Tcl_DecrRefCount(varNamePtr);
+    return result;
+}
+#endif /* TCL_NO_DEPRECATED */
+
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_UnsetVar2 --
  *
@@ -2426,11 +2572,11 @@
 
 int
 TclPtrUnsetVarIdx(
     Tcl_Interp *interp,		/* Command interpreter in which varName is to
 				 * be looked up. */
-    register Var *varPtr,	/* The variable to be unset. */
+    Var *varPtr,	/* The variable to be unset. */
     Var *arrayPtr,		/* NULL for scalar variables, pointer to the
 				 * containing array otherwise. */
     Tcl_Obj *part1Ptr,		/* Name of an array (if part2 is non-NULL) or
 				 * the name of a variable. */
     Tcl_Obj *part2Ptr,		/* If non-NULL, gives the name of an element
@@ -2680,12 +2826,12 @@
     ClientData dummy,		/* Not used. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    register int i, flags = TCL_LEAVE_ERR_MSG;
-    register const char *name;
+    int i, flags = TCL_LEAVE_ERR_MSG;
+    const char *name;
 
     if (objc == 1) {
 	/*
 	 * Do nothing if no arguments supplied, so as to match command
 	 * documentation.
@@ -2749,11 +2895,11 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Var *varPtr, *arrayPtr;
-    register Tcl_Obj *varValuePtr = NULL;
+    Tcl_Obj *varValuePtr = NULL;
 				/* Initialized to avoid compiler warning. */
     int i;
 
     if (objc < 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "varName ?value ...?");
@@ -3073,11 +3219,11 @@
 
     /*
      * Make a new array search, put it on the stack.
      */
 
-    searchPtr = Tcl_Alloc(sizeof(ArraySearch));
+    searchPtr = ckalloc(sizeof(ArraySearch));
     ArrayPopulateSearch(interp, arrayNameObj, varPtr, searchPtr);
 
     /*
      * Make sure that these objects (which we need throughout the body of the
      * loop) don't vanish.
@@ -3194,11 +3340,11 @@
 	 * VAR_SEARCH_ACTIVE flag will no longer be set.
 	 */
 
 	ArrayDoneSearch(iPtr, varPtr, searchPtr);
 	Tcl_DecrRefCount(searchPtr->name);
-	Tcl_Free(searchPtr);
+	ckfree(searchPtr);
     }
 
     TclDecrRefCount(varListObj);
     TclDecrRefCount(scriptObj);
     return result;
@@ -3282,11 +3428,11 @@
 
     /*
      * Make a new array search with a free name.
      */
 
-    searchPtr = Tcl_Alloc(sizeof(ArraySearch));
+    searchPtr = ckalloc(sizeof(ArraySearch));
     ArrayPopulateSearch(interp, objv[1], varPtr, searchPtr);
     Tcl_SetObjResult(interp, searchPtr->name);
     return TCL_OK;
 }
 
@@ -3549,11 +3695,11 @@
 	return TCL_ERROR;
     }
 
     ArrayDoneSearch(iPtr, varPtr, searchPtr);
     Tcl_DecrRefCount(searchPtr->name);
-    Tcl_Free(searchPtr);
+    ckfree(searchPtr);
     return TCL_OK;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -4209,11 +4355,11 @@
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"error reading array statistics", -1));
 	return TCL_ERROR;
     }
     Tcl_SetObjResult(interp, Tcl_NewStringObj(stats, -1));
-    Tcl_Free(stats);
+    ckfree(stats);
     return TCL_OK;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -4669,10 +4815,67 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
+ * Tcl_UpVar --
+ *
+ *	This function links one variable to another, just like the "upvar"
+ *	command.
+ *
+ * Results:
+ *	A standard Tcl completion code. If an error occurs then an error
+ *	message is left in the interp's result.
+ *
+ * Side effects:
+ *	The variable in frameName whose name is given by varName becomes
+ *	accessible under the name localNameStr, so that references to
+ *	localNameStr are redirected to the other variable like a symbolic
+ *	link.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef Tcl_UpVar
+int
+Tcl_UpVar(
+    Tcl_Interp *interp,		/* Command interpreter in which varName is to
+				 * be looked up. */
+    const char *frameName,	/* Name of the frame containing the source
+				 * variable, such as "1" or "#0". */
+    const char *varName,	/* Name of a variable in interp to link to.
+				 * May be either a scalar name or an element
+				 * in an array. */
+    const char *localNameStr,	/* Name of link variable. */
+    int flags)			/* 0, TCL_GLOBAL_ONLY or TCL_NAMESPACE_ONLY:
+				 * indicates scope of localNameStr. */
+{
+    int result;
+    CallFrame *framePtr;
+    Tcl_Obj *varNamePtr, *localNamePtr;
+
+    if (TclGetFrame(interp, frameName, &framePtr) == -1) {
+	return TCL_ERROR;
+    }
+
+    varNamePtr = Tcl_NewStringObj(varName, -1);
+    Tcl_IncrRefCount(varNamePtr);
+    localNamePtr = Tcl_NewStringObj(localNameStr, -1);
+    Tcl_IncrRefCount(localNamePtr);
+
+    result = ObjMakeUpvar(interp, framePtr, varNamePtr, NULL, 0,
+	    localNamePtr, flags, -1);
+    Tcl_DecrRefCount(varNamePtr);
+    Tcl_DecrRefCount(localNamePtr);
+    return result;
+}
+#endif /* TCL_NO_DEPRECATED */
+
+/*
+ *----------------------------------------------------------------------
+ *
  * Tcl_UpVar2 --
  *
  *	This function links one variable to another, just like the "upvar"
  *	command.
  *
@@ -4748,11 +4951,11 @@
 				 * previous call to Tcl_FindNamespaceVar. */
     Tcl_Obj *objPtr)		/* Points to the object onto which the
 				 * variable's full name is appended. */
 {
     Interp *iPtr = (Interp *) interp;
-    register Var *varPtr = (Var *) variable;
+    Var *varPtr = (Var *) variable;
     Tcl_Obj *namePtr;
     Namespace *nsPtr;
 
     if (!varPtr || TclIsVarArrayElement(varPtr)) {
 	return;
@@ -4808,13 +5011,13 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     Interp *iPtr = (Interp *) interp;
-    register Tcl_Obj *objPtr, *tailPtr;
+    Tcl_Obj *objPtr, *tailPtr;
     const char *varName;
-    register const char *tail;
+    const char *tail;
     int result, i;
 
     /*
      * If we are not executing inside a Tcl procedure, just return.
      */
@@ -5205,11 +5408,11 @@
  */
 
 static void
 DeleteSearches(
     Interp *iPtr,
-    register Var *arrayVarPtr)	/* Variable whose searches are to be
+    Var *arrayVarPtr)	/* Variable whose searches are to be
 				 * deleted. */
 {
     ArraySearch *searchPtr, *nextPtr;
     Tcl_HashEntry *sPtr;
 
@@ -5217,11 +5420,11 @@
 	sPtr = Tcl_FindHashEntry(&iPtr->varSearches, arrayVarPtr);
 	for (searchPtr = Tcl_GetHashValue(sPtr); searchPtr != NULL;
 		searchPtr = nextPtr) {
 	    nextPtr = searchPtr->nextPtr;
 	    Tcl_DecrRefCount(searchPtr->name);
-	    Tcl_Free(searchPtr);
+	    ckfree(searchPtr);
 	}
 	arrayVarPtr->flags &= ~VAR_SEARCH_ACTIVE;
 	Tcl_DeleteHashEntry(sPtr);
     }
 }
@@ -5347,11 +5550,11 @@
     TclVarHashTable *tablePtr)	/* Hash table containing variables to
 				 * delete. */
 {
     Tcl_Interp *interp = (Tcl_Interp *) iPtr;
     Tcl_HashSearch search;
-    register Var *varPtr;
+    Var *varPtr;
     int flags;
     Namespace *currNsPtr = (Namespace *) TclGetCurrentNamespace(interp);
 
     /*
      * Determine what flags to pass to the trace callback functions.
@@ -5399,11 +5602,11 @@
 TclDeleteCompiledLocalVars(
     Interp *iPtr,		/* Interpreter to which variables belong. */
     CallFrame *framePtr)	/* Procedure call frame containing compiler-
 				 * assigned local variables to delete. */
 {
-    register Var *varPtr;
+    Var *varPtr;
     int numLocals, i;
     Tcl_Obj **namePtrPtr;
 
     numLocals = framePtr->numCompiledLocals;
     varPtr = framePtr->compiledLocals;
@@ -5448,11 +5651,11 @@
 				 * TCL_NAMESPACE_ONLY or TCL_GLOBAL_ONLY. */
     int index)
 {
     Tcl_HashSearch search;
     Tcl_HashEntry *tPtr;
-    register Var *elPtr;
+    Var *elPtr;
     ActiveVarTrace *activePtr;
     Tcl_Obj *objPtr;
     VarTrace *tracePtr;
 
     for (elPtr = VarHashFirstVar(varPtr->value.tablePtr, &search);
@@ -5637,11 +5840,11 @@
 
 static void
 FreeParsedVarName(
     Tcl_Obj *objPtr)
 {
-    register Tcl_Obj *arrayPtr, *elem;
+    Tcl_Obj *arrayPtr, *elem;
     int parsed;
 
     ParsedGetIntRep(objPtr, parsed, arrayPtr, elem);
 
     parsed++;				/* Silence compiler. */
@@ -5654,11 +5857,11 @@
 static void
 DupParsedVarName(
     Tcl_Obj *srcPtr,
     Tcl_Obj *dupPtr)
 {
-    register Tcl_Obj *arrayPtr, *elem;
+    Tcl_Obj *arrayPtr, *elem;
     int parsed;
 
     ParsedGetIntRep(srcPtr, parsed, arrayPtr, elem);
 
     parsed++;				/* Silence compiler. */
@@ -5743,11 +5946,11 @@
     Interp *iPtr = (Interp *) interp;
     ResolverScheme *resPtr;
     Namespace *nsPtr[2], *cxtNsPtr;
     const char *simpleName;
     Var *varPtr;
-    register int search;
+    int search;
     int result;
     Tcl_Var var;
     Tcl_Obj *simpleNamePtr;
     const char *name = TclGetString(namePtr);
 
@@ -5793,14 +5996,10 @@
 
     /*
      * Find the namespace(s) that contain the variable.
      */
 
-    if (!(flags & TCL_GLOBAL_ONLY)) {
-	flags |= TCL_NAMESPACE_ONLY;
-    }
-
     TclGetNamespaceForQualName(interp, name, (Namespace *) contextNsPtr,
 	    flags, &nsPtr[0], &nsPtr[1], &cxtNsPtr, &simpleName);
 
     /*
      * Look for the variable in the variable table of its namespace. Be sure
@@ -6357,15 +6556,15 @@
 static Tcl_HashEntry *
 AllocVarEntry(
     Tcl_HashTable *tablePtr,	/* Hash table. */
     void *keyPtr)		/* Key to store in the hash table entry. */
 {
-    Tcl_Obj *objPtr = (Tcl_Obj *)keyPtr;
+    Tcl_Obj *objPtr = keyPtr;
     Tcl_HashEntry *hPtr;
     Var *varPtr;
 
-    varPtr = Tcl_Alloc(sizeof(VarInHash));
+    varPtr = ckalloc(sizeof(VarInHash));
     varPtr->flags = VAR_IN_HASHTABLE;
     varPtr->value.objPtr = NULL;
     VarHashRefCount(varPtr) = 1;
 
     hPtr = &(((VarInHash *) varPtr)->entry);
@@ -6383,11 +6582,11 @@
     Var *varPtr = VarHashGetValue(hPtr);
     Tcl_Obj *objPtr = hPtr->key.objPtr;
 
     if (TclIsVarUndefined(varPtr) && !TclIsVarTraced(varPtr)
 	    && (VarHashRefCount(varPtr) == 1)) {
-	Tcl_Free(varPtr);
+	ckfree(varPtr);
     } else {
 	VarHashInvalidateEntry(varPtr);
 	TclSetVarUndefined(varPtr);
 	VarHashRefCount(varPtr)--;
     }
@@ -6394,17 +6593,17 @@
     Tcl_DecrRefCount(objPtr);
 }
 
 static int
 CompareVarKeys(
-    void *keyPtr,			/* New key to compare. */
+    void *keyPtr,		/* New key to compare. */
     Tcl_HashEntry *hPtr)	/* Existing key to compare. */
 {
-    Tcl_Obj *objPtr1 = (Tcl_Obj *)keyPtr;
+    Tcl_Obj *objPtr1 = keyPtr;
     Tcl_Obj *objPtr2 = hPtr->key.objPtr;
-    register const char *p1, *p2;
-    register size_t l1, l2;
+    const char *p1, *p2;
+    int l1, l2;
 
     /*
      * If the object pointers are the same then they match.
      * OPT: this comparison was moved to the caller
      *
@@ -6591,11 +6790,11 @@
 
 void
 TclInitArrayVar(
     Var *arrayPtr)
 {
-    ArrayVarHashTable *tablePtr = Tcl_Alloc(sizeof(ArrayVarHashTable));
+    ArrayVarHashTable *tablePtr = ckalloc(sizeof(ArrayVarHashTable));
 
     /*
      * Mark the variable as an array.
      */
 
@@ -6635,11 +6834,11 @@
     /*
      * Regular TclVarHashTable cleanup.
      */
 
     VarHashDeleteTable(arrayPtr->value.tablePtr);
-    Tcl_Free(tablePtr);
+    ckfree(tablePtr);
 }
 
 /*
  * Get array default value if any.
  */

Index: generic/tclZipfs.c
==================================================================
--- generic/tclZipfs.c
+++ generic/tclZipfs.c
@@ -397,13 +397,11 @@
 
 /*
  * Define the ZIP filesystem dispatch table.
  */
 
-MODULE_SCOPE const Tcl_Filesystem zipfsFilesystem;
-
-const Tcl_Filesystem zipfsFilesystem = {
+static const Tcl_Filesystem zipfsFilesystem = {
     "zipfs",
     sizeof(Tcl_Filesystem),
     TCL_FILESYSTEM_VERSION_2,
     ZipFSPathInFilesystemProc,
     NULL, /* dupInternalRepProc */
@@ -456,10 +454,16 @@
     NULL,		    /* Function to handle event, NULL'able */
     NULL,		    /* Wide seek function, NULL'able */
     NULL,		    /* Thread action function, NULL'able */
     NULL,		    /* Truncate function, NULL'able */
 };
+
+/*
+ * Miscellaneous constants.
+ */
+
+#define ERROR_LENGTH	((size_t) -1)
 
 /*
  *-------------------------------------------------------------------------
  *
  * ReadLock, WriteLock, Unlock --
@@ -902,16 +906,16 @@
 ZipFSCloseArchive(
     Tcl_Interp *interp,		/* Current interpreter. */
     ZipFile *zf)
 {
     if (zf->nameLength) {
-	Tcl_Free(zf->name);
+	ckfree(zf->name);
     }
     if (zf->isMemBuffer) {
 	/* Pointer to memory */
 	if (zf->ptrToFree) {
-	    Tcl_Free(zf->ptrToFree);
+	    ckfree(zf->ptrToFree);
 	    zf->ptrToFree = NULL;
 	}
 	zf->data = NULL;
 	return;
     }
@@ -930,11 +934,11 @@
 	zf->data = MAP_FAILED;
     }
 #endif /* _WIN32 */
 
     if (zf->ptrToFree) {
-	Tcl_Free(zf->ptrToFree);
+	ckfree(zf->ptrToFree);
 	zf->ptrToFree = NULL;
     }
     if (zf->chan) {
 	Tcl_Close(interp, zf->chan);
 	zf->chan = NULL;
@@ -1108,11 +1112,11 @@
     if (!zf->chan) {
 	return TCL_ERROR;
     }
     if (Tcl_GetChannelHandle(zf->chan, TCL_READABLE, &handle) != TCL_OK) {
 	zf->length = Tcl_Seek(zf->chan, 0, SEEK_END);
-	if (zf->length == TCL_IO_FAILURE) {
+	if (zf->length == ERROR_LENGTH) {
 	    ZIPFS_POSIX_ERROR(interp, "seek error");
 	    goto error;
 	}
 	if ((zf->length - ZIP_CENTRAL_END_LEN)
 		> (64 * 1024 * 1024 - ZIP_CENTRAL_END_LEN)) {
@@ -1124,11 +1128,11 @@
 	}
 	if (Tcl_Seek(zf->chan, 0, SEEK_SET) == -1) {
 	    ZIPFS_POSIX_ERROR(interp, "seek error");
 	    goto error;
 	}
-	zf->ptrToFree = zf->data = Tcl_AttemptAlloc(zf->length);
+	zf->ptrToFree = zf->data = attemptckalloc(zf->length);
 	if (!zf->ptrToFree) {
 	    ZIPFS_ERROR(interp, "out of memory");
 	    if (interp) {
 		Tcl_SetErrorCode(interp, "TCL", "MALLOC", NULL);
 	    }
@@ -1167,11 +1171,11 @@
 	    ZIPFS_POSIX_ERROR(interp, "file mapping failed");
 	    goto error;
 	}
 #else /* !_WIN32 */
 	zf->length = lseek(PTR2INT(handle), 0, SEEK_END);
-	if (zf->length == TCL_IO_FAILURE || zf->length < ZIP_CENTRAL_END_LEN) {
+	if (zf->length == ERROR_LENGTH || zf->length < ZIP_CENTRAL_END_LEN) {
 	    ZIPFS_POSIX_ERROR(interp, "invalid file size");
 	    goto error;
 	}
 	lseek(PTR2INT(handle), 0, SEEK_SET);
 	zf->data = (unsigned char *) mmap(0, zf->length, PROT_READ,
@@ -1264,11 +1268,11 @@
 	}
 	Unlock();
 	ZipFSCloseArchive(interp, zf0);
 	return TCL_ERROR;
     }
-    zf = Tcl_AttemptAlloc(sizeof(ZipFile) + strlen(mountPoint) + 1);
+    zf = attemptckalloc(sizeof(ZipFile) + strlen(mountPoint) + 1);
     if (!zf) {
 	if (interp) {
 	    Tcl_AppendResult(interp, "out of memory", (char *) NULL);
 	    Tcl_SetErrorCode(interp, "TCL", "MALLOC", NULL);
 	}
@@ -1281,11 +1285,11 @@
     *zf = *zf0;
     zf->mountPoint = Tcl_GetHashKey(&ZipFS.zipHash, hPtr);
     Tcl_CreateExitHandler(ZipfsExitHandler, (ClientData)zf);
     zf->mountPointLen = strlen(zf->mountPoint);
     zf->nameLength = strlen(zipname);
-    zf->name = Tcl_Alloc(zf->nameLength + 1);
+    zf->name = ckalloc(zf->nameLength + 1);
     memcpy(zf->name, zipname, zf->nameLength + 1);
     zf->entries = NULL;
     zf->topEnts = NULL;
     zf->numOpen = 0;
     Tcl_SetHashValue(hPtr, zf);
@@ -1300,11 +1304,11 @@
 	zf->passBuf[k] = '\0';
     }
     if (mountPoint[0] != '\0') {
 	hPtr = Tcl_CreateHashEntry(&ZipFS.fileHash, mountPoint, &isNew);
 	if (isNew) {
-	    z = Tcl_Alloc(sizeof(ZipEntry));
+	    z = ckalloc(sizeof(ZipEntry));
 	    Tcl_SetHashValue(hPtr, z);
 
 	    z->tnext = NULL;
 	    z->depth = CountSlashes(mountPoint);
 	    z->zipFilePtr = zf;
@@ -1395,11 +1399,11 @@
 	    goto nextent;
 #endif /* ANDROID */
 	}
 	Tcl_DStringSetLength(&fpBuf, 0);
 	fullpath = CanonicalPath(mountPoint, path, &fpBuf, 1);
-	z = Tcl_Alloc(sizeof(ZipEntry));
+	z = ckalloc(sizeof(ZipEntry));
 	z->name = NULL;
 	z->tnext = NULL;
 	z->depth = CountSlashes(fullpath);
 	z->zipFilePtr = zf;
 	z->isDirectory = isdir;
@@ -1424,11 +1428,11 @@
 	z->numCompressedBytes = nbcompr;
 	z->data = NULL;
 	hPtr = Tcl_CreateHashEntry(&ZipFS.fileHash, fullpath, &isNew);
 	if (!isNew) {
 	    /* should not happen but skip it anyway */
-	    Tcl_Free(z);
+	    ckfree(z);
 	} else {
 	    Tcl_SetHashValue(hPtr, z);
 	    z->name = Tcl_GetHashKey(&ZipFS.fileHash, hPtr);
 	    z->next = zf->entries;
 	    zf->entries = z;
@@ -1449,11 +1453,11 @@
 		    Tcl_DStringSetLength(&ds, end - dir);
 		    hPtr = Tcl_CreateHashEntry(&ZipFS.fileHash, dir, &isNew);
 		    if (!isNew) {
 			break;
 		    }
-		    zd = Tcl_Alloc(sizeof(ZipEntry));
+		    zd = ckalloc(sizeof(ZipEntry));
 		    zd->name = NULL;
 		    zd->tnext = NULL;
 		    zd->depth = CountSlashes(dir);
 		    zd->zipFilePtr = zf;
 		    zd->isDirectory = 1;
@@ -1663,28 +1667,28 @@
 		Tcl_SetErrorCode(interp, "TCL", "ZIPFS", "BAD_PASS", NULL);
 	    }
 	    return TCL_ERROR;
 	}
     }
-    zf = Tcl_AttemptAlloc(sizeof(ZipFile) + strlen(mountPoint) + 1);
+    zf = attemptckalloc(sizeof(ZipFile) + strlen(mountPoint) + 1);
     if (!zf) {
 	if (interp) {
 	    Tcl_AppendResult(interp, "out of memory", (char *) NULL);
 	    Tcl_SetErrorCode(interp, "TCL", "MALLOC", NULL);
 	}
 	return TCL_ERROR;
     }
     if (ZipFSOpenArchive(interp, zipname, 1, zf) != TCL_OK) {
-	Tcl_Free(zf);
+	ckfree(zf);
 	return TCL_ERROR;
     }
     if (ZipFSCatalogFilesystem(interp, zf, mountPoint, passwd, zipname)
 	    != TCL_OK) {
-	Tcl_Free(zf);
+	ckfree(zf);
 	return TCL_ERROR;
     }
-    Tcl_Free(zf);
+    ckfree(zf);
     return TCL_OK;
 }
 
 /*
  *-------------------------------------------------------------------------
@@ -1744,11 +1748,11 @@
 
     /*
      * Have both a mount point and data to mount there.
      */
 
-    zf = Tcl_AttemptAlloc(sizeof(ZipFile) + strlen(mountPoint) + 1);
+    zf = attemptckalloc(sizeof(ZipFile) + strlen(mountPoint) + 1);
     if (!zf) {
 	if (interp) {
 	    Tcl_AppendResult(interp, "out of memory", (char *) NULL);
 	    Tcl_SetErrorCode(interp, "TCL", "MALLOC", NULL);
 	}
@@ -1755,11 +1759,11 @@
 	return TCL_ERROR;
     }
     zf->isMemBuffer = 1;
     zf->length = datalen;
     if (copy) {
-	zf->data = Tcl_AttemptAlloc(datalen);
+	zf->data = attemptckalloc(datalen);
 	if (!zf->data) {
 	    if (interp) {
 		Tcl_AppendResult(interp, "out of memory", (char *) NULL);
 		Tcl_SetErrorCode(interp, "TCL", "MALLOC", NULL);
 	    }
@@ -1775,11 +1779,11 @@
     if (ZipFSFindTOC(interp, 0, zf) != TCL_OK) {
 	return TCL_ERROR;
     }
     result = ZipFSCatalogFilesystem(interp, zf, mountPoint, NULL,
 	    "Memory Buffer");
-    Tcl_Free(zf);
+    ckfree(zf);
     return result;
 }
 
 /*
  *-------------------------------------------------------------------------
@@ -1839,17 +1843,17 @@
 	hPtr = Tcl_FindHashEntry(&ZipFS.fileHash, z->name);
 	if (hPtr) {
 	    Tcl_DeleteHashEntry(hPtr);
 	}
 	if (z->data) {
-	    Tcl_Free(z->data);
+	    ckfree(z->data);
 	}
-	Tcl_Free(z);
+	ckfree(z);
     }
     ZipFSCloseArchive(interp, zf);
     Tcl_DeleteExitHandler(ZipfsExitHandler, (ClientData)zf);
-    Tcl_Free(zf);
+    ckfree(zf);
     unmounted = 1;
   done:
     Unlock();
     if (unmounted) {
 	Tcl_FSMountsChanged(NULL);
@@ -1884,13 +1888,13 @@
 	Tcl_WrongNumArgs(interp, 1, objv,
 		 "?mountpoint? ?zipfile? ?password?");
 	return TCL_ERROR;
     }
 
-    return TclZipfs_Mount(interp, (objc > 1) ? TclGetString(objv[1]) : NULL,
-	    (objc > 2) ? TclGetString(objv[2]) : NULL,
-	    (objc > 3) ? TclGetString(objv[3]) : NULL);
+    return TclZipfs_Mount(interp, (objc > 1) ? Tcl_GetString(objv[1]) : NULL,
+	    (objc > 2) ? Tcl_GetString(objv[2]) : NULL,
+	    (objc > 3) ? Tcl_GetString(objv[3]) : NULL);
 }
 
 /*
  *-------------------------------------------------------------------------
  *
@@ -1914,11 +1918,11 @@
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     const char *mountPoint;	/* Mount point path. */
     unsigned char *data;
-    size_t length = 0;
+    int length;
 
     if (objc > 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "?mountpoint? ?data?");
 	return TCL_ERROR;
     }
@@ -1929,19 +1933,19 @@
 	ret = ListMountPoints(interp);
 	Unlock();
 	return ret;
     }
 
-    mountPoint = TclGetString(objv[1]);
+    mountPoint = Tcl_GetString(objv[1]);
     if (objc < 3) {
 	ReadLock();
 	DescribeMounted(interp, mountPoint);
 	Unlock();
 	return TCL_OK;
     }
 
-    data = TclGetByteArrayFromObj(objv[2], &length);
+    data = Tcl_GetByteArrayFromObj(objv[2], &length);
     return TclZipfs_MountBuffer(interp, mountPoint, data, length, 1);
 }
 
 /*
  *-------------------------------------------------------------------------
@@ -1995,11 +1999,11 @@
 {
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "zipfile");
 	return TCL_ERROR;
     }
-    return TclZipfs_Unmount(interp, TclGetString(objv[1]));
+    return TclZipfs_Unmount(interp, Tcl_GetString(objv[1]));
 }
 
 /*
  *-------------------------------------------------------------------------
  *
@@ -2029,11 +2033,11 @@
 
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "password");
 	return TCL_ERROR;
     }
-    pw = TclGetString(objv[1]);
+    pw = Tcl_GetString(objv[1]);
     len = strlen(pw);
     if (len == 0) {
 	return TCL_OK;
     }
     if ((len > 255) || strchr(pw, 0xff)) {
@@ -2146,11 +2150,11 @@
     Tcl_ResetResult(interp);
     crc = 0;
     nbyte = nbytecompr = 0;
     while (1) {
 	len = Tcl_Read(in, buf, bufsize);
-	if (len == TCL_IO_FAILURE) {
+	if (len == ERROR_LENGTH) {
 	    if (nbyte == 0 && errno == EISDIR) {
 		Tcl_Close(interp, in);
 		return TCL_OK;
 	    }
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf("read error on \"%s\": %s",
@@ -2172,11 +2176,11 @@
     }
     pos[0] = Tcl_Tell(out);
     memset(buf, '\0', ZIP_LOCAL_HEADER_LEN);
     memcpy(buf + ZIP_LOCAL_HEADER_LEN, zpath, zpathlen);
     len = zpathlen + ZIP_LOCAL_HEADER_LEN;
-    if (Tcl_Write(out, buf, len) != len) {
+    if ((size_t) Tcl_Write(out, buf, len) != len) {
     wrerr:
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"write error on %s: %s", path, Tcl_PosixError(interp)));
 	Tcl_Close(interp, in);
 	return TCL_ERROR;
@@ -2191,11 +2195,11 @@
 
 	align = 4 + ((len + pos[0]) & 3);
 	ZipWriteShort(abuf, 0xffff);
 	ZipWriteShort(abuf + 2, align - 4);
 	ZipWriteInt(abuf + 4, 0x03020100);
-	if (Tcl_Write(out, (const char *) abuf, align) != align) {
+	if ((size_t) Tcl_Write(out, (const char *) abuf, align) != align) {
 	    goto wrerr;
 	}
     }
     if (passwd) {
 	int i, ch, tmp;
@@ -2262,11 +2266,11 @@
 	Tcl_Close(interp, in);
 	return TCL_ERROR;
     }
     do {
 	len = Tcl_Read(in, buf, bufsize);
-	if (len == TCL_IO_FAILURE) {
+	if (len == ERROR_LENGTH) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "read error on %s: %s", path, Tcl_PosixError(interp)));
 	    deflateEnd(&stream);
 	    Tcl_Close(interp, in);
 	    return TCL_ERROR;
@@ -2293,11 +2297,11 @@
 
 		for (i = 0; i < olen; i++) {
 		    obuf[i] = (char) zencode(keys, crc32tab, obuf[i], tmp);
 		}
 	    }
-	    if (olen && (Tcl_Write(out, obuf, olen) != olen)) {
+	    if (olen && ((size_t) Tcl_Write(out, obuf, olen) != olen)) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"write error: %s", Tcl_PosixError(interp)));
 		deflateEnd(&stream);
 		Tcl_Close(interp, in);
 		return TCL_ERROR;
@@ -2323,11 +2327,11 @@
 	    return TCL_ERROR;
 	}
 	nbytecompr = (passwd ? 12 : 0);
 	while (1) {
 	    len = Tcl_Read(in, buf, bufsize);
-	    if (len == TCL_IO_FAILURE) {
+	    if (len == ERROR_LENGTH) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"read error on \"%s\": %s",
 			path, Tcl_PosixError(interp)));
 		Tcl_Close(interp, in);
 		return TCL_ERROR;
@@ -2340,11 +2344,11 @@
 
 		for (i = 0; i < len; i++) {
 		    buf[i] = (char) zencode(keys0, crc32tab, buf[i], tmp);
 		}
 	    }
-	    if (Tcl_Write(out, buf, len) != len) {
+	    if ((size_t) Tcl_Write(out, buf, len) != len) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"write error: %s", Tcl_PosixError(interp)));
 		Tcl_Close(interp, in);
 		return TCL_ERROR;
 	    }
@@ -2363,11 +2367,11 @@
 		"non-unique path name \"%s\"", path));
 	Tcl_SetErrorCode(interp, "TCL", "ZIPFS", "DUPLICATE_PATH", NULL);
 	return TCL_ERROR;
     }
 
-    z = Tcl_Alloc(sizeof(ZipEntry));
+    z = ckalloc(sizeof(ZipEntry));
     Tcl_SetHashValue(hPtr, z);
     z->name = NULL;
     z->tnext = NULL;
     z->depth = 0;
     z->zipFilePtr = NULL;
@@ -2397,26 +2401,26 @@
     ZipWriteInt(buf + ZIP_LOCAL_UNCOMPLEN_OFFS, z->numBytes);
     ZipWriteShort(buf + ZIP_LOCAL_PATHLEN_OFFS, zpathlen);
     ZipWriteShort(buf + ZIP_LOCAL_EXTRALEN_OFFS, align);
     if (Tcl_Seek(out, pos[0], SEEK_SET) != pos[0]) {
 	Tcl_DeleteHashEntry(hPtr);
-	Tcl_Free(z);
+	ckfree(z);
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"seek error: %s", Tcl_PosixError(interp)));
 	return TCL_ERROR;
     }
     if (Tcl_Write(out, buf, ZIP_LOCAL_HEADER_LEN) != ZIP_LOCAL_HEADER_LEN) {
 	Tcl_DeleteHashEntry(hPtr);
-	Tcl_Free(z);
+	ckfree(z);
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"write error: %s", Tcl_PosixError(interp)));
 	return TCL_ERROR;
     }
     Tcl_Flush(out);
     if (Tcl_Seek(out, pos[1], SEEK_SET) != pos[1]) {
 	Tcl_DeleteHashEntry(hPtr);
-	Tcl_Free(z);
+	ckfree(z);
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"seek error: %s", Tcl_PosixError(interp)));
 	return TCL_ERROR;
     }
     return TCL_OK;
@@ -2464,11 +2468,11 @@
      * Caller has verified that the number of arguments is correct.
      */
 
     passBuf[0] = 0;
     if (objc > (isList ? 3 : 4)) {
-	pw = TclGetString(objv[isList ? 3 : 4]);
+	pw = Tcl_GetString(objv[isList ? 3 : 4]);
 	pwlen = strlen(pw);
 	if ((pwlen > 255) || strchr(pw, 0xff)) {
 	    Tcl_SetObjResult(interp,
 		    Tcl_NewStringObj("illegal password", -1));
 	    Tcl_SetErrorCode(interp, "TCL", "ZIPFS", "BAD_PASS", NULL);
@@ -2508,11 +2512,11 @@
 	Tcl_DecrRefCount(list);
 	Tcl_SetObjResult(interp, Tcl_NewStringObj("empty archive", -1));
 	Tcl_SetErrorCode(interp, "TCL", "ZIPFS", "EMPTY", NULL);
 	return TCL_ERROR;
     }
-    out = Tcl_OpenFileChannel(interp, TclGetString(objv[1]), "wb", 0755);
+    out = Tcl_OpenFileChannel(interp, Tcl_GetString(objv[1]), "wb", 0755);
     if (out == NULL) {
 	Tcl_DecrRefCount(list);
 	return TCL_ERROR;
     }
     if (pwlen <= 0) {
@@ -2523,14 +2527,14 @@
 	ZipFile *zf, zf0;
 	int isMounted = 0;
 	const char *imgName;
 
 	if (isList) {
-	    imgName = (objc > 4) ? TclGetString(objv[4]) :
+	    imgName = (objc > 4) ? Tcl_GetString(objv[4]) :
 		    Tcl_GetNameOfExecutable();
 	} else {
-	    imgName = (objc > 5) ? TclGetString(objv[5]) :
+	    imgName = (objc > 5) ? Tcl_GetString(objv[5]) :
 		    Tcl_GetNameOfExecutable();
 	}
 	if (pwlen) {
 	    i = 0;
 	    for (len = pwlen; len-- > 0;) {
@@ -2565,11 +2569,11 @@
 	Unlock();
 	if (!isMounted) {
 	    zf = &zf0;
 	}
 	if (isMounted || ZipFSOpenArchive(interp, imgName, 0, zf) == TCL_OK) {
-	    if (Tcl_Write(out, (char *) zf->data,
+	    if ((size_t) Tcl_Write(out, (char *) zf->data,
 		    zf->passOffset) != zf->passOffset) {
 		memset(passBuf, 0, sizeof(passBuf));
 		Tcl_DecrRefCount(list);
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"write error: %s", Tcl_PosixError(interp)));
@@ -2608,11 +2612,11 @@
 		Tcl_DecrRefCount(list);
 		Tcl_Close(interp, out);
 		return TCL_ERROR;
 	    }
 	    i = Tcl_Seek(in, 0, SEEK_END);
-	    if (i == TCL_IO_FAILURE) {
+	    if (i == ERROR_LENGTH) {
 	    cperr:
 		memset(passBuf, 0, sizeof(passBuf));
 		Tcl_DecrRefCount(list);
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"%s: %s", errMsg, Tcl_PosixError(interp)));
@@ -2656,19 +2660,19 @@
 	Tcl_Flush(out);
     }
     Tcl_InitHashTable(&fileHash, TCL_STRING_KEYS);
     pos[0] = Tcl_Tell(out);
     if (!isList && (objc > 3)) {
-	strip = TclGetString(objv[3]);
+	strip = Tcl_GetString(objv[3]);
 	slen = strlen(strip);
     }
     for (i = 0; i < (size_t) lobjc; i += (isList ? 2 : 1)) {
 	const char *path, *name;
 
-	path = TclGetString(lobjv[i]);
+	path = Tcl_GetString(lobjv[i]);
 	if (isList) {
-	    name = TclGetString(lobjv[i + 1]);
+	    name = Tcl_GetString(lobjv[i + 1]);
 	} else {
 	    name = path;
 	    if (slen > 0) {
 		len = strlen(name);
 		if ((len <= slen) || (strncmp(strip, name, slen) != 0)) {
@@ -2691,13 +2695,13 @@
     pos[1] = Tcl_Tell(out);
     count = 0;
     for (i = 0; i < (size_t) lobjc; i += (isList ? 2 : 1)) {
 	const char *path, *name;
 
-	path = TclGetString(lobjv[i]);
+	path = Tcl_GetString(lobjv[i]);
 	if (isList) {
-	    name = TclGetString(lobjv[i + 1]);
+	    name = Tcl_GetString(lobjv[i + 1]);
 	} else {
 	    name = path;
 	    if (slen > 0) {
 		len = strlen(name);
 		if ((len <= slen) || (strncmp(strip, name, slen) != 0)) {
@@ -2735,11 +2739,11 @@
 	ZipWriteShort(buf + ZIP_CENTRAL_IATTR_OFFS, 0);
 	ZipWriteInt(buf + ZIP_CENTRAL_EATTR_OFFS, 0);
 	ZipWriteInt(buf + ZIP_CENTRAL_LOCALHDR_OFFS, z->offset - pos[0]);
 	if ((Tcl_Write(out, buf,
 		    ZIP_CENTRAL_HEADER_LEN) != ZIP_CENTRAL_HEADER_LEN)
-		|| (Tcl_Write(out, z->name, len) != len)) {
+		|| ((size_t) Tcl_Write(out, z->name, len) != len)) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "write error: %s", Tcl_PosixError(interp)));
 	    goto done;
 	}
 	count++;
@@ -2770,11 +2774,11 @@
     }
     Tcl_DecrRefCount(list);
     for (hPtr = Tcl_FirstHashEntry(&fileHash, &search); hPtr;
 	    hPtr = Tcl_NextHashEntry(&search)) {
 	z = Tcl_GetHashValue(hPtr);
-	Tcl_Free(z);
+	ckfree(z);
 	Tcl_DeleteHashEntry(hPtr);
     }
     Tcl_DeleteHashTable(&fileHash);
     return ret;
 }
@@ -2927,24 +2931,24 @@
 	Tcl_WrongNumArgs(interp, 1, objv, "?mountpoint? filename ?inZipfs?");
 	return TCL_ERROR;
     }
     Tcl_DStringInit(&dPath);
     if (objc == 2) {
-	filename = TclGetString(objv[1]);
+	filename = Tcl_GetString(objv[1]);
 	result = CanonicalPath("", filename, &dPath, 1);
     } else if (objc == 3) {
-	mntpoint = TclGetString(objv[1]);
-	filename = TclGetString(objv[2]);
+	mntpoint = Tcl_GetString(objv[1]);
+	filename = Tcl_GetString(objv[2]);
 	result = CanonicalPath(mntpoint, filename, &dPath, 1);
     } else {
 	int zipfs = 0;
 
 	if (Tcl_GetBooleanFromObj(interp, objv[3], &zipfs)) {
 	    return TCL_ERROR;
 	}
-	mntpoint = TclGetString(objv[1]);
-	filename = TclGetString(objv[2]);
+	mntpoint = Tcl_GetString(objv[1]);
+	filename = Tcl_GetString(objv[2]);
 	result = CanonicalPath(mntpoint, filename, &dPath, zipfs);
     }
     Tcl_SetObjResult(interp, Tcl_NewStringObj(result, -1));
     return TCL_OK;
 }
@@ -2985,11 +2989,11 @@
 
     /*
      * Prepend ZIPFS_VOLUME to filename, eliding the final /
      */
 
-    filename = TclGetString(objv[1]);
+    filename = Tcl_GetString(objv[1]);
     Tcl_DStringInit(&ds);
     Tcl_DStringAppend(&ds, ZIPFS_VOLUME, ZIPFS_VOLUME_LEN - 1);
     Tcl_DStringAppend(&ds, filename, -1);
     filename = Tcl_DStringValue(&ds);
 
@@ -3032,11 +3036,11 @@
 
     if (objc != 2) {
 	Tcl_WrongNumArgs(interp, 1, objv, "filename");
 	return TCL_ERROR;
     }
-    filename = TclGetString(objv[1]);
+    filename = Tcl_GetString(objv[1]);
     ReadLock();
     z = ZipFSLookup(filename);
     if (z) {
 	Tcl_Obj *result = Tcl_GetObjResult(interp);
 
@@ -3086,17 +3090,17 @@
     if (objc > 3) {
 	Tcl_WrongNumArgs(interp, 1, objv, "?(-glob|-regexp)? ?pattern?");
 	return TCL_ERROR;
     }
     if (objc == 3) {
-	size_t n;
-	char *what = TclGetStringFromObj(objv[1], &n);
+	int n;
+	char *what = Tcl_GetStringFromObj(objv[1], &n);
 
 	if ((n >= 2) && (strncmp(what, "-glob", n) == 0)) {
-	    pattern = TclGetString(objv[2]);
+	    pattern = Tcl_GetString(objv[2]);
 	} else if ((n >= 2) && (strncmp(what, "-regexp", n) == 0)) {
-	    regexp = Tcl_RegExpCompile(interp, TclGetString(objv[2]));
+	    regexp = Tcl_RegExpCompile(interp, Tcl_GetString(objv[2]));
 	    if (!regexp) {
 		return TCL_ERROR;
 	    }
 	} else {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
@@ -3103,11 +3107,11 @@
 		    "unknown option \"%s\"", what));
 	    Tcl_SetErrorCode(interp, "TCL", "ZIPFS", "BAD_OPT", NULL);
 	    return TCL_ERROR;
 	}
     } else if (objc == 2) {
-	pattern = TclGetString(objv[1]);
+	pattern = Tcl_GetString(objv[1]);
     }
     ReadLock();
     if (pattern) {
 	for (hPtr = Tcl_FirstHashEntry(&ZipFS.fileHash, &search);
 		hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
@@ -3307,24 +3311,24 @@
     Tcl_Interp *interp)		/* Current interpreter. */
 {
     ZipChannel *info = instanceData;
 
     if (info->iscompr && info->ubuf) {
-	Tcl_Free(info->ubuf);
+	ckfree(info->ubuf);
 	info->ubuf = NULL;
     }
     if (info->isEncrypted) {
 	info->isEncrypted = 0;
 	memset(info->keys, 0, sizeof(info->keys));
     }
     if (info->isWriting) {
 	ZipEntry *z = info->zipEntryPtr;
-	unsigned char *newdata = Tcl_AttemptRealloc(info->ubuf, info->numRead);
+	unsigned char *newdata = attemptckrealloc(info->ubuf, info->numRead);
 
 	if (newdata) {
 	    if (z->data) {
-		Tcl_Free(z->data);
+		ckfree(z->data);
 	    }
 	    z->data = newdata;
 	    z->numBytes = z->numCompressedBytes = info->numBytes;
 	    z->compressMethod = ZIP_COMPMETH_STORED;
 	    z->timestamp = time(NULL);
@@ -3331,17 +3335,17 @@
 	    z->isDirectory = 0;
 	    z->isEncrypted = 0;
 	    z->offset = 0;
 	    z->crc32 = 0;
 	} else {
-	    Tcl_Free(info->ubuf);
+	    ckfree(info->ubuf);
 	}
     }
     WriteLock();
     info->zipFilePtr->numOpen--;
     Unlock();
-    Tcl_Free(info);
+    ckfree(info);
     return TCL_OK;
 }
 
 /*
  *-------------------------------------------------------------------------
@@ -3667,11 +3671,11 @@
 	    goto error;
 	}
     } else {
 	flags = TCL_WRITABLE;
     }
-    info = Tcl_AttemptAlloc(sizeof(ZipChannel));
+    info = attemptckalloc(sizeof(ZipChannel));
     if (!info) {
 	ZIPFS_ERROR(interp, "out of memory");
 	if (interp) {
 	    Tcl_SetErrorCode(interp, "TCL", "MALLOC", NULL);
 	}
@@ -3685,17 +3689,17 @@
 	info->isWriting = 1;
 	info->isDirectory = 0;
 	info->maxWrite = ZipFS.wrmax;
 	info->iscompr = 0;
 	info->isEncrypted = 0;
-	info->ubuf = Tcl_AttemptAlloc(info->maxWrite);
+	info->ubuf = attemptckalloc(info->maxWrite);
 	if (!info->ubuf) {
 	merror0:
 	    if (info->ubuf) {
-		Tcl_Free(info->ubuf);
+		ckfree(info->ubuf);
 	    }
-	    Tcl_Free(info);
+	    ckfree(info);
 	    ZIPFS_ERROR(interp, "out of memory");
 	    if (interp) {
 		Tcl_SetErrorCode(interp, "TCL", "MALLOC", NULL);
 	    }
 	    goto error;
@@ -3702,11 +3706,11 @@
 	}
 	memset(info->ubuf, 0, info->maxWrite);
 	if (trunc) {
 	    info->numBytes = 0;
 	} else if (z->data) {
-	    size_t j = z->numBytes;
+	    unsigned int j = z->numBytes;
 
 	    if (j > info->maxWrite) {
 		j = info->maxWrite;
 	    }
 	    memcpy(info->ubuf, z->data, j);
@@ -3740,14 +3744,14 @@
 		stream.zalloc = Z_NULL;
 		stream.zfree = Z_NULL;
 		stream.opaque = Z_NULL;
 		stream.avail_in = z->numCompressedBytes;
 		if (z->isEncrypted) {
-		    size_t j;
+		    unsigned int j;
 
 		    stream.avail_in -= 12;
-		    cbuf = Tcl_AttemptAlloc(stream.avail_in);
+		    cbuf = attemptckalloc(stream.avail_in);
 		    if (!cbuf) {
 			goto merror0;
 		    }
 		    for (j = 0; j < stream.avail_in; j++) {
 			ch = info->ubuf[j];
@@ -3766,23 +3770,23 @@
 		inflateEnd(&stream);
 		if ((err == Z_STREAM_END)
 			|| ((err == Z_OK) && (stream.avail_in == 0))) {
 		    if (cbuf) {
 			memset(info->keys, 0, sizeof(info->keys));
-			Tcl_Free(cbuf);
+			ckfree(cbuf);
 		    }
 		    goto wrapchan;
 		}
 	    cerror0:
 		if (cbuf) {
 		    memset(info->keys, 0, sizeof(info->keys));
-		    Tcl_Free(cbuf);
+		    ckfree(cbuf);
 		}
 		if (info->ubuf) {
-		    Tcl_Free(info->ubuf);
+		    ckfree(info->ubuf);
 		}
-		Tcl_Free(info);
+		ckfree(info);
 		ZIPFS_ERROR(interp, "decompression error");
 		if (interp) {
 		    Tcl_SetErrorCode(interp, "TCL", "ZIPFS", "CORRUPT", NULL);
 		}
 		goto error;
@@ -3834,20 +3838,20 @@
 	}
 	if (info->iscompr) {
 	    z_stream stream;
 	    int err;
 	    unsigned char *ubuf = NULL;
-	    size_t j;
+	    unsigned int j;
 
 	    memset(&stream, 0, sizeof(z_stream));
 	    stream.zalloc = Z_NULL;
 	    stream.zfree = Z_NULL;
 	    stream.opaque = Z_NULL;
 	    stream.avail_in = z->numCompressedBytes;
 	    if (info->isEncrypted) {
 		stream.avail_in -= 12;
-		ubuf = Tcl_AttemptAlloc(stream.avail_in);
+		ubuf = attemptckalloc(stream.avail_in);
 		if (!ubuf) {
 		    info->ubuf = NULL;
 		    goto merror;
 		}
 		for (j = 0; j < stream.avail_in; j++) {
@@ -3856,19 +3860,19 @@
 		}
 		stream.next_in = ubuf;
 	    } else {
 		stream.next_in = info->ubuf;
 	    }
-	    stream.next_out = info->ubuf = Tcl_AttemptAlloc(info->numBytes);
+	    stream.next_out = info->ubuf = attemptckalloc(info->numBytes);
 	    if (!info->ubuf) {
 	    merror:
 		if (ubuf) {
 		    info->isEncrypted = 0;
 		    memset(info->keys, 0, sizeof(info->keys));
-		    Tcl_Free(ubuf);
+		    ckfree(ubuf);
 		}
-		Tcl_Free(info);
+		ckfree(info);
 		if (interp) {
 		    Tcl_SetObjResult(interp,
 			    Tcl_NewStringObj("out of memory", -1));
 		    Tcl_SetErrorCode(interp, "TCL", "MALLOC", NULL);
 		}
@@ -3883,42 +3887,42 @@
 	    if ((err == Z_STREAM_END)
 		    || ((err == Z_OK) && (stream.avail_in == 0))) {
 		if (ubuf) {
 		    info->isEncrypted = 0;
 		    memset(info->keys, 0, sizeof(info->keys));
-		    Tcl_Free(ubuf);
+		    ckfree(ubuf);
 		}
 		goto wrapchan;
 	    }
 	cerror:
 	    if (ubuf) {
 		info->isEncrypted = 0;
 		memset(info->keys, 0, sizeof(info->keys));
-		Tcl_Free(ubuf);
+		ckfree(ubuf);
 	    }
 	    if (info->ubuf) {
-		Tcl_Free(info->ubuf);
+		ckfree(info->ubuf);
 	    }
-	    Tcl_Free(info);
+	    ckfree(info);
 	    ZIPFS_ERROR(interp, "decompression error");
 	    if (interp) {
 		Tcl_SetErrorCode(interp, "TCL", "ZIPFS", "CORRUPT", NULL);
 	    }
 	    goto error;
 	} else if (info->isEncrypted) {
 	    unsigned char *ubuf = NULL;
-	    size_t j, len;
+	    unsigned int j, len;
 
 	    /*
 	     * Decode encrypted but uncompressed file, since we support
 	     * Tcl_Seek() on it, and it can be randomly accessed later.
 	     */
 
 	    len = z->numCompressedBytes - 12;
-	    ubuf = (unsigned char *) Tcl_AttemptAlloc(len);
+	    ubuf = (unsigned char *) attemptckalloc(len);
 	    if (ubuf == NULL) {
-		Tcl_Free((char *) info);
+		ckfree((char *) info);
 		if (interp != NULL) {
 		    Tcl_SetObjResult(interp,
 			Tcl_NewStringObj("out of memory", -1));
 		}
 		goto error;
@@ -4038,15 +4042,17 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     Tcl_Obj *pathPtr,
     int mode,
     int permissions)
 {
+    int len;
+
     pathPtr = Tcl_FSGetNormalizedPath(NULL, pathPtr);
     if (!pathPtr) {
 	return NULL;
     }
-    return ZipChannelOpen(interp, TclGetString(pathPtr), mode,
+    return ZipChannelOpen(interp, Tcl_GetStringFromObj(pathPtr, &len), mode,
 	    permissions);
 }
 
 /*
  *-------------------------------------------------------------------------
@@ -4068,16 +4074,17 @@
 static int
 ZipFSStatProc(
     Tcl_Obj *pathPtr,
     Tcl_StatBuf *buf)
 {
+    int len;
 
     pathPtr = Tcl_FSGetNormalizedPath(NULL, pathPtr);
     if (!pathPtr) {
 	return -1;
     }
-    return ZipEntryStat(TclGetString(pathPtr), buf);
+    return ZipEntryStat(Tcl_GetStringFromObj(pathPtr, &len), buf);
 }
 
 /*
  *-------------------------------------------------------------------------
  *
@@ -4098,15 +4105,17 @@
 static int
 ZipFSAccessProc(
     Tcl_Obj *pathPtr,
     int mode)
 {
+    int len;
+
     pathPtr = Tcl_FSGetNormalizedPath(NULL, pathPtr);
     if (!pathPtr) {
 	return -1;
     }
-    return ZipEntryAccess(TclGetString(pathPtr), mode);
+    return ZipEntryAccess(Tcl_GetStringFromObj(pathPtr, &len), mode);
 }
 
 /*
  *-------------------------------------------------------------------------
  *
@@ -4161,12 +4170,12 @@
     Tcl_GlobTypeData *types)
 {
     Tcl_HashEntry *hPtr;
     Tcl_HashSearch search;
     Tcl_Obj *normPathPtr = Tcl_FSGetNormalizedPath(NULL, pathPtr);
-    int scnt, l, dirOnly = -1, strip = 0;
-    size_t len, prefixLen;
+    int scnt, l, dirOnly = -1, prefixLen, strip = 0;
+    size_t len;
     char *pat, *prefix, *path;
     Tcl_DString dsPref;
 
     if (!normPathPtr) {
 	return -1;
@@ -4177,17 +4186,18 @@
 
     /*
      * The prefix that gets prepended to results.
      */
 
-    prefix = TclGetStringFromObj(pathPtr, &prefixLen);
+    prefix = Tcl_GetStringFromObj(pathPtr, &prefixLen);
 
     /*
      * The (normalized) path we're searching.
      */
 
-    path = TclGetStringFromObj(normPathPtr, &len);
+    path = Tcl_GetString(normPathPtr);
+    len = normPathPtr->length;
 
     Tcl_DStringInit(&dsPref);
     Tcl_DStringAppend(&dsPref, prefix, prefixLen);
 
     if (strcmp(prefix, path) == 0) {
@@ -4282,11 +4292,11 @@
 	}
 	goto end;
     }
 
     l = strlen(pattern);
-    pat = Tcl_Alloc(len + l + 2);
+    pat = ckalloc(len + l + 2);
     memcpy(pat, path, len);
     while ((len > 1) && (pat[len - 1] == '/')) {
 	--len;
     }
     if ((len > 1) || (pat[0] != '/')) {
@@ -4314,11 +4324,11 @@
 		Tcl_ListObjAppendElement(NULL, result,
 			Tcl_NewStringObj(z->name + strip, -1));
 	    }
 	}
     }
-    Tcl_Free(pat);
+    ckfree(pat);
 
   end:
     Unlock();
     Tcl_DStringFree(&dsPref);
     return TCL_OK;
@@ -4355,14 +4365,16 @@
     pathPtr = Tcl_FSGetNormalizedPath(NULL, pathPtr);
     if (!pathPtr) {
 	return -1;
     }
 
-    path = TclGetStringFromObj(pathPtr, &len);
+    path = Tcl_GetString(pathPtr);
     if (strncmp(path, ZIPFS_VOLUME, ZIPFS_VOLUME_LEN) != 0) {
 	return -1;
     }
+
+    len = pathPtr->length;
 
     ReadLock();
     hPtr = Tcl_FindHashEntry(&ZipFS.fileHash, path);
     if (hPtr) {
 	ret = TCL_OK;
@@ -4478,19 +4490,19 @@
     Tcl_Interp *interp,		/* Current interpreter. */
     int index,
     Tcl_Obj *pathPtr,
     Tcl_Obj **objPtrRef)
 {
-    int ret = TCL_OK;
+    int len, ret = TCL_OK;
     char *path;
     ZipEntry *z;
 
     pathPtr = Tcl_FSGetNormalizedPath(NULL, pathPtr);
     if (!pathPtr) {
 	return -1;
     }
-    path = TclGetString(pathPtr);
+    path = Tcl_GetStringFromObj(pathPtr, &len);
     ReadLock();
     z = ZipFSLookup(path);
     if (!z) {
 	Tcl_SetErrno(ENOENT);
 	ZIPFS_POSIX_ERROR(interp, "file not found");
@@ -4713,11 +4725,11 @@
  *	related commands to the given interpreter.
  *
  *-------------------------------------------------------------------------
  */
 
-MODULE_SCOPE int
+int
 TclZipfs_Init(
     Tcl_Interp *interp)		/* Current interpreter. */
 {
 #ifdef HAVE_ZLIB
     static const EnsembleImplMap initMap[] = {
@@ -4783,11 +4795,11 @@
 	Tcl_GetEnsembleMappingDict(NULL, ensemble, &mapObj);
 	Tcl_DictObjPut(NULL, mapObj, Tcl_NewStringObj("find", -1),
 		Tcl_NewStringObj("::tcl::zipfs::find", -1));
 	Tcl_CreateObjCommand(interp, "::tcl::zipfs::tcl_library_init",
 		ZipFSTclLibraryObjCmd, NULL, NULL);
-	Tcl_PkgProvideEx(interp, "zipfs", "2.0", NULL);
+	Tcl_PkgProvide(interp, "zipfs", "2.0");
     }
     return TCL_OK;
 #else /* !HAVE_ZLIB */
     ZIPFS_ERROR(interp, "no zlib available");
     Tcl_SetErrorCode(interp, "TCL", "ZIPFS", "NO_ZLIB", NULL);

Index: generic/tclZlib.c
==================================================================
--- generic/tclZlib.c
+++ generic/tclZlib.c
@@ -62,11 +62,11 @@
     z_stream stream;		/* The interface to the zlib library. */
     int streamEnd;		/* If we've got to end-of-stream. */
     Tcl_Obj *inData, *outData;	/* Input / output buffers (lists) */
     Tcl_Obj *currentInput;	/* Pointer to what is currently being
 				 * inflated. */
-    size_t outPos;
+    int outPos;
     int mode;			/* Either TCL_ZLIB_STREAM_DEFLATE or
 				 * TCL_ZLIB_STREAM_INFLATE. */
     int format;			/* Flags from the TCL_ZLIB_FORMAT_* */
     int level;			/* Default 5, 0-9 */
     int flush;			/* Stores the flush param for deferred the
@@ -176,18 +176,18 @@
 
 static void		ConvertError(Tcl_Interp *interp, int code,
 			    uLong adler);
 static Tcl_Obj *	ConvertErrorToList(int code, uLong adler);
 static inline int	Deflate(z_streamp strm, void *bufferPtr,
-			    size_t bufferSize, int flush, size_t *writtenPtr);
+			    int bufferSize, int flush, int *writtenPtr);
 static void		ExtractHeader(gz_header *headerPtr, Tcl_Obj *dictObj);
 static int		GenerateHeader(Tcl_Interp *interp, Tcl_Obj *dictObj,
 			    GzipHeader *headerPtr, int *extraSizePtr);
 static int		ZlibPushSubcmd(Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 static inline int	ResultCopy(ZlibChannelData *cd, char *buf,
-			    size_t toRead);
+			    int toRead);
 static int		ResultGenerate(ZlibChannelData *cd, int n, int flush,
 			    int *errorCodePtr);
 static Tcl_Channel	ZlibStackChannelTransform(Tcl_Interp *interp,
 			    int mode, int format, int level, int limit,
 			    Tcl_Channel channel, Tcl_Obj *gzipHeaderDictPtr,
@@ -420,11 +420,10 @@
     int *extraSizePtr)		/* Variable to add the length of header
 				 * strings (filename, comment) to. */
 {
     Tcl_Obj *value;
     int len, result = TCL_ERROR;
-    size_t length;
     Tcl_WideInt wideValue = 0;
     const char *valueStr;
     Tcl_Encoding latin1enc;
     static const char *const types[] = {
 	"binary", "text"
@@ -440,12 +439,12 @@
     }
 
     if (GetValue(interp, dictObj, "comment", &value) != TCL_OK) {
 	goto error;
     } else if (value != NULL) {
-	valueStr = TclGetStringFromObj(value, &length);
-	Tcl_UtfToExternal(NULL, latin1enc, valueStr, length, 0, NULL,
+	valueStr = TclGetStringFromObj(value, &len);
+	Tcl_UtfToExternal(NULL, latin1enc, valueStr, len, 0, NULL,
 		headerPtr->nativeCommentBuf, MAX_COMMENT_LEN-1, NULL, &len,
 		NULL);
 	headerPtr->nativeCommentBuf[len] = '\0';
 	headerPtr->header.comment = (Bytef *) headerPtr->nativeCommentBuf;
 	if (extraSizePtr != NULL) {
@@ -461,12 +460,12 @@
     }
 
     if (GetValue(interp, dictObj, "filename", &value) != TCL_OK) {
 	goto error;
     } else if (value != NULL) {
-	valueStr = TclGetStringFromObj(value, &length);
-	Tcl_UtfToExternal(NULL, latin1enc, valueStr, length, 0, NULL,
+	valueStr = TclGetStringFromObj(value, &len);
+	Tcl_UtfToExternal(NULL, latin1enc, valueStr, len, 0, NULL,
 		headerPtr->nativeFilenameBuf, MAXPATHLEN-1, NULL, &len, NULL);
 	headerPtr->nativeFilenameBuf[len] = '\0';
 	headerPtr->header.name = (Bytef *) headerPtr->nativeFilenameBuf;
 	if (extraSizePtr != NULL) {
 	    *extraSizePtr += len;
@@ -591,12 +590,12 @@
 SetInflateDictionary(
     z_streamp strm,
     Tcl_Obj *compDictObj)
 {
     if (compDictObj != NULL) {
-	size_t length = 0;
-	unsigned char *bytes = TclGetByteArrayFromObj(compDictObj, &length);
+	int length;
+	unsigned char *bytes = Tcl_GetByteArrayFromObj(compDictObj, &length);
 
 	return inflateSetDictionary(strm, bytes, length);
     }
     return Z_OK;
 }
@@ -605,12 +604,12 @@
 SetDeflateDictionary(
     z_streamp strm,
     Tcl_Obj *compDictObj)
 {
     if (compDictObj != NULL) {
-	size_t length = 0;
-	unsigned char *bytes = TclGetByteArrayFromObj(compDictObj, &length);
+	int length;
+	unsigned char *bytes = Tcl_GetByteArrayFromObj(compDictObj, &length);
 
 	return deflateSetDictionary(strm, bytes, length);
     }
     return Z_OK;
 }
@@ -617,13 +616,13 @@
 
 static inline int
 Deflate(
     z_streamp strm,
     void *bufferPtr,
-    size_t bufferSize,
+    int bufferSize,
     int flush,
-    size_t *writtenPtr)
+    int *writtenPtr)
 {
     int e;
 
     strm->next_out = (Bytef *) bufferPtr;
     strm->avail_out = bufferSize;
@@ -636,11 +635,11 @@
 
 static inline void
 AppendByteArray(
     Tcl_Obj *listObj,
     void *buffer,
-    size_t size)
+    int size)
 {
     if (size > 0) {
 	Tcl_Obj *baObj = Tcl_NewByteArrayObj((unsigned char *) buffer, size);
 
 	Tcl_ListObjAppendElement(NULL, listObj, baObj);
@@ -698,15 +697,15 @@
 	    wbits = WBITS_RAW;
 	    break;
 	case TCL_ZLIB_FORMAT_GZIP:
 	    wbits = WBITS_GZIP;
 	    if (dictObj) {
-		gzHeaderPtr = Tcl_Alloc(sizeof(GzipHeader));
+		gzHeaderPtr = ckalloc(sizeof(GzipHeader));
 		memset(gzHeaderPtr, 0, sizeof(GzipHeader));
 		if (GenerateHeader(interp, dictObj, gzHeaderPtr,
 			NULL) != TCL_OK) {
-		    Tcl_Free(gzHeaderPtr);
+		    ckfree(gzHeaderPtr);
 		    return TCL_ERROR;
 		}
 	    }
 	    break;
 	case TCL_ZLIB_FORMAT_ZLIB:
@@ -732,11 +731,11 @@
 	case TCL_ZLIB_FORMAT_RAW:
 	    wbits = WBITS_RAW;
 	    break;
 	case TCL_ZLIB_FORMAT_GZIP:
 	    wbits = WBITS_GZIP;
-	    gzHeaderPtr = Tcl_Alloc(sizeof(GzipHeader));
+	    gzHeaderPtr = ckalloc(sizeof(GzipHeader));
 	    memset(gzHeaderPtr, 0, sizeof(GzipHeader));
 	    gzHeaderPtr->header.name = (Bytef *)
 		    gzHeaderPtr->nativeFilenameBuf;
 	    gzHeaderPtr->header.name_max = MAXPATHLEN - 1;
 	    gzHeaderPtr->header.comment = (Bytef *)
@@ -758,11 +757,11 @@
     default:
 	Tcl_Panic("bad mode, must be TCL_ZLIB_STREAM_DEFLATE or"
 		" TCL_ZLIB_STREAM_INFLATE");
     }
 
-    zshPtr = Tcl_Alloc(sizeof(ZlibStreamHandle));
+    zshPtr = ckalloc(sizeof(ZlibStreamHandle));
     zshPtr->interp = interp;
     zshPtr->mode = mode;
     zshPtr->format = format;
     zshPtr->level = level;
     zshPtr->wbits = wbits;
@@ -858,13 +857,13 @@
   error:
     if (zshPtr->compDictObj) {
 	Tcl_DecrRefCount(zshPtr->compDictObj);
     }
     if (zshPtr->gzHeaderPtr) {
-	Tcl_Free(zshPtr->gzHeaderPtr);
+	ckfree(zshPtr->gzHeaderPtr);
     }
-    Tcl_Free(zshPtr);
+    ckfree(zshPtr);
     return TCL_ERROR;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -971,14 +970,14 @@
     }
     if (zshPtr->compDictObj) {
 	Tcl_DecrRefCount(zshPtr->compDictObj);
     }
     if (zshPtr->gzHeaderPtr) {
-	Tcl_Free(zshPtr->gzHeaderPtr);
+	ckfree(zshPtr->gzHeaderPtr);
     }
 
-    Tcl_Free(zshPtr);
+    ckfree(zshPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1189,12 +1188,11 @@
     int flush)			/* TCL_ZLIB_NO_FLUSH, TCL_ZLIB_FLUSH,
 				 * TCL_ZLIB_FULLFLUSH, or TCL_ZLIB_FINALIZE */
 {
     ZlibStreamHandle *zshPtr = (ZlibStreamHandle *) zshandle;
     char *dataTmp = NULL;
-    int e;
-    size_t size = 0, outSize, toStore;
+    int e, size, outSize, toStore;
 
     if (zshPtr->streamEnd) {
 	if (zshPtr->interp) {
 	    Tcl_SetObjResult(zshPtr->interp, Tcl_NewStringObj(
 		    "already past compressed stream end", -1));
@@ -1202,11 +1200,11 @@
 	}
 	return TCL_ERROR;
     }
 
     if (zshPtr->mode == TCL_ZLIB_STREAM_DEFLATE) {
-	zshPtr->stream.next_in = TclGetByteArrayFromObj(data, &size);
+	zshPtr->stream.next_in = Tcl_GetByteArrayFromObj(data, &size);
 	zshPtr->stream.avail_in = size;
 
 	/*
 	 * Must not do a zero-length compress unless finalizing. [Bug 25842c161]
 	 */
@@ -1233,11 +1231,11 @@
 
 	outSize = deflateBound(&zshPtr->stream, size) + 100;
 	if (outSize > BUFFER_SIZE_LIMIT) {
 	    outSize = BUFFER_SIZE_LIMIT;
 	}
-	dataTmp = Tcl_Alloc(outSize);
+	dataTmp = ckalloc(outSize);
 
 	while (1) {
 	    e = Deflate(&zshPtr->stream, dataTmp, outSize, flush, &toStore);
 
 	    /*
@@ -1267,20 +1265,20 @@
 	    AppendByteArray(zshPtr->outData, dataTmp, outSize);
 
 	    if (outSize < BUFFER_SIZE_LIMIT) {
 		outSize = BUFFER_SIZE_LIMIT;
 		/* There may be *lots* of data left to output... */
-		dataTmp = Tcl_Realloc(dataTmp, outSize);
+		dataTmp = ckrealloc(dataTmp, outSize);
 	    }
 	}
 
 	/*
 	 * And append the final data block to the outData list.
 	 */
 
 	AppendByteArray(zshPtr->outData, dataTmp, toStore);
-	Tcl_Free(dataTmp);
+	ckfree(dataTmp);
     } else {
 	/*
 	 * This is easy. Just append to the inData list.
 	 */
 
@@ -1309,32 +1307,31 @@
 
 int
 Tcl_ZlibStreamGet(
     Tcl_ZlibStream zshandle,	/* As obtained from Tcl_ZlibStreamInit */
     Tcl_Obj *data,		/* A place to append the data. */
-    size_t count)			/* Number of bytes to grab as a maximum, you
+    int count)			/* Number of bytes to grab as a maximum, you
 				 * may get less! */
 {
     ZlibStreamHandle *zshPtr = (ZlibStreamHandle *) zshandle;
-    int e, i, listLen;
-    size_t itemLen = 0, dataPos = 0;
+    int e, i, listLen, itemLen, dataPos = 0;
     Tcl_Obj *itemObj;
     unsigned char *dataPtr, *itemPtr;
-    size_t existing = 0;
+    int existing;
 
     /*
      * Getting beyond the of stream, just return empty string.
      */
 
     if (zshPtr->streamEnd) {
 	return TCL_OK;
     }
 
-    (void) TclGetByteArrayFromObj(data, &existing);
+    (void) Tcl_GetByteArrayFromObj(data, &existing);
 
     if (zshPtr->mode == TCL_ZLIB_STREAM_INFLATE) {
-	if (count == TCL_AUTO_LENGTH) {
+	if (count == -1) {
 	    /*
 	     * The only safe thing to do is restict to 65k. We might cause a
 	     * panic for out of memory if we just kept growing the buffer.
 	     */
 
@@ -1370,11 +1367,11 @@
 
 		Tcl_ListObjIndex(NULL, zshPtr->inData, 0, &itemObj);
 		if (Tcl_IsShared(itemObj)) {
 		    itemObj = Tcl_DuplicateObj(itemObj);
 		}
-		itemPtr = TclGetByteArrayFromObj(itemObj, &itemLen);
+		itemPtr = Tcl_GetByteArrayFromObj(itemObj, &itemLen);
 		Tcl_IncrRefCount(itemObj);
 		zshPtr->currentInput = itemObj;
 		zshPtr->stream.next_in = itemPtr;
 		zshPtr->stream.avail_in = itemLen;
 
@@ -1442,11 +1439,11 @@
 
 	    Tcl_ListObjIndex(zshPtr->interp, zshPtr->inData, 0, &itemObj);
 	    if (Tcl_IsShared(itemObj)) {
 		itemObj = Tcl_DuplicateObj(itemObj);
 	    }
-	    itemPtr = TclGetByteArrayFromObj(itemObj, &itemLen);
+	    itemPtr = Tcl_GetByteArrayFromObj(itemObj, &itemLen);
 	    Tcl_IncrRefCount(itemObj);
 	    zshPtr->currentInput = itemObj;
 	    zshPtr->stream.next_in = itemPtr;
 	    zshPtr->stream.avail_in = itemLen;
 
@@ -1487,15 +1484,15 @@
 	    }
 	    inflateEnd(&zshPtr->stream);
 	}
     } else {
 	Tcl_ListObjLength(NULL, zshPtr->outData, &listLen);
-	if (count == TCL_AUTO_LENGTH) {
+	if (count == -1) {
 	    count = 0;
 	    for (i=0; i<listLen; i++) {
 		Tcl_ListObjIndex(NULL, zshPtr->outData, i, &itemObj);
-		(void) TclGetByteArrayFromObj(itemObj, &itemLen);
+		(void) Tcl_GetByteArrayFromObj(itemObj, &itemLen);
 		if (i == 0) {
 		    count += itemLen - zshPtr->outPos;
 		} else {
 		    count += itemLen;
 		}
@@ -1516,12 +1513,12 @@
 	     * Get the next chunk off our list of chunks and grab the data out
 	     * of it.
 	     */
 
 	    Tcl_ListObjIndex(NULL, zshPtr->outData, 0, &itemObj);
-	    itemPtr = TclGetByteArrayFromObj(itemObj, &itemLen);
-	    if (itemLen-zshPtr->outPos + dataPos >= count) {
+	    itemPtr = Tcl_GetByteArrayFromObj(itemObj, &itemLen);
+	    if (itemLen-zshPtr->outPos >= count-dataPos) {
 		size_t len = count - dataPos;
 
 		memcpy(dataPtr + dataPos, itemPtr + zshPtr->outPos, len);
 		zshPtr->outPos += len;
 		dataPos += len;
@@ -1563,12 +1560,11 @@
     int format,
     Tcl_Obj *data,
     int level,
     Tcl_Obj *gzipHeaderDictObj)
 {
-    int wbits = 0, e = 0, extraSize = 0;
-    size_t inLen = 0;
+    int wbits = 0, inLen = 0, e = 0, extraSize = 0;
     Byte *inData = NULL;
     z_stream stream;
     GzipHeader header;
     gz_header *headerPtr = NULL;
     Tcl_Obj *obj;
@@ -1624,13 +1620,13 @@
     /*
      * Obtain the pointer to the byte array, we'll pass this pointer straight
      * to the deflate command.
      */
 
-    inData = TclGetByteArrayFromObj(data, &inLen);
+    inData = Tcl_GetByteArrayFromObj(data, &inLen);
     memset(&stream, 0, sizeof(z_stream));
-    stream.avail_in = inLen;
+    stream.avail_in = (uInt) inLen;
     stream.next_in = inData;
 
     /*
      * No output buffer available yet, will alloc after deflateInit2.
      */
@@ -1711,15 +1707,14 @@
 int
 Tcl_ZlibInflate(
     Tcl_Interp *interp,
     int format,
     Tcl_Obj *data,
-    size_t bufferSize,
+    int bufferSize,
     Tcl_Obj *gzipHeaderDictObj)
 {
-    int wbits = 0, e = 0;
-    size_t inLen = 0, newBufferSize;
+    int wbits = 0, inLen = 0, e = 0, newBufferSize;
     Byte *inData = NULL, *outData = NULL, *newOutData = NULL;
     z_stream stream;
     gz_header header, *headerPtr = NULL;
     Tcl_Obj *obj;
     char *nameBuf = NULL, *commentBuf = NULL;
@@ -1755,19 +1750,19 @@
     }
 
     if (gzipHeaderDictObj) {
 	headerPtr = &header;
 	memset(headerPtr, 0, sizeof(gz_header));
-	nameBuf = Tcl_Alloc(MAXPATHLEN);
+	nameBuf = ckalloc(MAXPATHLEN);
 	header.name = (Bytef *) nameBuf;
 	header.name_max = MAXPATHLEN - 1;
-	commentBuf = Tcl_Alloc(MAX_COMMENT_LEN);
+	commentBuf = ckalloc(MAX_COMMENT_LEN);
 	header.comment = (Bytef *) commentBuf;
 	header.comm_max = MAX_COMMENT_LEN - 1;
     }
 
-    inData = TclGetByteArrayFromObj(data, &inLen);
+    inData = Tcl_GetByteArrayFromObj(data, &inLen);
     if (bufferSize < 1) {
 	/*
 	 * Start with a buffer (up to) 3 times the size of the input data.
 	 */
 
@@ -1781,11 +1776,11 @@
     }
 
     TclNewObj(obj);
     outData = Tcl_SetByteArrayLength(obj, bufferSize);
     memset(&stream, 0, sizeof(z_stream));
-    stream.avail_in = inLen+1;	/* +1 because zlib can "over-request"
+    stream.avail_in = (uInt) inLen+1;	/* +1 because zlib can "over-request"
 					 * input (but ignore it!) */
     stream.next_in = inData;
     stream.avail_out = bufferSize;
     stream.next_out = outData;
 
@@ -1864,24 +1859,24 @@
     Tcl_SetByteArrayLength(obj, stream.total_out);
     if (headerPtr != NULL) {
 	ExtractHeader(&header, gzipHeaderDictObj);
 	SetValue(gzipHeaderDictObj, "size",
 		Tcl_NewWideIntObj(stream.total_out));
-	Tcl_Free(nameBuf);
-	Tcl_Free(commentBuf);
+	ckfree(nameBuf);
+	ckfree(commentBuf);
     }
     Tcl_SetObjResult(interp, obj);
     return TCL_OK;
 
   error:
     TclDecrRefCount(obj);
     ConvertError(interp, e, stream.adler);
     if (nameBuf) {
-	Tcl_Free(nameBuf);
+	ckfree(nameBuf);
     }
     if (commentBuf) {
-	Tcl_Free(commentBuf);
+	ckfree(commentBuf);
     }
     return TCL_ERROR;
 }
 
 /*
@@ -1896,21 +1891,21 @@
 
 unsigned int
 Tcl_ZlibCRC32(
     unsigned int crc,
     const unsigned char *buf,
-    size_t len)
+    int len)
 {
     /* Nothing much to do, just wrap the crc32(). */
     return crc32(crc, (Bytef *) buf, len);
 }
 
 unsigned int
 Tcl_ZlibAdler32(
     unsigned int adler,
     const unsigned char *buf,
-    size_t len)
+    int len)
 {
     return adler32(adler, (Bytef *) buf, len);
 }
 
 /*
@@ -1928,13 +1923,12 @@
     void *notUsed,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const objv[])
 {
-    int command, i, option, level = -1;
-    size_t dlen = 0, start, buffersize = 0;
-    Tcl_WideInt wideLen;
+    int command, dlen, i, option, level = -1;
+    unsigned start, buffersize = 0;
     Byte *data;
     Tcl_Obj *headerDictObj;
     const char *extraInfoStr = NULL;
     static const char *const commands[] = {
 	"adler32", "compress", "crc32", "decompress", "deflate", "gunzip",
@@ -1967,11 +1961,11 @@
 	    return TCL_ERROR;
 	}
 	if (objc < 4) {
 	    start = Tcl_ZlibAdler32(0, NULL, 0);
 	}
-	data = TclGetByteArrayFromObj(objv[2], &dlen);
+	data = Tcl_GetByteArrayFromObj(objv[2], &dlen);
 	Tcl_SetObjResult(interp, Tcl_NewWideIntObj((Tcl_WideInt)
 		(uLong) Tcl_ZlibAdler32(start, data, dlen)));
 	return TCL_OK;
     case CMD_CRC:			/* crc32 str ?startvalue?
 					 * -> checksum */
@@ -1984,11 +1978,11 @@
 	    return TCL_ERROR;
 	}
 	if (objc < 4) {
 	    start = Tcl_ZlibCRC32(0, NULL, 0);
 	}
-	data = TclGetByteArrayFromObj(objv[2], &dlen);
+	data = Tcl_GetByteArrayFromObj(objv[2], &dlen);
 	Tcl_SetObjResult(interp, Tcl_NewWideIntObj((Tcl_WideInt)
 		(uLong) Tcl_ZlibCRC32(start, data, dlen)));
 	return TCL_OK;
     case CMD_DEFLATE:			/* deflate data ?level?
 					 * -> rawCompressedData */
@@ -2077,19 +2071,18 @@
 	if (objc < 3 || objc > 4) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "data ?bufferSize?");
 	    return TCL_ERROR;
 	}
 	if (objc > 3) {
-	    if (Tcl_GetWideIntFromObj(interp, objv[3],
-		    &wideLen) != TCL_OK) {
+	    if (Tcl_GetIntFromObj(interp, objv[3],
+		    (int *) &buffersize) != TCL_OK) {
 		return TCL_ERROR;
 	    }
-	    if (wideLen < MIN_NONSTREAM_BUFFER_SIZE
-		    || wideLen > MAX_BUFFER_SIZE) {
+	    if (buffersize < MIN_NONSTREAM_BUFFER_SIZE
+		    || buffersize > MAX_BUFFER_SIZE) {
 		goto badBuffer;
 	    }
-	    buffersize = wideLen;
 	}
 	return Tcl_ZlibInflate(interp, TCL_ZLIB_FORMAT_RAW, objv[2],
 		buffersize, NULL);
     case CMD_DECOMPRESS:		/* decompress zlibcomprdata \
 					 *    ?bufferSize?
@@ -2097,19 +2090,18 @@
 	if (objc < 3 || objc > 4) {
 	    Tcl_WrongNumArgs(interp, 2, objv, "data ?bufferSize?");
 	    return TCL_ERROR;
 	}
 	if (objc > 3) {
-	    if (Tcl_GetWideIntFromObj(interp, objv[3],
-		    &wideLen) != TCL_OK) {
+	    if (Tcl_GetIntFromObj(interp, objv[3],
+		    (int *) &buffersize) != TCL_OK) {
 		return TCL_ERROR;
 	    }
-	    if (wideLen < MIN_NONSTREAM_BUFFER_SIZE
-		    || wideLen > MAX_BUFFER_SIZE) {
+	    if (buffersize < MIN_NONSTREAM_BUFFER_SIZE
+		    || buffersize > MAX_BUFFER_SIZE) {
 		goto badBuffer;
 	    }
-	    buffersize = wideLen;
 	}
 	return Tcl_ZlibInflate(interp, TCL_ZLIB_FORMAT_ZLIB, objv[2],
 		buffersize, NULL);
     case CMD_GUNZIP: {			/* gunzip gzippeddata ?bufferSize?
 					 *	-> decompressedData */
@@ -2129,19 +2121,18 @@
 		    &option) != TCL_OK) {
 		return TCL_ERROR;
 	    }
 	    switch (option) {
 	    case 0:
-		if (Tcl_GetWideIntFromObj(interp, objv[i+1],
-			&wideLen) != TCL_OK) {
+		if (Tcl_GetIntFromObj(interp, objv[i+1],
+			(int *) &buffersize) != TCL_OK) {
 		    return TCL_ERROR;
 		}
-		if (wideLen < MIN_NONSTREAM_BUFFER_SIZE
-			|| wideLen > MAX_BUFFER_SIZE) {
+		if (buffersize < MIN_NONSTREAM_BUFFER_SIZE
+			|| buffersize > MAX_BUFFER_SIZE) {
 		    goto badBuffer;
 		}
-		buffersize = wideLen;
 		break;
 	    case 1:
 		headerVarObj = objv[i+1];
 		headerDictObj = Tcl_NewObj();
 		break;
@@ -2740,13 +2731,13 @@
     /*
      * Set the compression dictionary if requested.
      */
 
     if (compDictObj != NULL) {
-	size_t len = 0;
+	int len;
 
-	(void) TclGetByteArrayFromObj(compDictObj, &len);
+	(void) Tcl_GetByteArrayFromObj(compDictObj, &len);
 	if (len == 0) {
 	    compDictObj = NULL;
 	}
 	Tcl_ZlibStreamSetCompressionDictionary(zstream, compDictObj);
     }
@@ -2844,13 +2835,13 @@
     /*
      * Set the compression dictionary if requested.
      */
 
     if (compDictObj != NULL) {
-	size_t len = 0;
+	int len;
 
-	(void) TclGetByteArrayFromObj(compDictObj, &len);
+	(void) Tcl_GetByteArrayFromObj(compDictObj, &len);
 	if (len == 0) {
 	    compDictObj = NULL;
 	}
 	Tcl_ZlibStreamSetCompressionDictionary(zstream, compDictObj);
     }
@@ -2905,12 +2896,11 @@
 ZlibTransformClose(
     void *instanceData,
     Tcl_Interp *interp)
 {
     ZlibChannelData *cd = instanceData;
-    int e, result = TCL_OK;
-    size_t written;
+    int e, written, result = TCL_OK;
 
     /*
      * Delete the support timer.
      */
 
@@ -2970,18 +2960,18 @@
 	cd->compDictObj = NULL;
     }
     Tcl_DStringFree(&cd->decompressed);
 
     if (cd->inBuffer) {
-	Tcl_Free(cd->inBuffer);
+	ckfree(cd->inBuffer);
 	cd->inBuffer = NULL;
     }
     if (cd->outBuffer) {
-	Tcl_Free(cd->outBuffer);
+	ckfree(cd->outBuffer);
 	cd->outBuffer = NULL;
     }
-    Tcl_Free(cd);
+    ckfree(cd);
     return result;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -3043,17 +3033,17 @@
 
 	/*
 	 * Three cases here:
 	 *  1.	Got some data from the underlying channel (readBytes > 0) so
 	 *	it should be fed through the decompression engine.
-	 *  2.	Got an error (readBytes == -1) which we should report up except
+	 *  2.	Got an error (readBytes < 0) which we should report up except
 	 *	for the case where we can convert it to a short read.
 	 *  3.	Got an end-of-data from EOF or blocking (readBytes == 0). If
 	 *	it is EOF, try flushing the data out of the decompressor.
 	 */
 
-	if (readBytes == -1) {
+	if (readBytes < 0) {
 
 	    /* See ReflectInput() in tclIORTrans.c */
 	    if (Tcl_InputBlocked(cd->parent) && (gotBytes > 0)) {
 		return gotBytes;
 	    }
@@ -3115,12 +3105,11 @@
     int *errorCodePtr)
 {
     ZlibChannelData *cd = instanceData;
     Tcl_DriverOutputProc *outProc =
 	    Tcl_ChannelOutputProc(Tcl_GetChannelType(cd->parent));
-    int e;
-    size_t produced;
+    int e, produced;
     Tcl_Obj *errObj;
 
     if (cd->mode == TCL_ZLIB_STREAM_INFLATE) {
 	return outProc(Tcl_GetChannelInstanceData(cd->parent), buf, toWrite,
 		errorCodePtr);
@@ -3178,12 +3167,11 @@
 ZlibTransformFlush(
     Tcl_Interp *interp,
     ZlibChannelData *cd,
     int flushType)
 {
-    int e;
-    size_t len;
+    int e, len;
 
     cd->outStream.avail_in = 0;
     do {
 	/*
 	 * Get the bytes to go out of the compression engine.
@@ -3251,11 +3239,11 @@
 	Tcl_Obj *compDictObj;
 	int code;
 
 	TclNewStringObj(compDictObj, value, strlen(value));
 	Tcl_IncrRefCount(compDictObj);
-	Tcl_GetByteArrayFromObj(compDictObj, NULL);
+	(void) Tcl_GetByteArrayFromObj(compDictObj, NULL);
 	if (cd->compDictObj) {
 	    TclDecrRefCount(cd->compDictObj);
 	}
 	cd->compDictObj = compDictObj;
 	code = Z_OK;
@@ -3392,20 +3380,20 @@
 
 	if (optionName == NULL) {
 	    Tcl_DStringAppendElement(dsPtr, "-dictionary");
 	    if (cd->compDictObj) {
 		Tcl_DStringAppendElement(dsPtr,
-			TclGetString(cd->compDictObj));
+			Tcl_GetString(cd->compDictObj));
 	    } else {
 		Tcl_DStringAppendElement(dsPtr, "");
 	    }
 	} else {
 	    if (cd->compDictObj) {
-		size_t length;
-		const char *str = TclGetStringFromObj(cd->compDictObj, &length);
+		int len;
+		const char *str = TclGetStringFromObj(cd->compDictObj, &len);
 
-		Tcl_DStringAppend(dsPtr, str, length);
+		Tcl_DStringAppend(dsPtr, str, len);
 	    }
 	    return TCL_OK;
 	}
     }
 
@@ -3419,11 +3407,11 @@
 	Tcl_Obj *tmpObj = Tcl_NewObj();
 
 	ExtractHeader(&cd->inHeader.header, tmpObj);
 	if (optionName == NULL) {
 	    Tcl_DStringAppendElement(dsPtr, "-header");
-	    Tcl_DStringAppendElement(dsPtr, TclGetString(tmpObj));
+	    Tcl_DStringAppendElement(dsPtr, Tcl_GetString(tmpObj));
 	    Tcl_DecrRefCount(tmpObj);
 	} else {
 	    TclDStringAppendObj(dsPtr, tmpObj);
 	    Tcl_DecrRefCount(tmpObj);
 	    return TCL_OK;
@@ -3602,11 +3590,11 @@
 				 * to produce gzip-format data. */
     Tcl_Obj *compDictObj)	/* Byte-array object containing compression
 				 * dictionary (not dictObj!) to use if
 				 * necessary. */
 {
-    ZlibChannelData *cd = Tcl_Alloc(sizeof(ZlibChannelData));
+    ZlibChannelData *cd = ckalloc(sizeof(ZlibChannelData));
     Tcl_Channel chan;
     int wbits = 0;
 
     if (mode != TCL_ZLIB_STREAM_DEFLATE && mode != TCL_ZLIB_STREAM_INFLATE) {
 	Tcl_Panic("unknown mode: %d", mode);
@@ -3662,11 +3650,11 @@
     if (mode == TCL_ZLIB_STREAM_INFLATE) {
 	if (inflateInit2(&cd->inStream, wbits) != Z_OK) {
 	    goto error;
 	}
 	cd->inAllocated = DEFAULT_BUFFER_SIZE;
-	cd->inBuffer = Tcl_Alloc(cd->inAllocated);
+	cd->inBuffer = ckalloc(cd->inAllocated);
 	if (cd->flags & IN_HEADER) {
 	    if (inflateGetHeader(&cd->inStream, &cd->inHeader.header) != Z_OK) {
 		goto error;
 	    }
 	}
@@ -3679,11 +3667,11 @@
 	if (deflateInit2(&cd->outStream, level, Z_DEFLATED, wbits,
 		MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY) != Z_OK) {
 	    goto error;
 	}
 	cd->outAllocated = DEFAULT_BUFFER_SIZE;
-	cd->outBuffer = Tcl_Alloc(cd->outAllocated);
+	cd->outBuffer = ckalloc(cd->outAllocated);
 	if (cd->flags & OUT_HEADER) {
 	    if (deflateSetHeader(&cd->outStream, &cd->outHeader.header) != Z_OK) {
 		goto error;
 	    }
 	}
@@ -3706,21 +3694,21 @@
     Tcl_SetObjResult(interp, Tcl_NewStringObj(Tcl_GetChannelName(chan), -1));
     return chan;
 
   error:
     if (cd->inBuffer) {
-	Tcl_Free(cd->inBuffer);
+	ckfree(cd->inBuffer);
 	inflateEnd(&cd->inStream);
     }
     if (cd->outBuffer) {
-	Tcl_Free(cd->outBuffer);
+	ckfree(cd->outBuffer);
 	deflateEnd(&cd->outStream);
     }
     if (cd->compDictObj) {
 	Tcl_DecrRefCount(cd->compDictObj);
     }
-    Tcl_Free(cd);
+    ckfree(cd);
     return NULL;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -3742,13 +3730,13 @@
 
 static inline int
 ResultCopy(
     ZlibChannelData *cd,	/* The location of the buffer to read from. */
     char *buf,			/* The buffer to copy into */
-    size_t toRead)			/* Number of requested bytes */
+    int toRead)			/* Number of requested bytes */
 {
-    size_t have = Tcl_DStringLength(&cd->decompressed);
+    int have = Tcl_DStringLength(&cd->decompressed);
 
     if (have == 0) {
 	/*
 	 * Nothing to copy in the case of an empty buffer.
 	 */
@@ -3930,11 +3918,11 @@
 
     /*
      * Formally provide the package as a Tcl built-in.
      */
 
-    return Tcl_PkgProvideEx(interp, "zlib", TCL_ZLIB_VERSION, NULL);
+    return Tcl_PkgProvide(interp, "zlib", TCL_ZLIB_VERSION);
 }
 
 /*
  *----------------------------------------------------------------------
  *	Stubs used when a suitable zlib installation was not found during
@@ -4005,11 +3993,11 @@
 
 int
 Tcl_ZlibStreamGet(
     Tcl_ZlibStream zshandle,
     Tcl_Obj *data,
-    size_t count)
+    int count)
 {
     return TCL_OK;
 }
 
 int
@@ -4030,11 +4018,11 @@
 int
 Tcl_ZlibInflate(
     Tcl_Interp *interp,
     int format,
     Tcl_Obj *data,
-    size_t bufferSize,
+    int bufferSize,
     Tcl_Obj *gzipHeaderDictObj)
 {
     if (interp) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj("unimplemented", -1));
 	Tcl_SetErrorCode(interp, "TCL", "UNIMPLEMENTED", NULL);
@@ -4043,21 +4031,21 @@
 }
 
 unsigned int
 Tcl_ZlibCRC32(
     unsigned int crc,
-    const unsigned char *buf,
-    size_t len)
+    const char *buf,
+    int len)
 {
     return 0;
 }
 
 unsigned int
 Tcl_ZlibAdler32(
     unsigned int adler,
-    const unsigned char *buf,
-    size_t len)
+    const char *buf,
+    int len)
 {
     return 0;
 }
 
 void

Index: library/http/cookiejar.tcl
==================================================================
--- library/http/cookiejar.tcl
+++ library/http/cookiejar.tcl
@@ -6,11 +6,11 @@
 #
 # See the file "license.terms" for information on usage and redistribution of
 # this file, and for a DISCLAIMER OF ALL WARRANTIES.
 
 # Dependencies
-package require Tcl 8.6-
+package require Tcl 8.6
 package require http 2.8.4
 package require sqlite3
 package require tcl::idna 1.0
 
 #

Index: library/http/effective_tld_names.txt.gz
==================================================================
--- library/http/effective_tld_names.txt.gz
+++ library/http/effective_tld_names.txt.gz
cannot compute difference between binary files

Index: library/init.tcl
==================================================================
--- library/init.tcl
+++ library/init.tcl
@@ -17,11 +17,11 @@
 
 # This test intentionally written in pre-7.5 Tcl
 if {[info commands package] == ""} {
     error "version mismatch: library\nscripts expect Tcl version 7.5b1 or later but the loaded version is\nonly [info patchlevel]"
 }
-package require -exact Tcl 9.0a0
+package require -exact Tcl 8.7a2
 
 # Compute the auto path to use in this interpreter.
 # The values on the path come from several locations:
 #
 # The environment variable TCLLIBPATH

Index: library/safe.tcl
==================================================================
--- library/safe.tcl
+++ library/safe.tcl
@@ -111,11 +111,11 @@
 
 # This is even more complicated by the boolean flags with no values that
 # we had the bad idea to support for the sake of user simplicity in
 # create/init but which makes life hard in configure...
 # So this will be hopefully written and some integrated with opt1.0
-# (hopefully for tcl9.0 ?)
+# (hopefully for tcl8.1 ?)
 proc ::safe::interpConfigure {args} {
     switch [llength $args] {
 	1 {
 	    # If we have exactly 1 argument the semantic is to return all
 	    # the current configuration. We still call OptKeyParse though

Index: library/tcltest/pkgIndex.tcl
==================================================================
--- library/tcltest/pkgIndex.tcl
+++ library/tcltest/pkgIndex.tcl
@@ -7,6 +7,6 @@
 # in response to "package require" commands.  When this
 # script is sourced, the variable $dir must contain the
 # full path name of this file's directory.
 
 if {![package vsatisfies [package provide Tcl] 8.5-]} {return}
-package ifneeded tcltest 2.5.0 [list source [file join $dir tcltest.tcl]]
+package ifneeded tcltest 2.5.1 [list source [file join $dir tcltest.tcl]]

Index: library/tcltest/tcltest.tcl
==================================================================
--- library/tcltest/tcltest.tcl
+++ library/tcltest/tcltest.tcl
@@ -20,11 +20,11 @@
 namespace eval tcltest {
 
     # When the version number changes, be sure to update the pkgIndex.tcl file,
     # and the install directory in the Makefiles.  When the minor version
     # changes (new feature) be sure to update the man page as well.
-    variable Version 2.5.0
+    variable Version 2.5.1
 
     # Compatibility support for dumb variables defined in tcltest 1
     # Do not use these.  Call [package provide Tcl] and [info patchlevel]
     # yourself.  You don't need tcltest to wrap it for you.
     variable version [package provide Tcl]
@@ -3070,11 +3070,16 @@
     if {![file isfile $fullName]} {
 	DebugDo 1 {
 	    Warn "removeFile removing \"$fullName\":\n  not a file"
 	}
     }
-    return [file delete -- $fullName]
+    if {[catch {file delete -- $fullName} msg ]} {
+	DebugDo 1 {
+	    Warn "removeFile removing \"$fullName\":\n  failed: $msg"
+	}
+    }
+    return
 }
 
 # tcltest::makeDirectory --
 #
 # Create a new dir with the name <name>.

Index: library/tzdata/Africa/Casablanca
==================================================================
--- library/tzdata/Africa/Casablanca
+++ library/tzdata/Africa/Casablanca
@@ -95,6 +95,108 @@
     {2080173600 3600 0 +01}
     {2107994400 0 1 +01}
     {2111018400 3600 0 +01}
     {2138234400 0 1 +01}
     {2141863200 3600 0 +01}
+    {2169079200 0 1 +01}
+    {2172103200 3600 0 +01}
+    {2199924000 0 1 +01}
+    {2202948000 3600 0 +01}
+    {2230164000 0 1 +01}
+    {2233792800 3600 0 +01}
+    {2261008800 0 1 +01}
+    {2264032800 3600 0 +01}
+    {2291248800 0 1 +01}
+    {2294877600 3600 0 +01}
+    {2322093600 0 1 +01}
+    {2325117600 3600 0 +01}
+    {2352938400 0 1 +01}
+    {2355962400 3600 0 +01}
+    {2383178400 0 1 +01}
+    {2386807200 3600 0 +01}
+    {2414023200 0 1 +01}
+    {2417047200 3600 0 +01}
+    {2444868000 0 1 +01}
+    {2447892000 3600 0 +01}
+    {2475108000 0 1 +01}
+    {2478736800 3600 0 +01}
+    {2505952800 0 1 +01}
+    {2508976800 3600 0 +01}
+    {2536192800 0 1 +01}
+    {2539821600 3600 0 +01}
+    {2567037600 0 1 +01}
+    {2570061600 3600 0 +01}
+    {2597882400 0 1 +01}
+    {2600906400 3600 0 +01}
+    {2628122400 0 1 +01}
+    {2631751200 3600 0 +01}
+    {2658967200 0 1 +01}
+    {2661991200 3600 0 +01}
+    {2689812000 0 1 +01}
+    {2692836000 3600 0 +01}
+    {2720052000 0 1 +01}
+    {2723680800 3600 0 +01}
+    {2750896800 0 1 +01}
+    {2753920800 3600 0 +01}
+    {2781136800 0 1 +01}
+    {2784765600 3600 0 +01}
+    {2811981600 0 1 +01}
+    {2815005600 3600 0 +01}
+    {2842826400 0 1 +01}
+    {2845850400 3600 0 +01}
+    {2873066400 0 1 +01}
+    {2876695200 3600 0 +01}
+    {2903911200 0 1 +01}
+    {2906935200 3600 0 +01}
+    {2934756000 0 1 +01}
+    {2937780000 3600 0 +01}
+    {2964996000 0 1 +01}
+    {2968020000 3600 0 +01}
+    {2995840800 0 1 +01}
+    {2998864800 3600 0 +01}
+    {3026080800 0 1 +01}
+    {3029709600 3600 0 +01}
+    {3056925600 0 1 +01}
+    {3059949600 3600 0 +01}
+    {3087770400 0 1 +01}
+    {3090794400 3600 0 +01}
+    {3118010400 0 1 +01}
+    {3121639200 3600 0 +01}
+    {3148855200 0 1 +01}
+    {3151879200 3600 0 +01}
+    {3179700000 0 1 +01}
+    {3182724000 3600 0 +01}
+    {3209940000 0 1 +01}
+    {3212964000 3600 0 +01}
+    {3240784800 0 1 +01}
+    {3243808800 3600 0 +01}
+    {3271024800 0 1 +01}
+    {3274653600 3600 0 +01}
+    {3301869600 0 1 +01}
+    {3304893600 3600 0 +01}
+    {3332714400 0 1 +01}
+    {3335738400 3600 0 +01}
+    {3362954400 0 1 +01}
+    {3366583200 3600 0 +01}
+    {3393799200 0 1 +01}
+    {3396823200 3600 0 +01}
+    {3424644000 0 1 +01}
+    {3427668000 3600 0 +01}
+    {3454884000 0 1 +01}
+    {3457908000 3600 0 +01}
+    {3485728800 0 1 +01}
+    {3488752800 3600 0 +01}
+    {3515968800 0 1 +01}
+    {3519597600 3600 0 +01}
+    {3546813600 0 1 +01}
+    {3549837600 3600 0 +01}
+    {3577658400 0 1 +01}
+    {3580682400 3600 0 +01}
+    {3607898400 0 1 +01}
+    {3611527200 3600 0 +01}
+    {3638743200 0 1 +01}
+    {3641767200 3600 0 +01}
+    {3669588000 0 1 +01}
+    {3672612000 3600 0 +01}
+    {3699828000 0 1 +01}
+    {3702852000 3600 0 +01}
 }

Index: library/tzdata/Africa/El_Aaiun
==================================================================
--- library/tzdata/Africa/El_Aaiun
+++ library/tzdata/Africa/El_Aaiun
@@ -84,6 +84,108 @@
     {2080173600 3600 0 +01}
     {2107994400 0 1 +01}
     {2111018400 3600 0 +01}
     {2138234400 0 1 +01}
     {2141863200 3600 0 +01}
+    {2169079200 0 1 +01}
+    {2172103200 3600 0 +01}
+    {2199924000 0 1 +01}
+    {2202948000 3600 0 +01}
+    {2230164000 0 1 +01}
+    {2233792800 3600 0 +01}
+    {2261008800 0 1 +01}
+    {2264032800 3600 0 +01}
+    {2291248800 0 1 +01}
+    {2294877600 3600 0 +01}
+    {2322093600 0 1 +01}
+    {2325117600 3600 0 +01}
+    {2352938400 0 1 +01}
+    {2355962400 3600 0 +01}
+    {2383178400 0 1 +01}
+    {2386807200 3600 0 +01}
+    {2414023200 0 1 +01}
+    {2417047200 3600 0 +01}
+    {2444868000 0 1 +01}
+    {2447892000 3600 0 +01}
+    {2475108000 0 1 +01}
+    {2478736800 3600 0 +01}
+    {2505952800 0 1 +01}
+    {2508976800 3600 0 +01}
+    {2536192800 0 1 +01}
+    {2539821600 3600 0 +01}
+    {2567037600 0 1 +01}
+    {2570061600 3600 0 +01}
+    {2597882400 0 1 +01}
+    {2600906400 3600 0 +01}
+    {2628122400 0 1 +01}
+    {2631751200 3600 0 +01}
+    {2658967200 0 1 +01}
+    {2661991200 3600 0 +01}
+    {2689812000 0 1 +01}
+    {2692836000 3600 0 +01}
+    {2720052000 0 1 +01}
+    {2723680800 3600 0 +01}
+    {2750896800 0 1 +01}
+    {2753920800 3600 0 +01}
+    {2781136800 0 1 +01}
+    {2784765600 3600 0 +01}
+    {2811981600 0 1 +01}
+    {2815005600 3600 0 +01}
+    {2842826400 0 1 +01}
+    {2845850400 3600 0 +01}
+    {2873066400 0 1 +01}
+    {2876695200 3600 0 +01}
+    {2903911200 0 1 +01}
+    {2906935200 3600 0 +01}
+    {2934756000 0 1 +01}
+    {2937780000 3600 0 +01}
+    {2964996000 0 1 +01}
+    {2968020000 3600 0 +01}
+    {2995840800 0 1 +01}
+    {2998864800 3600 0 +01}
+    {3026080800 0 1 +01}
+    {3029709600 3600 0 +01}
+    {3056925600 0 1 +01}
+    {3059949600 3600 0 +01}
+    {3087770400 0 1 +01}
+    {3090794400 3600 0 +01}
+    {3118010400 0 1 +01}
+    {3121639200 3600 0 +01}
+    {3148855200 0 1 +01}
+    {3151879200 3600 0 +01}
+    {3179700000 0 1 +01}
+    {3182724000 3600 0 +01}
+    {3209940000 0 1 +01}
+    {3212964000 3600 0 +01}
+    {3240784800 0 1 +01}
+    {3243808800 3600 0 +01}
+    {3271024800 0 1 +01}
+    {3274653600 3600 0 +01}
+    {3301869600 0 1 +01}
+    {3304893600 3600 0 +01}
+    {3332714400 0 1 +01}
+    {3335738400 3600 0 +01}
+    {3362954400 0 1 +01}
+    {3366583200 3600 0 +01}
+    {3393799200 0 1 +01}
+    {3396823200 3600 0 +01}
+    {3424644000 0 1 +01}
+    {3427668000 3600 0 +01}
+    {3454884000 0 1 +01}
+    {3457908000 3600 0 +01}
+    {3485728800 0 1 +01}
+    {3488752800 3600 0 +01}
+    {3515968800 0 1 +01}
+    {3519597600 3600 0 +01}
+    {3546813600 0 1 +01}
+    {3549837600 3600 0 +01}
+    {3577658400 0 1 +01}
+    {3580682400 3600 0 +01}
+    {3607898400 0 1 +01}
+    {3611527200 3600 0 +01}
+    {3638743200 0 1 +01}
+    {3641767200 3600 0 +01}
+    {3669588000 0 1 +01}
+    {3672612000 3600 0 +01}
+    {3699828000 0 1 +01}
+    {3702852000 3600 0 +01}
 }

Index: library/tzdata/America/Campo_Grande
==================================================================
--- library/tzdata/America/Campo_Grande
+++ library/tzdata/America/Campo_Grande
@@ -91,167 +91,6 @@
     {1487473200 -14400 0 -04}
     {1508040000 -10800 1 -04}
     {1518922800 -14400 0 -04}
     {1541304000 -10800 1 -04}
     {1550372400 -14400 0 -04}
-    {1572753600 -10800 1 -04}
-    {1581822000 -14400 0 -04}
-    {1604203200 -10800 1 -04}
-    {1613876400 -14400 0 -04}
-    {1636257600 -10800 1 -04}
-    {1645326000 -14400 0 -04}
-    {1667707200 -10800 1 -04}
-    {1677380400 -14400 0 -04}
-    {1699156800 -10800 1 -04}
-    {1708225200 -14400 0 -04}
-    {1730606400 -10800 1 -04}
-    {1739674800 -14400 0 -04}
-    {1762056000 -10800 1 -04}
-    {1771729200 -14400 0 -04}
-    {1793505600 -10800 1 -04}
-    {1803178800 -14400 0 -04}
-    {1825560000 -10800 1 -04}
-    {1834628400 -14400 0 -04}
-    {1857009600 -10800 1 -04}
-    {1866078000 -14400 0 -04}
-    {1888459200 -10800 1 -04}
-    {1897527600 -14400 0 -04}
-    {1919908800 -10800 1 -04}
-    {1928977200 -14400 0 -04}
-    {1951358400 -10800 1 -04}
-    {1960426800 -14400 0 -04}
-    {1983412800 -10800 1 -04}
-    {1992481200 -14400 0 -04}
-    {2014862400 -10800 1 -04}
-    {2024535600 -14400 0 -04}
-    {2046312000 -10800 1 -04}
-    {2055380400 -14400 0 -04}
-    {2077761600 -10800 1 -04}
-    {2086830000 -14400 0 -04}
-    {2109211200 -10800 1 -04}
-    {2118884400 -14400 0 -04}
-    {2140660800 -10800 1 -04}
-    {2150334000 -14400 0 -04}
-    {2172715200 -10800 1 -04}
-    {2181783600 -14400 0 -04}
-    {2204164800 -10800 1 -04}
-    {2213233200 -14400 0 -04}
-    {2235614400 -10800 1 -04}
-    {2244682800 -14400 0 -04}
-    {2267064000 -10800 1 -04}
-    {2276132400 -14400 0 -04}
-    {2298513600 -10800 1 -04}
-    {2307582000 -14400 0 -04}
-    {2329963200 -10800 1 -04}
-    {2339636400 -14400 0 -04}
-    {2362017600 -10800 1 -04}
-    {2371086000 -14400 0 -04}
-    {2393467200 -10800 1 -04}
-    {2402535600 -14400 0 -04}
-    {2424916800 -10800 1 -04}
-    {2433985200 -14400 0 -04}
-    {2456366400 -10800 1 -04}
-    {2465434800 -14400 0 -04}
-    {2487816000 -10800 1 -04}
-    {2497489200 -14400 0 -04}
-    {2519870400 -10800 1 -04}
-    {2528938800 -14400 0 -04}
-    {2551320000 -10800 1 -04}
-    {2560388400 -14400 0 -04}
-    {2582769600 -10800 1 -04}
-    {2591838000 -14400 0 -04}
-    {2614219200 -10800 1 -04}
-    {2623287600 -14400 0 -04}
-    {2645668800 -10800 1 -04}
-    {2654737200 -14400 0 -04}
-    {2677118400 -10800 1 -04}
-    {2686791600 -14400 0 -04}
-    {2709172800 -10800 1 -04}
-    {2718241200 -14400 0 -04}
-    {2740622400 -10800 1 -04}
-    {2749690800 -14400 0 -04}
-    {2772072000 -10800 1 -04}
-    {2781140400 -14400 0 -04}
-    {2803521600 -10800 1 -04}
-    {2812590000 -14400 0 -04}
-    {2834971200 -10800 1 -04}
-    {2844039600 -14400 0 -04}
-    {2867025600 -10800 1 -04}
-    {2876094000 -14400 0 -04}
-    {2898475200 -10800 1 -04}
-    {2907543600 -14400 0 -04}
-    {2929924800 -10800 1 -04}
-    {2938993200 -14400 0 -04}
-    {2961374400 -10800 1 -04}
-    {2970442800 -14400 0 -04}
-    {2992824000 -10800 1 -04}
-    {3001892400 -14400 0 -04}
-    {3024273600 -10800 1 -04}
-    {3033946800 -14400 0 -04}
-    {3056328000 -10800 1 -04}
-    {3065396400 -14400 0 -04}
-    {3087777600 -10800 1 -04}
-    {3096846000 -14400 0 -04}
-    {3119227200 -10800 1 -04}
-    {3128295600 -14400 0 -04}
-    {3150676800 -10800 1 -04}
-    {3159745200 -14400 0 -04}
-    {3182126400 -10800 1 -04}
-    {3191194800 -14400 0 -04}
-    {3213576000 -10800 1 -04}
-    {3223249200 -14400 0 -04}
-    {3245630400 -10800 1 -04}
-    {3254698800 -14400 0 -04}
-    {3277080000 -10800 1 -04}
-    {3286148400 -14400 0 -04}
-    {3308529600 -10800 1 -04}
-    {3317598000 -14400 0 -04}
-    {3339979200 -10800 1 -04}
-    {3349047600 -14400 0 -04}
-    {3371428800 -10800 1 -04}
-    {3381102000 -14400 0 -04}
-    {3403483200 -10800 1 -04}
-    {3412551600 -14400 0 -04}
-    {3434932800 -10800 1 -04}
-    {3444001200 -14400 0 -04}
-    {3466382400 -10800 1 -04}
-    {3475450800 -14400 0 -04}
-    {3497832000 -10800 1 -04}
-    {3506900400 -14400 0 -04}
-    {3529281600 -10800 1 -04}
-    {3538350000 -14400 0 -04}
-    {3560731200 -10800 1 -04}
-    {3570404400 -14400 0 -04}
-    {3592785600 -10800 1 -04}
-    {3601854000 -14400 0 -04}
-    {3624235200 -10800 1 -04}
-    {3633303600 -14400 0 -04}
-    {3655684800 -10800 1 -04}
-    {3664753200 -14400 0 -04}
-    {3687134400 -10800 1 -04}
-    {3696202800 -14400 0 -04}
-    {3718584000 -10800 1 -04}
-    {3727652400 -14400 0 -04}
-    {3750638400 -10800 1 -04}
-    {3759706800 -14400 0 -04}
-    {3782088000 -10800 1 -04}
-    {3791156400 -14400 0 -04}
-    {3813537600 -10800 1 -04}
-    {3822606000 -14400 0 -04}
-    {3844987200 -10800 1 -04}
-    {3854055600 -14400 0 -04}
-    {3876436800 -10800 1 -04}
-    {3885505200 -14400 0 -04}
-    {3907886400 -10800 1 -04}
-    {3917559600 -14400 0 -04}
-    {3939940800 -10800 1 -04}
-    {3949009200 -14400 0 -04}
-    {3971390400 -10800 1 -04}
-    {3980458800 -14400 0 -04}
-    {4002840000 -10800 1 -04}
-    {4011908400 -14400 0 -04}
-    {4034289600 -10800 1 -04}
-    {4043358000 -14400 0 -04}
-    {4065739200 -10800 1 -04}
-    {4074807600 -14400 0 -04}
-    {4097188800 -10800 1 -04}
 }

Index: library/tzdata/America/Cuiaba
==================================================================
--- library/tzdata/America/Cuiaba
+++ library/tzdata/America/Cuiaba
@@ -91,167 +91,6 @@
     {1487473200 -14400 0 -04}
     {1508040000 -10800 1 -04}
     {1518922800 -14400 0 -04}
     {1541304000 -10800 1 -04}
     {1550372400 -14400 0 -04}
-    {1572753600 -10800 1 -04}
-    {1581822000 -14400 0 -04}
-    {1604203200 -10800 1 -04}
-    {1613876400 -14400 0 -04}
-    {1636257600 -10800 1 -04}
-    {1645326000 -14400 0 -04}
-    {1667707200 -10800 1 -04}
-    {1677380400 -14400 0 -04}
-    {1699156800 -10800 1 -04}
-    {1708225200 -14400 0 -04}
-    {1730606400 -10800 1 -04}
-    {1739674800 -14400 0 -04}
-    {1762056000 -10800 1 -04}
-    {1771729200 -14400 0 -04}
-    {1793505600 -10800 1 -04}
-    {1803178800 -14400 0 -04}
-    {1825560000 -10800 1 -04}
-    {1834628400 -14400 0 -04}
-    {1857009600 -10800 1 -04}
-    {1866078000 -14400 0 -04}
-    {1888459200 -10800 1 -04}
-    {1897527600 -14400 0 -04}
-    {1919908800 -10800 1 -04}
-    {1928977200 -14400 0 -04}
-    {1951358400 -10800 1 -04}
-    {1960426800 -14400 0 -04}
-    {1983412800 -10800 1 -04}
-    {1992481200 -14400 0 -04}
-    {2014862400 -10800 1 -04}
-    {2024535600 -14400 0 -04}
-    {2046312000 -10800 1 -04}
-    {2055380400 -14400 0 -04}
-    {2077761600 -10800 1 -04}
-    {2086830000 -14400 0 -04}
-    {2109211200 -10800 1 -04}
-    {2118884400 -14400 0 -04}
-    {2140660800 -10800 1 -04}
-    {2150334000 -14400 0 -04}
-    {2172715200 -10800 1 -04}
-    {2181783600 -14400 0 -04}
-    {2204164800 -10800 1 -04}
-    {2213233200 -14400 0 -04}
-    {2235614400 -10800 1 -04}
-    {2244682800 -14400 0 -04}
-    {2267064000 -10800 1 -04}
-    {2276132400 -14400 0 -04}
-    {2298513600 -10800 1 -04}
-    {2307582000 -14400 0 -04}
-    {2329963200 -10800 1 -04}
-    {2339636400 -14400 0 -04}
-    {2362017600 -10800 1 -04}
-    {2371086000 -14400 0 -04}
-    {2393467200 -10800 1 -04}
-    {2402535600 -14400 0 -04}
-    {2424916800 -10800 1 -04}
-    {2433985200 -14400 0 -04}
-    {2456366400 -10800 1 -04}
-    {2465434800 -14400 0 -04}
-    {2487816000 -10800 1 -04}
-    {2497489200 -14400 0 -04}
-    {2519870400 -10800 1 -04}
-    {2528938800 -14400 0 -04}
-    {2551320000 -10800 1 -04}
-    {2560388400 -14400 0 -04}
-    {2582769600 -10800 1 -04}
-    {2591838000 -14400 0 -04}
-    {2614219200 -10800 1 -04}
-    {2623287600 -14400 0 -04}
-    {2645668800 -10800 1 -04}
-    {2654737200 -14400 0 -04}
-    {2677118400 -10800 1 -04}
-    {2686791600 -14400 0 -04}
-    {2709172800 -10800 1 -04}
-    {2718241200 -14400 0 -04}
-    {2740622400 -10800 1 -04}
-    {2749690800 -14400 0 -04}
-    {2772072000 -10800 1 -04}
-    {2781140400 -14400 0 -04}
-    {2803521600 -10800 1 -04}
-    {2812590000 -14400 0 -04}
-    {2834971200 -10800 1 -04}
-    {2844039600 -14400 0 -04}
-    {2867025600 -10800 1 -04}
-    {2876094000 -14400 0 -04}
-    {2898475200 -10800 1 -04}
-    {2907543600 -14400 0 -04}
-    {2929924800 -10800 1 -04}
-    {2938993200 -14400 0 -04}
-    {2961374400 -10800 1 -04}
-    {2970442800 -14400 0 -04}
-    {2992824000 -10800 1 -04}
-    {3001892400 -14400 0 -04}
-    {3024273600 -10800 1 -04}
-    {3033946800 -14400 0 -04}
-    {3056328000 -10800 1 -04}
-    {3065396400 -14400 0 -04}
-    {3087777600 -10800 1 -04}
-    {3096846000 -14400 0 -04}
-    {3119227200 -10800 1 -04}
-    {3128295600 -14400 0 -04}
-    {3150676800 -10800 1 -04}
-    {3159745200 -14400 0 -04}
-    {3182126400 -10800 1 -04}
-    {3191194800 -14400 0 -04}
-    {3213576000 -10800 1 -04}
-    {3223249200 -14400 0 -04}
-    {3245630400 -10800 1 -04}
-    {3254698800 -14400 0 -04}
-    {3277080000 -10800 1 -04}
-    {3286148400 -14400 0 -04}
-    {3308529600 -10800 1 -04}
-    {3317598000 -14400 0 -04}
-    {3339979200 -10800 1 -04}
-    {3349047600 -14400 0 -04}
-    {3371428800 -10800 1 -04}
-    {3381102000 -14400 0 -04}
-    {3403483200 -10800 1 -04}
-    {3412551600 -14400 0 -04}
-    {3434932800 -10800 1 -04}
-    {3444001200 -14400 0 -04}
-    {3466382400 -10800 1 -04}
-    {3475450800 -14400 0 -04}
-    {3497832000 -10800 1 -04}
-    {3506900400 -14400 0 -04}
-    {3529281600 -10800 1 -04}
-    {3538350000 -14400 0 -04}
-    {3560731200 -10800 1 -04}
-    {3570404400 -14400 0 -04}
-    {3592785600 -10800 1 -04}
-    {3601854000 -14400 0 -04}
-    {3624235200 -10800 1 -04}
-    {3633303600 -14400 0 -04}
-    {3655684800 -10800 1 -04}
-    {3664753200 -14400 0 -04}
-    {3687134400 -10800 1 -04}
-    {3696202800 -14400 0 -04}
-    {3718584000 -10800 1 -04}
-    {3727652400 -14400 0 -04}
-    {3750638400 -10800 1 -04}
-    {3759706800 -14400 0 -04}
-    {3782088000 -10800 1 -04}
-    {3791156400 -14400 0 -04}
-    {3813537600 -10800 1 -04}
-    {3822606000 -14400 0 -04}
-    {3844987200 -10800 1 -04}
-    {3854055600 -14400 0 -04}
-    {3876436800 -10800 1 -04}
-    {3885505200 -14400 0 -04}
-    {3907886400 -10800 1 -04}
-    {3917559600 -14400 0 -04}
-    {3939940800 -10800 1 -04}
-    {3949009200 -14400 0 -04}
-    {3971390400 -10800 1 -04}
-    {3980458800 -14400 0 -04}
-    {4002840000 -10800 1 -04}
-    {4011908400 -14400 0 -04}
-    {4034289600 -10800 1 -04}
-    {4043358000 -14400 0 -04}
-    {4065739200 -10800 1 -04}
-    {4074807600 -14400 0 -04}
-    {4097188800 -10800 1 -04}
 }

Index: library/tzdata/America/Sao_Paulo
==================================================================
--- library/tzdata/America/Sao_Paulo
+++ library/tzdata/America/Sao_Paulo
@@ -92,167 +92,6 @@
     {1487469600 -10800 0 -03}
     {1508036400 -7200 1 -03}
     {1518919200 -10800 0 -03}
     {1541300400 -7200 1 -03}
     {1550368800 -10800 0 -03}
-    {1572750000 -7200 1 -03}
-    {1581818400 -10800 0 -03}
-    {1604199600 -7200 1 -03}
-    {1613872800 -10800 0 -03}
-    {1636254000 -7200 1 -03}
-    {1645322400 -10800 0 -03}
-    {1667703600 -7200 1 -03}
-    {1677376800 -10800 0 -03}
-    {1699153200 -7200 1 -03}
-    {1708221600 -10800 0 -03}
-    {1730602800 -7200 1 -03}
-    {1739671200 -10800 0 -03}
-    {1762052400 -7200 1 -03}
-    {1771725600 -10800 0 -03}
-    {1793502000 -7200 1 -03}
-    {1803175200 -10800 0 -03}
-    {1825556400 -7200 1 -03}
-    {1834624800 -10800 0 -03}
-    {1857006000 -7200 1 -03}
-    {1866074400 -10800 0 -03}
-    {1888455600 -7200 1 -03}
-    {1897524000 -10800 0 -03}
-    {1919905200 -7200 1 -03}
-    {1928973600 -10800 0 -03}
-    {1951354800 -7200 1 -03}
-    {1960423200 -10800 0 -03}
-    {1983409200 -7200 1 -03}
-    {1992477600 -10800 0 -03}
-    {2014858800 -7200 1 -03}
-    {2024532000 -10800 0 -03}
-    {2046308400 -7200 1 -03}
-    {2055376800 -10800 0 -03}
-    {2077758000 -7200 1 -03}
-    {2086826400 -10800 0 -03}
-    {2109207600 -7200 1 -03}
-    {2118880800 -10800 0 -03}
-    {2140657200 -7200 1 -03}
-    {2150330400 -10800 0 -03}
-    {2172711600 -7200 1 -03}
-    {2181780000 -10800 0 -03}
-    {2204161200 -7200 1 -03}
-    {2213229600 -10800 0 -03}
-    {2235610800 -7200 1 -03}
-    {2244679200 -10800 0 -03}
-    {2267060400 -7200 1 -03}
-    {2276128800 -10800 0 -03}
-    {2298510000 -7200 1 -03}
-    {2307578400 -10800 0 -03}
-    {2329959600 -7200 1 -03}
-    {2339632800 -10800 0 -03}
-    {2362014000 -7200 1 -03}
-    {2371082400 -10800 0 -03}
-    {2393463600 -7200 1 -03}
-    {2402532000 -10800 0 -03}
-    {2424913200 -7200 1 -03}
-    {2433981600 -10800 0 -03}
-    {2456362800 -7200 1 -03}
-    {2465431200 -10800 0 -03}
-    {2487812400 -7200 1 -03}
-    {2497485600 -10800 0 -03}
-    {2519866800 -7200 1 -03}
-    {2528935200 -10800 0 -03}
-    {2551316400 -7200 1 -03}
-    {2560384800 -10800 0 -03}
-    {2582766000 -7200 1 -03}
-    {2591834400 -10800 0 -03}
-    {2614215600 -7200 1 -03}
-    {2623284000 -10800 0 -03}
-    {2645665200 -7200 1 -03}
-    {2654733600 -10800 0 -03}
-    {2677114800 -7200 1 -03}
-    {2686788000 -10800 0 -03}
-    {2709169200 -7200 1 -03}
-    {2718237600 -10800 0 -03}
-    {2740618800 -7200 1 -03}
-    {2749687200 -10800 0 -03}
-    {2772068400 -7200 1 -03}
-    {2781136800 -10800 0 -03}
-    {2803518000 -7200 1 -03}
-    {2812586400 -10800 0 -03}
-    {2834967600 -7200 1 -03}
-    {2844036000 -10800 0 -03}
-    {2867022000 -7200 1 -03}
-    {2876090400 -10800 0 -03}
-    {2898471600 -7200 1 -03}
-    {2907540000 -10800 0 -03}
-    {2929921200 -7200 1 -03}
-    {2938989600 -10800 0 -03}
-    {2961370800 -7200 1 -03}
-    {2970439200 -10800 0 -03}
-    {2992820400 -7200 1 -03}
-    {3001888800 -10800 0 -03}
-    {3024270000 -7200 1 -03}
-    {3033943200 -10800 0 -03}
-    {3056324400 -7200 1 -03}
-    {3065392800 -10800 0 -03}
-    {3087774000 -7200 1 -03}
-    {3096842400 -10800 0 -03}
-    {3119223600 -7200 1 -03}
-    {3128292000 -10800 0 -03}
-    {3150673200 -7200 1 -03}
-    {3159741600 -10800 0 -03}
-    {3182122800 -7200 1 -03}
-    {3191191200 -10800 0 -03}
-    {3213572400 -7200 1 -03}
-    {3223245600 -10800 0 -03}
-    {3245626800 -7200 1 -03}
-    {3254695200 -10800 0 -03}
-    {3277076400 -7200 1 -03}
-    {3286144800 -10800 0 -03}
-    {3308526000 -7200 1 -03}
-    {3317594400 -10800 0 -03}
-    {3339975600 -7200 1 -03}
-    {3349044000 -10800 0 -03}
-    {3371425200 -7200 1 -03}
-    {3381098400 -10800 0 -03}
-    {3403479600 -7200 1 -03}
-    {3412548000 -10800 0 -03}
-    {3434929200 -7200 1 -03}
-    {3443997600 -10800 0 -03}
-    {3466378800 -7200 1 -03}
-    {3475447200 -10800 0 -03}
-    {3497828400 -7200 1 -03}
-    {3506896800 -10800 0 -03}
-    {3529278000 -7200 1 -03}
-    {3538346400 -10800 0 -03}
-    {3560727600 -7200 1 -03}
-    {3570400800 -10800 0 -03}
-    {3592782000 -7200 1 -03}
-    {3601850400 -10800 0 -03}
-    {3624231600 -7200 1 -03}
-    {3633300000 -10800 0 -03}
-    {3655681200 -7200 1 -03}
-    {3664749600 -10800 0 -03}
-    {3687130800 -7200 1 -03}
-    {3696199200 -10800 0 -03}
-    {3718580400 -7200 1 -03}
-    {3727648800 -10800 0 -03}
-    {3750634800 -7200 1 -03}
-    {3759703200 -10800 0 -03}
-    {3782084400 -7200 1 -03}
-    {3791152800 -10800 0 -03}
-    {3813534000 -7200 1 -03}
-    {3822602400 -10800 0 -03}
-    {3844983600 -7200 1 -03}
-    {3854052000 -10800 0 -03}
-    {3876433200 -7200 1 -03}
-    {3885501600 -10800 0 -03}
-    {3907882800 -7200 1 -03}
-    {3917556000 -10800 0 -03}
-    {3939937200 -7200 1 -03}
-    {3949005600 -10800 0 -03}
-    {3971386800 -7200 1 -03}
-    {3980455200 -10800 0 -03}
-    {4002836400 -7200 1 -03}
-    {4011904800 -10800 0 -03}
-    {4034286000 -7200 1 -03}
-    {4043354400 -10800 0 -03}
-    {4065735600 -7200 1 -03}
-    {4074804000 -10800 0 -03}
-    {4097185200 -7200 1 -03}
 }

Index: library/tzdata/Asia/Gaza
==================================================================
--- library/tzdata/Asia/Gaza
+++ library/tzdata/Asia/Gaza
@@ -115,168 +115,168 @@
     {1477692000 7200 0 EET}
     {1490396400 10800 1 EEST}
     {1509141600 7200 0 EET}
     {1521846000 10800 1 EEST}
     {1540591200 7200 0 EET}
-    {1553900400 10800 1 EEST}
+    {1553810400 10800 1 EEST}
     {1572040800 7200 0 EET}
-    {1585350000 10800 1 EEST}
+    {1585260000 10800 1 EEST}
     {1604095200 7200 0 EET}
-    {1616799600 10800 1 EEST}
+    {1616709600 10800 1 EEST}
     {1635544800 7200 0 EET}
-    {1648249200 10800 1 EEST}
+    {1648159200 10800 1 EEST}
     {1666994400 7200 0 EET}
-    {1679698800 10800 1 EEST}
+    {1680213600 10800 1 EEST}
     {1698444000 7200 0 EET}
-    {1711753200 10800 1 EEST}
+    {1711663200 10800 1 EEST}
     {1729893600 7200 0 EET}
-    {1743202800 10800 1 EEST}
+    {1743112800 10800 1 EEST}
     {1761343200 7200 0 EET}
-    {1774652400 10800 1 EEST}
+    {1774562400 10800 1 EEST}
     {1793397600 7200 0 EET}
-    {1806102000 10800 1 EEST}
+    {1806012000 10800 1 EEST}
     {1824847200 7200 0 EET}
-    {1837551600 10800 1 EEST}
+    {1838066400 10800 1 EEST}
     {1856296800 7200 0 EET}
-    {1869001200 10800 1 EEST}
+    {1869516000 10800 1 EEST}
     {1887746400 7200 0 EET}
-    {1901055600 10800 1 EEST}
+    {1900965600 10800 1 EEST}
     {1919196000 7200 0 EET}
-    {1932505200 10800 1 EEST}
+    {1932415200 10800 1 EEST}
     {1950645600 7200 0 EET}
-    {1963954800 10800 1 EEST}
+    {1963864800 10800 1 EEST}
     {1982700000 7200 0 EET}
-    {1995404400 10800 1 EEST}
+    {1995314400 10800 1 EEST}
     {2014149600 7200 0 EET}
-    {2026854000 10800 1 EEST}
+    {2027368800 10800 1 EEST}
     {2045599200 7200 0 EET}
-    {2058303600 10800 1 EEST}
+    {2058818400 10800 1 EEST}
     {2077048800 7200 0 EET}
-    {2090358000 10800 1 EEST}
+    {2090268000 10800 1 EEST}
     {2108498400 7200 0 EET}
-    {2121807600 10800 1 EEST}
+    {2121717600 10800 1 EEST}
     {2140552800 7200 0 EET}
-    {2153257200 10800 1 EEST}
+    {2153167200 10800 1 EEST}
     {2172002400 7200 0 EET}
-    {2184706800 10800 1 EEST}
+    {2184616800 10800 1 EEST}
     {2203452000 7200 0 EET}
-    {2216156400 10800 1 EEST}
+    {2216671200 10800 1 EEST}
     {2234901600 7200 0 EET}
-    {2248210800 10800 1 EEST}
+    {2248120800 10800 1 EEST}
     {2266351200 7200 0 EET}
-    {2279660400 10800 1 EEST}
+    {2279570400 10800 1 EEST}
     {2297800800 7200 0 EET}
-    {2311110000 10800 1 EEST}
+    {2311020000 10800 1 EEST}
     {2329855200 7200 0 EET}
-    {2342559600 10800 1 EEST}
+    {2342469600 10800 1 EEST}
     {2361304800 7200 0 EET}
-    {2374009200 10800 1 EEST}
+    {2374524000 10800 1 EEST}
     {2392754400 7200 0 EET}
-    {2405458800 10800 1 EEST}
+    {2405973600 10800 1 EEST}
     {2424204000 7200 0 EET}
-    {2437513200 10800 1 EEST}
+    {2437423200 10800 1 EEST}
     {2455653600 7200 0 EET}
-    {2468962800 10800 1 EEST}
+    {2468872800 10800 1 EEST}
     {2487708000 7200 0 EET}
-    {2500412400 10800 1 EEST}
+    {2500322400 10800 1 EEST}
     {2519157600 7200 0 EET}
-    {2531862000 10800 1 EEST}
+    {2531772000 10800 1 EEST}
     {2550607200 7200 0 EET}
-    {2563311600 10800 1 EEST}
+    {2563826400 10800 1 EEST}
     {2582056800 7200 0 EET}
-    {2595366000 10800 1 EEST}
+    {2595276000 10800 1 EEST}
     {2613506400 7200 0 EET}
-    {2626815600 10800 1 EEST}
+    {2626725600 10800 1 EEST}
     {2644956000 7200 0 EET}
-    {2658265200 10800 1 EEST}
+    {2658175200 10800 1 EEST}
     {2677010400 7200 0 EET}
-    {2689714800 10800 1 EEST}
+    {2689624800 10800 1 EEST}
     {2708460000 7200 0 EET}
-    {2721164400 10800 1 EEST}
+    {2721679200 10800 1 EEST}
     {2739909600 7200 0 EET}
-    {2752614000 10800 1 EEST}
+    {2753128800 10800 1 EEST}
     {2771359200 7200 0 EET}
-    {2784668400 10800 1 EEST}
+    {2784578400 10800 1 EEST}
     {2802808800 7200 0 EET}
-    {2816118000 10800 1 EEST}
+    {2816028000 10800 1 EEST}
     {2834258400 7200 0 EET}
-    {2847567600 10800 1 EEST}
+    {2847477600 10800 1 EEST}
     {2866312800 7200 0 EET}
-    {2879017200 10800 1 EEST}
+    {2878927200 10800 1 EEST}
     {2897762400 7200 0 EET}
-    {2910466800 10800 1 EEST}
+    {2910981600 10800 1 EEST}
     {2929212000 7200 0 EET}
-    {2941916400 10800 1 EEST}
+    {2942431200 10800 1 EEST}
     {2960661600 7200 0 EET}
-    {2973970800 10800 1 EEST}
+    {2973880800 10800 1 EEST}
     {2992111200 7200 0 EET}
-    {3005420400 10800 1 EEST}
+    {3005330400 10800 1 EEST}
     {3024165600 7200 0 EET}
-    {3036870000 10800 1 EEST}
+    {3036780000 10800 1 EEST}
     {3055615200 7200 0 EET}
-    {3068319600 10800 1 EEST}
+    {3068229600 10800 1 EEST}
     {3087064800 7200 0 EET}
-    {3099769200 10800 1 EEST}
+    {3100284000 10800 1 EEST}
     {3118514400 7200 0 EET}
-    {3131823600 10800 1 EEST}
+    {3131733600 10800 1 EEST}
     {3149964000 7200 0 EET}
-    {3163273200 10800 1 EEST}
+    {3163183200 10800 1 EEST}
     {3181413600 7200 0 EET}
-    {3194722800 10800 1 EEST}
+    {3194632800 10800 1 EEST}
     {3213468000 7200 0 EET}
-    {3226172400 10800 1 EEST}
+    {3226082400 10800 1 EEST}
     {3244917600 7200 0 EET}
-    {3257622000 10800 1 EEST}
+    {3258136800 10800 1 EEST}
     {3276367200 7200 0 EET}
-    {3289071600 10800 1 EEST}
+    {3289586400 10800 1 EEST}
     {3307816800 7200 0 EET}
-    {3321126000 10800 1 EEST}
+    {3321036000 10800 1 EEST}
     {3339266400 7200 0 EET}
-    {3352575600 10800 1 EEST}
+    {3352485600 10800 1 EEST}
     {3371320800 7200 0 EET}
-    {3384025200 10800 1 EEST}
+    {3383935200 10800 1 EEST}
     {3402770400 7200 0 EET}
-    {3415474800 10800 1 EEST}
+    {3415384800 10800 1 EEST}
     {3434220000 7200 0 EET}
-    {3446924400 10800 1 EEST}
+    {3447439200 10800 1 EEST}
     {3465669600 7200 0 EET}
-    {3478978800 10800 1 EEST}
+    {3478888800 10800 1 EEST}
     {3497119200 7200 0 EET}
-    {3510428400 10800 1 EEST}
+    {3510338400 10800 1 EEST}
     {3528568800 7200 0 EET}
-    {3541878000 10800 1 EEST}
+    {3541788000 10800 1 EEST}
     {3560623200 7200 0 EET}
-    {3573327600 10800 1 EEST}
+    {3573237600 10800 1 EEST}
     {3592072800 7200 0 EET}
-    {3604777200 10800 1 EEST}
+    {3605292000 10800 1 EEST}
     {3623522400 7200 0 EET}
-    {3636226800 10800 1 EEST}
+    {3636741600 10800 1 EEST}
     {3654972000 7200 0 EET}
-    {3668281200 10800 1 EEST}
+    {3668191200 10800 1 EEST}
     {3686421600 7200 0 EET}
-    {3699730800 10800 1 EEST}
+    {3699640800 10800 1 EEST}
     {3717871200 7200 0 EET}
-    {3731180400 10800 1 EEST}
+    {3731090400 10800 1 EEST}
     {3749925600 7200 0 EET}
-    {3762630000 10800 1 EEST}
+    {3762540000 10800 1 EEST}
     {3781375200 7200 0 EET}
-    {3794079600 10800 1 EEST}
+    {3794594400 10800 1 EEST}
     {3812824800 7200 0 EET}
-    {3825529200 10800 1 EEST}
+    {3826044000 10800 1 EEST}
     {3844274400 7200 0 EET}
-    {3857583600 10800 1 EEST}
+    {3857493600 10800 1 EEST}
     {3875724000 7200 0 EET}
-    {3889033200 10800 1 EEST}
+    {3888943200 10800 1 EEST}
     {3907778400 7200 0 EET}
-    {3920482800 10800 1 EEST}
+    {3920392800 10800 1 EEST}
     {3939228000 7200 0 EET}
-    {3951932400 10800 1 EEST}
+    {3951842400 10800 1 EEST}
     {3970677600 7200 0 EET}
-    {3983382000 10800 1 EEST}
+    {3983896800 10800 1 EEST}
     {4002127200 7200 0 EET}
-    {4015436400 10800 1 EEST}
+    {4015346400 10800 1 EEST}
     {4033576800 7200 0 EET}
-    {4046886000 10800 1 EEST}
+    {4046796000 10800 1 EEST}
     {4065026400 7200 0 EET}
-    {4078335600 10800 1 EEST}
+    {4078245600 10800 1 EEST}
     {4097080800 7200 0 EET}
 }

Index: library/tzdata/Asia/Hebron
==================================================================
--- library/tzdata/Asia/Hebron
+++ library/tzdata/Asia/Hebron
@@ -114,168 +114,168 @@
     {1477692000 7200 0 EET}
     {1490396400 10800 1 EEST}
     {1509141600 7200 0 EET}
     {1521846000 10800 1 EEST}
     {1540591200 7200 0 EET}
-    {1553900400 10800 1 EEST}
+    {1553810400 10800 1 EEST}
     {1572040800 7200 0 EET}
-    {1585350000 10800 1 EEST}
+    {1585260000 10800 1 EEST}
     {1604095200 7200 0 EET}
-    {1616799600 10800 1 EEST}
+    {1616709600 10800 1 EEST}
     {1635544800 7200 0 EET}
-    {1648249200 10800 1 EEST}
+    {1648159200 10800 1 EEST}
     {1666994400 7200 0 EET}
-    {1679698800 10800 1 EEST}
+    {1680213600 10800 1 EEST}
     {1698444000 7200 0 EET}
-    {1711753200 10800 1 EEST}
+    {1711663200 10800 1 EEST}
     {1729893600 7200 0 EET}
-    {1743202800 10800 1 EEST}
+    {1743112800 10800 1 EEST}
     {1761343200 7200 0 EET}
-    {1774652400 10800 1 EEST}
+    {1774562400 10800 1 EEST}
     {1793397600 7200 0 EET}
-    {1806102000 10800 1 EEST}
+    {1806012000 10800 1 EEST}
     {1824847200 7200 0 EET}
-    {1837551600 10800 1 EEST}
+    {1838066400 10800 1 EEST}
     {1856296800 7200 0 EET}
-    {1869001200 10800 1 EEST}
+    {1869516000 10800 1 EEST}
     {1887746400 7200 0 EET}
-    {1901055600 10800 1 EEST}
+    {1900965600 10800 1 EEST}
     {1919196000 7200 0 EET}
-    {1932505200 10800 1 EEST}
+    {1932415200 10800 1 EEST}
     {1950645600 7200 0 EET}
-    {1963954800 10800 1 EEST}
+    {1963864800 10800 1 EEST}
     {1982700000 7200 0 EET}
-    {1995404400 10800 1 EEST}
+    {1995314400 10800 1 EEST}
     {2014149600 7200 0 EET}
-    {2026854000 10800 1 EEST}
+    {2027368800 10800 1 EEST}
     {2045599200 7200 0 EET}
-    {2058303600 10800 1 EEST}
+    {2058818400 10800 1 EEST}
     {2077048800 7200 0 EET}
-    {2090358000 10800 1 EEST}
+    {2090268000 10800 1 EEST}
     {2108498400 7200 0 EET}
-    {2121807600 10800 1 EEST}
+    {2121717600 10800 1 EEST}
     {2140552800 7200 0 EET}
-    {2153257200 10800 1 EEST}
+    {2153167200 10800 1 EEST}
     {2172002400 7200 0 EET}
-    {2184706800 10800 1 EEST}
+    {2184616800 10800 1 EEST}
     {2203452000 7200 0 EET}
-    {2216156400 10800 1 EEST}
+    {2216671200 10800 1 EEST}
     {2234901600 7200 0 EET}
-    {2248210800 10800 1 EEST}
+    {2248120800 10800 1 EEST}
     {2266351200 7200 0 EET}
-    {2279660400 10800 1 EEST}
+    {2279570400 10800 1 EEST}
     {2297800800 7200 0 EET}
-    {2311110000 10800 1 EEST}
+    {2311020000 10800 1 EEST}
     {2329855200 7200 0 EET}
-    {2342559600 10800 1 EEST}
+    {2342469600 10800 1 EEST}
     {2361304800 7200 0 EET}
-    {2374009200 10800 1 EEST}
+    {2374524000 10800 1 EEST}
     {2392754400 7200 0 EET}
-    {2405458800 10800 1 EEST}
+    {2405973600 10800 1 EEST}
     {2424204000 7200 0 EET}
-    {2437513200 10800 1 EEST}
+    {2437423200 10800 1 EEST}
     {2455653600 7200 0 EET}
-    {2468962800 10800 1 EEST}
+    {2468872800 10800 1 EEST}
     {2487708000 7200 0 EET}
-    {2500412400 10800 1 EEST}
+    {2500322400 10800 1 EEST}
     {2519157600 7200 0 EET}
-    {2531862000 10800 1 EEST}
+    {2531772000 10800 1 EEST}
     {2550607200 7200 0 EET}
-    {2563311600 10800 1 EEST}
+    {2563826400 10800 1 EEST}
     {2582056800 7200 0 EET}
-    {2595366000 10800 1 EEST}
+    {2595276000 10800 1 EEST}
     {2613506400 7200 0 EET}
-    {2626815600 10800 1 EEST}
+    {2626725600 10800 1 EEST}
     {2644956000 7200 0 EET}
-    {2658265200 10800 1 EEST}
+    {2658175200 10800 1 EEST}
     {2677010400 7200 0 EET}
-    {2689714800 10800 1 EEST}
+    {2689624800 10800 1 EEST}
     {2708460000 7200 0 EET}
-    {2721164400 10800 1 EEST}
+    {2721679200 10800 1 EEST}
     {2739909600 7200 0 EET}
-    {2752614000 10800 1 EEST}
+    {2753128800 10800 1 EEST}
     {2771359200 7200 0 EET}
-    {2784668400 10800 1 EEST}
+    {2784578400 10800 1 EEST}
     {2802808800 7200 0 EET}
-    {2816118000 10800 1 EEST}
+    {2816028000 10800 1 EEST}
     {2834258400 7200 0 EET}
-    {2847567600 10800 1 EEST}
+    {2847477600 10800 1 EEST}
     {2866312800 7200 0 EET}
-    {2879017200 10800 1 EEST}
+    {2878927200 10800 1 EEST}
     {2897762400 7200 0 EET}
-    {2910466800 10800 1 EEST}
+    {2910981600 10800 1 EEST}
     {2929212000 7200 0 EET}
-    {2941916400 10800 1 EEST}
+    {2942431200 10800 1 EEST}
     {2960661600 7200 0 EET}
-    {2973970800 10800 1 EEST}
+    {2973880800 10800 1 EEST}
     {2992111200 7200 0 EET}
-    {3005420400 10800 1 EEST}
+    {3005330400 10800 1 EEST}
     {3024165600 7200 0 EET}
-    {3036870000 10800 1 EEST}
+    {3036780000 10800 1 EEST}
     {3055615200 7200 0 EET}
-    {3068319600 10800 1 EEST}
+    {3068229600 10800 1 EEST}
     {3087064800 7200 0 EET}
-    {3099769200 10800 1 EEST}
+    {3100284000 10800 1 EEST}
     {3118514400 7200 0 EET}
-    {3131823600 10800 1 EEST}
+    {3131733600 10800 1 EEST}
     {3149964000 7200 0 EET}
-    {3163273200 10800 1 EEST}
+    {3163183200 10800 1 EEST}
     {3181413600 7200 0 EET}
-    {3194722800 10800 1 EEST}
+    {3194632800 10800 1 EEST}
     {3213468000 7200 0 EET}
-    {3226172400 10800 1 EEST}
+    {3226082400 10800 1 EEST}
     {3244917600 7200 0 EET}
-    {3257622000 10800 1 EEST}
+    {3258136800 10800 1 EEST}
     {3276367200 7200 0 EET}
-    {3289071600 10800 1 EEST}
+    {3289586400 10800 1 EEST}
     {3307816800 7200 0 EET}
-    {3321126000 10800 1 EEST}
+    {3321036000 10800 1 EEST}
     {3339266400 7200 0 EET}
-    {3352575600 10800 1 EEST}
+    {3352485600 10800 1 EEST}
     {3371320800 7200 0 EET}
-    {3384025200 10800 1 EEST}
+    {3383935200 10800 1 EEST}
     {3402770400 7200 0 EET}
-    {3415474800 10800 1 EEST}
+    {3415384800 10800 1 EEST}
     {3434220000 7200 0 EET}
-    {3446924400 10800 1 EEST}
+    {3447439200 10800 1 EEST}
     {3465669600 7200 0 EET}
-    {3478978800 10800 1 EEST}
+    {3478888800 10800 1 EEST}
     {3497119200 7200 0 EET}
-    {3510428400 10800 1 EEST}
+    {3510338400 10800 1 EEST}
     {3528568800 7200 0 EET}
-    {3541878000 10800 1 EEST}
+    {3541788000 10800 1 EEST}
     {3560623200 7200 0 EET}
-    {3573327600 10800 1 EEST}
+    {3573237600 10800 1 EEST}
     {3592072800 7200 0 EET}
-    {3604777200 10800 1 EEST}
+    {3605292000 10800 1 EEST}
     {3623522400 7200 0 EET}
-    {3636226800 10800 1 EEST}
+    {3636741600 10800 1 EEST}
     {3654972000 7200 0 EET}
-    {3668281200 10800 1 EEST}
+    {3668191200 10800 1 EEST}
     {3686421600 7200 0 EET}
-    {3699730800 10800 1 EEST}
+    {3699640800 10800 1 EEST}
     {3717871200 7200 0 EET}
-    {3731180400 10800 1 EEST}
+    {3731090400 10800 1 EEST}
     {3749925600 7200 0 EET}
-    {3762630000 10800 1 EEST}
+    {3762540000 10800 1 EEST}
     {3781375200 7200 0 EET}
-    {3794079600 10800 1 EEST}
+    {3794594400 10800 1 EEST}
     {3812824800 7200 0 EET}
-    {3825529200 10800 1 EEST}
+    {3826044000 10800 1 EEST}
     {3844274400 7200 0 EET}
-    {3857583600 10800 1 EEST}
+    {3857493600 10800 1 EEST}
     {3875724000 7200 0 EET}
-    {3889033200 10800 1 EEST}
+    {3888943200 10800 1 EEST}
     {3907778400 7200 0 EET}
-    {3920482800 10800 1 EEST}
+    {3920392800 10800 1 EEST}
     {3939228000 7200 0 EET}
-    {3951932400 10800 1 EEST}
+    {3951842400 10800 1 EEST}
     {3970677600 7200 0 EET}
-    {3983382000 10800 1 EEST}
+    {3983896800 10800 1 EEST}
     {4002127200 7200 0 EET}
-    {4015436400 10800 1 EEST}
+    {4015346400 10800 1 EEST}
     {4033576800 7200 0 EET}
-    {4046886000 10800 1 EEST}
+    {4046796000 10800 1 EEST}
     {4065026400 7200 0 EET}
-    {4078335600 10800 1 EEST}
+    {4078245600 10800 1 EEST}
     {4097080800 7200 0 EET}
 }

Index: library/tzdata/Asia/Hong_Kong
==================================================================
--- library/tzdata/Asia/Hong_Kong
+++ library/tzdata/Asia/Hong_Kong
@@ -1,28 +1,28 @@
 # created by tools/tclZIC.tcl - do not edit
 
 set TZData(:Asia/Hong_Kong) {
     {-9223372036854775808 27402 0 LMT}
     {-2056690800 28800 0 HKT}
-    {-900909000 32400 1 HKST}
+    {-900910800 32400 1 HKST}
     {-891579600 30600 0 HKT}
     {-884248200 32400 0 JST}
-    {-766659600 28800 0 HKT}
-    {-747981000 32400 1 HKST}
-    {-728544600 28800 0 HKT}
+    {-761209200 28800 0 HKT}
+    {-747907200 32400 1 HKST}
+    {-728541000 28800 0 HKT}
     {-717049800 32400 1 HKST}
-    {-694503000 28800 0 HKT}
+    {-697091400 28800 0 HKT}
     {-683785800 32400 1 HKST}
-    {-668064600 28800 0 HKT}
+    {-668061000 28800 0 HKT}
     {-654755400 32400 1 HKST}
-    {-636615000 28800 0 HKT}
+    {-636611400 28800 0 HKT}
     {-623305800 32400 1 HKST}
-    {-605165400 28800 0 HKT}
+    {-605161800 28800 0 HKT}
     {-591856200 32400 1 HKST}
-    {-573715800 28800 0 HKT}
+    {-573712200 28800 0 HKT}
     {-559801800 32400 1 HKST}
-    {-541661400 28800 0 HKT}
+    {-541657800 28800 0 HKT}
     {-528352200 32400 1 HKST}
     {-510211800 28800 0 HKT}
     {-498112200 32400 1 HKST}
     {-478762200 28800 0 HKT}
     {-466662600 32400 1 HKST}

Index: library/tzdata/Europe/Rome
==================================================================
--- library/tzdata/Europe/Rome
+++ library/tzdata/Europe/Rome
@@ -1,10 +1,10 @@
 # created by tools/tclZIC.tcl - do not edit
 
 set TZData(:Europe/Rome) {
     {-9223372036854775808 2996 0 LMT}
-    {-3259097396 2996 0 RMT}
+    {-3252098996 2996 0 RMT}
     {-2403565200 3600 0 CET}
     {-1690765200 7200 1 CEST}
     {-1680487200 3600 0 CET}
     {-1664758800 7200 1 CEST}
     {-1648951200 3600 0 CET}

ADDED   library/tzdata/SystemV/AST4
Index: library/tzdata/SystemV/AST4
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/AST4
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
+}
+set TZData(:SystemV/AST4) $TZData(:America/Puerto_Rico)

ADDED   library/tzdata/SystemV/AST4ADT
Index: library/tzdata/SystemV/AST4ADT
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/AST4ADT
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(America/Halifax)]} {
+    LoadTimeZoneFile America/Halifax
+}
+set TZData(:SystemV/AST4ADT) $TZData(:America/Halifax)

ADDED   library/tzdata/SystemV/CST6
Index: library/tzdata/SystemV/CST6
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/CST6
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(America/Regina)]} {
+    LoadTimeZoneFile America/Regina
+}
+set TZData(:SystemV/CST6) $TZData(:America/Regina)

ADDED   library/tzdata/SystemV/CST6CDT
Index: library/tzdata/SystemV/CST6CDT
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/CST6CDT
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(America/Chicago)]} {
+    LoadTimeZoneFile America/Chicago
+}
+set TZData(:SystemV/CST6CDT) $TZData(:America/Chicago)

ADDED   library/tzdata/SystemV/EST5
Index: library/tzdata/SystemV/EST5
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/EST5
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(America/Indianapolis)]} {
+    LoadTimeZoneFile America/Indianapolis
+}
+set TZData(:SystemV/EST5) $TZData(:America/Indianapolis)

ADDED   library/tzdata/SystemV/EST5EDT
Index: library/tzdata/SystemV/EST5EDT
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/EST5EDT
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(America/New_York)]} {
+    LoadTimeZoneFile America/New_York
+}
+set TZData(:SystemV/EST5EDT) $TZData(:America/New_York)

ADDED   library/tzdata/SystemV/HST10
Index: library/tzdata/SystemV/HST10
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/HST10
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(Pacific/Honolulu)]} {
+    LoadTimeZoneFile Pacific/Honolulu
+}
+set TZData(:SystemV/HST10) $TZData(:Pacific/Honolulu)

ADDED   library/tzdata/SystemV/MST7
Index: library/tzdata/SystemV/MST7
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/MST7
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(America/Phoenix)]} {
+    LoadTimeZoneFile America/Phoenix
+}
+set TZData(:SystemV/MST7) $TZData(:America/Phoenix)

ADDED   library/tzdata/SystemV/MST7MDT
Index: library/tzdata/SystemV/MST7MDT
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/MST7MDT
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(America/Denver)]} {
+    LoadTimeZoneFile America/Denver
+}
+set TZData(:SystemV/MST7MDT) $TZData(:America/Denver)

ADDED   library/tzdata/SystemV/PST8
Index: library/tzdata/SystemV/PST8
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/PST8
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(Pacific/Pitcairn)]} {
+    LoadTimeZoneFile Pacific/Pitcairn
+}
+set TZData(:SystemV/PST8) $TZData(:Pacific/Pitcairn)

ADDED   library/tzdata/SystemV/PST8PDT
Index: library/tzdata/SystemV/PST8PDT
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/PST8PDT
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(America/Los_Angeles)]} {
+    LoadTimeZoneFile America/Los_Angeles
+}
+set TZData(:SystemV/PST8PDT) $TZData(:America/Los_Angeles)

ADDED   library/tzdata/SystemV/YST9
Index: library/tzdata/SystemV/YST9
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/YST9
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(Pacific/Gambier)]} {
+    LoadTimeZoneFile Pacific/Gambier
+}
+set TZData(:SystemV/YST9) $TZData(:Pacific/Gambier)

ADDED   library/tzdata/SystemV/YST9YDT
Index: library/tzdata/SystemV/YST9YDT
==================================================================
--- /dev/null
+++ library/tzdata/SystemV/YST9YDT
@@ -0,0 +1,5 @@
+# created by ../tools/tclZIC.tcl - do not edit
+if {![info exists TZData(America/Anchorage)]} {
+    LoadTimeZoneFile America/Anchorage
+}
+set TZData(:SystemV/YST9YDT) $TZData(:America/Anchorage)

Index: macosx/README
==================================================================
--- macosx/README
+++ macosx/README
@@ -111,11 +111,11 @@
 	Note that the non-SDK configurations have their deployment target set to
 	10.5 (Tcl.xcode) resp. 10.6 (Tcl.xcodeproj).
 The Xcode projects refer to the toplevel tcl source directory via the
 TCL_SRCROOT user build setting, by default this is set to the project-relative
 path '../../tcl', if your tcl source directory is named differently, e.g.
-'../../tcl9.0', you need to manually change the TCL_SRCROOT setting by editing
+'../../tcl8.7', you need to manually change the TCL_SRCROOT setting by editing
 your ${USER}.pbxuser file (located inside the Tcl.xcodeproj bundle directory)
 with a text editor.
 
 - To build universal binaries outside of the Xcode IDE, set CFLAGS as follows:
 	export CFLAGS="-arch i386 -arch x86_64 -arch ppc"
@@ -132,13 +132,13 @@
 ----------------------------------------------------------
 
 - Unpack the Tcl source release archive.
 
 - The following instructions assume the Tcl source tree is named "tcl${ver}",
-(where ${ver} is a shell variable containing the Tcl version number e.g. '9.0').
+(where ${ver} is a shell variable containing the Tcl version number e.g. '8.7').
 Setup this shell variable as follows:
-	ver="9.0"
+	ver="8.7"
 If you are building from CVS, omit this step (CVS source tree names usually do
 not contain a version number).
 
 - Setup environment variables as desired, e.g. for a universal build on 10.5:
 	CFLAGS="-arch i386 -arch x86_64 -arch ppc -mmacosx-version-min=10.5"

Index: macosx/Tcl-Common.xcconfig
==================================================================
--- macosx/Tcl-Common.xcconfig
+++ macosx/Tcl-Common.xcconfig
@@ -32,6 +32,6 @@
 PREFIX = /usr/local
 TCL_CONFIGURE_ARGS = --enable-dtrace
 TCL_LIBRARY = $(LIBDIR)/tcl$(VERSION)
 TCL_PACKAGE_PATH = "$(LIBDIR)"
 TCL_DEFS = HAVE_TCL_CONFIG_H
-VERSION = 9.0
+VERSION = 8.7

Index: macosx/Tcl.xcode/project.pbxproj
==================================================================
--- macosx/Tcl.xcode/project.pbxproj
+++ macosx/Tcl.xcode/project.pbxproj
@@ -1336,10 +1336,11 @@
 				F96D3F3908F272A8004A47F5 /* auto.tcl */,
 				F96D3F3A08F272A8004A47F5 /* clock.tcl */,
 				F96D3F3B08F272A8004A47F5 /* dde */,
 				F96D3F8C08F272A8004A47F5 /* history.tcl */,
 				F96D3F8D08F272A8004A47F5 /* http */,
+				F96D3F9008F272A8004A47F5 /* http1.0 */,
 				F96D3F9308F272A8004A47F5 /* init.tcl */,
 				F96D3F9408F272A8004A47F5 /* msgcat */,
 				F96D401708F272AA004A47F5 /* opt */,
 				F96D401A08F272AA004A47F5 /* package.tcl */,
 				F96D401B08F272AA004A47F5 /* parray.tcl */,
@@ -1368,10 +1369,19 @@
 				F96D3F8E08F272A8004A47F5 /* http.tcl */,
 				F96D3F8F08F272A8004A47F5 /* pkgIndex.tcl */,
 			);
 			path = http;
 			sourceTree = "<group>";
+		};
+		F96D3F9008F272A8004A47F5 /* http1.0 */ = {
+			isa = PBXGroup;
+			children = (
+				F96D3F9108F272A8004A47F5 /* http.tcl */,
+				F96D3F9208F272A8004A47F5 /* pkgIndex.tcl */,
+			);
+			path = http1.0;
+			sourceTree = "<group>";
 		};
 		F96D3F9408F272A8004A47F5 /* msgcat */ = {
 			isa = PBXGroup;
 			children = (
 				F96D3F9508F272A8004A47F5 /* msgcat.tcl */,

Index: macosx/Tcl.xcodeproj/project.pbxproj
==================================================================
--- macosx/Tcl.xcodeproj/project.pbxproj
+++ macosx/Tcl.xcodeproj/project.pbxproj
@@ -1337,10 +1337,11 @@
 				F96D3F3908F272A8004A47F5 /* auto.tcl */,
 				F96D3F3A08F272A8004A47F5 /* clock.tcl */,
 				F96D3F3B08F272A8004A47F5 /* dde */,
 				F96D3F8C08F272A8004A47F5 /* history.tcl */,
 				F96D3F8D08F272A8004A47F5 /* http */,
+				F96D3F9008F272A8004A47F5 /* http1.0 */,
 				F96D3F9308F272A8004A47F5 /* init.tcl */,
 				F96D3F9408F272A8004A47F5 /* msgcat */,
 				F96D401708F272AA004A47F5 /* opt */,
 				F96D401A08F272AA004A47F5 /* package.tcl */,
 				F96D401B08F272AA004A47F5 /* parray.tcl */,
@@ -1369,10 +1370,19 @@
 				F96D3F8E08F272A8004A47F5 /* http.tcl */,
 				F96D3F8F08F272A8004A47F5 /* pkgIndex.tcl */,
 			);
 			path = http;
 			sourceTree = "<group>";
+		};
+		F96D3F9008F272A8004A47F5 /* http1.0 */ = {
+			isa = PBXGroup;
+			children = (
+				F96D3F9108F272A8004A47F5 /* http.tcl */,
+				F96D3F9208F272A8004A47F5 /* pkgIndex.tcl */,
+			);
+			path = http1.0;
+			sourceTree = "<group>";
 		};
 		F96D3F9408F272A8004A47F5 /* msgcat */ = {
 			isa = PBXGroup;
 			children = (
 				F96D3F9508F272A8004A47F5 /* msgcat.tcl */,

Index: macosx/tclMacOSXBundle.c
==================================================================
--- macosx/tclMacOSXBundle.c
+++ macosx/tclMacOSXBundle.c
@@ -165,11 +165,11 @@
 int
 Tcl_MacOSXOpenBundleResources(
     Tcl_Interp *interp,
     const char *bundleName,
     int hasResourceFile,
-    size_t maxPathLen,
+    int maxPathLen,
     char *libraryPath)
 {
     return Tcl_MacOSXOpenVersionedBundleResources(interp, bundleName, NULL,
 	    hasResourceFile, maxPathLen, libraryPath);
 }
@@ -199,11 +199,11 @@
 Tcl_MacOSXOpenVersionedBundleResources(
     Tcl_Interp *interp,
     const char *bundleName,
     const char *bundleVersion,
     int hasResourceFile,
-    size_t maxPathLen,
+    int maxPathLen,
     char *libraryPath)
 {
 #ifdef HAVE_COREFOUNDATION
     CFBundleRef bundleRef, versionedBundleRef = NULL;
     CFStringRef bundleNameRef;

Index: macosx/tclMacOSXFCmd.c
==================================================================
--- macosx/tclMacOSXFCmd.c
+++ macosx/tclMacOSXFCmd.c
@@ -345,11 +345,11 @@
 
 	    Tcl_DStringInit(&ds);
 	    Tcl_DStringAppend(&ds, native, -1);
 	    Tcl_DStringAppend(&ds, _PATH_RSRCFORKSPEC, -1);
 
-	    result = truncate(Tcl_DStringValue(&ds), (off_t)0);
+	    result = truncate(Tcl_DStringValue(&ds), 0);
 	    if (result != 0) {
 		/*
 		 * truncate() on a valid resource fork path may fail with a
 		 * permission error in some OS releases, try truncating with
 		 * open() instead:
@@ -637,14 +637,13 @@
 {
     const char *string;
     int result = TCL_OK;
     Tcl_DString ds;
     Tcl_Encoding encoding = Tcl_GetEncoding(NULL, "macRoman");
-    size_t length;
 
-    string = TclGetStringFromObj(objPtr, &length);
-    Tcl_UtfToExternalDString(encoding, string, length, &ds);
+    string = TclGetString(objPtr);
+    Tcl_UtfToExternalDString(encoding, string, objPtr->length, &ds);
 
     if (Tcl_DStringLength(&ds) > 4) {
 	if (interp) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "expected Macintosh OS type but got \"%s\": ", string));
@@ -688,11 +687,11 @@
  *----------------------------------------------------------------------
  */
 
 static void
 UpdateStringOfOSType(
-    register Tcl_Obj *objPtr)	/* OSType object whose string rep to
+    Tcl_Obj *objPtr)	/* OSType object whose string rep to
 				 * update. */
 {
     const int size = TCL_UTF_MAX * 4;
     char *dst = Tcl_InitStringRep(objPtr, NULL, size);
     OSType osType = (OSType) objPtr->internalRep.wideValue;

Index: macosx/tclMacOSXNotify.c
==================================================================
--- macosx/tclMacOSXNotify.c
+++ macosx/tclMacOSXNotify.c
@@ -1034,11 +1034,11 @@
 	if (filePtr->fd == fd) {
 	    break;
 	}
     }
     if (filePtr == NULL) {
-	filePtr = Tcl_Alloc(sizeof(FileHandler));
+	filePtr = ckalloc(sizeof(FileHandler));
 	filePtr->fd = fd;
 	filePtr->readyMask = 0;
 	filePtr->nextPtr = tsdPtr->firstFileHandlerPtr;
 	tsdPtr->firstFileHandlerPtr = filePtr;
     }
@@ -1162,11 +1162,11 @@
     if (prevPtr == NULL) {
 	tsdPtr->firstFileHandlerPtr = filePtr->nextPtr;
     } else {
 	prevPtr->nextPtr = filePtr->nextPtr;
     }
-    Tcl_Free(filePtr);
+    ckfree(filePtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1417,11 +1417,11 @@
 	 * Don't bother to queue an event if the mask was previously non-zero
 	 * since an event must still be on the queue.
 	 */
 
 	if (filePtr->readyMask == 0) {
-	    FileHandlerEvent *fileEvPtr = Tcl_Alloc(sizeof(FileHandlerEvent));
+	    FileHandlerEvent *fileEvPtr = ckalloc(sizeof(FileHandlerEvent));
 
 	    fileEvPtr->header.proc = FileHandlerEventProc;
 	    fileEvPtr->fd = filePtr->fd;
 	    Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
 	}

Index: tests-perf/clock.perf.tcl
==================================================================
--- tests-perf/clock.perf.tcl
+++ tests-perf/clock.perf.tcl
@@ -120,11 +120,11 @@
     {clock format 1482525936 -format "%%a = %a | %%A = %A | %%b = %b | %%h = %h | %%B = %B | %%C = %C | %%d = %d | %%e = %e | %%g = %g | %%G = %G | %%H = %H | %%I = %I | %%j = %j | %%J = %J | %%k = %k | %%l = %l | %%m = %m | %%M = %M | %%N = %N | %%p = %p | %%P = %P | %%Q = %Q | %%s = %s | %%S = %S | %%t = %t | %%u = %u | %%U = %U | %%V = %V | %%w = %w | %%W = %W | %%y = %y | %%Y = %Y | %%z = %z | %%Z = %Z | %%n = %n | %%EE = %EE | %%EC = %EC | %%Ey = %Ey | %%n = %n | %%Od = %Od | %%Oe = %Oe | %%OH = %OH | %%Ok = %Ok | %%OI = %OI | %%Ol = %Ol | %%Om = %Om | %%OM = %OM | %%OS = %OS | %%Ou = %Ou | %%Ow = %Ow | %%Oy = %Oy" -timezone :CET -locale de}
   }
 }
 
 proc test-scan {{reptime 1000}} {
-  _test_run $reptime {
+  _test_run -convert-result {clock format $_(r) -locale en} $reptime {
     # Scan : date (in gmt)
     {clock scan "25.11.2015" -format "%d.%m.%Y" -base 0 -gmt 1}
     # Scan : date (system time zone, with base)
     {clock scan "25.11.2015" -format "%d.%m.%Y" -base 0}
     # Scan : date (system time zone, without base)
@@ -196,15 +196,15 @@
     # {clock scan "25.11.2015" -format "%d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y" -base 0 -gmt 1}
     # # Scan : dynamic, very long format test (create obj representation, allock chain, GC, etc):
     # {clock scan "25.11.2015" -format [string repeat "[incr i] %d.%m.%Y %d.%m.%Y" 10] -base 0 -gmt 1}
     # # Scan : again:
     # {clock scan "25.11.2015" -format [string repeat "[incr i -1] %d.%m.%Y %d.%m.%Y" 10] -base 0 -gmt 1}
-  } {puts [clock format $_(r) -locale en]}
+  }
 }
 
 proc test-freescan {{reptime 1000}} {
-  _test_run $reptime {
+  _test_run -convert-result {clock format $_(r) -locale en}  $reptime {
     # FreeScan : relative date
     {clock scan "5 years 18 months 385 days" -base 0 -gmt 1}
     # FreeScan : relative date with relative weekday
     {clock scan "5 years 18 months 385 days Fri" -base 0 -gmt 1}
     # FreeScan : relative date with ordinal month
@@ -237,11 +237,11 @@
     {clock scan "19:18:30 GMT" -base 148863600}
     # FreeScan : fast switch of zones in cycle - GMT, MST, CET (system) and EST
     {clock scan "19:18:30 MST" -base 148863600 -gmt 1
      clock scan "19:18:30 EST" -base 148863600
     }
-  } {puts [clock format $_(r) -locale en]}
+  }
 }
 
 proc test-add {{reptime 1000}} {
   set tests {
     # Add : years
@@ -280,11 +280,11 @@
   }
   # if does not support add of weekdays:
   if {[catch {clock add 0 3 weekdays -gmt 1}]} {
     regsub -all {\mweekdays\M} $tests "days" tests
   }
-  _test_run $reptime $tests {puts [clock format $_(r) -locale en]}
+  _test_run -convert-result {clock format $_(r) -locale en} $reptime $tests
 }
 
 proc test-convert {{reptime 1000}} {
   _test_run $reptime {
     # Convert locale (en -> de):

Index: tests-perf/test-performance.tcl
==================================================================
--- tests-perf/test-performance.tcl
+++ tests-perf/test-performance.tcl
@@ -125,19 +125,27 @@
 }
 
 proc _test_run {args} {
   upvar _ _
   # parse args:
-  array set _ [set _opts {-no-result 0 -uplevel 0}]
+  array set _ {-no-result 0 -uplevel 0 -convert-result {}}
   while {[llength $args] > 2} {
-    if {[set o [lindex $args 0]] ni $_opts || $_($o)} {
+    if {![info exists _([set o [lindex $args 0]])]} {
       break
     }
-    set _($o) 1
-    set args [lrange $args 1 end]
+    if {[string is boolean -strict $_($o)]} {
+      set _($o) [expr {! $_($o)}]
+      set args [lrange $args 1 end]
+    } else {
+      if {[llength $args] <= 2} {
+        return -code error "value expected for option $o"
+      }
+      set _($o) [lindex $args 1]
+      set args [lrange $args 2 end]
+    }
   }
-  unset -nocomplain _opts o
+  unset -nocomplain o
   if {[llength $args] < 2 || [llength $args] > 3} {
     return -code error "wrong # args: should be \"[lindex [info level [info level]] 0] ?-no-result? reptime lst ?outcmd?\""
   }
   set _(outcmd) {puts}
   set args [lassign $args reptime lst]
@@ -171,11 +179,12 @@
     }
     set _(ittime) $_(reptime)
     # if output result (and not once):
     if {!$_(-no-result)} {
       set _(r) [if 1 $_(c)]
-      if {$_(outcmd) ne {}} {{*}$_(outcmd) $_(r)}
+      if {$_(-convert-result) ne ""} { set _(r) [if 1 $_(-convert-result)] }
+      {*}$_(outcmd) $_(r)
       if {[llength $_(ittime)] > 1} { # decrement max-count
         lset _(ittime) 1 [expr {[lindex $_(ittime) 1] - 1}]
       }
     }
     {*}$_(outcmd) [set _(m) [timerate $_(c) {*}$_(ittime)]]

Index: tests/all.tcl
==================================================================
--- tests/all.tcl
+++ tests/all.tcl
@@ -10,11 +10,11 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 
 package prefer latest
 package require Tcl 8.5-
-package require tcltest 2.2
+package require tcltest 2.5
 namespace import ::tcltest::*
 
 configure {*}$argv -testdir [file dirname [file dirname [file normalize [
     info script]/...]]]
 

Index: tests/assemble.test
==================================================================
--- tests/assemble.test
+++ tests/assemble.test
@@ -529,10 +529,22 @@
 	}
 	x
     }
     -result 12
     -cleanup {rename x {}}
+}
+test assemble-7.17 {land/lor} {
+    -body {
+	proc x {a b} {
+	    list \
+		[assemble {load a; load b; land}] \
+		[assemble {load a; load b; lor}]
+	}
+	list [x 0 0] [x 0 23] [x 35 0] [x 47 59]
+    }
+    -result {{0 0} {0 1} {0 1} {1 1}}
+    -cleanup {rename x {}}
 }
 test assemble-7.18 {lappendArrayStk} {
     -body {
 	proc x {} {
 	    set able(baker) charlie
@@ -767,11 +779,11 @@
 	assemble {
 	    push NaN; uplus
 	}
     }
     -returnCodes error
-    -result {can't use non-numeric floating-point value "NaN" as operand of "+"}
+    -result {can't use non-numeric floating-point value as operand of "+"}
 }
 test assemble-7.43.1 {tryCvtToNumeric} {
     -body {
 	assemble {
 	    push NaN; tryCvtToNumeric

Index: tests/async.test
==================================================================
--- tests/async.test
+++ tests/async.test
@@ -18,10 +18,11 @@
 
 ::tcltest::loadTestedCommands
 catch [list package require -exact Tcltest [info patchlevel]]
 
 testConstraint testasync [llength [info commands testasync]]
+testConstraint knownMsvcBug [expr {![info exists ::env(TRAVIS_OS_NAME)] || ![string match windows $::env(TRAVIS_OS_NAME)]}]
 
 proc async1 {result code} {
     global aresult acode
     set aresult $result
     set acode $code
@@ -200,11 +201,11 @@
     # "still reachable" cases from early thread termination
     after 100
     testasync delete $hm
 }
 test async-4.3 {async interrupting loop-less bytecode sequence} -constraints {
-    testasync
+    testasync knownMsvcBug
 } -setup {
     set hm [testasync create async3]
 } -body {
     apply [list {handle} [concat {
 	global aresult

Index: tests/binary.test
==================================================================
--- tests/binary.test
+++ tests/binary.test
@@ -2910,11 +2910,11 @@
 	return $one[binary format H* $b]
     }} ab cd
 } [binary format H* abcd]
 
 test binary-78.1 {unicode (out of BMP) to byte-array conversion, bug-[bd94500678]} -body {
-    # just test for BO-segfault (high surrogate w/o advance source pointer for out of BMP char if TCL_UTF_MAX <= 4):
+    # just test for BO-segfault (high surrogate w/o advance source pointer for out of BMP char if TCL_UTF_MAX == 3):
     binary encode hex \U0001f415
     binary scan \U0001f415 a* v; set v
     set str {}
 } -result {}
 

ADDED   tests/case.test
Index: tests/case.test
==================================================================
--- /dev/null
+++ tests/case.test
@@ -0,0 +1,94 @@
+# Commands covered:  case
+#
+# This file contains a collection of tests for one or more of the Tcl
+# built-in commands.  Sourcing this file into Tcl runs the tests and
+# generates output for errors.  No output means no errors were found.
+#
+# Copyright (c) 1991-1993 The Regents of the University of California.
+# Copyright (c) 1994 Sun Microsystems, Inc.
+# Copyright (c) 1998-1999 by Scriptics Corporation.
+#
+# See the file "license.terms" for information on usage and redistribution
+# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+
+if {![llength [info commands case]]} {
+    # No "case" command? So no need to test
+    return
+}
+
+if {[lsearch [namespace children] ::tcltest] == -1} {
+    package require tcltest
+    namespace import -force ::tcltest::*
+}
+
+test case-1.1 {simple pattern} {
+    case a in a {format 1} b {format 2} c {format 3} default {format 4}
+} 1
+test case-1.2 {simple pattern} {
+    case b a {format 1} b {format 2} c {format 3} default {format 4}
+} 2
+test case-1.3 {simple pattern} {
+    case x in a {format 1} b {format 2} c {format 3} default {format 4}
+} 4
+test case-1.4 {simple pattern} {
+    case x a {format 1} b {format 2} c {format 3}
+} {}
+test case-1.5 {simple pattern matches many times} {
+    case b a {format 1} b {format 2} b {format 3} b {format 4}
+} 2
+test case-1.6 {fancier pattern} {
+    case cx a {format 1} *c {format 2} *x {format 3} default {format 4}
+} 3
+test case-1.7 {list of patterns} {
+    case abc in {a b c} {format 1} {def abc ghi} {format 2}
+} 2
+
+test case-2.1 {error in executed command} {
+    list [catch {case a in a {error "Just a test"} default {format 1}} msg] \
+	    $msg $::errorInfo
+} {1 {Just a test} {Just a test
+    while executing
+"error "Just a test""
+    ("a" arm line 1)
+    invoked from within
+"case a in a {error "Just a test"} default {format 1}"}}
+test case-2.2 {error: not enough args} {
+    list [catch {case} msg] $msg
+} {1 {wrong # args: should be "case string ?in? ?pattern body ...? ?default body?"}}
+test case-2.3 {error: pattern with no body} {
+    list [catch {case a b} msg] $msg
+} {1 {extra case pattern with no body}}
+test case-2.4 {error: pattern with no body} {
+    list [catch {case a in b {format 1} c} msg] $msg
+} {1 {extra case pattern with no body}}
+test case-2.5 {error in default command} {
+    list [catch {case foo in a {error case1} default {error case2} \
+	    b {error case 3}} msg] $msg $::errorInfo
+} {1 case2 {case2
+    while executing
+"error case2"
+    ("default" arm line 1)
+    invoked from within
+"case foo in a {error case1} default {error case2}  b {error case 3}"}}
+
+test case-3.1 {single-argument form for pattern/command pairs} {
+    case b in {
+	a {format 1}
+	b {format 2}
+	default {format 6}
+    }
+} {2}
+test case-3.2 {single-argument form for pattern/command pairs} {
+    case b {
+	a {format 1}
+	b {format 2}
+	default {format 6}
+    }
+} {2}
+test case-3.3 {single-argument form for pattern/command pairs} {
+    list [catch {case z in {a 2 b}} msg] $msg
+} {1 {extra case pattern with no body}}
+
+# cleanup
+::tcltest::cleanupTests
+return

Index: tests/chanio.test
==================================================================
--- tests/chanio.test
+++ tests/chanio.test
@@ -41,10 +41,11 @@
     testConstraint testchannel      [llength [info commands testchannel]]
     testConstraint openpipe         1
     testConstraint testfevent       [llength [info commands testfevent]]
     testConstraint testchannelevent [llength [info commands testchannelevent]]
     testConstraint testmainthread   [llength [info commands testmainthread]]
+    testConstraint knownMsvcBug [expr {![info exists ::env(TRAVIS_OS_NAME)] || ![string match windows $::env(TRAVIS_OS_NAME)]}]
 
     # You need a *very* special environment to do some tests.  In particular,
     # many file systems do not support large-files...
     testConstraint largefileSupport [expr {$::tcl_platform(os) ne "Darwin"}]
 
@@ -886,11 +887,11 @@
     set x ""
 } -constraints {stdio testchannel openpipe fileevent} -body {
     # Tcl_ExternalToUtf()
     set f [openpipe w+ $path(cat)]
     chan configure $f -translation {auto lf} -buffering none
-    chan configure $f -encoding unicode
+    chan configure $f -encoding utf-16
     chan puts -nonewline $f "bbbbbbbbbbbbbbb\n123456789abcdef\r"
     chan configure $f -buffersize 16
     chan gets $f
     chan configure $f -blocking 0
     lappend x [chan gets $f line] $line [testchannel queuedcr $f]
@@ -1127,11 +1128,11 @@
     chan configure $f -translation lf -encoding ascii -buffering none
     chan puts -nonewline $f "123456789012345\r\nbcdefghijklmnopqrstuvwxyz"
     chan event $f read [namespace code {
 	lappend x [chan gets $f line] $line [testchannel inputbuffered $f]
     }]
-    chan configure $f -encoding unicode -buffersize 16 -blocking 0
+    chan configure $f -encoding utf-16 -buffersize 16 -blocking 0
     vwait [namespace which -variable x]
     chan configure $f -translation auto -encoding ascii -blocking 1
     # here
     vwait [namespace which -variable x]
     return $x
@@ -2788,11 +2789,11 @@
     proc writelots {s l} {
 	for {set i 0} {$i < 2000} {incr i} {
 	    chan puts $s $l
 	}
     }
-} -constraints {socket tempNotMac fileevent} -body {
+} -constraints {socket tempNotMac fileevent knownMsvcBug} -body {
     proc accept {s a p} {
 	variable x
 	chan event $s readable [namespace code [list readit $s]]
 	chan configure $s -blocking off
 	set x accepted

Index: tests/cmdAH.test
==================================================================
--- tests/cmdAH.test
+++ tests/cmdAH.test
@@ -19,15 +19,20 @@
 catch [list package require -exact Tcltest [info patchlevel]]
 
 testConstraint testchmod       [llength [info commands testchmod]]
 testConstraint testsetplatform [llength [info commands testsetplatform]]
 testConstraint testvolumetype  [llength [info commands testvolumetype]]
+testConstraint time64bit [expr {
+    $::tcl_platform(pointerSize) >= 8 ||
+    [llength [info command testsize]] && [testsize st_mtime] >= 8
+}]
 testConstraint linkDirectory [expr {
     ![testConstraint win] ||
     ($::tcl_platform(osVersion) >= 5.0
      && [lindex [file system [temporaryDirectory]] 1] eq "NTFS")
 }]
+testConstraint knownMsvcBug [expr {![info exists ::env(TRAVIS_OS_NAME)] || ![string match windows $::env(TRAVIS_OS_NAME)]}]
 
 global env
 set cmdAHwd [pwd]
 catch {set platform [testgetplatform]}
 
@@ -56,10 +61,12 @@
     break foo
 } -returnCodes error -result {wrong # args: should be "break"}
 test cmdAH-0.2 {Tcl_BreakObjCmd, success} {
     list [catch {break} msg] $msg
 } {3 {}}
+
+# Tcl_CaseObjCmd is tested in case.test
 
 test cmdAH-1.1 {Tcl_CatchObjCmd, errors} -returnCodes error -body {
     catch
 } -result {wrong # args: should be "catch script ?resultVarName? ?optionVarName?"}
 test cmdAH-1.2 {Tcl_CatchObjCmd, errors} {
@@ -1286,10 +1293,26 @@
     Tcl_FileObjCmd: mtime (built-in Windows names with dir path and extension)
 } -constraints {win} -body {
     file mtime [file join [temporaryDirectory] CON.txt]
 } -match regexp -result {could not (?:get modification time|read)} -returnCodes error
 
+# 3155760000 is 64-bit unix time, Wed Jan 01 00:00:00 GMT 2070:
+test cmdAH-24.20.1 {Tcl_FileObjCmd: atime 64-bit time_t, bug [4718b41c56]} -constraints {time64bit} -setup {
+    set filename [makeFile "" foo.text]
+} -body {
+    list [file atime $filename 3155760000] [file atime $filename]
+} -cleanup {
+    removeFile $filename
+} -result {3155760000 3155760000}
+test cmdAH-24.20.2 {Tcl_FileObjCmd: mtime 64-bit time_t, bug [4718b41c56]} -constraints {time64bit} -setup {
+    set filename [makeFile "" foo.text]
+} -body {
+    list [file mtime $filename 3155760000] [file mtime $filename]
+} -cleanup {
+    file delete -force $filename
+} -result {3155760000 3155760000}
+
 # owned
 test cmdAH-25.1 {Tcl_FileObjCmd: owned} -returnCodes error -body {
     file owned a b
 } -result {wrong # args: should be "file owned name"}
 test cmdAH-25.2 {Tcl_FileObjCmd: owned} -constraints win -body {
@@ -1304,11 +1327,11 @@
     removeFile touch.me /tmp
 } -result 1
 test cmdAH-25.3 {Tcl_FileObjCmd: owned} {unix notRoot} {
     file owned /
 } 0
-test cmdAH-25.3.1 {Tcl_FileObjCmd: owned} -constraints win -body {
+test cmdAH-25.3.1 {Tcl_FileObjCmd: owned} -constraints {win knownMsvcBug} -body {
     file owned $env(windir)
 } -result 0
 test cmdAH-25.4 {Tcl_FileObjCmd: owned} -body {
     file owned nosuchfile
 } -result 0

Index: tests/cmdMZ.test
==================================================================
--- tests/cmdMZ.test
+++ tests/cmdMZ.test
@@ -20,11 +20,14 @@
     namespace import ::tcltest::cleanupTests
     namespace import ::tcltest::customMatch
     namespace import ::tcltest::makeFile
     namespace import ::tcltest::removeFile
     namespace import ::tcltest::temporaryDirectory
+    namespace import ::tcltest::testConstraint
     namespace import ::tcltest::test
+
+    testConstraint knownMsvcBug [expr {![info exists ::env(TRAVIS_OS_NAME)] || ![string match windows $::env(TRAVIS_OS_NAME)]}]
 
     proc ListGlobMatch {expected actual} {
 	if {[llength $expected] != [llength $actual]} {
 	    return 0
 	}
@@ -337,20 +340,38 @@
     time bogusCmd -12456
 } {0 microseconds per iteration}
 test cmdMZ-5.5 {Tcl_TimeObjCmd: result format} -body {
     time {format 1}
 } -match regexp -result {^\d+ microseconds per iteration}
-test cmdMZ-5.6 {Tcl_TimeObjCmd: slower commands take longer} {
+test cmdMZ-5.6 {Tcl_TimeObjCmd: slower commands take longer} knownMsvcBug {
     expr {[lindex [time {_nrt_sleep 1}] 0] < [lindex [time {_nrt_sleep 20}] 0]}
 } 1
 test cmdMZ-5.7 {Tcl_TimeObjCmd: errors generate right trace} {
     list [catch {time {error foo}} msg] $msg $::errorInfo
 } {1 foo {foo
     while executing
 "error foo"
     invoked from within
 "time {error foo}"}}
+test cmdMZ-5.7.1 {Tcl_TimeObjCmd: return from time} {
+    set x 0
+    proc r1 {} {upvar x x; time {incr x; return "r1"; incr x} 10}
+    list [r1] $x
+} {r1 1}
+test cmdMZ-5.8 {Tcl_TimeObjCmd: done optimization: nested call of self inside time (if compiled)} {
+    set x [set y 0]
+    set m1 {
+	if {[incr x] <= 5} {
+	    # nested call should return result, so covering that:
+	    if {![string is integer -strict [eval $m1]]} {error unexpected}
+	}
+	# increase again (no "continue" from nested call):
+	incr x
+    }
+    time {incr y; eval $m1} 5
+    list $y $x
+} {5 20}
 
 test cmdMZ-6.1 {Tcl_TimeRateObjCmd: basic format of command} {
     list [catch {timerate} msg] $msg
 } {1 {wrong # args: should be "timerate ?-direct? ?-calibrate? ?-overhead double? command ?time ?max-count??"}}
 test cmdMZ-6.2.1 {Tcl_TimeRateObjCmd: basic format of command} {
@@ -372,11 +393,11 @@
     regexp {^\d+(?:\.\d+)? \ws/# 1 # \d+(?:\.\d+)? #/sec \d+(?:\.\d+)? net-ms$} [timerate {} 0]
 } 1
 test cmdMZ-6.5b {Tcl_TimeRateObjCmd: result format without iterations} {
     regexp {^0 \ws/# 0 # 0 #/sec 0 net-ms$} [timerate {} 0 0]
 } 1
-test cmdMZ-6.6 {Tcl_TimeRateObjCmd: slower commands take longer, but it remains almost the same time of measument} {
+test cmdMZ-6.6 {Tcl_TimeRateObjCmd: slower commands take longer, but it remains almost the same time of measument} knownMsvcBug {
     set m1 [timerate {_nrt_sleep 0} 20]
     set m2 [timerate {_nrt_sleep 0.2} 20]
     list \
 	[expr {[lindex $m1 0] < [lindex $m2 0]}] \
 	[expr {[lindex $m1 0] < 100}] \
@@ -393,10 +414,15 @@
 } {1 foo {foo
     while executing
 "error foo"
     invoked from within
 "timerate {error foo} 1"}}
+test cmdMZ-6.7.1 {Tcl_TimeRateObjCmd: return from timerate} {
+    set x 0
+    proc r1 {} {upvar x x; timerate {incr x; return "r1"; incr x} 1000 10}
+    list [r1] $x
+} {r1 1}
 test cmdMZ-6.8 {Tcl_TimeRateObjCmd: allow (conditional) break from timerate} {
     set m1 [timerate {break}]
     list \
 	[expr {[lindex $m1 0] < 1000}] \
 	[expr {[lindex $m1 2] == 1}] \
@@ -404,14 +430,14 @@
 	[expr {[lindex $m1 6] < 10}]
 } {1 1 1 1}
 test cmdMZ-6.8.1 {Tcl_TimeRateObjCmd: allow (conditional) continue in timerate} {
     set m1 [timerate {continue; return -code error "unexpected"} 1000 10]
     list \
-    [expr {[lindex $m1 0] < 1000}] \
-    [expr {[lindex $m1 2] == 10}] \
-    [expr {[lindex $m1 4] > 1000}] \
-    [expr {[lindex $m1 6] < 100}]
+	[expr {[lindex $m1 0] < 1000}] \
+	[expr {[lindex $m1 2] == 10}] \
+	[expr {[lindex $m1 4] > 1000}] \
+	[expr {[lindex $m1 6] < 100}]
 } {1 1 1 1}
 test cmdMZ-6.9 {Tcl_TimeRateObjCmd: max count of iterations} {
     set m1 [timerate {} 1000 5];	# max-count wins
     set m2 [timerate {_nrt_sleep 20} 1 5];	# max-time wins
     list [lindex $m1 2] [lindex $m2 2]
@@ -428,10 +454,22 @@
     set m1 {set m2 ok}
     if 1 $m1
     timerate $m1 1000 10
     if 1 $m1; # if rollback is missing throws an error: invoked "continue" outside of a loop
 } ok
+test cmdMZ-6.12 {Tcl_TimeRateObjCmd: done optimization: nested call of self inside timerate} {
+    set x 0
+    set m1 {
+	if {[incr x] <= 5} {
+	    # nested call should return result, so covering that:
+	    if {![string is integer -strict [eval $m1]]} {error unexpected}
+	}
+	# increase again (no "continue" from nested call):
+	incr x
+    }
+    list [lindex [timerate $m1 1000 5] 2] $x
+} {5 20}
 
 test cmdMZ-try-1.0 {
 
     fix for issue 45b9faf103f2
 

Index: tests/compExpr-old.test
==================================================================
--- tests/compExpr-old.test
+++ tests/compExpr-old.test
@@ -16,10 +16,11 @@
     package require tcltest 2
     namespace import -force ::tcltest::*
 }
 
 ::tcltest::loadTestedCommands
+catch [list package require -exact Tcltest [info patchlevel]]
 
 # Big test for correct ordering of data in [expr]
 
 proc testIEEE {} {
     variable ieeeValues
@@ -276,14 +277,14 @@
 test compExpr-old-6.8 {CompileBitXorExpr: error compiling bitxor arm} -body {
     expr 2^x
 } -returnCodes error -match glob -result *
 test compExpr-old-6.9 {CompileBitXorExpr: runtime error in bitxor arm} {
     list [catch {expr {24.0^3}} msg] $msg
-} {1 {can't use floating-point value "24.0" as operand of "^"}}
+} {1 {can't use floating-point value as operand of "^"}}
 test compExpr-old-6.10 {CompileBitXorExpr: runtime error in bitxor arm} {
     list [catch {expr {"a"^"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "^"}}
+} {1 {can't use non-numeric string as operand of "^"}}
 
 test compExpr-old-7.1 {CompileBitAndExpr: just equality expr} {expr 3==2} 0
 test compExpr-old-7.2 {CompileBitAndExpr: just equality expr} {expr 2.0==2} 1
 test compExpr-old-7.3 {CompileBitAndExpr: just equality expr} {expr 3.2!=2.2} 1
 test compExpr-old-7.4 {CompileBitAndExpr: just equality expr} {expr {"abc" == "abd"}} 0
@@ -300,14 +301,14 @@
 test compExpr-old-7.11 {CompileBitAndExpr: error compiling bitand arm} -body {
     expr 2&x
 } -returnCodes error -match glob -result *
 test compExpr-old-7.12 {CompileBitAndExpr: runtime error in bitand arm} {
     list [catch {expr {24.0&3}} msg] $msg
-} {1 {can't use floating-point value "24.0" as operand of "&"}}
+} {1 {can't use floating-point value as operand of "&"}}
 test compExpr-old-7.13 {CompileBitAndExpr: runtime error in bitand arm} {
     list [catch {expr {"a"&"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "&"}}
+} {1 {can't use non-numeric string as operand of "&"}}
 
 test compExpr-old-8.1 {CompileEqualityExpr: just relational expr} {expr 3>=2} 1
 test compExpr-old-8.2 {CompileEqualityExpr: just relational expr} {expr 2<=2.1} 1
 test compExpr-old-8.3 {CompileEqualityExpr: just relational expr} {expr 3.2>"2.2"} 1
 test compExpr-old-8.4 {CompileEqualityExpr: just relational expr} {expr {"0y"<"0x12"}} 0
@@ -361,14 +362,14 @@
 test compExpr-old-10.9 {CompileShiftExpr: error compiling shift arm} -body {
     expr 2<<x
 } -returnCodes error -match glob -result *
 test compExpr-old-10.10 {CompileShiftExpr: runtime error} {
     list [catch {expr {24.0>>43}} msg] $msg
-} {1 {can't use floating-point value "24.0" as operand of ">>"}}
+} {1 {can't use floating-point value as operand of ">>"}}
 test compExpr-old-10.11 {CompileShiftExpr: runtime error} {
     list [catch {expr {"a"<<"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "<<"}}
+} {1 {can't use non-numeric string as operand of "<<"}}
 
 test compExpr-old-11.1 {CompileAddExpr: just multiply expr} {expr 4*-2} -8
 test compExpr-old-11.2 {CompileAddExpr: just multiply expr} {expr 0xff%2} 1
 test compExpr-old-11.3 {CompileAddExpr: just multiply expr} {expr -1/2} -1
 test compExpr-old-11.4 {CompileAddExpr: just multiply expr} {expr 7891%0o123} 6
@@ -383,14 +384,14 @@
 test compExpr-old-11.9 {CompileAddExpr: error compiling add arm} -body {
     expr 2-x
 } -returnCodes error -match glob -result *
 test compExpr-old-11.10 {CompileAddExpr: runtime error} {
     list [catch {expr {24.0+"xx"}} msg] $msg
-} {1 {can't use non-numeric string "xx" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 test compExpr-old-11.11 {CompileAddExpr: runtime error} {
     list [catch {expr {"a"-"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "-"}}
+} {1 {can't use non-numeric string as operand of "-"}}
 test compExpr-old-11.12 {CompileAddExpr: runtime error} {
     list [catch {expr {3/0}} msg] $msg
 } {1 {divide by zero}}
 test compExpr-old-11.13a {CompileAddExpr: runtime error} ieeeFloatingPoint {
     list [catch {expr {2.3/0.0}} msg] $msg
@@ -414,14 +415,14 @@
 test compExpr-old-12.9 {CompileMultiplyExpr: error compiling multiply arm} -body {
     expr 2*x
 } -returnCodes error -match glob -result *
 test compExpr-old-12.10 {CompileMultiplyExpr: runtime error} {
     list [catch {expr {24.0*"xx"}} msg] $msg
-} {1 {can't use non-numeric string "xx" as operand of "*"}}
+} {1 {can't use non-numeric string as operand of "*"}}
 test compExpr-old-12.11 {CompileMultiplyExpr: runtime error} {
     list [catch {expr {"a"/"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "/"}}
+} {1 {can't use non-numeric string as operand of "/"}}
 
 test compExpr-old-13.1 {CompileUnaryExpr: unary exprs} {expr -0xff} -255
 test compExpr-old-13.2 {CompileUnaryExpr: unary exprs} {expr +0o00123} 83
 test compExpr-old-13.3 {CompileUnaryExpr: unary exprs} {expr +--++36} 36
 test compExpr-old-13.4 {CompileUnaryExpr: unary exprs} {expr !2} 0
@@ -435,14 +436,14 @@
     expr !1.x
     set msg
 } -returnCodes error -match glob -result *
 test compExpr-old-13.10 {CompileUnaryExpr: runtime error} {
     list [catch {expr {~"xx"}} msg] $msg
-} {1 {can't use non-numeric string "xx" as operand of "~"}}
+} {1 {can't use non-numeric string as operand of "~"}}
 test compExpr-old-13.11 {CompileUnaryExpr: runtime error} {
     list [catch {expr ~4.0} msg] $msg
-} {1 {can't use floating-point value "4.0" as operand of "~"}}
+} {1 {can't use floating-point value as operand of "~"}}
 test compExpr-old-13.12 {CompileUnaryExpr: just primary expr} {expr 0x123} 291
 test compExpr-old-13.13 {CompileUnaryExpr: just primary expr} {
     set a 27
     expr $a
 } 27
@@ -586,11 +587,10 @@
     while *ing
 "expr pow(1)"}
 test compExpr-old-15.6 {CompileMathFuncCall: missing ')'} -body {
     expr sin(1
 } -returnCodes error -match glob -result *
-
 test compExpr-old-16.1 {GetToken: checks whether integer token starting with "0x" (e.g., "0x$") is invalid} {
     catch {unset a}
     set a(VALUE) ff15
     set i 123
     if {[expr 0x$a(VALUE)] & 16} {

Index: tests/compExpr.test
==================================================================
--- tests/compExpr.test
+++ tests/compExpr.test
@@ -12,10 +12,11 @@
     package require tcltest 2
     namespace import -force ::tcltest::*
 }
 
 ::tcltest::loadTestedCommands
+catch [list package require -exact Tcltest [info patchlevel]]
 
 # Constrain memory leak tests
 testConstraint memory [llength [info commands memory]]
 
 catch {unset a}

Index: tests/compile.test
==================================================================
--- tests/compile.test
+++ tests/compile.test
@@ -321,11 +321,11 @@
 test compile-11.2 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
     apply {{} { set r [list foobar] ; string index a bogus }}
 } -returnCodes error -result {bad index "bogus": must be integer?[+-]integer? or end?[+-]integer?}
 test compile-11.3 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
     apply {{} { set r [list foobar] ; string index a 0o9 }}
-} -returnCodes error -match glob -result {*}
+} -returnCodes error -match glob -result {*invalid octal number*}
 test compile-11.4 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
     apply {{} { set r [list foobar] ; array set var {one two many} }}
 } -returnCodes error -result {list must have an even number of elements}
 test compile-11.5 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
     apply {{} { set r [list foobar] ; incr foo bar baz}}
@@ -463,10 +463,41 @@
     }
     append body {]; puts OK}
     regsub BODY {proc crash {} {BODY}; crash} $body script
     list [catch {exec [interpreter] << $script} msg] $msg
 } {0 OK}
+
+# Tests of nested compile (body in body compilation), should not generate stack overflow
+# (with abnormal program termination), bug [fec0c17d39]:
+test compile-13.2 {TclCompileScript: testing nested scripts compilation} -setup {
+    set i [interp create]
+    interp recursionlimit $i [expr {10000+50}]
+    $i eval {proc gencode {nr {cmd eval} {nl 0}} {
+	set code ""
+	set e ""; if {$nl} {set e "\n"}
+	for {set i 0} {$i < $nr} {incr i} {
+	    append code "$cmd \{$e"
+	}
+	append code "lappend result 1$e"
+	for {set i 0} {$i < $nr} {incr i} {
+	    append code "\}$e"
+	}
+	#puts [format "%% %.40s ... %d bytes" $code [string length $code]]
+	return $code
+    }}
+} -body {
+    # Test different compilation variants (instructions evalStk, invokeStk, etc),
+    # with 2000 (1000 in debug) nested scripts (bodies). If you get SO/SF exceptions on some low-stack
+    # boxes or systems, please don't decrease it (either provide a constraint)
+    $i eval {foreach cmd {eval "if 1" try catch} {
+	set c [gencode [expr {![::tcl::pkgconfig get debug] ? 2000 : 1000}] $cmd]
+	if 1 $c
+    }}
+    $i eval {set result}
+} -result {1 1 1 1} -cleanup {
+    interp delete $i
+}
 
 # Tests compile-14.* for [Bug 599788] [Bug 0c043a175a47da8c2342]
 test compile-14.1 {testing errors in element name; segfault?} {} {
      catch {set a([error])} msg1
      catch {set bubba([join $abba $jubba]) $vol} msg2

Index: tests/encoding.test
==================================================================
--- tests/encoding.test
+++ tests/encoding.test
@@ -320,22 +320,33 @@
     set y [encoding convertfrom utf-8 [encoding convertto utf-8 \u0000]]
     binary scan [teststringbytes $y] H* z
     set z
 } c080
 
-test encoding-16.1 {UnicodeToUtfProc} -body {
-    set val [encoding convertfrom unicode NN]
+test encoding-16.1 {Utf16ToUtfProc} -body {
+    set val [encoding convertfrom utf-16 NN]
+    list $val [format %x [scan $val %c]]
+} -result "\u4e4e 4e4e"
+test encoding-16.2 {Utf16ToUtfProc} -body {
+    set val [encoding convertfrom utf-16 "\xd8\xd8\xdc\xdc"]
+    list $val [format %x [scan $val %c]]
+} -result "\U460dc 460dc"
+test encoding-16.3 {Ucs2ToUtfProc} -body {
+    set val [encoding convertfrom ucs-2 NN]
     list $val [format %x [scan $val %c]]
 } -result "\u4e4e 4e4e"
-test encoding-16.2 {UnicodeToUtfProc} -body {
-    set val [encoding convertfrom unicode "\xd8\xd8\xdc\xdc"]
+test encoding-16.4 {Ucs2ToUtfProc} -body {
+    set val [encoding convertfrom ucs-2 "\xd8\xd8\xdc\xdc"]
     list $val [format %x [scan $val %c]]
 } -result "\U460dc 460dc"
 
-test encoding-17.1 {UtfToUnicodeProc} -body {
-    encoding convertto unicode "\U460dc"
+test encoding-17.1 {UtfToUtf16Proc} -body {
+    encoding convertto utf-16 "\U460dc"
 } -result "\xd8\xd8\xdc\xdc"
+test encoding-17.2 {UtfToUcs2Proc} -body {
+    encoding convertfrom utf-16 [encoding convertto ucs-2 "\U460dc"]
+} -result "\ufffd"
 
 test encoding-18.1 {TableToUtfProc} {
 } {}
 
 test encoding-19.1 {TableFromUtfProc} {

Index: tests/execute.test
==================================================================
--- tests/execute.test
+++ tests/execute.test
@@ -35,10 +35,15 @@
 }]
 
 testConstraint longIs32bit [expr {$tcl_platform(wordSize) == 4}]
 testConstraint testexprlongobj [llength [info commands testexprlongobj]]
 
+
+if {[namespace which -command testbumpinterpepoch] eq ""} {
+  proc testbumpinterpepoch {} { rename ::set ::dummy; rename ::dummy ::set }
+}
+
 # Tests for the omnibus TclExecuteByteCode function:
 
 # INST_DONE not tested
 # INST_PUSH1 not tested
 # INST_PUSH4 not tested
@@ -172,11 +177,11 @@
     expr {$x + 1}
 } 2.0
 test execute-3.6 {TclExecuteByteCode, INST_ADD, op1 is non-numeric} {testobj} {
     set x [teststringobj set 0 foo]
     list [catch {expr {$x + 1}} msg] $msg
-} {1 {can't use non-numeric string "foo" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 test execute-3.7 {TclExecuteByteCode, INST_ADD, op2 is int} {testobj} {
     set x [testintobj set 0 1]
     expr {1 + $x}
 } 2
 test execute-3.8 {TclExecuteByteCode, INST_ADD, op2 is double} {testobj} {
@@ -197,11 +202,11 @@
     expr {1 + $x}
 } 2.0
 test execute-3.12 {TclExecuteByteCode, INST_ADD, op2 is non-numeric} {testobj} {
     set x [teststringobj set 0 foo]
     list [catch {expr {1 + $x}} msg] $msg
-} {1 {can't use non-numeric string "foo" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 
 # INST_SUB is partially tested:
 test execute-3.13 {TclExecuteByteCode, INST_SUB, op1 is int} {testobj} {
     set x [testintobj set 0 1]
     expr {$x - 1}
@@ -224,11 +229,11 @@
     expr {$x - 1}
 } 0.0
 test execute-3.18 {TclExecuteByteCode, INST_SUB, op1 is non-numeric} {testobj} {
     set x [teststringobj set 0 foo]
     list [catch {expr {$x - 1}} msg] $msg
-} {1 {can't use non-numeric string "foo" as operand of "-"}}
+} {1 {can't use non-numeric string as operand of "-"}}
 test execute-3.19 {TclExecuteByteCode, INST_SUB, op2 is int} {testobj} {
     set x [testintobj set 0 1]
     expr {1 - $x}
 } 0
 test execute-3.20 {TclExecuteByteCode, INST_SUB, op2 is double} {testobj} {
@@ -249,11 +254,11 @@
     expr {1 - $x}
 } 0.0
 test execute-3.24 {TclExecuteByteCode, INST_SUB, op2 is non-numeric} {testobj} {
     set x [teststringobj set 0 foo]
     list [catch {expr {1 - $x}} msg] $msg
-} {1 {can't use non-numeric string "foo" as operand of "-"}}
+} {1 {can't use non-numeric string as operand of "-"}}
 
 # INST_MULT is partially tested:
 test execute-3.25 {TclExecuteByteCode, INST_MULT, op1 is int} {testobj} {
     set x [testintobj set 1 1]
     expr {$x * 1}
@@ -276,11 +281,11 @@
     expr {$x * 1}
 } 1.0
 test execute-3.30 {TclExecuteByteCode, INST_MULT, op1 is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {$x * 1}} msg] $msg
-} {1 {can't use non-numeric string "foo" as operand of "*"}}
+} {1 {can't use non-numeric string as operand of "*"}}
 test execute-3.31 {TclExecuteByteCode, INST_MULT, op2 is int} {testobj} {
     set x [testintobj set 1 1]
     expr {1 * $x}
 } 1
 test execute-3.32 {TclExecuteByteCode, INST_MULT, op2 is double} {testobj} {
@@ -301,11 +306,11 @@
     expr {1 * $x}
 } 1.0
 test execute-3.36 {TclExecuteByteCode, INST_MULT, op2 is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {1 * $x}} msg] $msg
-} {1 {can't use non-numeric string "foo" as operand of "*"}}
+} {1 {can't use non-numeric string as operand of "*"}}
 
 # INST_DIV is partially tested:
 test execute-3.37 {TclExecuteByteCode, INST_DIV, op1 is int} {testobj} {
     set x [testintobj set 1 1]
     expr {$x / 1}
@@ -328,11 +333,11 @@
     expr {$x / 1}
 } 1.0
 test execute-3.42 {TclExecuteByteCode, INST_DIV, op1 is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {$x / 1}} msg] $msg
-} {1 {can't use non-numeric string "foo" as operand of "/"}}
+} {1 {can't use non-numeric string as operand of "/"}}
 test execute-3.43 {TclExecuteByteCode, INST_DIV, op2 is int} {testobj} {
     set x [testintobj set 1 1]
     expr {2 / $x}
 } 2
 test execute-3.44 {TclExecuteByteCode, INST_DIV, op2 is double} {testobj} {
@@ -353,11 +358,11 @@
     expr {2 / $x}
 } 2.0
 test execute-3.48 {TclExecuteByteCode, INST_DIV, op2 is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {1 / $x}} msg] $msg
-} {1 {can't use non-numeric string "foo" as operand of "/"}}
+} {1 {can't use non-numeric string as operand of "/"}}
 
 # INST_UPLUS is partially tested:
 test execute-3.49 {TclExecuteByteCode, INST_UPLUS, op is int} {testobj} {
     set x [testintobj set 1 1]
     expr {+ $x}
@@ -380,11 +385,11 @@
     expr {+ $x}
 } 1.0
 test execute-3.54 {TclExecuteByteCode, INST_UPLUS, op is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {+ $x}} msg] $msg
-} {1 {can't use non-numeric string "foo" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 
 # INST_UMINUS is partially tested:
 test execute-3.55 {TclExecuteByteCode, INST_UMINUS, op is int} {testobj} {
     set x [testintobj set 1 1]
     expr {- $x}
@@ -407,11 +412,11 @@
     expr {- $x}
 } -1.0
 test execute-3.60 {TclExecuteByteCode, INST_UMINUS, op is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {- $x}} msg] $msg
-} {1 {can't use non-numeric string "foo" as operand of "-"}}
+} {1 {can't use non-numeric string as operand of "-"}}
 
 # INST_LNOT is partially tested:
 test execute-3.61 {TclExecuteByteCode, INST_LNOT, op is int} {testobj} {
     set x [testintobj set 1 2]
     expr {! $x}
@@ -455,11 +460,15 @@
     expr {! $x}
 } 1
 test execute-3.71 {TclExecuteByteCode, INST_LNOT, op is non-numeric} {testobj} {
     set x [teststringobj set 1 foo]
     list [catch {expr {! $x}} msg] $msg
-} {1 {can't use non-numeric string "foo" as operand of "!"}}
+} {1 {can't use non-numeric string as operand of "!"}}
+
+# INST_BITNOT not tested
+# INST_CALL_BUILTIN_FUNC1 not tested
+# INST_CALL_FUNC1 not tested
 
 # INST_TRY_CVT_TO_NUMERIC is partially tested:
 test execute-3.72 {TclExecuteByteCode, INST_TRY_CVT_TO_NUMERIC, op is int} {testobj} {
     set x [testintobj set 1 1]
     expr {$x}
@@ -927,12 +936,11 @@
     # evaluation
     set arglst [string repeat "a " 1000]
     proc f {args} "f $arglst"
     proc run {} {
 	# bump the interp's epoch
-	rename ::set ::dummy
-	rename ::dummy ::set
+	testbumpinterpepoch
 	catch f msg
 	set msg
     }
     run
 } -cleanup {
@@ -942,12 +950,11 @@
     proc foo {} {
 	error bar
     }
     proc FOO {} {
 	catch {error bar} m o
-	rename ::set ::dummy
-	rename ::dummy ::set
+	testbumpinterpepoch
 	return -options $o $m
     }
 } -body {
     catch foo m o
     set stack1 [dict get $o -errorinfo]
@@ -971,10 +978,80 @@
 } -match glob -result {-code 1 -level 0 -errorstack * -errorcode NONE -errorinfo {FOO
     while executing
 "error FOO"
     invoked from within
 "catch \[list error FOO\] m o"} -errorline 2}
+
+test execute-8.6 {Compile epoch bump in global level (bug [fa6bf38d07])} -setup {
+    interp create slave
+    slave eval {
+	package require tcltest
+	catch [list package require -exact Tcltest [info patchlevel]]
+	::tcltest::loadTestedCommands
+	if {[namespace which -command testbumpinterpepoch] eq ""} {
+	  proc testbumpinterpepoch {} { rename ::set ::dummy; rename ::dummy ::set }
+	}
+    }
+} -body {
+    slave eval {
+	lappend res A; testbumpinterpepoch; lappend res B; return; lappend res C;
+    }
+    slave eval {
+	set i 0; while {[incr i] < 3} {
+	    lappend res A; testbumpinterpepoch; lappend res B; return; lappend res C;
+	}
+    }
+    slave eval {
+	set i 0; while {[incr i] < 3} {
+	    lappend res A; testbumpinterpepoch; lappend res B; break; lappend res C;
+	}
+    }
+    slave eval {
+	catch {
+	    lappend res A; testbumpinterpepoch; lappend res B; error test; lappend res C;
+	}
+    }
+    slave eval {set res}
+} -cleanup {
+    interp delete slave
+} -result [lrepeat 4 A B]
+test execute-8.7 {Compile epoch bump in global level (bug [fa6bf38d07]), exception case} -setup {
+    interp create slave
+    slave eval {
+	package require tcltest
+	catch [list package require -exact Tcltest [info patchlevel]]
+	::tcltest::loadTestedCommands
+	if {[namespace which -command testbumpinterpepoch] eq ""} {
+	  proc testbumpinterpepoch {} { rename ::set ::dummy; rename ::dummy ::set }
+	}
+    }
+} -body {
+    set res {}
+    lappend res [catch {
+	slave eval {
+	   lappend res A; testbumpinterpepoch; lappend res B; return -code error test; lappend res C;
+	}
+    } e] $e
+    lappend res [catch {
+	slave eval {
+	   lappend res A; testbumpinterpepoch; lappend res B; error test; lappend res C;
+	}
+    } e] $e
+    lappend res [catch {
+	slave eval {
+	   lappend res A; testbumpinterpepoch; lappend res B; return -code return test; lappend res C;
+	}
+    } e] $e
+    lappend res [catch {
+	slave eval {
+	   lappend res A; testbumpinterpepoch; lappend res B; break; lappend res C;
+	}
+    } e] $e
+    list $res [slave eval {set res}]
+} -cleanup {
+    interp delete slave
+} -result [list {1 test 1 test 2 test 3 {}} [lrepeat 4 A B]]
 
 test execute-9.1 {Interp result resetting [Bug 1522803]} {
     set c 0
     catch {
 	catch {set foo}

Index: tests/expr-old.test
==================================================================
--- tests/expr-old.test
+++ tests/expr-old.test
@@ -190,38 +190,38 @@
 
 # Operators that aren't legal on floating-point numbers
 
 test expr-old-3.1 {illegal floating-point operations} {
     list [catch {expr ~4.0} msg] $msg
-} {1 {can't use floating-point value "4.0" as operand of "~"}}
+} {1 {can't use floating-point value as operand of "~"}}
 test expr-old-3.2 {illegal floating-point operations} {
     list [catch {expr 27%4.0} msg] $msg
-} {1 {can't use floating-point value "4.0" as operand of "%"}}
+} {1 {can't use floating-point value as operand of "%"}}
 test expr-old-3.3 {illegal floating-point operations} {
     list [catch {expr 27.0%4} msg] $msg
-} {1 {can't use floating-point value "27.0" as operand of "%"}}
+} {1 {can't use floating-point value as operand of "%"}}
 test expr-old-3.4 {illegal floating-point operations} {
     list [catch {expr 1.0<<3} msg] $msg
-} {1 {can't use floating-point value "1.0" as operand of "<<"}}
+} {1 {can't use floating-point value as operand of "<<"}}
 test expr-old-3.5 {illegal floating-point operations} {
     list [catch {expr 3<<1.0} msg] $msg
-} {1 {can't use floating-point value "1.0" as operand of "<<"}}
+} {1 {can't use floating-point value as operand of "<<"}}
 test expr-old-3.6 {illegal floating-point operations} {
     list [catch {expr 24.0>>3} msg] $msg
-} {1 {can't use floating-point value "24.0" as operand of ">>"}}
+} {1 {can't use floating-point value as operand of ">>"}}
 test expr-old-3.7 {illegal floating-point operations} {
     list [catch {expr 24>>3.0} msg] $msg
-} {1 {can't use floating-point value "3.0" as operand of ">>"}}
+} {1 {can't use floating-point value as operand of ">>"}}
 test expr-old-3.8 {illegal floating-point operations} {
     list [catch {expr 24&3.0} msg] $msg
-} {1 {can't use floating-point value "3.0" as operand of "&"}}
+} {1 {can't use floating-point value as operand of "&"}}
 test expr-old-3.9 {illegal floating-point operations} {
     list [catch {expr 24.0|3} msg] $msg
-} {1 {can't use floating-point value "24.0" as operand of "|"}}
+} {1 {can't use floating-point value as operand of "|"}}
 test expr-old-3.10 {illegal floating-point operations} {
     list [catch {expr 24.0^3} msg] $msg
-} {1 {can't use floating-point value "24.0" as operand of "^"}}
+} {1 {can't use floating-point value as operand of "^"}}
 
 # Check the string operators individually.
 
 test expr-old-4.1 {string operators} {expr {"abc" > "def"}} 0
 test expr-old-4.2 {string operators} {expr {"def" > "def"}} 0
@@ -258,50 +258,50 @@
 
 # Operators that aren't legal on string operands.
 
 test expr-old-5.1 {illegal string operations} {
     list [catch {expr {-"a"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "-"}}
+} {1 {can't use non-numeric string as operand of "-"}}
 test expr-old-5.2 {illegal string operations} {
     list [catch {expr {+"a"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 test expr-old-5.3 {illegal string operations} {
     list [catch {expr {~"a"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "~"}}
+} {1 {can't use non-numeric string as operand of "~"}}
 test expr-old-5.4 {illegal string operations} {
     list [catch {expr {!"a"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "!"}}
+} {1 {can't use non-numeric string as operand of "!"}}
 test expr-old-5.5 {illegal string operations} {
     list [catch {expr {"a"*"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "*"}}
+} {1 {can't use non-numeric string as operand of "*"}}
 test expr-old-5.6 {illegal string operations} {
     list [catch {expr {"a"/"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "/"}}
+} {1 {can't use non-numeric string as operand of "/"}}
 test expr-old-5.7 {illegal string operations} {
     list [catch {expr {"a"%"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "%"}}
+} {1 {can't use non-numeric string as operand of "%"}}
 test expr-old-5.8 {illegal string operations} {
     list [catch {expr {"a"+"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 test expr-old-5.9 {illegal string operations} {
     list [catch {expr {"a"-"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "-"}}
+} {1 {can't use non-numeric string as operand of "-"}}
 test expr-old-5.10 {illegal string operations} {
     list [catch {expr {"a"<<"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "<<"}}
+} {1 {can't use non-numeric string as operand of "<<"}}
 test expr-old-5.11 {illegal string operations} {
     list [catch {expr {"a">>"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of ">>"}}
+} {1 {can't use non-numeric string as operand of ">>"}}
 test expr-old-5.12 {illegal string operations} {
     list [catch {expr {"a"&"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "&"}}
+} {1 {can't use non-numeric string as operand of "&"}}
 test expr-old-5.13 {illegal string operations} {
     list [catch {expr {"a"^"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "^"}}
+} {1 {can't use non-numeric string as operand of "^"}}
 test expr-old-5.14 {illegal string operations} {
     list [catch {expr {"a"|"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "|"}}
+} {1 {can't use non-numeric string as operand of "|"}}
 test expr-old-5.15 {illegal string operations} {
     list [catch {expr {"a"&&"b"}} msg] $msg
 } {1 {expected boolean value but got "a"}}
 test expr-old-5.16 {illegal string operations} {
     list [catch {expr {"a"||"b"}} msg] $msg
@@ -486,11 +486,11 @@
 
 # Various error conditions.
 
 test expr-old-26.1 {error conditions} {
     list [catch {expr 2+"a"} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 test expr-old-26.2 {error conditions} -body {
     expr 2+4*
 } -returnCodes error -match glob -result *
 test expr-old-26.3 {error conditions} -body {
     expr 2+4*(
@@ -500,14 +500,14 @@
     list [catch {expr 2+$_non_existent_} msg] $msg
 } {1 {can't read "_non_existent_": no such variable}}
 set a xx
 test expr-old-26.5 {error conditions} {
     list [catch {expr {2+$a}} msg] $msg
-} {1 {can't use non-numeric string "xx" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 test expr-old-26.6 {error conditions} {
     list [catch {expr {2+[set a]}} msg] $msg
-} {1 {can't use non-numeric string "xx" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 test expr-old-26.7 {error conditions} -body {
     expr {2+(4}
 } -returnCodes error -match glob -result *
 test expr-old-26.8 {error conditions} {
     list [catch {expr 2/0} msg] $msg $errorCode
@@ -527,11 +527,11 @@
 test expr-old-26.12 {error conditions} -body {
     expr a.b
 } -returnCodes error -match glob -result *
 test expr-old-26.13 {error conditions} {
     list [catch {expr {"a"/"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "/"}}
+} {1 {can't use non-numeric string as operand of "/"}}
 test expr-old-26.14 {error conditions} -body {
     expr 2:3
 } -returnCodes error -match glob -result *
 test expr-old-26.15 {error conditions} -body {
     expr a@b
@@ -939,18 +939,17 @@
     expr round(1.0e30)
 } 1000000000000000019884624838656
 test expr-old-34.16 {errors in math functions} {
     expr round(-1.0e30)
 } -1000000000000000019884624838656
-
 test expr-old-36.1 {ExprLooksLikeInt procedure} -body {
     expr 0o289
 } -returnCodes error -match glob -result {*invalid octal number*}
 test expr-old-36.2 {ExprLooksLikeInt procedure} {
     set x 0o289
     list [catch {expr {$x+1}} msg] $msg
-} {1 {can't use non-numeric string "0o289" as operand of "+"}}
+} {1 {can't use invalid octal number as operand of "+"}}
 test expr-old-36.3 {ExprLooksLikeInt procedure} {
     list [catch {expr 0289.1} msg] $msg
 } {0 289.1}
 test expr-old-36.4 {ExprLooksLikeInt procedure} {
     set x 0289.1
@@ -986,23 +985,23 @@
 
 # tests for [Bug #587140]
 test expr-old-36.12 {ExprLooksLikeInt procedure} {
     set x "10;"
     list [catch {expr {$x+1}} msg] $msg
-} {1 {can't use non-numeric string "10;" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 test expr-old-36.13 {ExprLooksLikeInt procedure} {
     set x " +"
     list [catch {expr {$x+1}} msg] $msg
-} {1 {can't use non-numeric string " +" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 test expr-old-36.14 {ExprLooksLikeInt procedure} {
     set x "123456789012345678901234567890 "
     expr {$x+1}
 } 123456789012345678901234567891
 test expr-old-36.15 {ExprLooksLikeInt procedure} {
     set x "0o99 "
     list [catch {expr {$x+1}} msg] $msg
-} {1 {can't use non-numeric string "0o99 " as operand of "+"}}
+} {1 {can't use invalid octal number as operand of "+"}}
 test expr-old-36.16 {ExprLooksLikeInt procedure} {
     set x " 0xffffffffffffffffffffffffffffffffffffff  "
     expr {$x+1}
 } [expr 0x100000000000000000000000000000000000000]
 

Index: tests/expr.test
==================================================================
--- tests/expr.test
+++ tests/expr.test
@@ -14,10 +14,11 @@
     package require tcltest 2.1
     namespace import -force ::tcltest::*
 }
 
 ::tcltest::loadTestedCommands
+catch [list package require -exact Tcltest [info patchlevel]]
 
 # Determine if "long int" type is a 32 bit number and if the wide
 # type is a 64 bit number on this machine.
 
 testConstraint longIs32bit [expr {$tcl_platform(wordSize) == 4}]
@@ -249,11 +250,11 @@
     set i 7
     expr {[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]] || [string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]] || [string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]] || [string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]&&[string compare [format %c $i] [string index $a $i]]}
 } 1
 test expr-4.10 {CompileLorExpr: error compiling ! operand} {
     list [catch {expr {!"a"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "!"}}
+} {1 {can't use non-numeric string as operand of "!"}}
 test expr-4.11 {CompileLorExpr: error compiling land arms} {
     list [catch {expr {"a"||0}} msg] $msg
 } {1 {expected boolean value but got "a"}}
 test expr-4.12 {CompileLorExpr: error compiling land arms} {
     list [catch {expr {0||"a"}} msg] $msg
@@ -296,14 +297,14 @@
 test expr-6.8 {CompileBitXorExpr: error compiling bitxor arm} -body {
     expr 2^x
 } -returnCodes error -match glob -result *
 test expr-6.9 {CompileBitXorExpr: runtime error in bitxor arm} {
     list [catch {expr {24.0^3}} msg] $msg
-} {1 {can't use floating-point value "24.0" as operand of "^"}}
+} {1 {can't use floating-point value as operand of "^"}}
 test expr-6.10 {CompileBitXorExpr: runtime error in bitxor arm} {
     list [catch {expr {"a"^"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "^"}}
+} {1 {can't use non-numeric string as operand of "^"}}
 
 test expr-7.1 {CompileBitAndExpr: just equality expr} {expr 3==2} 0
 test expr-7.2 {CompileBitAndExpr: just equality expr} {expr 2.0==2} 1
 test expr-7.3 {CompileBitAndExpr: just equality expr} {expr 3.2!=2.2} 1
 test expr-7.4 {CompileBitAndExpr: just equality expr} {expr {"abc" == "abd"}} 0
@@ -320,14 +321,14 @@
 test expr-7.11 {CompileBitAndExpr: error compiling bitand arm} -body {
     expr 2&x
 } -returnCodes error -match glob -result *
 test expr-7.12 {CompileBitAndExpr: runtime error in bitand arm} {
     list [catch {expr {24.0&3}} msg] $msg
-} {1 {can't use floating-point value "24.0" as operand of "&"}}
+} {1 {can't use floating-point value as operand of "&"}}
 test expr-7.13 {CompileBitAndExpr: runtime error in bitand arm} {
     list [catch {expr {"a"&"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "&"}}
+} {1 {can't use non-numeric string as operand of "&"}}
 test expr-7.14 {CompileBitAndExpr: equality expr} {expr 3eq2} 0
 test expr-7.18 {CompileBitAndExpr: equality expr} {expr {"abc" eq "abd"}} 0
 test expr-7.20 {CompileBitAndExpr: error in equality expr} -body {
     expr xne3
 } -returnCodes error -match glob -result *
@@ -465,14 +466,14 @@
 test expr-10.9 {CompileShiftExpr: error compiling shift arm} -body {
     expr 2<<x
 } -returnCodes error -match glob -result *
 test expr-10.10 {CompileShiftExpr: runtime error} {
     list [catch {expr {24.0>>43}} msg] $msg
-} {1 {can't use floating-point value "24.0" as operand of ">>"}}
+} {1 {can't use floating-point value as operand of ">>"}}
 test expr-10.11 {CompileShiftExpr: runtime error} {
     list [catch {expr {"a"<<"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "<<"}}
+} {1 {can't use non-numeric string as operand of "<<"}}
 
 test expr-11.1 {CompileAddExpr: just multiply expr} {expr 4*-2} -8
 test expr-11.2 {CompileAddExpr: just multiply expr} {expr 0xff%2} 1
 test expr-11.3 {CompileAddExpr: just multiply expr} {expr -1/2} -1
 test expr-11.4 {CompileAddExpr: just multiply expr} {expr 7891%0o123} 6
@@ -487,14 +488,14 @@
 test expr-11.9 {CompileAddExpr: error compiling add arm} -body {
     expr 2-x
 } -returnCodes error -match glob -result *
 test expr-11.10 {CompileAddExpr: runtime error} {
     list [catch {expr {24.0+"xx"}} msg] $msg
-} {1 {can't use non-numeric string "xx" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 test expr-11.11 {CompileAddExpr: runtime error} {
     list [catch {expr {"a"-"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "-"}}
+} {1 {can't use non-numeric string as operand of "-"}}
 test expr-11.12 {CompileAddExpr: runtime error} {
     list [catch {expr {3/0}} msg] $msg
 } {1 {divide by zero}}
 test expr-11.13a {CompileAddExpr: runtime error} !ieeeFloatingPoint {
     list [catch {expr {2.3/0.0}} msg] $msg
@@ -518,14 +519,14 @@
 test expr-12.9 {CompileMultiplyExpr: error compiling multiply arm} -body {
     expr 2*x
 } -returnCodes error -match glob -result *
 test expr-12.10 {CompileMultiplyExpr: runtime error} {
     list [catch {expr {24.0*"xx"}} msg] $msg
-} {1 {can't use non-numeric string "xx" as operand of "*"}}
+} {1 {can't use non-numeric string as operand of "*"}}
 test expr-12.11 {CompileMultiplyExpr: runtime error} {
     list [catch {expr {"a"/"b"}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "/"}}
+} {1 {can't use non-numeric string as operand of "/"}}
 
 test expr-13.1 {CompileUnaryExpr: unary exprs} {expr -0xff} -255
 test expr-13.2 {CompileUnaryExpr: unary exprs} {expr +0o00123} 83
 test expr-13.3 {CompileUnaryExpr: unary exprs} {expr +--++36} 36
 test expr-13.4 {CompileUnaryExpr: unary exprs} {expr !2} 0
@@ -538,14 +539,14 @@
 test expr-13.9 {CompileUnaryExpr: error compiling unary expr} -body {
     expr !1.x
 } -returnCodes error -match glob -result *
 test expr-13.10 {CompileUnaryExpr: runtime error} {
     list [catch {expr {~"xx"}} msg] $msg
-} {1 {can't use non-numeric string "xx" as operand of "~"}}
+} {1 {can't use non-numeric string as operand of "~"}}
 test expr-13.11 {CompileUnaryExpr: runtime error} {
     list [catch {expr ~4.0} msg] $msg
-} {1 {can't use floating-point value "4.0" as operand of "~"}}
+} {1 {can't use floating-point value as operand of "~"}}
 test expr-13.12 {CompileUnaryExpr: just primary expr} {expr 0x123} 291
 test expr-13.13 {CompileUnaryExpr: just primary expr} {
     set a 27
     expr $a
 } 27
@@ -726,11 +727,11 @@
 test expr-18.1 {expr and conversion of operands to numbers} {
     set x [lindex 11 0]
     catch {expr int($x)}
     expr {$x}
 } 11
-test expr-18.2 {whitespace strings should not be == 0 (buggy strtod)} {
+test expr-18.2 {whitespace strings should not be == 0 (buggy strtol/strtoul)} {
     expr {" "}
 } { }
 
 # Check "expr" and interpreter result object resetting before appending
 # an error msg during evaluation of exprs not in {}s
@@ -818,19 +819,19 @@
 test expr-21.13 {non-numeric boolean literals} -body {
     expr !truef
 } -returnCodes error -match glob -result *
 test expr-21.14 {non-numeric boolean literals} {
     list [catch {expr !"truef"} err] $err
-} {1 {can't use non-numeric string "truef" as operand of "!"}}
+} {1 {can't use non-numeric string as operand of "!"}}
 test expr-21.15 {non-numeric boolean variables} {
     set v truef
     list [catch {expr {!$v}} err] $err
-} {1 {can't use non-numeric string "truef" as operand of "!"}}
+} {1 {can't use non-numeric string as operand of "!"}}
 test expr-21.16 {non-numeric boolean variables} {
     set v "true "
     list [catch {expr {!$v}} err] $err
-} {1 {can't use non-numeric string "true " as operand of "!"}}
+} {1 {can't use non-numeric string as operand of "!"}}
 test expr-21.17 {non-numeric boolean variables} {
     set v "tru"
     list [catch {expr {!$v}} err] $err
 } {0 0}
 test expr-21.18 {non-numeric boolean variables} {
@@ -846,27 +847,27 @@
     list [catch {expr {!$v}} err] $err
 } {0 1}
 test expr-21.21 {non-numeric boolean variables} {
     set v "o"
     list [catch {expr {!$v}} err] $err
-} {1 {can't use non-numeric string "o" as operand of "!"}}
+} {1 {can't use non-numeric string as operand of "!"}}
 test expr-21.22 {non-numeric boolean variables} {
     set v ""
     list [catch {expr {!$v}} err] $err
-} {1 {can't use non-numeric string "" as operand of "!"}}
+} {1 {can't use empty string as operand of "!"}}
 
 # Test for non-numeric float handling.
 test expr-22.1 {non-numeric floats} {
     list [catch {expr {NaN + 1}} msg] $msg
-} {1 {can't use non-numeric floating-point value "NaN" as operand of "+"}}
+} {1 {can't use non-numeric floating-point value as operand of "+"}}
 test expr-22.2 {non-numeric floats} !ieeeFloatingPoint {
     list [catch {expr {Inf + 1}} msg] $msg
 } {1 {can't use infinite floating-point value as operand of "+"}}
 test expr-22.3 {non-numeric floats} {
     set nan NaN
     list [catch {expr {$nan + 1}} msg] $msg
-} {1 {can't use non-numeric floating-point value "NaN" as operand of "+"}}
+} {1 {can't use non-numeric floating-point value as operand of "+"}}
 test expr-22.4 {non-numeric floats} !ieeeFloatingPoint {
     set inf Inf
     list [catch {expr {$inf + 1}} msg] $msg
 } {1 {can't use infinite floating-point value as operand of "+"}}
 test expr-22.5 {non-numeric floats} {
@@ -875,11 +876,11 @@
 test expr-22.6 {non-numeric floats} !ieeeFloatingPoint {
     list [catch {expr Inf} msg] $msg
 } {1 {floating-point value too large to represent}}
 test expr-22.7 {non-numeric floats} {
     list [catch {expr {1 / NaN}} msg] $msg
-} {1 {can't use non-numeric floating-point value "NaN" as operand of "/"}}
+} {1 {can't use non-numeric floating-point value as operand of "/"}}
 test expr-22.8 {non-numeric floats} !ieeeFloatingPoint {
     list [catch {expr {1 / Inf}} msg] $msg
 } {1 {can't use infinite floating-point value as operand of "/"}}
 # Make sure [Bug 761471] stays fixed.
 test expr-22.9 {non-numeric floats: shared object equality and NaN} {
@@ -911,14 +912,14 @@
 test expr-23.8 {CompileExponentialExpr: error compiling expo arm} -body {
     expr 2**x
 } -returnCodes error -match glob -result *
 test expr-23.9 {CompileExponentialExpr: runtime error} {
     list [catch {expr {24.0**"xx"}} msg] $msg
-} {1 {can't use non-numeric string "xx" as operand of "**"}}
+} {1 {can't use non-numeric string as operand of "**"}}
 test expr-23.10 {CompileExponentialExpr: runtime error} {
     list [catch {expr {"a"**2}} msg] $msg
-} {1 {can't use non-numeric string "a" as operand of "**"}}
+} {1 {can't use non-numeric string as operand of "**"}}
 test expr-23.11 {CompileExponentialExpr: runtime error} {
     list [catch {expr {0**-1}} msg] $msg
 } {1 {exponentiation of zero by negative power}}
 test expr-23.12 {CompileExponentialExpr: runtime error} {
     list [catch {expr {0.0**-1.0}} msg] $msg

Index: tests/fileSystem.test
==================================================================
--- tests/fileSystem.test
+++ tests/fileSystem.test
@@ -32,10 +32,11 @@
 
 # Test for commands defined in Tcltest executable
 testConstraint testfilesystem  	    [llength [info commands ::testfilesystem]]
 testConstraint testsetplatform 	    [llength [info commands ::testsetplatform]]
 testConstraint testsimplefilesystem [llength [info commands ::testsimplefilesystem]]
+testConstraint knownMsvcBug [expr {![info exists ::env(TRAVIS_OS_NAME)] || ![string match windows $::env(TRAVIS_OS_NAME)]}]
 
 cd [tcltest::temporaryDirectory]
 makeFile "test file" gorp.file
 makeDirectory dir.dir
 makeDirectory [file join dir.dir dirinside.dir]
@@ -310,11 +311,11 @@
     set fname "/abc/./def/./ghi/./asda/.././.././asd/x/../../../../....."
     file norm $fname
 } -match regexp -result {^(?:[^/]|/(?:[^/]|$))+$}
 test filesystem-1.38 {file normalisation with volume relative} -setup {
     set dir [pwd]
-} -constraints {win moreThanOneDrive} -body {
+} -constraints {win moreThanOneDrive knownMsvcBug} -body {
     set path "[string range [lindex $drives 0] 0 1]foo"
     cd [lindex $drives 1]
     file norm $path
 } -cleanup {
     cd $dir

Index: tests/format.test
==================================================================
--- tests/format.test
+++ tests/format.test
@@ -18,10 +18,11 @@
 # %u output depends on word length, so this test is not portable.
 testConstraint longIs32bit [expr {$tcl_platform(wordSize) == 4}]
 testConstraint longIs64bit [expr {$tcl_platform(wordSize) == 8}]
 testConstraint wideIs64bit [expr {wide(0x8000000000000000) < 0}]
 testConstraint pointerIs64bit [expr {$tcl_platform(pointerSize) >= 8}]
+testConstraint knownMsvcBug [expr {![info exists ::env(TRAVIS_OS_NAME)] || ![string match windows $::env(TRAVIS_OS_NAME)]}]
 
 test format-1.1 {integer formatting} {
     format "%*d %d %d %d" 6 34 16923 -12 -1
 } {    34 16923 -12 -1}
 test format-1.2 {integer formatting} {
@@ -77,17 +78,17 @@
 test format-1.12 {integer formatting} {
     format "%b %#b %#b %llb" 5 0 5 [expr {2**100}]
 } {101 0 0b101 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000}
 test format-1.13 {integer formatting} {
     format "%#0d %#0d %#0d %#0d %#0d" 0 6 34 16923 -12 -1
-} {0 6 34 16923 -12}
+} {0 0d6 0d34 0d16923 -0d12}
 test format-1.14 {integer formatting} {
     format "%#05d %#020d %#020d %#020d %#020d" 0 6 34 16923 -12 -1
-} {00000 00000000000000000006 00000000000000000034 00000000000000016923 -0000000000000000012}
+} {00000 0d000000000000000006 0d000000000000000034 0d000000000000016923 -0d00000000000000012}
 test format-1.15 {integer formatting} {
     format "%-#05d %-#020d %-#020d %-#020d %-#020d" 0 6 34 16923 -12 -1
-} {00000 00000000000000000006 00000000000000000034 00000000000000016923 -0000000000000000012}
+} {00000 0d000000000000000006 0d000000000000000034 0d000000000000016923 -0d00000000000000012}
 
 
 test format-2.1 {string formatting} {
     format "%s %s %c %s" abcd {This is a very long test string.} 120 x
 } {abcd This is a very long test string. x x}
@@ -261,17 +262,17 @@
     format "%e %f %g" 0.0 0.0 0.0 0.0
 } {0.000000e+00 0.000000 0}
 test format-6.2 {floating-point zeroes} {eformat} {
     format "%.4e %.4f %.4g" 0.0 0.0 0.0 0.0
 } {0.0000e+00 0.0000 0}
-test format-6.3 {floating-point zeroes} {eformat} {
+test format-6.3 {floating-point zeroes} {eformat knownMsvcBug} {
     format "%#.4e %#.4f %#.4g" 0.0 0.0 0.0 0.0
 } {0.0000e+00 0.0000 0.000}
 test format-6.4 {floating-point zeroes} {eformat} {
     format "%.0e %.0f %.0g" 0.0 0.0 0.0 0.0
 } {0e+00 0 0}
-test format-6.5 {floating-point zeroes} {eformat} {
+test format-6.5 {floating-point zeroes} {eformat knownMsvcBug} {
     format "%#.0e %#.0f %#.0g" 0.0 0.0 0.0 0.0
 } {0.e+00 0. 0.}
 test format-6.6 {floating-point zeroes} {
     format "%3.0f %3.0f %3.0f %3.0f" 0.0 0.0 0.0 0.0
 } {  0   0   0   0}

Index: tests/get.test
==================================================================
--- tests/get.test
+++ tests/get.test
@@ -96,21 +96,21 @@
     }
     set result
 } {0 1 0 1 1 {expected floating-point number but got "++1.0"} 1 {expected floating-point number but got "+-1.0"} 1 {expected floating-point number but got "-+1.0"} 0 -1 1 {expected floating-point number but got "--1.0"} 1 {expected floating-point number but got "- +1.0"}}
 # Bug 7114ac6141
 test get-3.3 {tcl_GetInt with iffy numbers} testgetint {
-    lmap x {0 " 0" "0 " " 0 " " 0xa " " 010 " " 0o10 " " 0b10 "} {
+    lmap x {0 " 0" "0 " " 0 " " 0xa " " 007 " " 0o10 " " 0b10 "} {
 	catch {testgetint 44 $x} x
 	set x
     }
-} {44 44 44 44 54 54 52 46}
+} {44 44 44 44 54 51 52 46}
 test get-3.4 {Tcl_GetDouble with iffy numbers} testdoubleobj {
-    lmap x {0 0.0 " .0" ".0 " " 0e0 " "09" "- 0" "-0" "0o12" "0b10"} {
+    lmap x {0 0.0 " .0" ".0 " " 0e0 " "07" "- 0" "-0" "0o12" "0b10"} {
 	catch {testdoubleobj set 1 $x} x
 	set x
     }
-} {0.0 0.0 0.0 0.0 0.0 9.0 {expected floating-point number but got "- 0"} 0.0 10.0 2.0}
+} {0.0 0.0 0.0 0.0 0.0 7.0 {expected floating-point number but got "- 0"} 0.0 10.0 2.0}
 
 # cleanup
 ::tcltest::cleanupTests
 return
 

Index: tests/http.test
==================================================================
--- tests/http.test
+++ tests/http.test
@@ -184,11 +184,11 @@
 } -result "<html><head><title>HTTP/1.0 TEST</title></head><body>
 <h1>Hello, World!</h1>
 <h2>GET $tail</h2>
 </body></html>"
 test http-3.8 {http::geturl} -body {
-    set token [http::geturl $url -query Name=Value&Foo=Bar -timeout 2000]
+    set token [http::geturl $url -query Name=Value&Foo=Bar -timeout 3000]
     http::data $token
 } -cleanup {
     http::cleanup $token
 } -result "<html><head><title>HTTP/1.0 TEST</title></head><body>
 <h1>Hello, World!</h1>
@@ -350,21 +350,21 @@
     http::geturl http://somewhere/path?%query
 } -returnCodes error -result {Illegal encoding character usage "%qu" in URL path}
 test http-3.25 {http::meta} -setup {
     unset -nocomplain m token
 } -body {
-    set token [http::geturl $url -timeout 2000]
+    set token [http::geturl $url -timeout 3000]
     array set m [http::meta $token]
     lsort [array names m]
 } -cleanup {
     http::cleanup $token
     unset -nocomplain m token
 } -result {Content-Length Content-Type Date}
 test http-3.26 {http::meta} -setup {
     unset -nocomplain m token
 } -body {
-    set token [http::geturl $url -headers {X-Check 1} -timeout 2000]
+    set token [http::geturl $url -headers {X-Check 1} -timeout 3000]
     array set m [http::meta $token]
     lsort [array names m]
 } -cleanup {
     http::cleanup $token
     unset -nocomplain m token
@@ -586,11 +586,11 @@
 } -result {connect failed connection refused}
 # Bogus host
 test http-4.15 {http::Event} -body {
     # This test may fail if you use a proxy server. That is to be
     # expected and is not a problem with Tcl.
-    set token [http::geturl //not_a_host.tcl.tk -timeout 1000 -command \#]
+    set token [http::geturl //not_a_host.tcl.tk -timeout 3000 -command \#]
     http::wait $token
     http::status $token
     # error codes vary among platforms.
 } -cleanup {
     catch {http::cleanup $token}

Index: tests/io.test
==================================================================
--- tests/io.test
+++ tests/io.test
@@ -41,10 +41,11 @@
 testConstraint openpipe         1
 testConstraint testfevent       [llength [info commands testfevent]]
 testConstraint testchannelevent [llength [info commands testchannelevent]]
 testConstraint testmainthread   [llength [info commands testmainthread]]
 testConstraint testobj		[llength [info commands testobj]]
+testConstraint knownMsvcBug [expr {![info exists ::env(TRAVIS_OS_NAME)] || ![string match windows $::env(TRAVIS_OS_NAME)]}]
 
 # You need a *very* special environment to do some tests.  In
 # particular, many file systems do not support large-files...
 testConstraint largefileSupport [expr {$::tcl_platform(os) ne "Darwin"}]
 
@@ -916,11 +917,11 @@
 test io-6.45 {Tcl_GetsObj: input saw cr, skip right number of bytes} {stdio testchannel openpipe fileevent} {
     # Tcl_ExternalToUtf()
 
     set f [open "|[list [interpreter] $path(cat)]" w+]
     fconfigure $f -translation {auto lf} -buffering none
-    fconfigure $f -encoding unicode
+    fconfigure $f -encoding utf-16
     puts -nonewline $f "bbbbbbbbbbbbbbb\n123456789abcdef\r"
     fconfigure $f -buffersize 16
     gets $f
     fconfigure $f -blocking 0
     set x [list [gets $f line] $line [testchannel queuedcr $f]]
@@ -1160,11 +1161,11 @@
     fileevent $f read [namespace code "ready $f"]
     proc ready {f} {
 	variable x
 	lappend x [gets $f line] $line [testchannel inputbuffered $f]
     }
-    fconfigure $f -encoding unicode -buffersize 16 -blocking 0
+    fconfigure $f -encoding utf-16 -buffersize 16 -blocking 0
     vwait [namespace which -variable x]
     fconfigure $f -translation auto -encoding ascii -blocking 1
     # here
     vwait [namespace which -variable x]
     close $f
@@ -2226,11 +2227,11 @@
     set l
 } {0 60 72}
 set path(pipe)   [makeFile {} pipe]
 set path(output) [makeFile {} output]
 test io-27.6 {FlushChannel, async flushing, async close} \
-	{stdio asyncPipeClose openpipe} {
+	{stdio asyncPipeClose openpipe knownMsvcBug} {
     # This test may fail on old Unix systems (seen on IRIX64 6.5) with
     # obsolete gettimeofday() calls.  See Tcl Bugs 3530533, 1942197.
     file delete $path(pipe)
     file delete $path(output)
     set f [open $path(pipe) w]
@@ -2830,11 +2831,11 @@
     # on Windows because a process still has the file open.
     after 100 set v 1; vwait v
     set result
 } ok
 test io-29.32 {Tcl_WriteChars, background flush to slow reader} \
-	{stdio asyncPipeClose openpipe} {
+	{stdio asyncPipeClose openpipe knownMsvcBug} {
     # This test may fail on old Unix systems (seen on IRIX64 6.5) with
     # obsolete gettimeofday() calls.  See Tcl Bugs 3530533, 1942197.
     file delete $path(pipe)
     file delete $path(output)
     set f [open $path(pipe) w]
@@ -8081,11 +8082,11 @@
     close $outChan
     close $c
     removeFile out
 } -result {line 100 line}
 
-test io-54.1 {Recursive channel events} {socket fileevent} {
+test io-54.1 {Recursive channel events} {socket fileevent knownMsvcBug} {
     # This test checks to see if file events are delivered during recursive
     # event loops when there is buffered data on the channel.
 
     proc accept {s a p} {
 	variable as

Index: tests/ioCmd.test
==================================================================
--- tests/ioCmd.test
+++ tests/ioCmd.test
@@ -23,10 +23,11 @@
 
 package require tcltests
 
 # Custom constraints used in this file
 testConstraint testchannel	[llength [info commands testchannel]]
+testConstraint knownMsvcBug [expr {![info exists ::env(TRAVIS_OS_NAME)] || ![string match windows $::env(TRAVIS_OS_NAME)]}]
 
 #----------------------------------------------------------------------
 
 test iocmd-1.1 {puts command} {
    list [catch {puts} msg] $msg
@@ -239,27 +240,27 @@
 } -result {bad value for -translation: must be one of auto, binary, cr, lf, crlf, or platform}
 test iocmd-8.7 {fconfigure command} -setup {
     file delete $path(test1)
 } -body {
     set f1 [open $path(test1) w]
-    fconfigure $f1 -translation lf -eofchar {} -encoding unicode
+    fconfigure $f1 -translation lf -eofchar {} -encoding utf-16
     fconfigure $f1
 } -cleanup {
     catch {close $f1}
-} -result {-blocking 1 -buffering full -buffersize 4096 -encoding unicode -eofchar {} -translation lf}
+} -result {-blocking 1 -buffering full -buffersize 4096 -encoding utf-16 -eofchar {} -translation lf}
 test iocmd-8.8 {fconfigure command} -setup {
     file delete $path(test1)
     set x {}
 } -body {
     set f1 [open $path(test1) w]
     fconfigure $f1 -translation lf -buffering line -buffersize 3030 \
-		-eofchar {} -encoding unicode
+		-eofchar {} -encoding utf-16
     lappend x [fconfigure $f1 -buffering]
     lappend x [fconfigure $f1]
 } -cleanup {
     catch {close $f1}
-} -result {line {-blocking 1 -buffering line -buffersize 3030 -encoding unicode -eofchar {} -translation lf}}
+} -result {line {-blocking 1 -buffering line -buffersize 3030 -encoding utf-16 -eofchar {} -translation lf}}
 test iocmd-8.9 {fconfigure command} -setup {
     file delete $path(test1)
 } -body {
     set f1 [open $path(test1) w]
     fconfigure $f1 -translation binary -buffering none -buffersize 4040 \
@@ -808,11 +809,11 @@
     lappend res $msg
     lappend res [file channel rc*]
     rename foo {}
     set res
 } -result {{} {initialize rc* {read write}} 1 {*all required methods*} {}}
-test iocmd-21.20 {Bug 88aef05cda} -setup {
+test iocmd-21.20 {Bug 88aef05cda} -constraints knownMsvcBug -setup {
     proc foo {method chan args} {
 	switch -- $method blocking {
 	    chan configure $chan -blocking [lindex $args 0]
 	    return
 	} initialize {
@@ -2013,11 +2014,11 @@
     set res {}
     proc foo {args} {oninit; onfinal; track; return}
     set c [chan create {r w} foo]
     set tock {}
     note [fileevent $c readable {lappend res TOCK; set tock 1}]
-    set stop [after 10000 {lappend res TIMEOUT; set tock 1}]
+    set stop [after 15000 {lappend res TIMEOUT; set tock 1}]
     after  1000 {note [chan postevent $c r]}
     vwait ::tock
     catch {after cancel $stop}
     close $c
     rename foo {}
@@ -2026,11 +2027,11 @@
 test iocmd-31.7 {chan postevent, posted events do happen} -match glob -body {
     set res {}
     proc foo {args} {oninit; onfinal; track; return}
     set c [chan create {r w} foo]
     note [fileevent $c writable {lappend res TOCK; set tock 1}]
-    set stop [after 10000 {lappend res TIMEOUT; set tock 1}]
+    set stop [after 15000 {lappend res TIMEOUT; set tock 1}]
     after  1000 {note [chan postevent $c w]}
     vwait ::tock
     catch {after cancel $stop}
     close $c
     rename foo {}

Index: tests/lindex.test
==================================================================
--- tests/lindex.test
+++ tests/lindex.test
@@ -68,15 +68,15 @@
     list [testevalex {lindex {a b c} $x}] [testevalex {lindex {a b c} $x}]
 } {{} {}}
 test lindex-3.5 {bad octal} -constraints testevalex -body {
     set x 0o8
     list [catch { testevalex {lindex {a b c} $x} } result] $result
-} -match glob -result {1 {*}}
+} -match glob -result {1 {*invalid octal number*}}
 test lindex-3.6 {bad octal} -constraints testevalex -body {
     set x -0o9
     list [catch { testevalex {lindex {a b c} $x} } result] $result
-} -match glob -result {1 {*}}
+} -match glob -result {1 {*invalid octal number*}}
 test lindex-3.7 {indexes don't shimmer wide ints} {
     set x [expr {(wide(1)<<31) - 2}]
     list $x [lindex {1 2 3} $x] [incr x] [incr x]
 } {2147483646 {} 2147483647 2147483648}
 test lindex-3.8 {compiled with static indices out of range, negative} {
@@ -112,15 +112,15 @@
     list [testevalex {lindex {a b c} $x}] [testevalex {lindex {a b c} $x}]
 } {{} {}}
 test lindex-4.6 {bad octal} -constraints testevalex -body {
     set x end-0o8
     list [catch { testevalex {lindex {a b c} $x} } result] $result
-} -match glob -result {1 {*}}
+} -match glob -result {1 {*invalid octal number*}}
 test lindex-4.7 {bad octal} -constraints testevalex -body {
     set x end--0o9
     list [catch { testevalex {lindex {a b c} $x} } result] $result
-} -match glob -result {1 {*}}
+} -match glob -result {1 {*invalid octal number*}}
 test lindex-4.8 {bad integer, not octal} testevalex {
     set x end-0a2
     list [catch { testevalex {lindex {a b c} $x} } result] $result
 } {1 {bad index "end-0a2": must be integer?[+-]integer? or end?[+-]integer?}}
 test lindex-4.9 {obsolete test} testevalex {
@@ -268,15 +268,15 @@
     set result
 } {{} {}}
 test lindex-11.5 {bad octal} -body {
     set x 0o8
     list [catch { lindex {a b c} $x } result] $result
-} -match glob -result {1 {*}}
+} -match glob -result {1 {*invalid octal number*}}
 test lindex-11.6 {bad octal} -body {
     set x -0o9
     list [catch { lindex {a b c} $x } result] $result
-} -match glob -result {1 {*}}
+} -match glob -result {1 {*invalid octal number*}}
 
 # Indices relative to end
 
 test lindex-12.1 {index = end} {
     set x end
@@ -314,15 +314,15 @@
     set result
 } {{} {}}
 test lindex-12.6 {bad octal} -body {
     set x end-0o8
     list [catch { lindex {a b c} $x } result] $result
-} -match glob -result {1 {*}}
+} -match glob -result {1 {*invalid octal number*}}
 test lindex-12.7 {bad octal} -body {
     set x end--0o9
     list [catch { lindex {a b c} $x } result] $result
-} -match glob -result {1 {*}}
+} -match glob -result {1 {*invalid octal number*}}
 test lindex-12.8 {bad integer, not octal} {
     set x end-0a2
     list [catch { lindex {a b c} $x } result] $result
 } {1 {bad index "end-0a2": must be integer?[+-]integer? or end?[+-]integer?}}
 test lindex-12.9 {obsolete test} {

Index: tests/mathop.test
==================================================================
--- tests/mathop.test
+++ tests/mathop.test
@@ -112,26 +112,26 @@
     test mathop-1.8 {compiled +} { + 1 2 300000000000 } 300000000003
     test mathop-1.9 {compiled +} { + 1000000000000000000000 2 3 } 1000000000000000000005
     test mathop-1.10 {compiled +} { + 1 2 3000000000000000000000 } 3000000000000000000003
     test mathop-1.11 {compiled +: errors} -returnCodes error -body {
 	+ x 0
-    } -result {can't use non-numeric string "x" as operand of "+"}
+    } -result {can't use non-numeric string as operand of "+"}
     test mathop-1.12 {compiled +: errors} -returnCodes error -body {
 	+ nan 0
-    } -result {can't use non-numeric floating-point value "nan" as operand of "+"}
+    } -result {can't use non-numeric floating-point value as operand of "+"}
     test mathop-1.13 {compiled +: errors} -returnCodes error -body {
 	+ 0 x
-    } -result {can't use non-numeric string "x" as operand of "+"}
+    } -result {can't use non-numeric string as operand of "+"}
     test mathop-1.14 {compiled +: errors} -returnCodes error -body {
 	+ 0 nan
-    } -result {can't use non-numeric floating-point value "nan" as operand of "+"}
+    } -result {can't use non-numeric floating-point value as operand of "+"}
     test mathop-1.15 {compiled +: errors} -returnCodes error -body {
 	+ 0o8 0
-    } -result {can't use non-numeric string "0o8" as operand of "+"}
+    } -result {can't use invalid octal number as operand of "+"}
     test mathop-1.16 {compiled +: errors} -returnCodes error -body {
 	+ 0 0o8
-    } -result {can't use non-numeric string "0o8" as operand of "+"}
+    } -result {can't use invalid octal number as operand of "+"}
     test mathop-1.17 {compiled +: errors} -returnCodes error -body {
 	+ 0 [error expectedError]
     } -result expectedError
     test mathop-1.18 {compiled +: argument processing order} -body {
 	# Bytecode compilation known hard for 3+ arguments
@@ -150,26 +150,26 @@
     test mathop-1.26 {interpreted +} { $op 1 2 300000000000 } 300000000003
     test mathop-1.27 {interpreted +} { $op 1000000000000000000000 2 3 } 1000000000000000000005
     test mathop-1.28 {interpreted +} { $op 1 2 3000000000000000000000 } 3000000000000000000003
     test mathop-1.29 {interpreted +: errors} -returnCodes error -body {
 	$op x 0
-    } -result {can't use non-numeric string "x" as operand of "+"}
+    } -result {can't use non-numeric string as operand of "+"}
     test mathop-1.30 {interpreted +: errors} -returnCodes error -body {
 	$op nan 0
-    } -result {can't use non-numeric floating-point value "nan" as operand of "+"}
+    } -result {can't use non-numeric floating-point value as operand of "+"}
     test mathop-1.31 {interpreted +: errors} -returnCodes error -body {
 	$op 0 x
-    } -result {can't use non-numeric string "x" as operand of "+"}
+    } -result {can't use non-numeric string as operand of "+"}
     test mathop-1.32 {interpreted +: errors} -returnCodes error -body {
 	$op 0 nan
-    } -result {can't use non-numeric floating-point value "nan" as operand of "+"}
+    } -result {can't use non-numeric floating-point value as operand of "+"}
     test mathop-1.33 {interpreted +: errors} -returnCodes error -body {
 	$op 0o8 0
-    } -result {can't use non-numeric string "0o8" as operand of "+"}
+    } -result {can't use invalid octal number as operand of "+"}
     test mathop-1.34 {interpreted +: errors} -returnCodes error -body {
 	$op 0 0o8
-    } -result {can't use non-numeric string "0o8" as operand of "+"}
+    } -result {can't use invalid octal number as operand of "+"}
     test mathop-1.35 {interpreted +: errors} -returnCodes error -body {
 	$op 0 [error expectedError]
     } -result expectedError
     test mathop-1.36 {interpreted +: argument processing order} -body {
 	list [catch {
@@ -187,26 +187,26 @@
     test mathop-2.8 {compiled *} { * 1 2 300000000000 } 600000000000
     test mathop-2.9 {compiled *} { * 1000000000000000000000 2 3 } 6000000000000000000000
     test mathop-2.10 {compiled *} { * 1 2 3000000000000000000000 } 6000000000000000000000
     test mathop-2.11 {compiled *: errors} -returnCodes error -body {
 	* x 0
-    } -result {can't use non-numeric string "x" as operand of "*"}
+    } -result {can't use non-numeric string as operand of "*"}
     test mathop-2.12 {compiled *: errors} -returnCodes error -body {
 	* nan 0
-    } -result {can't use non-numeric floating-point value "nan" as operand of "*"}
+    } -result {can't use non-numeric floating-point value as operand of "*"}
     test mathop-2.13 {compiled *: errors} -returnCodes error -body {
 	* 0 x
-    } -result {can't use non-numeric string "x" as operand of "*"}
+    } -result {can't use non-numeric string as operand of "*"}
     test mathop-2.14 {compiled *: errors} -returnCodes error -body {
 	* 0 nan
-    } -result {can't use non-numeric floating-point value "nan" as operand of "*"}
+    } -result {can't use non-numeric floating-point value as operand of "*"}
     test mathop-2.15 {compiled *: errors} -returnCodes error -body {
 	* 0o8 0
-    } -result {can't use non-numeric string "0o8" as operand of "*"}
+    } -result {can't use invalid octal number as operand of "*"}
     test mathop-2.16 {compiled *: errors} -returnCodes error -body {
 	* 0 0o8
-    } -result {can't use non-numeric string "0o8" as operand of "*"}
+    } -result {can't use invalid octal number as operand of "*"}
     test mathop-2.17 {compiled *: errors} -returnCodes error -body {
 	* 0 [error expectedError]
     } -result expectedError
     test mathop-2.18 {compiled *: argument processing order} -body {
 	# Bytecode compilation known hard for 3+ arguments
@@ -225,26 +225,26 @@
     test mathop-2.26 {interpreted *} { $op 1 2 300000000000 } 600000000000
     test mathop-2.27 {interpreted *} { $op 1000000000000000000000 2 3 } 6000000000000000000000
     test mathop-2.28 {interpreted *} { $op 1 2 3000000000000000000000 } 6000000000000000000000
     test mathop-2.29 {interpreted *: errors} -returnCodes error -body {
 	$op x 0
-    } -result {can't use non-numeric string "x" as operand of "*"}
+    } -result {can't use non-numeric string as operand of "*"}
     test mathop-2.30 {interpreted *: errors} -returnCodes error -body {
 	$op nan 0
-    } -result {can't use non-numeric floating-point value "nan" as operand of "*"}
+    } -result {can't use non-numeric floating-point value as operand of "*"}
     test mathop-2.31 {interpreted *: errors} -returnCodes error -body {
 	$op 0 x
-    } -result {can't use non-numeric string "x" as operand of "*"}
+    } -result {can't use non-numeric string as operand of "*"}
     test mathop-2.32 {interpreted *: errors} -returnCodes error -body {
 	$op 0 nan
-    } -result {can't use non-numeric floating-point value "nan" as operand of "*"}
+    } -result {can't use non-numeric floating-point value as operand of "*"}
     test mathop-2.33 {interpreted *: errors} -returnCodes error -body {
 	$op 0o8 0
-    } -result {can't use non-numeric string "0o8" as operand of "*"}
+    } -result {can't use invalid octal number as operand of "*"}
     test mathop-2.34 {interpreted *: errors} -returnCodes error -body {
 	$op 0 0o8
-    } -result {can't use non-numeric string "0o8" as operand of "*"}
+    } -result {can't use invalid octal number as operand of "*"}
     test mathop-2.35 {interpreted *: errors} -returnCodes error -body {
 	$op 0 [error expectedError]
     } -result expectedError
     test mathop-2.36 {interpreted *: argument processing order} -body {
 	list [catch {
@@ -259,11 +259,11 @@
     test mathop-3.5 {compiled !} {! 0.0} 1
     test mathop-3.6 {compiled !} {! 10000000000} 0
     test mathop-3.7 {compiled !} {! 10000000000000000000000000} 0
     test mathop-3.8 {compiled !: errors} -body {
 	! foobar
-    } -returnCodes error -result {can't use non-numeric string "foobar" as operand of "!"}
+    } -returnCodes error -result {can't use non-numeric string as operand of "!"}
     test mathop-3.9 {compiled !: errors} -body {
 	! 0 0
     } -returnCodes error -result "wrong # args: should be \"! boolean\""
     test mathop-3.10 {compiled !: errors} -body {
 	!
@@ -276,23 +276,23 @@
     test mathop-3.15 {interpreted !} {$op 0.0} 1
     test mathop-3.16 {interpreted !} {$op 10000000000} 0
     test mathop-3.17 {interpreted !} {$op 10000000000000000000000000} 0
     test mathop-3.18 {interpreted !: errors} -body {
 	$op foobar
-    } -returnCodes error -result {can't use non-numeric string "foobar" as operand of "!"}
+    } -returnCodes error -result {can't use non-numeric string as operand of "!"}
     test mathop-3.19 {interpreted !: errors} -body {
 	$op 0 0
     } -returnCodes error -result "wrong # args: should be \"! boolean\""
     test mathop-3.20 {interpreted !: errors} -body {
 	$op
     } -returnCodes error -result "wrong # args: should be \"! boolean\""
     test mathop-3.21 {compiled !: error} -returnCodes error -body {
 	! NaN
-    } -result {can't use non-numeric floating-point value "NaN" as operand of "!"}
+    } -result {can't use non-numeric floating-point value as operand of "!"}
     test mathop-3.22 {interpreted !: error} -returnCodes error -body {
 	$op NaN
-    } -result {can't use non-numeric floating-point value "NaN" as operand of "!"}
+    } -result {can't use non-numeric floating-point value as operand of "!"}
 
     test mathop-4.1 {compiled ~} {~ 0} -1
     test mathop-4.2 {compiled ~} {~ 1} -2
     test mathop-4.3 {compiled ~} {~ 31} -32
     test mathop-4.4 {compiled ~} {~ -127} 126
@@ -299,23 +299,23 @@
     test mathop-4.5 {compiled ~} {~ -0} -1
     test mathop-4.6 {compiled ~} {~ 10000000000} -10000000001
     test mathop-4.7 {compiled ~} {~ 10000000000000000000000000} -10000000000000000000000001
     test mathop-4.8 {compiled ~: errors} -body {
 	~ foobar
-    } -returnCodes error -result {can't use non-numeric string "foobar" as operand of "~"}
+    } -returnCodes error -result {can't use non-numeric string as operand of "~"}
     test mathop-4.9 {compiled ~: errors} -body {
 	~ 0 0
     } -returnCodes error -result "wrong # args: should be \"~ integer\""
     test mathop-4.10 {compiled ~: errors} -body {
 	~
     } -returnCodes error -result "wrong # args: should be \"~ integer\""
     test mathop-4.11 {compiled ~: errors} -returnCodes error -body {
 	~ 0.0
-    } -result {can't use floating-point value "0.0" as operand of "~"}
+    } -result {can't use floating-point value as operand of "~"}
     test mathop-4.12 {compiled ~: errors} -returnCodes error -body {
 	~ NaN
-    } -result {can't use non-numeric floating-point value "NaN" as operand of "~"}
+    } -result {can't use non-numeric floating-point value as operand of "~"}
     set op ~
     test mathop-4.13 {interpreted ~} {$op 0} -1
     test mathop-4.14 {interpreted ~} {$op 1} -2
     test mathop-4.15 {interpreted ~} {$op 31} -32
     test mathop-4.16 {interpreted ~} {$op -127} 126
@@ -322,23 +322,23 @@
     test mathop-4.17 {interpreted ~} {$op -0} -1
     test mathop-4.18 {interpreted ~} {$op 10000000000} -10000000001
     test mathop-4.19 {interpreted ~} {$op 10000000000000000000000000} -10000000000000000000000001
     test mathop-4.20 {interpreted ~: errors} -body {
 	$op foobar
-    } -returnCodes error -result {can't use non-numeric string "foobar" as operand of "~"}
+    } -returnCodes error -result {can't use non-numeric string as operand of "~"}
     test mathop-4.21 {interpreted ~: errors} -body {
 	$op 0 0
     } -returnCodes error -result "wrong # args: should be \"~ integer\""
     test mathop-4.22 {interpreted ~: errors} -body {
 	$op
     } -returnCodes error -result "wrong # args: should be \"~ integer\""
     test mathop-4.23 {interpreted ~: errors} -returnCodes error -body {
 	$op 0.0
-    } -result {can't use floating-point value "0.0" as operand of "~"}
+    } -result {can't use floating-point value as operand of "~"}
     test mathop-4.24 {interpreted ~: errors} -returnCodes error -body {
 	$op NaN
-    } -result {can't use non-numeric floating-point value "NaN" as operand of "~"}
+    } -result {can't use non-numeric floating-point value as operand of "~"}
 
     test mathop-5.1 {compiled eq} {eq {} a} 0
     test mathop-5.2 {compiled eq} {eq a a} 1
     test mathop-5.3 {compiled eq} {eq a {}} 0
     test mathop-5.4 {compiled eq} {eq a b} 0
@@ -375,36 +375,36 @@
     test mathop-6.2 {compiled &} { & 1 } 1
     test mathop-6.3 {compiled &} { & 1 2 } 0
     test mathop-6.4 {compiled &} { & 3 7 6 } 2
     test mathop-6.5 {compiled &} -returnCodes error -body {
 	& 1.0 2 3
-    } -result {can't use floating-point value "1.0" as operand of "&"}
+    } -result {can't use floating-point value as operand of "&"}
     test mathop-6.6 {compiled &} -returnCodes error -body {
 	& 1 2 3.0
-    } -result {can't use floating-point value "3.0" as operand of "&"}
+    } -result {can't use floating-point value as operand of "&"}
     test mathop-6.7 {compiled &} { & 100000000002 18 -126 } 2
     test mathop-6.8 {compiled &} { & 0xff 0o377 333333333333 } 85
     test mathop-6.9 {compiled &} { & 1000000000000000000002 18 -126 } 2
     test mathop-6.10 {compiled &} { & 0xff 0o377 3333333333333333333333 } 85
     test mathop-6.11 {compiled &: errors} -returnCodes error -body {
 	& x 0
-    } -result {can't use non-numeric string "x" as operand of "&"}
+    } -result {can't use non-numeric string as operand of "&"}
     test mathop-6.12 {compiled &: errors} -returnCodes error -body {
 	& nan 0
-    } -result {can't use non-numeric floating-point value "nan" as operand of "&"}
+    } -result {can't use non-numeric floating-point value as operand of "&"}
     test mathop-6.13 {compiled &: errors} -returnCodes error -body {
 	& 0 x
-    } -result {can't use non-numeric string "x" as operand of "&"}
+    } -result {can't use non-numeric string as operand of "&"}
     test mathop-6.14 {compiled &: errors} -returnCodes error -body {
 	& 0 nan
-    } -result {can't use non-numeric floating-point value "nan" as operand of "&"}
+    } -result {can't use non-numeric floating-point value as operand of "&"}
     test mathop-6.15 {compiled &: errors} -returnCodes error -body {
 	& 0o8 0
-    } -result {can't use non-numeric string "0o8" as operand of "&"}
+    } -result {can't use invalid octal number as operand of "&"}
     test mathop-6.16 {compiled &: errors} -returnCodes error -body {
 	& 0 0o8
-    } -result {can't use non-numeric string "0o8" as operand of "&"}
+    } -result {can't use invalid octal number as operand of "&"}
     test mathop-6.17 {compiled &: errors} -returnCodes error -body {
 	& 0 [error expectedError]
     } -result expectedError
     test mathop-6.18 {compiled &: argument processing order} -body {
 	# Bytecode compilation known hard for 3+ arguments
@@ -417,36 +417,36 @@
     test mathop-6.20 {interpreted &} { $op 1 } 1
     test mathop-6.21 {interpreted &} { $op 1 2 } 0
     test mathop-6.22 {interpreted &} { $op 3 7 6 } 2
     test mathop-6.23 {interpreted &} -returnCodes error -body {
 	$op 1.0 2 3
-    } -result {can't use floating-point value "1.0" as operand of "&"}
+    } -result {can't use floating-point value as operand of "&"}
     test mathop-6.24 {interpreted &} -returnCodes error -body {
 	$op 1 2 3.0
-    } -result {can't use floating-point value "3.0" as operand of "&"}
+    } -result {can't use floating-point value as operand of "&"}
     test mathop-6.25 {interpreted &} { $op 100000000002 18 -126 } 2
     test mathop-6.26 {interpreted &} { $op 0xff 0o377 333333333333 } 85
     test mathop-6.27 {interpreted &} { $op 1000000000000000000002 18 -126 } 2
     test mathop-6.28 {interpreted &} { $op 0xff 0o377 3333333333333333333333 } 85
     test mathop-6.29 {interpreted &: errors} -returnCodes error -body {
 	$op x 0
-    } -result {can't use non-numeric string "x" as operand of "&"}
+    } -result {can't use non-numeric string as operand of "&"}
     test mathop-6.30 {interpreted &: errors} -returnCodes error -body {
 	$op nan 0
-    } -result {can't use non-numeric floating-point value "nan" as operand of "&"}
+    } -result {can't use non-numeric floating-point value as operand of "&"}
     test mathop-6.31 {interpreted &: errors} -returnCodes error -body {
 	$op 0 x
-    } -result {can't use non-numeric string "x" as operand of "&"}
+    } -result {can't use non-numeric string as operand of "&"}
     test mathop-6.32 {interpreted &: errors} -returnCodes error -body {
 	$op 0 nan
-    } -result {can't use non-numeric floating-point value "nan" as operand of "&"}
+    } -result {can't use non-numeric floating-point value as operand of "&"}
     test mathop-6.33 {interpreted &: errors} -returnCodes error -body {
 	$op 0o8 0
-    } -result {can't use non-numeric string "0o8" as operand of "&"}
+    } -result {can't use invalid octal number as operand of "&"}
     test mathop-6.34 {interpreted &: errors} -returnCodes error -body {
 	$op 0 0o8
-    } -result {can't use non-numeric string "0o8" as operand of "&"}
+    } -result {can't use invalid octal number as operand of "&"}
     test mathop-6.35 {interpreted &: errors} -returnCodes error -body {
 	$op 0 [error expectedError]
     } -result expectedError
     test mathop-6.36 {interpreted &: argument processing order} -body {
 	list [catch {
@@ -485,36 +485,36 @@
     test mathop-7.2 {compiled |} { | 1 } 1
     test mathop-7.3 {compiled |} { | 1 2 } 3
     test mathop-7.4 {compiled |} { | 3 7 6 } 7
     test mathop-7.5 {compiled |} -returnCodes error -body {
 	| 1.0 2 3
-    } -result {can't use floating-point value "1.0" as operand of "|"}
+    } -result {can't use floating-point value as operand of "|"}
     test mathop-7.6 {compiled |} -returnCodes error -body {
 	| 1 2 3.0
-    } -result {can't use floating-point value "3.0" as operand of "|"}
+    } -result {can't use floating-point value as operand of "|"}
     test mathop-7.7 {compiled |} { | 100000000002 18 -126 } -110
     test mathop-7.8 {compiled |} { | 0xff 0o377 333333333333 } 333333333503
     test mathop-7.9 {compiled |} { | 1000000000000000000002 18 -126 } -110
     test mathop-7.10 {compiled |} { | 0xff 0o377 3333333333333333333333 } 3333333333333333333503
     test mathop-7.11 {compiled |: errors} -returnCodes error -body {
 	| x 0
-    } -result {can't use non-numeric string "x" as operand of "|"}
+    } -result {can't use non-numeric string as operand of "|"}
     test mathop-7.12 {compiled |: errors} -returnCodes error -body {
 	| nan 0
-    } -result {can't use non-numeric floating-point value "nan" as operand of "|"}
+    } -result {can't use non-numeric floating-point value as operand of "|"}
     test mathop-7.13 {compiled |: errors} -returnCodes error -body {
 	| 0 x
-    } -result {can't use non-numeric string "x" as operand of "|"}
+    } -result {can't use non-numeric string as operand of "|"}
     test mathop-7.14 {compiled |: errors} -returnCodes error -body {
 	| 0 nan
-    } -result {can't use non-numeric floating-point value "nan" as operand of "|"}
+    } -result {can't use non-numeric floating-point value as operand of "|"}
     test mathop-7.15 {compiled |: errors} -returnCodes error -body {
 	| 0o8 0
-    } -result {can't use non-numeric string "0o8" as operand of "|"}
+    } -result {can't use invalid octal number as operand of "|"}
     test mathop-7.16 {compiled |: errors} -returnCodes error -body {
 	| 0 0o8
-    } -result {can't use non-numeric string "0o8" as operand of "|"}
+    } -result {can't use invalid octal number as operand of "|"}
     test mathop-7.17 {compiled |: errors} -returnCodes error -body {
 	| 0 [error expectedError]
     } -result expectedError
     test mathop-7.18 {compiled |: argument processing order} -body {
 	# Bytecode compilation known hard for 3+ arguments
@@ -527,36 +527,36 @@
     test mathop-7.20 {interpreted |} { $op 1 } 1
     test mathop-7.21 {interpreted |} { $op 1 2 } 3
     test mathop-7.22 {interpreted |} { $op 3 7 6 } 7
     test mathop-7.23 {interpreted |} -returnCodes error -body {
 	$op 1.0 2 3
-    } -result {can't use floating-point value "1.0" as operand of "|"}
+    } -result {can't use floating-point value as operand of "|"}
     test mathop-7.24 {interpreted |} -returnCodes error -body {
 	$op 1 2 3.0
-    } -result {can't use floating-point value "3.0" as operand of "|"}
+    } -result {can't use floating-point value as operand of "|"}
     test mathop-7.25 {interpreted |} { $op 100000000002 18 -126 } -110
     test mathop-7.26 {interpreted |} { $op 0xff 0o377 333333333333 } 333333333503
     test mathop-7.27 {interpreted |} { $op 1000000000000000000002 18 -126 } -110
     test mathop-7.28 {interpreted |} { $op 0xff 0o377 3333333333333333333333 } 3333333333333333333503
     test mathop-7.29 {interpreted |: errors} -returnCodes error -body {
 	$op x 0
-    } -result {can't use non-numeric string "x" as operand of "|"}
+    } -result {can't use non-numeric string as operand of "|"}
     test mathop-7.30 {interpreted |: errors} -returnCodes error -body {
 	$op nan 0
-    } -result {can't use non-numeric floating-point value "nan" as operand of "|"}
+    } -result {can't use non-numeric floating-point value as operand of "|"}
     test mathop-7.31 {interpreted |: errors} -returnCodes error -body {
 	$op 0 x
-    } -result {can't use non-numeric string "x" as operand of "|"}
+    } -result {can't use non-numeric string as operand of "|"}
     test mathop-7.32 {interpreted |: errors} -returnCodes error -body {
 	$op 0 nan
-    } -result {can't use non-numeric floating-point value "nan" as operand of "|"}
+    } -result {can't use non-numeric floating-point value as operand of "|"}
     test mathop-7.33 {interpreted |: errors} -returnCodes error -body {
 	$op 0o8 0
-    } -result {can't use non-numeric string "0o8" as operand of "|"}
+    } -result {can't use invalid octal number as operand of "|"}
     test mathop-7.34 {interpreted |: errors} -returnCodes error -body {
 	$op 0 0o8
-    } -result {can't use non-numeric string "0o8" as operand of "|"}
+    } -result {can't use invalid octal number as operand of "|"}
     test mathop-7.35 {interpreted |: errors} -returnCodes error -body {
 	$op 0 [error expectedError]
     } -result expectedError
     test mathop-7.36 {interpreted |: argument processing order} -body {
 	list [catch {
@@ -595,36 +595,36 @@
     test mathop-8.2 {compiled ^} { ^ 1 } 1
     test mathop-8.3 {compiled ^} { ^ 1 2 } 3
     test mathop-8.4 {compiled ^} { ^ 3 7 6 } 2
     test mathop-8.5 {compiled ^} -returnCodes error -body {
 	^ 1.0 2 3
-    } -result {can't use floating-point value "1.0" as operand of "^"}
+    } -result {can't use floating-point value as operand of "^"}
     test mathop-8.6 {compiled ^} -returnCodes error -body {
 	^ 1 2 3.0
-    } -result {can't use floating-point value "3.0" as operand of "^"}
+    } -result {can't use floating-point value as operand of "^"}
     test mathop-8.7 {compiled ^} { ^ 100000000002 18 -126 } -100000000110
     test mathop-8.8 {compiled ^} { ^ 0xff 0o377 333333333333 } 333333333333
     test mathop-8.9 {compiled ^} { ^ 1000000000000000000002 18 -126 } -1000000000000000000110
     test mathop-8.10 {compiled ^} { ^ 0xff 0o377 3333333333333333333333 } 3333333333333333333333
     test mathop-8.11 {compiled ^: errors} -returnCodes error -body {
 	^ x 0
-    } -result {can't use non-numeric string "x" as operand of "^"}
+    } -result {can't use non-numeric string as operand of "^"}
     test mathop-8.12 {compiled ^: errors} -returnCodes error -body {
 	^ nan 0
-    } -result {can't use non-numeric floating-point value "nan" as operand of "^"}
+    } -result {can't use non-numeric floating-point value as operand of "^"}
     test mathop-8.13 {compiled ^: errors} -returnCodes error -body {
 	^ 0 x
-    } -result {can't use non-numeric string "x" as operand of "^"}
+    } -result {can't use non-numeric string as operand of "^"}
     test mathop-8.14 {compiled ^: errors} -returnCodes error -body {
 	^ 0 nan
-    } -result {can't use non-numeric floating-point value "nan" as operand of "^"}
+    } -result {can't use non-numeric floating-point value as operand of "^"}
     test mathop-8.15 {compiled ^: errors} -returnCodes error -body {
 	^ 0o8 0
-    } -result {can't use non-numeric string "0o8" as operand of "^"}
+    } -result {can't use invalid octal number as operand of "^"}
     test mathop-8.16 {compiled ^: errors} -returnCodes error -body {
 	^ 0 0o8
-    } -result {can't use non-numeric string "0o8" as operand of "^"}
+    } -result {can't use invalid octal number as operand of "^"}
     test mathop-8.17 {compiled ^: errors} -returnCodes error -body {
 	^ 0 [error expectedError]
     } -result expectedError
     test mathop-8.18 {compiled ^: argument processing order} -body {
 	# Bytecode compilation known hard for 3+ arguments
@@ -637,36 +637,36 @@
     test mathop-8.20 {interpreted ^} { $op 1 } 1
     test mathop-8.21 {interpreted ^} { $op 1 2 } 3
     test mathop-8.22 {interpreted ^} { $op 3 7 6 } 2
     test mathop-8.23 {interpreted ^} -returnCodes error -body {
 	$op 1.0 2 3
-    } -result {can't use floating-point value "1.0" as operand of "^"}
+    } -result {can't use floating-point value as operand of "^"}
     test mathop-8.24 {interpreted ^} -returnCodes error -body {
 	$op 1 2 3.0
-    } -result {can't use floating-point value "3.0" as operand of "^"}
+    } -result {can't use floating-point value as operand of "^"}
     test mathop-8.25 {interpreted ^} { $op 100000000002 18 -126 } -100000000110
     test mathop-8.26 {interpreted ^} { $op 0xff 0o377 333333333333 } 333333333333
     test mathop-8.27 {interpreted ^} { $op 1000000000000000000002 18 -126 } -1000000000000000000110
     test mathop-8.28 {interpreted ^} { $op 0xff 0o377 3333333333333333333333 } 3333333333333333333333
     test mathop-8.29 {interpreted ^: errors} -returnCodes error -body {
 	$op x 0
-    } -result {can't use non-numeric string "x" as operand of "^"}
+    } -result {can't use non-numeric string as operand of "^"}
     test mathop-8.30 {interpreted ^: errors} -returnCodes error -body {
 	$op nan 0
-    } -result {can't use non-numeric floating-point value "nan" as operand of "^"}
+    } -result {can't use non-numeric floating-point value as operand of "^"}
     test mathop-8.31 {interpreted ^: errors} -returnCodes error -body {
 	$op 0 x
-    } -result {can't use non-numeric string "x" as operand of "^"}
+    } -result {can't use non-numeric string as operand of "^"}
     test mathop-8.32 {interpreted ^: errors} -returnCodes error -body {
 	$op 0 nan
-    } -result {can't use non-numeric floating-point value "nan" as operand of "^"}
+    } -result {can't use non-numeric floating-point value as operand of "^"}
     test mathop-8.33 {interpreted ^: errors} -returnCodes error -body {
 	$op 0o8 0
-    } -result {can't use non-numeric string "0o8" as operand of "^"}
+    } -result {can't use invalid octal number as operand of "^"}
     test mathop-8.34 {interpreted ^: errors} -returnCodes error -body {
 	$op 0 0o8
-    } -result {can't use non-numeric string "0o8" as operand of "^"}
+    } -result {can't use invalid octal number as operand of "^"}
     test mathop-8.35 {interpreted ^: errors} -returnCodes error -body {
 	$op 0 [error expectedError]
     } -result expectedError
     test mathop-8.36 {interpreted ^: argument processing order} -body {
 	list [catch {
@@ -773,17 +773,17 @@
     set exp {}
     foreach vals {x {1 x} {1 1 x} {1 x 1}} {
         # skipping - for now, knownbug...
         foreach op {+ * / & | ^ **} {
             lappend res [TestOp $op {*}$vals]
-            lappend exp "can't use non-numeric string \"x\" as operand of \"$op\"\
+            lappend exp "can't use non-numeric string as operand of \"$op\"\
 		ARITH DOMAIN {non-numeric string}"
         }
     }
     foreach op {+ * / & | ^ **} {
 	lappend res [TestOp $op NaN 1]
-	lappend exp "can't use non-numeric floating-point value \"NaN\" as operand of \"$op\"\
+	lappend exp "can't use non-numeric floating-point value as operand of \"$op\"\
 	    ARITH DOMAIN {non-numeric floating-point value}"
     }
     expr {$res eq $exp ? 0 : $res}
 } 0
 test mathop-20.7 { multi arg } {
@@ -848,19 +848,19 @@
            2.8196218755553604e-15 8.10000006561e-27]
 test mathop-21.5 { unary ops, bad values } {
     set res {}
     set exp {}
     lappend res [TestOp / x]
-    lappend exp "can't use non-numeric string \"x\" as operand of \"/\" ARITH DOMAIN {non-numeric string}"
+    lappend exp "can't use non-numeric string as operand of \"/\" ARITH DOMAIN {non-numeric string}"
     lappend res [TestOp - x]
-    lappend exp "can't use non-numeric string \"x\" as operand of \"-\" ARITH DOMAIN {non-numeric string}"
+    lappend exp "can't use non-numeric string as operand of \"-\" ARITH DOMAIN {non-numeric string}"
     lappend res [TestOp ~ x]
-    lappend exp "can't use non-numeric string \"x\" as operand of \"~\" ARITH DOMAIN {non-numeric string}"
+    lappend exp "can't use non-numeric string as operand of \"~\" ARITH DOMAIN {non-numeric string}"
     lappend res [TestOp ! x]
-    lappend exp "can't use non-numeric string \"x\" as operand of \"!\" ARITH DOMAIN {non-numeric string}"
+    lappend exp "can't use non-numeric string as operand of \"!\" ARITH DOMAIN {non-numeric string}"
     lappend res [TestOp ~ 5.0]
-    lappend exp "can't use floating-point value \"5.0\" as operand of \"~\" ARITH DOMAIN {floating-point value}"
+    lappend exp "can't use floating-point value as operand of \"~\" ARITH DOMAIN {floating-point value}"
     expr {$res eq $exp ? 0 : $res}
 } 0
 test mathop-21.6 { unary ops, too many } {
     set exp {}
     foreach op {~ !} {
@@ -963,13 +963,13 @@
 test mathop-22.4 { unary ops, bad values } {
     set res {}
     set exp {}
     foreach op {& | ^} {
         lappend res [TestOp $op x 5]
-        lappend exp "can't use non-numeric string \"x\" as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
+        lappend exp "can't use non-numeric string as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
         lappend res [TestOp $op 5 x]
-        lappend exp "can't use non-numeric string \"x\" as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
+        lappend exp "can't use non-numeric string as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
     }
     expr {$res eq $exp ? 0 : $res}
 } 0
 
 test mathop-23.1 { comparison ops, numerical } {
@@ -1078,19 +1078,19 @@
 test mathop-24.3 { binary ops, bad values } {
     set res {}
     set exp {}
     foreach op {% << >>} {
         lappend res [TestOp $op x 1]
-        lappend exp "can't use non-numeric string \"x\" as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
+        lappend exp "can't use non-numeric string as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
         lappend res [TestOp $op 1 x]
-        lappend exp "can't use non-numeric string \"x\" as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
+        lappend exp "can't use non-numeric string as operand of \"$op\" ARITH DOMAIN {non-numeric string}"
     }
     foreach op {% << >>} {
         lappend res [TestOp $op 5.0 1]
-        lappend exp "can't use floating-point value \"5.0\" as operand of \"$op\" ARITH DOMAIN {floating-point value}"
+        lappend exp "can't use floating-point value as operand of \"$op\" ARITH DOMAIN {floating-point value}"
         lappend res [TestOp $op 1 5.0]
-        lappend exp "can't use floating-point value \"5.0\" as operand of \"$op\" ARITH DOMAIN {floating-point value}"
+        lappend exp "can't use floating-point value as operand of \"$op\" ARITH DOMAIN {floating-point value}"
     }
     foreach op {in ni} {
         lappend res [TestOp $op 5 "a b \{ c"]
         lappend exp "unmatched open brace in list TCL VALUE LIST BRACE"
     }
@@ -1264,13 +1264,13 @@
     lappend res [TestOp ** 2 $big]
     lappend exp "exponent too large NONE"
     lappend res [TestOp ** $huge 2.1]
     lappend exp "Inf"
     lappend res [TestOp ** 2 foo]
-    lappend exp "can't use non-numeric string \"foo\" as operand of \"**\" ARITH DOMAIN {non-numeric string}"
+    lappend exp "can't use non-numeric string as operand of \"**\" ARITH DOMAIN {non-numeric string}"
     lappend res [TestOp ** foo 2]
-    lappend exp "can't use non-numeric string \"foo\" as operand of \"**\" ARITH DOMAIN {non-numeric string}"
+    lappend exp "can't use non-numeric string as operand of \"**\" ARITH DOMAIN {non-numeric string}"
 
     expr {$res eq $exp ? 0 : $res}
 } 0
 
 test mathop-26.1 { misc ops, size combinations } {

Index: tests/namespace-old.test
==================================================================
--- tests/namespace-old.test
+++ tests/namespace-old.test
@@ -291,17 +291,16 @@
 	namespace eval test_ns_hier3b {}
     }
     namespace eval test_ns_hier2a {}
     namespace eval test_ns_hier2b {}
 }
-# TIP 278: secondary lookup disabled for vars, tests disabled with #
 test namespace-old-5.4 {nested namespaces can access global namespace} {
-    list [namespace eval test_ns_hier1 {#set test_ns_var_global}] \
+    list [namespace eval test_ns_hier1 {set test_ns_var_global}] \
          [namespace eval test_ns_hier1 {test_ns_cmd_global}] \
-         [namespace eval test_ns_hier1::test_ns_hier2 {#set test_ns_var_global}] \
+         [namespace eval test_ns_hier1::test_ns_hier2 {set test_ns_var_global}] \
          [namespace eval test_ns_hier1::test_ns_hier2 {test_ns_cmd_global}]
-} {{} {cmd in ::} {} {cmd in ::}}
+} {{var in ::} {cmd in ::} {var in ::} {cmd in ::}}
 test namespace-old-5.5 {variables in different namespaces don't conflict} {
     list [set test_ns_hier1::test_ns_level] \
          [set test_ns_hier1::test_ns_hier2::test_ns_level]
 } {1 2}
 test namespace-old-5.6 {commands in different namespaces don't conflict} {
@@ -467,42 +466,39 @@
     proc test_ns_cache1::test_ns_cache2::test_ns_cache_cmd {} {
         return "cache2 version"
     }
     list [test_ns_cache1::trigger] [test_ns_cache1::test_ns_cache2::trigger]
 } {{cache2 version} {cache2 version}}
-# TIP 278: secondary lookup disabled, catch added, result changed from {global version}
 test namespace-old-6.12 {define test variables} {
     variable test_ns_cache_var "global version"
     set trigger {set test_ns_cache_var}
-    list [catch {namespace eval test_ns_cache1 $trigger} msg] $msg
-} {1 {can't read "test_ns_cache_var": no such variable}}
+    namespace eval test_ns_cache1 $trigger
+} {global version}
     set trigger {set test_ns_cache_var}
 test namespace-old-6.13 {one-level check for variable shadowing} {
     namespace eval test_ns_cache1 {
         variable test_ns_cache_var "cache1 version"
     }
     namespace eval test_ns_cache1 $trigger
 } {cache1 version}
 variable ::test_ns_cache_var "global version"
-# TIP 278: secondary lookup disabled, catch added, result changed from {global version}
 test namespace-old-6.14 {deleting variables changes variable epoch} {
     namespace eval test_ns_cache1 {
         variable test_ns_cache_var "cache1 version"
     }
     list [namespace eval test_ns_cache1 $trigger] \
 	[namespace eval test_ns_cache1 {unset test_ns_cache_var}] \
-	[catch {namespace eval test_ns_cache1 $trigger}]
-} {{cache1 version} {} 1}
-# TIP 278: secondary lookup disabled, catch added, result changed
+	[namespace eval test_ns_cache1 $trigger]
+} {{cache1 version} {} {global version}}
 test namespace-old-6.15 {define test namespaces} {
     namespace eval test_ns_cache2 {
         variable test_ns_cache_var "global cache2 version"
     }
     set trigger2 {set test_ns_cache2::test_ns_cache_var}
-    catch {list [namespace eval test_ns_cache1 $trigger2] \
-	       [namespace eval test_ns_cache1::test_ns_cache2 $trigger]}
-} 1
+    list [namespace eval test_ns_cache1 $trigger2] \
+         [namespace eval test_ns_cache1::test_ns_cache2 $trigger]
+} {{global cache2 version} {global version}}
 set trigger2 {set test_ns_cache2::test_ns_cache_var}
 test namespace-old-6.16 {public variables affect all parent namespaces} {
     variable test_ns_cache1::test_ns_cache2::test_ns_cache_var "cache2 version"
     list [namespace eval test_ns_cache1 $trigger2] \
          [namespace eval test_ns_cache1::test_ns_cache2 $trigger]

Index: tests/namespace.test
==================================================================
--- tests/namespace.test
+++ tests/namespace.test
@@ -44,13 +44,13 @@
 } {:: :: ::}
 test namespace-2.2 {Tcl_GetCurrentNamespace} {
     set l {}
     lappend l [namespace current]
     namespace eval test_ns_1 {
-        lappend ::l [namespace current]
+        lappend l [namespace current]
         namespace eval foo {
-            lappend ::l [namespace current]
+            lappend l [namespace current]
         }
     }
     lappend l [namespace current]
 } {:: ::test_ns_1 ::test_ns_1::foo ::}
 
@@ -644,12 +644,10 @@
     namespace eval test_ns_1 {
         list [catch {set ::test_ns_777::v} msg] $msg \
              [catch {namespace children test_ns_777} msg] $msg
     }
 } -result {1 {can't read "::test_ns_777::v": no such variable} 1 {namespace "test_ns_777" not found in "::test_ns_1"}}
-
-# TIP 278: secondary lookup disabled, results changed from {10 20}
 test namespace-14.3 {TclGetNamespaceForQualName, relative names} -setup {
     catch {namespace delete {*}[namespace children :: test_ns_*]}
     variable v 10
     namespace eval test_ns_1::test_ns_2 {
         variable v 20
@@ -657,15 +655,13 @@
     namespace eval test_ns_2 {
         variable v 30
     }
 } -body {
     namespace eval test_ns_1 {
-        # list $v $test_ns_2::v
-        list [catch {set v} msg] $msg  [catch {set test_ns_2::v} msg] $msg
+        list $v $test_ns_2::v
     }
-} -result {1 {can't read "v": no such variable} 0 20}
-
+} -result {10 20}
 test namespace-14.4 {TclGetNamespaceForQualName, relative ns names looked up only in current ns} {
     namespace eval test_ns_1::test_ns_2 {
         namespace eval foo {}
     }
     namespace eval test_ns_1 {
@@ -722,21 +718,19 @@
 } -body {
     lappend l [catch {test_ns_1::test_ns_2:: hello} msg] $msg
     proc test_ns_1::test_ns_2:: {args} {return "\{\}: $args"}
     lappend l [test_ns_1::test_ns_2:: hello]
 } -result {1 {invalid command name "test_ns_1::test_ns_2::"} {{}: hello}}
-
-# TIP 278: secondary lookup disabled, added catch, result changed from y
 test namespace-14.12 {TclGetNamespaceForQualName, extra ::s are significant for vars} -setup {
     catch {namespace delete {*}[namespace children :: test_ns_*]}
 } -body {
     namespace eval test_ns_1 {
         variable {}
-        catch {set test_ns_1::(x) y} ::msg
+        set test_ns_1::(x) y
     }
-    list $::msg [catch {set test_ns_1::(x)} msg] $msg
-} -result {{can't set "test_ns_1::(x)": parent namespace doesn't exist} 1 {can't read "test_ns_1::(x)": no such variable}}
+    set test_ns_1::(x)
+} -result y
 test namespace-14.13 {TclGetNamespaceForQualName, namespace other than global ns can't have empty name} -setup {
     catch {namespace delete {*}[namespace children :: test_ns_*]}
 } -returnCodes error -body {
     namespace eval test_ns_1 {
 	proc {} {} {}
@@ -905,19 +899,17 @@
 } -body {
     namespace eval test_ns_1 {
         set x
     }
 } -result {777}
-
-# TIP 278: secondary lookup disabled, catch added, result changed from 314159
 test namespace-17.7 {Tcl_FindNamespaceVar, relative name found} {
     namespace eval test_ns_1 {
 	variable x 777
         unset x
-        list [catch {set x} msg] $msg  ;# must not be global x now
+        set x  ;# must be global x now
     }
-} {1 {can't read "x": no such variable}}
+} {314159}
 test namespace-17.8 {Tcl_FindNamespaceVar, relative name not found} -body {
     namespace eval test_ns_1 {
         set wuzzat
     }
 } -returnCodes error -result {can't read "wuzzat": no such variable}
@@ -925,12 +917,10 @@
     namespace eval test_ns_1 {
         variable a hello
     }
     set test_ns_1::a
 } {hello}
-
-# TIP 278: secondary lookup disabled, result changed from 1
 test namespace-17.10 {Tcl_FindNamespaceVar, interference with cached varNames} -setup {
     namespace eval test_ns_1 {}
 } -body {
     proc test_ns {} {
 	set ::test_ns_1::a 0
@@ -940,11 +930,11 @@
     namespace eval test_ns_1 unset a
     set a 0
     namespace eval test_ns_1 set a 1
     namespace delete test_ns_1
     return $a
-} -result 0
+} -result 1
 catch {unset a}
 catch {unset x}
 
 catch {unset l}
 catch {rename foo {}}
@@ -1561,12 +1551,10 @@
              [namespace which p] \
              [namespace which cmd1] \
              [namespace which ::test_ns_2::cmd2]
     }
 } -result {::foreach ::test_ns_3::p ::test_ns_3::cmd1 ::test_ns_2::cmd2}
-
-# TIP 278: secondary lookup disabled, catch added, result changed
 test namespace-34.7 {NamespaceWhichCmd, variable lookup} -setup {
     catch {namespace delete {*}[namespace children test_ns_*]}
     namespace eval test_ns_1 {
         namespace export cmd*
         proc cmd1 {args} {return "cmd1: $args"}
@@ -1582,16 +1570,16 @@
         variable v3 333
         namespace import ::test_ns_2::*
     }
 } -body {
     namespace eval test_ns_3 {
-        list [catch {namespace which -variable env } msg] $msg \
+        list [namespace which -variable env] \
              [namespace which -variable v3] \
              [namespace which -variable ::test_ns_2::v2] \
              [catch {namespace which -variable ::test_ns_2::noSuchVar} msg] $msg
     }
-} -result {0 {} ::test_ns_3::v3 ::test_ns_2::v2 0 {}}
+} -result {::env ::test_ns_3::v3 ::test_ns_2::v2 0 {}}
 
 test namespace-35.1 {FreeNsNameInternalRep, resulting ref count > 0} -setup {
     catch {namespace delete {*}[namespace children :: test_ns_*]}
 } -body {
     namespace eval test_ns_1 {

Index: tests/parse.test
==================================================================
--- tests/parse.test
+++ tests/parse.test
@@ -374,16 +374,16 @@
 	set aresult $result
 	set acode $code
 	return "new result"
     }
     set handler1 [testasync create async1]
-    set ::aresult xxx
-    set ::acode yyy
+    set aresult xxx
+    set acode yyy
 } -cleanup {
     testasync delete
 } -body {
-    list [testevalobjv 0 testasync mark $handler1 original 0] $::acode $::aresult
+    list [testevalobjv 0 testasync mark $handler1 original 0] $acode $aresult
 } -result {{new result} 0 original}
 test parse-8.9 {Tcl_EvalObjv procedure, exceptional return} testevalobjv {
     list [catch {testevalobjv 0 error message} msg] $msg
 } {1 message}
 test parse-8.10 {Tcl_EvalObjv procedure, TCL_EVAL_GLOBAL} testevalobjv {

Index: tests/result.test
==================================================================
--- tests/result.test
+++ tests/result.test
@@ -29,11 +29,11 @@
 test result-1.2 {Tcl_SaveInterpResult} {testsaveresult} {
     testsaveresult append {set x 42} 0
 } {append result}
 test result-1.3 {Tcl_SaveInterpResult} {testsaveresult} {
     testsaveresult dynamic {set x 42} 0
-} {dynamic result freed}
+} {dynamic result presentOrFreed}
 test result-1.4 {Tcl_SaveInterpResult} {testsaveresult} {
     testsaveresult object {set x 42} 0
 } {object result same}
 test result-1.5 {Tcl_SaveInterpResult} {testsaveresult} {
     testsaveresult small {set x 42} 1
@@ -41,11 +41,11 @@
 test result-1.6 {Tcl_SaveInterpResult} {testsaveresult} {
     testsaveresult append {set x 42} 1
 } {42}
 test result-1.7 {Tcl_SaveInterpResult} {testsaveresult} {
     testsaveresult dynamic {set x 42} 1
-} {42 freed}
+} {42 presentOrFreed}
 test result-1.8 {Tcl_SaveInterpResult} {testsaveresult} {
     testsaveresult object {set x 42} 1
 } {42 different}
 
 # Tcl_RestoreInterpResult is mostly tested by the previous tests except

Index: tests/socket.test
==================================================================
--- tests/socket.test
+++ tests/socket.test
@@ -73,10 +73,11 @@
 }
 
 # Some tests require the Thread package or exec command
 testConstraint thread [expr {0 == [catch {package require Thread 2.7-}]}]
 testConstraint exec [llength [info commands exec]]
+testConstraint knownMsvcBug [expr {![info exists ::env(TRAVIS_OS_NAME)] || ![string match windows $::env(TRAVIS_OS_NAME)]}]
 
 # Produce a random port number in the Dynamic/Private range
 # from 49152 through 65535.
 proc randport {} {
     # firstly try dynamic port via server-socket(0):
@@ -2283,11 +2284,11 @@
         close $fd
         close $sock
 	removeFile script
     } -result {{} ok}
 test socket-14.11.0 {pending [socket -async] and nonblocking [puts], no listener, no flush} \
-    -constraints {socket} \
+    -constraints {socket knownMsvcBug} \
     -body {
         set sock [socket -async localhost [randport]]
         fconfigure $sock -blocking 0
         puts $sock ok
         fileevent $sock writable {set x 1}

Index: tests/source.test
==================================================================
--- tests/source.test
+++ tests/source.test
@@ -238,16 +238,16 @@
     # file that contains the byte \x1A, although not the character \u001A in
     # the indicated encoding.
     set sourcefile [makeFile {} source.file]
     file delete $sourcefile
     set f [open $sourcefile w]
-    fconfigure $f -encoding unicode
+    fconfigure $f -encoding utf-16
     puts $f "set symbol(square-root) \u221A; set x correct"
     close $f
 } -body {
     set x unset
-    source -encoding unicode $sourcefile
+    source -encoding utf-16 $sourcefile
     set x
 } -cleanup {
     removeFile source.file
 } -result correct
 test source-7.3 {source -encoding: syntax} -body {

Index: tests/string.test
==================================================================
--- tests/string.test
+++ tests/string.test
@@ -493,14 +493,14 @@
     binary scan $str H* dump
     run {string compare [run {string index $str 10}] \x00}
 } 0
 test string-5.17.$noComp {string index, bad integer} -body {
     list [catch {run {string index "abc" 0o8}} msg] $msg
-} -match glob -result {1 {*}}
+} -match glob -result {1 {*invalid octal number*}}
 test string-5.18.$noComp {string index, bad integer} -body {
     list [catch {run {string index "abc" end-0o0289}} msg] $msg
-} -match glob -result {1 {*}}
+} -match glob -result {1 {*invalid octal number*}}
 test string-5.19.$noComp {string index, bytearray object out of bounds} {
     run {string index [binary format I* {0x50515253 0x52}] -1}
 } {}
 test string-5.20.$noComp {string index, bytearray object out of bounds} {
     run {string index [binary format I* {0x50515253 0x52}] 20}

Index: tests/stringObj.test
==================================================================
--- tests/stringObj.test
+++ tests/stringObj.test
@@ -437,13 +437,13 @@
     string length [testbytestring \x01\x00\x02]
 } 3
 
 test stringObj-14.1 {Tcl_SetObjLength on pure unicode object} testobj {
     teststringobj set 1 foo
-    teststringobj getunicode 1
+    teststringobj maxchars 1
     teststringobj append 1 bar -1
-    teststringobj getunicode 1
+    teststringobj maxchars 1
     teststringobj append 1 bar -1
     teststringobj setlength 1 0
     teststringobj append 1 bar -1
     teststringobj get 1
 } {bar}

Index: tests/tcltest.test
==================================================================
--- tests/tcltest.test
+++ tests/tcltest.test
@@ -542,11 +542,10 @@
 # Test non-writeable directories, non-readable directories with directory flags
 set notReadableDir [file join [temporaryDirectory] notreadable]
 set notWriteableDir [file join [temporaryDirectory] notwriteable]
 makeDirectory notreadable
 makeDirectory notwriteable
-
 switch -- $::tcl_platform(platform) {
     unix {
 	file attributes $notReadableDir -permissions 00333
 	file attributes $notWriteableDir -permissions 00555
     }

Index: tests/utf.test
==================================================================
--- tests/utf.test
+++ tests/utf.test
@@ -106,11 +106,11 @@
 } {0}
 test utf-4.2 {Tcl_NumUtfChars: length 1} {testnumutfchars testbytestring} {
     testnumutfchars [testbytestring "\xC2\xA2"]
 } {1}
 test utf-4.3 {Tcl_NumUtfChars: long string} {testnumutfchars testbytestring} {
-    testnumutfchars [testbytestring "abc\xC2\xA2\xE4\xB9\x8E\xA2\x4E"]
+    testnumutfchars [testbytestring "abc\xC2\xA2\xE4\xB9\x8E\uA2\x4E"]
 } {7}
 test utf-4.4 {Tcl_NumUtfChars: #u0000} {testnumutfchars testbytestring} {
     testnumutfchars [testbytestring "\xC0\x80"]
 } {1}
 test utf-4.5 {Tcl_NumUtfChars: zero length, calc len} testnumutfchars {
@@ -118,11 +118,11 @@
 } {0}
 test utf-4.6 {Tcl_NumUtfChars: length 1, calc len} {testnumutfchars testbytestring} {
     testnumutfchars [testbytestring "\xC2\xA2"] 2
 } {1}
 test utf-4.7 {Tcl_NumUtfChars: long string, calc len} {testnumutfchars testbytestring} {
-    testnumutfchars [testbytestring "abc\xC2\xA2\xE4\xB9\x8E\xA2\x4E"] 10
+    testnumutfchars [testbytestring "abc\xC2\xA2\xE4\xB9\x8E\uA2\x4E"] 10
 } {7}
 test utf-4.8 {Tcl_NumUtfChars: #u0000, calc len} {testnumutfchars testbytestring} {
     testnumutfchars [testbytestring "\xC0\x80"] 2
 } {1}
 # Bug [2738427]: Tcl_NumUtfChars(...) no overflow check
@@ -469,12 +469,12 @@
 	testobj freeallvars
     } \
     -body {
 	teststringobj set 1 a
 	teststringobj set 2 b
-	teststringobj getunicode 1
-	teststringobj getunicode 2
+	teststringobj maxchars 1
+	teststringobj maxchars 2
 	string compare -nocase [teststringobj get 1] [teststringobj get 2]
     } \
     -cleanup {
 	testobj freeallvars
     } \
@@ -484,12 +484,12 @@
 	testobj freeallvars
     } \
     -body {
 	teststringobj set 1 b
 	teststringobj set 2 a
-	teststringobj getunicode 1
-	teststringobj getunicode 2
+	teststringobj maxchars 1
+	teststringobj maxchars 2
 	string compare -nocase [teststringobj get 1] [teststringobj get 2]
     } \
     -cleanup {
 	testobj freeallvars
     } \
@@ -499,12 +499,12 @@
 	testobj freeallvars
     } \
     -body {
 	teststringobj set 1 B
 	teststringobj set 2 a
-	teststringobj getunicode 1
-	teststringobj getunicode 2
+	teststringobj maxchars 1
+	teststringobj maxchars 2
 	string compare -nocase [teststringobj get 1] [teststringobj get 2]
     } \
     -cleanup {
 	testobj freeallvars
     } \
@@ -515,12 +515,12 @@
 	testobj freeallvars
     } \
     -body {
 	teststringobj set 1 aBcB
 	teststringobj set 2 abca
-	teststringobj getunicode 1
-	teststringobj getunicode 2
+	teststringobj maxchars 1
+	teststringobj maxchars 2
 	string compare -nocase [teststringobj get 1] [teststringobj get 2]
     } \
     -cleanup {
 	testobj freeallvars
     } \

Index: tests/util.test
==================================================================
--- tests/util.test
+++ tests/util.test
@@ -19,10 +19,13 @@
 testConstraint testbytestring [llength [info commands testbytestring]]
 testConstraint testdstring [llength [info commands testdstring]]
 testConstraint testconcatobj [llength [info commands testconcatobj]]
 testConstraint testdoubledigits [llength [info commands testdoubledigits]]
 testConstraint testprint [llength [info commands testprint]]
+
+testConstraint precision [expr {![catch {set saved_precision $::tcl_precision}]}]
+
 
 # Big test for correct ordering of data in [expr]
 
 proc testIEEE {} {
     variable ieeeValues
@@ -277,11 +280,11 @@
     Wrapper_Tcl_StringMatch "a\[a\u4e4fc]c" "a\u4e4fc"
 } 1
 test util-5.18 {Tcl_StringMatch: UTF-8} testbytestring {
     # pattern += Tcl_UtfToUniChar(pattern, &endChar);
     # proper advance: wrong answer would match on UTF trail byte of \u4e4f
-    Wrapper_Tcl_StringMatch {a[a\u4e4fc]c} [testbytestring a\x8Fc]
+    Wrapper_Tcl_StringMatch {a[a\u4e4fc]c} [testbytestring a\x8fc]
 } 0
 test util-5.19 {Tcl_StringMatch: UTF-8} {
     # pattern += Tcl_UtfToUniChar(pattern, &endChar);
     # proper advance.
     Wrapper_Tcl_StringMatch {a[a\u4e4fc]c} "acc"
@@ -383,16 +386,92 @@
 } 0
 test util-5.51 {Tcl_StringMatch} {
     Wrapper_Tcl_StringMatch "" ""
 } 1
 
+test util-6.1 {Tcl_PrintDouble - using tcl_precision} -constraints precision -setup {
+    set old_precision $::tcl_precision
+    set ::tcl_precision 12
+} -body {
+    concat x[expr 1.4]
+} -cleanup {
+    set ::tcl_precision $old_precision
+} -result {x1.4}
+test util-6.2 {Tcl_PrintDouble - using tcl_precision} -constraints precision -setup {
+    set old_precision $::tcl_precision
+    set ::tcl_precision 12
+} -body {
+    concat x[expr 1.39999999999]
+} -cleanup {
+    set ::tcl_precision $old_precision
+} -result {x1.39999999999}
+test util-6.3 {Tcl_PrintDouble - using tcl_precision} -constraints precision -setup {
+    set old_precision $::tcl_precision
+    set ::tcl_precision 12
+} -body {
+    concat x[expr 1.399999999999]
+} -cleanup {
+    set ::tcl_precision $old_precision
+} -result {x1.4}
+test util-6.4 {Tcl_PrintDouble - using tcl_precision} -constraints precision -setup {
+    set old_precision $::tcl_precision
+    set ::tcl_precision 5
+} -body {
+    concat x[expr 1.123412341234]
+} -cleanup {
+    set tcl_precision $old_precision
+} -result {x1.1234}
 test util-6.5 {Tcl_PrintDouble - make sure there's a decimal point} {
     concat x[expr 2.0]
 } {x2.0}
 test util-6.6 {Tcl_PrintDouble - make sure there's a decimal point} {
     concat x[expr 3.0e98]
 } {x3e+98}
+
+test util-7.1 {TclPrecTraceProc - unset callbacks} -constraints precision -setup {
+    set old_precision $::tcl_precision
+} -body {
+    set tcl_precision 7
+    set x $tcl_precision
+    unset tcl_precision
+    list $x $tcl_precision
+} -cleanup {
+    set ::tcl_precision $old_precision
+} -result {7 7}
+test util-7.2 {TclPrecTraceProc - read traces, sharing among interpreters} -constraints precision  -setup {
+    set old_precision $::tcl_precision
+} -body {
+    set tcl_precision 12
+    interp create child
+    set x [child eval set tcl_precision]
+    child eval {set tcl_precision 6}
+    interp delete child
+    list $x $tcl_precision
+} -cleanup {
+    set ::tcl_precision $old_precision
+} -result {12 6}
+test util-7.3 {TclPrecTraceProc - write traces, safe interpreters} -constraints precision -setup {
+    set old_precision $::tcl_precision
+} -body {
+    set tcl_precision 12
+    interp create -safe child
+    set x [child eval {
+	list [catch {set tcl_precision 8} msg] $msg
+    }]
+    interp delete child
+    list $x $tcl_precision
+} -cleanup {
+    set ::tcl_precision $old_precision
+} -result {{1 {can't set "tcl_precision": can't modify precision from a safe interpreter}} 12}
+test util-7.4 {TclPrecTraceProc - write traces, bogus values} -constraints precision -setup {
+    set old_precision $::tcl_precision
+} -body {
+    set tcl_precision 12
+    list [catch {set tcl_precision abc} msg] $msg $tcl_precision
+} -cleanup {
+    set ::tcl_precision $old_precision
+} -result {1 {can't set "tcl_precision": improper value for precision} 12}
 
 # This test always succeeded in the C locale anyway...
 test util-8.1 {TclNeedSpace - correct UTF8 handling} {
     # Bug 411825
     # Note that this test relies on the fact that
@@ -2102,10 +2181,1878 @@
     -result 0x8010000000000000
     -cleanup {
 	unset x
     }
 }
+
+foreach ::tcl_precision {0 12} {
+    for {set e -312} {$e < -9} {incr e} {
+	test util-16.1.$::tcl_precision.$e {shortening of numbers} \
+	    "expr 1.1e$e" 1.1e$e
+    }
+}
+set tcl_precision 0
+for {set e -9} {$e < -4} {incr e} {
+    test util-16.1.$::tcl_precision.$e {shortening of numbers} \
+	"expr 1.1e$e" 1.1e$e
+}
+set tcl_precision 12
+for {set e -9} {$e < -4} {incr e} {
+    test util-16.1.$::tcl_precision.$e {8.4 compatible formatting of doubles} precision \
+	"expr 1.1e$e" 1.1e[format %+03d $e]
+}
+foreach ::tcl_precision {0 12} {
+    test util-16.1.$::tcl_precision.-4 {shortening of numbers} \
+	{expr 1.1e-4} \
+	0.00011
+    test util-16.1.$::tcl_precision.-3 {shortening of numbers} \
+	{expr 1.1e-3} \
+	0.0011
+    test util-16.1.$::tcl_precision.-2 {shortening of numbers} \
+	{expr 1.1e-2} \
+	0.011
+    test util-16.1.$::tcl_precision.-1 {shortening of numbers} \
+	{expr 1.1e-1} \
+	0.11
+    test util-16.1.$::tcl_precision.0 {shortening of numbers} \
+	{expr 1.1} \
+	1.1
+    for {set e 1} {$e < 17} {incr e} {
+	test util-16.1.$::tcl_precision.$e {shortening of numbers} \
+	    "expr 11[string repeat 0 [expr {$e-1}]].0" \
+	    11[string repeat 0 [expr {$e-1}]].0
+    }
+    for {set e 17} {$e < 309} {incr e} {
+	test util-16.1.$::tcl_precision.$e {shortening of numbers} \
+	    "expr 1.1e$e" 1.1e+$e
+    }
+}
+set tcl_precision 17
+test util-16.1.17.-300 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-300} \
+    1e-300
+test util-16.1.17.-299 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-299} \
+    9.9999999999999999e-300
+test util-16.1.17.-298 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-298} \
+    9.9999999999999991e-299
+test util-16.1.17.-297 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-297} \
+    1e-297
+test util-16.1.17.-296 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-296} \
+    1e-296
+test util-16.1.17.-295 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-295} \
+    1.0000000000000001e-295
+test util-16.1.17.-294 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-294} \
+    1e-294
+test util-16.1.17.-293 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-293} \
+    1.0000000000000001e-293
+test util-16.1.17.-292 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-292} \
+    1.0000000000000001e-292
+test util-16.1.17.-291 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-291} \
+    9.9999999999999996e-292
+test util-16.1.17.-290 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-290} \
+    1.0000000000000001e-290
+test util-16.1.17.-289 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-289} \
+    1e-289
+test util-16.1.17.-288 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-288} \
+    1.0000000000000001e-288
+test util-16.1.17.-287 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-287} \
+    1e-287
+test util-16.1.17.-286 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-286} \
+    1.0000000000000001e-286
+test util-16.1.17.-285 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-285} \
+    1.0000000000000001e-285
+test util-16.1.17.-284 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-284} \
+    1e-284
+test util-16.1.17.-283 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-283} \
+    9.9999999999999995e-284
+test util-16.1.17.-282 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-282} \
+    1e-282
+test util-16.1.17.-281 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-281} \
+    1e-281
+test util-16.1.17.-280 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-280} \
+    9.9999999999999996e-281
+test util-16.1.17.-279 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-279} \
+    1.0000000000000001e-279
+test util-16.1.17.-278 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-278} \
+    9.9999999999999994e-279
+test util-16.1.17.-277 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-277} \
+    9.9999999999999997e-278
+test util-16.1.17.-276 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-276} \
+    1.0000000000000001e-276
+test util-16.1.17.-275 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-275} \
+    9.9999999999999993e-276
+test util-16.1.17.-274 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-274} \
+    9.9999999999999997e-275
+test util-16.1.17.-273 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-273} \
+    1.0000000000000001e-273
+test util-16.1.17.-272 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-272} \
+    9.9999999999999993e-273
+test util-16.1.17.-271 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-271} \
+    9.9999999999999996e-272
+test util-16.1.17.-270 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-270} \
+    1e-270
+test util-16.1.17.-269 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-269} \
+    9.9999999999999996e-270
+test util-16.1.17.-268 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-268} \
+    9.9999999999999996e-269
+test util-16.1.17.-267 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-267} \
+    9.9999999999999998e-268
+test util-16.1.17.-266 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-266} \
+    9.9999999999999998e-267
+test util-16.1.17.-265 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-265} \
+    9.9999999999999998e-266
+test util-16.1.17.-264 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-264} \
+    1e-264
+test util-16.1.17.-263 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-263} \
+    1e-263
+test util-16.1.17.-262 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-262} \
+    1e-262
+test util-16.1.17.-261 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-261} \
+    9.9999999999999998e-262
+test util-16.1.17.-260 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-260} \
+    9.9999999999999996e-261
+test util-16.1.17.-259 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-259} \
+    1.0000000000000001e-259
+test util-16.1.17.-258 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-258} \
+    9.9999999999999995e-259
+test util-16.1.17.-257 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-257} \
+    9.9999999999999998e-258
+test util-16.1.17.-256 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-256} \
+    9.9999999999999998e-257
+test util-16.1.17.-255 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-255} \
+    1e-255
+test util-16.1.17.-254 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-254} \
+    9.9999999999999991e-255
+test util-16.1.17.-253 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-253} \
+    1.0000000000000001e-253
+test util-16.1.17.-252 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-252} \
+    9.9999999999999994e-253
+test util-16.1.17.-251 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-251} \
+    1e-251
+test util-16.1.17.-250 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-250} \
+    1.0000000000000001e-250
+test util-16.1.17.-249 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-249} \
+    1.0000000000000001e-249
+test util-16.1.17.-248 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-248} \
+    9.9999999999999998e-249
+test util-16.1.17.-247 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-247} \
+    1e-247
+test util-16.1.17.-246 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-246} \
+    9.9999999999999996e-247
+test util-16.1.17.-245 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-245} \
+    9.9999999999999993e-246
+test util-16.1.17.-244 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-244} \
+    9.9999999999999993e-245
+test util-16.1.17.-243 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-243} \
+    1e-243
+test util-16.1.17.-242 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-242} \
+    9.9999999999999997e-243
+test util-16.1.17.-241 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-241} \
+    9.9999999999999997e-242
+test util-16.1.17.-240 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-240} \
+    9.9999999999999997e-241
+test util-16.1.17.-239 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-239} \
+    1.0000000000000001e-239
+test util-16.1.17.-238 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-238} \
+    9.9999999999999999e-239
+test util-16.1.17.-237 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-237} \
+    9.9999999999999999e-238
+test util-16.1.17.-236 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-236} \
+    1e-236
+test util-16.1.17.-235 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-235} \
+    9.9999999999999996e-236
+test util-16.1.17.-234 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-234} \
+    9.9999999999999996e-235
+test util-16.1.17.-233 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-233} \
+    9.9999999999999996e-234
+test util-16.1.17.-232 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-232} \
+    1e-232
+test util-16.1.17.-231 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-231} \
+    9.9999999999999999e-232
+test util-16.1.17.-230 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-230} \
+    1e-230
+test util-16.1.17.-229 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-229} \
+    1.0000000000000001e-229
+test util-16.1.17.-228 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-228} \
+    1e-228
+test util-16.1.17.-227 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-227} \
+    9.9999999999999994e-228
+test util-16.1.17.-226 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-226} \
+    9.9999999999999992e-227
+test util-16.1.17.-225 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-225} \
+    9.9999999999999996e-226
+test util-16.1.17.-224 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-224} \
+    1e-224
+test util-16.1.17.-223 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-223} \
+    9.9999999999999997e-224
+test util-16.1.17.-222 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-222} \
+    1e-222
+test util-16.1.17.-221 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-221} \
+    1e-221
+test util-16.1.17.-220 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-220} \
+    9.9999999999999999e-221
+test util-16.1.17.-219 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-219} \
+    1e-219
+test util-16.1.17.-218 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-218} \
+    1e-218
+test util-16.1.17.-217 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-217} \
+    1.0000000000000001e-217
+test util-16.1.17.-216 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-216} \
+    1e-216
+test util-16.1.17.-215 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-215} \
+    1e-215
+test util-16.1.17.-214 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-214} \
+    9.9999999999999991e-215
+test util-16.1.17.-213 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-213} \
+    9.9999999999999995e-214
+test util-16.1.17.-212 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-212} \
+    9.9999999999999995e-213
+test util-16.1.17.-211 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-211} \
+    1.0000000000000001e-211
+test util-16.1.17.-210 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-210} \
+    1e-210
+test util-16.1.17.-209 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-209} \
+    1e-209
+test util-16.1.17.-208 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-208} \
+    1.0000000000000001e-208
+test util-16.1.17.-207 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-207} \
+    9.9999999999999993e-208
+test util-16.1.17.-206 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-206} \
+    1e-206
+test util-16.1.17.-205 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-205} \
+    1e-205
+test util-16.1.17.-204 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-204} \
+    1e-204
+test util-16.1.17.-203 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-203} \
+    1e-203
+test util-16.1.17.-202 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-202} \
+    1e-202
+test util-16.1.17.-201 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-201} \
+    9.9999999999999995e-202
+test util-16.1.17.-200 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-200} \
+    9.9999999999999998e-201
+test util-16.1.17.-199 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-199} \
+    9.9999999999999998e-200
+test util-16.1.17.-198 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-198} \
+    9.9999999999999991e-199
+test util-16.1.17.-197 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-197} \
+    9.9999999999999999e-198
+test util-16.1.17.-196 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-196} \
+    1e-196
+test util-16.1.17.-195 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-195} \
+    1.0000000000000001e-195
+test util-16.1.17.-194 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-194} \
+    1e-194
+test util-16.1.17.-193 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-193} \
+    1e-193
+test util-16.1.17.-192 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-192} \
+    1.0000000000000001e-192
+test util-16.1.17.-191 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-191} \
+    1e-191
+test util-16.1.17.-190 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-190} \
+    1e-190
+test util-16.1.17.-189 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-189} \
+    1.0000000000000001e-189
+test util-16.1.17.-188 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-188} \
+    9.9999999999999995e-189
+test util-16.1.17.-187 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-187} \
+    1e-187
+test util-16.1.17.-186 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-186} \
+    9.9999999999999991e-187
+test util-16.1.17.-185 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-185} \
+    9.9999999999999999e-186
+test util-16.1.17.-184 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-184} \
+    1.0000000000000001e-184
+test util-16.1.17.-183 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-183} \
+    1e-183
+test util-16.1.17.-182 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-182} \
+    1e-182
+test util-16.1.17.-181 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-181} \
+    1e-181
+test util-16.1.17.-180 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-180} \
+    1e-180
+test util-16.1.17.-179 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-179} \
+    1e-179
+test util-16.1.17.-178 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-178} \
+    9.9999999999999995e-179
+test util-16.1.17.-177 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-177} \
+    9.9999999999999995e-178
+test util-16.1.17.-176 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-176} \
+    1e-176
+test util-16.1.17.-175 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-175} \
+    1e-175
+test util-16.1.17.-174 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-174} \
+    1e-174
+test util-16.1.17.-173 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-173} \
+    1e-173
+test util-16.1.17.-172 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-172} \
+    1e-172
+test util-16.1.17.-171 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-171} \
+    9.9999999999999998e-172
+test util-16.1.17.-170 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-170} \
+    9.9999999999999998e-171
+test util-16.1.17.-169 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-169} \
+    1e-169
+test util-16.1.17.-168 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-168} \
+    1e-168
+test util-16.1.17.-167 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-167} \
+    1e-167
+test util-16.1.17.-166 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-166} \
+    1e-166
+test util-16.1.17.-165 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-165} \
+    1e-165
+test util-16.1.17.-164 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-164} \
+    9.9999999999999996e-165
+test util-16.1.17.-163 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-163} \
+    9.9999999999999992e-164
+test util-16.1.17.-162 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-162} \
+    9.9999999999999995e-163
+test util-16.1.17.-161 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-161} \
+    1e-161
+test util-16.1.17.-160 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-160} \
+    9.9999999999999999e-161
+test util-16.1.17.-159 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-159} \
+    9.9999999999999999e-160
+test util-16.1.17.-158 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-158} \
+    1.0000000000000001e-158
+test util-16.1.17.-157 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-157} \
+    9.9999999999999994e-158
+test util-16.1.17.-156 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-156} \
+    1e-156
+test util-16.1.17.-155 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-155} \
+    1e-155
+test util-16.1.17.-154 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-154} \
+    9.9999999999999997e-155
+test util-16.1.17.-153 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-153} \
+    1e-153
+test util-16.1.17.-152 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-152} \
+    1.0000000000000001e-152
+test util-16.1.17.-151 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-151} \
+    9.9999999999999994e-152
+test util-16.1.17.-150 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-150} \
+    1e-150
+test util-16.1.17.-149 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-149} \
+    9.9999999999999998e-150
+test util-16.1.17.-148 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-148} \
+    9.9999999999999994e-149
+test util-16.1.17.-147 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-147} \
+    9.9999999999999997e-148
+test util-16.1.17.-146 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-146} \
+    1e-146
+test util-16.1.17.-145 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-145} \
+    9.9999999999999991e-146
+test util-16.1.17.-144 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-144} \
+    9.9999999999999995e-145
+test util-16.1.17.-143 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-143} \
+    9.9999999999999995e-144
+test util-16.1.17.-142 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-142} \
+    1e-142
+test util-16.1.17.-141 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-141} \
+    1e-141
+test util-16.1.17.-140 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-140} \
+    9.9999999999999998e-141
+test util-16.1.17.-139 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-139} \
+    1e-139
+test util-16.1.17.-138 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-138} \
+    1.0000000000000001e-138
+test util-16.1.17.-137 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-137} \
+    9.9999999999999998e-138
+test util-16.1.17.-136 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-136} \
+    1e-136
+test util-16.1.17.-135 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-135} \
+    1e-135
+test util-16.1.17.-134 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-134} \
+    1e-134
+test util-16.1.17.-133 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-133} \
+    1.0000000000000001e-133
+test util-16.1.17.-132 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-132} \
+    9.9999999999999999e-133
+test util-16.1.17.-131 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-131} \
+    9.9999999999999999e-132
+test util-16.1.17.-130 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-130} \
+    1.0000000000000001e-130
+test util-16.1.17.-129 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-129} \
+    9.9999999999999993e-130
+test util-16.1.17.-128 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-128} \
+    1.0000000000000001e-128
+test util-16.1.17.-127 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-127} \
+    1e-127
+test util-16.1.17.-126 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-126} \
+    9.9999999999999995e-127
+test util-16.1.17.-125 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-125} \
+    1e-125
+test util-16.1.17.-124 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-124} \
+    9.9999999999999993e-125
+test util-16.1.17.-123 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-123} \
+    1.0000000000000001e-123
+test util-16.1.17.-122 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-122} \
+    1.0000000000000001e-122
+test util-16.1.17.-121 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-121} \
+    9.9999999999999998e-122
+test util-16.1.17.-120 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-120} \
+    9.9999999999999998e-121
+test util-16.1.17.-119 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-119} \
+    1e-119
+test util-16.1.17.-118 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-118} \
+    9.9999999999999999e-119
+test util-16.1.17.-117 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-117} \
+    1e-117
+test util-16.1.17.-116 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-116} \
+    9.9999999999999999e-117
+test util-16.1.17.-115 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-115} \
+    1.0000000000000001e-115
+test util-16.1.17.-114 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-114} \
+    1.0000000000000001e-114
+test util-16.1.17.-113 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-113} \
+    9.9999999999999998e-114
+test util-16.1.17.-112 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-112} \
+    9.9999999999999995e-113
+test util-16.1.17.-111 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-111} \
+    1.0000000000000001e-111
+test util-16.1.17.-110 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-110} \
+    1.0000000000000001e-110
+test util-16.1.17.-109 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-109} \
+    9.9999999999999999e-110
+test util-16.1.17.-108 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-108} \
+    1e-108
+test util-16.1.17.-107 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-107} \
+    1e-107
+test util-16.1.17.-106 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-106} \
+    9.9999999999999994e-107
+test util-16.1.17.-105 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-105} \
+    9.9999999999999997e-106
+test util-16.1.17.-104 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-104} \
+    9.9999999999999993e-105
+test util-16.1.17.-103 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-103} \
+    9.9999999999999996e-104
+test util-16.1.17.-102 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-102} \
+    9.9999999999999993e-103
+test util-16.1.17.-101 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-101} \
+    1.0000000000000001e-101
+test util-16.1.17.-100 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-100} \
+    1e-100
+test util-16.1.17.-99 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-99} \
+    1e-99
+test util-16.1.17.-98 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-98} \
+    9.9999999999999994e-99
+test util-16.1.17.-97 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-97} \
+    1e-97
+test util-16.1.17.-96 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-96} \
+    9.9999999999999991e-97
+test util-16.1.17.-95 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-95} \
+    9.9999999999999999e-96
+test util-16.1.17.-94 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-94} \
+    9.9999999999999996e-95
+test util-16.1.17.-93 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-93} \
+    9.999999999999999e-94
+test util-16.1.17.-92 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-92} \
+    9.9999999999999999e-93
+test util-16.1.17.-91 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-91} \
+    1e-91
+test util-16.1.17.-90 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-90} \
+    9.9999999999999999e-91
+test util-16.1.17.-89 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-89} \
+    1e-89
+test util-16.1.17.-88 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-88} \
+    9.9999999999999993e-89
+test util-16.1.17.-87 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-87} \
+    1e-87
+test util-16.1.17.-86 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-86} \
+    1.0000000000000001e-86
+test util-16.1.17.-85 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-85} \
+    9.9999999999999998e-86
+test util-16.1.17.-84 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-84} \
+    1e-84
+test util-16.1.17.-83 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-83} \
+    1e-83
+test util-16.1.17.-82 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-82} \
+    9.9999999999999996e-83
+test util-16.1.17.-81 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-81} \
+    9.9999999999999996e-82
+test util-16.1.17.-80 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-80} \
+    9.9999999999999996e-81
+test util-16.1.17.-79 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-79} \
+    1e-79
+test util-16.1.17.-78 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-78} \
+    1e-78
+test util-16.1.17.-77 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-77} \
+    9.9999999999999993e-78
+test util-16.1.17.-76 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-76} \
+    9.9999999999999993e-77
+test util-16.1.17.-75 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-75} \
+    9.9999999999999996e-76
+test util-16.1.17.-74 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-74} \
+    9.9999999999999996e-75
+test util-16.1.17.-73 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-73} \
+    1e-73
+test util-16.1.17.-72 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-72} \
+    9.9999999999999997e-73
+test util-16.1.17.-71 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-71} \
+    9.9999999999999992e-72
+test util-16.1.17.-70 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-70} \
+    1e-70
+test util-16.1.17.-69 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-69} \
+    9.9999999999999996e-70
+test util-16.1.17.-68 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-68} \
+    1.0000000000000001e-68
+test util-16.1.17.-67 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-67} \
+    9.9999999999999994e-68
+test util-16.1.17.-66 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-66} \
+    9.9999999999999998e-67
+test util-16.1.17.-65 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-65} \
+    9.9999999999999992e-66
+test util-16.1.17.-64 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-64} \
+    9.9999999999999997e-65
+test util-16.1.17.-63 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-63} \
+    1.0000000000000001e-63
+test util-16.1.17.-62 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-62} \
+    1e-62
+test util-16.1.17.-61 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-61} \
+    1e-61
+test util-16.1.17.-60 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-60} \
+    9.9999999999999997e-61
+test util-16.1.17.-59 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-59} \
+    1e-59
+test util-16.1.17.-58 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-58} \
+    1e-58
+test util-16.1.17.-57 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-57} \
+    9.9999999999999995e-58
+test util-16.1.17.-56 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-56} \
+    1e-56
+test util-16.1.17.-55 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-55} \
+    9.9999999999999999e-56
+test util-16.1.17.-54 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-54} \
+    1e-54
+test util-16.1.17.-53 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-53} \
+    1e-53
+test util-16.1.17.-52 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-52} \
+    1e-52
+test util-16.1.17.-51 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-51} \
+    1e-51
+test util-16.1.17.-50 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-50} \
+    1e-50
+test util-16.1.17.-49 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-49} \
+    9.9999999999999994e-50
+test util-16.1.17.-48 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-48} \
+    9.9999999999999997e-49
+test util-16.1.17.-47 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-47} \
+    9.9999999999999997e-48
+test util-16.1.17.-46 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-46} \
+    1e-46
+test util-16.1.17.-45 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-45} \
+    9.9999999999999998e-46
+test util-16.1.17.-44 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-44} \
+    9.9999999999999995e-45
+test util-16.1.17.-43 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-43} \
+    1.0000000000000001e-43
+test util-16.1.17.-42 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-42} \
+    1e-42
+test util-16.1.17.-41 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-41} \
+    1e-41
+test util-16.1.17.-40 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-40} \
+    9.9999999999999993e-41
+test util-16.1.17.-39 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-39} \
+    9.9999999999999993e-40
+test util-16.1.17.-38 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-38} \
+    9.9999999999999996e-39
+test util-16.1.17.-37 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-37} \
+    1.0000000000000001e-37
+test util-16.1.17.-36 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-36} \
+    9.9999999999999994e-37
+test util-16.1.17.-35 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-35} \
+    1e-35
+test util-16.1.17.-34 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-34} \
+    9.9999999999999993e-35
+test util-16.1.17.-33 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-33} \
+    1.0000000000000001e-33
+test util-16.1.17.-32 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-32} \
+    1.0000000000000001e-32
+test util-16.1.17.-31 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-31} \
+    1.0000000000000001e-31
+test util-16.1.17.-30 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-30} \
+    1.0000000000000001e-30
+test util-16.1.17.-29 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-29} \
+    9.9999999999999994e-30
+test util-16.1.17.-28 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-28} \
+    9.9999999999999997e-29
+test util-16.1.17.-27 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-27} \
+    1e-27
+test util-16.1.17.-26 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-26} \
+    1e-26
+test util-16.1.17.-25 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-25} \
+    1e-25
+test util-16.1.17.-24 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-24} \
+    9.9999999999999992e-25
+test util-16.1.17.-23 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-23} \
+    9.9999999999999996e-24
+test util-16.1.17.-22 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-22} \
+    1e-22
+test util-16.1.17.-21 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-21} \
+    9.9999999999999991e-22
+test util-16.1.17.-20 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-20} \
+    9.9999999999999995e-21
+test util-16.1.17.-19 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-19} \
+    9.9999999999999998e-20
+test util-16.1.17.-18 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-18} \
+    1.0000000000000001e-18
+test util-16.1.17.-17 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-17} \
+    1.0000000000000001e-17
+test util-16.1.17.-16 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-16} \
+    9.9999999999999998e-17
+test util-16.1.17.-15 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-15} \
+    1.0000000000000001e-15
+test util-16.1.17.-14 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-14} \
+    1e-14
+test util-16.1.17.-13 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-13} \
+    1e-13
+test util-16.1.17.-12 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-12} \
+    9.9999999999999998e-13
+test util-16.1.17.-11 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-11} \
+    9.9999999999999994e-12
+test util-16.1.17.-10 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-10} \
+    1e-10
+test util-16.1.17.-9 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-9} \
+    1.0000000000000001e-09
+test util-16.1.17.-8 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-8} \
+    1e-08
+test util-16.1.17.-7 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-7} \
+    9.9999999999999995e-08
+test util-16.1.17.-6 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-6} \
+    9.9999999999999995e-07
+test util-16.1.17.-5 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-5} \
+    1.0000000000000001e-05
+test util-16.1.17.-4 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-4} \
+    0.0001
+test util-16.1.17.-3 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-3} \
+    0.001
+test util-16.1.17.-2 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-2} \
+    0.01
+test util-16.1.17.-1 {8.4 compatible formatting of doubles} precision \
+    {expr 1e-1} \
+    0.10000000000000001
+test util-16.1.17.0 {8.4 compatible formatting of doubles} precision \
+    {expr 1e0} \
+    1.0
+test util-16.1.17.1 {8.4 compatible formatting of doubles} precision \
+    {expr 1e1} \
+    10.0
+test util-16.1.17.2 {8.4 compatible formatting of doubles} precision \
+    {expr 1e2} \
+    100.0
+test util-16.1.17.3 {8.4 compatible formatting of doubles} precision \
+    {expr 1e3} \
+    1000.0
+test util-16.1.17.4 {8.4 compatible formatting of doubles} precision \
+    {expr 1e4} \
+    10000.0
+test util-16.1.17.5 {8.4 compatible formatting of doubles} precision \
+    {expr 1e5} \
+    100000.0
+test util-16.1.17.6 {8.4 compatible formatting of doubles} precision \
+    {expr 1e6} \
+    1000000.0
+test util-16.1.17.7 {8.4 compatible formatting of doubles} precision \
+    {expr 1e7} \
+    10000000.0
+test util-16.1.17.8 {8.4 compatible formatting of doubles} precision \
+    {expr 1e8} \
+    100000000.0
+test util-16.1.17.9 {8.4 compatible formatting of doubles} precision \
+    {expr 1e9} \
+    1000000000.0
+test util-16.1.17.10 {8.4 compatible formatting of doubles} precision \
+    {expr 1e10} \
+    10000000000.0
+test util-16.1.17.11 {8.4 compatible formatting of doubles} precision \
+    {expr 1e11} \
+    100000000000.0
+test util-16.1.17.12 {8.4 compatible formatting of doubles} precision \
+    {expr 1e12} \
+    1000000000000.0
+test util-16.1.17.13 {8.4 compatible formatting of doubles} precision \
+    {expr 1e13} \
+    10000000000000.0
+test util-16.1.17.14 {8.4 compatible formatting of doubles} precision \
+    {expr 1e14} \
+    100000000000000.0
+test util-16.1.17.15 {8.4 compatible formatting of doubles} precision \
+    {expr 1e15} \
+    1000000000000000.0
+test util-16.1.17.16 {8.4 compatible formatting of doubles} precision \
+    {expr 1e16} \
+    10000000000000000.0
+test util-16.1.17.17 {8.4 compatible formatting of doubles} precision \
+    {expr 1e17} \
+    1e+17
+test util-16.1.17.18 {8.4 compatible formatting of doubles} precision \
+    {expr 1e18} \
+    1e+18
+test util-16.1.17.19 {8.4 compatible formatting of doubles} precision \
+    {expr 1e19} \
+    1e+19
+test util-16.1.17.20 {8.4 compatible formatting of doubles} precision \
+    {expr 1e20} \
+    1e+20
+test util-16.1.17.21 {8.4 compatible formatting of doubles} precision \
+    {expr 1e21} \
+    1e+21
+test util-16.1.17.22 {8.4 compatible formatting of doubles} precision \
+    {expr 1e22} \
+    1e+22
+test util-16.1.17.23 {8.4 compatible formatting of doubles} precision \
+    {expr 1e23} \
+    9.9999999999999992e+22
+test util-16.1.17.24 {8.4 compatible formatting of doubles} precision \
+    {expr 1e24} \
+    9.9999999999999998e+23
+test util-16.1.17.25 {8.4 compatible formatting of doubles} precision \
+    {expr 1e25} \
+    1.0000000000000001e+25
+test util-16.1.17.26 {8.4 compatible formatting of doubles} precision \
+    {expr 1e26} \
+    1e+26
+test util-16.1.17.27 {8.4 compatible formatting of doubles} precision \
+    {expr 1e27} \
+    1e+27
+test util-16.1.17.28 {8.4 compatible formatting of doubles} precision \
+    {expr 1e28} \
+    9.9999999999999996e+27
+test util-16.1.17.29 {8.4 compatible formatting of doubles} precision \
+    {expr 1e29} \
+    9.9999999999999991e+28
+test util-16.1.17.30 {8.4 compatible formatting of doubles} precision \
+    {expr 1e30} \
+    1e+30
+test util-16.1.17.31 {8.4 compatible formatting of doubles} precision \
+    {expr 1e31} \
+    9.9999999999999996e+30
+test util-16.1.17.32 {8.4 compatible formatting of doubles} precision \
+    {expr 1e32} \
+    1.0000000000000001e+32
+test util-16.1.17.33 {8.4 compatible formatting of doubles} precision \
+    {expr 1e33} \
+    9.9999999999999995e+32
+test util-16.1.17.34 {8.4 compatible formatting of doubles} precision \
+    {expr 1e34} \
+    9.9999999999999995e+33
+test util-16.1.17.35 {8.4 compatible formatting of doubles} precision \
+    {expr 1e35} \
+    9.9999999999999997e+34
+test util-16.1.17.36 {8.4 compatible formatting of doubles} precision \
+    {expr 1e36} \
+    1e+36
+test util-16.1.17.37 {8.4 compatible formatting of doubles} precision \
+    {expr 1e37} \
+    9.9999999999999995e+36
+test util-16.1.17.38 {8.4 compatible formatting of doubles} precision \
+    {expr 1e38} \
+    9.9999999999999998e+37
+test util-16.1.17.39 {8.4 compatible formatting of doubles} precision \
+    {expr 1e39} \
+    9.9999999999999994e+38
+test util-16.1.17.40 {8.4 compatible formatting of doubles} precision \
+    {expr 1e40} \
+    1e+40
+test util-16.1.17.41 {8.4 compatible formatting of doubles} precision \
+    {expr 1e41} \
+    1e+41
+test util-16.1.17.42 {8.4 compatible formatting of doubles} precision \
+    {expr 1e42} \
+    1e+42
+test util-16.1.17.43 {8.4 compatible formatting of doubles} precision \
+    {expr 1e43} \
+    1e+43
+test util-16.1.17.44 {8.4 compatible formatting of doubles} precision \
+    {expr 1e44} \
+    1.0000000000000001e+44
+test util-16.1.17.45 {8.4 compatible formatting of doubles} precision \
+    {expr 1e45} \
+    9.9999999999999993e+44
+test util-16.1.17.46 {8.4 compatible formatting of doubles} precision \
+    {expr 1e46} \
+    9.9999999999999999e+45
+test util-16.1.17.47 {8.4 compatible formatting of doubles} precision \
+    {expr 1e47} \
+    1e+47
+test util-16.1.17.48 {8.4 compatible formatting of doubles} precision \
+    {expr 1e48} \
+    1e+48
+test util-16.1.17.49 {8.4 compatible formatting of doubles} precision \
+    {expr 1e49} \
+    9.9999999999999995e+48
+test util-16.1.17.50 {8.4 compatible formatting of doubles} precision \
+    {expr 1e50} \
+    1.0000000000000001e+50
+test util-16.1.17.51 {8.4 compatible formatting of doubles} precision \
+    {expr 1e51} \
+    9.9999999999999999e+50
+test util-16.1.17.52 {8.4 compatible formatting of doubles} precision \
+    {expr 1e52} \
+    9.9999999999999999e+51
+test util-16.1.17.53 {8.4 compatible formatting of doubles} precision \
+    {expr 1e53} \
+    9.9999999999999999e+52
+test util-16.1.17.54 {8.4 compatible formatting of doubles} precision \
+    {expr 1e54} \
+    1.0000000000000001e+54
+test util-16.1.17.55 {8.4 compatible formatting of doubles} precision \
+    {expr 1e55} \
+    1e+55
+test util-16.1.17.56 {8.4 compatible formatting of doubles} precision \
+    {expr 1e56} \
+    1.0000000000000001e+56
+test util-16.1.17.57 {8.4 compatible formatting of doubles} precision \
+    {expr 1e57} \
+    1e+57
+test util-16.1.17.58 {8.4 compatible formatting of doubles} precision \
+    {expr 1e58} \
+    9.9999999999999994e+57
+test util-16.1.17.59 {8.4 compatible formatting of doubles} precision \
+    {expr 1e59} \
+    9.9999999999999997e+58
+test util-16.1.17.60 {8.4 compatible formatting of doubles} precision \
+    {expr 1e60} \
+    9.9999999999999995e+59
+test util-16.1.17.61 {8.4 compatible formatting of doubles} precision \
+    {expr 1e61} \
+    9.9999999999999995e+60
+test util-16.1.17.62 {8.4 compatible formatting of doubles} precision \
+    {expr 1e62} \
+    1e+62
+test util-16.1.17.63 {8.4 compatible formatting of doubles} precision \
+    {expr 1e63} \
+    1.0000000000000001e+63
+test util-16.1.17.64 {8.4 compatible formatting of doubles} precision \
+    {expr 1e64} \
+    1e+64
+test util-16.1.17.65 {8.4 compatible formatting of doubles} precision \
+    {expr 1e65} \
+    9.9999999999999999e+64
+test util-16.1.17.66 {8.4 compatible formatting of doubles} precision \
+    {expr 1e66} \
+    9.9999999999999995e+65
+test util-16.1.17.67 {8.4 compatible formatting of doubles} precision \
+    {expr 1e67} \
+    9.9999999999999998e+66
+test util-16.1.17.68 {8.4 compatible formatting of doubles} precision \
+    {expr 1e68} \
+    9.9999999999999995e+67
+test util-16.1.17.69 {8.4 compatible formatting of doubles} precision \
+    {expr 1e69} \
+    1.0000000000000001e+69
+test util-16.1.17.70 {8.4 compatible formatting of doubles} precision \
+    {expr 1e70} \
+    1.0000000000000001e+70
+test util-16.1.17.71 {8.4 compatible formatting of doubles} precision \
+    {expr 1e71} \
+    1e+71
+test util-16.1.17.72 {8.4 compatible formatting of doubles} precision \
+    {expr 1e72} \
+    9.9999999999999994e+71
+test util-16.1.17.73 {8.4 compatible formatting of doubles} precision \
+    {expr 1e73} \
+    9.9999999999999998e+72
+test util-16.1.17.74 {8.4 compatible formatting of doubles} precision \
+    {expr 1e74} \
+    9.9999999999999995e+73
+test util-16.1.17.75 {8.4 compatible formatting of doubles} precision \
+    {expr 1e75} \
+    9.9999999999999993e+74
+test util-16.1.17.76 {8.4 compatible formatting of doubles} precision \
+    {expr 1e76} \
+    1e+76
+test util-16.1.17.77 {8.4 compatible formatting of doubles} precision \
+    {expr 1e77} \
+    9.9999999999999998e+76
+test util-16.1.17.78 {8.4 compatible formatting of doubles} precision \
+    {expr 1e78} \
+    1e+78
+test util-16.1.17.79 {8.4 compatible formatting of doubles} precision \
+    {expr 1e79} \
+    9.9999999999999997e+78
+test util-16.1.17.80 {8.4 compatible formatting of doubles} precision \
+    {expr 1e80} \
+    1e+80
+test util-16.1.17.81 {8.4 compatible formatting of doubles} precision \
+    {expr 1e81} \
+    9.9999999999999992e+80
+test util-16.1.17.82 {8.4 compatible formatting of doubles} precision \
+    {expr 1e82} \
+    9.9999999999999996e+81
+test util-16.1.17.83 {8.4 compatible formatting of doubles} precision \
+    {expr 1e83} \
+    1e+83
+test util-16.1.17.84 {8.4 compatible formatting of doubles} precision \
+    {expr 1e84} \
+    1.0000000000000001e+84
+test util-16.1.17.85 {8.4 compatible formatting of doubles} precision \
+    {expr 1e85} \
+    1e+85
+test util-16.1.17.86 {8.4 compatible formatting of doubles} precision \
+    {expr 1e86} \
+    1e+86
+test util-16.1.17.87 {8.4 compatible formatting of doubles} precision \
+    {expr 1e87} \
+    9.9999999999999996e+86
+test util-16.1.17.88 {8.4 compatible formatting of doubles} precision \
+    {expr 1e88} \
+    9.9999999999999996e+87
+test util-16.1.17.89 {8.4 compatible formatting of doubles} precision \
+    {expr 1e89} \
+    9.9999999999999999e+88
+test util-16.1.17.90 {8.4 compatible formatting of doubles} precision \
+    {expr 1e90} \
+    9.9999999999999997e+89
+test util-16.1.17.91 {8.4 compatible formatting of doubles} precision \
+    {expr 1e91} \
+    1.0000000000000001e+91
+test util-16.1.17.92 {8.4 compatible formatting of doubles} precision \
+    {expr 1e92} \
+    1e+92
+test util-16.1.17.93 {8.4 compatible formatting of doubles} precision \
+    {expr 1e93} \
+    1e+93
+test util-16.1.17.94 {8.4 compatible formatting of doubles} precision \
+    {expr 1e94} \
+    1e+94
+test util-16.1.17.95 {8.4 compatible formatting of doubles} precision \
+    {expr 1e95} \
+    1e+95
+test util-16.1.17.96 {8.4 compatible formatting of doubles} precision \
+    {expr 1e96} \
+    1e+96
+test util-16.1.17.97 {8.4 compatible formatting of doubles} precision \
+    {expr 1e97} \
+    1.0000000000000001e+97
+test util-16.1.17.98 {8.4 compatible formatting of doubles} precision \
+    {expr 1e98} \
+    1e+98
+test util-16.1.17.99 {8.4 compatible formatting of doubles} precision \
+    {expr 1e99} \
+    9.9999999999999997e+98
+test util-16.1.17.100 {8.4 compatible formatting of doubles} precision \
+    {expr 1e100} \
+    1e+100
+test util-16.1.17.101 {8.4 compatible formatting of doubles} precision \
+    {expr 1e101} \
+    9.9999999999999998e+100
+test util-16.1.17.102 {8.4 compatible formatting of doubles} precision \
+    {expr 1e102} \
+    9.9999999999999998e+101
+test util-16.1.17.103 {8.4 compatible formatting of doubles} precision \
+    {expr 1e103} \
+    1e+103
+test util-16.1.17.104 {8.4 compatible formatting of doubles} precision \
+    {expr 1e104} \
+    1e+104
+test util-16.1.17.105 {8.4 compatible formatting of doubles} precision \
+    {expr 1e105} \
+    9.9999999999999994e+104
+test util-16.1.17.106 {8.4 compatible formatting of doubles} precision \
+    {expr 1e106} \
+    1.0000000000000001e+106
+test util-16.1.17.107 {8.4 compatible formatting of doubles} precision \
+    {expr 1e107} \
+    9.9999999999999997e+106
+test util-16.1.17.108 {8.4 compatible formatting of doubles} precision \
+    {expr 1e108} \
+    1e+108
+test util-16.1.17.109 {8.4 compatible formatting of doubles} precision \
+    {expr 1e109} \
+    9.9999999999999998e+108
+test util-16.1.17.110 {8.4 compatible formatting of doubles} precision \
+    {expr 1e110} \
+    1e+110
+test util-16.1.17.111 {8.4 compatible formatting of doubles} precision \
+    {expr 1e111} \
+    9.9999999999999996e+110
+test util-16.1.17.112 {8.4 compatible formatting of doubles} precision \
+    {expr 1e112} \
+    9.9999999999999993e+111
+test util-16.1.17.113 {8.4 compatible formatting of doubles} precision \
+    {expr 1e113} \
+    1e+113
+test util-16.1.17.114 {8.4 compatible formatting of doubles} precision \
+    {expr 1e114} \
+    1e+114
+test util-16.1.17.115 {8.4 compatible formatting of doubles} precision \
+    {expr 1e115} \
+    1e+115
+test util-16.1.17.116 {8.4 compatible formatting of doubles} precision \
+    {expr 1e116} \
+    1e+116
+test util-16.1.17.117 {8.4 compatible formatting of doubles} precision \
+    {expr 1e117} \
+    1.0000000000000001e+117
+test util-16.1.17.118 {8.4 compatible formatting of doubles} precision \
+    {expr 1e118} \
+    9.9999999999999997e+117
+test util-16.1.17.119 {8.4 compatible formatting of doubles} precision \
+    {expr 1e119} \
+    9.9999999999999994e+118
+test util-16.1.17.120 {8.4 compatible formatting of doubles} precision \
+    {expr 1e120} \
+    9.9999999999999998e+119
+test util-16.1.17.121 {8.4 compatible formatting of doubles} precision \
+    {expr 1e121} \
+    1e+121
+test util-16.1.17.122 {8.4 compatible formatting of doubles} precision \
+    {expr 1e122} \
+    1e+122
+test util-16.1.17.123 {8.4 compatible formatting of doubles} precision \
+    {expr 1e123} \
+    9.9999999999999998e+122
+test util-16.1.17.124 {8.4 compatible formatting of doubles} precision \
+    {expr 1e124} \
+    9.9999999999999995e+123
+test util-16.1.17.125 {8.4 compatible formatting of doubles} precision \
+    {expr 1e125} \
+    9.9999999999999992e+124
+test util-16.1.17.126 {8.4 compatible formatting of doubles} precision \
+    {expr 1e126} \
+    9.9999999999999992e+125
+test util-16.1.17.127 {8.4 compatible formatting of doubles} precision \
+    {expr 1e127} \
+    9.9999999999999995e+126
+test util-16.1.17.128 {8.4 compatible formatting of doubles} precision \
+    {expr 1e128} \
+    1.0000000000000001e+128
+test util-16.1.17.129 {8.4 compatible formatting of doubles} precision \
+    {expr 1e129} \
+    1e+129
+test util-16.1.17.130 {8.4 compatible formatting of doubles} precision \
+    {expr 1e130} \
+    1.0000000000000001e+130
+test util-16.1.17.131 {8.4 compatible formatting of doubles} precision \
+    {expr 1e131} \
+    9.9999999999999991e+130
+test util-16.1.17.132 {8.4 compatible formatting of doubles} precision \
+    {expr 1e132} \
+    9.9999999999999999e+131
+test util-16.1.17.133 {8.4 compatible formatting of doubles} precision \
+    {expr 1e133} \
+    1e+133
+test util-16.1.17.134 {8.4 compatible formatting of doubles} precision \
+    {expr 1e134} \
+    9.9999999999999992e+133
+test util-16.1.17.135 {8.4 compatible formatting of doubles} precision \
+    {expr 1e135} \
+    9.9999999999999996e+134
+test util-16.1.17.136 {8.4 compatible formatting of doubles} precision \
+    {expr 1e136} \
+    1.0000000000000001e+136
+test util-16.1.17.137 {8.4 compatible formatting of doubles} precision \
+    {expr 1e137} \
+    1e+137
+test util-16.1.17.138 {8.4 compatible formatting of doubles} precision \
+    {expr 1e138} \
+    1e+138
+test util-16.1.17.139 {8.4 compatible formatting of doubles} precision \
+    {expr 1e139} \
+    1e+139
+test util-16.1.17.140 {8.4 compatible formatting of doubles} precision \
+    {expr 1e140} \
+    1.0000000000000001e+140
+test util-16.1.17.141 {8.4 compatible formatting of doubles} precision \
+    {expr 1e141} \
+    1e+141
+test util-16.1.17.142 {8.4 compatible formatting of doubles} precision \
+    {expr 1e142} \
+    1.0000000000000001e+142
+test util-16.1.17.143 {8.4 compatible formatting of doubles} precision \
+    {expr 1e143} \
+    1e+143
+test util-16.1.17.144 {8.4 compatible formatting of doubles} precision \
+    {expr 1e144} \
+    1e+144
+test util-16.1.17.145 {8.4 compatible formatting of doubles} precision \
+    {expr 1e145} \
+    9.9999999999999999e+144
+test util-16.1.17.146 {8.4 compatible formatting of doubles} precision \
+    {expr 1e146} \
+    9.9999999999999993e+145
+test util-16.1.17.147 {8.4 compatible formatting of doubles} precision \
+    {expr 1e147} \
+    9.9999999999999998e+146
+test util-16.1.17.148 {8.4 compatible formatting of doubles} precision \
+    {expr 1e148} \
+    1e+148
+test util-16.1.17.149 {8.4 compatible formatting of doubles} precision \
+    {expr 1e149} \
+    1e+149
+test util-16.1.17.150 {8.4 compatible formatting of doubles} precision \
+    {expr 1e150} \
+    9.9999999999999998e+149
+test util-16.1.17.151 {8.4 compatible formatting of doubles} precision \
+    {expr 1e151} \
+    1e+151
+test util-16.1.17.152 {8.4 compatible formatting of doubles} precision \
+    {expr 1e152} \
+    1e+152
+test util-16.1.17.153 {8.4 compatible formatting of doubles} precision \
+    {expr 1e153} \
+    1e+153
+test util-16.1.17.154 {8.4 compatible formatting of doubles} precision \
+    {expr 1e154} \
+    1e+154
+test util-16.1.17.155 {8.4 compatible formatting of doubles} precision \
+    {expr 1e155} \
+    1e+155
+test util-16.1.17.156 {8.4 compatible formatting of doubles} precision \
+    {expr 1e156} \
+    9.9999999999999998e+155
+test util-16.1.17.157 {8.4 compatible formatting of doubles} precision \
+    {expr 1e157} \
+    9.9999999999999998e+156
+test util-16.1.17.158 {8.4 compatible formatting of doubles} precision \
+    {expr 1e158} \
+    9.9999999999999995e+157
+test util-16.1.17.159 {8.4 compatible formatting of doubles} precision \
+    {expr 1e159} \
+    9.9999999999999993e+158
+test util-16.1.17.160 {8.4 compatible formatting of doubles} precision \
+    {expr 1e160} \
+    1e+160
+test util-16.1.17.161 {8.4 compatible formatting of doubles} precision \
+    {expr 1e161} \
+    1e+161
+test util-16.1.17.162 {8.4 compatible formatting of doubles} precision \
+    {expr 1e162} \
+    9.9999999999999994e+161
+test util-16.1.17.163 {8.4 compatible formatting of doubles} precision \
+    {expr 1e163} \
+    9.9999999999999994e+162
+test util-16.1.17.164 {8.4 compatible formatting of doubles} precision \
+    {expr 1e164} \
+    1e+164
+test util-16.1.17.165 {8.4 compatible formatting of doubles} precision \
+    {expr 1e165} \
+    9.999999999999999e+164
+test util-16.1.17.166 {8.4 compatible formatting of doubles} precision \
+    {expr 1e166} \
+    9.9999999999999994e+165
+test util-16.1.17.167 {8.4 compatible formatting of doubles} precision \
+    {expr 1e167} \
+    1e+167
+test util-16.1.17.168 {8.4 compatible formatting of doubles} precision \
+    {expr 1e168} \
+    9.9999999999999993e+167
+test util-16.1.17.169 {8.4 compatible formatting of doubles} precision \
+    {expr 1e169} \
+    9.9999999999999993e+168
+test util-16.1.17.170 {8.4 compatible formatting of doubles} precision \
+    {expr 1e170} \
+    1e+170
+test util-16.1.17.171 {8.4 compatible formatting of doubles} precision \
+    {expr 1e171} \
+    9.9999999999999995e+170
+test util-16.1.17.172 {8.4 compatible formatting of doubles} precision \
+    {expr 1e172} \
+    1.0000000000000001e+172
+test util-16.1.17.173 {8.4 compatible formatting of doubles} precision \
+    {expr 1e173} \
+    1e+173
+test util-16.1.17.174 {8.4 compatible formatting of doubles} precision \
+    {expr 1e174} \
+    1.0000000000000001e+174
+test util-16.1.17.175 {8.4 compatible formatting of doubles} precision \
+    {expr 1e175} \
+    9.9999999999999994e+174
+test util-16.1.17.176 {8.4 compatible formatting of doubles} precision \
+    {expr 1e176} \
+    1e+176
+test util-16.1.17.177 {8.4 compatible formatting of doubles} precision \
+    {expr 1e177} \
+    1e+177
+test util-16.1.17.178 {8.4 compatible formatting of doubles} precision \
+    {expr 1e178} \
+    1.0000000000000001e+178
+test util-16.1.17.179 {8.4 compatible formatting of doubles} precision \
+    {expr 1e179} \
+    9.9999999999999998e+178
+test util-16.1.17.180 {8.4 compatible formatting of doubles} precision \
+    {expr 1e180} \
+    1e+180
+test util-16.1.17.181 {8.4 compatible formatting of doubles} precision \
+    {expr 1e181} \
+    9.9999999999999992e+180
+test util-16.1.17.182 {8.4 compatible formatting of doubles} precision \
+    {expr 1e182} \
+    1.0000000000000001e+182
+test util-16.1.17.183 {8.4 compatible formatting of doubles} precision \
+    {expr 1e183} \
+    9.9999999999999995e+182
+test util-16.1.17.184 {8.4 compatible formatting of doubles} precision \
+    {expr 1e184} \
+    1e+184
+test util-16.1.17.185 {8.4 compatible formatting of doubles} precision \
+    {expr 1e185} \
+    9.9999999999999998e+184
+test util-16.1.17.186 {8.4 compatible formatting of doubles} precision \
+    {expr 1e186} \
+    9.9999999999999998e+185
+test util-16.1.17.187 {8.4 compatible formatting of doubles} precision \
+    {expr 1e187} \
+    9.9999999999999991e+186
+test util-16.1.17.188 {8.4 compatible formatting of doubles} precision \
+    {expr 1e188} \
+    1e+188
+test util-16.1.17.189 {8.4 compatible formatting of doubles} precision \
+    {expr 1e189} \
+    1e+189
+test util-16.1.17.190 {8.4 compatible formatting of doubles} precision \
+    {expr 1e190} \
+    1.0000000000000001e+190
+test util-16.1.17.191 {8.4 compatible formatting of doubles} precision \
+    {expr 1e191} \
+    1.0000000000000001e+191
+test util-16.1.17.192 {8.4 compatible formatting of doubles} precision \
+    {expr 1e192} \
+    1e+192
+test util-16.1.17.193 {8.4 compatible formatting of doubles} precision \
+    {expr 1e193} \
+    1.0000000000000001e+193
+test util-16.1.17.194 {8.4 compatible formatting of doubles} precision \
+    {expr 1e194} \
+    9.9999999999999994e+193
+test util-16.1.17.195 {8.4 compatible formatting of doubles} precision \
+    {expr 1e195} \
+    9.9999999999999998e+194
+test util-16.1.17.196 {8.4 compatible formatting of doubles} precision \
+    {expr 1e196} \
+    9.9999999999999995e+195
+test util-16.1.17.197 {8.4 compatible formatting of doubles} precision \
+    {expr 1e197} \
+    9.9999999999999995e+196
+test util-16.1.17.198 {8.4 compatible formatting of doubles} precision \
+    {expr 1e198} \
+    1e+198
+test util-16.1.17.199 {8.4 compatible formatting of doubles} precision \
+    {expr 1e199} \
+    1.0000000000000001e+199
+test util-16.1.17.200 {8.4 compatible formatting of doubles} precision \
+    {expr 1e200} \
+    9.9999999999999997e+199
+test util-16.1.17.201 {8.4 compatible formatting of doubles} precision \
+    {expr 1e201} \
+    1e+201
+test util-16.1.17.202 {8.4 compatible formatting of doubles} precision \
+    {expr 1e202} \
+    9.999999999999999e+201
+test util-16.1.17.203 {8.4 compatible formatting of doubles} precision \
+    {expr 1e203} \
+    9.9999999999999999e+202
+test util-16.1.17.204 {8.4 compatible formatting of doubles} precision \
+    {expr 1e204} \
+    9.9999999999999999e+203
+test util-16.1.17.205 {8.4 compatible formatting of doubles} precision \
+    {expr 1e205} \
+    1e+205
+test util-16.1.17.206 {8.4 compatible formatting of doubles} precision \
+    {expr 1e206} \
+    1e+206
+test util-16.1.17.207 {8.4 compatible formatting of doubles} precision \
+    {expr 1e207} \
+    1e+207
+test util-16.1.17.208 {8.4 compatible formatting of doubles} precision \
+    {expr 1e208} \
+    9.9999999999999998e+207
+test util-16.1.17.209 {8.4 compatible formatting of doubles} precision \
+    {expr 1e209} \
+    1.0000000000000001e+209
+test util-16.1.17.210 {8.4 compatible formatting of doubles} precision \
+    {expr 1e210} \
+    9.9999999999999993e+209
+test util-16.1.17.211 {8.4 compatible formatting of doubles} precision \
+    {expr 1e211} \
+    9.9999999999999996e+210
+test util-16.1.17.212 {8.4 compatible formatting of doubles} precision \
+    {expr 1e212} \
+    9.9999999999999991e+211
+test util-16.1.17.213 {8.4 compatible formatting of doubles} precision \
+    {expr 1e213} \
+    9.9999999999999998e+212
+test util-16.1.17.214 {8.4 compatible formatting of doubles} precision \
+    {expr 1e214} \
+    9.9999999999999995e+213
+test util-16.1.17.215 {8.4 compatible formatting of doubles} precision \
+    {expr 1e215} \
+    9.9999999999999991e+214
+test util-16.1.17.216 {8.4 compatible formatting of doubles} precision \
+    {expr 1e216} \
+    1e+216
+test util-16.1.17.217 {8.4 compatible formatting of doubles} precision \
+    {expr 1e217} \
+    9.9999999999999996e+216
+test util-16.1.17.218 {8.4 compatible formatting of doubles} precision \
+    {expr 1e218} \
+    1.0000000000000001e+218
+test util-16.1.17.219 {8.4 compatible formatting of doubles} precision \
+    {expr 1e219} \
+    9.9999999999999997e+218
+test util-16.1.17.220 {8.4 compatible formatting of doubles} precision \
+    {expr 1e220} \
+    1e+220
+test util-16.1.17.221 {8.4 compatible formatting of doubles} precision \
+    {expr 1e221} \
+    1e+221
+test util-16.1.17.222 {8.4 compatible formatting of doubles} precision \
+    {expr 1e222} \
+    1e+222
+test util-16.1.17.223 {8.4 compatible formatting of doubles} precision \
+    {expr 1e223} \
+    1e+223
+test util-16.1.17.224 {8.4 compatible formatting of doubles} precision \
+    {expr 1e224} \
+    9.9999999999999997e+223
+test util-16.1.17.225 {8.4 compatible formatting of doubles} precision \
+    {expr 1e225} \
+    9.9999999999999993e+224
+test util-16.1.17.226 {8.4 compatible formatting of doubles} precision \
+    {expr 1e226} \
+    9.9999999999999996e+225
+test util-16.1.17.227 {8.4 compatible formatting of doubles} precision \
+    {expr 1e227} \
+    1.0000000000000001e+227
+test util-16.1.17.228 {8.4 compatible formatting of doubles} precision \
+    {expr 1e228} \
+    9.9999999999999992e+227
+test util-16.1.17.229 {8.4 compatible formatting of doubles} precision \
+    {expr 1e229} \
+    9.9999999999999999e+228
+test util-16.1.17.230 {8.4 compatible formatting of doubles} precision \
+    {expr 1e230} \
+    1.0000000000000001e+230
+test util-16.1.17.231 {8.4 compatible formatting of doubles} precision \
+    {expr 1e231} \
+    1.0000000000000001e+231
+test util-16.1.17.232 {8.4 compatible formatting of doubles} precision \
+    {expr 1e232} \
+    1.0000000000000001e+232
+test util-16.1.17.233 {8.4 compatible formatting of doubles} precision \
+    {expr 1e233} \
+    9.9999999999999997e+232
+test util-16.1.17.234 {8.4 compatible formatting of doubles} precision \
+    {expr 1e234} \
+    1e+234
+test util-16.1.17.235 {8.4 compatible formatting of doubles} precision \
+    {expr 1e235} \
+    1.0000000000000001e+235
+test util-16.1.17.236 {8.4 compatible formatting of doubles} precision \
+    {expr 1e236} \
+    1.0000000000000001e+236
+test util-16.1.17.237 {8.4 compatible formatting of doubles} precision \
+    {expr 1e237} \
+    9.9999999999999994e+236
+test util-16.1.17.238 {8.4 compatible formatting of doubles} precision \
+    {expr 1e238} \
+    1e+238
+test util-16.1.17.239 {8.4 compatible formatting of doubles} precision \
+    {expr 1e239} \
+    9.9999999999999999e+238
+test util-16.1.17.240 {8.4 compatible formatting of doubles} precision \
+    {expr 1e240} \
+    1e+240
+test util-16.1.17.241 {8.4 compatible formatting of doubles} precision \
+    {expr 1e241} \
+    1.0000000000000001e+241
+test util-16.1.17.242 {8.4 compatible formatting of doubles} precision \
+    {expr 1e242} \
+    1.0000000000000001e+242
+test util-16.1.17.243 {8.4 compatible formatting of doubles} precision \
+    {expr 1e243} \
+    1.0000000000000001e+243
+test util-16.1.17.244 {8.4 compatible formatting of doubles} precision \
+    {expr 1e244} \
+    1.0000000000000001e+244
+test util-16.1.17.245 {8.4 compatible formatting of doubles} precision \
+    {expr 1e245} \
+    1e+245
+test util-16.1.17.246 {8.4 compatible formatting of doubles} precision \
+    {expr 1e246} \
+    1.0000000000000001e+246
+test util-16.1.17.247 {8.4 compatible formatting of doubles} precision \
+    {expr 1e247} \
+    9.9999999999999995e+246
+test util-16.1.17.248 {8.4 compatible formatting of doubles} precision \
+    {expr 1e248} \
+    1e+248
+test util-16.1.17.249 {8.4 compatible formatting of doubles} precision \
+    {expr 1e249} \
+    9.9999999999999992e+248
+test util-16.1.17.250 {8.4 compatible formatting of doubles} precision \
+    {expr 1e250} \
+    9.9999999999999992e+249
+test util-16.1.17.251 {8.4 compatible formatting of doubles} precision \
+    {expr 1e251} \
+    1e+251
+test util-16.1.17.252 {8.4 compatible formatting of doubles} precision \
+    {expr 1e252} \
+    1.0000000000000001e+252
+test util-16.1.17.253 {8.4 compatible formatting of doubles} precision \
+    {expr 1e253} \
+    9.9999999999999994e+252
+test util-16.1.17.254 {8.4 compatible formatting of doubles} precision \
+    {expr 1e254} \
+    9.9999999999999994e+253
+test util-16.1.17.255 {8.4 compatible formatting of doubles} precision \
+    {expr 1e255} \
+    9.9999999999999999e+254
+test util-16.1.17.256 {8.4 compatible formatting of doubles} precision \
+    {expr 1e256} \
+    1e+256
+test util-16.1.17.257 {8.4 compatible formatting of doubles} precision \
+    {expr 1e257} \
+    1e+257
+test util-16.1.17.258 {8.4 compatible formatting of doubles} precision \
+    {expr 1e258} \
+    1.0000000000000001e+258
+test util-16.1.17.259 {8.4 compatible formatting of doubles} precision \
+    {expr 1e259} \
+    9.9999999999999993e+258
+test util-16.1.17.260 {8.4 compatible formatting of doubles} precision \
+    {expr 1e260} \
+    1.0000000000000001e+260
+test util-16.1.17.261 {8.4 compatible formatting of doubles} precision \
+    {expr 1e261} \
+    9.9999999999999993e+260
+test util-16.1.17.262 {8.4 compatible formatting of doubles} precision \
+    {expr 1e262} \
+    1e+262
+test util-16.1.17.263 {8.4 compatible formatting of doubles} precision \
+    {expr 1e263} \
+    1e+263
+test util-16.1.17.264 {8.4 compatible formatting of doubles} precision \
+    {expr 1e264} \
+    1e+264
+test util-16.1.17.265 {8.4 compatible formatting of doubles} precision \
+    {expr 1e265} \
+    1.0000000000000001e+265
+test util-16.1.17.266 {8.4 compatible formatting of doubles} precision \
+    {expr 1e266} \
+    1e+266
+test util-16.1.17.267 {8.4 compatible formatting of doubles} precision \
+    {expr 1e267} \
+    9.9999999999999997e+266
+test util-16.1.17.268 {8.4 compatible formatting of doubles} precision \
+    {expr 1e268} \
+    9.9999999999999997e+267
+test util-16.1.17.269 {8.4 compatible formatting of doubles} precision \
+    {expr 1e269} \
+    1e+269
+test util-16.1.17.270 {8.4 compatible formatting of doubles} precision \
+    {expr 1e270} \
+    1e+270
+test util-16.1.17.271 {8.4 compatible formatting of doubles} precision \
+    {expr 1e271} \
+    9.9999999999999995e+270
+test util-16.1.17.272 {8.4 compatible formatting of doubles} precision \
+    {expr 1e272} \
+    1.0000000000000001e+272
+test util-16.1.17.273 {8.4 compatible formatting of doubles} precision \
+    {expr 1e273} \
+    9.9999999999999995e+272
+test util-16.1.17.274 {8.4 compatible formatting of doubles} precision \
+    {expr 1e274} \
+    9.9999999999999992e+273
+test util-16.1.17.275 {8.4 compatible formatting of doubles} precision \
+    {expr 1e275} \
+    9.9999999999999996e+274
+test util-16.1.17.276 {8.4 compatible formatting of doubles} precision \
+    {expr 1e276} \
+    1.0000000000000001e+276
+test util-16.1.17.277 {8.4 compatible formatting of doubles} precision \
+    {expr 1e277} \
+    1e+277
+test util-16.1.17.278 {8.4 compatible formatting of doubles} precision \
+    {expr 1e278} \
+    9.9999999999999996e+277
+test util-16.1.17.279 {8.4 compatible formatting of doubles} precision \
+    {expr 1e279} \
+    1.0000000000000001e+279
+test util-16.1.17.280 {8.4 compatible formatting of doubles} precision \
+    {expr 1e280} \
+    1e+280
+test util-16.1.17.281 {8.4 compatible formatting of doubles} precision \
+    {expr 1e281} \
+    1e+281
+test util-16.1.17.282 {8.4 compatible formatting of doubles} precision \
+    {expr 1e282} \
+    1e+282
+test util-16.1.17.283 {8.4 compatible formatting of doubles} precision \
+    {expr 1e283} \
+    9.9999999999999996e+282
+test util-16.1.17.284 {8.4 compatible formatting of doubles} precision \
+    {expr 1e284} \
+    1.0000000000000001e+284
+test util-16.1.17.285 {8.4 compatible formatting of doubles} precision \
+    {expr 1e285} \
+    9.9999999999999998e+284
+test util-16.1.17.286 {8.4 compatible formatting of doubles} precision \
+    {expr 1e286} \
+    1e+286
+test util-16.1.17.287 {8.4 compatible formatting of doubles} precision \
+    {expr 1e287} \
+    1.0000000000000001e+287
+test util-16.1.17.288 {8.4 compatible formatting of doubles} precision \
+    {expr 1e288} \
+    1e+288
+test util-16.1.17.289 {8.4 compatible formatting of doubles} precision \
+    {expr 1e289} \
+    1.0000000000000001e+289
+test util-16.1.17.290 {8.4 compatible formatting of doubles} precision \
+    {expr 1e290} \
+    1.0000000000000001e+290
+test util-16.1.17.291 {8.4 compatible formatting of doubles} precision \
+    {expr 1e291} \
+    9.9999999999999996e+290
+test util-16.1.17.292 {8.4 compatible formatting of doubles} precision \
+    {expr 1e292} \
+    1e+292
+test util-16.1.17.293 {8.4 compatible formatting of doubles} precision \
+    {expr 1e293} \
+    9.9999999999999992e+292
+test util-16.1.17.294 {8.4 compatible formatting of doubles} precision \
+    {expr 1e294} \
+    1.0000000000000001e+294
+test util-16.1.17.295 {8.4 compatible formatting of doubles} precision \
+    {expr 1e295} \
+    9.9999999999999998e+294
+test util-16.1.17.296 {8.4 compatible formatting of doubles} precision \
+    {expr 1e296} \
+    9.9999999999999998e+295
+test util-16.1.17.297 {8.4 compatible formatting of doubles} precision \
+    {expr 1e297} \
+    1e+297
+test util-16.1.17.298 {8.4 compatible formatting of doubles} precision \
+    {expr 1e298} \
+    9.9999999999999996e+297
+test util-16.1.17.299 {8.4 compatible formatting of doubles} precision \
+    {expr 1e299} \
+    1.0000000000000001e+299
+test util-16.1.17.300 {8.4 compatible formatting of doubles} precision \
+    {expr 1e300} \
+    1.0000000000000001e+300
+test util-16.1.17.301 {8.4 compatible formatting of doubles} precision \
+    {expr 1e301} \
+    1.0000000000000001e+301
+test util-16.1.17.302 {8.4 compatible formatting of doubles} precision \
+    {expr 1e302} \
+    1.0000000000000001e+302
+test util-16.1.17.303 {8.4 compatible formatting of doubles} precision \
+    {expr 1e303} \
+    1e+303
+test util-16.1.17.304 {8.4 compatible formatting of doubles} precision \
+    {expr 1e304} \
+    9.9999999999999994e+303
+test util-16.1.17.305 {8.4 compatible formatting of doubles} precision \
+    {expr 1e305} \
+    9.9999999999999994e+304
+test util-16.1.17.306 {8.4 compatible formatting of doubles} precision \
+    {expr 1e306} \
+    1e+306
+test util-16.1.17.307 {8.4 compatible formatting of doubles} precision \
+    {expr 1e307} \
+    9.9999999999999999e+306
 
 test util-17.1 {bankers' rounding [Bug 3349507]} {ieeeFloatingPoint} {
     set r {}
     foreach {input} {
 	0x1ffffffffffffc000
@@ -2179,13 +4126,17 @@
 } {65536 65536}
 
 test util-18.12 {Tcl_ObjPrintf} {testprint} {
     testprint "%I64d %Id" 65537
 } {65537 65537}
+
+if {[catch {set ::tcl_precision $saved_precision}]} {
+    unset ::tcl_precision
+}
 
 # cleanup
 ::tcltest::cleanupTests
 return
 
 # Local Variables:
 # mode: tcl
 # End:

Index: tests/var.test
==================================================================
--- tests/var.test
+++ tests/var.test
@@ -267,15 +267,14 @@
     set a 456
     namespace eval test_ns_var {
 	catch {unset ::test_ns_var::vv}
 	proc p {} {
 	    # create namespace var vv linked to global a
-	    testupvar 2 a {} vv namespace
+	    testupvar 1 a {} vv namespace
 	}
 	p
     }
-    # Modified: that should create a global var according to the docs!
     list $test_ns_var::vv [set test_ns_var::vv 123] $a
 } -result {456 123 123}
 test var-3.5 {MakeUpvar, no call frame so my var will be in global :: ns} -setup {
     catch {unset aaaaa}
     catch {unset xxxxx}
@@ -463,11 +462,11 @@
     set a ""
     set five 555
     set six  666
     namespace eval test_ns_var {
         variable five 5 six
-        lappend ::a $five
+        lappend a $five
     }
     lappend a $test_ns_var::five \
         [set test_ns_var::six 6] [set test_ns_var::six] $six
 } -cleanup {
     catch {unset five}
@@ -490,13 +489,13 @@
 } -result {can't define "sev:::en": parent namespace doesn't exist}
 test var-7.8 {Tcl_VariableObjCmd, if var already exists and no value is given, leave value unchanged} {
     set a ""
     namespace eval test_ns_var {
         variable eight 8
-        lappend ::a $eight
+        lappend a $eight
         variable eight
-        lappend ::a $eight
+        lappend a $eight
     }
     set a
 } {8 8}
 test var-7.9 {Tcl_VariableObjCmd, mark as namespace var so var persists until namespace is destroyed or var is unset} -setup {
     catch {namespace delete test_ns_var2}

Index: tests/while-old.test
==================================================================
--- tests/while-old.test
+++ tests/while-old.test
@@ -90,11 +90,11 @@
     list $err $msg
 } {1 {wrong # args: should be "while test command"}}
 test while-old-4.4 {errors in while loops} {
     set err [catch {while {"a"+"b"} {error "loop aborted"}} msg]
     list $err $msg
-} {1 {can't use non-numeric string "a" as operand of "+"}}
+} {1 {can't use non-numeric string as operand of "+"}}
 test while-old-4.5 {errors in while loops} {
     catch {unset x}
     set x 1
     set err [catch {while {$x} {set x foo}} msg]
     list $err $msg

Index: tests/while.test
==================================================================
--- tests/while.test
+++ tests/while.test
@@ -30,11 +30,11 @@
 } -cleanup {
     unset i
 } -match glob -result {*"while {$i<} break"}
 test while-1.3 {TclCompileWhileCmd: error in test expression} -body {
     while {"a"+"b"} {error "loop aborted"}
-} -returnCodes error -result {can't use non-numeric string "a" as operand of "+"}
+} -returnCodes error -result {can't use non-numeric string as operand of "+"}
 test while-1.4 {TclCompileWhileCmd: multiline test expr} -body {
     set value 1
     while {($tcl_platform(platform) != "foobar1") && \
 	    ($tcl_platform(platform) != "foobar2")} {
         incr value
@@ -341,11 +341,11 @@
     unset i z
 } -result {*"$z {$i<} {set x 1}"}
 test while-4.4 {while (not compiled): error in test expression} -body {
     set z while
     $z {"a"+"b"} {error "loop aborted"}
-} -returnCodes error -result {can't use non-numeric string "a" as operand of "+"}
+} -returnCodes error -result {can't use non-numeric string as operand of "+"}
 test while-4.5 {while (not compiled): multiline test expr} -body {
     set value 1
     set z while
     $z {($tcl_platform(platform) != "foobar1") && \
 	    ($tcl_platform(platform) != "foobar2")} {

Index: tests/winFCmd.test
==================================================================
--- tests/winFCmd.test
+++ tests/winFCmd.test
@@ -26,10 +26,11 @@
 testConstraint testfile       [llength [info commands testfile]]
 testConstraint testchmod      [llength [info commands testchmod]]
 testConstraint cdrom 0
 testConstraint exdev 0
 testConstraint longFileNames 0
+testConstraint knownMsvcBug [expr {![info exists ::env(TRAVIS_OS_NAME)] || ![string match windows $::env(TRAVIS_OS_NAME)]}]
 
 proc createfile {file {string a}} {
     set f [open $file w]
     puts -nonewline $f $string
     close $f
@@ -90,12 +91,17 @@
 }
 
 # NB: filename is chosen to be short but unlikely to clash with other apps
 if {[file exists c:/] && [file exists d:/]} {
     catch {file delete d:/TclTmpF.1}
-    if {[catch {createfile d:/TclTmpF.1 {}}] == 0} {
-	file delete d:/TclTmpF.1
+    catch {file delete d:/TclTmpD.1}
+    catch {file delete c:/TclTmpC.1}
+    if {![catch {createfile d:/TclTmpF.1 {}}] && [file isfile d:/TclTmpF.1]
+	&& ![catch {file mkdir d:/TclTmpD.1}] && [file isdirectory d:/TclTmpD.1]
+	&& ![catch {file mkdir c:/TclTmpC.1}] && [file isdirectory c:/TclTmpC.1]
+    } {
+	file delete d:/TclTmpF.1 d:/TclTmpD.1 c:/TclTmpC.1
 	testConstraint exdev 1
     }
 }
 
 file delete -force -- td1
@@ -171,16 +177,16 @@
     file mkdir td1
     createfile tf1
     testfile mv td1 tf1
 } -returnCodes error -result ENOTDIR
 test winFCmd-1.10 {TclpRenameFile: errno: EXDEV} -setup {
-    file delete -force d:/tf1
+    file delete -force d:/TclTmpD.1
 } -constraints {win exdev testfile} -body {
-    file mkdir c:/tf1
-    testfile mv c:/tf1 d:/tf1
+    file mkdir c:/TclTmpC.1
+    testfile mv c:/TclTmpC.1 d:/TclTmpD.1
 } -cleanup {
-    file delete -force c:/tf1
+    file delete -force c:/TclTmpC.1
 } -returnCodes error -result EXDEV
 test winFCmd-1.11 {TclpRenameFile: errno: EACCES} -setup {
     cleanup
 } -constraints {win testfile} -body {
     set fd [open tf1 w]
@@ -314,19 +320,19 @@
     testfile mv td1 td2
     list [file exists td1] [file exists td2] [file exists td2/td2]
 } -result {0 1 1}
 test winFCmd-1.33 {TclpRenameFile: After removing dst dir, MoveFile fails} \
 	-constraints {win exdev testfile testchmod} -body {
-    file mkdir d:/td1
-    testchmod 0 d:/td1
-    file mkdir c:/tf1
-    catch {testfile mv c:/tf1 d:/td1} msg
-    list $msg [file writable d:/td1]
+    file mkdir d:/TclTmpD.1
+    testchmod 0 d:/TclTmpD.1
+    file mkdir c:/TclTmpC.1
+    catch {testfile mv c:/TclTmpC.1 d:/TclTmpD.1} msg
+    list $msg [file writable d:/TclTmpD.1]
 } -cleanup {
-    catch {testchmod 0o666 d:/td1}
-    file delete d:/td1
-    file delete -force c:/tf1
+    catch {testchmod 0o666 d:/TclTmpD.1}
+    file delete d:/TclTmpD.1
+    file delete -force c:/TclTmpC.1
 } -result {EXDEV 0}
 test winFCmd-1.34 {TclpRenameFile: src is dir, dst is not} -setup {
     cleanup
 } -constraints {win testfile} -body {
     file mkdir td1
@@ -386,11 +392,11 @@
     }
 }
 
 test winFCmd-1.38 {TclpRenameFile: check rename of conflicting inodes} -setup {
     cleanup
-} -constraints {win winNonZeroInodes} -body {
+} -constraints {win winNonZeroInodes knownMsvcBug} -body {
     file mkdir td1
     foreach {a b} [MakeFiles td1] break
     file rename -force $a $b
     file exists $a
 } -cleanup {
@@ -631,11 +637,11 @@
     cleanup
 } -result {directory directory}
 
 test winFCmd-6.1 {TclpRemoveDirectory: errno: EACCES} -setup {
     cleanup
-} -constraints {winVista testfile testchmod} -body {
+} -constraints {winVista testfile testchmod knownMsvcBug} -body {
     file mkdir td1
     testchmod 0 td1
     testfile rmdir td1
     file exists td1
 } -returnCodes error -cleanup {
@@ -685,11 +691,11 @@
     createfile tf1
     list [catch {testfile rmdir tf1} msg] [file tail $msg]
 } -result {1 {tf1 ENOTDIR}}
 test winFCmd-6.9 {TclpRemoveDirectory: errno == EACCES} -setup {
     cleanup
-} -constraints {winVista testfile testchmod} -body {
+} -constraints {winVista testfile testchmod knownMsvcBug} -body {
     file mkdir td1
     testchmod 0 td1
     testfile rmdir td1
     file exists td1
 } -returnCodes error -cleanup {
@@ -703,11 +709,11 @@
     # WinXP returns EEXIST, WinNT seems to return EACCES.  No policy
     # decision has been made as to which is correct.
 } -returnCodes error -match regexp -result {^/ E(ACCES|EXIST)$}
 test winFCmd-6.13 {TclpRemoveDirectory: write-protected} -setup {
     cleanup
-} -constraints {winVista testfile testchmod} -body {
+} -constraints {winVista testfile testchmod knownMsvcBug} -body {
     file mkdir td1
     testchmod 0 td1
     testfile rmdir td1
     file exists td1
 } -cleanup {
@@ -932,11 +938,11 @@
     createfile td1/tf1
     testfile rmdir -force td1
 } -result {}
 test winFCmd-9.3 {TraversalDelete: DOTREE_PRED} -setup {
     cleanup
-} -constraints {winVista testfile testchmod} -body {
+} -constraints {winVista testfile testchmod knownMsvcBug} -body {
     file mkdir td1/td2
     testchmod 0 td1
     testfile rmdir -force td1
     file exists td1
 } -cleanup {
@@ -1046,17 +1052,17 @@
 } -result {./td1}
 test winFCmd-12.5 {ConvertFileNameFormat: absolute path} -body {
     list [file attributes / -longname] [file attributes \\ -longname]
 } -constraints {win} -result {/ /}
 test winFCmd-12.6 {ConvertFileNameFormat: absolute path with drive} -setup {
-    catch {file delete -force -- c:/td1}
+    catch {file delete -force -- c:/TclTmpC.1}
 } -constraints {win winXP} -body {
-    createfile c:/td1 {}
-    string tolower [file attributes c:/td1 -longname]
+    createfile c:/TclTmpC.1 {}
+    string tolower [file attributes c:/TclTmpC.1 -longname]
 } -cleanup {
-    file delete -force -- c:/td1
-} -result {c:/td1}
+    file delete -force -- c:/TclTmpC.1
+} -result [string tolower {c:/TclTmpC.1}]
 test winFCmd-12.6.2 {ConvertFileNameFormat: absolute path with drive (in temp folder)} -setup {
     catch {file delete -force -- $::env(TEMP)/td1}
 } -constraints {win} -body {
     createfile $::env(TEMP)/td1 {}
     string equal [string tolower [file attributes $::env(TEMP)/td1 -longname]] \

Index: tests/winTime.test
==================================================================
--- tests/winTime.test
+++ tests/winTime.test
@@ -17,10 +17,11 @@
 
 ::tcltest::loadTestedCommands
 catch [list package require -exact Tcltest [info patchlevel]]
 
 testConstraint testwinclock [llength [info commands testwinclock]]
+testConstraint knownMsvcBug [expr {![info exists ::env(TRAVIS_OS_NAME)] || ![string match windows $::env(TRAVIS_OS_NAME)]}]
 
 # The next two tests will crash on Windows if the check for negative
 # clock values is not done properly.
 
 test winTime-1.1 {TclpGetDate} {win} {
@@ -38,21 +39,21 @@
 
 # Next test tries to make sure that the Tcl clock stays in step
 # with the Windows clock.  30 sec really isn't enough,
 # but how much time does a tester have patience for?
 
-test winTime-2.1 {Synchronization of Tcl and Windows clocks} {testwinclock} {
+test winTime-2.1 {Synchronization of Tcl and Windows clocks} {testwinclock knownMsvcBug} {
     # May fail due to OS/hardware discrepancies.  See:
     # http://support.microsoft.com/default.aspx?scid=kb;en-us;274323
     set failed {}
     set ok 1
     foreach start_sec [testwinclock] break
     while { 1 } {
 	foreach { sys_sec sys_usec tcl_sec tcl_usec } [testwinclock] break
 	set diff [expr { $tcl_sec - $sys_sec
 			 + 1.0e-6 * ( $tcl_usec - $sys_usec ) }]
-        if { abs($diff) > 0.06 } {
+        if { abs($diff) > 0.1 } {
 	    set failed "Tcl clock differs from system clock by $diff sec"
 	    break
 	} else {
 	    testwinsleep 1
 	}

Index: tests/zipfs.test
==================================================================
--- tests/zipfs.test
+++ tests/zipfs.test
@@ -43,11 +43,11 @@
     #
     # Hack the environment to pretend we did pull tcl_library from a zip
     # archive
     ###
     set tclzip [file join $CWD [::tcl::pkgconfig get zipfile,runtime]]
-    testConstraint zipfslib [file exists $tclzip]
+    testConstraint zipfslib [file isfile $tclzip]
     if {[testConstraint zipfslib]} {
         zipfs mount /lib/tcl $tclzip
         set ::tcl_library ${ziproot}lib/tcl/tcl_library
     }
 }

Index: tools/README
==================================================================
--- tools/README
+++ tools/README
@@ -10,11 +10,11 @@
 
 Generating HTML files.
 The tcl-tk-man-html.tcl script from Robert Critchlow
 generates a nice set of HTML with good cross references.
 Use it like
-    tclsh tcl-tk-man-html.tcl --htmldir=/tmp/tcl9.0
+    tclsh tcl-tk-man-html.tcl --htmldir=/tmp/tcl8.2
 This script is very picky about the organization of man pages,
 effectively acting as a style enforcer.
 
 Generating Windows Help Files:
 1) Build tcl in the ../unix directory

Index: tools/checkLibraryDoc.tcl
==================================================================
--- tools/checkLibraryDoc.tcl
+++ tools/checkLibraryDoc.tcl
@@ -1,11 +1,11 @@
 # checkLibraryDoc.tcl --
 #
 # This script attempts to determine what APIs exist in the source base that
 # have not been documented.  By grepping through all of the doc/*.3 man
 # pages, looking for "Pkg_*" (e.g., Tcl_ or Tk_), and comparing this list
-# against the list of Pkg_ APIs found in the source (e.g., tcl9.0/*/*.[ch])
+# against the list of Pkg_ APIs found in the source (e.g., tcl8.2/*/*.[ch])
 # we create six lists:
 #      1) APIs in Source not in Docs.
 #      2) APIs in Docs not in Source.
 #      3) Internal APIs and structs.
 #      4) Misc APIs and structs that we are not documenting.
@@ -48,10 +48,12 @@
     Tcl_ThreadId \
     Tcl_Time \
     Tcl_TimerToken \
     Tcl_Token \
     Tcl_Trace \
+    Tcl_Value \
+    Tcl_ValueType \
     Tcl_Var \
     Tk_3DBorder \
     Tk_ArgvInfo \
     Tk_BindingTable \
     Tk_Canvas \
@@ -102,11 +104,11 @@
 
     set len [llength $argv]
     if {($len != 2) && ($len != 3)} {
 	puts "usage: $argv0 pkgName pkgDir \[outFile\]"
 	puts "   pkgName == Tcl,Tk"
-	puts "   pkgDir  == /home/surles/cvs/tcl9.0"
+	puts "   pkgDir  == /home/surles/cvs/tcl8.2"
 	exit 1
     }
 
     set pkg [lindex $argv 0]
     set dir [lindex $argv 1]

Index: tools/configure
==================================================================
--- tools/configure
+++ tools/configure
@@ -1679,11 +1679,11 @@
 #--------------------------------------------------------------------
 #       See if there was a command-line option for where Tcl is;  if
 #       not, assume that its top-level directory is a sibling of ours.
 #--------------------------------------------------------------------
 
-DEF_VER=9.0
+DEF_VER=8.7
 
 
 # Check whether --with-tcl was given.
 if test "${with_tcl+set}" = set; then :
   withval=$with_tcl; TCL_BIN_DIR=$withval

Index: tools/configure.ac
==================================================================
--- tools/configure.ac
+++ tools/configure.ac
@@ -9,11 +9,11 @@
 #--------------------------------------------------------------------
 #       See if there was a command-line option for where Tcl is;  if
 #       not, assume that its top-level directory is a sibling of ours.
 #--------------------------------------------------------------------
 
-DEF_VER=9.0
+DEF_VER=8.7
 
 AC_ARG_WITH(tcl, [  --with-tcl=DIR          use Tcl $DEF_VER binaries from DIR], TCL_BIN_DIR=$withval, TCL_BIN_DIR=`cd ../../tcl$DEF_VER$TCL_PATCH_LEVEL/unix; pwd`)
 if test ! -d $TCL_BIN_DIR; then
     AC_MSG_ERROR(Tcl directory $TCL_BIN_DIR doesn't exist)
 fi

Index: tools/tcl.hpj.in
==================================================================
--- tools/tcl.hpj.in
+++ tools/tcl.hpj.in
@@ -3,13 +3,13 @@
 [OPTIONS]
 HCW=0
 LCID=0x409 0x0 0x0 ;English (United States)
 REPORT=Yes
 TITLE=Tcl/Tk Reference Manual
-CNT=tcl90.cnt
+CNT=tcl87.cnt
 COPYRIGHT=Copyright © 2000 Ajuba Solutions
-HLP=tcl90.hlp
+HLP=tcl87.hlp
 
 [FILES]
 tcl.rtf
 
 [WINDOWS]

Index: tools/tcltk-man2html.tcl
==================================================================
--- tools/tcltk-man2html.tcl
+++ tools/tcltk-man2html.tcl
@@ -2,11 +2,11 @@
 
 if {[catch {package require Tcl 8.6-} msg]} {
     puts stderr "ERROR: $msg"
     puts stderr "If running this script from 'make html', set the\
 	NATIVE_TCLSH environment\nvariable to point to an installed\
-	tclsh9.0 (or the equivalent tclsh90.exe\non Windows)."
+	tclsh8.7 (or the equivalent tclsh87.exe\non Windows)."
     exit 1
 }
 
 # Convert Ousterhout format man pages into highly crosslinked hypertext.
 #
@@ -20,11 +20,11 @@
 # try to use this, you'll be very much on your own.
 #
 # Copyright (c) 1995-1997 Roger E. Critchlow Jr
 # Copyright (c) 2004-2010 Donal K. Fellows
 
-set ::Version "50/9.0"
+set ::Version "50/8.7"
 set ::CSSFILE "docs.css"
 
 ##
 ## Source the utility functions that provide most of the
 ## implementation of the transformation from nroff to html.

Index: unix/Makefile.in
==================================================================
--- unix/Makefile.in
+++ unix/Makefile.in
@@ -26,10 +26,11 @@
 exec_prefix		= @exec_prefix@
 bindir			= @bindir@
 libdir			= @libdir@
 includedir		= @includedir@
 datarootdir		= @datarootdir@
+runstatedir		= @runstatedir@
 mandir			= @mandir@
 
 # The following definition can be set to non-null for special systems like AFS
 # with replication. It allows the pathnames used for installation to be
 # different than those used for actually reference files at run-time.
@@ -123,11 +124,11 @@
 ENV_FLAGS =
 #ENV_FLAGS = -DTclSetEnv=setenv -DTcl_PutEnv=putenv -DTclUnsetEnv=unsetenv
 
 # To enable memory debugging, call configure with --enable-symbols=mem
 # Warning: if you enable memory debugging, you must do it *everywhere*,
-# including all the code that calls Tcl, and you must use Tcl_Alloc and Tcl_Free
+# including all the code that calls Tcl, and you must use ckalloc and ckfree
 # everywhere instead of malloc and free.
 
 TCL_STUB_LIB_FILE	= @TCL_STUB_LIB_FILE@
 #TCL_STUB_LIB_FILE	= libtclstub.a
 
@@ -923,11 +924,11 @@
 	    if [ ! -d "$$i" ] ; then \
 		echo "Making directory $$i"; \
 		$(INSTALL_DATA_DIR) "$$i"; \
 	    fi; \
 	done
-	@for i in opt0.4 encoding ../tcl9 ../tcl9/9.0  ../tcl9/9.0/platform ; do \
+	@for i in opt0.4 encoding ../tcl8 ../tcl8/8.4  ../tcl8/8.4/platform ../tcl8/8.5 ../tcl8/8.6 ../tcl8/8.7 ; do \
 	    if [ ! -d "$(SCRIPT_INSTALL_DIR)"/$$i ] ; then \
 		echo "Making directory $(SCRIPT_INSTALL_DIR)/$$i"; \
 		$(INSTALL_DATA_DIR) "$(SCRIPT_INSTALL_DIR)"/$$i; \
 	    fi; \
 	done
@@ -936,27 +937,27 @@
 		$(UNIX_DIR)/tclAppInit.c @LDAIX_SRC@ @DTRACE_SRC@ ; do \
 	    $(INSTALL_DATA) $$i "$(SCRIPT_INSTALL_DIR)"; \
 	done
 	@echo "Installing package http 2.9.0 as a Tcl Module"
 	@$(INSTALL_DATA) $(TOP_DIR)/library/http/http.tcl \
-		"$(MODULE_INSTALL_DIR)"/tcl9/9.0/http-2.9.0.tm
+		"$(MODULE_INSTALL_DIR)"/tcl8/8.6/http-2.9.0.tm
 	@echo "Installing package opt0.4 files to $(SCRIPT_INSTALL_DIR)/opt0.4/"
 	@for i in $(TOP_DIR)/library/opt/*.tcl ; do \
 	    $(INSTALL_DATA) $$i "$(SCRIPT_INSTALL_DIR)"/opt0.4; \
 	done
 	@echo "Installing package msgcat 1.7.0 as a Tcl Module"
 	@$(INSTALL_DATA) $(TOP_DIR)/library/msgcat/msgcat.tcl \
-		"$(MODULE_INSTALL_DIR)"/tcl9/9.0/msgcat-1.7.0.tm
+		"$(MODULE_INSTALL_DIR)"/tcl8/8.7/msgcat-1.7.0.tm
 	@echo "Installing package tcltest 2.5.0 as a Tcl Module"
 	@$(INSTALL_DATA) $(TOP_DIR)/library/tcltest/tcltest.tcl \
-		"$(MODULE_INSTALL_DIR)"/tcl9/9.0/tcltest-2.5.0.tm
+		"$(MODULE_INSTALL_DIR)"/tcl8/8.5/tcltest-2.5.0.tm
 	@echo "Installing package platform 1.0.14 as a Tcl Module"
 	@$(INSTALL_DATA) $(TOP_DIR)/library/platform/platform.tcl \
-		"$(MODULE_INSTALL_DIR)"/tcl9/9.0/platform-1.0.14.tm
+		"$(MODULE_INSTALL_DIR)"/tcl8/8.4/platform-1.0.14.tm
 	@echo "Installing package platform::shell 1.1.4 as a Tcl Module"
 	@$(INSTALL_DATA) $(TOP_DIR)/library/platform/shell.tcl \
-		"$(MODULE_INSTALL_DIR)"/tcl9/9.0/platform/shell-1.1.4.tm
+		"$(MODULE_INSTALL_DIR)"/tcl8/8.4/platform/shell-1.1.4.tm
 	@echo "Installing encoding files to $(SCRIPT_INSTALL_DIR)/encoding/"
 	@for i in $(TOP_DIR)/library/encoding/*.enc ; do \
 		$(INSTALL_DATA) $$i "$(SCRIPT_INSTALL_DIR)"/encoding; \
 	done
 	@if [ -n "$(TCL_MODULE_PATH)" -a -f $(TOP_DIR)/library/tm.tcl ] ; then \
@@ -2135,12 +2136,10 @@
 
 DISTROOT = /tmp/dist
 DISTNAME = tcl${VERSION}${PATCH_LEVEL}
 ZIPNAME	 = tcl${MAJOR_VERSION}${MINOR_VERSION}${PATCH_LEVEL}-src.zip
 DISTDIR	 = $(DISTROOT)/$(DISTNAME)
-DIST_INSTALL_DATA   = CPPROG='cp -p' $(INSTALL) -m 644
-DIST_INSTALL_SCRIPT = CPPROG='cp -p' $(INSTALL) -m 755
 BUILTIN_PACKAGE_LIST = http opt msgcat reg dde tcltest platform
 
 $(UNIX_DIR)/configure: $(UNIX_DIR)/configure.ac $(UNIX_DIR)/tcl.m4 \
 		$(UNIX_DIR)/aclocal.m4
 	cd $(UNIX_DIR); autoconf
@@ -2150,110 +2149,105 @@
 	cd $(MAC_OSX_DIR); autoheader; touch $@
 
 dist: $(UNIX_DIR)/configure $(UNIX_DIR)/tclConfig.h.in $(UNIX_DIR)/tcl.pc.in \
 		$(MAC_OSX_DIR)/configure genstubs dist-packages ${NATIVE_TCLSH}
 	rm -rf $(DISTDIR)
-	$(INSTALL_DATA_DIR) $(DISTDIR)/unix
-	$(DIST_INSTALL_DATA) $(UNIX_DIR)/*.[ch] $(DISTDIR)/unix
-	$(DIST_INSTALL_DATA) $(UNIX_DIR)/Makefile.in $(DISTDIR)/unix
-	$(DIST_INSTALL_DATA) $(UNIX_DIR)/configure.ac \
+	mkdir -p $(DISTDIR)/unix
+	cp -p $(UNIX_DIR)/*.[ch] $(DISTDIR)/unix
+	cp $(UNIX_DIR)/Makefile.in $(DISTDIR)/unix
+	chmod 664 $(DISTDIR)/unix/Makefile.in
+	cp $(UNIX_DIR)/configure $(UNIX_DIR)/configure.ac \
 		$(UNIX_DIR)/tcl.m4 $(UNIX_DIR)/aclocal.m4 \
 		$(UNIX_DIR)/tclConfig.sh.in $(UNIX_DIR)/tclooConfig.sh \
 		$(UNIX_DIR)/install-sh \
-		$(UNIX_DIR)/README $(UNIX_DIR)/tcl.spec \
+		$(UNIX_DIR)/README $(UNIX_DIR)/ldAix $(UNIX_DIR)/tcl.spec \
 		$(UNIX_DIR)/installManPage $(UNIX_DIR)/tclConfig.h.in \
 		$(UNIX_DIR)/tcl.pc.in $(DISTDIR)/unix
-	$(DIST_INSTALL_SCRIPT) $(UNIX_DIR)/configure $(UNIX_DIR)/ldAix $(DISTDIR)/unix
-	$(INSTALL_DATA_DIR) $(DISTDIR)/generic
-	$(DIST_INSTALL_DATA) $(GENERIC_DIR)/*.[cdh] $(DISTDIR)/generic
-	$(DIST_INSTALL_DATA) $(GENERIC_DIR)/*.decls $(DISTDIR)/generic
-	$(DIST_INSTALL_DATA) $(GENERIC_DIR)/README $(DISTDIR)/generic
-	$(DIST_INSTALL_DATA) $(GENERIC_DIR)/tclGetDate.y $(DISTDIR)/generic
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/changes $(TOP_DIR)/ChangeLog $(TOP_DIR)/README.md \
+	chmod 775 $(DISTDIR)/unix/configure $(DISTDIR)/unix/configure.ac
+	chmod 775 $(DISTDIR)/unix/ldAix
+	@mkdir $(DISTDIR)/generic
+	cp -p $(GENERIC_DIR)/*.[cdh] $(DISTDIR)/generic
+	cp -p $(GENERIC_DIR)/*.decls $(DISTDIR)/generic
+	cp -p $(GENERIC_DIR)/README $(DISTDIR)/generic
+	cp -p $(GENERIC_DIR)/tclGetDate.y $(DISTDIR)/generic
+	cp -p $(TOP_DIR)/changes $(TOP_DIR)/ChangeLog $(TOP_DIR)/README.md \
 		$(TOP_DIR)/ChangeLog.[12]??? $(TOP_DIR)/license.terms \
 		$(DISTDIR)
-	$(INSTALL_DATA_DIR) $(DISTDIR)/library
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/license.terms $(TOP_DIR)/library/*.tcl \
+	@mkdir $(DISTDIR)/library
+	cp -p $(TOP_DIR)/license.terms $(TOP_DIR)/library/*.tcl \
 		$(TOP_DIR)/library/tclIndex $(DISTDIR)/library
 	@for i in $(BUILTIN_PACKAGE_LIST) ; do \
-	    $(INSTALL_DATA_DIR) $(DISTDIR)/library/$$i;\
-	    $(DIST_INSTALL_DATA) $(TOP_DIR)/library/$$i/*.tcl $(DISTDIR)/library/$$i; \
+	    mkdir $(DISTDIR)/library/$$i;\
+	    cp -p $(TOP_DIR)/library/$$i/*.tcl $(DISTDIR)/library/$$i; \
 	done
-	$(INSTALL_DATA_DIR) $(DISTDIR)/library/encoding
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/library/encoding/*.enc $(DISTDIR)/library/encoding
-	$(INSTALL_DATA_DIR) $(DISTDIR)/library/msgs
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/library/msgs/*.msg $(DISTDIR)/library/msgs
+	@mkdir $(DISTDIR)/library/encoding
+	cp -p $(TOP_DIR)/library/encoding/*.enc $(DISTDIR)/library/encoding
+	@mkdir $(DISTDIR)/library/msgs
+	cp -p $(TOP_DIR)/library/msgs/*.msg $(DISTDIR)/library/msgs
 	@echo cp -r $(TOP_DIR)/library/tzdata $(DISTDIR)/library/tzdata
 	@( cd $(TOP_DIR); find library/tzdata -type f -print ) \
 	    | ( cd $(TOP_DIR) ; xargs tar cf - ) \
 	    | ( cd $(DISTDIR) ; tar xfp - )
-	$(INSTALL_DATA_DIR) $(DISTDIR)/doc
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/license.terms $(TOP_DIR)/doc/*.[13n] \
+	@mkdir $(DISTDIR)/doc
+	cp -p $(TOP_DIR)/license.terms $(TOP_DIR)/doc/*.[13n] \
 		$(TOP_DIR)/doc/man.macros $(DISTDIR)/doc
-	$(INSTALL_DATA_DIR) $(DISTDIR)/compat
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/license.terms $(COMPAT_DIR)/*.[ch] \
+	@mkdir $(DISTDIR)/compat
+	cp -p $(TOP_DIR)/license.terms $(COMPAT_DIR)/*.[ch] \
 		$(COMPAT_DIR)/README $(DISTDIR)/compat
-	$(INSTALL_DATA_DIR) $(DISTDIR)/compat/zlib
+	@mkdir $(DISTDIR)/compat/zlib
 	@echo cp -r $(COMPAT_DIR)/zlib $(DISTDIR)/compat/zlib
 	@( cd $(COMPAT_DIR)/zlib; find . -type f -print ) \
 	    | ( cd $(COMPAT_DIR)/zlib ; xargs tar cf - ) \
 	    | ( cd $(DISTDIR)/compat/zlib ; tar xfp - )
-	$(INSTALL_DATA_DIR) $(DISTDIR)/tests
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/license.terms $(DISTDIR)/tests
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/tests/*.test $(TOP_DIR)/tests/README \
+	@mkdir $(DISTDIR)/tests
+	cp -p $(TOP_DIR)/license.terms $(DISTDIR)/tests
+	cp -p $(TOP_DIR)/tests/*.test $(TOP_DIR)/tests/README \
 		$(TOP_DIR)/tests/httpd $(TOP_DIR)/tests/*.tcl \
 		$(DISTDIR)/tests
-	$(INSTALL_DATA_DIR) $(DISTDIR)/win
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/win/Makefile.in $(DISTDIR)/win
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/win/configure.ac \
+	@mkdir $(DISTDIR)/win
+	cp $(TOP_DIR)/win/Makefile.in $(DISTDIR)/win
+	cp $(TOP_DIR)/win/configure.ac $(TOP_DIR)/win/configure \
 		$(TOP_DIR)/win/tclConfig.sh.in $(TOP_DIR)/win/tclooConfig.sh \
 		$(TOP_DIR)/win/tcl.m4 $(TOP_DIR)/win/aclocal.m4 \
 		$(TOP_DIR)/win/tclsh.exe.manifest.in \
 		$(DISTDIR)/win
-	$(DIST_INSTALL_SCRIPT) $(TOP_DIR)/win/configure $(DISTDIR)/win
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/win/*.[ch] $(TOP_DIR)/win/*.ico $(TOP_DIR)/win/*.rc \
+	cp -p $(TOP_DIR)/win/*.[ch] $(TOP_DIR)/win/*.ico $(TOP_DIR)/win/*.rc \
 		$(DISTDIR)/win
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/win/*.bat $(DISTDIR)/win
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/win/*.vc $(DISTDIR)/win
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/win/tcl.hpj.in $(DISTDIR)/win
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/win/tcl.ds* $(DISTDIR)/win
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/win/README $(DISTDIR)/win
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/license.terms $(DISTDIR)/win
-	$(INSTALL_DATA_DIR) $(DISTDIR)/macosx
-	$(DIST_INSTALL_DATA) $(MAC_OSX_DIR)/GNUmakefile $(MAC_OSX_DIR)/README \
+	cp -p $(TOP_DIR)/win/*.bat $(DISTDIR)/win
+	cp -p $(TOP_DIR)/win/*.vc $(DISTDIR)/win
+	cp -p $(TOP_DIR)/win/tcl.hpj.in $(DISTDIR)/win
+	cp -p $(TOP_DIR)/win/tcl.ds* $(DISTDIR)/win
+	cp -p $(TOP_DIR)/win/README $(DISTDIR)/win
+	cp -p $(TOP_DIR)/license.terms $(DISTDIR)/win
+	@mkdir $(DISTDIR)/macosx
+	cp -p $(MAC_OSX_DIR)/GNUmakefile $(MAC_OSX_DIR)/README \
 		$(MAC_OSX_DIR)/*.c $(MAC_OSX_DIR)/*.in \
 		$(MAC_OSX_DIR)/*.ac $(MAC_OSX_DIR)/*.xcconfig \
-		$(DISTDIR)/macosx
-	$(DIST_INSTALL_SCRIPT) $(MAC_OSX_DIR)/configure $(DISTDIR)/macosx
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/license.terms $(DISTDIR)/macosx
-	$(INSTALL_DATA_DIR) $(DISTDIR)/macosx/Tcl.xcode
-	$(DIST_INSTALL_DATA) $(MAC_OSX_DIR)/Tcl.xcode/project.pbxproj \
+		$(MAC_OSX_DIR)/configure $(DISTDIR)/macosx
+	cp -p $(TOP_DIR)/license.terms $(DISTDIR)/macosx
+	@mkdir $(DISTDIR)/macosx/Tcl.xcode
+	cp -p $(MAC_OSX_DIR)/Tcl.xcode/project.pbxproj \
 		$(MAC_OSX_DIR)/Tcl.xcode/default.pbxuser \
 		$(DISTDIR)/macosx/Tcl.xcode
-	$(INSTALL_DATA_DIR) $(DISTDIR)/macosx/Tcl.xcodeproj
-	$(DIST_INSTALL_DATA) $(MAC_OSX_DIR)/Tcl.xcodeproj/project.pbxproj \
+	@mkdir $(DISTDIR)/macosx/Tcl.xcodeproj
+	cp -p $(MAC_OSX_DIR)/Tcl.xcodeproj/project.pbxproj \
 		$(MAC_OSX_DIR)/Tcl.xcodeproj/default.pbxuser \
 		$(DISTDIR)/macosx/Tcl.xcodeproj
-	$(INSTALL_DATA_DIR) $(DISTDIR)/unix/dltest
-	$(DIST_INSTALL_DATA) $(UNIX_DIR)/dltest/*.c $(UNIX_DIR)/dltest/Makefile.in \
+	@mkdir $(DISTDIR)/unix/dltest
+	cp -p $(UNIX_DIR)/dltest/*.c $(UNIX_DIR)/dltest/Makefile.in \
 		$(UNIX_DIR)/dltest/README $(DISTDIR)/unix/dltest
-	$(INSTALL_DATA_DIR) $(DISTDIR)/tools
-	$(DIST_INSTALL_DATA) $(TOOL_DIR)/Makefile.in $(TOOL_DIR)/README \
+	@mkdir $(DISTDIR)/tools
+	cp -p $(TOOL_DIR)/Makefile.in $(TOOL_DIR)/README \
 		$(TOOL_DIR)/configure $(TOOL_DIR)/configure.ac \
 		$(TOOL_DIR)/*.tcl $(TOOL_DIR)/man2tcl.c \
 		$(TOOL_DIR)/*.bmp $(TOOL_DIR)/tcl.hpj.in \
 		$(DISTDIR)/tools
-	chmod 755 $(DISTDIR)/tools/checkLibraryDoc.tcl \
-		$(DISTDIR)/tools/configure $(DISTDIR)/tools/findBadExternals.tcl \
-		$(DISTDIR)/tools/fix_tommath_h.tcl $(DISTDIR)/tools/loadICU.tcl \
-		$(DISTDIR)/tools/makeTestCases.tcl $(DISTDIR)/tools/tclZIC.tcl \
-		$(DISTDIR)/tools/tcltk-man2html.tcl
-	$(INSTALL_DATA_DIR) $(DISTDIR)/libtommath
-	$(DIST_INSTALL_DATA) $(TOMMATH_SRCS) $(TOMMATH_DIR)/*.h $(DISTDIR)/libtommath
-	$(INSTALL_DATA_DIR) $(DISTDIR)/pkgs
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/pkgs/README $(DISTDIR)/pkgs
-	$(DIST_INSTALL_DATA) $(TOP_DIR)/pkgs/package.list.txt $(DISTDIR)/pkgs
+	@mkdir $(DISTDIR)/libtommath
+	cp -p $(TOMMATH_SRCS) $(TOMMATH_DIR)/*.h $(DISTDIR)/libtommath
+	@mkdir $(DISTDIR)/pkgs
+	cp $(TOP_DIR)/pkgs/README $(DISTDIR)/pkgs
+	cp $(TOP_DIR)/pkgs/package.list.txt $(DISTDIR)/pkgs
 	for i in `ls $(DISTROOT)/pkgs/*.tar.gz 2> /dev/null` ; do \
 	    tar -C $(DISTDIR)/pkgs -xzf "$$i"; \
 	done
 
 alldist: dist
@@ -2264,11 +2258,11 @@
 		zip -qr8 $(ZIPNAME) $(DISTNAME) )
 
 #--------------------------------------------------------------------------
 # This target creates the HTML folder for Tcl & Tk and places it in
 # DISTDIR/html. It uses the tcltk-man2html.tcl tool from the Tcl group's tool
-# workspace. It depends on the Tcl & Tk being in directories called tcl9.* &
+# workspace. It depends on the Tcl & Tk being in directories called tcl8.* &
 # tk8.* up two directories from the TOOL_DIR.
 #
 # Note that for platforms where this is important, it is more common to use a
 # build of this HTML documentation that has already been placed online. As
 # such, this rule is not guaranteed to work well on all systems; it only needs

Index: unix/configure
==================================================================
--- unix/configure
+++ unix/configure
@@ -1,8 +1,8 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for tcl 9.0.
+# Generated by GNU Autoconf 2.69 for tcl 8.7.
 #
 #
 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
 #
 #
@@ -575,12 +575,12 @@
 MAKEFLAGS=
 
 # Identity of this package.
 PACKAGE_NAME='tcl'
 PACKAGE_TARNAME='tcl'
-PACKAGE_VERSION='9.0'
-PACKAGE_STRING='tcl 9.0'
+PACKAGE_VERSION='8.7'
+PACKAGE_STRING='tcl 8.7'
 PACKAGE_BUGREPORT=''
 PACKAGE_URL=''
 
 # Factoring default headers for most tests.
 ac_includes_default="\
@@ -1328,11 +1328,11 @@
 #
 if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures tcl 9.0 to adapt to many kinds of systems.
+\`configure' configures tcl 8.7 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 VAR=VALUE.  See below for descriptions of some of the useful variables.
@@ -1389,11 +1389,11 @@
 _ACEOF
 fi
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of tcl 9.0:";;
+     short | recursive ) echo "Configuration of tcl 8.7:";;
    esac
   cat <<\_ACEOF
 
 Optional Features:
   --disable-option-checking  ignore unrecognized --enable/--with options
@@ -1503,11 +1503,11 @@
 fi
 
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-tcl configure 9.0
+tcl configure 8.7
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
 This configure script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it.
@@ -2025,11 +2025,11 @@
 } # ac_fn_c_check_member
 cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by tcl $as_me 9.0, which was
+It was created by tcl $as_me 8.7, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
 
 _ACEOF
@@ -2377,14 +2377,14 @@
 
 
 
 
 
-TCL_VERSION=9.0
-TCL_MAJOR_VERSION=9
-TCL_MINOR_VERSION=0
-TCL_PATCH_LEVEL="a0"
+TCL_VERSION=8.7
+TCL_MAJOR_VERSION=8
+TCL_MINOR_VERSION=7
+TCL_PATCH_LEVEL="a2"
 VERSION=${TCL_VERSION}
 
 EXTRA_INSTALL_BINARIES=${EXTRA_INSTALL_BINARIES:-"@:"}
 EXTRA_BUILD_HTML=${EXTRA_BUILD_HTML:-"@:"}
 
@@ -3331,12 +3331,12 @@
 
 
 
 #--------------------------------------------------------------------
 # Supply substitutes for missing POSIX header files.  Special notes:
-#	- stdlib.h doesn't define strtol, strtoul, or
-#	  strtod insome versions of SunOS
+#	- stdlib.h doesn't define strtol or strtoul in some versions
+#	  of SunOS
 #	- some versions of string.h don't declare procedures such
 #	  as strstr
 # Do this early, otherwise an autoconf bug throws errors on configure
 #--------------------------------------------------------------------
 
@@ -3818,23 +3818,10 @@
 
 _ACEOF
 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
   $EGREP "strtoul" >/dev/null 2>&1; then :
 
-else
-  tcl_ok=0
-fi
-rm -f conftest*
-
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <stdlib.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "strtod" >/dev/null 2>&1; then :
-
 else
   tcl_ok=0
 fi
 rm -f conftest*
 
@@ -5658,11 +5645,11 @@
 fi
 
 fi
 
 	    # The combo of gcc + glibc has a bug related to inlining of
-	    # functions like strtod(). The -fno-builtin flag should address
+	    # functions like strtol()/strtoul(). The -fno-builtin flag should address
 	    # this problem but it does not work. The -fno-inline flag is kind
 	    # of overkill but it works. Disable inlining only when one of the
 	    # files in compat/*.c is being linked in.
 
 	    if test x"${USE_COMPAT}" != x; then :
@@ -9834,11 +9821,11 @@
 $as_echo "$tcl_ok" >&6; }
 
 #------------------------------------------------------------------------
 #	Check whether the timezone data is supplied by the OS or has
 #	to be installed by Tcl. The default is autodetection, but can
-#	be overriden on the configure command line either way.
+#	be overridden on the configure command line either way.
 #------------------------------------------------------------------------
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for timezone data" >&5
 $as_echo_n "checking for timezone data... " >&6; }
 
@@ -10968,11 +10955,11 @@
 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 # Save the log message, to keep $0 and so on meaningful, and to
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by tcl $as_me 9.0, which was
+This file was extended by tcl $as_me 8.7, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
   CONFIG_HEADERS  = $CONFIG_HEADERS
   CONFIG_LINKS    = $CONFIG_LINKS
@@ -11025,11 +11012,11 @@
 
 _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-tcl config.status 9.0
+tcl config.status 8.7
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
 Copyright (C) 2012 Free Software Foundation, Inc.
 This config.status script is free software; the Free Software Foundation

Index: unix/configure.ac
==================================================================
--- unix/configure.ac
+++ unix/configure.ac
@@ -1,11 +1,11 @@
 #! /bin/bash -norc
 dnl	This file is an input file used by the GNU "autoconf" program to
 dnl	generate the file "configure", which is run during Tcl installation
 dnl	to configure the system for the local environment.
 
-AC_INIT([tcl],[9.0])
+AC_INIT([tcl],[8.7])
 AC_PREREQ(2.69)
 
 dnl This is only used when included from macosx/configure.ac
 m4_ifdef([SC_USE_CONFIG_HEADERS], [
     AC_CONFIG_HEADERS([tclConfig.h:../unix/tclConfig.h.in])
@@ -20,14 +20,14 @@
     /* override */ #undef PACKAGE_STRING
     /* override */ #undef PACKAGE_TARNAME
     #endif /* _TCLCONFIG */])
 ])
 
-TCL_VERSION=9.0
-TCL_MAJOR_VERSION=9
-TCL_MINOR_VERSION=0
-TCL_PATCH_LEVEL="a0"
+TCL_VERSION=8.7
+TCL_MAJOR_VERSION=8
+TCL_MINOR_VERSION=7
+TCL_PATCH_LEVEL="a2"
 VERSION=${TCL_VERSION}
 
 EXTRA_INSTALL_BINARIES=${EXTRA_INSTALL_BINARIES:-"@:"}
 EXTRA_BUILD_HTML=${EXTRA_BUILD_HTML:-"@:"}
 
@@ -87,12 +87,12 @@
 AC_C_INLINE
 
 
 #--------------------------------------------------------------------
 # Supply substitutes for missing POSIX header files.  Special notes:
-#	- stdlib.h doesn't define strtol, strtoul, or
-#	  strtod insome versions of SunOS
+#	- stdlib.h doesn't define strtol or strtoul in some versions
+#	  of SunOS
 #	- some versions of string.h don't declare procedures such
 #	  as strstr
 # Do this early, otherwise an autoconf bug throws errors on configure
 #--------------------------------------------------------------------
 
@@ -675,11 +675,11 @@
 AC_MSG_RESULT([$tcl_ok])
 
 #------------------------------------------------------------------------
 #	Check whether the timezone data is supplied by the OS or has
 #	to be installed by Tcl. The default is autodetection, but can
-#	be overriden on the configure command line either way.
+#	be overridden on the configure command line either way.
 #------------------------------------------------------------------------
 
 AC_MSG_CHECKING([for timezone data])
 AC_ARG_WITH(tzdata,
     AC_HELP_STRING([--with-tzdata],

Index: unix/tcl.m4
==================================================================
--- unix/tcl.m4
+++ unix/tcl.m4
@@ -94,12 +94,12 @@
 			`ls -d /usr/local/lib 2>/dev/null` \
 			`ls -d /usr/contrib/lib 2>/dev/null` \
 			`ls -d /usr/pkg/lib 2>/dev/null` \
 			`ls -d /usr/lib 2>/dev/null` \
 			`ls -d /usr/lib64 2>/dev/null` \
-			`ls -d /usr/local/lib/tcl9.0 2>/dev/null` \
-			`ls -d /usr/local/lib/tcl/tcl9.0 2>/dev/null` \
+			`ls -d /usr/local/lib/tcl8.7 2>/dev/null` \
+			`ls -d /usr/local/lib/tcl/tcl8.7 2>/dev/null` \
 			; do
 		    if test -f "$i/tclConfig.sh" ; then
 			ac_cv_c_tclconfig="`(cd $i; pwd)`"
 			break
 		    fi
@@ -227,12 +227,12 @@
 			`ls -d /usr/local/lib 2>/dev/null` \
 			`ls -d /usr/contrib/lib 2>/dev/null` \
 			`ls -d /usr/pkg/lib 2>/dev/null` \
 			`ls -d /usr/lib 2>/dev/null` \
 			`ls -d /usr/lib64 2>/dev/null` \
-			`ls -d /usr/local/lib/tk9.0 2>/dev/null` \
-			`ls -d /usr/local/lib/tcl/tk9.0 2>/dev/null` \
+			`ls -d /usr/local/lib/tk8.7 2>/dev/null` \
+			`ls -d /usr/local/lib/tcl/tk8.7 2>/dev/null` \
 			; do
 		    if test -f "$i/tkConfig.sh" ; then
 			ac_cv_c_tkconfig="`(cd $i; pwd)`"
 			break
 		    fi
@@ -1309,11 +1309,11 @@
 		    do64bit_ok=yes
 		])
 	   ])
 
 	    # The combo of gcc + glibc has a bug related to inlining of
-	    # functions like strtod(). The -fno-builtin flag should address
+	    # functions like strtol()/strtoul(). The -fno-builtin flag should address
 	    # this problem but it does not work. The -fno-inline flag is kind
 	    # of overkill but it works. Disable inlining only when one of the
 	    # files in compat/*.c is being linked in.
 
 	    AS_IF([test x"${USE_COMPAT}" != x],[CFLAGS="$CFLAGS -fno-inline"])
@@ -1911,12 +1911,12 @@
 #--------------------------------------------------------------------
 # SC_MISSING_POSIX_HEADERS
 #
 #	Supply substitutes for missing POSIX header files.  Special
 #	notes:
-#	    - stdlib.h doesn't define strtol, strtoul, or
-#	      strtod insome versions of SunOS
+#	    - stdlib.h doesn't define strtol or strtoul in some
+#	      versions of SunOS
 #	    - some versions of string.h don't declare procedures such
 #	      as strstr
 #
 # Arguments:
 #	none
@@ -1963,11 +1963,10 @@
     fi
 
     AC_CHECK_HEADER(stdlib.h, tcl_ok=1, tcl_ok=0)
     AC_EGREP_HEADER(strtol, stdlib.h, , tcl_ok=0)
     AC_EGREP_HEADER(strtoul, stdlib.h, , tcl_ok=0)
-    AC_EGREP_HEADER(strtod, stdlib.h, , tcl_ok=0)
     if test $tcl_ok = 0; then
 	AC_DEFINE(NO_STDLIB_H, 1, [Do we have <stdlib.h>?])
     fi
     AC_CHECK_HEADER(string.h, tcl_ok=1, tcl_ok=0)
     AC_EGREP_HEADER(strstr, string.h, , tcl_ok=0)

Index: unix/tcl.spec
==================================================================
--- unix/tcl.spec
+++ unix/tcl.spec
@@ -2,11 +2,11 @@
 
 %{!?directory:%define directory /usr/local}
 
 Name:          tcl
 Summary:       Tcl scripting language development environment
-Version:       9.0a0
+Version:       8.7a2
 Release:       2
 License:       BSD
 Group:         Development/Languages
 Source:        http://prdownloads.sourceforge.net/tcl/tcl%{version}-src.tar.gz
 URL:           http://www.tcl.tk/

Index: unix/tclEpollNotfy.c
==================================================================
--- unix/tclEpollNotfy.c
+++ unix/tclEpollNotfy.c
@@ -236,11 +236,11 @@
     }
     if (filePtr->mask & TCL_WRITABLE) {
 	newEvent.events |= EPOLLOUT;
     }
     if (isNew) {
-        newPedPtr = Tcl_Alloc(sizeof(*newPedPtr));
+        newPedPtr = ckalloc(sizeof(*newPedPtr));
         newPedPtr->filePtr = filePtr;
         newPedPtr->tsdPtr = tsdPtr;
 	filePtr->pedPtr = newPedPtr;
     }
     newEvent.data.ptr = filePtr->pedPtr;
@@ -316,18 +316,18 @@
     if (tsdPtr->triggerPipe[1]) {
 	close(tsdPtr->triggerPipe[1]);
 	tsdPtr->triggerPipe[1] = -1;
     }
 #endif /* HAVE_EVENTFD */
-    Tcl_Free(tsdPtr->triggerFilePtr->pedPtr);
-    Tcl_Free(tsdPtr->triggerFilePtr);
+    ckfree(tsdPtr->triggerFilePtr->pedPtr);
+    ckfree(tsdPtr->triggerFilePtr);
     if (tsdPtr->eventsFd > 0) {
 	close(tsdPtr->eventsFd);
 	tsdPtr->eventsFd = 0;
     }
     if (tsdPtr->readyEvents) {
-	Tcl_Free(tsdPtr->readyEvents);
+	ckfree(tsdPtr->readyEvents);
 	tsdPtr->maxReadyEvents = 0;
     }
     pthread_mutex_unlock(&tsdPtr->notifierMutex);
     if ((errno = pthread_mutex_destroy(&tsdPtr->notifierMutex))) {
 	Tcl_Panic("pthread_mutex_destroy: %s", strerror(errno));
@@ -368,11 +368,11 @@
 
     errno = pthread_mutex_init(&tsdPtr->notifierMutex, NULL);
     if (errno) {
 	Tcl_Panic("Tcl_InitNotifier: %s", "could not create mutex");
     }
-    filePtr = Tcl_Alloc(sizeof(*filePtr));
+    filePtr = ckalloc(sizeof(*filePtr));
 #ifdef HAVE_EVENTFD
     tsdPtr->triggerEventFd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
     if (tsdPtr->triggerEventFd <= 0) {
 	Tcl_Panic("Tcl_InitNotifier: %s", "could not create trigger eventfd");
     }
@@ -389,11 +389,11 @@
     }
     filePtr->mask = TCL_READABLE;
     PlatformEventsControl(filePtr, tsdPtr, EPOLL_CTL_ADD, 1);
     if (!tsdPtr->readyEvents) {
         tsdPtr->maxReadyEvents = 512;
-	tsdPtr->readyEvents = Tcl_Alloc(
+	tsdPtr->readyEvents = ckalloc(
 		tsdPtr->maxReadyEvents * sizeof(tsdPtr->readyEvents[0]));
     }
     LIST_INIT(&tsdPtr->firstReadyFileHandlerPtr);
 }
 
@@ -548,11 +548,11 @@
 	    if (filePtr->fd == fd) {
 		break;
 	    }
 	}
 	if (filePtr == NULL) {
-	    filePtr = Tcl_Alloc(sizeof(FileHandler));
+	    filePtr = ckalloc(sizeof(FileHandler));
 	    filePtr->fd = fd;
 	    filePtr->readyMask = 0;
 	    filePtr->nextPtr = tsdPtr->firstFileHandlerPtr;
 	    tsdPtr->firstFileHandlerPtr = filePtr;
 	    isNew = 1;
@@ -618,11 +618,11 @@
 	 * Update the check masks for this file.
 	 */
 
 	PlatformEventsControl(filePtr, tsdPtr, EPOLL_CTL_DEL, 0);
 	if (filePtr->pedPtr) {
-	    Tcl_Free(filePtr->pedPtr);
+	    ckfree(filePtr->pedPtr);
 	}
 
 	/*
 	 * Clean up information in the callback record.
 	 */
@@ -630,11 +630,11 @@
 	if (prevPtr == NULL) {
 	    tsdPtr->firstFileHandlerPtr = filePtr->nextPtr;
 	} else {
 	    prevPtr->nextPtr = filePtr->nextPtr;
 	}
-	Tcl_Free(filePtr);
+	ckfree(filePtr);
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -732,11 +732,11 @@
 	     * non-zero since an event must still be on the queue.
 	     */
 
 	    if (filePtr->readyMask == 0) {
 		FileHandlerEvent *fileEvPtr =
-			Tcl_Alloc(sizeof(FileHandlerEvent));
+			ckalloc(sizeof(FileHandlerEvent));
 
 		fileEvPtr->header.proc = FileHandlerEventProc;
 		fileEvPtr->fd = filePtr->fd;
 		Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
 		numQueued++;
@@ -809,11 +809,11 @@
 	     * non-zero since an event must still be on the queue.
 	     */
 
 	    if (filePtr->readyMask == 0) {
 		FileHandlerEvent *fileEvPtr =
-			Tcl_Alloc(sizeof(FileHandlerEvent));
+			ckalloc(sizeof(FileHandlerEvent));
 
 		fileEvPtr->header.proc = FileHandlerEventProc;
 		fileEvPtr->fd = filePtr->fd;
 		Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
 	    }

Index: unix/tclKqueueNotfy.c
==================================================================
--- unix/tclKqueueNotfy.c
+++ unix/tclKqueueNotfy.c
@@ -220,11 +220,11 @@
     struct kevent changeList[2];
     struct PlatformEventData *newPedPtr;
     struct stat fdStat;
 
     if (isNew) {
-        newPedPtr = Tcl_Alloc(sizeof(*newPedPtr));
+        newPedPtr = ckalloc(sizeof(*newPedPtr));
         newPedPtr->filePtr = filePtr;
         newPedPtr->tsdPtr = tsdPtr;
         filePtr->pedPtr = newPedPtr;
     }
 
@@ -342,11 +342,11 @@
     if (tsdPtr->eventsFd > 0) {
 	close(tsdPtr->eventsFd);
 	tsdPtr->eventsFd = 0;
     }
     if (tsdPtr->readyEvents) {
-	Tcl_Free(tsdPtr->readyEvents);
+	ckfree(tsdPtr->readyEvents);
 	tsdPtr->maxReadyEvents = 0;
     }
     pthread_mutex_unlock(&tsdPtr->notifierMutex);
     if ((errno = pthread_mutex_destroy(&tsdPtr->notifierMutex))) {
 	Tcl_Panic("pthread_mutex_destroy: %s", strerror(errno));
@@ -407,17 +407,17 @@
     if ((tsdPtr->eventsFd = kqueue()) == -1) {
 	Tcl_Panic("kqueue: %s", strerror(errno));
     } else if (fcntl(tsdPtr->eventsFd, F_SETFD, FD_CLOEXEC) == -1) {
 	Tcl_Panic("fcntl: %s", strerror(errno));
     }
-    filePtr = Tcl_Alloc(sizeof(*filePtr));
+    filePtr = ckalloc(sizeof(*filePtr));
     filePtr->fd = tsdPtr->triggerPipe[0];
     filePtr->mask = TCL_READABLE;
     PlatformEventsControl(filePtr, tsdPtr, EV_ADD, 1);
     if (!tsdPtr->readyEvents) {
         tsdPtr->maxReadyEvents = 512;
-	tsdPtr->readyEvents = Tcl_Alloc(
+	tsdPtr->readyEvents = ckalloc(
 		tsdPtr->maxReadyEvents * sizeof(tsdPtr->readyEvents[0]));
     }
     LIST_INIT(&tsdPtr->firstReadyFileHandlerPtr);
 }
 
@@ -578,11 +578,11 @@
 	    if (filePtr->fd == fd) {
 		break;
 	    }
 	}
 	if (filePtr == NULL) {
-	    filePtr = Tcl_Alloc(sizeof(FileHandler));
+	    filePtr = ckalloc(sizeof(FileHandler));
 	    filePtr->fd = fd;
 	    filePtr->readyMask = 0;
 	    filePtr->nextPtr = tsdPtr->firstFileHandlerPtr;
 	    tsdPtr->firstFileHandlerPtr = filePtr;
 	    isNew = 1;
@@ -647,11 +647,11 @@
 	 * Update the check masks for this file.
 	 */
 
 	PlatformEventsControl(filePtr, tsdPtr, EV_DELETE, 0);
 	if (filePtr->pedPtr) {
-	    Tcl_Free(filePtr->pedPtr);
+	    ckfree(filePtr->pedPtr);
 	}
 
 	/*
 	 * Clean up information in the callback record.
 	 */
@@ -659,11 +659,11 @@
 	if (prevPtr == NULL) {
 	    tsdPtr->firstFileHandlerPtr = filePtr->nextPtr;
 	} else {
 	    prevPtr->nextPtr = filePtr->nextPtr;
 	}
-	Tcl_Free(filePtr);
+	ckfree(filePtr);
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -767,11 +767,11 @@
 	     * non-zero since an event must still be on the queue.
 	     */
 
 	    if (filePtr->readyMask == 0) {
 		FileHandlerEvent *fileEvPtr =
-			Tcl_Alloc(sizeof(FileHandlerEvent));
+			ckalloc(sizeof(FileHandlerEvent));
 
 		fileEvPtr->header.proc = FileHandlerEventProc;
 		fileEvPtr->fd = filePtr->fd;
 		Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
 		numQueued++;
@@ -827,11 +827,11 @@
 	     * non-zero since an event must still be on the queue.
 	     */
 
 	    if (filePtr->readyMask == 0) {
 		FileHandlerEvent *fileEvPtr =
-			Tcl_Alloc(sizeof(FileHandlerEvent));
+			ckalloc(sizeof(FileHandlerEvent));
 
 		fileEvPtr->header.proc = FileHandlerEventProc;
 		fileEvPtr->fd = filePtr->fd;
 		Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
 	    }

Index: unix/tclLoadAix.c
==================================================================
--- unix/tclLoadAix.c
+++ unix/tclLoadAix.c
@@ -96,11 +96,11 @@
 void *
 dlopen(
     const char *path,
     int mode)
 {
-    register ModulePtr mp;
+    ModulePtr mp;
     static void *mainModule;
 
     /*
      * Upon the first call register a terminate handler that will close all
      * libraries. Also get a reference to the main module for use with
@@ -189,11 +189,11 @@
      * If the user wants global binding, loadbind against all other loaded
      * modules.
      */
 
     if (mode & RTLD_GLOBAL) {
-	register ModulePtr mp1;
+	ModulePtr mp1;
 
 	for (mp1 = mp->next; mp1; mp1 = mp1->next) {
 	    if (loadbind(0, mp1->entry, mp->entry) == -1) {
 		goto loadbindFailure;
 	    }
@@ -241,11 +241,11 @@
 
 static void
 caterr(
     char *s)
 {
-    register char *p = s;
+    char *p = s;
 
     while (*p >= '0' && *p <= '9') {
 	p++;
     }
     switch (atoi(s)) {		/* INTL: "C", UTF safe. */
@@ -280,13 +280,13 @@
 void *
 dlsym(
     void *handle,
     const char *symbol)
 {
-    register ModulePtr mp = (ModulePtr)handle;
-    register ExportPtr ep;
-    register int i;
+    ModulePtr mp = (ModulePtr)handle;
+    ExportPtr ep;
+    int i;
 
     /*
      * Could speed up the search, but I assume that one assigns the result to
      * function pointers anyways.
      */
@@ -315,13 +315,13 @@
 
 int
 dlclose(
     void *handle)
 {
-    register ModulePtr mp = (ModulePtr)handle;
+    ModulePtr mp = (ModulePtr)handle;
     int result;
-    register ModulePtr mp1;
+    ModulePtr mp1;
 
     if (--mp->refCnt > 0) {
 	return 0;
     }
 
@@ -341,12 +341,12 @@
 	errvalid++;
 	strcpy(errbuf, strerror(errno));
     }
 
     if (mp->exports) {
-	register ExportPtr ep;
-	register int i;
+	ExportPtr ep;
+	int i;
 	for (ep = mp->exports, i = mp->nExports; i; i--, ep++) {
 	    if (ep->name) {
 		free(ep->name);
 	    }
 	}

Index: unix/tclLoadDl.c
==================================================================
--- unix/tclLoadDl.c
+++ unix/tclLoadDl.c
@@ -104,11 +104,11 @@
 	 * string the user gave us which hopefully refers to a file on the
 	 * binary path.
 	 */
 
 	Tcl_DString ds;
-	const char *fileName = TclGetString(pathPtr);
+	const char *fileName = Tcl_GetString(pathPtr);
 
 	native = Tcl_UtfToExternalDString(NULL, fileName, -1, &ds);
 	/*
 	 * Use (RTLD_NOW|RTLD_LOCAL) as default, see [Bug #3216070]
 	 */
@@ -125,15 +125,15 @@
 	const char *errorStr = dlerror();
 
 	if (interp) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "couldn't load file \"%s\": %s",
-		    TclGetString(pathPtr), errorStr));
+		    Tcl_GetString(pathPtr), errorStr));
 	}
 	return TCL_ERROR;
     }
-    newHandle = Tcl_Alloc(sizeof(*newHandle));
+    newHandle = ckalloc(sizeof(*newHandle));
     newHandle->clientData = handle;
     newHandle->findSymbolProcPtr = &FindSymbol;
     newHandle->unloadFileProcPtr = &UnloadFile;
     *unloadProcPtr = &UnloadFile;
     *loadHandle = newHandle;
@@ -230,11 +230,11 @@
 				 * that represents the loaded file. */
 {
     void *handle = loadHandle->clientData;
 
     dlclose(handle);
-    Tcl_Free(loadHandle);
+    ckfree(loadHandle);
 }
 
 /*
  *----------------------------------------------------------------------
  *

Index: unix/tclLoadDyld.c
==================================================================
--- unix/tclLoadDyld.c
+++ unix/tclLoadDyld.c
@@ -182,11 +182,11 @@
      * important if the cwd is inside a vfs, and we are trying to load using a
      * relative path.
      */
 
     nativePath = Tcl_FSGetNativePath(pathPtr);
-    nativeFileName = Tcl_UtfToExternalDString(NULL, TclGetString(pathPtr),
+    nativeFileName = Tcl_UtfToExternalDString(NULL, Tcl_GetString(pathPtr),
 	    -1, &ds);
 
 #if TCL_DYLD_USE_DLFCN
     /*
      * Use (RTLD_NOW|RTLD_LOCAL) as default, see [Bug #3216070]
@@ -256,11 +256,11 @@
 		    if (!(flags & 1)) nsflags |= NSLINKMODULE_OPTION_PRIVATE;
 		    if (!(flags & 2)) nsflags |= NSLINKMODULE_OPTION_BINDNOW;
 		    module = NSLinkModule(dyldObjFileImage, nativePath, nsflags);
 		    NSDestroyObjectFileImage(dyldObjFileImage);
 		    if (module) {
-			modulePtr = Tcl_Alloc(sizeof(Tcl_DyldModuleHandle));
+			modulePtr = ckalloc(sizeof(Tcl_DyldModuleHandle));
 			modulePtr->module = module;
 			modulePtr->nextPtr = NULL;
 		    } else {
 			NSLinkEditError(&editError, &errorNumber, &errorName,
 				&errMsg);
@@ -276,17 +276,17 @@
     if (dlHandle
 #if TCL_DYLD_USE_NSMODULE
 	    || dyldLibHeader || modulePtr
 #endif /* TCL_DYLD_USE_NSMODULE */
     ) {
-	dyldLoadHandle = Tcl_Alloc(sizeof(Tcl_DyldLoadHandle));
+	dyldLoadHandle = ckalloc(sizeof(Tcl_DyldLoadHandle));
 	dyldLoadHandle->dlHandle = dlHandle;
 #if TCL_DYLD_USE_NSMODULE || defined(TCL_LOAD_FROM_MEMORY)
 	dyldLoadHandle->dyldLibHeader = dyldLibHeader;
 	dyldLoadHandle->modulePtr = modulePtr;
 #endif /* TCL_DYLD_USE_NSMODULE || TCL_LOAD_FROM_MEMORY */
-	newHandle = Tcl_Alloc(sizeof(*newHandle));
+	newHandle = ckalloc(sizeof(*newHandle));
 	newHandle->clientData = dyldLoadHandle;
 	newHandle->findSymbolProcPtr = &FindSymbol;
 	newHandle->unloadFileProcPtr = &UnloadFile;
 	*unloadProcPtr = &UnloadFile;
 	*loadHandle = newHandle;
@@ -379,11 +379,11 @@
 			break;
 		    }
 		    modulePtr = modulePtr->nextPtr;
 		}
 		if (modulePtr == NULL) {
-		    modulePtr = Tcl_Alloc(sizeof(Tcl_DyldModuleHandle));
+		    modulePtr = ckalloc(sizeof(Tcl_DyldModuleHandle));
 		    modulePtr->module = module;
 		    modulePtr->nextPtr = dyldLoadHandle->modulePtr;
 		    dyldLoadHandle->modulePtr = modulePtr;
 		}
 #endif /* DYLD_SUPPORTS_DYLIB_UNLOADING */
@@ -454,16 +454,16 @@
 	    void *ptr = modulePtr;
 
 	    (void) NSUnLinkModule(modulePtr->module,
 		    NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES);
 	    modulePtr = modulePtr->nextPtr;
-	    Tcl_Free(ptr);
+	    ckfree(ptr);
 	}
 #endif /* TCL_DYLD_USE_NSMODULE */
     }
-    Tcl_Free(dyldLoadHandle);
-    Tcl_Free(loadHandle);
+    ckfree(dyldLoadHandle);
+    ckfree(loadHandle);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -691,18 +691,18 @@
 
     /*
      * Stash the module reference within the load handle we create and return.
      */
 
-    modulePtr = Tcl_Alloc(sizeof(Tcl_DyldModuleHandle));
+    modulePtr = ckalloc(sizeof(Tcl_DyldModuleHandle));
     modulePtr->module = module;
     modulePtr->nextPtr = NULL;
-    dyldLoadHandle = Tcl_Alloc(sizeof(Tcl_DyldLoadHandle));
+    dyldLoadHandle = ckalloc(sizeof(Tcl_DyldLoadHandle));
     dyldLoadHandle->dlHandle = NULL;
     dyldLoadHandle->dyldLibHeader = NULL;
     dyldLoadHandle->modulePtr = modulePtr;
-    newHandle = Tcl_Alloc(sizeof(*newHandle));
+    newHandle = ckalloc(sizeof(*newHandle));
     newHandle->clientData = dyldLoadHandle;
     newHandle->findSymbolProcPtr = &FindSymbol;
     newHandle->unloadFileProcPtr = &UnloadFile;
     *loadHandle = newHandle;
     *unloadProcPtr = &UnloadFile;

Index: unix/tclLoadNext.c
==================================================================
--- unix/tclLoadNext.c
+++ unix/tclLoadNext.c
@@ -59,11 +59,11 @@
     const char *native;
     int result = 1;
 
     NXStream *errorStream = NXOpenMemory(0,0,NX_READWRITE);
 
-    fileName = TclGetString(pathPtr);
+    fileName = Tcl_GetString(pathPtr);
 
     /*
      * First try the full path the user gave us. This is particularly
      * important if the cwd is inside a vfs, and we are trying to load using a
      * relative path.
@@ -99,11 +99,11 @@
 	NXCloseMemory(errorStream, NX_FREEBUFFER);
 	return TCL_ERROR;
     }
     NXCloseMemory(errorStream, NX_FREEBUFFER);
 
-    newHandle = Tcl_Alloc(sizeof(Tcl_LoadHandle));
+    newHandle = ckalloc(sizeof(Tcl_LoadHandle));
     newHandle->clientData = INT2PTR(1);
     newHandle->findSymbolProcPtr = &FindSymbol;
     newHandle->unloadFileProcPtr = &UnloadFile;
     *loadHandle = newHandle;
     *unloadProcPtr = &UnloadFile;
@@ -173,11 +173,11 @@
 UnloadFile(
     Tcl_LoadHandle loadHandle)	/* loadHandle returned by a previous call to
 				 * TclpDlopen(). The loadHandle is a token
 				 * that represents the loaded file. */
 {
-    Tcl_Free(loadHandle);
+    ckfree(loadHandle);
 }
 
 /*
  *----------------------------------------------------------------------
  *

Index: unix/tclLoadOSF.c
==================================================================
--- unix/tclLoadOSF.c
+++ unix/tclLoadOSF.c
@@ -77,11 +77,11 @@
     int flags)
 {
     Tcl_LoadHandle newHandle;
     ldr_module_t lm;
     char *pkg;
-    char *fileName = TclGetString(pathPtr);
+    char *fileName = Tcl_GetString(pathPtr);
     const char *native;
 
     /*
      * First try the full path the user gave us.  This is particularly
      * important if the cwd is inside a vfs, and we are trying to load using a
@@ -126,11 +126,11 @@
     if ((pkg = strrchr(fileName, '/')) == NULL) {
         pkg = fileName;
     } else {
 	pkg++;
     }
-    newHandle = Tcl_Alloc(sizeof(*newHandle));
+    newHandle = ckalloc(sizeof(*newHandle));
     newHandle->clientData = pkg;
     newHandle->findSymbolProcPtr = &FindSymbol;
     newHandle->unloadFileProcPtr = &UnloadFile;
     *loadHandle = newHandle;
     *unloadProcPtr = &UnloadFile;
@@ -191,11 +191,11 @@
 UnloadFile(
     Tcl_LoadHandle loadHandle)	/* loadHandle returned by a previous call to
 				 * TclpDlopen(). The loadHandle is a token
 				 * that represents the loaded file. */
 {
-    Tcl_Free(loadHandle);
+    ckfree(loadHandle);
 }
 
 /*
  *----------------------------------------------------------------------
  *

Index: unix/tclLoadShl.c
==================================================================
--- unix/tclLoadShl.c
+++ unix/tclLoadShl.c
@@ -55,11 +55,11 @@
     int flags)
 {
     shl_t handle;
     Tcl_LoadHandle newHandle;
     const char *native;
-    char *fileName = TclGetString(pathPtr);
+    char *fileName = Tcl_GetString(pathPtr);
 
     /*
      * The flags below used to be BIND_IMMEDIATE; they were changed at the
      * suggestion of Wolfgang Kechel (wolfgang@prs.de): "This enables
      * verbosity for missing symbols when loading a shared lib and allows to
@@ -95,11 +95,11 @@
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"couldn't load file \"%s\": %s",
 		fileName, Tcl_PosixError(interp)));
 	return TCL_ERROR;
     }
-    newHandle = Tcl_Alloc(sizeof(*newHandle));
+    newHandle = ckalloc(sizeof(*newHandle));
     newHandle->clientData = handle;
     newHandle->findSymbolProcPtr = &FindSymbol;
     newHandle->unloadFileProcPtr = *unloadProcPtr = &UnloadFile;
     *loadHandle = newHandle;
     return TCL_OK;
@@ -180,11 +180,11 @@
 				 * that represents the loaded file. */
 {
     shl_t handle = (shl_t) loadHandle->clientData;
 
     shl_unload(handle);
-    Tcl_Free(loadHandle);
+    ckfree(loadHandle);
 }
 
 /*
  *----------------------------------------------------------------------
  *

Index: unix/tclSelectNotfy.c
==================================================================
--- unix/tclSelectNotfy.c
+++ unix/tclSelectNotfy.c
@@ -462,11 +462,11 @@
 	    if (filePtr->fd == fd) {
 		break;
 	    }
 	}
 	if (filePtr == NULL) {
-	    filePtr = Tcl_Alloc(sizeof(FileHandler));
+	    filePtr = ckalloc(sizeof(FileHandler));
 	    filePtr->fd = fd;
 	    filePtr->readyMask = 0;
 	    filePtr->nextPtr = tsdPtr->firstFileHandlerPtr;
 	    tsdPtr->firstFileHandlerPtr = filePtr;
 	}
@@ -581,11 +581,11 @@
 	if (prevPtr == NULL) {
 	    tsdPtr->firstFileHandlerPtr = filePtr->nextPtr;
 	} else {
 	    prevPtr->nextPtr = filePtr->nextPtr;
 	}
-	Tcl_Free(filePtr);
+	ckfree(filePtr);
     }
 }
 
 #if defined(__CYGWIN__)
 
@@ -875,11 +875,11 @@
 	     * non-zero since an event must still be on the queue.
 	     */
 
 	    if (filePtr->readyMask == 0) {
 		FileHandlerEvent *fileEvPtr =
-			Tcl_Alloc(sizeof(FileHandlerEvent));
+			ckalloc(sizeof(FileHandlerEvent));
 
 		fileEvPtr->header.proc = FileHandlerEventProc;
 		fileEvPtr->fd = filePtr->fd;
 		Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
 	    }

Index: unix/tclUnixChan.c
==================================================================
--- unix/tclUnixChan.c
+++ unix/tclUnixChan.c
@@ -94,11 +94,11 @@
 
 #ifdef SUPPORTS_TTY
 
 /*
  * The following structure is used to set or get the serial port attributes in
- * a platform-independant manner.
+ * a platform-independent manner.
  */
 
 typedef struct {
     int baud;
     int parity;
@@ -275,11 +275,11 @@
      * appropriately, and read will unblock as soon as a short read is
      * possible, if the channel is in blocking mode. If the channel is
      * nonblocking, the read will never block.
      */
 
-    bytesRead = read(fsPtr->fd, buf, toRead);
+    bytesRead = read(fsPtr->fd, buf, (size_t) toRead);
     if (bytesRead > -1) {
 	return bytesRead;
     }
     *errorCodePtr = errno;
     return -1;
@@ -322,11 +322,11 @@
 	 * pipe behind the file).
 	 */
 
 	return 0;
     }
-    written = write(fsPtr->fd, buf, toWrite);
+    written = write(fsPtr->fd, buf, (size_t) toWrite);
     if (written > -1) {
 	return written;
     }
     *errorCodePtr = errno;
     return -1;
@@ -368,11 +368,11 @@
 	    || ((fsPtr->fd != 0) && (fsPtr->fd != 1) && (fsPtr->fd != 2))) {
 	if (close(fsPtr->fd) < 0) {
 	    errorCode = errno;
 	}
     }
-    Tcl_Free(fsPtr);
+    ckfree(fsPtr);
     return errorCode;
 }
 
 #ifdef SUPPORTS_TTY
 static int
@@ -643,11 +643,11 @@
     Tcl_Interp *interp,		/* For error reporting - can be NULL. */
     const char *optionName,	/* Which option to set? */
     const char *value)		/* New value for option. */
 {
     TtyState *fsPtr = instanceData;
-    size_t len, vlen;
+    unsigned int len, vlen;
     TtyAttrs tty;
     int argc;
     const char **argv;
     struct termios iostate;
 
@@ -728,11 +728,11 @@
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"bad value for -xchar: should be a list of"
 			" two elements with each a single 8-bit character", -1));
 		Tcl_SetErrorCode(interp, "TCL", "VALUE", "XCHAR", NULL);
 	    }
-	    Tcl_Free(argv);
+	    ckfree(argv);
 	    return TCL_ERROR;
 	}
 
 	tcgetattr(fsPtr->fileState.fd, &iostate);
 
@@ -751,11 +751,11 @@
 	    if ((character > 0xFF) || argv[1][charLen]) {
 		goto badXchar;
 	    }
 	    iostate.c_cc[VSTOP] = character;
 	}
-	Tcl_Free(argv);
+	ckfree(argv);
 
 	tcsetattr(fsPtr->fileState.fd, TCSADRAIN, &iostate);
 	return TCL_OK;
     }
 
@@ -793,18 +793,18 @@
 			"bad value for -ttycontrol: should be a list of"
 			" signal,value pairs", -1));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "FCONFIGURE",
 			"VALUE", NULL);
 	    }
-	    Tcl_Free(argv);
+	    ckfree(argv);
 	    return TCL_ERROR;
 	}
 
 	ioctl(fsPtr->fileState.fd, TIOCMGET, &control);
 	for (i = 0; i < argc-1; i += 2) {
 	    if (Tcl_GetBoolean(interp, argv[i+1], &flag) == TCL_ERROR) {
-		Tcl_Free(argv);
+		ckfree(argv);
 		return TCL_ERROR;
 	    }
 	    if (Tcl_UtfNcasecmp(argv[i], "DTR", strlen(argv[i])) == 0) {
 		if (flag) {
 		    SET_BITS(control, TIOCM_DTR);
@@ -824,11 +824,11 @@
 		} else {
 		    ioctl(fsPtr->fileState.fd, TIOCCBRK, NULL);
 		}
 #else /* TIOCSBRK & TIOCCBRK */
 		UNSUPPORTED_OPTION("-ttycontrol BREAK");
-		Tcl_Free(argv);
+		ckfree(argv);
 		return TCL_ERROR;
 #endif /* TIOCSBRK & TIOCCBRK */
 	    } else {
 		if (interp) {
 		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
@@ -835,17 +835,17 @@
 			    "bad signal \"%s\" for -ttycontrol: must be"
 			    " DTR, RTS or BREAK", argv[i]));
 		    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "FCONFIGURE",
 			"VALUE", NULL);
 		}
-		Tcl_Free(argv);
+		ckfree(argv);
 		return TCL_ERROR;
 	    }
 	} /* -ttycontrol options loop */
 
 	ioctl(fsPtr->fileState.fd, TIOCMSET, &control);
-	Tcl_Free(argv);
+	ckfree(argv);
 	return TCL_OK;
 #else /* TIOCMGET&TIOCMSET */
 	UNSUPPORTED_OPTION("-ttycontrol");
 #endif /* TIOCMGET&TIOCMSET */
     }
@@ -982,11 +982,11 @@
     Tcl_Interp *interp,		/* For error reporting - can be NULL. */
     const char *optionName,	/* Option to get. */
     Tcl_DString *dsPtr)		/* Where to store value(s). */
 {
     TtyState *fsPtr = instanceData;
-    size_t len;
+    unsigned int len;
     char buf[3*TCL_INTEGER_SPACE + 16];
     int valid = 0;		/* Flag if valid option parsed. */
     struct termios iostate;
 
     if (optionName == NULL) {
@@ -1710,11 +1710,11 @@
 	translation = NULL;
 	channelTypePtr = &fileChannelType;
 	sprintf(channelName, "file%d", fd);
     }
 
-    fsPtr = Tcl_Alloc(sizeof(TtyState));
+    fsPtr = ckalloc(sizeof(TtyState));
     fsPtr->fileState.validMask = channelPermissions | TCL_EXCEPTION;
     fsPtr->fileState.fd = fd;
 #ifdef SUPPORTS_TTY
     if (channelTypePtr == &ttyChannelType) {
 	fsPtr->closeMode = CLOSE_DEFAULT;
@@ -1769,41 +1769,36 @@
 {
     TtyState *fsPtr;
     char channelName[16 + TCL_INTEGER_SPACE];
     int fd = PTR2INT(handle);
     const Tcl_ChannelType *channelTypePtr;
-    struct stat buf;
+    struct sockaddr sockaddr;
+    socklen_t sockaddrLen = sizeof(sockaddr);
 
     if (mode == 0) {
 	return NULL;
     }
+
+    sockaddr.sa_family = AF_UNSPEC;
 
 #ifdef SUPPORTS_TTY
     if (isatty(fd)) {
 	channelTypePtr = &ttyChannelType;
 	sprintf(channelName, "serial%d", fd);
     } else
 #endif /* SUPPORTS_TTY */
-    if (fstat(fd, &buf) == 0 && S_ISSOCK(buf.st_mode)) {
-	struct sockaddr sockaddr;
-	socklen_t sockaddrLen = sizeof(sockaddr);
-
-	sockaddr.sa_family = AF_UNSPEC;
-	if ((getsockname(fd, (struct sockaddr *)&sockaddr, &sockaddrLen) == 0)
-		&& (sockaddrLen > 0)
-		&& (sockaddr.sa_family == AF_INET
-			|| sockaddr.sa_family == AF_INET6)) {
-	    return TclpMakeTcpClientChannelMode(INT2PTR(fd), mode);
-	}
-	goto normalChannelAfterAll;
+    if ((getsockname(fd, (struct sockaddr *) &sockaddr, &sockaddrLen) == 0)
+	    && (sockaddrLen > 0)
+	    && (sockaddr.sa_family == AF_INET
+		    || sockaddr.sa_family == AF_INET6)) {
+	return TclpMakeTcpClientChannelMode(INT2PTR(fd), mode);
     } else {
-    normalChannelAfterAll:
 	channelTypePtr = &fileChannelType;
 	sprintf(channelName, "file%d", fd);
     }
 
-    fsPtr = Tcl_Alloc(sizeof(TtyState));
+    fsPtr = ckalloc(sizeof(TtyState));
     fsPtr->fileState.fd = fd;
     fsPtr->fileState.validMask = mode | TCL_EXCEPTION;
     fsPtr->fileState.channel = Tcl_CreateChannel(channelTypePtr, channelName,
 	    fsPtr, mode);
 #ifdef SUPPORTS_TTY

Index: unix/tclUnixCompat.c
==================================================================
--- unix/tclUnixCompat.c
+++ unix/tclUnixCompat.c
@@ -6,10 +6,12 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  */
 
 #include "tclInt.h"
+#include <pwd.h>
+#include <grp.h>
 #include <errno.h>
 #include <string.h>
 
 /*
  * See also: SC_BLOCKING_STYLE in unix/tcl.m4
@@ -197,11 +199,11 @@
     if (tsdPtr->pbuf == NULL) {
 	tsdPtr->pbuflen = (int) sysconf(_SC_GETPW_R_SIZE_MAX);
 	if (tsdPtr->pbuflen < 1) {
 	    tsdPtr->pbuflen = 1024;
 	}
-	tsdPtr->pbuf = Tcl_Alloc(tsdPtr->pbuflen);
+	tsdPtr->pbuf = ckalloc(tsdPtr->pbuflen);
 	Tcl_CreateThreadExitHandler(FreePwBuf, NULL);
     }
     while (1) {
 	int e = getpwnam_r(name, &tsdPtr->pwd, tsdPtr->pbuf, tsdPtr->pbuflen,
 		&pwPtr);
@@ -210,11 +212,11 @@
 	    break;
 	} else if (e != ERANGE) {
 	    return NULL;
 	}
 	tsdPtr->pbuflen *= 2;
-	tsdPtr->pbuf = Tcl_Realloc(tsdPtr->pbuf, tsdPtr->pbuflen);
+	tsdPtr->pbuf = ckrealloc(tsdPtr->pbuf, tsdPtr->pbuflen);
     }
     return (pwPtr != NULL ? &tsdPtr->pwd : NULL);
 
 #elif defined(HAVE_GETPWNAM_R_4)
     return getpwnam_r(name, &tsdPtr->pwd, tsdPtr->pbuf, sizeof(tsdPtr->pbuf));
@@ -277,11 +279,11 @@
     if (tsdPtr->pbuf == NULL) {
 	tsdPtr->pbuflen = (int) sysconf(_SC_GETPW_R_SIZE_MAX);
 	if (tsdPtr->pbuflen < 1) {
 	    tsdPtr->pbuflen = 1024;
 	}
-	tsdPtr->pbuf = Tcl_Alloc(tsdPtr->pbuflen);
+	tsdPtr->pbuf = ckalloc(tsdPtr->pbuflen);
 	Tcl_CreateThreadExitHandler(FreePwBuf, NULL);
     }
     while (1) {
 	int e = getpwuid_r(uid, &tsdPtr->pwd, tsdPtr->pbuf, tsdPtr->pbuflen,
 		&pwPtr);
@@ -290,11 +292,11 @@
 	    break;
 	} else if (e != ERANGE) {
 	    return NULL;
 	}
 	tsdPtr->pbuflen *= 2;
-	tsdPtr->pbuf = Tcl_Realloc(tsdPtr->pbuf, tsdPtr->pbuflen);
+	tsdPtr->pbuf = ckrealloc(tsdPtr->pbuf, tsdPtr->pbuflen);
     }
     return (pwPtr != NULL ? &tsdPtr->pwd : NULL);
 
 #elif defined(HAVE_GETPWUID_R_4)
     return getpwuid_r(uid, &tsdPtr->pwd, tsdPtr->pbuf, sizeof(tsdPtr->pbuf));
@@ -336,11 +338,11 @@
 FreePwBuf(
     ClientData ignored)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
-    Tcl_Free(tsdPtr->pbuf);
+    ckfree(tsdPtr->pbuf);
 }
 #endif /* NEED_PW_CLEANER */
 
 /*
  *---------------------------------------------------------------------------
@@ -380,11 +382,11 @@
     if (tsdPtr->gbuf == NULL) {
 	tsdPtr->gbuflen = (int) sysconf(_SC_GETGR_R_SIZE_MAX);
 	if (tsdPtr->gbuflen < 1) {
 	    tsdPtr->gbuflen = 1024;
 	}
-	tsdPtr->gbuf = Tcl_Alloc(tsdPtr->gbuflen);
+	tsdPtr->gbuf = ckalloc(tsdPtr->gbuflen);
 	Tcl_CreateThreadExitHandler(FreeGrBuf, NULL);
     }
     while (1) {
 	int e = getgrnam_r(name, &tsdPtr->grp, tsdPtr->gbuf, tsdPtr->gbuflen,
 		&grPtr);
@@ -393,11 +395,11 @@
 	    break;
 	} else if (e != ERANGE) {
 	    return NULL;
 	}
 	tsdPtr->gbuflen *= 2;
-	tsdPtr->gbuf = Tcl_Realloc(tsdPtr->gbuf, tsdPtr->gbuflen);
+	tsdPtr->gbuf = ckrealloc(tsdPtr->gbuf, tsdPtr->gbuflen);
     }
     return (grPtr != NULL ? &tsdPtr->grp : NULL);
 
 #elif defined(HAVE_GETGRNAM_R_4)
     return getgrnam_r(name, &tsdPtr->grp, tsdPtr->gbuf, sizeof(tsdPtr->gbuf));
@@ -460,11 +462,11 @@
     if (tsdPtr->gbuf == NULL) {
 	tsdPtr->gbuflen = (int) sysconf(_SC_GETGR_R_SIZE_MAX);
 	if (tsdPtr->gbuflen < 1) {
 	    tsdPtr->gbuflen = 1024;
 	}
-	tsdPtr->gbuf = Tcl_Alloc(tsdPtr->gbuflen);
+	tsdPtr->gbuf = ckalloc(tsdPtr->gbuflen);
 	Tcl_CreateThreadExitHandler(FreeGrBuf, NULL);
     }
     while (1) {
 	int e = getgrgid_r(gid, &tsdPtr->grp, tsdPtr->gbuf, tsdPtr->gbuflen,
 		&grPtr);
@@ -473,11 +475,11 @@
 	    break;
 	} else if (e != ERANGE) {
 	    return NULL;
 	}
 	tsdPtr->gbuflen *= 2;
-	tsdPtr->gbuf = Tcl_Realloc(tsdPtr->gbuf, tsdPtr->gbuflen);
+	tsdPtr->gbuf = ckrealloc(tsdPtr->gbuf, tsdPtr->gbuflen);
     }
     return (grPtr != NULL ? &tsdPtr->grp : NULL);
 
 #elif defined(HAVE_GETGRGID_R_4)
     return getgrgid_r(gid, &tsdPtr->grp, tsdPtr->gbuf, sizeof(tsdPtr->gbuf));
@@ -519,11 +521,11 @@
 FreeGrBuf(
     ClientData ignored)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
-    Tcl_Free(tsdPtr->gbuf);
+    ckfree(tsdPtr->gbuf);
 }
 #endif /* NEED_GR_CLEANER */
 
 /*
  *---------------------------------------------------------------------------
@@ -681,12 +683,12 @@
 CopyGrp(
     struct group *tgtPtr,
     char *buf,
     int buflen)
 {
-    register char *p = buf;
-    register int copied, len = 0;
+    char *p = buf;
+    int copied, len = 0;
 
     /*
      * Copy username.
      */
 
@@ -883,11 +885,11 @@
 				 * length. */
     char *buf,			/* Buffer to copy into. */
     int buflen)			/* Size of buffer. */
 {
     int i, j, len = 0;
-    char *p, **new;
+    char *p, **newBuffer;
 
     if (src == NULL) {
 	return 0;
     }
 
@@ -899,11 +901,11 @@
     len = sizeof(char *) * (i + 1);	/* Leave place for the array. */
     if (len >  buflen) {
 	return -1;
     }
 
-    new = (char **) buf;
+    newBuffer = (char **) buf;
     p = buf + len;
 
     for (j = 0; j < i; j++) {
 	int sz = (elsize<0 ? (int) strlen(src[j]) + 1 : elsize);
 
@@ -910,14 +912,14 @@
 	len += sz;
 	if (len > buflen) {
 	    return -1;
 	}
 	memcpy(p, src[j], sz);
-	new[j] = p;
+	newBuffer[j] = p;
 	p = buf + len;
     }
-    new[j] = NULL;
+    newBuffer[j] = NULL;
 
     return len;
 }
 #endif /* NEED_COPYARRAY */
 

Index: unix/tclUnixFCmd.c
==================================================================
--- unix/tclUnixFCmd.c
+++ unix/tclUnixFCmd.c
@@ -39,10 +39,12 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGE.
  */
 
 #include "tclInt.h"
+#include <utime.h>
+#include <grp.h>
 #ifndef HAVE_STRUCT_STAT_ST_BLKSIZE
 #ifndef NO_FSTATFS
 #include <sys/statfs.h>
 #endif
 #endif /* !HAVE_STRUCT_STAT_ST_BLKSIZE */
@@ -550,11 +552,11 @@
     const Tcl_StatBuf *statBufPtr,
 				/* Used to determine mode and blocksize. */
     int dontCopyAtts)		/* If flag set, don't copy attributes. */
 {
     int srcFd, dstFd;
-    size_t blockSize;		/* Optimal I/O blocksize for filesystem */
+    unsigned blockSize;		/* Optimal I/O blocksize for filesystem */
     char *buffer;		/* Data buffer for copy */
     size_t nread;
 
 #ifdef DJGPP
 #define BINMODE |O_BINARY
@@ -606,25 +608,25 @@
      */
 
     if (blockSize <= 0) {
 	blockSize = DEFAULT_COPY_BLOCK_SIZE;
     }
-    buffer = Tcl_Alloc(blockSize);
+    buffer = ckalloc(blockSize);
     while (1) {
-	nread = read(srcFd, buffer, blockSize);
-	if ((nread == TCL_IO_FAILURE) || (nread == 0)) {
+	nread = (size_t) read(srcFd, buffer, blockSize);
+	if ((nread == (size_t) -1) || (nread == 0)) {
 	    break;
 	}
 	if ((size_t) write(dstFd, buffer, nread) != nread) {
-	    nread = TCL_IO_FAILURE;
+	    nread = (size_t) -1;
 	    break;
 	}
     }
 
-    Tcl_Free(buffer);
+    ckfree(buffer);
     close(srcFd);
-    if ((close(dstFd) != 0) || (nread == TCL_IO_FAILURE)) {
+    if ((close(dstFd) != 0) || (nread == (size_t) -1)) {
 	unlink(dst);					/* INTL: Native. */
 	return TCL_ERROR;
     }
     if (!dontCopyAtts && CopyFileAtts(src, dst, statBufPtr) == TCL_ERROR) {
 	/*
@@ -956,12 +958,12 @@
     				 * source hierarchy, e.g. by deleting
     				 * files. */
 {
     Tcl_StatBuf statBuf;
     const char *source, *errfile;
-    int result;
-    size_t targetLen, sourceLen;
+    int result, sourceLen;
+    int targetLen;
 #ifndef HAVE_FTS
     int numProcessed = 0;
     Tcl_DirEntry *dirEntPtr;
     TclDIR *dirPtr;
 #else
@@ -1311,12 +1313,12 @@
 	if (chmod(dst, newMode)) {			/* INTL: Native. */
 	    return TCL_ERROR;
 	}
     }
 
-    tval.actime = statBufPtr->st_atime;
-    tval.modtime = statBufPtr->st_mtime;
+    tval.actime = Tcl_GetAccessTimeFromStat(statBufPtr);
+    tval.modtime = Tcl_GetModificationTimeFromStat(statBufPtr);
 
     if (utime(dst, &tval)) {				/* INTL: Native. */
 	return TCL_ERROR;
     }
 #ifdef MAC_OSX_TCL
@@ -1503,15 +1505,14 @@
 
     if (Tcl_GetWideIntFromObj(NULL, attributePtr, &gid) != TCL_OK) {
 	Tcl_DString ds;
 	struct group *groupPtr = NULL;
 	const char *string;
-	size_t length;
 
-	string = TclGetStringFromObj(attributePtr, &length);
+	string = TclGetString(attributePtr);
 
-	native = Tcl_UtfToExternalDString(NULL, string, length, &ds);
+	native = Tcl_UtfToExternalDString(NULL, string, attributePtr->length, &ds);
 	groupPtr = TclpGetGrNam(native); /* INTL: Native. */
 	Tcl_DStringFree(&ds);
 
 	if (groupPtr == NULL) {
 	    if (interp != NULL) {
@@ -1570,15 +1571,14 @@
 
     if (Tcl_GetWideIntFromObj(NULL, attributePtr, &uid) != TCL_OK) {
 	Tcl_DString ds;
 	struct passwd *pwPtr = NULL;
 	const char *string;
-	size_t length;
 
-	string = TclGetStringFromObj(attributePtr, &length);
+	string = TclGetString(attributePtr);
 
-	native = Tcl_UtfToExternalDString(NULL, string, length, &ds);
+	native = Tcl_UtfToExternalDString(NULL, string, attributePtr->length, &ds);
 	pwPtr = TclpGetPwNam(native);			/* INTL: Native. */
 	Tcl_DStringFree(&ds);
 
 	if (pwPtr == NULL) {
 	    if (interp != NULL) {
@@ -1943,12 +1943,12 @@
     Tcl_Obj *pathPtr,
     int nextCheckpoint)
 {
     const char *currentPathEndPosition;
     char cur;
-    size_t pathLen;
-    const char *path = TclGetStringFromObj(pathPtr, &pathLen);
+    const char *path = TclGetString(pathPtr);
+    size_t pathLen = pathPtr->length;
     Tcl_DString ds;
     const char *nativePath;
 #ifndef NO_REALPATH
     char normPath[MAXPATHLEN];
 #endif
@@ -2052,11 +2052,11 @@
 	    return 0;
 	}
 
 	nativePath = Tcl_UtfToExternalDString(NULL, path,nextCheckpoint, &ds);
 	if (Realpath(nativePath, normPath) != NULL) {
-	    size_t newNormLen;
+	    int newNormLen;
 
 	wholeStringOk:
 	    newNormLen = strlen(normPath);
 	    if ((newNormLen == Tcl_DStringLength(&ds))
 		    && (strcmp(normPath, nativePath) == 0)) {
@@ -2086,11 +2086,11 @@
 	     * Free up the native path and put in its place the converted,
 	     * normalized path.
 	     */
 
 	    Tcl_DStringFree(&ds);
-	    Tcl_ExternalToUtfDString(NULL, normPath, newNormLen, &ds);
+	    Tcl_ExternalToUtfDString(NULL, normPath, (int) newNormLen, &ds);
 
 	    if (path[nextCheckpoint] != '\0') {
 		/*
 		 * Not at end, append remaining path.
 		 */
@@ -2174,29 +2174,28 @@
     Tcl_Obj *resultingNameObj)
 {
     Tcl_DString template, tmp;
     const char *string;
     int fd;
-    size_t length;
 
     /*
      * We should also check against making more then TMP_MAX of these.
      */
 
     if (dirObj) {
-	string = TclGetStringFromObj(dirObj, &length);
-	Tcl_UtfToExternalDString(NULL, string, length, &template);
+	string = TclGetString(dirObj);
+	Tcl_UtfToExternalDString(NULL, string, dirObj->length, &template);
     } else {
 	Tcl_DStringInit(&template);
 	Tcl_DStringAppend(&template, DefaultTempDir(), -1); /* INTL: native */
     }
 
     TclDStringAppendLiteral(&template, "/");
 
     if (basenameObj) {
-	string = TclGetStringFromObj(basenameObj, &length);
-	Tcl_UtfToExternalDString(NULL, string, length, &tmp);
+	string = TclGetString(basenameObj);
+	Tcl_UtfToExternalDString(NULL, string, basenameObj->length, &tmp);
 	TclDStringAppendDString(&template, &tmp);
 	Tcl_DStringFree(&tmp);
     } else {
 	TclDStringAppendLiteral(&template, "tcl");
     }
@@ -2203,12 +2202,12 @@
 
     TclDStringAppendLiteral(&template, "_XXXXXX");
 
 #ifdef HAVE_MKSTEMPS
     if (extensionObj) {
-	string = TclGetStringFromObj(extensionObj, &length);
-	Tcl_UtfToExternalDString(NULL, string, length, &tmp);
+	string = TclGetString(extensionObj);
+	Tcl_UtfToExternalDString(NULL, string, extensionObj->length, &tmp);
 	TclDStringAppendDString(&template, &tmp);
 	fd = mkstemps(Tcl_DStringValue(&template), Tcl_DStringLength(&tmp));
 	Tcl_DStringFree(&tmp);
     } else
 #endif
@@ -2368,16 +2367,16 @@
 
 static WCHAR *
 winPathFromObj(
     Tcl_Obj *fileName)
 {
-    size_t size;
+    int size;
     const char *native =  Tcl_FSGetNativePath(fileName);
     WCHAR *winPath;
 
     size = cygwin_conv_path(1, native, NULL, 0);
-    winPath = Tcl_Alloc(size);
+    winPath = ckalloc(size);
     cygwin_conv_path(1, native, winPath, size);
 
     return winPath;
 }
 
@@ -2411,11 +2410,11 @@
 {
     int fileAttributes;
     WCHAR *winPath = winPathFromObj(fileName);
 
     fileAttributes = GetFileAttributesW(winPath);
-    Tcl_Free(winPath);
+    ckfree(winPath);
 
     if (fileAttributes == -1) {
 	StatError(interp, fileName);
 	return TCL_ERROR;
     }
@@ -2458,11 +2457,11 @@
     winPath = winPathFromObj(fileName);
 
     fileAttributes = old = GetFileAttributesW(winPath);
 
     if (fileAttributes == -1) {
-	Tcl_Free(winPath);
+	ckfree(winPath);
 	StatError(interp, fileName);
 	return TCL_ERROR;
     }
 
     if (yesNo) {
@@ -2471,16 +2470,16 @@
 	fileAttributes &= ~attributeArray[objIndex];
     }
 
     if ((fileAttributes != old)
 	    && !SetFileAttributesW(winPath, fileAttributes)) {
-	Tcl_Free(winPath);
+	ckfree(winPath);
 	StatError(interp, fileName);
 	return TCL_ERROR;
     }
 
-    Tcl_Free(winPath);
+    ckfree(winPath);
     return TCL_OK;
 }
 #elif defined(HAVE_CHFLAGS) && defined(UF_IMMUTABLE)
 /*
  *----------------------------------------------------------------------

Index: unix/tclUnixFile.c
==================================================================
--- unix/tclUnixFile.c
+++ unix/tclUnixFile.c
@@ -39,11 +39,11 @@
     const char *argv0)		/* The value of the application's argv[0]
 				 * (native). */
 {
     Tcl_Encoding encoding;
 #ifdef __CYGWIN__
-    size_t length;
+    int length;
     char buf[PATH_MAX * 2];
     char name[PATH_MAX * TCL_UTF_MAX + 1];
     GetModuleFileNameW(NULL, buf, PATH_MAX);
     cygwin_conv_path(3, buf, name, PATH_MAX);
     length = strlen(name);
@@ -267,11 +267,12 @@
 	Tcl_StatBuf statBuf;
 	Tcl_DString ds;		/* native encoding of dir */
 	Tcl_DString dsOrig;	/* utf-8 encoding of dir */
 
 	Tcl_DStringInit(&dsOrig);
-	dirName = TclGetStringFromObj(fileNamePtr, &dirLength);
+	dirName = TclGetString(fileNamePtr);
+	dirLength = fileNamePtr->length;
 	Tcl_DStringAppend(&dsOrig, dirName, dirLength);
 
 	/*
 	 * Make sure that the directory part of the name really is a
 	 * directory. If the directory name is "", use the name "." instead,
@@ -717,11 +718,11 @@
 	return NULL;
     }
 #endif /* USEGETWD */
 
     if ((clientData == NULL) || strcmp(buffer, (const char *) clientData)) {
-	char *newCd = Tcl_Alloc(strlen(buffer) + 1);
+	char *newCd = ckalloc(strlen(buffer) + 1);
 
 	strcpy(newCd, buffer);
 	return newCd;
     }
 
@@ -937,11 +938,10 @@
 	 */
 
 	if (linkAction & TCL_CREATE_SYMBOLIC_LINK) {
 	    Tcl_DString ds;
 	    Tcl_Obj *transPtr;
-	    size_t length;
 
 	    /*
 	     * Now we don't want to link to the absolute, normalized path.
 	     * Relative links are quite acceptable (but links to ~user are not
 	     * -- these must be expanded first).
@@ -949,12 +949,12 @@
 
 	    transPtr = Tcl_FSGetTranslatedPath(NULL, toPtr);
 	    if (transPtr == NULL) {
 		return NULL;
 	    }
-	    target = TclGetStringFromObj(transPtr, &length);
-	    target = Tcl_UtfToExternalDString(NULL, target, length, &ds);
+	    target = TclGetString(transPtr);
+	    target = Tcl_UtfToExternalDString(NULL, target, transPtr->length, &ds);
 	    Tcl_DecrRefCount(transPtr);
 
 	    if (symlink(target, src) != 0) {
 		toPtr = NULL;
 	    }
@@ -1103,21 +1103,22 @@
 	    return NULL;
 	}
 	Tcl_IncrRefCount(validPathPtr);
     }
 
-    str = TclGetStringFromObj(validPathPtr, &len);
+    str = TclGetString(validPathPtr);
+    len = validPathPtr->length;
     Tcl_UtfToExternalDString(NULL, str, len, &ds);
     len = Tcl_DStringLength(&ds) + sizeof(char);
     if (strlen(Tcl_DStringValue(&ds)) < len - sizeof(char)) {
 	/* See bug [3118489]: NUL in filenames */
 	Tcl_DecrRefCount(validPathPtr);
 	Tcl_DStringFree(&ds);
 	return NULL;
     }
     Tcl_DecrRefCount(validPathPtr);
-    nativePathPtr = Tcl_Alloc(len);
+    nativePathPtr = ckalloc(len);
     memcpy(nativePathPtr, Tcl_DStringValue(&ds), len);
 
     Tcl_DStringFree(&ds);
     return nativePathPtr;
 }
@@ -1154,11 +1155,11 @@
      * ASCII representation when running on Unix.
      */
 
     len = (strlen((const char*) clientData) + 1) * sizeof(char);
 
-    copy = Tcl_Alloc(len);
+    copy = ckalloc(len);
     memcpy(copy, clientData, len);
     return copy;
 }
 
 /*

Index: unix/tclUnixInit.c
==================================================================
--- unix/tclUnixInit.c
+++ unix/tclUnixInit.c
@@ -7,12 +7,10 @@
  * Copyright (c) 1999 by Scriptics Corporation.
  * All rights reserved.
  */
 
 #include "tclInt.h"
-#include <stddef.h>
-#include <locale.h>
 #ifdef HAVE_LANGINFO
 #   include <langinfo.h>
 #   ifdef __APPLE__
 #	if defined(HAVE_WEAK_IMPORT) && MAC_OS_X_VERSION_MIN_REQUIRED < 1030
 	    /* Support for weakly importing nl_langinfo on Darwin. */
@@ -333,11 +331,11 @@
 /*
  *---------------------------------------------------------------------------
  *
  * TclpInitPlatform --
  *
- *	Initialize all the platform-dependant things like signals and
+ *	Initialize all the platform-dependent things like signals and
  *	floating-point error handling.
  *
  *	Called at process initialization time.
  *
  * Results:
@@ -409,11 +407,11 @@
     setlocale(LC_CTYPE, "");
 
     /*
      * In case the initial locale is not "C", ensure that the numeric
      * processing is done in "C" locale regardless. This is needed because Tcl
-     * relies on routines like strtod, but should not have locale dependent
+     * relies on routines like strtol/strtoul, but should not have locale dependent
      * behavior.
      */
 
     setlocale(LC_NUMERIC, "C");
 
@@ -446,11 +444,11 @@
  */
 
 void
 TclpInitLibraryPath(
     char **valuePtr,
-    size_t *lengthPtr,
+    unsigned int *lengthPtr,
     Tcl_Encoding *encodingPtr)
 {
 #define LIBRARY_SIZE	    32
     Tcl_Obj *pathPtr, *objPtr;
     const char *str;
@@ -503,11 +501,11 @@
 
 	    pathv[pathc - 1] = installLib + 4;
 	    str = Tcl_JoinPath(pathc, pathv, &ds);
 	    Tcl_ListObjAppendElement(NULL, pathPtr, TclDStringToObj(&ds));
 	}
-	Tcl_Free(pathv);
+	ckfree(pathv);
     }
 
     /*
      * Finally, look for the library relative to the compiled-in path. This is
      * needed when users install Tcl with an exec-prefix that is different
@@ -535,12 +533,13 @@
 	}
     }
     Tcl_DStringFree(&buffer);
 
     *encodingPtr = Tcl_GetEncoding(NULL, NULL);
-    str = TclGetStringFromObj(pathPtr, lengthPtr);
-    *valuePtr = Tcl_Alloc(*lengthPtr + 1);
+    str = TclGetString(pathPtr);
+    *lengthPtr = pathPtr->length;
+    *valuePtr = ckalloc(*lengthPtr + 1);
     memcpy(*valuePtr, str, *lengthPtr + 1);
     Tcl_DecrRefCount(pathPtr);
 }
 
 /*
@@ -978,31 +977,31 @@
  *	Locate the entry in environ for a given name. On Unix this routine is
  *	case sensetive, on Windows this matches mixed case.
  *
  * Results:
  *	The return value is the index in environ of an entry with the name
- *	"name", or TCL_IO_FAILURE if there is no such entry. The integer at *lengthPtr is
+ *	"name", or -1 if there is no such entry. The integer at *lengthPtr is
  *	filled in with the length of name (if a matching entry is found) or
  *	the length of the environ array (if no matching entry is found).
  *
  * Side effects:
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 TclpFindVariable(
     const char *name,		/* Name of desired environment variable
 				 * (native). */
-    size_t *lengthPtr)		/* Used to return length of name (for
+    int *lengthPtr)		/* Used to return length of name (for
 				 * successful searches) or number of non-NULL
 				 * entries in environ (for unsuccessful
 				 * searches). */
 {
-    size_t i, result = TCL_IO_FAILURE;
-    register const char *env, *p1, *p2;
+    int i, result = -1;
+    const char *env, *p1, *p2;
     Tcl_DString envString;
 
     Tcl_DStringInit(&envString);
     for (i = 0, env = environ[i]; env != NULL; i++, env = environ[i]) {
 	p1 = Tcl_ExternalToUtfDString(NULL, env, -1, &envString);

Index: unix/tclUnixPipe.c
==================================================================
--- unix/tclUnixPipe.c
+++ unix/tclUnixPipe.c
@@ -522,11 +522,11 @@
 
     TclpCloseFile(errPipeOut);
     errPipeOut = NULL;
 
     fd = GetFd(errPipeIn);
-    count = read(fd, errSpace, sizeof(errSpace) - 1);
+    count = read(fd, errSpace, (size_t) (sizeof(errSpace) - 1));
     if (count > 0) {
 	char *end;
 
 	errSpace[count] = 0;
 	errno = strtol(errSpace, &end, 10);
@@ -742,11 +742,11 @@
 				 * closed or the processes are detached (in a
 				 * background exec). */
 {
     char channelName[16 + TCL_INTEGER_SPACE];
     int channelId;
-    PipeState *statePtr = Tcl_Alloc(sizeof(PipeState));
+    PipeState *statePtr = ckalloc(sizeof(PipeState));
     int mode;
 
     statePtr->inFile = readFile;
     statePtr->outFile = writeFile;
     statePtr->errorFile = errorFile;
@@ -876,11 +876,11 @@
 		PTR2INT(pipePtr->pidPtr[i])));
 	Tcl_DetachPids(1, &pipePtr->pidPtr[i]);
     }
     Tcl_SetObjResult(interp, pidsObj);
     if (pipePtr->numPids > 0) {
-	Tcl_Free(pipePtr->pidPtr);
+	ckfree(pipePtr->pidPtr);
 	pipePtr->numPids = 0;
     }
 }
 
 /*
@@ -1007,13 +1007,13 @@
 	result = TclCleanupChildren(interp, pipePtr->numPids, pipePtr->pidPtr,
 		errChan);
     }
 
     if (pipePtr->numPids != 0) {
-	Tcl_Free(pipePtr->pidPtr);
+	ckfree(pipePtr->pidPtr);
     }
-    Tcl_Free(pipePtr);
+    ckfree(pipePtr);
     if (errorCode == 0) {
 	return result;
     }
     return errorCode;
 }
@@ -1057,11 +1057,11 @@
      * nonblocking, the read will never block. Some OSes can throw an
      * interrupt error, for which we should immediately retry. [Bug #415131]
      */
 
     do {
-	bytesRead = read(GetFd(psPtr->inFile), buf, toRead);
+	bytesRead = read(GetFd(psPtr->inFile), buf, (size_t) toRead);
     } while ((bytesRead < 0) && (errno == EINTR));
 
     if (bytesRead < 0) {
 	*errorCodePtr = errno;
 	return -1;
@@ -1103,11 +1103,11 @@
      * Some OSes can throw an interrupt error, for which we should immediately
      * retry. [Bug #415131]
      */
 
     do {
-	written = write(GetFd(psPtr->outFile), buf, toWrite);
+	written = write(GetFd(psPtr->outFile), buf, (size_t) toWrite);
     } while ((written < 0) && (errno == EINTR));
 
     if (written < 0) {
 	*errorCodePtr = errno;
 	return -1;
@@ -1272,11 +1272,11 @@
     } else {
 	/*
 	 * Get the channel and make sure that it refers to a pipe.
 	 */
 
-	chan = Tcl_GetChannel(interp, TclGetString(objv[1]), NULL);
+	chan = Tcl_GetChannel(interp, Tcl_GetString(objv[1]), NULL);
 	if (chan == NULL) {
 	    return TCL_ERROR;
 	}
 	if (Tcl_GetChannelType(chan) != &pipeChannelType) {
 	    return TCL_OK;

Index: unix/tclUnixPort.h
==================================================================
--- unix/tclUnixPort.h
+++ unix/tclUnixPort.h
@@ -669,13 +669,13 @@
  *---------------------------------------------------------------------------
  * The following defines wrap the system memory allocation routines.
  *---------------------------------------------------------------------------
  */
 
-#define TclpSysAlloc(size)		malloc(size)
-#define TclpSysFree(ptr)		free(ptr)
-#define TclpSysRealloc(ptr, size)	realloc(ptr, size)
+#define TclpSysAlloc(size, isBin)	malloc((size_t)(size))
+#define TclpSysFree(ptr)		free((char *)(ptr))
+#define TclpSysRealloc(ptr, size)	realloc((char *)(ptr), (size_t)(size))
 
 /*
  *---------------------------------------------------------------------------
  * The following macros and declaration wrap the C runtime library functions.
  *---------------------------------------------------------------------------

Index: unix/tclUnixSock.c
==================================================================
--- unix/tclUnixSock.c
+++ unix/tclUnixSock.c
@@ -215,11 +215,11 @@
  */
 
 static void
 InitializeHostName(
     char **valuePtr,
-    size_t *lengthPtr,
+    unsigned int *lengthPtr,
     Tcl_Encoding *encodingPtr)
 {
     const char *native = NULL;
 
 #ifndef NO_UNAME
@@ -237,16 +237,16 @@
 	     */
 
 	    char *dot = strchr(u.nodename, '.');
 
 	    if (dot != NULL) {
-		char *node = Tcl_Alloc(dot - u.nodename + 1);
+		char *node = ckalloc(dot - u.nodename + 1);
 
 		memcpy(node, u.nodename, dot - u.nodename);
 		node[dot - u.nodename] = '\0';
 		hp = TclpGetHostByName(node);
-		Tcl_Free(node);
+		ckfree(node);
 	    }
 	}
         if (hp != NULL) {
 	    native = hp->h_name;
         } else {
@@ -281,15 +281,15 @@
 #endif /* NO_UNAME */
 
     *encodingPtr = Tcl_GetEncoding(NULL, NULL);
     if (native) {
 	*lengthPtr = strlen(native);
-	*valuePtr = Tcl_Alloc(*lengthPtr + 1);
+	*valuePtr = ckalloc(*lengthPtr + 1);
 	memcpy(*valuePtr, native, *lengthPtr + 1);
     } else {
 	*lengthPtr = 0;
-	*valuePtr = Tcl_Alloc(1);
+	*valuePtr = ckalloc(1);
 	*valuePtr[0] = '\0';
     }
 }
 
 /*
@@ -311,12 +311,11 @@
  */
 
 const char *
 Tcl_GetHostName(void)
 {
-    Tcl_Obj *tclObj = TclGetProcessGlobalValue(&hostName);
-    return TclGetString(tclObj);
+    return Tcl_GetString(TclGetProcessGlobalValue(&hostName));
 }
 
 /*
  * ----------------------------------------------------------------------
  *
@@ -539,11 +538,11 @@
 
     *errorCodePtr = 0;
     if (WaitForConnect(statePtr, errorCodePtr) != 0) {
 	return -1;
     }
-    bytesRead = recv(statePtr->fds.fd, buf, bufSize, 0);
+    bytesRead = recv(statePtr->fds.fd, buf, (size_t) bufSize, 0);
     if (bytesRead > -1) {
 	return bytesRead;
     }
     if (errno == ECONNRESET) {
 	/*
@@ -589,11 +588,11 @@
 
     *errorCodePtr = 0;
     if (WaitForConnect(statePtr, errorCodePtr) != 0) {
 	return -1;
     }
-    written = send(statePtr->fds.fd, buf, toWrite, 0);
+    written = send(statePtr->fds.fd, buf, (size_t) toWrite, 0);
 
     if (written > -1) {
 	return written;
     }
     *errorCodePtr = errno;
@@ -648,20 +647,20 @@
     }
     fds = statePtr->fds.next;
     while (fds != NULL) {
 	TcpFdList *next = fds->next;
 
-	Tcl_Free(fds);
+	ckfree(fds);
 	fds = next;
     }
     if (statePtr->addrlist != NULL) {
         freeaddrinfo(statePtr->addrlist);
     }
     if (statePtr->myaddrlist != NULL) {
         freeaddrinfo(statePtr->myaddrlist);
     }
-    Tcl_Free(statePtr);
+    ckfree(statePtr);
     return errorCode;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1398,11 +1397,11 @@
 
     /*
      * Allocate a new TcpState for this socket.
      */
 
-    statePtr = Tcl_Alloc(sizeof(TcpState));
+    statePtr = ckalloc(sizeof(TcpState));
     memset(statePtr, 0, sizeof(TcpState));
     statePtr->flags = async ? TCP_ASYNC_CONNECT : 0;
     statePtr->cachedBlocking = TCL_MODE_BLOCKING;
     statePtr->addrlist = addrlist;
     statePtr->myaddrlist = myaddrlist;
@@ -1477,11 +1476,11 @@
 				 * TCL_WRITABLE to indicate file mode. */
 {
     TcpState *statePtr;
     char channelName[SOCK_CHAN_LENGTH];
 
-    statePtr = Tcl_Alloc(sizeof(TcpState));
+    statePtr = ckalloc(sizeof(TcpState));
     memset(statePtr, 0, sizeof(TcpState));
     statePtr->fds.fd = PTR2INT(sock);
     statePtr->flags = 0;
 
     sprintf(channelName, SOCK_TEMPLATE, (long)statePtr);
@@ -1700,18 +1699,18 @@
         if (statePtr == NULL) {
             /*
              * Allocate a new TcpState for this socket.
              */
 
-            statePtr = Tcl_Alloc(sizeof(TcpState));
+            statePtr = ckalloc(sizeof(TcpState));
             memset(statePtr, 0, sizeof(TcpState));
             statePtr->acceptProc = acceptProc;
             statePtr->acceptProcData = acceptProcData;
             sprintf(channelName, SOCK_TEMPLATE, (long) statePtr);
             newfds = &statePtr->fds;
         } else {
-            newfds = Tcl_Alloc(sizeof(TcpFdList));
+            newfds = ckalloc(sizeof(TcpFdList));
             memset(newfds, (int) 0, sizeof(TcpFdList));
             fds->next = newfds;
         }
         newfds->fd = sock;
         newfds->statePtr = statePtr;
@@ -1792,11 +1791,11 @@
      * inherited by child processes.
      */
 
     (void) fcntl(newsock, F_SETFD, FD_CLOEXEC);
 
-    newSockState = Tcl_Alloc(sizeof(TcpState));
+    newSockState = ckalloc(sizeof(TcpState));
     memset(newSockState, 0, sizeof(TcpState));
     newSockState->flags = 0;
     newSockState->fds.fd = newsock;
 
     sprintf(channelName, SOCK_TEMPLATE, (long) newSockState);

Index: unix/tclUnixThrd.c
==================================================================
--- unix/tclUnixThrd.c
+++ unix/tclUnixThrd.c
@@ -158,10 +158,18 @@
 {
     pthread_cond_timedwait(pcondPtr, &pmutexPtr->mutex, ptime);
 }
 #endif /* HAVE_PTHREAD_MUTEX_RECURSIVE */
 
+#ifndef TCL_NO_DEPRECATED
+typedef struct {
+    char nabuf[16];
+} ThreadSpecificData;
+
+static Tcl_ThreadDataKey dataKey;
+#endif /* TCL_NO_DEPRECATED */
+
 /*
  * masterLock is used to serialize creation of mutexes, condition variables,
  * and thread local storage. This is the only place that can count on the
  * ability to statically initialize the mutex.
  */
@@ -212,11 +220,11 @@
 int
 TclpThreadCreate(
     Tcl_ThreadId *idPtr,	/* Return, the ID of the thread */
     Tcl_ThreadCreateProc *proc,	/* Main() function of the thread */
     ClientData clientData,	/* The one argument to Main() */
-    size_t stackSize,		/* Size of stack for the new thread */
+    int stackSize,		/* Size of stack for the new thread */
     int flags)			/* Flags controlling behaviour of the new
 				 * thread. */
 {
 #if TCL_THREADS
     pthread_attr_t attr;
@@ -226,11 +234,11 @@
     pthread_attr_init(&attr);
     pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
 
 #ifdef HAVE_PTHREAD_ATTR_SETSTACKSIZE
     if (stackSize != TCL_THREAD_STACK_DEFAULT) {
-	pthread_attr_setstacksize(&attr, stackSize);
+	pthread_attr_setstacksize(&attr, (size_t) stackSize);
 #ifdef TCL_THREAD_STACK_MIN
     } else {
 	/*
 	 * Certain systems define a thread stack size that by default is too
 	 * small for many operations. The user has the option of defining
@@ -567,11 +575,11 @@
 	if (*mutexPtr == NULL) {
 	    /*
 	     * Double inside master lock check to avoid a race condition.
 	     */
 
-	    pmutexPtr = Tcl_Alloc(sizeof(PMutex));
+	    pmutexPtr = ckalloc(sizeof(PMutex));
 	    PMutexInit(pmutexPtr);
 	    *mutexPtr = (Tcl_Mutex) pmutexPtr;
 	    TclRememberMutex(mutexPtr);
 	}
 	pthread_mutex_unlock(&masterLock);
@@ -631,11 +639,11 @@
 {
     PMutex *pmutexPtr = *(PMutex **) mutexPtr;
 
     if (pmutexPtr != NULL) {
 	PMutexDestroy(pmutexPtr);
-	Tcl_Free(pmutexPtr);
+	ckfree(pmutexPtr);
 	*mutexPtr = NULL;
     }
 }
 
 /*
@@ -677,11 +685,11 @@
 	 * Double check inside mutex to avoid race, then initialize condition
 	 * variable if necessary.
 	 */
 
 	if (*condPtr == NULL) {
-	    pcondPtr = Tcl_Alloc(sizeof(pthread_cond_t));
+	    pcondPtr = ckalloc(sizeof(pthread_cond_t));
 	    pthread_cond_init(pcondPtr, NULL);
 	    *condPtr = (Tcl_Condition) pcondPtr;
 	    TclRememberCondition(condPtr);
 	}
 	pthread_mutex_unlock(&masterLock);
@@ -765,15 +773,63 @@
 {
     pthread_cond_t *pcondPtr = *(pthread_cond_t **) condPtr;
 
     if (pcondPtr != NULL) {
 	pthread_cond_destroy(pcondPtr);
-	Tcl_Free(pcondPtr);
+	ckfree(pcondPtr);
 	*condPtr = NULL;
     }
 }
+#endif /* TCL_THREADS */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpReaddir, TclpInetNtoa --
+ *
+ *	These procedures replace core C versions to be used in a threaded
+ *	environment.
+ *
+ * Results:
+ *	See documentation of C functions.
+ *
+ * Side effects:
+ *	See documentation of C functions.
+ *
+ * Notes:
+ *	TclpReaddir is no longer used by the core (see 1095909), but it
+ *	appears in the internal stubs table (see #589526).
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+Tcl_DirEntry *
+TclpReaddir(
+    TclDIR * dir)
+{
+    return TclOSreaddir(dir);
+}
+
+#undef TclpInetNtoa
+char *
+TclpInetNtoa(
+    struct in_addr addr)
+{
+#if TCL_THREADS
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+    unsigned char *b = (unsigned char*) &addr.s_addr;
+
+    sprintf(tsdPtr->nabuf, "%u.%u.%u.%u", b[0], b[1], b[2], b[3]);
+    return tsdPtr->nabuf;
+#else
+    return inet_ntoa(addr);
+#endif
+}
+#endif /* TCL_NO_DEPRECATED */
 
+#if TCL_THREADS
 /*
  * Additions by AOL for specialized thread memory allocator.
  */
 
 #ifdef USE_THREAD_ALLOC
@@ -786,11 +842,11 @@
 
 Tcl_Mutex *
 TclpNewAllocMutex(void)
 {
     AllocMutex *lockPtr;
-    register PMutex *plockPtr;
+    PMutex *plockPtr;
 
     lockPtr = malloc(sizeof(AllocMutex));
     if (lockPtr == NULL) {
 	Tcl_Panic("could not allocate lock");
     }
@@ -859,11 +915,11 @@
 void *
 TclpThreadCreateKey(void)
 {
     pthread_key_t *ptkeyPtr;
 
-    ptkeyPtr = TclpSysAlloc(sizeof(pthread_key_t));
+    ptkeyPtr = TclpSysAlloc(sizeof(pthread_key_t), 0);
     if (NULL == ptkeyPtr) {
 	Tcl_Panic("unable to allocate thread key!");
     }
 
     if (pthread_key_create(ptkeyPtr, NULL)) {

Index: unix/tclUnixTime.c
==================================================================
--- unix/tclUnixTime.c
+++ unix/tclUnixTime.c
@@ -9,18 +9,45 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  */
 
 #include "tclInt.h"
-#include <locale.h>
 #if defined(TCL_WIDE_CLICKS) && defined(MAC_OSX_TCL)
 #include <mach/mach_time.h>
 #endif
 
+/*
+ * TclpGetDate is coded to return a pointer to a 'struct tm'. For thread
+ * safety, this structure must be in thread-specific data. The 'tmKey'
+ * variable is the key to this buffer.
+ */
+
+#ifndef TCL_NO_DEPRECATED
+static Tcl_ThreadDataKey tmKey;
+typedef struct {
+    struct tm gmtime_buf;
+    struct tm localtime_buf;
+} ThreadSpecificData;
+
+/*
+ * If we fall back on the thread-unsafe versions of gmtime and localtime, use
+ * this mutex to try to protect them.
+ */
+
+TCL_DECLARE_MUTEX(tmMutex)
+
+static char *lastTZ = NULL;	/* Holds the last setting of the TZ
+				 * environment variable, or an empty string if
+				 * the variable was not set. */
+
 /*
  * Static functions declared in this file.
  */
+
+static void		SetTZIfNecessary(void);
+static void		CleanupMemory(ClientData clientData);
+#endif /* TCL_NO_DEPRECATED */
 
 static void		NativeScaleTime(Tcl_Time *timebuf,
 			    ClientData clientData);
 static void		NativeGetTime(Tcl_Time *timebuf,
 			    ClientData clientData);
@@ -48,11 +75,11 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-Tcl_WideUInt
+unsigned long
 TclpGetSeconds(void)
 {
     return time(NULL);
 }
 
@@ -88,11 +115,11 @@
  * TclpGetClicks --
  *
  *	This procedure returns a value that represents the highest resolution
  *	clock available on the system. There are no garantees on what the
  *	resolution will be. In Tcl we will call this value a "click". The
- *	start time is also system dependant.
+ *	start time is also system dependent.
  *
  * Results:
  *	Number of clicks from some start time.
  *
  * Side effects:
@@ -99,34 +126,34 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-Tcl_WideUInt
+unsigned long
 TclpGetClicks(void)
 {
-	Tcl_WideUInt now;
+    unsigned long now;
 
 #ifdef NO_GETTOD
     if (tclGetTimeProcPtr != NativeGetTime) {
 	Tcl_Time time;
 
 	tclGetTimeProcPtr(&time, tclTimeClientData);
-	now = (Tcl_WideUInt)time.sec*1000000 + time.usec;
+	now = time.sec*1000000 + time.usec;
     } else {
 	/*
 	 * A semi-NativeGetTime, specialized to clicks.
 	 */
 	struct tms dummy;
 
-	now = (Tcl_WideUInt) times(&dummy);
+	now = (unsigned long) times(&dummy);
     }
 #else
     Tcl_Time time;
 
     tclGetTimeProcPtr(&time, tclTimeClientData);
-    now = (Tcl_WideUInt)time.sec*1000000 + time.usec;
+    now = time.sec*1000000 + time.usec;
 #endif
 
     return now;
 }
 #ifdef TCL_WIDE_CLICKS
@@ -135,11 +162,11 @@
  *----------------------------------------------------------------------
  *
  * TclpGetWideClicks --
  *
  *	This procedure returns a WideInt value that represents the highest
- *	resolution clock available on the system. There are no guarantees on
+ *	resolution clock available on the system. There are no garantees on
  *	what the resolution will be. In Tcl we will call this value a "click".
  *	The start time is also system dependent.
  *
  * Results:
  *	Number of WideInt clicks from some start time.
@@ -292,10 +319,120 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
+ * TclpGetDate --
+ *
+ *	This function converts between seconds and struct tm. If useGMT is
+ *	true, then the returned date will be in Greenwich Mean Time (GMT).
+ *	Otherwise, it will be in the local time zone.
+ *
+ * Results:
+ *	Returns a static tm structure.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+struct tm *
+TclpGetDate(
+    const time_t *time,
+    int useGMT)
+{
+    if (useGMT) {
+	return TclpGmtime(time);
+    } else {
+	return TclpLocaltime(time);
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpGmtime --
+ *
+ *	Wrapper around the 'gmtime' library function to make it thread safe.
+ *
+ * Results:
+ *	Returns a pointer to a 'struct tm' in thread-specific data.
+ *
+ * Side effects:
+ *	Invokes gmtime or gmtime_r as appropriate.
+ *
+ *----------------------------------------------------------------------
+ */
+
+struct tm *
+TclpGmtime(
+    const time_t *timePtr)	/* Pointer to the number of seconds since the
+				 * local system's epoch */
+{
+    /*
+     * Get a thread-local buffer to hold the returned time.
+     */
+
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&tmKey);
+
+#ifdef HAVE_GMTIME_R
+    gmtime_r(timePtr, &tsdPtr->gmtime_buf);
+#else
+    Tcl_MutexLock(&tmMutex);
+    memcpy(&tsdPtr->gmtime_buf, gmtime(timePtr), sizeof(struct tm));
+    Tcl_MutexUnlock(&tmMutex);
+#endif
+
+    return &tsdPtr->gmtime_buf;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpLocaltime --
+ *
+ *	Wrapper around the 'localtime' library function to make it thread
+ *	safe.
+ *
+ * Results:
+ *	Returns a pointer to a 'struct tm' in thread-specific data.
+ *
+ * Side effects:
+ *	Invokes localtime or localtime_r as appropriate.
+ *
+ *----------------------------------------------------------------------
+ */
+
+struct tm *
+TclpLocaltime(
+    const time_t *timePtr)	/* Pointer to the number of seconds since the
+				 * local system's epoch */
+{
+    /*
+     * Get a thread-local buffer to hold the returned time.
+     */
+
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&tmKey);
+
+    SetTZIfNecessary();
+#ifdef HAVE_LOCALTIME_R
+    localtime_r(timePtr, &tsdPtr->localtime_buf);
+#else
+    Tcl_MutexLock(&tmMutex);
+    memcpy(&tsdPtr->localtime_buf, localtime(timePtr), sizeof(struct tm));
+    Tcl_MutexUnlock(&tmMutex);
+#endif
+
+    return &tsdPtr->localtime_buf;
+}
+#endif /* TCL_NO_DEPRECATED */
+
+/*
+ *----------------------------------------------------------------------
+ *
  * Tcl_SetTimeProc --
  *
  *	TIP #233 (Virtualized Time): Registers two handlers for the
  *	virtualization of Tcl's access to time information.
  *
@@ -403,13 +540,79 @@
 
     (void) gettimeofday(&tv, NULL);
     timePtr->sec = tv.tv_sec;
     timePtr->usec = tv.tv_usec;
 }
+/*
+ *----------------------------------------------------------------------
+ *
+ * SetTZIfNecessary --
+ *
+ *	Determines whether a call to 'tzset' is needed prior to the next call
+ *	to 'localtime' or examination of the 'timezone' variable.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	If 'tzset' has never been called in the current process, or if the
+ *	value of the environment variable TZ has changed since the last call
+ *	to 'tzset', then 'tzset' is called again.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+static void
+SetTZIfNecessary(void)
+{
+    const char *newTZ = getenv("TZ");
+
+    Tcl_MutexLock(&tmMutex);
+    if (newTZ == NULL) {
+	newTZ = "";
+    }
+    if (lastTZ == NULL || strcmp(lastTZ, newTZ)) {
+	tzset();
+	if (lastTZ == NULL) {
+	    Tcl_CreateExitHandler(CleanupMemory, NULL);
+	} else {
+	    ckfree(lastTZ);
+	}
+	lastTZ = ckalloc(strlen(newTZ) + 1);
+	strcpy(lastTZ, newTZ);
+    }
+    Tcl_MutexUnlock(&tmMutex);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * CleanupMemory --
+ *
+ *	Releases the private copy of the TZ environment variable upon exit
+ *	from Tcl.
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Frees allocated memory.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+CleanupMemory(
+    ClientData ignored)
+{
+    ckfree(lastTZ);
+}
+#endif /* TCL_NO_DEPRECATED */
 
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 4
  * fill-column: 78
  * End:
  */

Index: unix/tclXtNotify.c
==================================================================
--- unix/tclXtNotify.c
+++ unix/tclXtNotify.c
@@ -266,11 +266,11 @@
 
 static void
 SetTimer(
     const Tcl_Time *timePtr)		/* Timeout value, may be NULL. */
 {
-    unsigned long timeout;
+    long timeout;
 
     if (!initialized) {
 	InitNotifier();
     }
 
@@ -279,11 +279,11 @@
 	XtRemoveTimeOut(notifier.currentTimeout);
     }
     if (timePtr) {
 	timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
 	notifier.currentTimeout = XtAppAddTimeOut(notifier.appContext,
-		timeout, TimerProc, NULL);
+		(unsigned long) timeout, TimerProc, NULL);
     } else {
 	notifier.currentTimeout = 0;
     }
 }
 
@@ -357,11 +357,11 @@
 	if (filePtr->fd == fd) {
 	    break;
 	}
     }
     if (filePtr == NULL) {
-	filePtr = Tcl_Alloc(sizeof(FileHandler));
+	filePtr = ckalloc(sizeof(FileHandler));
 	filePtr->fd = fd;
 	filePtr->read = 0;
 	filePtr->write = 0;
 	filePtr->except = 0;
 	filePtr->readyMask = 0;
@@ -468,11 +468,11 @@
 	XtRemoveInput(filePtr->write);
     }
     if (filePtr->mask & TCL_EXCEPTION) {
 	XtRemoveInput(filePtr->except);
     }
-    Tcl_Free(filePtr);
+    ckfree(filePtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -523,11 +523,11 @@
     /*
      * This is an interesting event, so put it onto the event queue.
      */
 
     filePtr->readyMask |= mask;
-    fileEvPtr = Tcl_Alloc(sizeof(FileHandlerEvent));
+    fileEvPtr = ckalloc(sizeof(FileHandlerEvent));
     fileEvPtr->header.proc = FileHandlerEventProc;
     fileEvPtr->fd = filePtr->fd;
     Tcl_QueueEvent((Tcl_Event *) fileEvPtr, TCL_QUEUE_TAIL);
 
     /*

Index: win/Makefile.in
==================================================================
--- win/Makefile.in
+++ win/Makefile.in
@@ -21,10 +21,11 @@
 exec_prefix		= @exec_prefix@
 bindir			= @bindir@
 libdir			= @libdir@
 includedir		= @includedir@
 datarootdir		= @datarootdir@
+runstatedir		= @runstatedir@
 mandir			= @mandir@
 
 # The following definition can be set to non-null for special systems like AFS
 # with replication. It allows the pathnames used for installation to be
 # different than those used for actually reference files at run-time.
@@ -94,11 +95,11 @@
 #COMPILE_DEBUG_FLAGS = -DTCL_COMPILE_DEBUG
 #COMPILE_DEBUG_FLAGS = -DTCL_COMPILE_DEBUG -DTCL_COMPILE_STATS
 
 SRC_DIR			= @srcdir@
 ROOT_DIR		= @srcdir@/..
-TOP_DIR			= $(shell cd @srcdir@/..; pwd -P)
+TOP_DIR			= $(shell cd @srcdir@/..; pwd -W 2>/dev/null || pwd -P)
 GENERIC_DIR		= $(TOP_DIR)/generic
 TOMMATH_DIR		= $(TOP_DIR)/libtommath
 WIN_DIR			= $(TOP_DIR)/win
 COMPAT_DIR		= $(TOP_DIR)/compat
 PKGS_DIR		= $(TOP_DIR)/pkgs
@@ -114,11 +115,11 @@
 TCL_LIBRARY_NATIVE	= $(shell $(CYGPATH) '$(TCL_LIBRARY)')
 GENERIC_DIR_NATIVE	= $(shell $(CYGPATH) '$(GENERIC_DIR)')
 TOMMATH_DIR_NATIVE	= $(shell $(CYGPATH) '$(TOMMATH_DIR)')
 WIN_DIR_NATIVE		= $(shell $(CYGPATH) '$(WIN_DIR)')
 ROOT_DIR_NATIVE		= $(shell $(CYGPATH) '$(ROOT_DIR)')
-ROOT_DIR_WIN_NATIVE	= $(shell cd '$(ROOT_DIR)' ; pwd -W || pwd -P)
+ROOT_DIR_WIN_NATIVE	= $(shell cd '$(ROOT_DIR)' ; pwd -W 2>/dev/null || pwd -P)
 ZLIB_DIR_NATIVE		= $(shell $(CYGPATH) '$(ZLIB_DIR)')
 #GENERIC_DIR_NATIVE	= $(GENERIC_DIR)
 #TOMMATH_DIR_NATIVE	= $(TOMMATH_DIR)
 #WIN_DIR_NATIVE		= $(WIN_DIR)
 #ROOT_DIR_NATIVE		= $(ROOT_DIR)
@@ -484,32 +485,34 @@
 # To start from windows shell use:
 #   > tcltest.cmd -verbose bps -file fileName.test
 # or from mingw/msys shell:
 #   $ ./tcltest -verbose bps -file fileName.test
 
-tcltest.cmd:
+tcltest.cmd: Makefile
 	@echo 'Create tcltest.cmd helpers';
 	@(\
 	  echo '@echo off'; \
 	  echo 'rem set LANG=en_US'; \
 	  echo 'set BDP=%~dp0'; \
 	  echo 'set OWD=%CD%'; \
 	  echo 'cd /d %TEMP%'; \
-	  echo 'rem "%BDP%\$(TCLSH)" "$(ROOT_DIR_WIN_NATIVE)/tests/all.tcl" $(TESTFLAGS) -load "$(TEST_LOAD_FACILITIES)" %*'; \
-	  echo '"%BDP%\$(TEST_EXE_FILE)" "$(ROOT_DIR_WIN_NATIVE)/tests/all.tcl" $(TESTFLAGS) -load "$(TEST_LOAD_PRMS)" %*'; \
+	  echo 'rem "%BDP%\$(TCLSH)" "$(ROOT_DIR_WIN_NATIVE)/tests/all.tcl" %TESTFLAGS% -load "$(TEST_LOAD_FACILITIES)" %*'; \
+	  echo '"%BDP%\$(TEST_EXE_FILE)" "$(ROOT_DIR_WIN_NATIVE)/tests/all.tcl" %TESTFLAGS% -load "$(TEST_LOAD_PRMS)" %*'; \
 	  echo 'cd /d %OWD%'; \
 	) > tcltest.cmd;
 	@(\
 	  echo '#!/bin/sh'; \
 	  echo '#LANG=en_US'; \
 	  echo 'BDP=$$(dirname $$(readlink -f %0))'; \
 	  echo 'cd /tmp'; \
-	  echo '#"$$BDP/$(TCLSH)" "$(ROOT_DIR_WIN_NATIVE)/tests/all.tcl" $(TESTFLAGS) -load "$(TEST_LOAD_FACILITIES)" "$$@"'; \
-	  echo '"$$BDP/$(TEST_EXE_FILE)" "$(ROOT_DIR_WIN_NATIVE)/tests/all.tcl" $(TESTFLAGS) -load "$(TEST_LOAD_PRMS)" "$$@"'; \
-	) > tcltest;
+	  echo '#"$$BDP/$(TCLSH)" "$(ROOT_DIR_WIN_NATIVE)/tests/all.tcl" $$TESTFLAGS -load "$(TEST_LOAD_FACILITIES)" "$$@"'; \
+	  echo '"$$BDP/$(TEST_EXE_FILE)" "$(ROOT_DIR_WIN_NATIVE)/tests/all.tcl" $$TESTFLAGS -load "$(TEST_LOAD_PRMS)" "$$@"'; \
+	) > tcltest.sh;
 
-tcltest: $(TCLSH) $(TEST_EXE_FILE) $(TEST_DLL_FILE) tcltest.cmd
+tcltest.sh: tcltest.cmd
+
+tcltest: binaries $(TEST_EXE_FILE) $(TEST_DLL_FILE) $(CAT32) tcltest.cmd
 
 binaries: $(TCL_STUB_LIB_FILE) @LIBRARIES@ winextensions ${TCL_ZIP_FILE} $(TCLSH)
 
 winextensions: ${DDE_DLL_FILE} ${REG_DLL_FILE}
 
@@ -546,10 +549,11 @@
 	  cd ..)
 
 $(TCLSH): $(TCLSH_OBJS) @LIBRARIES@ $(TCL_STUB_LIB_FILE) tclsh.$(RES)
 	$(CC) $(CFLAGS) $(TCLSH_OBJS) $(TCL_LIB_FILE) $(TCL_STUB_LIB_FILE) $(LIBS) \
 	tclsh.$(RES) $(CC_EXENAME) $(LDFLAGS_CONSOLE)
+	$(COPY) tclsh.exe.manifest $(TCLSH).manifest
 	@VC_MANIFEST_EMBED_EXE@
 
 cat32.$(OBJEXT): cat.c
 	$(CC) -c $(CC_SWITCHES) @DEPARG@ $(CC_OBJNAME)
 
@@ -565,10 +569,11 @@
 	@POST_MAKE_LIB@
 
 ${TCL_DLL_FILE}: ${TCL_OBJS} tcl.$(RES) @ZLIB_DLL_FILE@ ${TCL_ZIP_FILE}
 	@$(RM) ${TCL_DLL_FILE} $(TCL_LIB_FILE)
 	@MAKE_DLL@ ${TCL_OBJS} tcl.$(RES) $(SHLIB_LD_LIBS)
+	$(COPY) tclsh.exe.manifest ${TCL_DLL_FILE}.manifest
 	@VC_MANIFEST_EMBED_DLL@
 	@if test "${ZIPFS_BUILD}" = "1" ; then \
 		cat ${TCL_ZIP_FILE} >> ${TCL_DLL_FILE}; \
 		${NATIVE_ZIP} -A ${TCL_DLL_FILE} \
 		  || echo 'ignore zip-error by adjust sfx process (not executable?)'; \
@@ -579,22 +584,26 @@
 	@MAKE_LIB@ ${TCL_OBJS} ${DDE_OBJS} ${REG_OBJS}
 	@POST_MAKE_LIB@
 
 ${DDE_DLL_FILE}: ${TCL_STUB_LIB_FILE} ${DDE_OBJS}
 	@MAKE_DLL@ ${DDE_OBJS} $(TCL_STUB_LIB_FILE) $(SHLIB_LD_LIBS)
+	$(COPY) tclsh.exe.manifest ${DDE_DLL_FILE}.manifest
 
 ${REG_DLL_FILE}: ${TCL_STUB_LIB_FILE} ${REG_OBJS}
 	@MAKE_DLL@ ${REG_OBJS} $(TCL_STUB_LIB_FILE) $(SHLIB_LD_LIBS)
+	$(COPY) tclsh.exe.manifest ${REG_DLL_FILE}.manifest
 
 ${TEST_DLL_FILE}: ${TCL_STUB_LIB_FILE} ${TCLTEST_OBJS}
 	@$(RM) ${TEST_DLL_FILE} ${TEST_LIB_FILE}
 	@MAKE_DLL@ ${TCLTEST_OBJS} $(TCL_STUB_LIB_FILE) $(SHLIB_LD_LIBS)
+	$(COPY) tclsh.exe.manifest ${TEST_DLL_FILE}.manifest
 
 ${TEST_EXE_FILE}: ${TCL_STUB_LIB_FILE} ${TCLTEST_OBJS} tclTestMain.${OBJEXT}
 	@$(RM) ${TEST_EXE_FILE}
 	$(CC) $(CFLAGS) $(TCLTEST_OBJS) tclTestMain.$(OBJEXT) $(TCL_LIB_FILE) $(TCL_STUB_LIB_FILE) $(LIBS) \
         tclsh.$(RES) $(CC_EXENAME) $(LDFLAGS_CONSOLE)
+	$(COPY) tclsh.exe.manifest ${TEST_EXE_FILE}.manifest
 
 # use pre-built zlib1.dll
 ${ZLIB_DLL_FILE}: ${TCL_STUB_LIB_FILE}
 	@if test "@ZLIB_LIBS@set" != "${ZLIB_DIR_NATIVE}/win32/zdll.libset" ; then \
 		$(COPY) $(ZLIB_DIR)/win64/${ZLIB_DLL_FILE} ${ZLIB_DLL_FILE}; \
@@ -645,21 +654,21 @@
 # every path can be configured separately we do not remember one general
 # prefix/exec_prefix but all the different paths individually.
 
 tclPkgConfig.${OBJEXT}: tclPkgConfig.c
 	$(CC)	-c $(CC_SWITCHES)			\
-		-DCFG_INSTALL_LIBDIR=\"$(LIB_INSTALL_DIR_NATIVE)\" \
-		-DCFG_INSTALL_BINDIR=\"$(BIN_INSTALL_DIR_NATIVE)\" \
-		-DCFG_INSTALL_SCRDIR=\"$(SCRIPT_INSTALL_DIR_NATIVE)\" \
-		-DCFG_INSTALL_INCDIR=\"$(INCLUDE_INSTALL_DIR_NATIVE)\" \
-		-DCFG_INSTALL_DOCDIR=\"$(MAN_INSTALL_DIR)\" \
-		\
-		-DCFG_RUNTIME_LIBDIR=\"$(libdir_native)\" \
-		-DCFG_RUNTIME_BINDIR=\"$(bindir_native)\" \
-		-DCFG_RUNTIME_SCRDIR=\"$(TCL_LIBRARY_NATIVE)\" \
-		-DCFG_RUNTIME_INCDIR=\"$(includedir_native)\" \
-		-DCFG_RUNTIME_DOCDIR=\"$(mandir_native)\" \
+		-DCFG_INSTALL_LIBDIR="\"$(LIB_INSTALL_DIR_NATIVE)\"" \
+		-DCFG_INSTALL_BINDIR="\"$(BIN_INSTALL_DIR_NATIVE)\"" \
+		-DCFG_INSTALL_SCRDIR="\"$(SCRIPT_INSTALL_DIR_NATIVE)\"" \
+		-DCFG_INSTALL_INCDIR="\"$(INCLUDE_INSTALL_DIR_NATIVE)\"" \
+		-DCFG_INSTALL_DOCDIR="\"$(MAN_INSTALL_DIR)\"" \
+		\
+		-DCFG_RUNTIME_LIBDIR="\"$(libdir_native)\"" \
+		-DCFG_RUNTIME_BINDIR="\"$(bindir_native)\"" \
+		-DCFG_RUNTIME_SCRDIR="\"$(TCL_LIBRARY_NATIVE)\"" \
+		-DCFG_RUNTIME_INCDIR="\"$(includedir_native)\"" \
+		-DCFG_RUNTIME_DOCDIR="\"$(mandir_native)\"" \
 		-DCFG_RUNTIME_DLLFILE="\"$(TCL_DLL_FILE)\"" \
 		-DCFG_RUNTIME_ZIPFILE="\"$(TCL_ZIP_FILE)\"" \
 		-DBUILD_tcl \
 		@DEPARG@ $(CC_OBJNAME)
 
@@ -835,11 +844,11 @@
 		echo "Making directory $$i"; \
 		$(MKDIR) $$i; \
 		else true; \
 		fi; \
 	    done;
-	@for i in opt0.4 encoding ../tcl9 ../tcl9/9.0 ../tcl9/9.0/platform; \
+	@for i in opt0.4 encoding ../tcl8 ../tcl8/8.4  ../tcl8/8.4/platform ../tcl8/8.5 ../tcl8/8.6 ../tcl8/8.7; \
 	    do \
 	    if [ ! -d $(SCRIPT_INSTALL_DIR)/$$i ] ; then \
 		echo "Making directory $(SCRIPT_INSTALL_DIR)/$$i"; \
 		$(MKDIR) $(SCRIPT_INSTALL_DIR)/$$i; \
 		else true; \
@@ -849,24 +858,24 @@
 	@for i in $(ROOT_DIR)/library/*.tcl $(ROOT_DIR)/library/tclIndex; \
 	    do \
 	    $(COPY) "$$i" "$(SCRIPT_INSTALL_DIR)"; \
 	    done;
 	@echo "Installing package http 2.9.0 as a Tcl Module";
-	@$(COPY) $(ROOT_DIR)/library/http/http.tcl $(SCRIPT_INSTALL_DIR)/../tcl9/9.0/http-2.9.0.tm;
+	@$(COPY) $(ROOT_DIR)/library/http/http.tcl $(SCRIPT_INSTALL_DIR)/../tcl8/8.6/http-2.9.0.tm;
 	@echo "Installing library opt0.4 directory";
 	@for j in $(ROOT_DIR)/library/opt/*.tcl; \
 	    do \
 	    $(COPY) "$$j" "$(SCRIPT_INSTALL_DIR)/opt0.4"; \
 	    done;
 	@echo "Installing package msgcat 1.7.0 as a Tcl Module";
-	@$(COPY) $(ROOT_DIR)/library/msgcat/msgcat.tcl $(SCRIPT_INSTALL_DIR)/../tcl9/9.0/msgcat-1.7.0.tm;
+	@$(COPY) $(ROOT_DIR)/library/msgcat/msgcat.tcl $(SCRIPT_INSTALL_DIR)/../tcl8/8.7/msgcat-1.7.0.tm;
 	@echo "Installing package tcltest 2.4.0 as a Tcl Module";
-	@$(COPY) $(ROOT_DIR)/library/tcltest/tcltest.tcl $(SCRIPT_INSTALL_DIR)/../tcl9/9.0/tcltest-2.4.0.tm;
+	@$(COPY) $(ROOT_DIR)/library/tcltest/tcltest.tcl $(SCRIPT_INSTALL_DIR)/../tcl8/8.5/tcltest-2.4.0.tm;
 	@echo "Installing package platform 1.0.14 as a Tcl Module";
-	@$(COPY) $(ROOT_DIR)/library/platform/platform.tcl $(SCRIPT_INSTALL_DIR)/../tcl9/9.0/platform-1.0.14.tm;
+	@$(COPY) $(ROOT_DIR)/library/platform/platform.tcl $(SCRIPT_INSTALL_DIR)/../tcl8/8.4/platform-1.0.14.tm;
 	@echo "Installing package platform::shell 1.1.4 as a Tcl Module";
-	@$(COPY) $(ROOT_DIR)/library/platform/shell.tcl $(SCRIPT_INSTALL_DIR)/../tcl9/9.0/platform/shell-1.1.4.tm;
+	@$(COPY) $(ROOT_DIR)/library/platform/shell.tcl $(SCRIPT_INSTALL_DIR)/../tcl8/8.4/platform/shell-1.1.4.tm;
 	@echo "Installing encodings";
 	@for i in $(ROOT_DIR)/library/encoding/*.enc ; do \
 		$(COPY) "$$i" "$(SCRIPT_INSTALL_DIR)/encoding"; \
 	done;
 
@@ -925,17 +934,17 @@
 # tcltest, i.e.:
 #	% make test TESTFLAGS="-verbose bps -file fileName.test"
 
 test: test-tcl test-packages
 
-test-tcl: binaries $(TCLSH) $(CAT32) $(TEST_DLL_FILE)
+test-tcl: tcltest
 	TCL_LIBRARY="$(LIBRARY_DIR)"; export TCL_LIBRARY; \
 	$(WINE) ./$(TCLSH) "$(ROOT_DIR_NATIVE)/tests/all.tcl" $(TESTFLAGS) \
-	-load "$(TEST_LOAD_FACILITIES)" | $(WINE) ./$(CAT32)
+	-load "$(TEST_LOAD_FACILITIES)"
 
 # Useful target to launch a built tclsh with the proper path,...
-runtest: binaries $(TCLSH) $(TEST_DLL_FILE)
+runtest: tcltest
 	@TCL_LIBRARY="$(LIBRARY_DIR)"; export TCL_LIBRARY; \
 	$(WINE) ./$(TCLSH) $(TESTFLAGS) -load "$(TEST_LOAD_FACILITIES)" $(SCRIPT)
 
 # This target can be used to run tclsh from the build directory via
 # `make shell SCRIPT=foo.tcl`
@@ -957,11 +966,11 @@
 cleanhelp:
 	$(RM) *.hlp *.cnt *.GID *.rtf man2tcl.exe
 
 clean: cleanhelp clean-packages
 	$(RM) *.lib *.a *.exp *.dll *.$(RES) *.${OBJEXT} *~ \#* TAGS a.out
-	$(RM) $(TCLSH) $(CAT32) $(TEST_EXE_FILE) $(TEST_DLL_FILE) tcltest.cmd tcltest
+	$(RM) $(TCLSH) $(CAT32) $(TEST_EXE_FILE) $(TEST_DLL_FILE) tcltest.cmd tcltest.sh
 	$(RM) *.pch *.ilk *.pdb
 	$(RM) minizip${HOST_EXEEXT} *.${HOST_OBJEXT}
 	$(RM) *.zip
 	$(RMDIR) *.vfs
 
@@ -1068,11 +1077,11 @@
 	    "$(GENERIC_DIR_NATIVE)/tclOO.decls"
 
 #
 # This target creates the HTML folder for Tcl & Tk and places it in
 # DISTDIR/html. It uses the tcltk-man2html.tcl tool from the Tcl group's tool
-# workspace. It depends on the Tcl & Tk being in directories called tcl9.* &
+# workspace. It depends on the Tcl & Tk being in directories called tcl8.* &
 # tk8.* up two directories from the TOOL_DIR.
 #
 
 TOOL_DIR=$(ROOT_DIR)/tools
 HTML_INSTALL_DIR=$(ROOT_DIR)/html

Index: win/README
==================================================================
--- win/README
+++ win/README
@@ -1,6 +1,6 @@
-Tcl 9.0 for Windows
+Tcl 8.7 for Windows
 
 1. Introduction
 ---------------
 
 This is the directory where you configure and compile the Windows
@@ -14,11 +14,11 @@
 2. Compiling Tcl
 ----------------
 
 In order to compile Tcl for Windows, you need the following:
 
-	Tcl 9.0 Source Distribution (plus any patches)
+	Tcl 8.7 Source Distribution (plus any patches)
 
 	and
 
 	Visual C++ 6 or newer
 
@@ -77,13 +77,13 @@
 
 Use the Makefile "install" target to install Tcl.  It will install it
 according to the prefix options you provided in the correct directory
 structure.
 
-Note that in order to run tclsh90.exe, you must ensure that tcl90.dll is
+Note that in order to run tclsh87.exe, you must ensure that tcl87.dll is
 on your path, in the system directory, or in the directory containing
-tclsh90.exe.
+tclsh87.exe.
 
 Note: Tcl no longer provides support for Win32s.
 
 3. Test suite
 -------------

Index: win/cat.c
==================================================================
--- win/cat.c
+++ win/cat.c
@@ -26,16 +26,16 @@
     char buf[1024];
     int n;
     const char *err;
 
     while (1) {
-	n = read(0, buf, sizeof(buf));
+	n = _read(0, buf, sizeof(buf));
 	if (n <= 0) {
 	    break;
 	}
-        write(1, buf, n);
+	_write(1, buf, n);
     }
     err = (sizeof(int) == 2) ? "stderr16" : "stderr32";
-    write(2, err, strlen(err));
+    _write(2, err, (unsigned int)strlen(err));
 
     return 0;
 }

Index: win/configure
==================================================================
--- win/configure
+++ win/configure
@@ -776,10 +776,11 @@
 ac_subst_files=''
 ac_user_opts='
 enable_option_checking
 with_encoding
 enable_shared
+enable_time64bit
 enable_64bit
 enable_zipfs
 enable_symbols
 enable_embedded_manifest
 '
@@ -1398,10 +1399,11 @@
 Optional Features:
   --disable-option-checking  ignore unrecognized --enable/--with options
   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
   --enable-shared         build and link with shared libraries (default: on)
+  --enable-time64bit      force 64-bit time_t for 32-bit build (default: off)
   --enable-64bit          enable 64bit support (where applicable)
   --enable-zipfs          build with Zipfs support (default: on)
   --enable-symbols        build with debugging symbols (default: off)
   --enable-embedded-manifest
                           embed manifest if possible (default: yes)
@@ -2105,14 +2107,14 @@
 # The following define is needed when building with Cygwin since newer
 # versions of autoconf incorrectly set SHELL to /bin/bash instead of
 # /bin/sh. The bash shell seems to suffer from some strange failures.
 SHELL=/bin/sh
 
-TCL_VERSION=9.0
-TCL_MAJOR_VERSION=9
-TCL_MINOR_VERSION=0
-TCL_PATCH_LEVEL="a0"
+TCL_VERSION=8.7
+TCL_MAJOR_VERSION=8
+TCL_MINOR_VERSION=7
+TCL_PATCH_LEVEL="a2"
 VER=$TCL_MAJOR_VERSION$TCL_MINOR_VERSION
 
 TCL_DDE_VERSION=1.4
 TCL_DDE_MAJOR_VERSION=1
 TCL_DDE_MINOR_VERSION=4
@@ -3745,10 +3747,29 @@
 $as_echo "#define STATIC_BUILD 1" >>confdefs.h
 
     fi
 
 
+
+#--------------------------------------------------------------------
+# Check whether --enable-time64bit was given.
+#--------------------------------------------------------------------
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking force of 64-bit time_t" >&5
+$as_echo_n "checking force of 64-bit time_t... " >&6; }
+# Check whether --enable-time64bit was given.
+if test "${enable_time64bit+set}" = set; then :
+  enableval=$enable_time64bit; tcl_ok=$enableval
+else
+  tcl_ok=no
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: \"$tcl_ok\"" >&5
+$as_echo "\"$tcl_ok\"" >&6; }
+if test "$tcl_ok" = "yes"; then
+    CFLAGS="${CFLAGS} -D_USE_64BIT_TIME_T"
+fi
 
 #--------------------------------------------------------------------
 # The statements below define a collection of compile flags.  This
 # macro depends on the value of SHARED_BUILD, and should be called
 # after SC_ENABLE_SHARED checks the configure switches.

Index: win/configure.ac
==================================================================
--- win/configure.ac
+++ win/configure.ac
@@ -9,14 +9,14 @@
 # The following define is needed when building with Cygwin since newer
 # versions of autoconf incorrectly set SHELL to /bin/bash instead of
 # /bin/sh. The bash shell seems to suffer from some strange failures.
 SHELL=/bin/sh
 
-TCL_VERSION=9.0
-TCL_MAJOR_VERSION=9
-TCL_MINOR_VERSION=0
-TCL_PATCH_LEVEL="a0"
+TCL_VERSION=8.7
+TCL_MAJOR_VERSION=8
+TCL_MINOR_VERSION=7
+TCL_PATCH_LEVEL="a2"
 VER=$TCL_MAJOR_VERSION$TCL_MINOR_VERSION
 
 TCL_DDE_VERSION=1.4
 TCL_DDE_MAJOR_VERSION=1
 TCL_DDE_MINOR_VERSION=4
@@ -88,10 +88,24 @@
 # The statements below define a collection of symbols related to
 # building libtcl as a shared library instead of a static library.
 #--------------------------------------------------------------------
 
 SC_ENABLE_SHARED
+
+#--------------------------------------------------------------------
+# Check whether --enable-time64bit was given.
+#--------------------------------------------------------------------
+
+AC_MSG_CHECKING([force of 64-bit time_t])
+AC_ARG_ENABLE(time64bit,
+    AC_HELP_STRING([--enable-time64bit],
+	[force 64-bit time_t for 32-bit build (default: off)]),
+    [tcl_ok=$enableval], [tcl_ok=no])
+AC_MSG_RESULT("$tcl_ok")
+if test "$tcl_ok" = "yes"; then
+    CFLAGS="${CFLAGS} -D_USE_64BIT_TIME_T"
+fi
 
 #--------------------------------------------------------------------
 # The statements below define a collection of compile flags.  This
 # macro depends on the value of SHARED_BUILD, and should be called
 # after SC_ENABLE_SHARED checks the configure switches.

Index: win/makefile.vc
==================================================================
--- win/makefile.vc
+++ win/makefile.vc
@@ -49,10 +49,75 @@
 # NOTE: For older (Visual C++ 6 or the 2003 SDK), to use the Platform
 # SDK (not expressly needed), run setenv.bat after
 # vcvars32.bat according to the instructions for it.  This can also
 # turn on the 64-bit compiler, if your SDK has it.
 #
+# Basic macros and options usable on the commandline (see rules.vc for more info):
+#	OPTS=msvcrt,static,staticpkg,symbols,profile,unchecked,time64bit,utfmax,none
+#		Sets special options for the core.  The default is for none.
+#		Any combination of the above may be used (comma separated).
+#		'none' will over-ride everything to nothing.
+#
+#		msvcrt   = Affects the static option only to switch it from
+#			   using libcmt(d) as the C runtime [by default] to
+#			   msvcrt(d). This is useful for static embedding
+#			   support.
+#		static   = Builds a static library of the core instead of a
+#			   dll.  The shell will be static (and large), as well.
+#		staticpkg= Affects the static option only to switch
+#			   tclshXX.exe to have the dde and reg extension linked
+#			   inside it.
+#		thrdalloc = Use the thread allocator (shared global free pool).
+#		symbols =  Adds symbols for step debugging.
+#		profile =  Adds profiling hooks.  Map file is assumed.
+#		unchecked = Allows a symbols build to not use the debug
+#			   enabled runtime (msvcrt.dll not msvcrtd.dll
+#			   or libcmt.lib not libcmtd.lib).
+#		time64bit = Forces a build using 64-bit time_t for 32-bit build
+#			   (CRT library should support this).
+#		utfmax =   Forces Tcl_UniChar to be a 32-bit quantity in stead
+#			   of 16-bits
+#
+#	STATS=compdbg,memdbg,none
+#		Sets optional memory and bytecode compiler debugging code added
+#		to the core.  The default is for none.  Any combination of the
+#		above may be used (comma separated).  'none' will over-ride
+#		everything to nothing.
+#
+#		compdbg  = Enables byte compilation logging.
+#		memdbg   = Enables the debugging memory allocator.
+#
+#	CHECKS=64bit,fullwarn,nodep,none
+#		Sets special macros for checking compatibility.
+#
+#		64bit    = Enable 64bit portability warnings (if available)
+#		fullwarn = Builds with full compiler and link warnings enabled.
+#			    Very verbose.
+#		nodep	 = Turns off compatibility macros to ensure the core
+#			    isn't being built with deprecated functions.
+#
+#	MACHINE=(ALPHA|AMD64|IA64|IX86)
+#		Set the machine type used for the compiler, linker, and
+#		resource compiler.  This hook is needed to tell the tools
+#		when alternate platforms are requested.  IX86 is the default
+#		when not specified. If the CPU environment variable has been
+#		set (ie: recent Platform SDK) then MACHINE is set from CPU.
+#
+#	TMP_DIR=<path>
+#	OUT_DIR=<path>
+#		Hooks to allow the intermediate and output directories to be
+#		changed.  $(OUT_DIR) is assumed to be
+#		$(BINROOT)\(Release|Debug) based on if symbols are requested.
+#		$(TMP_DIR) will de $(OUT_DIR)\<buildtype> by default.
+#
+#	TESTPAT=<file>
+#		Reads the tests requested to be run from this file.
+#
+#	CFG_ENCODING=encoding
+#		name of encoding for configuration information. Defaults
+#		to cp1252
+#
 # Examples:
 #       c:\tcl_src\win\>nmake -f makefile.vc release
 #       c:\tcl_src\win\>nmake -f makefile.vc test
 #       c:\tcl_src\win\>nmake -f makefile.vc install INSTALLDIR=c:\progra~1\tcl
 #       c:\tcl_src\win\>nmake -f makefile.vc release OPTS=pdbs
@@ -825,16 +890,24 @@
 	@$(CPY) "$(TCLSTUBLIB)" "$(LIB_INSTALL_DIR)\"
 
 install-libraries: tclConfig tcl-nmake install-msgs install-tzdata
 	@if not exist "$(SCRIPT_INSTALL_DIR)" \
 		$(MKDIR) "$(SCRIPT_INSTALL_DIR)"
-	@if not exist "$(SCRIPT_INSTALL_DIR)\..\tcl9$(NULL)" \
-		$(MKDIR) "$(SCRIPT_INSTALL_DIR)\..\tcl9"
-	@if not exist "$(SCRIPT_INSTALL_DIR)\..\tcl9\9.0$(NULL)" \
-		$(MKDIR) "$(SCRIPT_INSTALL_DIR)\..\tcl9\9.0"
-	@if not exist "$(SCRIPT_INSTALL_DIR)\..\tcl9\9.0\platform$(NULL)" \
-		$(MKDIR) "$(SCRIPT_INSTALL_DIR)\..\tcl9\9.0\platform"
+	@if not exist "$(SCRIPT_INSTALL_DIR)\..\tcl8" \
+		$(MKDIR) "$(SCRIPT_INSTALL_DIR)\..\tcl8"
+	@if not exist "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.4" \
+		$(MKDIR) "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.4"
+	@if not exist "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.4\platform" \
+		$(MKDIR) "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.4\platform"
+	@if not exist "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.5" \
+		$(MKDIR) "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.5"
+	@if not exist "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.6" \
+		$(MKDIR) "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.6"
+	@if not exist "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.7" \
+		$(MKDIR) "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.7"
+	@if not exist "$(LIB_INSTALL_DIR)\nmake" \
+		$(MKDIR) "$(LIB_INSTALL_DIR)\nmake"
 	@echo Installing header files
 	@$(CPY) "$(GENERICDIR)\tcl.h"             "$(INCLUDE_INSTALL_DIR)\"
 	@$(CPY) "$(GENERICDIR)\tclDecls.h"        "$(INCLUDE_INSTALL_DIR)\"
 	@$(CPY) "$(GENERICDIR)\tclOO.h"           "$(INCLUDE_INSTALL_DIR)\"
 	@$(CPY) "$(GENERICDIR)\tclOODecls.h"      "$(INCLUDE_INSTALL_DIR)\"
@@ -863,23 +936,23 @@
 	@echo Installing library opt0.4 directory
 	@$(CPY) "$(ROOT)\library\opt\*.tcl" \
 	    "$(SCRIPT_INSTALL_DIR)\opt0.4\"
 	@echo Installing package http $(PKG_HTTP_VER) as a Tcl Module
 	@$(COPY) "$(ROOT)\library\http\http.tcl" \
-	    "$(SCRIPT_INSTALL_DIR)\..\tcl9\9.0\http-$(PKG_HTTP_VER).tm"
+	    "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.6\http-$(PKG_HTTP_VER).tm"
 	@echo Installing package msgcat $(PKG_MSGCAT_VER) as a Tcl Module
 	@$(COPY) "$(ROOT)\library\msgcat\msgcat.tcl" \
-	    "$(SCRIPT_INSTALL_DIR)\..\tcl9\9.0\msgcat-$(PKG_MSGCAT_VER).tm"
+	    "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.7\msgcat-$(PKG_MSGCAT_VER).tm"
 	@echo Installing package tcltest $(PKG_TCLTEST_VER) as a Tcl Module
 	@$(COPY) "$(ROOT)\library\tcltest\tcltest.tcl" \
-	    "$(SCRIPT_INSTALL_DIR)\..\tcl9\9.0\tcltest-$(PKG_TCLTEST_VER).tm"
+	    "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.5\tcltest-$(PKG_TCLTEST_VER).tm"
 	@echo Installing package platform $(PKG_PLATFORM_VER) as a Tcl Module
 	@$(COPY) "$(ROOT)\library\platform\platform.tcl" \
-	    "$(SCRIPT_INSTALL_DIR)\..\tcl9\9.0\platform-$(PKG_PLATFORM_VER).tm"
+	    "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.4\platform-$(PKG_PLATFORM_VER).tm"
 	@echo Installing package platform::shell $(PKG_SHELL_VER) as a Tcl Module
 	@$(COPY) "$(ROOT)\library\platform\shell.tcl" \
-	    "$(SCRIPT_INSTALL_DIR)\..\tcl9\9.0\platform\shell-$(PKG_SHELL_VER).tm"
+	    "$(SCRIPT_INSTALL_DIR)\..\tcl8\8.4\platform\shell-$(PKG_SHELL_VER).tm"
 	@echo Installing $(TCLDDELIBNAME)
 !if $(STATIC_BUILD)
 !if !$(TCL_USE_STATIC_PACKAGES)
 	@$(CPY) "$(TCLDDELIB)" "$(LIB_INSTALL_DIR)\"
 !endif

Index: win/nmakehlp.c
==================================================================
--- win/nmakehlp.c
+++ win/nmakehlp.c
@@ -641,11 +641,11 @@
 	    }
 	    fclose(sp);
 	}
 
 	/* debug: dump the list */
-#ifdef _DEBUG
+#ifndef NDEBUG
 	{
 	    int n = 0;
 	    list_item_t *p = NULL;
 	    for (p = substPtr; p != NULL; p = p->nextPtr, ++n) {
 		fprintf(stderr, "% 3d '%s' => '%s'\n", n, p->key, p->value);

Index: win/rules.vc
==================================================================
--- win/rules.vc
+++ win/rules.vc
@@ -22,11 +22,11 @@
 
 # The following macros define the version of the rules.vc nmake build system
 # For modifications that are not backward-compatible, you *must* change
 # the major version.
 RULES_VERSION_MAJOR = 1
-RULES_VERSION_MINOR = 3
+RULES_VERSION_MINOR = 4
 
 # The PROJECT macro must be defined by parent makefile.
 !if "$(PROJECT)" == ""
 !error *** Error: Macro PROJECT not defined! Please define it before including rules.vc
 !endif
@@ -684,10 +684,13 @@
 # UNCHECKED - 1 -> when doing a debug build with symbols, use the release
 #           C runtime, 0 -> use the debug C runtime.
 # USE_STUBS - 1 -> compile to use stubs interfaces, 0 -> direct linking
 # CONFIG_CHECK - 1 -> check current build configuration against Tcl
 #           configuration (ignored for Tcl itself)
+# _USE_64BIT_TIME_T - forces a build using 64-bit time_t for 32-bit build
+#           (CRT library should support this)
+# TCL_UTF_MAX=6 - forces a build using 32-bit Tcl_UniChar in stead of 16-bit.
 # Further, LINKERFLAGS are modified based on above.
 
 # Default values for all the above
 STATIC_BUILD	= 0
 TCL_THREADS	= 1
@@ -742,10 +745,20 @@
 !message *** Doing staticpkg
 TCL_USE_STATIC_PACKAGES	= 1
 !else
 TCL_USE_STATIC_PACKAGES	= 0
 !endif
+
+!if [nmakehlp -f $(OPTS) "time64bit"]
+!message *** Force 64-bit time_t
+_USE_64BIT_TIME_T = 1
+!endif
+
+!if [nmakehlp -f $(OPTS) "utfmax"]
+!message *** Force 32-bit Tcl_UniChar
+TCL_UTF_MAX = 6
+!endif
 
 # Yes, it's weird that the "symbols" option controls DEBUG and
 # the "pdbs" option controls SYMBOLS. That's historical.
 !if [nmakehlp -f $(OPTS) "symbols"]
 !message *** Doing symbols
@@ -1263,13 +1276,13 @@
 OPTDEFINES	= $(OPTDEFINES) -DTCL_MEM_DEBUG
 !endif
 !if $(TCL_COMPILE_DEBUG)
 OPTDEFINES	= $(OPTDEFINES) -DTCL_COMPILE_DEBUG -DTCL_COMPILE_STATS
 !endif
-!if $(TCL_THREADS) && $(TCL_VERSION) < 86
+!if $(TCL_THREADS) && $(TCL_VERSION) < 87
 OPTDEFINES	= $(OPTDEFINES) -DTCL_THREADS=1
-!if $(USE_THREAD_ALLOC)
+!if $(USE_THREAD_ALLOC) && $(TCL_VERSION) < 87
 OPTDEFINES	= $(OPTDEFINES) -DUSE_THREAD_ALLOC=1
 !endif
 !endif
 !if $(STATIC_BUILD)
 OPTDEFINES	= $(OPTDEFINES) -DSTATIC_BUILD
@@ -1302,10 +1315,17 @@
 OPTDEFINES	= $(OPTDEFINES) -DTCL_CFG_DO64BIT
 !endif
 !if $(VCVERSION) < 1300
 OPTDEFINES	= $(OPTDEFINES) -DNO_STRTOI64
 !endif
+
+!if "$(_USE_64BIT_TIME_T)" == "1"
+OPTDEFINES	= $(OPTDEFINES) -D_USE_64BIT_TIME_T
+!endif
+!if "$(TCL_UTF_MAX)" == "6"
+OPTDEFINES	= $(OPTDEFINES) -DTCL_UTF_MAX=6
+!endif
 
 # _ATL_XP_TARGETING - Newer SDK's need this to build for XP
 COMPILERFLAGS  = /D_ATL_XP_TARGETING
 
 # Following is primarily for the benefit of extensions. Tcl 8.5 builds
@@ -1405,12 +1425,12 @@
 # object files (e.g. tclsh, or wish) pkgcflags contains $(cflags) plus
 # flags used for building shared object files The two differ in the
 # BUILD_$(PROJECT) macro which should be defined only for the shared
 # library *implementation* and not for its caller interface
 
-appcflags = $(cflags) $(crt) $(INCLUDES) $(TCL_DEFINES) $(PRJ_DEFINES) $(OPTDEFINES) $(USE_STUBS_DEFS)
 appcflags_nostubs = $(cflags) $(crt) $(INCLUDES) $(TCL_DEFINES) $(PRJ_DEFINES) $(OPTDEFINES)
+appcflags = $(appcflags_nostubs) $(USE_STUBS_DEFS)
 pkgcflags = $(appcflags) $(PKGNAMEFLAGS) -DBUILD_$(PROJECT)
 pkgcflags_nostubs = $(appcflags_nostubs) $(PKGNAMEFLAGS) -DBUILD_$(PROJECT)
 
 # stubscflags contains $(cflags) plus flags used for building a stubs
 # library for the package.  Note: -DSTATIC_BUILD is defined in
@@ -1421,11 +1441,11 @@
 # TBD - tclvfs has a comment that stubs libs should not be compiled with -GL
 # without stating why. Tcl itself compiled stubs libs with this flag.
 # so we do not remove it from cflags. -GL may prevent extensions
 # compiled with one VC version to fail to link against stubs library
 # compiled with another VC version. Check for this and fix accordingly.
-stubscflags = $(cflags) $(PKGNAMEFLAGS) $(PRJ_DEFINES) $(OPTDEFINES) -Zl -DSTATIC_BUILD $(INCLUDES)
+stubscflags = $(cflags) $(PKGNAMEFLAGS) $(PRJ_DEFINES) $(OPTDEFINES) -Zl -DSTATIC_BUILD $(INCLUDES) $(USE_STUBS_DEFS)
 
 # Link flags
 
 !if $(DEBUG)
 ldebug	= -debug -debugtype:cv
@@ -1729,10 +1749,13 @@
 !include $(TCLNMAKECONFIG)
 
 !if defined(CORE_MACHINE) && "$(CORE_MACHINE)" != "$(MACHINE)"
 !error ERROR: Build target ($(MACHINE)) does not match the Tcl library architecture ($(CORE_MACHINE)).
 !endif
+!if $(TCL_VERSION) < 87 && defined(CORE_USE_THREAD_ALLOC) && $(CORE_USE_THREAD_ALLOC) != $(USE_THREAD_ALLOC)
+!message WARNING: Value of USE_THREAD_ALLOC ($(USE_THREAD_ALLOC)) does not match its Tcl core value ($(CORE_USE_THREAD_ALLOC)).
+!endif
 !if defined(CORE_DEBUG) && $(CORE_DEBUG) != $(DEBUG)
 !message WARNING: Value of DEBUG ($(DEBUG)) does not match its Tcl library configuration ($(DEBUG)).
 !endif
 !endif
 

Index: win/tcl.dsp
==================================================================
--- win/tcl.dsp
+++ win/tcl.dsp
@@ -34,20 +34,20 @@
 # PROP BASE Use_Debug_Libraries 0
 # PROP BASE Output_Dir "Release"
 # PROP BASE Intermediate_Dir "Release\tcl_Dynamic"
 # PROP BASE Cmd_Line "nmake -nologo -f makefile.vc OPTS=none MSVCDIR=IDE"
 # PROP BASE Rebuild_Opt "-a"
-# PROP BASE Target_File "Release\tclsh90.exe"
+# PROP BASE Target_File "Release\tclsh87.exe"
 # PROP BASE Bsc_Name ""
 # PROP BASE Target_Dir ""
 # PROP Use_MFC 0
 # PROP Use_Debug_Libraries 0
 # PROP Output_Dir "Release"
 # PROP Intermediate_Dir "Release\tcl_Dynamic"
 # PROP Cmd_Line "nmake -nologo -f makefile.vc OPTS=threads MSVCDIR=IDE"
 # PROP Rebuild_Opt "clean release"
-# PROP Target_File "Release\tclsh90t.exe"
+# PROP Target_File "Release\tclsh87t.exe"
 # PROP Bsc_Name ""
 # PROP Target_Dir ""
 
 !ELSEIF  "$(CFG)" == "tcl - Win32 Debug"
 
@@ -55,20 +55,20 @@
 # PROP BASE Use_Debug_Libraries 1
 # PROP BASE Output_Dir "Debug"
 # PROP BASE Intermediate_Dir "Debug\tcl_Dynamic"
 # PROP BASE Cmd_Line "nmake -nologo -f makefile.vc OPTS=symbols MSVCDIR=IDE"
 # PROP BASE Rebuild_Opt "-a"
-# PROP BASE Target_File "Debug\tclsh90g.exe"
+# PROP BASE Target_File "Debug\tclsh87g.exe"
 # PROP BASE Bsc_Name ""
 # PROP BASE Target_Dir ""
 # PROP Use_MFC 0
 # PROP Use_Debug_Libraries 1
 # PROP Output_Dir "Debug"
 # PROP Intermediate_Dir "Debug\tcl_Dynamic"
 # PROP Cmd_Line "nmake -nologo -f makefile.vc OPTS=threads,symbols MSVCDIR=IDE"
 # PROP Rebuild_Opt "clean release"
-# PROP Target_File "Debug\tclsh90tg.exe"
+# PROP Target_File "Debug\tclsh87tg.exe"
 # PROP Bsc_Name ""
 # PROP Target_Dir ""
 
 !ELSEIF  "$(CFG)" == "tcl - Win32 Debug Static"
 
@@ -76,20 +76,20 @@
 # PROP BASE Use_Debug_Libraries 1
 # PROP BASE Output_Dir "Debug"
 # PROP BASE Intermediate_Dir "Debug\tcl_Static"
 # PROP BASE Cmd_Line "nmake -nologo -f makefile.vc OPTS=symbols,static MSVCDIR=IDE"
 # PROP BASE Rebuild_Opt "-a"
-# PROP BASE Target_File "Debug\tclsh90sg.exe"
+# PROP BASE Target_File "Debug\tclsh87sg.exe"
 # PROP BASE Bsc_Name ""
 # PROP BASE Target_Dir ""
 # PROP Use_MFC 0
 # PROP Use_Debug_Libraries 1
 # PROP Output_Dir "Debug"
 # PROP Intermediate_Dir "Debug\tcl_Static"
 # PROP Cmd_Line "nmake -nologo -f makefile.vc OPTS=symbols,static MSVCDIR=IDE"
 # PROP Rebuild_Opt "-a"
-# PROP Target_File "Debug\tclsh90sg.exe"
+# PROP Target_File "Debug\tclsh87sg.exe"
 # PROP Bsc_Name ""
 # PROP Target_Dir ""
 
 !ELSEIF  "$(CFG)" == "tcl - Win32 Release Static"
 
@@ -97,20 +97,20 @@
 # PROP BASE Use_Debug_Libraries 0
 # PROP BASE Output_Dir "Release"
 # PROP BASE Intermediate_Dir "Release\tcl_Static"
 # PROP BASE Cmd_Line "nmake -nologo -f makefile.vc OPTS=static MSVCDIR=IDE"
 # PROP BASE Rebuild_Opt "-a"
-# PROP BASE Target_File "Release\tclsh90s.exe"
+# PROP BASE Target_File "Release\tclsh87s.exe"
 # PROP BASE Bsc_Name ""
 # PROP BASE Target_Dir ""
 # PROP Use_MFC 0
 # PROP Use_Debug_Libraries 0
 # PROP Output_Dir "Release"
 # PROP Intermediate_Dir "Release\tcl_Static"
 # PROP Cmd_Line "nmake -nologo -f makefile.vc OPTS=static MSVCDIR=IDE"
 # PROP Rebuild_Opt "-a"
-# PROP Target_File "Release\tclsh90s.exe"
+# PROP Target_File "Release\tclsh87s.exe"
 # PROP Bsc_Name ""
 # PROP Target_Dir ""
 
 !ENDIF
 
@@ -146,14 +146,10 @@
 
 SOURCE=..\compat\dlfcn.h
 # End Source File
 # Begin Source File
 
-SOURCE=..\compat\fixstrtod.c
-# End Source File
-# Begin Source File
-
 SOURCE=..\compat\gettod.c
 # End Source File
 # Begin Source File
 
 SOURCE=..\compat\limits.h
@@ -184,14 +180,10 @@
 # End Source File
 # Begin Source File
 
 SOURCE=..\compat\strstr.c
 # End Source File
-# Begin Source File
-
-SOURCE=..\compat\strtod.c
-# End Source File
 # Begin Source File
 
 SOURCE=..\compat\strtol.c
 # End Source File
 # Begin Source File

Index: win/tcl.hpj.in
==================================================================
--- win/tcl.hpj.in
+++ win/tcl.hpj.in
@@ -3,13 +3,13 @@
 [OPTIONS]
 HCW=0
 LCID=0x409 0x0 0x0 ;English (United States)
 REPORT=Yes
 TITLE=Tcl/Tk Reference Manual
-CNT=tcl90.cnt
+CNT=tcl87.cnt
 COPYRIGHT=Copyright © 2000 Ajuba Solutions
-HLP=tcl90.hlp
+HLP=tcl87.hlp
 
 [FILES]
 tcl.rtf
 
 [WINDOWS]

Index: win/tcl.m4
==================================================================
--- win/tcl.m4
+++ win/tcl.m4
@@ -991,17 +991,17 @@
 #	Defines the following vars:
 #		TCL_BIN_DIR	Full path to the tcl build dir.
 #------------------------------------------------------------------------
 
 AC_DEFUN([SC_WITH_TCL], [
-    if test -d ../../tcl9.0$1/win;  then
-	TCL_BIN_DEFAULT=../../tcl9.0$1/win
+    if test -d ../../tcl8.7$1/win;  then
+	TCL_BIN_DEFAULT=../../tcl8.7$1/win
     else
-	TCL_BIN_DEFAULT=../../tcl9.0/win
+	TCL_BIN_DEFAULT=../../tcl8.7/win
     fi
 
-    AC_ARG_WITH(tcl, [  --with-tcl=DIR          use Tcl 9.0 binaries from DIR],
+    AC_ARG_WITH(tcl, [  --with-tcl=DIR          use Tcl 8.7 binaries from DIR],
 	    TCL_BIN_DIR=$withval, TCL_BIN_DIR=`cd $TCL_BIN_DEFAULT; pwd`)
     if test ! -d $TCL_BIN_DIR; then
 	AC_MSG_ERROR(Tcl directory $TCL_BIN_DIR does not exist)
     fi
     if test ! -f $TCL_BIN_DIR/Makefile; then

Index: win/tclAppInit.c
==================================================================
--- win/tclAppInit.c
+++ win/tclAppInit.c
@@ -265,14 +265,15 @@
 		break;
 	    }
 	}
     }
 
-    /* Make sure we don't call Tcl_Alloc through the (not yet initialized) stub table */
+    /* Make sure we don't call ckalloc through the (not yet initialized) stub table */
 #   undef Tcl_Alloc
+#   undef Tcl_DbCkalloc
 
-    argSpace = Tcl_Alloc(size * sizeof(char *)
+    argSpace = ckalloc(size * sizeof(char *)
 	    + (_tcslen(cmdLine) * sizeof(TCHAR)) + sizeof(TCHAR));
     argv = (TCHAR **) argSpace;
     argSpace += size * (sizeof(char *)/sizeof(TCHAR));
     size--;
 

Index: win/tclWin32Dll.c
==================================================================
--- win/tclWin32Dll.c
+++ win/tclWin32Dll.c
@@ -253,12 +253,12 @@
 
     Tcl_MutexLock(&mountPointMap);
     dlIter = driveLetterLookup;
     while (dlIter != NULL) {
 	dlIter2 = dlIter->nextPtr;
-	Tcl_Free(dlIter->volumeName);
-	Tcl_Free(dlIter);
+	ckfree(dlIter->volumeName);
+	ckfree(dlIter);
 	dlIter = dlIter2;
     }
     Tcl_MutexUnlock(&mountPointMap);
 }
 
@@ -288,11 +288,11 @@
 TclWinDriveLetterForVolMountPoint(
     const WCHAR *mountPoint)
 {
     MountPointMap *dlIter, *dlPtr2;
     WCHAR Target[55];		/* Target of mount at mount point */
-    WCHAR drive[4] = TEXT("A:\\");
+    WCHAR drive[4] = L"A:\\";
 
     /*
      * Detect the volume mounted there. Unfortunately, there is no simple way
      * to map a unique volume name to a DOS drive letter. So, we have to build
      * an associative array.
@@ -347,12 +347,12 @@
 
 	    /*
 	     * Now dlPtr2 points to the structure to free.
 	     */
 
-	    Tcl_Free(dlPtr2->volumeName);
-	    Tcl_Free(dlPtr2);
+	    ckfree(dlPtr2->volumeName);
+	    ckfree(dlPtr2);
 
 	    /*
 	     * Restart the loop - we could try to be clever and continue half
 	     * way through, but the logic is a bit messy, so it's cleanest
 	     * just to restart.
@@ -366,11 +366,11 @@
 
     /*
      * We couldn't find it, so we must iterate over the letters.
      */
 
-    for (drive[0] = L'A'; drive[0] <= L'Z'; drive[0]++) {
+    for (drive[0] = 'A'; drive[0] <= 'Z'; drive[0]++) {
 	/*
 	 * Try to read the volume mount point and see where it points.
 	 */
 
 	if (GetVolumeNameForVolumeMountPoint(drive,
@@ -383,11 +383,11 @@
 		    alreadyStored = 1;
 		    break;
 		}
 	    }
 	    if (!alreadyStored) {
-		dlPtr2 = Tcl_Alloc(sizeof(MountPointMap));
+		dlPtr2 = ckalloc(sizeof(MountPointMap));
 		dlPtr2->volumeName = TclNativeDupInternalRep(Target);
 		dlPtr2->driveLetter = (char) drive[0];
 		dlPtr2->nextPtr = driveLetterLookup;
 		driveLetterLookup = dlPtr2;
 	    }
@@ -409,11 +409,11 @@
     /*
      * The volume doesn't appear to correspond to a drive letter - we remember
      * that fact and store '-1' so we don't have to look it up each time.
      */
 
-    dlPtr2 = Tcl_Alloc(sizeof(MountPointMap));
+    dlPtr2 = ckalloc(sizeof(MountPointMap));
     dlPtr2->volumeName = TclNativeDupInternalRep((ClientData) mountPoint);
     dlPtr2->driveLetter = -1;
     dlPtr2->nextPtr = driveLetterLookup;
     driveLetterLookup = dlPtr2;
     Tcl_MutexUnlock(&mountPointMap);
@@ -464,12 +464,12 @@
  */
 
 WCHAR *
 Tcl_WinUtfToTChar(
     const char *string,		/* Source string in UTF-8. */
-    size_t len,			/* Source string length in bytes, or -1
-				 * for strlen(). */
+    int len,			/* Source string length in bytes, or -1 for
+				 * strlen(). */
     Tcl_DString *dsPtr)		/* Uninitialized or free DString in which the
 				 * converted string is stored. */
 {
     Tcl_DStringInit(dsPtr);
     if (!string) {
@@ -479,20 +479,20 @@
 }
 
 char *
 Tcl_WinTCharToUtf(
     const WCHAR *string,	/* Source string in Unicode. */
-    size_t len,			/* Source string length in bytes, or -1
-				 * for platform-specific string length. */
+    int len,			/* Source string length in bytes, or -1 for
+				 * platform-specific string length. */
     Tcl_DString *dsPtr)		/* Uninitialized or free DString in which the
 				 * converted string is stored. */
 {
     Tcl_DStringInit(dsPtr);
     if (!string) {
 	return NULL;
     }
-    if (len == TCL_AUTO_LENGTH) {
+    if (len < 0) {
 	len = wcslen((WCHAR *)string);
     } else {
 	len /= 2;
     }
     return TclWCharToUtfDString((unsigned short *)string, len, dsPtr);

Index: win/tclWinChan.c
==================================================================
--- win/tclWinChan.c
+++ win/tclWinChan.c
@@ -265,11 +265,11 @@
 
     for (infoPtr = tsdPtr->firstFilePtr; infoPtr != NULL;
 	    infoPtr = infoPtr->nextPtr) {
 	if (infoPtr->watchMask && !TEST_FLAG(infoPtr->flags, FILE_PENDING)) {
 	    SET_FLAG(infoPtr->flags, FILE_PENDING);
-	    evPtr = Tcl_Alloc(sizeof(FileEvent));
+	    evPtr = ckalloc(sizeof(FileEvent));
 	    evPtr->header.proc = FileEventProc;
 	    evPtr->infoPtr = infoPtr;
 	    Tcl_QueueEvent((Tcl_Event *) evPtr, TCL_QUEUE_TAIL);
 	}
     }
@@ -432,11 +432,11 @@
 
 	    FileThreadActionProc(fileInfoPtr,TCL_CHANNEL_THREAD_REMOVE);
 	    break;
 	}
     }
-    Tcl_Free(fileInfoPtr);
+    ckfree(fileInfoPtr);
     return errorCode;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -1363,11 +1363,11 @@
 	if (infoPtr->handle == (HANDLE) handle) {
 	    return (permissions==infoPtr->validMask) ? infoPtr->channel : NULL;
 	}
     }
 
-    infoPtr = Tcl_Alloc(sizeof(FileInfo));
+    infoPtr = ckalloc(sizeof(FileInfo));
 
     /*
      * TIP #218. Removed the code inserting the new structure into the global
      * list. This is now handled in the thread action callbacks, and only
      * there.
@@ -1569,11 +1569,11 @@
     if ((len == 4) && (_wcsnicmp(p, L"com", 3) == 0)) {
 	/*
 	 * The 4th character must be a digit 1..9
 	 */
 
-	if ((p[3] < L'1') || (p[3] > L'9')) {
+	if ((p[3] < '1') || (p[3] > '9')) {
 	    return 0;
 	}
 	return 1;
     }
 

Index: win/tclWinConsole.c
==================================================================
--- win/tclWinConsole.c
+++ win/tclWinConsole.c
@@ -200,12 +200,12 @@
 /*
  *----------------------------------------------------------------------
  *
  * ReadConsoleBytes, WriteConsoleBytes --
  *
- *	Wrapper for ReadConsole{A,W}, that takes and returns number of bytes
- *	instead of number of TCHARS.
+ *	Wrapper for ReadConsoleW, that takes and returns number of bytes
+ *	instead of number of WCHARS.
  *
  *----------------------------------------------------------------------
  */
 
 static BOOL
@@ -215,11 +215,10 @@
     DWORD nbytes,
     LPDWORD nbytesread)
 {
     DWORD ntchars;
     BOOL result;
-    int tcharsize = sizeof(TCHAR);
 
     /*
      * If user types a Ctrl-Break or Ctrl-C, ReadConsole will return
      * success with ntchars == 0 and GetLastError() will be
      * ERROR_OPERATION_ABORTED. We do not want to treat this case
@@ -228,15 +227,15 @@
      * thread will terminate the program. If a Ctrl signal handler
      * has been established (through an extension for example), it
      * will run and take whatever action it deems appropriate.
      */
     do {
-        result = ReadConsole(hConsole, lpBuffer, nbytes / tcharsize, &ntchars,
+        result = ReadConsole(hConsole, lpBuffer, nbytes / sizeof(WCHAR), &ntchars,
                              NULL);
     } while (result && ntchars == 0 && GetLastError() == ERROR_OPERATION_ABORTED);
     if (nbytesread != NULL) {
-	*nbytesread = ntchars * tcharsize;
+	*nbytesread = ntchars * sizeof(WCHAR);
     }
     return result;
 }
 
 static BOOL
@@ -246,16 +245,15 @@
     DWORD nbytes,
     LPDWORD nbyteswritten)
 {
     DWORD ntchars;
     BOOL result;
-    int tcharsize = sizeof(TCHAR);
 
-    result = WriteConsole(hConsole, lpBuffer, nbytes / tcharsize, &ntchars,
+    result = WriteConsole(hConsole, lpBuffer, nbytes / sizeof(WCHAR), &ntchars,
 	    NULL);
     if (nbyteswritten != NULL) {
-	*nbyteswritten = ntchars * tcharsize;
+	*nbyteswritten = ntchars * sizeof(WCHAR);
     }
     return result;
 }
 
 /*
@@ -462,11 +460,11 @@
 		needEvent = 1;
 	    }
 	}
 
 	if (needEvent) {
-	    ConsoleEvent *evPtr = Tcl_Alloc(sizeof(ConsoleEvent));
+	    ConsoleEvent *evPtr = ckalloc(sizeof(ConsoleEvent));
 
 	    infoPtr->flags |= CONSOLE_PENDING;
 	    evPtr->header.proc = ConsoleEventProc;
 	    evPtr->infoPtr = infoPtr;
 	    Tcl_QueueEvent((Tcl_Event *) evPtr, TCL_QUEUE_TAIL);
@@ -617,14 +615,14 @@
 	    *nextPtrPtr = infoPtr->nextPtr;
 	    break;
 	}
     }
     if (consolePtr->writeBuf != NULL) {
-	Tcl_Free(consolePtr->writeBuf);
+	ckfree(consolePtr->writeBuf);
 	consolePtr->writeBuf = 0;
     }
-    Tcl_Free(consolePtr);
+    ckfree(consolePtr);
 
     return errorCode;
 }
 
 /*
@@ -784,14 +782,14 @@
 	    /*
 	     * Reallocate the buffer to be large enough to hold the data.
 	     */
 
 	    if (infoPtr->writeBuf) {
-		Tcl_Free(infoPtr->writeBuf);
+		ckfree(infoPtr->writeBuf);
 	    }
 	    infoPtr->writeBufLen = toWrite;
-	    infoPtr->writeBuf = Tcl_Alloc(toWrite);
+	    infoPtr->writeBuf = ckalloc(toWrite);
 	}
 	memcpy(infoPtr->writeBuf, buf, toWrite);
 	infoPtr->toWrite = toWrite;
 	ResetEvent(threadInfo->readyEvent);
 	TclPipeThreadSignal(&threadInfo->TI);
@@ -1321,11 +1319,11 @@
 
     /*
      * See if a channel with this handle already exists.
      */
 
-    infoPtr = Tcl_Alloc(sizeof(ConsoleInfo));
+    infoPtr = ckalloc(sizeof(ConsoleInfo));
     memset(infoPtr, 0, sizeof(ConsoleInfo));
 
     infoPtr->validMask = permissions;
     infoPtr->handle = handle;
     infoPtr->channel = (Tcl_Channel) NULL;

Index: win/tclWinError.c
==================================================================
--- win/tclWinError.c
+++ win/tclWinError.c
@@ -379,11 +379,11 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-void
+TCL_NORETURN void
 tclWinDebugPanic(
     const char *format, ...)
 {
 #define TCL_MAX_WARN_LEN 1024
     va_list argList;
@@ -392,18 +392,18 @@
     if (IsDebuggerPresent()) {
 	WCHAR msgString[TCL_MAX_WARN_LEN];
 	char buf[TCL_MAX_WARN_LEN * 3];
 
 	vsnprintf(buf, sizeof(buf), format, argList);
-	msgString[TCL_MAX_WARN_LEN-1] = L'\0';
+	msgString[TCL_MAX_WARN_LEN-1] = '\0';
 	MultiByteToWideChar(CP_UTF8, 0, buf, -1, msgString, TCL_MAX_WARN_LEN);
 
 	/*
 	 * Truncate MessageBox string if it is too long to not overflow the buffer.
 	 */
 
-	if (msgString[TCL_MAX_WARN_LEN-1] != L'\0') {
+	if (msgString[TCL_MAX_WARN_LEN-1] != '\0') {
 	    memcpy(msgString + (TCL_MAX_WARN_LEN - 5), L" ...", 5 * sizeof(WCHAR));
 	}
 	OutputDebugStringW(msgString);
     } else {
 	if (!isatty(fileno(stderr))) {
@@ -411,10 +411,16 @@
 	}
 	vfprintf(stderr, format, argList);
 	fprintf(stderr, "\n");
 	fflush(stderr);
     }
+#   if defined(__GNUC__)
+    __builtin_trap();
+#   else
+    DebugBreak();
+#   endif
+    abort();
 }
 #endif
 /*
  * Local Variables:
  * mode: c

Index: win/tclWinFCmd.c
==================================================================
--- win/tclWinFCmd.c
+++ win/tclWinFCmd.c
@@ -374,12 +374,12 @@
 		 */
 
 		Tcl_SetErrno(EXDEV);
 	    }
 
-	    Tcl_Free((void *)srcArgv);
-	    Tcl_Free((void *)dstArgv);
+	    ckfree(srcArgv);
+	    ckfree(dstArgv);
 	}
 
 	/*
 	 * Other types of access failure is that dst is a read-only
 	 * filesystem, that an open file referred to src or dest, or that src
@@ -453,11 +453,11 @@
 			tempBuf, &nativeRest);
 		if ((size == 0) || (size > MAX_PATH) || (nativeRest == NULL)) {
 		    return TCL_ERROR;
 		}
 		nativeTmp = (WCHAR *) tempBuf;
-		nativeRest[0] = L'\0';
+		nativeRest[0] = '\0';
 
 		result = TCL_ERROR;
 		nativePrefix = (WCHAR *) L"tclr";
 		if (GetTempFileName(nativeTmp, nativePrefix,
 			0, tempBuf) != 0) {
@@ -909,12 +909,12 @@
     normDestPtr = Tcl_FSGetNormalizedPath(NULL,destPathPtr);
     if ((normSrcPtr == NULL) || (normDestPtr == NULL)) {
 	return TCL_ERROR;
     }
 
-    Tcl_WinUtfToTChar(TclGetString(normSrcPtr), -1, &srcString);
-    Tcl_WinUtfToTChar(TclGetString(normDestPtr), -1, &dstString);
+    Tcl_WinUtfToTChar(Tcl_GetString(normSrcPtr), -1, &srcString);
+    Tcl_WinUtfToTChar(Tcl_GetString(normDestPtr), -1, &dstString);
 
     ret = TraverseWinTree(TraversalCopy, &srcString, &dstString, &ds);
 
     Tcl_DStringFree(&srcString);
     Tcl_DStringFree(&dstString);
@@ -982,11 +982,11 @@
 	Tcl_DString native;
 	normPtr = Tcl_FSGetNormalizedPath(NULL, pathPtr);
 	if (normPtr == NULL) {
 	    return TCL_ERROR;
 	}
-	Tcl_WinUtfToTChar(TclGetString(normPtr), -1, &native);
+	Tcl_WinUtfToTChar(Tcl_GetString(normPtr), -1, &native);
 	ret = DoRemoveDirectory(&native, recursive, &ds);
 	Tcl_DStringFree(&native);
     } else {
 	ret = DoRemoveJustDirectory(Tcl_FSGetNativePath(pathPtr), 0, &ds);
     }
@@ -1522,11 +1522,11 @@
 	 * they are not (and cannot be).
 	 *
 	 * We test for, and fix that case, here.
 	 */
 
-	size_t len;
+	int len;
 	const char *str = TclGetStringFromObj(fileName, &len);
 
 	if (len < 4) {
 	    if (len == 0) {
 		/*
@@ -1584,19 +1584,18 @@
     int longShort,		/* 0 to short name, 1 to long name. */
     Tcl_Obj **attributePtrPtr)	/* A pointer to return the object with. */
 {
     int pathc, i;
     Tcl_Obj *splitPath;
-    size_t length;
 
     splitPath = Tcl_FSSplitPath(fileName, &pathc);
 
     if (splitPath == NULL || pathc == 0) {
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		    "could not read \"%s\": no such file or directory",
-		    TclGetString(fileName)));
+		    Tcl_GetString(fileName)));
 	    errno = ENOENT;
 	    Tcl_PosixError(interp);
 	}
 	goto cleanup;
     }
@@ -1609,10 +1608,11 @@
     Tcl_IncrRefCount(splitPath);
 
     for (i = 0; i < pathc; i++) {
 	Tcl_Obj *elt;
 	char *pathv;
+	int length;
 
 	Tcl_ListObjIndex(NULL, splitPath, i, &elt);
 
 	pathv = TclGetStringFromObj(elt, &length);
 	if ((pathv[0] == '/') || ((length == 3) && (pathv[1] == ':'))
@@ -1882,11 +1882,11 @@
     Tcl_Obj *fileName,		/* The name of the file. */
     Tcl_Obj *attributePtr)	/* The new value of the attribute. */
 {
     Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 	    "cannot set attribute \"%s\" for file \"%s\": attribute is readonly",
-	    tclpFileAttrStrings[objIndex], TclGetString(fileName)));
+	    tclpFileAttrStrings[objIndex], Tcl_GetString(fileName)));
     errno = EINVAL;
     Tcl_PosixError(interp);
     return TCL_ERROR;
 }
 

Index: win/tclWinFile.c
==================================================================
--- win/tclWinFile.c
+++ win/tclWinFile.c
@@ -175,11 +175,11 @@
 static Tcl_Obj *	WinReadLinkDirectory(const WCHAR *LinkDirectory);
 static int		WinLink(const WCHAR *LinkSource,
 			    const WCHAR *LinkTarget, int linkAction);
 static int		WinSymLinkDirectory(const WCHAR *LinkDirectory,
 			    const WCHAR *LinkTarget);
-MODULE_SCOPE void	tclWinDebugPanic(const char *format, ...);
+MODULE_SCOPE TCL_NORETURN void	tclWinDebugPanic(const char *format, ...);
 
 /*
  *--------------------------------------------------------------------
  *
  * WinLink --
@@ -393,15 +393,15 @@
      * forward slashes everything appears to work, but the resulting symlink
      * is useless!
      */
 
     for (loop = nativeTarget; *loop != 0; loop++) {
-	if (*loop == L'/') {
-	    *loop = L'\\';
+	if (*loop == '/') {
+	    *loop = '\\';
 	}
     }
-    if ((nativeTarget[len-1] == L'\\') && (nativeTarget[len-2] != L':')) {
+    if ((nativeTarget[len-1] == '\\') && (nativeTarget[len-2] != ':')) {
 	nativeTarget[len-1] = 0;
     }
 
     /*
      * Build the reparse info.
@@ -570,11 +570,11 @@
 	 * which support reparse tags at present. If that changes in the
 	 * future, this code will have to be generalised.
 	 */
 
 	offset = 0;
-	if (reparseBuffer->MountPointReparseBuffer.PathBuffer[0] == L'\\') {
+	if (reparseBuffer->MountPointReparseBuffer.PathBuffer[0] == '\\') {
 	    /*
 	     * Check whether this is a mounted volume.
 	     */
 
 	    if (wcsncmp(reparseBuffer->MountPointReparseBuffer.PathBuffer,
@@ -584,11 +584,11 @@
 		/*
 		 * There is some confusion between \??\ and \\?\ which we have
 		 * to fix here. It doesn't seem very well documented.
 		 */
 
-		reparseBuffer->MountPointReparseBuffer.PathBuffer[1]=L'\\';
+		reparseBuffer->MountPointReparseBuffer.PathBuffer[1] = '\\';
 
 		/*
 		 * Check if a corresponding drive letter exists, and use that
 		 * if it is found
 		 */
@@ -800,11 +800,11 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-void
+TCL_NORETURN void
 tclWinDebugPanic(
     const char *format, ...)
 {
 #define TCL_MAX_WARN_LEN 1024
     va_list argList;
@@ -812,28 +812,38 @@
     WCHAR msgString[TCL_MAX_WARN_LEN];
 
     va_start(argList, format);
     vsnprintf(buf, sizeof(buf), format, argList);
 
-    msgString[TCL_MAX_WARN_LEN-1] = L'\0';
+    msgString[TCL_MAX_WARN_LEN-1] = '\0';
     MultiByteToWideChar(CP_UTF8, 0, buf, -1, msgString, TCL_MAX_WARN_LEN);
 
     /*
      * Truncate MessageBox string if it is too long to not overflow the screen
      * and cause possible oversized window error.
      */
 
-    if (msgString[TCL_MAX_WARN_LEN-1] != L'\0') {
+    if (msgString[TCL_MAX_WARN_LEN-1] != '\0') {
 	memcpy(msgString + (TCL_MAX_WARN_LEN - 5), L" ...", 5 * sizeof(WCHAR));
     }
     if (IsDebuggerPresent()) {
 	OutputDebugStringW(msgString);
     } else {
 	MessageBeep(MB_ICONEXCLAMATION);
 	MessageBoxW(NULL, msgString, L"Fatal Error",
 		MB_ICONSTOP | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
     }
+#if defined(__GNUC__)
+    __builtin_trap();
+#elif defined(_WIN64)
+    __debugbreak();
+#elif defined(_MSC_VER) && defined (_M_IX86)
+    _asm {int 3}
+#else
+    DebugBreak();
+#endif
+    abort();
 }
 
 /*
  *---------------------------------------------------------------------------
  *
@@ -856,10 +866,20 @@
     const char *argv0)		/* If NULL, install PanicMessageBox, otherwise
 				 * ignore. */
 {
     WCHAR wName[MAX_PATH];
     char name[MAX_PATH * 3];
+
+    /*
+     * Under Windows we ignore argv0, and return the path for the file used to
+     * create this process. Only if it is NULL, install a new panic handler.
+     */
+
+    if (argv0 == NULL) {
+#	undef Tcl_SetPanicProc
+	Tcl_SetPanicProc(tclWinDebugPanic);
+    }
 
     GetModuleFileNameW(NULL, wName, MAX_PATH);
     WideCharToMultiByte(CP_UTF8, 0, wName, -1, name, sizeof(name), NULL, NULL);
     TclWinNoBackslash(name);
     TclSetObjNameOfExecutable(Tcl_NewStringObj(name, -1), NULL);
@@ -910,24 +930,24 @@
 	if (norm != NULL) {
 	    /*
 	     * Match a single file directly.
 	     */
 
+	    int len;
 	    DWORD attr;
 	    WIN32_FILE_ATTRIBUTE_DATA data;
-	    size_t length = 0;
-	    const char *str = TclGetStringFromObj(norm, &length);
+	    const char *str = TclGetStringFromObj(norm, &len);
 
 	    native = Tcl_FSGetNativePath(pathPtr);
 
 	    if (GetFileAttributesEx(native,
 		    GetFileExInfoStandard, &data) != TRUE) {
 		return TCL_OK;
 	    }
 	    attr = data.dwFileAttributes;
 
-	    if (NativeMatchType(WinIsDrive(str, length), attr, native, types)) {
+	    if (NativeMatchType(WinIsDrive(str,len), attr, native, types)) {
 		Tcl_ListObjAppendElement(interp, resultPtr, pathPtr);
 	    }
 	}
 	return TCL_OK;
     } else {
@@ -934,11 +954,11 @@
 	DWORD attr;
 	HANDLE handle;
 	WIN32_FIND_DATA data;
 	const char *dirName;	/* UTF-8 dir name, later with pattern
 				 * appended. */
-	size_t dirLength;
+	int dirLength;
 	int matchSpecialDots;
 	Tcl_DString ds;		/* Native encoding of dir, also used
 				 * temporarily for other things. */
 	Tcl_DString dsOrig;	/* UTF-8 encoding of dir. */
 	Tcl_Obj *fileNamePtr;
@@ -1482,11 +1502,11 @@
 	}
 	if (rc == 0) {
 	    DWORD i, size = MAX_PATH;
 
 	    wHomeDir = uiPtr->usri1_home_dir;
-	    if ((wHomeDir != NULL) && (wHomeDir[0] != L'\0')) {
+	    if ((wHomeDir != NULL) && (wHomeDir[0] != '\0')) {
 		size = lstrlenW(wHomeDir);
 		TclWCharToUtfDString(wHomeDir, size, bufferPtr);
 	    } else {
 		/*
 		 * User exists but has no home dir. Return
@@ -2446,11 +2466,11 @@
     Tcl_Obj *normPath = Tcl_FSGetNormalizedPath(NULL, pathPtr);
 
     if (normPath == NULL) {
 	return NULL;
     }
-    path = TclGetString(normPath);
+    path = Tcl_GetString(normPath);
     if (path == NULL) {
 	return NULL;
     }
 
     firstSeparator = strchr(path, '/');
@@ -2524,11 +2544,11 @@
     Tcl_Obj *temp = NULL;
     int isDrive = 1;
     Tcl_DString ds;		/* Some workspace. */
 
     Tcl_DStringInit(&dsNorm);
-    path = TclGetString(pathPtr);
+    path = Tcl_GetString(pathPtr);
 
     currentPathEndPosition = path + nextCheckpoint;
     if (*currentPathEndPosition == '/') {
 	currentPathEndPosition++;
     }
@@ -2561,12 +2581,12 @@
 			int i;
 
 			for (i=0 ; i<len ; i++) {
 			    WCHAR wc = ((WCHAR *) nativePath)[i];
 
-			    if (wc >= L'a') {
-				wc -= (L'a' - L'A');
+			    if (wc >= 'a') {
+				wc -= ('a' - 'A');
 				((WCHAR *) nativePath)[i] = wc;
 			    }
 			}
 			Tcl_DStringAppend(&dsNorm,
 				(const char *)nativePath,
@@ -2619,16 +2639,16 @@
 
 		    /*
 		     * Convert link to forward slashes.
 		     */
 
-		    for (path = TclGetString(to); *path != 0; path++) {
+		    for (path = Tcl_GetString(to); *path != 0; path++) {
 			if (*path == '\\') {
 			    *path = '/';
 			}
 		    }
-		    path = TclGetString(to);
+		    path = Tcl_GetString(to);
 		    currentPathEndPosition = path + nextCheckpoint;
 		    if (temp != NULL) {
 			Tcl_DecrRefCount(temp);
 		    }
 		    temp = to;
@@ -2652,12 +2672,12 @@
 	     */
 
 	    if (isDrive) {
 		WCHAR drive = ((WCHAR *) nativePath)[0];
 
-		if (drive >= L'a') {
-		    drive -= (L'a' - L'A');
+		if (drive >= 'a') {
+		    drive -= ('a' - 'A');
 		    ((WCHAR *) nativePath)[0] = drive;
 		}
 		Tcl_DStringAppend(&dsNorm, (const char *)nativePath,
 			Tcl_DStringLength(&ds));
 	    } else {
@@ -2750,12 +2770,12 @@
 
 	    /*
 	     * We have to make the drive letter uppercase.
 	     */
 
-	    if (wpath[0] >= L'a') {
-		wpath[0] -= (L'a' - L'A');
+	    if (wpath[0] >= 'a') {
+		wpath[0] -= ('a' - 'A');
 	    }
 	    Tcl_DStringAppend(&dsNorm, (const char *) wpath,
 		    wpathlen * sizeof(WCHAR));
 	    Tcl_DStringFree(&ds);
 	}
@@ -2780,19 +2800,19 @@
 	if (*lastValidPathEnd != 0) {
 	    /*
 	     * Not the end of the string.
 	     */
 
+	    int len;
 	    char *path;
 	    Tcl_Obj *tmpPathPtr;
-	    size_t length;
 
 	    tmpPathPtr = Tcl_NewStringObj(Tcl_DStringValue(&ds),
 		    nextCheckpoint);
 	    Tcl_AppendToObj(tmpPathPtr, lastValidPathEnd, -1);
-	    path = TclGetStringFromObj(tmpPathPtr, &length);
-	    Tcl_SetStringObj(pathPtr, path, length);
+	    path = TclGetStringFromObj(tmpPathPtr, &len);
+	    Tcl_SetStringObj(pathPtr, path, len);
 	    Tcl_DecrRefCount(tmpPathPtr);
 	} else {
 	    /*
 	     * End of string was reached above.
 	     */
@@ -2856,11 +2876,11 @@
 	/*
 	 * Path of form /foo/bar which is a path in the root directory of the
 	 * current volume.
 	 */
 
-	const char *drive = TclGetString(useThisCwd);
+	const char *drive = Tcl_GetString(useThisCwd);
 
 	absolutePath = Tcl_NewStringObj(drive,2);
 	Tcl_AppendToObj(absolutePath, path, -1);
 	Tcl_IncrRefCount(absolutePath);
 
@@ -2871,11 +2891,11 @@
 	/*
 	 * Path of form C:foo/bar, but this only makes sense if the cwd is
 	 * also on drive C.
 	 */
 
-	size_t cwdLen;
+	int cwdLen;
 	const char *drive = TclGetStringFromObj(useThisCwd, &cwdLen);
 	char drive_cur = path[0];
 
 	if (drive_cur >= 'a') {
 	    drive_cur -= ('a' - 'A');
@@ -2945,11 +2965,11 @@
 TclpNativeToNormalized(
     ClientData clientData)
 {
     Tcl_DString ds;
     Tcl_Obj *objPtr;
-    size_t len;
+    int len;
     char *copy, *p;
 
     Tcl_WinTCharToUtf((const WCHAR *) clientData, -1, &ds);
     copy = Tcl_DStringValue(&ds);
     len = Tcl_DStringLength(&ds);
@@ -3007,11 +3027,11 @@
     Tcl_Obj *pathPtr)
 {
     WCHAR *nativePathPtr = NULL;
     const char *str;
     Tcl_Obj *validPathPtr;
-    size_t len;
+    int len;
     WCHAR *wp;
 
     if (TclFSCwdIsNative()) {
 	/*
 	 * The cwd is native, which means we can use the translated path
@@ -3044,13 +3064,13 @@
 	 */
 
 	Tcl_IncrRefCount(validPathPtr);
     }
 
-    str = TclGetStringFromObj(validPathPtr, &len);
+    str = Tcl_GetStringFromObj(validPathPtr, &len);
 
-    if (strlen(str) != len) {
+    if (strlen(str) != (size_t) len) {
 	/*
 	 * String contains NUL-bytes. This is invalid.
 	 */
 
 	goto done;
@@ -3075,11 +3095,11 @@
 
     /*
      * Overallocate 6 chars, making some room for extended paths
      */
 
-    wp = nativePathPtr = Tcl_Alloc((len + 6) * sizeof(WCHAR));
+    wp = nativePathPtr = ckalloc((len + 6) * sizeof(WCHAR));
     if (nativePathPtr==0) {
       goto done;
     }
     MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str, -1, nativePathPtr,
 	    len + 1);
@@ -3173,11 +3193,11 @@
 	return NULL;
     }
 
     len = sizeof(WCHAR) * (wcslen((const WCHAR *) clientData) + 1);
 
-    copy = Tcl_Alloc(len);
+    copy = ckalloc(len);
     memcpy(copy, clientData, len);
     return copy;
 }
 
 /*
@@ -3289,11 +3309,11 @@
 	 */
 
         bufsz = 0;
         GetTokenInformation(token, TokenUser, NULL, 0, &bufsz);
         if (bufsz) {
-            buf = Tcl_Alloc(bufsz);
+            buf = ckalloc(bufsz);
             if (GetTokenInformation(token, TokenUser, buf, bufsz, &bufsz)) {
                 owned = EqualSid(ownerSid, ((PTOKEN_USER) buf)->User.Sid);
             }
         }
         CloseHandle(token);
@@ -3305,11 +3325,11 @@
 
     if (secd) {
         LocalFree(secd);            /* Also frees ownerSid */
     }
     if (buf) {
-        Tcl_Free(buf);
+        ckfree(buf);
     }
 
     return (owned != 0);        /* Convert non-0 to 1 */
 }
 

Index: win/tclWinInit.c
==================================================================
--- win/tclWinInit.c
+++ win/tclWinInit.c
@@ -111,11 +111,11 @@
 /*
  *---------------------------------------------------------------------------
  *
  * TclpInitPlatform --
  *
- *	Initialize all the platform-dependant things like signals,
+ *	Initialize all the platform-dependent things like signals,
  *	floating-point error handling and sockets.
  *
  *	Called at process initialization time.
  *
  * Results:
@@ -179,18 +179,18 @@
  */
 
 void
 TclpInitLibraryPath(
     char **valuePtr,
-    size_t *lengthPtr,
+    unsigned int *lengthPtr,
     Tcl_Encoding *encodingPtr)
 {
 #define LIBRARY_SIZE	    64
     Tcl_Obj *pathPtr;
     char installLib[LIBRARY_SIZE];
     const char *bytes;
-    size_t length;
+    int length;
 
     pathPtr = Tcl_NewObj();
 
     /*
      * Initialize the substring used when locating the script library. The
@@ -224,11 +224,11 @@
 	    TclGetProcessGlobalValue(&sourceLibraryDir));
 
     *encodingPtr = NULL;
     bytes = TclGetStringFromObj(pathPtr, &length);
     *lengthPtr = length++;
-    *valuePtr = Tcl_Alloc(length);
+    *valuePtr = ckalloc(length);
     memcpy(*valuePtr, bytes, length);
     Tcl_DecrRefCount(pathPtr);
 }
 
 /*
@@ -315,11 +315,11 @@
 	    objPtr = TclDStringToObj(&ds);
 	} else {
 	    objPtr = Tcl_NewStringObj(buf, -1);
 	}
 	Tcl_ListObjAppendElement(NULL, pathPtr, objPtr);
-	Tcl_Free((void *)pathv);
+	ckfree(pathv);
     }
 }
 
 /*
  *---------------------------------------------------------------------------
@@ -339,11 +339,11 @@
  */
 
 static void
 InitializeDefaultLibraryDir(
     char **valuePtr,
-    size_t *lengthPtr,
+    unsigned int *lengthPtr,
     Tcl_Encoding *encodingPtr)
 {
     HMODULE hModule = TclWinGetTclInstance();
     WCHAR wName[MAX_PATH + LIBRARY_SIZE];
     char name[(MAX_PATH + LIBRARY_SIZE) * 3];
@@ -361,11 +361,11 @@
     *end = '\\';
 
     TclWinNoBackslash(name);
     sprintf(end + 1, "lib/tcl%s", TCL_VERSION);
     *lengthPtr = strlen(name);
-    *valuePtr = Tcl_Alloc(*lengthPtr + 1);
+    *valuePtr = ckalloc(*lengthPtr + 1);
     *encodingPtr = NULL;
     memcpy(*valuePtr, name, *lengthPtr + 1);
 }
 
 /*
@@ -387,11 +387,11 @@
  */
 
 static void
 InitializeSourceLibraryDir(
     char **valuePtr,
-    size_t *lengthPtr,
+    unsigned int *lengthPtr,
     Tcl_Encoding *encodingPtr)
 {
     HMODULE hModule = TclWinGetTclInstance();
     WCHAR wName[MAX_PATH + LIBRARY_SIZE];
     char name[(MAX_PATH + LIBRARY_SIZE) * 3];
@@ -409,11 +409,11 @@
     *end = '\\';
 
     TclWinNoBackslash(name);
     sprintf(end + 1, "../library");
     *lengthPtr = strlen(name);
-    *valuePtr = Tcl_Alloc(*lengthPtr + 1);
+    *valuePtr = ckalloc(*lengthPtr + 1);
     *encodingPtr = NULL;
     memcpy(*valuePtr, name, *lengthPtr + 1);
 }
 
 /*
@@ -541,11 +541,11 @@
 	Tcl_SetVar2(interp, "tcl_platform", "machine",
 		processors[sys.oemId.wProcessorArchitecture],
 		TCL_GLOBAL_ONLY);
     }
 
-#ifdef _DEBUG
+#ifndef NDEBUG
     /*
      * The existence of the "debug" element of the tcl_platform array
      * indicates that this particular Tcl shell has been compiled with debug
      * information. Using "info exists tcl_platform(debug)" a Tcl script can
      * direct the interpreter to load debug versions of DLLs with the load
@@ -606,41 +606,40 @@
  *	Locate the entry in environ for a given name. On Unix this routine is
  *	case sensitive, on Windows this matches mixed case.
  *
  * Results:
  *	The return value is the index in environ of an entry with the name
- *	"name", or TCL_IO_FAILURE if there is no such entry. The integer
- *	at *lengthPtr is filled in with the length of name (if a matching
- *	entry is found) or the length of the environ array (if no
- *	matching entry is found).
+ *	"name", or -1 if there is no such entry. The integer at *lengthPtr is
+ *	filled in with the length of name (if a matching entry is found) or
+ *	the length of the environ array (if no matching entry is found).
  *
  * Side effects:
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-size_t
+int
 TclpFindVariable(
     const char *name,		/* Name of desired environment variable
 				 * (UTF-8). */
-    size_t *lengthPtr)		/* Used to return length of name (for
+    int *lengthPtr)		/* Used to return length of name (for
 				 * successful searches) or number of non-NULL
 				 * entries in environ (for unsuccessful
 				 * searches). */
 {
-    size_t i, length, result = TCL_IO_FAILURE;
-    register const char *env, *p1, *p2;
+    int i, length, result = -1;
+    const char *env, *p1, *p2;
     char *envUpper, *nameUpper;
     Tcl_DString envString;
 
     /*
      * Convert the name to all upper case for the case insensitive comparison.
      */
 
     length = strlen(name);
-    nameUpper = Tcl_Alloc(length + 1);
+    nameUpper = ckalloc(length + 1);
     memcpy(nameUpper, name, length+1);
     Tcl_UtfToUpper(nameUpper);
 
     Tcl_DStringInit(&envString);
     for (i = 0, env = environ[i]; env != NULL; i++, env = environ[i]) {
@@ -653,11 +652,11 @@
 	envUpper = Tcl_ExternalToUtfDString(NULL, env, -1, &envString);
 	p1 = strchr(envUpper, '=');
 	if (p1 == NULL) {
 	    continue;
 	}
-	length = p1 - envUpper;
+	length = (int) (p1 - envUpper);
 	Tcl_DStringSetLength(&envString, length+1);
 	Tcl_UtfToUpper(envUpper);
 
 	p1 = envUpper;
 	p2 = nameUpper;
@@ -675,11 +674,11 @@
 
     *lengthPtr = i;
 
   done:
     Tcl_DStringFree(&envString);
-    Tcl_Free(nameUpper);
+    ckfree(nameUpper);
     return result;
 }
 
 /*
  * Local Variables:

Index: win/tclWinInt.h
==================================================================
--- win/tclWinInt.h
+++ win/tclWinInt.h
@@ -56,13 +56,13 @@
 			    int permissions, int appendMode);
 MODULE_SCOPE Tcl_Channel TclWinOpenSerialChannel(HANDLE handle,
 			    char *channelName, int permissions);
 MODULE_SCOPE HANDLE	TclWinSerialOpen(HANDLE handle, const WCHAR *name,
 			    DWORD access);
-MODULE_SCOPE int	TclWinSymLinkCopyDirectory(const TCHAR *LinkOriginal,
-			    const TCHAR *LinkCopy);
-MODULE_SCOPE int	TclWinSymLinkDelete(const TCHAR *LinkOriginal,
+MODULE_SCOPE int	TclWinSymLinkCopyDirectory(const WCHAR *LinkOriginal,
+			    const WCHAR *LinkCopy);
+MODULE_SCOPE int	TclWinSymLinkDelete(const WCHAR *LinkOriginal,
 			    int linkOnly);
 MODULE_SCOPE int        TclWinFileOwned(Tcl_Obj *);
 
 MODULE_SCOPE const char*TclpGetUserName(Tcl_DString *bufferPtr);
 
@@ -83,16 +83,16 @@
     HANDLE evControl;		/* Auto-reset event used by the main thread to
 				 * signal when the pipe thread should attempt
 				 * to do read/write operation. Additionally
 				 * used as signal to stop (state set to -1) */
     volatile LONG state;	/* Indicates current state of the thread */
-    void *clientData;	/* Referenced data of the main thread */
+    ClientData clientData;	/* Referenced data of the main thread */
     HANDLE evWakeUp;		/* Optional wake-up event worker set by shutdown */
 } TclPipeThreadInfo;
 
 
-/* If pipe-workers will use some tcl subsystem, we can use Tcl_Alloc without
+/* If pipe-workers will use some tcl subsystem, we can use ckalloc without
  * more overhead for finalize thread (should be executed anyway)
  *
  * #define _PTI_USE_CKALLOC 1
  */
 
@@ -110,11 +110,11 @@
 #define PTI_STATE_DOWN  8	/* worker is down */
 
 
 MODULE_SCOPE
 TclPipeThreadInfo *	TclPipeThreadCreateTI(TclPipeThreadInfo **pipeTIPtr,
-			    void *clientData, HANDLE wakeEvent);
+			    ClientData clientData, HANDLE wakeEvent);
 MODULE_SCOPE int	TclPipeThreadWaitForSignal(TclPipeThreadInfo **pipeTIPtr);
 
 static inline void
 TclPipeThreadSignal(
     TclPipeThreadInfo **pipeTIPtr)

Index: win/tclWinLoad.c
==================================================================
--- win/tclWinLoad.c
+++ win/tclWinLoad.c
@@ -62,11 +62,11 @@
 				 * function which should be used for this
 				 * file. */
     int flags)
 {
     HINSTANCE hInstance = NULL;
-    const TCHAR *nativeName;
+    const WCHAR *nativeName;
     Tcl_LoadHandle handlePtr;
     DWORD firstError;
 
     /*
      * First try the full path the user gave us. This is particularly
@@ -93,11 +93,11 @@
          * second load attempt below also fails.
         */
         firstError = (nativeName == NULL) ?
 		ERROR_MOD_NOT_FOUND : GetLastError();
 
-	nativeName = Tcl_WinUtfToTChar(TclGetString(pathPtr), -1, &ds);
+	nativeName = Tcl_WinUtfToTChar(Tcl_GetString(pathPtr), -1, &ds);
 	hInstance = LoadLibraryEx(nativeName, NULL,
 		LOAD_WITH_ALTERED_SEARCH_PATH);
 	Tcl_DStringFree(&ds);
     }
 
@@ -115,11 +115,11 @@
             lastError = GetLastError();
         else
             lastError = firstError;
 
 	errMsg = Tcl_ObjPrintf("couldn't load library \"%s\": ",
-		TclGetString(pathPtr));
+		Tcl_GetString(pathPtr));
 
 	/*
 	 * Check for possible DLL errors. This doesn't work quite right,
 	 * because Windows seems to only return ERROR_MOD_NOT_FOUND for just
 	 * about any problem, but it's better than nothing. It'd be even
@@ -168,11 +168,11 @@
 
     /*
      * Succeded; package everything up for Tcl.
      */
 
-    handlePtr = Tcl_Alloc(sizeof(struct Tcl_LoadHandle_));
+    handlePtr = ckalloc(sizeof(struct Tcl_LoadHandle_));
     handlePtr->clientData = (ClientData) hInstance;
     handlePtr->findSymbolProcPtr = &FindSymbol;
     handlePtr->unloadFileProcPtr = &UnloadFile;
     *loadHandle = handlePtr;
     *unloadProcPtr = &UnloadFile;
@@ -253,11 +253,11 @@
 				 * that represents the loaded file. */
 {
     HINSTANCE hInstance = (HINSTANCE) loadHandle->clientData;
 
     FreeLibrary(hInstance);
-    Tcl_Free(loadHandle);
+    ckfree(loadHandle);
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -414,11 +414,11 @@
     /*
      * Store our computed value in the global.
      */
 
   copyToGlobalBuffer:
-    dllDirectoryName = Tcl_Alloc((nameLen+1) * sizeof(WCHAR));
+    dllDirectoryName = ckalloc((nameLen+1) * sizeof(WCHAR));
     wcscpy(dllDirectoryName, name);
     return TCL_OK;
 }
 
 /*

Index: win/tclWinNotify.c
==================================================================
--- win/tclWinNotify.c
+++ win/tclWinNotify.c
@@ -47,11 +47,11 @@
  *
  * You must hold the notifierMutex lock before accessing this variable.
  */
 
 static int notifierCount = 0;
-static const TCHAR className[] = TEXT("TclNotifier");
+static const WCHAR className[] = L"TclNotifier";
 static int initialized = 0;
 static CRITICAL_SECTION notifierMutex;
 
 /*
  * Static routines defined in this file.
@@ -81,11 +81,10 @@
 {
     if (tclNotifierHooks.initNotifierProc) {
 	return tclNotifierHooks.initNotifierProc();
     } else {
 	ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
-	WNDCLASS class;
 
 	TclpMasterLock();
 	if (!initialized) {
 	    initialized = 1;
 	    InitializeCriticalSection(&notifierMutex);
@@ -97,22 +96,24 @@
 	 * this module.
 	 */
 
 	EnterCriticalSection(&notifierMutex);
 	if (notifierCount == 0) {
-	    class.style = 0;
-	    class.cbClsExtra = 0;
-	    class.cbWndExtra = 0;
-	    class.hInstance = TclWinGetTclInstance();
-	    class.hbrBackground = NULL;
-	    class.lpszMenuName = NULL;
-	    class.lpszClassName = className;
-	    class.lpfnWndProc = NotifierProc;
-	    class.hIcon = NULL;
-	    class.hCursor = NULL;
-
-	    if (!RegisterClass(&class)) {
+	    WNDCLASS clazz;
+
+	    clazz.style = 0;
+	    clazz.cbClsExtra = 0;
+	    clazz.cbWndExtra = 0;
+	    clazz.hInstance = TclWinGetTclInstance();
+	    clazz.hbrBackground = NULL;
+	    clazz.lpszMenuName = NULL;
+	    clazz.lpszClassName = className;
+	    clazz.lpfnWndProc = NotifierProc;
+	    clazz.hIcon = NULL;
+	    clazz.hCursor = NULL;
+
+	    if (!RegisterClass(&clazz)) {
 		Tcl_Panic("Unable to register TclNotifier window class");
 	    }
 	}
 	notifierCount++;
 	LeaveCriticalSection(&notifierMutex);

Index: win/tclWinPanic.c
==================================================================
--- win/tclWinPanic.c
+++ win/tclWinPanic.c
@@ -1,6 +1,6 @@
- /*
+/*
  * tclWinPanic.c --
  *
  *	Contains the Windows-specific command-line panic proc.
  *
  * Copyright (c) 2013 by Jan Nijtmans.
@@ -26,11 +26,11 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-TCL_NORETURN1 void
+void
 Tcl_ConsolePanic(
     const char *format, ...)
 {
 #define TCL_MAX_WARN_LEN 26000
     va_list argList;
@@ -40,18 +40,18 @@
     DWORD dummy;
 
     va_start(argList, format);
     vsnprintf(buf+3, sizeof(buf)-3, format, argList);
     buf[sizeof(buf)-1] = 0;
-    msgString[TCL_MAX_WARN_LEN-1] = L'\0';
+    msgString[TCL_MAX_WARN_LEN-1] = '\0';
     MultiByteToWideChar(CP_UTF8, 0, buf+3, -1, msgString, TCL_MAX_WARN_LEN);
 
     /*
      * Truncate MessageBox string if it is too long to not overflow the buffer.
      */
 
-    if (msgString[TCL_MAX_WARN_LEN-1] != L'\0') {
+    if (msgString[TCL_MAX_WARN_LEN-1] != '\0') {
 	memcpy(msgString + (TCL_MAX_WARN_LEN - 5), L" ...", 5 * sizeof(WCHAR));
     }
 
     if (IsDebuggerPresent()) {
 	OutputDebugStringW(msgString);

Index: win/tclWinPipe.c
==================================================================
--- win/tclWinPipe.c
+++ win/tclWinPipe.c
@@ -59,11 +59,11 @@
  * This list is used to map from pids to process handles.
  */
 
 typedef struct ProcInfo {
     HANDLE hProcess;
-    size_t dwProcessId;
+    DWORD dwProcessId;
     struct ProcInfo *nextPtr;
 } ProcInfo;
 
 static ProcInfo *procList;
 
@@ -400,11 +400,11 @@
 	    needEvent = 1;
 	}
 
 	if (needEvent) {
 	    infoPtr->flags |= PIPE_PENDING;
-	    evPtr = Tcl_Alloc(sizeof(PipeEvent));
+	    evPtr = ckalloc(sizeof(PipeEvent));
 	    evPtr->header.proc = PipeEventProc;
 	    evPtr->infoPtr = infoPtr;
 	    Tcl_QueueEvent((Tcl_Event *) evPtr, TCL_QUEUE_TAIL);
 	}
     }
@@ -431,11 +431,11 @@
 TclWinMakeFile(
     HANDLE handle)		/* Type-specific data. */
 {
     WinFile *filePtr;
 
-    filePtr = Tcl_Alloc(sizeof(WinFile));
+    filePtr = ckalloc(sizeof(WinFile));
     filePtr->type = WIN_FILE;
     filePtr->handle = handle;
 
     return (TclFile)filePtr;
 }
@@ -823,21 +823,21 @@
 		    && (GetStdHandle(STD_OUTPUT_HANDLE) != filePtr->handle)
 		    && (GetStdHandle(STD_ERROR_HANDLE) != filePtr->handle))) {
 	    if (filePtr->handle != NULL &&
 		    CloseHandle(filePtr->handle) == FALSE) {
 		TclWinConvertError(GetLastError());
-		Tcl_Free(filePtr);
+		ckfree(filePtr);
 		return -1;
 	    }
 	}
 	break;
 
     default:
 	Tcl_Panic("TclpCloseFile: unexpected file type");
     }
 
-    Tcl_Free(filePtr);
+    ckfree(filePtr);
     return 0;
 }
 
 /*
  *--------------------------------------------------------------------------
@@ -848,35 +848,35 @@
  *	child process.
  *
  * Results:
  *	Returns the process id for the child process. If the pid was not known
  *	by Tcl, either because the pid was not created by Tcl or the child
- *	process has already been reaped, TCL_IO_FAILURE is returned.
+ *	process has already been reaped, -1 is returned.
  *
  * Side effects:
  *	None.
  *
  *--------------------------------------------------------------------------
  */
 
-size_t
+int
 TclpGetPid(
     Tcl_Pid pid)		/* The HANDLE of the child process. */
 {
     ProcInfo *infoPtr;
 
     PipeInit();
 
     Tcl_MutexLock(&pipeMutex);
     for (infoPtr = procList; infoPtr != NULL; infoPtr = infoPtr->nextPtr) {
-	if (infoPtr->dwProcessId == (size_t) pid) {
+	if (infoPtr->dwProcessId == (DWORD) (size_t) pid) {
 	    Tcl_MutexUnlock(&pipeMutex);
 	    return infoPtr->dwProcessId;
 	}
     }
     Tcl_MutexUnlock(&pipeMutex);
-    return TCL_IO_FAILURE;
+    return (unsigned long) -1;
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -1756,11 +1756,11 @@
 				 * can be read. */
     int numPids,		/* The number of pids in the pid array. */
     Tcl_Pid *pidPtr)		/* An array of process identifiers. */
 {
     char channelName[16 + TCL_INTEGER_SPACE];
-    PipeInfo *infoPtr = Tcl_Alloc(sizeof(PipeInfo));
+    PipeInfo *infoPtr = ckalloc(sizeof(PipeInfo));
 
     PipeInit();
 
     infoPtr->watchMask = 0;
     infoPtr->flags = 0;
@@ -1914,17 +1914,17 @@
 
     pipePtr = Tcl_GetChannelInstanceData(chan);
     TclNewObj(pidsObj);
     for (i = 0; i < pipePtr->numPids; i++) {
 	Tcl_ListObjAppendElement(NULL, pidsObj,
-		Tcl_NewWideIntObj(
+		Tcl_NewWideIntObj((unsigned)
 			TclpGetPid(pipePtr->pidPtr[i])));
 	Tcl_DetachPids(1, &pipePtr->pidPtr[i]);
     }
     Tcl_SetObjResult(interp, pidsObj);
     if (pipePtr->numPids > 0) {
-	Tcl_Free(pipePtr->pidPtr);
+	ckfree(pipePtr->pidPtr);
 	pipePtr->numPids = 0;
     }
 }
 
 /*
@@ -2107,28 +2107,28 @@
 	if (pipePtr->errorFile) {
 	    WinFile *filePtr = (WinFile *) pipePtr->errorFile;
 
 	    errChan = Tcl_MakeFileChannel((ClientData) filePtr->handle,
 		    TCL_READABLE);
-	    Tcl_Free(filePtr);
+	    ckfree(filePtr);
 	} else {
 	    errChan = NULL;
 	}
 
 	result = TclCleanupChildren(interp, pipePtr->numPids,
 		pipePtr->pidPtr, errChan);
     }
 
     if (pipePtr->numPids > 0) {
-	Tcl_Free(pipePtr->pidPtr);
+	ckfree(pipePtr->pidPtr);
     }
 
     if (pipePtr->writeBuf != NULL) {
-	Tcl_Free(pipePtr->writeBuf);
+	ckfree(pipePtr->writeBuf);
     }
 
-    Tcl_Free(pipePtr);
+    ckfree(pipePtr);
 
     if (errorCode == 0) {
 	return result;
     }
     return errorCode;
@@ -2293,14 +2293,14 @@
 	    /*
 	     * Reallocate the buffer to be large enough to hold the data.
 	     */
 
 	    if (infoPtr->writeBuf) {
-		Tcl_Free(infoPtr->writeBuf);
+		ckfree(infoPtr->writeBuf);
 	    }
 	    infoPtr->writeBufLen = toWrite;
-	    infoPtr->writeBuf = Tcl_Alloc(toWrite);
+	    infoPtr->writeBuf = ckalloc(toWrite);
 	}
 	memcpy(infoPtr->writeBuf, buf, toWrite);
 	infoPtr->toWrite = toWrite;
 	ResetEvent(infoPtr->writable);
 	TclPipeThreadSignal(&infoPtr->writeTI);
@@ -2558,11 +2558,11 @@
 
     Tcl_MutexLock(&pipeMutex);
     prevPtrPtr = &procList;
     for (infoPtr = procList; infoPtr != NULL;
 	    prevPtrPtr = &infoPtr->nextPtr, infoPtr = infoPtr->nextPtr) {
-	 if (infoPtr->dwProcessId == (size_t) pid) {
+	 if (infoPtr->dwProcessId == (DWORD) (size_t) pid) {
 	    *prevPtrPtr = infoPtr->nextPtr;
 	    break;
 	}
     }
     Tcl_MutexUnlock(&pipeMutex);
@@ -2676,11 +2676,11 @@
     /*
      * Officially close the process handle.
      */
 
     CloseHandle(infoPtr->hProcess);
-    Tcl_Free(infoPtr);
+    ckfree(infoPtr);
 
     return result;
 }
 
 /*
@@ -2702,13 +2702,13 @@
  */
 
 void
 TclWinAddProcess(
     void *hProcess,		/* Handle to process */
-    size_t id)		/* Global process identifier */
+    unsigned long id)		/* Global process identifier */
 {
-    ProcInfo *procPtr = Tcl_Alloc(sizeof(ProcInfo));
+    ProcInfo *procPtr = ckalloc(sizeof(ProcInfo));
 
     PipeInit();
 
     procPtr->hProcess = hProcess;
     procPtr->dwProcessId = id;
@@ -2754,11 +2754,11 @@
 	return TCL_ERROR;
     }
     if (objc == 1) {
 	Tcl_SetObjResult(interp, Tcl_NewWideIntObj((unsigned) getpid()));
     } else {
-	chan = Tcl_GetChannel(interp, TclGetString(objv[1]),
+	chan = Tcl_GetChannel(interp, Tcl_GetString(objv[1]),
 		NULL);
 	if (chan == (Tcl_Channel) NULL) {
 	    return TCL_ERROR;
 	}
 	chanTypePtr = Tcl_GetChannelType(chan);
@@ -3191,12 +3191,11 @@
 {
     WCHAR name[MAX_PATH];
     char *namePtr;
     HANDLE handle;
     DWORD flags = FILE_ATTRIBUTE_TEMPORARY;
-    size_t length;
-    int counter, counter2;
+    int length, counter, counter2;
     Tcl_DString buf;
 
     if (!resultingNameObj) {
 	flags |= FILE_FLAG_DELETE_ON_CLOSE;
     }
@@ -3280,11 +3279,11 @@
 {
     TclPipeThreadInfo *pipeTI;
 #ifndef _PTI_USE_CKALLOC
     pipeTI = malloc(sizeof(TclPipeThreadInfo));
 #else
-    pipeTI = Tcl_Alloc(sizeof(TclPipeThreadInfo));
+    pipeTI = ckalloc(sizeof(TclPipeThreadInfo));
 #endif /* !_PTI_USE_CKALLOC */
     pipeTI->evControl = CreateEvent(NULL, FALSE, FALSE, NULL);
     pipeTI->state = PTI_STATE_IDLE;
     pipeTI->clientData = clientData;
     pipeTI->evWakeUp = wakeEvent;
@@ -3429,10 +3428,11 @@
 	 * Thread was idle/waiting, notify it goes teardown
 	 */
 
 	SetEvent(evControl);
 	*pipeTIPtr = NULL;
+	/* FALLTHRU */
     case PTI_STATE_DOWN:
 	return 1;
 
     default:
 	/*
@@ -3642,11 +3642,11 @@
 	}
 	CloseHandle(pipeTI->evControl);
 #ifndef _PTI_USE_CKALLOC
 	free(pipeTI);
 #else
-	Tcl_Free(pipeTI);
+	ckfree(pipeTI);
 #endif /* !_PTI_USE_CKALLOC */
     }
 }
 
 /*
@@ -3692,11 +3692,11 @@
 	    SetEvent(pipeTI->evWakeUp);
 	}
 #ifndef _PTI_USE_CKALLOC
 	free(pipeTI);
 #else
-	Tcl_Free(pipeTI);
+	ckfree(pipeTI);
 	/* be sure all subsystems used are finalized */
 	Tcl_FinalizeThread();
 #endif /* !_PTI_USE_CKALLOC */
     }
 }

Index: win/tclWinPort.h
==================================================================
--- win/tclWinPort.h
+++ win/tclWinPort.h
@@ -12,19 +12,24 @@
  */
 
 #ifndef _TCLWINPORT
 #define _TCLWINPORT
 
-#if !defined(_WIN64) && defined(BUILD_tcl)
+/* define _USE_64BIT_TIME_T (or make/configure option time64bit) to force 64-bit time_t */
+#if defined(_USE_64BIT_TIME_T)
+#define __MINGW_USE_VC2005_COMPAT
+#endif
+
+#if !defined(_WIN64) && !defined(__MINGW_USE_VC2005_COMPAT)
 /* See [Bug 3354324]: file mtime sets wrong time */
 #   define _USE_32BIT_TIME_T
 #endif
 
 /*
  * We must specify the lower version we intend to support.
  *
- * WINVER = 0x0501 means Windows XP and above
+ * WINVER = 0x0500 means Windows 2000 and above
  */
 
 #ifndef WINVER
 #   define WINVER 0x0501
 #endif
@@ -526,11 +531,11 @@
 /*
  * The following defines wrap the system memory allocation routines for
  * use by tclAlloc.c.
  */
 
-#define TclpSysAlloc(size)		((void*)HeapAlloc(GetProcessHeap(), \
+#define TclpSysAlloc(size, isBin)	((void*)HeapAlloc(GetProcessHeap(), \
 					    (DWORD)0, (DWORD)size))
 #define TclpSysFree(ptr)		(HeapFree(GetProcessHeap(), \
 					    (DWORD)0, (HGLOBAL)ptr))
 #define TclpSysRealloc(ptr, size)	((void*)HeapReAlloc(GetProcessHeap(), \
 					    (DWORD)0, (LPVOID)ptr, (DWORD)size))
@@ -542,11 +547,11 @@
 /*
  * The following macros have trivial definitions, allowing generic code to
  * address platform-specific issues.
  */
 
-#define TclpReleaseFile(file)	Tcl_Free(file)
+#define TclpReleaseFile(file)	ckfree(file)
 
 /*
  * The following macros and declarations wrap the C runtime library
  * functions.
  */
@@ -558,7 +563,10 @@
 #endif /* INVALID_SET_FILE_POINTER */
 
 #ifndef LABEL_SECURITY_INFORMATION
 #   define LABEL_SECURITY_INFORMATION (0x00000010L)
 #endif
+
+#define Tcl_DirEntry void
+#define TclDIR void
 
 #endif /* _TCLWINPORT */

Index: win/tclWinSerial.c
==================================================================
--- win/tclWinSerial.c
+++ win/tclWinSerial.c
@@ -529,11 +529,11 @@
 	 * Queue an event if the serial is signaled for reading or writing.
 	 */
 
 	if (needEvent) {
 	    infoPtr->flags |= SERIAL_PENDING;
-	    evPtr = Tcl_Alloc(sizeof(SerialEvent));
+	    evPtr = ckalloc(sizeof(SerialEvent));
 	    evPtr->header.proc = SerialEventProc;
 	    evPtr->infoPtr = infoPtr;
 	    Tcl_QueueEvent((Tcl_Event *) evPtr, TCL_QUEUE_TAIL);
 	}
     }
@@ -660,14 +660,14 @@
     /*
      * Wrap the error file into a channel and give it to the cleanup routine.
      */
 
     if (serialPtr->writeBuf != NULL) {
-	Tcl_Free(serialPtr->writeBuf);
+	ckfree(serialPtr->writeBuf);
 	serialPtr->writeBuf = NULL;
     }
-    Tcl_Free(serialPtr);
+    ckfree(serialPtr);
 
     if (errorCode == 0) {
 	return result;
     }
     return errorCode;
@@ -1025,14 +1025,14 @@
 	    /*
 	     * Reallocate the buffer to be large enough to hold the data.
 	     */
 
 	    if (infoPtr->writeBuf) {
-		Tcl_Free(infoPtr->writeBuf);
+		ckfree(infoPtr->writeBuf);
 	    }
 	    infoPtr->writeBufLen = toWrite;
-	    infoPtr->writeBuf = Tcl_Alloc(toWrite);
+	    infoPtr->writeBuf = ckalloc(toWrite);
 	}
 	memcpy(infoPtr->writeBuf, buf, toWrite);
 	infoPtr->toWrite = toWrite;
 	ResetEvent(infoPtr->evWritable);
 	TclPipeThreadSignal(&infoPtr->writeTI);
@@ -1445,11 +1445,11 @@
 {
     SerialInfo *infoPtr;
 
     SerialInit();
 
-    infoPtr = Tcl_Alloc(sizeof(SerialInfo));
+    infoPtr = ckalloc(sizeof(SerialInfo));
     memset(infoPtr, 0, sizeof(SerialInfo));
 
     infoPtr->validMask = permissions;
     infoPtr->handle = handle;
     infoPtr->channel = (Tcl_Channel) NULL;
@@ -1771,11 +1771,11 @@
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"bad value for -xchar: should be a list of"
 			" two elements with each a single 8-bit character", -1));
 		Tcl_SetErrorCode(interp, "TCL", "VALUE", "XCHAR", NULL);
 	    }
-	    Tcl_Free((void *)argv);
+	    ckfree(argv);
 	    return TCL_ERROR;
 	}
 
 	/*
 	 * These dereferences are safe, even in the zero-length string cases,
@@ -1802,11 +1802,11 @@
 	    if ((character > 0xFF) || argv[1][charLen]) {
 		goto badXchar;
 	    }
 	    dcb.XoffChar = (char) character;
 	}
-	Tcl_Free((void *)argv);
+	ckfree(argv);
 
 	if (!SetCommState(infoPtr->handle, &dcb)) {
 	    goto setStateFailed;
 	}
 	return TCL_OK;
@@ -1827,11 +1827,11 @@
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"bad value \"%s\" for -ttycontrol: should be "
 			"a list of signal,value pairs", value));
 		Tcl_SetErrorCode(interp, "TCL", "VALUE", "TTYCONTROL", NULL);
 	    }
-	    Tcl_Free((void *)argv);
+	    ckfree(argv);
 	    return TCL_ERROR;
 	}
 
 	for (i = 0; i < argc - 1; i += 2) {
 	    if (Tcl_GetBoolean(interp, argv[i+1], &flag) == TCL_ERROR) {
@@ -1885,11 +1885,11 @@
 		result = TCL_ERROR;
 		break;
 	    }
 	}
 
-	Tcl_Free((void *)argv);
+	ckfree(argv);
 	return result;
     }
 
     /*
      * Option -sysbuffer {read_size write_size}
@@ -1911,11 +1911,11 @@
 	    outSize = infoPtr->sysBufWrite;
 	} else if (argc == 2) {
 	    inSize  = atoi(argv[0]);
 	    outSize = atoi(argv[1]);
 	}
-	Tcl_Free((void *)argv);
+	ckfree(argv);
 
 	if ((argc < 1) || (argc > 2) || (inSize <= 0) || (outSize <= 0)) {
 	    if (interp != NULL) {
 		Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 			"bad value \"%s\" for -sysbuffer: should be "

Index: win/tclWinSock.c
==================================================================
--- win/tclWinSock.c
+++ win/tclWinSock.c
@@ -358,11 +358,11 @@
  */
 
 void
 InitializeHostName(
     char **valuePtr,
-    size_t *lengthPtr,
+    unsigned int *lengthPtr,
     Tcl_Encoding *encodingPtr)
 {
     WCHAR tbuf[MAX_COMPUTERNAME_LENGTH + 1];
     DWORD length = MAX_COMPUTERNAME_LENGTH + 1;
     Tcl_DString ds;
@@ -395,11 +395,11 @@
 	}
     }
 
     *encodingPtr = Tcl_GetEncoding(NULL, "utf-8");
     *lengthPtr = Tcl_DStringLength(&ds);
-    *valuePtr = Tcl_Alloc(*lengthPtr + 1);
+    *valuePtr = ckalloc(*lengthPtr + 1);
     memcpy(*valuePtr, Tcl_DStringValue(&ds), *lengthPtr + 1);
     Tcl_DStringFree(&ds);
 }
 
 /*
@@ -1064,11 +1064,11 @@
 	    statePtr->sockets = thisfd->next;
 	    if (closesocket(thisfd->fd) == SOCKET_ERROR) {
 		TclWinConvertError((DWORD) WSAGetLastError());
 		errorCode = Tcl_GetErrno();
 	    }
-	    Tcl_Free(thisfd);
+	    ckfree(thisfd);
 	}
     }
 
     if (statePtr->addrlist != NULL) {
         freeaddrinfo(statePtr->addrlist);
@@ -1106,11 +1106,11 @@
      * socket list. This is now done by the thread action callbacks, and only
      * there. This happens before this code is called. We can free without
      * fear of damaging the list.
      */
 
-    Tcl_Free(statePtr);
+    ckfree(statePtr);
     return errorCode;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -2720,11 +2720,11 @@
 	    statePtr = statePtr->nextPtr) {
 	if (GOT_BITS(statePtr->readyEvents,
 		statePtr->watchEvents | FD_CONNECT | FD_ACCEPT)
                 && !GOT_BITS(statePtr->flags, SOCKET_PENDING)) {
 	    SET_BITS(statePtr->flags, SOCKET_PENDING);
-	    evPtr = Tcl_Alloc(sizeof(SocketEvent));
+	    evPtr = ckalloc(sizeof(SocketEvent));
 	    evPtr->header.proc = SocketEventProc;
 	    evPtr->socket = statePtr->sockets->fd;
 	    Tcl_QueueEvent((Tcl_Event *) evPtr, TCL_QUEUE_TAIL);
 	}
     }
@@ -2995,11 +2995,11 @@
     if (fds == NULL) {
 	/*
          * Add the first FD.
          */
 
-	statePtr->sockets = Tcl_Alloc(sizeof(TcpFdList));
+	statePtr->sockets = ckalloc(sizeof(TcpFdList));
 	fds = statePtr->sockets;
     } else {
 	/*
          * Find end of list and append FD.
          */
@@ -3006,11 +3006,11 @@
 
 	while (fds->next != NULL) {
 	    fds = fds->next;
 	}
 
-	fds->next = Tcl_Alloc(sizeof(TcpFdList));
+	fds->next = ckalloc(sizeof(TcpFdList));
 	fds = fds->next;
     }
 
     /*
      * Populate new FD.
@@ -3039,11 +3039,11 @@
  */
 
 static TcpState *
 NewSocketInfo(SOCKET socket)
 {
-    TcpState *statePtr = Tcl_Alloc(sizeof(TcpState));
+    TcpState *statePtr = ckalloc(sizeof(TcpState));
 
     memset(statePtr, 0, sizeof(TcpState));
 
     /*
      * TIP #218. Removed the code inserting the new structure into the global
@@ -3399,10 +3399,72 @@
 	}
     }
     return 0;
 }
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclWinGetSockOpt, et al. --
+ *
+ *	Those functions are historically exported by the stubs table and
+ *	just use the original system calls now.
+ *
+ * Warning:
+ *	Those functions are depreciated and will be removed with TCL 9.0.
+ *
+ * Results:
+ *	As defined for each function.
+ *
+ * Side effects:
+ *	As defined for each function.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+#undef TclWinGetSockOpt
+int
+TclWinGetSockOpt(
+    SOCKET s,
+    int level,
+    int optname,
+    char *optval,
+    int *optlen)
+{
+
+    return getsockopt(s, level, optname, optval, optlen);
+}
+#undef TclWinSetSockOpt
+int
+TclWinSetSockOpt(
+    SOCKET s,
+    int level,
+    int optname,
+    const char *optval,
+    int optlen)
+{
+    return setsockopt(s, level, optname, optval, optlen);
+}
+
+#undef TclpInetNtoa
+char *
+TclpInetNtoa(
+    struct in_addr addr)
+{
+    return inet_ntoa(addr);
+}
+#undef TclWinGetServByName
+struct servent *
+TclWinGetServByName(
+    const char *name,
+    const char *proto)
+{
+    return getservbyname(name, proto);
+}
+#endif /* TCL_NO_DEPRECATED */
+
 /*
  *----------------------------------------------------------------------
  *
  * TcpThreadActionProc --
  *

Index: win/tclWinTest.c
==================================================================
--- win/tclWinTest.c
+++ win/tclWinTest.c
@@ -39,10 +39,12 @@
 			    Tcl_Obj *const objv[]);
 static int		TestwinclockCmd(ClientData dummy, Tcl_Interp* interp,
 			    int objc, Tcl_Obj *const objv[]);
 static int		TestwinsleepCmd(ClientData dummy, Tcl_Interp* interp,
 			    int objc, Tcl_Obj *const objv[]);
+static int		TestSizeCmd(ClientData dummy, Tcl_Interp* interp,
+			    int objc, Tcl_Obj *const objv[]);
 static Tcl_ObjCmdProc	TestExceptionCmd;
 static int		TestplatformChmod(const char *nativePath, int pmode);
 static int		TestchmodCmd(ClientData dummy, Tcl_Interp* interp,
 			    int objc, Tcl_Obj *const objv[]);
 
@@ -76,10 +78,11 @@
     Tcl_CreateObjCommand(interp, "testvolumetype", TestvolumetypeCmd,
 	    NULL, NULL);
     Tcl_CreateObjCommand(interp, "testwinclock", TestwinclockCmd, NULL, NULL);
     Tcl_CreateObjCommand(interp, "testwinsleep", TestwinsleepCmd, NULL, NULL);
     Tcl_CreateObjCommand(interp, "testexcept", TestExceptionCmd, NULL, NULL);
+    Tcl_CreateObjCommand(interp, "testsize", TestSizeCmd, NULL, NULL);
     return TCL_OK;
 }
 
 /*
  *----------------------------------------------------------------------
@@ -307,10 +310,35 @@
 	return TCL_ERROR;
     }
     Sleep((DWORD) ms);
     return TCL_OK;
 }
+
+static int
+TestSizeCmd(
+    ClientData clientData,	/* Unused */
+    Tcl_Interp* interp,		/* Tcl interpreter */
+    int objc,			/* Parameter count */
+    Tcl_Obj *const * objv)	/* Parameter vector */
+{
+    if (objc != 2) {
+	goto syntax;
+    }
+    if (strcmp(Tcl_GetString(objv[1]), "time_t") == 0) {
+	Tcl_SetObjResult(interp, Tcl_NewWideIntObj(sizeof(time_t)));
+	return TCL_OK;
+    }
+    if (strcmp(Tcl_GetString(objv[1]), "st_mtime") == 0) {
+        Tcl_StatBuf *statPtr;
+        Tcl_SetObjResult(interp, Tcl_NewWideIntObj(sizeof(statPtr->st_mtime)));
+        return TCL_OK;
+    }
+
+syntax:
+    Tcl_WrongNumArgs(interp, 1, objv, "time_t|st_mtime");
+    return TCL_ERROR;
+}
 
 /*
  *----------------------------------------------------------------------
  *
  * TestExceptionCmd --
@@ -463,11 +491,11 @@
 
 	if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
 	    goto done;
 	}
 
-	secDesc = Tcl_Alloc(secDescLen);
+	secDesc = ckalloc(secDescLen);
 	if (!GetFileSecurityA(nativePath, infoBits,
 		(PSECURITY_DESCRIPTOR) secDesc, secDescLen, &secDescLen2)
 		|| (secDescLen < secDescLen2)) {
 	    goto done;
 	}
@@ -475,11 +503,11 @@
 
     /*
      * Get the World SID.
      */
 
-    userSid = Tcl_Alloc(GetSidLengthRequired((UCHAR) 1));
+    userSid = ckalloc(GetSidLengthRequired((UCHAR) 1));
     InitializeSid(userSid, &userSidAuthority, (BYTE) 1);
     *(GetSidSubAuthority(userSid, 0)) = SECURITY_WORLD_RID;
 
     /*
      * If curAclPresent == false then curAcl and curAclDefaulted not valid.
@@ -501,11 +529,11 @@
      * Allocate memory for the new ACL.
      */
 
     newAclSize = ACLSize.AclBytesInUse + sizeof(ACCESS_DENIED_ACE)
 	    + GetLengthSid(userSid) - sizeof(DWORD);
-    newAcl = Tcl_Alloc(newAclSize);
+    newAcl = ckalloc(newAclSize);
 
     /*
      * Initialize the new ACL.
      */
 
@@ -578,20 +606,20 @@
 	res = 0;
     }
 
   done:
     if (secDesc) {
-	Tcl_Free(secDesc);
+	ckfree(secDesc);
     }
     if (newAcl) {
-	Tcl_Free(newAcl);
+	ckfree(newAcl);
     }
     if (userSid) {
-	Tcl_Free(userSid);
+	ckfree(userSid);
     }
     if (userDomain) {
-	Tcl_Free(userDomain);
+	ckfree(userDomain);
     }
 
     if (res != 0) {
 	return res;
     }

Index: win/tclWinThrd.c
==================================================================
--- win/tclWinThrd.c
+++ win/tclWinThrd.c
@@ -176,11 +176,11 @@
     );
 
     lpOrigStartAddress = winThreadPtr->lpStartAddress;
     lpOrigParameter = winThreadPtr->lpParameter;
 
-    Tcl_Free(winThreadPtr);
+    ckfree(winThreadPtr);
     return lpOrigStartAddress(lpOrigParameter);
 }
 
 /*
  *----------------------------------------------------------------------
@@ -202,18 +202,18 @@
 int
 TclpThreadCreate(
     Tcl_ThreadId *idPtr,	/* Return, the ID of the thread. */
     Tcl_ThreadCreateProc *proc,	/* Main() function of the thread. */
     ClientData clientData,	/* The one argument to Main(). */
-    size_t stackSize,		/* Size of stack for the new thread. */
+    int stackSize,		/* Size of stack for the new thread. */
     int flags)			/* Flags controlling behaviour of the new
 				 * thread. */
 {
     WinThread *winThreadPtr;		/* Per-thread startup info */
     HANDLE tHandle;
 
-    winThreadPtr = (WinThread *)Tcl_Alloc(sizeof(WinThread));
+    winThreadPtr = (WinThread *)ckalloc(sizeof(WinThread));
     winThreadPtr->lpStartAddress = (LPTHREAD_START_ROUTINE) proc;
     winThreadPtr->lpParameter = clientData;
     winThreadPtr->fpControl = _controlfp(0, 0);
 
     EnterCriticalSection(&joinLock);
@@ -566,11 +566,11 @@
 	/*
 	 * Double inside master lock check to avoid a race.
 	 */
 
 	if (*mutexPtr == NULL) {
-	    csPtr = Tcl_Alloc(sizeof(CRITICAL_SECTION));
+	    csPtr = ckalloc(sizeof(CRITICAL_SECTION));
 	    InitializeCriticalSection(csPtr);
 	    *mutexPtr = (Tcl_Mutex)csPtr;
 	    TclRememberMutex(mutexPtr);
 	}
 	TclpMasterUnlock();
@@ -627,11 +627,11 @@
 {
     CRITICAL_SECTION *csPtr = *(CRITICAL_SECTION **)mutexPtr;
 
     if (csPtr != NULL) {
 	DeleteCriticalSection(csPtr);
-	Tcl_Free(csPtr);
+	ckfree(csPtr);
 	*mutexPtr = NULL;
     }
 }
 
 /*
@@ -709,11 +709,11 @@
 	/*
 	 * Initialize the per-condition queue pointers and Mutex.
 	 */
 
 	if (*condPtr == NULL) {
-	    winCondPtr = Tcl_Alloc(sizeof(WinCondition));
+	    winCondPtr = ckalloc(sizeof(WinCondition));
 	    InitializeCriticalSection(&winCondPtr->condLock);
 	    winCondPtr->firstPtr = NULL;
 	    winCondPtr->lastPtr = NULL;
 	    *condPtr = (Tcl_Condition) winCondPtr;
 	    TclRememberCondition(condPtr);
@@ -920,11 +920,11 @@
      * reclaimed.
      */
 
     if (winCondPtr != NULL) {
 	DeleteCriticalSection(&winCondPtr->condLock);
-	Tcl_Free(winCondPtr);
+	ckfree(winCondPtr);
 	*condPtr = NULL;
     }
 }
 
 
@@ -1035,11 +1035,11 @@
 void *
 TclpThreadCreateKey(void)
 {
     DWORD *key;
 
-    key = TclpSysAlloc(sizeof *key);
+    key = TclpSysAlloc(sizeof *key, 0);
     if (key == NULL) {
 	Tcl_Panic("unable to allocate thread key!");
     }
 
     *key = TlsAlloc();

Index: win/tclWinTime.c
==================================================================
--- win/tclWinTime.c
+++ win/tclWinTime.c
@@ -10,16 +10,41 @@
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  */
 
 #include "tclInt.h"
 
+#define SECSPERDAY	(60L * 60L * 24L)
+#define SECSPERYEAR	(SECSPERDAY * 365L)
+#define SECSPER4YEAR	(SECSPERYEAR * 4L + SECSPERDAY)
+
 /*
  * Number of samples over which to estimate the performance counter.
  */
 
 #define SAMPLES		64
 
+/*
+ * The following arrays contain the day of year for the last day of each
+ * month, where index 1 is January.
+ */
+
+#ifndef TCL_NO_DEPRECATED
+static const int normalDays[] = {
+    -1, 30, 58, 89, 119, 150, 180, 211, 242, 272, 303, 333, 364
+};
+
+static const int leapDays[] = {
+    -1, 30, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
+};
+
+typedef struct {
+    char tzName[64];		/* Time zone name */
+    struct tm tm;		/* time information */
+} ThreadSpecificData;
+static Tcl_ThreadDataKey dataKey;
+#endif /* TCL_NO_DEPRECATED */
+
 /*
  * Data for managing high-resolution timers.
  */
 
 typedef struct {
@@ -97,17 +122,20 @@
  */
 static struct {
     int initialized;		/* 1 if initialized, 0 otherwise */
     int perfCounter;		/* 1 if performance counter usable for wide clicks */
     double microsecsScale;	/* Denominator scale between clock / microsecs */
-} wideClick = {0, 0.0};
+} wideClick = {0, 0, 0.0};
 
 
 /*
  * Declarations for functions defined later in this file.
  */
 
+#ifndef TCL_NO_DEPRECATED
+static struct tm *	ComputeGMT(const time_t *tp);
+#endif /* TCL_NO_DEPRECATED */
 static void		StopCalibration(ClientData clientData);
 static DWORD WINAPI	CalibrationThread(LPVOID arg);
 static void 		UpdateTimeEachSecond(void);
 static void		ResetCounterSamples(Tcl_WideUInt fileTime,
 			    Tcl_WideInt perfCounter, Tcl_WideInt perfFreq);
@@ -142,11 +170,11 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-Tcl_WideUInt
+unsigned long
 TclpGetSeconds(void)
 {
     Tcl_WideInt usecSincePosixEpoch;
 
     /* Try to use high resolution timer */
@@ -168,11 +196,11 @@
  * TclpGetClicks --
  *
  *	This procedure returns a value that represents the highest resolution
  *	clock available on the system. There are no guarantees on what the
  *	resolution will be. In Tcl we will call this value a "click". The
- *	start time is also system dependant.
+ *	start time is also system dependent.
  *
  * Results:
  *	Number of clicks from some start time.
  *
  * Side effects:
@@ -179,30 +207,30 @@
  *	None.
  *
  *----------------------------------------------------------------------
  */
 
-Tcl_WideUInt
+unsigned long
 TclpGetClicks(void)
 {
     Tcl_WideInt usecSincePosixEpoch;
 
     /* Try to use high resolution timer */
     if ( tclGetTimeProcPtr == NativeGetTime
       && (usecSincePosixEpoch = NativeGetMicroseconds())
     ) {
-	return (Tcl_WideUInt)usecSincePosixEpoch;
+	return (unsigned long)usecSincePosixEpoch;
     } else {
 	/*
 	* Use the Tcl_GetTime abstraction to get the time in microseconds, as
 	* nearly as we can, and return it.
 	*/
 
 	Tcl_Time now;		/* Current Tcl time */
 
 	tclGetTimeProcPtr(&now, tclTimeClientData);	/* Tcl_GetTime inlined */
-	return (Tcl_WideUInt)(now.sec * 1000000) + now.usec;
+	return (unsigned long)(now.sec * 1000000) + now.usec;
     }
 }
 
 /*
  *----------------------------------------------------------------------
@@ -681,10 +709,242 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
+ * TclpGetDate --
+ *
+ *	This function converts between seconds and struct tm. If useGMT is
+ *	true, then the returned date will be in Greenwich Mean Time (GMT).
+ *	Otherwise, it will be in the local time zone.
+ *
+ * Results:
+ *	Returns a static tm structure.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+struct tm *
+TclpGetDate(
+    const time_t *t,
+    int useGMT)
+{
+    struct tm *tmPtr;
+    time_t time;
+
+    if (!useGMT) {
+#if defined(_MSC_VER) && (_MSC_VER >= 1900)
+#	undef timezone /* prevent conflict with timezone() function */
+	long timezone = 0;
+#endif
+
+	tzset();
+
+	/*
+	 * If we are in the valid range, let the C run-time library handle it.
+	 * Otherwise we need to fake it. Note that this algorithm ignores
+	 * daylight savings time before the epoch.
+	 */
+
+	/*
+	 * Hm, Borland's localtime manages to return NULL under certain
+	 * circumstances (e.g. wintime.test, test 1.2). Nobody tests for this,
+	 * since 'localtime' isn't supposed to do this, possibly leading to
+	 * crashes.
+	 *
+	 * Patch: We only call this function if we are at least one day into
+	 * the epoch, else we handle it ourselves (like we do for times < 0).
+	 * H. Giese, June 2003
+	 */
+
+#ifdef __BORLANDC__
+#define LOCALTIME_VALIDITY_BOUNDARY	SECSPERDAY
+#else
+#define LOCALTIME_VALIDITY_BOUNDARY	0
+#endif
+
+	if (*t >= LOCALTIME_VALIDITY_BOUNDARY) {
+	    return TclpLocaltime(t);
+	}
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1900)
+	_get_timezone(&timezone);
+#endif
+
+	time = *t - timezone;
+
+	/*
+	 * If we aren't near to overflowing the long, just add the bias and
+	 * use the normal calculation. Otherwise we will need to adjust the
+	 * result at the end.
+	 */
+
+	if (*t < (LONG_MAX - 2*SECSPERDAY) && *t > (LONG_MIN + 2*SECSPERDAY)) {
+	    tmPtr = ComputeGMT(&time);
+	} else {
+	    tmPtr = ComputeGMT(t);
+
+	    tzset();
+
+	    /*
+	     * Add the bias directly to the tm structure to avoid overflow.
+	     * Propagate seconds overflow into minutes, hours and days.
+	     */
+
+	    time = tmPtr->tm_sec - timezone;
+	    tmPtr->tm_sec = (int)(time % 60);
+	    if (tmPtr->tm_sec < 0) {
+		tmPtr->tm_sec += 60;
+		time -= 60;
+	    }
+
+	    time = tmPtr->tm_min + time/60;
+	    tmPtr->tm_min = (int)(time % 60);
+	    if (tmPtr->tm_min < 0) {
+		tmPtr->tm_min += 60;
+		time -= 60;
+	    }
+
+	    time = tmPtr->tm_hour + time/60;
+	    tmPtr->tm_hour = (int)(time % 24);
+	    if (tmPtr->tm_hour < 0) {
+		tmPtr->tm_hour += 24;
+		time -= 24;
+	    }
+
+	    time /= 24;
+	    tmPtr->tm_mday += (int)time;
+	    tmPtr->tm_yday += (int)time;
+	    tmPtr->tm_wday = (tmPtr->tm_wday + (int)time) % 7;
+	}
+    } else {
+	tmPtr = ComputeGMT(t);
+    }
+    return tmPtr;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ComputeGMT --
+ *
+ *	This function computes GMT given the number of seconds since the epoch
+ *	(midnight Jan 1 1970).
+ *
+ * Results:
+ *	Returns a (per thread) statically allocated struct tm.
+ *
+ * Side effects:
+ *	Updates the values of the static struct tm.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static struct tm *
+ComputeGMT(
+    const time_t *tp)
+{
+    struct tm *tmPtr;
+    long tmp, rem;
+    int isLeap;
+    const int *days;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    tmPtr = &tsdPtr->tm;
+
+    /*
+     * Compute the 4 year span containing the specified time.
+     */
+
+    tmp = (long)(*tp / SECSPER4YEAR);
+    rem = (long)(*tp % SECSPER4YEAR);
+
+    /*
+     * Correct for weird mod semantics so the remainder is always positive.
+     */
+
+    if (rem < 0) {
+	tmp--;
+	rem += SECSPER4YEAR;
+    }
+
+    /*
+     * Compute the year after 1900 by taking the 4 year span and adjusting for
+     * the remainder. This works because 2000 is a leap year, and 1900/2100
+     * are out of the range.
+     */
+
+    tmp = (tmp * 4) + 70;
+    isLeap = 0;
+    if (rem >= SECSPERYEAR) {			  /* 1971, etc. */
+	tmp++;
+	rem -= SECSPERYEAR;
+	if (rem >= SECSPERYEAR) {		  /* 1972, etc. */
+	    tmp++;
+	    rem -= SECSPERYEAR;
+	    if (rem >= SECSPERYEAR + SECSPERDAY) { /* 1973, etc. */
+		tmp++;
+		rem -= SECSPERYEAR + SECSPERDAY;
+	    } else {
+		isLeap = 1;
+	    }
+	}
+    }
+    tmPtr->tm_year = tmp;
+
+    /*
+     * Compute the day of year and leave the seconds in the current day in the
+     * remainder.
+     */
+
+    tmPtr->tm_yday = rem / SECSPERDAY;
+    rem %= SECSPERDAY;
+
+    /*
+     * Compute the time of day.
+     */
+
+    tmPtr->tm_hour = rem / 3600;
+    rem %= 3600;
+    tmPtr->tm_min = rem / 60;
+    tmPtr->tm_sec = rem % 60;
+
+    /*
+     * Compute the month and day of month.
+     */
+
+    days = (isLeap) ? leapDays : normalDays;
+    for (tmp = 1; days[tmp] < tmPtr->tm_yday; tmp++) {
+	/* empty body */
+    }
+    tmPtr->tm_mon = --tmp;
+    tmPtr->tm_mday = tmPtr->tm_yday - days[tmp];
+
+    /*
+     * Compute day of week.  Epoch started on a Thursday.
+     */
+
+    tmPtr->tm_wday = (long)(*tp / SECSPERDAY) + 4;
+    if ((*tp % SECSPERDAY) < 0) {
+	tmPtr->tm_wday--;
+    }
+    tmPtr->tm_wday %= 7;
+    if (tmPtr->tm_wday < 0) {
+	tmPtr->tm_wday += 7;
+    }
+
+    return tmPtr;
+}
+#endif /* TCL_NO_DEPRECATED */
+
+/*
+ *----------------------------------------------------------------------
+ *
  * CalibrationThread --
  *
  *	Thread that manages calibration of the hi-resolution time derived from
  *	the performance counter, to keep it synchronized with the system
  *	clock.
@@ -1067,10 +1327,73 @@
 
 	return estFreq;
     }
 }
 
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpGmtime --
+ *
+ *	Wrapper around the 'gmtime' library function to make it thread safe.
+ *
+ * Results:
+ *	Returns a pointer to a 'struct tm' in thread-specific data.
+ *
+ * Side effects:
+ *	Invokes gmtime or gmtime_r as appropriate.
+ *
+ *----------------------------------------------------------------------
+ */
+
+#ifndef TCL_NO_DEPRECATED
+struct tm *
+TclpGmtime(
+    const time_t *timePtr)	/* Pointer to the number of seconds since the
+				 * local system's epoch */
+{
+    /*
+     * The MS implementation of gmtime is thread safe because it returns the
+     * time in a block of thread-local storage, and Windows does not provide a
+     * Posix gmtime_r function.
+     */
+
+    return gmtime(timePtr);
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpLocaltime --
+ *
+ *	Wrapper around the 'localtime' library function to make it thread
+ *	safe.
+ *
+ * Results:
+ *	Returns a pointer to a 'struct tm' in thread-specific data.
+ *
+ * Side effects:
+ *	Invokes localtime or localtime_r as appropriate.
+ *
+ *----------------------------------------------------------------------
+ */
+
+struct tm *
+TclpLocaltime(
+    const time_t *timePtr)	/* Pointer to the number of seconds since the
+				 * local system's epoch */
+{
+    /*
+     * The MS implementation of localtime is thread safe because it returns
+     * the time in a block of thread-local storage, and Windows does not
+     * provide a Posix localtime_r function.
+     */
+
+    return localtime(timePtr);
+}
+#endif /* TCL_NO_DEPRECATED */
+
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_SetTimeProc --
  *