Change "IntRep" to "InternalRep", as discussed in the Tcl Core mailing list

Fix problem with application manifest, supporting UTF-8 console (it appears that mingw is stricter than msvc on this)
Rewrite comments for clarity and conciseness.
2021-10-06 19:33:03 +00:00 · 2021-10-06 14:00:44 +00:00 · 2021-10-04 21:09:02 +00:00 · 2021-09-30 08:03:06 +00:00 · 2021-09-30 07:49:10 +00:00 · 2021-09-29 13:46:51 +00:00
135 changed files with 3307 additions and 3028 deletions
@@ -42,6 +42,7 @@ jobs:
          if ($lastexitcode -ne 0) {
             throw "nmake exit code: $lastexitcode"
          }
+        env:
          CI_BUILD_WITH_MSVC: 1
  gcc:
    runs-on: windows-latest
@@ -9,7 +9,7 @@
 .so man.macros
 .BS
 .SH NAME
-Tcl_AsyncCreate, Tcl_AsyncMark, Tcl_AsyncInvoke, Tcl_AsyncDelete, Tcl_AsyncReady \- handle asynchronous events
+Tcl_AsyncCreate, Tcl_AsyncMark, Tcl_AsyncMarkFromSignal, Tcl_AsyncInvoke, Tcl_AsyncDelete, Tcl_AsyncReady \- handle asynchronous events
 .SH SYNOPSIS
 .nf
 \fB#include <tcl.h>\fR
@@ -17,11 +17,16 @@ Tcl_AsyncCreate, Tcl_AsyncMark, Tcl_AsyncInvoke, Tcl_AsyncDelete, Tcl_AsyncReady
 Tcl_AsyncHandler
 \fBTcl_AsyncCreate\fR(\fIproc, clientData\fR)
 .sp
+void
 \fBTcl_AsyncMark\fR(\fIasync\fR)
 .sp
 int
+\fBTcl_AsyncMarkFromSignal\fR(\fIasync\fR, \fIsigNumber\fR)
+.sp
+int
 \fBTcl_AsyncInvoke\fR(\fIinterp, code\fR)
 .sp
+void
 \fBTcl_AsyncDelete\fR(\fIasync\fR)
 .sp
 int
@@ -34,6 +39,8 @@ Procedure to invoke to handle an asynchronous event.
 One-word value to pass to \fIproc\fR.
 .AP Tcl_AsyncHandler async in
 Token for asynchronous event handler.
+.AP int sigNumber in
+POSIX signal number, when used in a signal context.
 .AP Tcl_Interp *interp in
 Tcl interpreter in which command was being evaluated when handler was
 invoked, or NULL if handler was invoked when there was no interpreter
@@ -60,10 +67,11 @@ to a clean state, such as after the current Tcl command completes.
 .PP
 \fBTcl_AsyncCreate\fR, \fBTcl_AsyncDelete\fR, and \fBTcl_AsyncReady\fR
 are thread sensitive.  They access and/or set a thread-specific data
-structure in the event of a core built with \fI\-\-enable\-threads\fR.  The token
-created by \fBTcl_AsyncCreate\fR contains the needed thread information it
-was called from so that calling \fBTcl_AsyncMark\fR(\fItoken\fR) will only yield
-the origin thread into the asynchronous handler.
+structure in the event of a core built with \fI\-\-enable\-threads\fR.
+The token created by \fBTcl_AsyncCreate\fR contains the needed thread
+information it was called from so that calling \fBTcl_AsyncMarkFromSignal\fR
+or \fBTcl_AsyncMark\fR with this token will only yield the origin
+thread into the asynchronous handler.
 .PP
 \fBTcl_AsyncCreate\fR creates an asynchronous handler and returns
 a token for it.
@@ -72,13 +80,16 @@ any occurrences of the asynchronous event that it is intended
 to handle (it is not safe to create a handler at the time of
 an event).
 When an asynchronous event occurs the code that detects the event
-(such as a signal handler) should call \fBTcl_AsyncMark\fR with the
-token for the handler.
-\fBTcl_AsyncMark\fR will mark the handler as ready to execute, but it
-will not invoke the handler immediately.
-Tcl will call the \fIproc\fR associated with the handler later, when
-the world is in a safe state, and \fIproc\fR can then carry out
-the actions associated with the asynchronous event.
+(such as a POSIX signal handler) should call \fBTcl_AsyncMarkFromSignal\fR
+with the token for the handler and the POSIX signal number. The
+return value of this function is true, when the handler will be
+marked, false otherwise.
+For non-signal contexts, \fBTcl_AsyncMark\fR serves the same purpose.
+\fBTcl_AsyncMarkFromSignal\fR and \fBTcl_AsyncMark\fR will mark
+the handler as ready to execute, but will not invoke the handler
+immediately. Tcl will call the \fIproc\fR associated with the
+handler later, when the world is in a safe state, and \fIproc\fR
+can then carry out the actions associated with the asynchronous event.
 \fIProc\fR should have arguments and result that match the
 type \fBTcl_AsyncProc\fR:
 .PP
@@ -55,6 +55,14 @@ Tcl_ObjectMapMethodNameProc
 \fBTcl_ObjectGetMethodNameMapper\fR(\fIobject\fR)
 .sp
 \fBTcl_ObjectSetMethodNameMapper\fR(\fIobject\fR, \fImethodNameMapper\fR)
+.sp
+.VS "TIP 605"
+Tcl_Class
+\fBTcl_GetClassOfObject\fR(\fIobject\fR)
+.sp
+Tcl_Obj *
+\fBTcl_GetObjectClassName\fR(\fIinterp\fR, \fIobject\fR)
+.VE "TIP 605"
 .SH ARGUMENTS
 .AS ClientData metadata in/out
 .AP Tcl_Interp *interp in/out
@@ -114,6 +122,13 @@ function. Note that the Tcl_Obj reference returned by \fBTcl_GetObjectName\fR
 is a shared reference. You can also get whether the object has been marked for
 deletion with \fBTcl_ObjectDeleted\fR (it returns true if deletion of the
 object has begun); this can be useful during the processing of methods.
+.VS "TIP 605"
+The class of an object can be retrieved with \fBTcl_GetClassOfObject\fR, and
+the name of the class of an object with \fBTcl_GetObjectClassName\fR; note
+that these two \fImay\fR return NULL during deletion of an object (this is
+transient, and only occurs when the object is a long way through being
+deleted).
+.VE "TIP 605"
 .PP
 Instances of classes are created using \fBTcl_NewObjectInstance\fR, which
 creates an object from any class (and which is internally called by both
@@ -735,7 +735,7 @@ To register to a callback, use:
 namespace eval gui {
    msgcat::mcpackageconfig changecmd updateGUI

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

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

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

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

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

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

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

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

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

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

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

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

@@ -2348,18 +2348,18 @@ declare 635 {

 # TIP #445
 declare 636 {
-    void Tcl_FreeIntRep(Tcl_Obj *objPtr)
+    void Tcl_FreeInternalRep(Tcl_Obj *objPtr)
 }
 declare 637 {
    char *Tcl_InitStringRep(Tcl_Obj *objPtr, const char *bytes,
 	    unsigned int numBytes)
 }
 declare 638 {
-    Tcl_ObjIntRep *Tcl_FetchIntRep(Tcl_Obj *objPtr, const Tcl_ObjType *typePtr)
+    Tcl_ObjInternalRep *Tcl_FetchInternalRep(Tcl_Obj *objPtr, const Tcl_ObjType *typePtr)
 }
 declare 639 {
-    void Tcl_StoreIntRep(Tcl_Obj *objPtr, const Tcl_ObjType *typePtr,
-	    const Tcl_ObjIntRep *irPtr)
+    void Tcl_StoreInternalRep(Tcl_Obj *objPtr, const Tcl_ObjType *typePtr,
+	    const Tcl_ObjInternalRep *irPtr)
 }
 declare 640 {
    int Tcl_HasStringRep(Tcl_Obj *objPtr)
@@ -2427,6 +2427,11 @@ declare 657 {
    int Tcl_UniCharIsUnicode(int ch)
 }

+# TIP #511
+declare 660 {
+    int Tcl_AsyncMarkFromSignal(Tcl_AsyncHandler async, int sigNumber)
+}
+
 # ----- BASELINE -- FOR -- 8.7.0 ----- #

 ##############################################################################
@@ -749,13 +749,13 @@ typedef struct Tcl_ObjType {
 } Tcl_ObjType;

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

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

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


@@ -865,7 +865,7 @@ CompileAssembleObj(
     * is valid in the current context.
     */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 	if (irPtr) {
 	    d2 = irPtr->doubleValue;
@@ -8017,7 +8017,7 @@ ExprDoubleFunc(
    }
    if (Tcl_GetDoubleFromObj(interp, objv[1], &dResult) != TCL_OK) {
 #ifdef ACCEPT_NAN
-	if (TclHasIntRep(objv[1], &tclDoubleType)) {
+	if (TclHasInternalRep(objv[1], &tclDoubleType)) {
 	    Tcl_SetObjResult(interp, objv[1]);
 	    return TCL_OK;
 	}
@@ -226,7 +226,7 @@ static const EnsembleImplMap decodeMap[] = {
 * implies a side testing burden -- past mistakes will not let us avoid that
 * immediately, but it is at least a conventional test of type, and can be
 * implemented entirely by examining the objPtr fields, with no need to query
- * the intrep, as a canonical flag would require.
+ * the internalrep, as a canonical flag would require.
 *
 * Until Tcl_GetByteArrayFromObj() and Tcl_SetByteArrayLength() can be revised
 * to admit the possibility of returning NULL when the true value is not a
@@ -289,7 +289,7 @@ int
 TclIsPureByteArray(
    Tcl_Obj * objPtr)
 {
-    return TclHasIntRep(objPtr, &properByteArrayType);
+    return TclHasInternalRep(objPtr, &properByteArrayType);
 }

 /*
@@ -414,7 +414,7 @@ Tcl_SetByteArrayObj(
 				 * be >= 0. */
 {
    ByteArray *byteArrayPtr;
-    Tcl_ObjIntRep ir;
+    Tcl_ObjInternalRep ir;

    if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetByteArrayObj");
@@ -434,7 +434,7 @@ Tcl_SetByteArrayObj(
    }
    SET_BYTEARRAY(&ir, byteArrayPtr);

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

 /*
@@ -462,17 +462,17 @@ TclGetBytesFromObj(
 				 * array of bytes in the ByteArray object. */
 {
    ByteArray *baPtr;
-    const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
+    const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);

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

-		irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
+		irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
 		baPtr = GET_BYTEARRAY(irPtr);
 		nonbyte = Tcl_UtfAtIndex(Tcl_GetString(objPtr), baPtr->bad);
 		TclUtfToUCS4(nonbyte, &ucs4);
@@ -519,14 +519,14 @@ Tcl_GetByteArrayFromObj(
 				 * array of bytes in the ByteArray object. */
 {
    ByteArray *baPtr;
-    const Tcl_ObjIntRep *irPtr;
+    const Tcl_ObjInternalRep *irPtr;
    unsigned char *result = TclGetBytesFromObj(NULL, objPtr, lengthPtr);

    if (result) {
 	return result;
    }

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

    baPtr = GET_BYTEARRAY(irPtr);
@@ -544,14 +544,14 @@ TclGetByteArrayFromObj(
 				 * array of bytes in the ByteArray object. */
 {
    ByteArray *baPtr;
-    const Tcl_ObjIntRep *irPtr;
+    const Tcl_ObjInternalRep *irPtr;
    unsigned char *result = TclGetBytesFromObj(NULL, objPtr, (int *)NULL);

    if (result) {
 	return result;
    }

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

    baPtr = GET_BYTEARRAY(irPtr);
@@ -595,7 +595,7 @@ Tcl_SetByteArrayLength(
 {
    ByteArray *byteArrayPtr;
    unsigned newLength;
-    Tcl_ObjIntRep *irPtr;
+    Tcl_ObjInternalRep *irPtr;

    assert(length >= 0);
    newLength = (unsigned int)length;
@@ -604,14 +604,14 @@ Tcl_SetByteArrayLength(
 	Tcl_Panic("%s called with shared object", "Tcl_SetByteArrayLength");
    }

-    irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
+    irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
    if (irPtr == NULL) {
-	irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
+	irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
 	if (irPtr == NULL) {
 	    SetByteArrayFromAny(NULL, objPtr);
-	    irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
+	    irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
 	    if (irPtr == NULL) {
-		irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
+		irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
 	    }
 	}
    }
@@ -655,12 +655,12 @@ SetByteArrayFromAny(
    unsigned char *dst;
    Tcl_UniChar ch = 0;
    ByteArray *byteArrayPtr;
-    Tcl_ObjIntRep ir;
+    Tcl_ObjInternalRep ir;

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

@@ -683,10 +683,10 @@ SetByteArrayFromAny(

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

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

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

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

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

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

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

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

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

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

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

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

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

    length = (unsigned int) len;

-    irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
+    irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
    if (irPtr == NULL) {
-	irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
+	irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
 	if (irPtr == NULL) {
 	    SetByteArrayFromAny(NULL, objPtr);
-	    irPtr = TclFetchIntRep(objPtr, &properByteArrayType);
+	    irPtr = TclFetchInternalRep(objPtr, &properByteArrayType);
 	    if (irPtr == NULL) {
-		irPtr = TclFetchIntRep(objPtr, &tclByteArrayType);
+		irPtr = TclFetchInternalRep(objPtr, &tclByteArrayType);
 	    }
 	}
    }
@@ -2158,7 +2158,7 @@ FormatNumber(
 	 */

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

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

 	    if (irPtr == NULL) {
 		return TCL_ERROR;
@@ -381,7 +381,7 @@ Tcl_DumpActiveMemory(
 * Tcl_DbCkalloc - debugging ckalloc
 *
 *	Allocate the requested amount of space plus some extra for guard bands
- *	at both ends of the request, plus a size, panicing if there isn't
+ *	at both ends of the request, plus a size, panicking if there isn't
 *	enough space, then write in the guard bands and return the address of
 *	the space in the middle that the user asked for.
 *
@@ -452,7 +452,7 @@ ClockGetdatefieldsObjCmd(
     * that it isn't.
     */

-    if (TclHasIntRep(objv[1], &tclBignumType)) {
+    if (TclHasInternalRep(objv[1], &tclBignumType)) {
 	Tcl_SetObjResult(interp, lit[LIT_INTEGER_VALUE_TOO_LARGE]);
 	return TCL_ERROR;
    }
@@ -1611,7 +1611,7 @@ StringIsCmd(
    case STR_IS_BOOL:
    case STR_IS_TRUE:
    case STR_IS_FALSE:
-	if (!TclHasIntRep(objPtr, &tclBooleanType)
+	if (!TclHasInternalRep(objPtr, &tclBooleanType)
 		&& (TCL_OK != TclSetBooleanFromAny(NULL, objPtr))) {
 	    if (strict) {
 		result = 0;
@@ -1681,9 +1681,9 @@ StringIsCmd(
 	chcomp = Tcl_UniCharIsDigit;
 	break;
    case STR_IS_DOUBLE: {
-	if (TclHasIntRep(objPtr, &tclDoubleType) ||
-		TclHasIntRep(objPtr, &tclIntType) ||
-		TclHasIntRep(objPtr, &tclBignumType)) {
+	if (TclHasInternalRep(objPtr, &tclDoubleType) ||
+		TclHasInternalRep(objPtr, &tclIntType) ||
+		TclHasInternalRep(objPtr, &tclBignumType)) {
 	    break;
 	}
 	string1 = TclGetStringFromObj(objPtr, &length1);
@@ -1702,7 +1702,7 @@ StringIsCmd(
 	    failat = stop - string1;
 	    if (stop < end) {
 		result = 0;
-		TclFreeIntRep(objPtr);
+		TclFreeInternalRep(objPtr);
 	    }
 	}
 	break;
@@ -1712,8 +1712,8 @@ StringIsCmd(
 	break;
    case STR_IS_INT:
    case STR_IS_ENTIER:
-	if (TclHasIntRep(objPtr, &tclIntType) ||
-		TclHasIntRep(objPtr, &tclBignumType)) {
+	if (TclHasInternalRep(objPtr, &tclIntType) ||
+		TclHasInternalRep(objPtr, &tclBignumType)) {
 	    break;
 	}
 	string1 = TclGetStringFromObj(objPtr, &length1);
@@ -1742,7 +1742,7 @@ StringIsCmd(

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

 		failat = stop - string1;
-		TclFreeIntRep(objPtr);
+		TclFreeInternalRep(objPtr);
 	    }
 	} else {
 	    /*
@@ -1990,7 +1990,7 @@ StringMapCmd(
     */

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

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

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

@@ -2109,7 +2109,7 @@ ParseLexeme(
 	     * Example: Inf + luence + () becomes a valid function call.
 	     * [Bug 3401704]
 	     */
-	    if (TclHasIntRep(literal, &tclDoubleType)) {
+	    if (TclHasInternalRep(literal, &tclDoubleType)) {
 		const char *p = start;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -515,20 +515,20 @@ typedef struct ByteCode {
 #endif /* TCL_COMPILE_STATS */
 } ByteCode;

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



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

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

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

 #define TclFetchAuxData(envPtr, index) \
@@ -1557,9 +1557,9 @@ MODULE_SCOPE int	TclPushProcCallFrame(ClientData clientData,
 */

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

 /*
 * Macro to advance to the next token; it is more mnemonic than the address
@@ -1886,17 +1886,17 @@ EXTERN int		TclZipfs_MountBuffer(Tcl_Interp *interp,
 				const char *mountPoint, unsigned char *data,
 				size_t datalen, int copy);
 /* 636 */
-EXTERN void		Tcl_FreeIntRep(Tcl_Obj *objPtr);
+EXTERN void		Tcl_FreeInternalRep(Tcl_Obj *objPtr);
 /* 637 */
 EXTERN char *		Tcl_InitStringRep(Tcl_Obj *objPtr, const char *bytes,
 				unsigned int numBytes);
 /* 638 */
-EXTERN Tcl_ObjIntRep *	Tcl_FetchIntRep(Tcl_Obj *objPtr,
+EXTERN Tcl_ObjInternalRep * Tcl_FetchInternalRep(Tcl_Obj *objPtr,
 				const Tcl_ObjType *typePtr);
 /* 639 */
-EXTERN void		Tcl_StoreIntRep(Tcl_Obj *objPtr,
+EXTERN void		Tcl_StoreInternalRep(Tcl_Obj *objPtr,
 				const Tcl_ObjType *typePtr,
-				const Tcl_ObjIntRep *irPtr);
+				const Tcl_ObjInternalRep *irPtr);
 /* 640 */
 EXTERN int		Tcl_HasStringRep(Tcl_Obj *objPtr);
 /* 641 */
@@ -1939,6 +1939,11 @@ EXTERN const char *	Tcl_UtfNext(const char *src);
 EXTERN const char *	Tcl_UtfPrev(const char *src, const char *start);
 /* 657 */
 EXTERN int		Tcl_UniCharIsUnicode(int ch);
+/* Slot 658 is reserved */
+/* Slot 659 is reserved */
+/* 660 */
+EXTERN int		Tcl_AsyncMarkFromSignal(Tcl_AsyncHandler async,
+				int sigNumber);

 typedef struct {
    const struct TclPlatStubs *tclPlatStubs;
@@ -2610,10 +2615,10 @@ typedef struct TclStubs {
    int (*tclZipfs_Unmount) (Tcl_Interp *interp, const char *mountPoint); /* 633 */
    Tcl_Obj * (*tclZipfs_TclLibrary) (void); /* 634 */
    int (*tclZipfs_MountBuffer) (Tcl_Interp *interp, const char *mountPoint, unsigned char *data, size_t datalen, int copy); /* 635 */
-    void (*tcl_FreeIntRep) (Tcl_Obj *objPtr); /* 636 */
+    void (*tcl_FreeInternalRep) (Tcl_Obj *objPtr); /* 636 */
    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 */
+    Tcl_ObjInternalRep * (*tcl_FetchInternalRep) (Tcl_Obj *objPtr, const Tcl_ObjType *typePtr); /* 638 */
+    void (*tcl_StoreInternalRep) (Tcl_Obj *objPtr, const Tcl_ObjType *typePtr, const Tcl_ObjInternalRep *irPtr); /* 639 */
    int (*tcl_HasStringRep) (Tcl_Obj *objPtr); /* 640 */
    void (*tcl_IncrRefCount) (Tcl_Obj *objPtr); /* 641 */
    void (*tcl_DecrRefCount) (Tcl_Obj *objPtr); /* 642 */
@@ -2632,6 +2637,9 @@ typedef struct TclStubs {
    const char * (*tcl_UtfNext) (const char *src); /* 655 */
    const char * (*tcl_UtfPrev) (const char *src, const char *start); /* 656 */
    int (*tcl_UniCharIsUnicode) (int ch); /* 657 */
+    void (*reserved658)(void);
+    void (*reserved659)(void);
+    int (*tcl_AsyncMarkFromSignal) (Tcl_AsyncHandler async, int sigNumber); /* 660 */
 } TclStubs;

 extern const TclStubs *tclStubsPtr;
@@ -3934,14 +3942,14 @@ extern const TclStubs *tclStubsPtr;
 	(tclStubsPtr->tclZipfs_TclLibrary) /* 634 */
 #define TclZipfs_MountBuffer \
 	(tclStubsPtr->tclZipfs_MountBuffer) /* 635 */
-#define Tcl_FreeIntRep \
-	(tclStubsPtr->tcl_FreeIntRep) /* 636 */
+#define Tcl_FreeInternalRep \
+	(tclStubsPtr->tcl_FreeInternalRep) /* 636 */
 #define Tcl_InitStringRep \
 	(tclStubsPtr->tcl_InitStringRep) /* 637 */
-#define Tcl_FetchIntRep \
-	(tclStubsPtr->tcl_FetchIntRep) /* 638 */
-#define Tcl_StoreIntRep \
-	(tclStubsPtr->tcl_StoreIntRep) /* 639 */
+#define Tcl_FetchInternalRep \
+	(tclStubsPtr->tcl_FetchInternalRep) /* 638 */
+#define Tcl_StoreInternalRep \
+	(tclStubsPtr->tcl_StoreInternalRep) /* 639 */
 #define Tcl_HasStringRep \
 	(tclStubsPtr->tcl_HasStringRep) /* 640 */
 #define Tcl_IncrRefCount \
@@ -3976,6 +3984,10 @@ extern const TclStubs *tclStubsPtr;
 	(tclStubsPtr->tcl_UtfPrev) /* 656 */
 #define Tcl_UniCharIsUnicode \
 	(tclStubsPtr->tcl_UniCharIsUnicode) /* 657 */
+/* Slot 658 is reserved */
+/* Slot 659 is reserved */
+#define Tcl_AsyncMarkFromSignal \
+	(tclStubsPtr->tcl_AsyncMarkFromSignal) /* 660 */

 #endif /* defined(USE_TCL_STUBS) */

@@ -149,18 +149,18 @@ const Tcl_ObjType tclDictType = {
    SetDictFromAny			/* setFromAnyProc */
 };

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

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

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

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

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

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

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

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

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

    int numElems;

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

    assert (dict != NULL);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    if (codePtr->flags & TCL_BYTECODE_PRECOMPILED) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
@@ -196,13 +196,13 @@ static unsigned short emptyPage[256];
 */

 static Tcl_EncodingConvertProc	BinaryProc;
-static Tcl_DupInternalRepProc	DupEncodingIntRep;
+static Tcl_DupInternalRepProc	DupEncodingInternalRep;
 static Tcl_EncodingFreeProc	EscapeFreeProc;
 static Tcl_EncodingConvertProc	EscapeFromUtfProc;
 static Tcl_EncodingConvertProc	EscapeToUtfProc;
 static void			FillEncodingFileMap(void);
 static void			FreeEncoding(Tcl_Encoding encoding);
-static Tcl_FreeInternalRepProc	FreeEncodingIntRep;
+static Tcl_FreeInternalRepProc	FreeEncodingInternalRep;
 static Encoding *		GetTableEncoding(EscapeEncodingData *dataPtr,
 				    int state);
 static Tcl_Encoding		LoadEncodingFile(Tcl_Interp *interp,
@@ -226,25 +226,25 @@ static Tcl_EncodingConvertProc	Iso88591ToUtfProc;

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

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

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

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

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

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

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

 /*
 *----------------------------------------------------------------------
 *
- * DupEncodingIntRep --
+ * DupEncodingInternalRep --
 *
 *	The Tcl_DupInternalRepProc for the "encoding" Tcl_ObjType.
 *
@@ -320,12 +320,12 @@ FreeEncodingIntRep(
 */

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

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

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

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

@@ -1759,7 +1759,7 @@ NsEnsembleImplementationCmdNR(
 	 */
 	EnsembleCmdRep *ensembleCmd;

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

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

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

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

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

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

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

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

    ensembleCopy->epoch = ensembleCmd->epoch;
    ensembleCopy->token = ensembleCmd->token;
@@ -1618,6 +1618,12 @@ Tcl_CreateThread(
    }
    return result;
 #else
+    (void)idPtr;
+    (void)proc;
+    (void)clientData;
+    (void)stackSize;
+    (void)flags;
+
    return TCL_ERROR;
 #endif /* TCL_THREADS */
 }
@@ -509,11 +509,11 @@ VarHashCreateVar(
 */

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

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

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

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

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

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

-    ByteCodeGetIntRep(objPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetInternalRep(objPtr, &tclByteCodeType, codePtr);
    if (codePtr != NULL) {
 	/*
 	 * Make sure the Bytecode hasn't been invalidated by, e.g., someone
@@ -1775,7 +1775,7 @@ TclCompileObj(
    iPtr->invokeWord = word;
    TclSetByteCodeFromAny(interp, objPtr, NULL, NULL);
    iPtr->invokeCmdFramePtr = NULL;
-    ByteCodeGetIntRep(objPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetInternalRep(objPtr, &tclByteCodeType, codePtr);
    if (iPtr->varFramePtr->localCachePtr) {
 	codePtr->localCachePtr = iPtr->varFramePtr->localCachePtr;
 	codePtr->localCachePtr->refCount++;
@@ -4864,7 +4864,7 @@ TEBCresume(
 	 */

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

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

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

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

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

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

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

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

 	    if (statePtr &&
-		    (irPtr = TclFetchIntRep(statePtr, &dictIteratorType))) {
+		    (irPtr = TclFetchInternalRep(statePtr, &dictIteratorType))) {
 		searchPtr = (Tcl_DictSearch *)irPtr->twoPtrValue.ptr1;
 		Tcl_DictObjNext(searchPtr, &keyPtr, &valuePtr, &done);
 	    } else {
@@ -9852,7 +9852,7 @@ EvalStatsCmd(
    for (i = 0;  i < globalTablePtr->numBuckets;  i++) {
 	for (entryPtr = globalTablePtr->buckets[i];  entryPtr != NULL;
 		entryPtr = entryPtr->nextPtr) {
-	    if (TclHasIntRep(entryPtr->objPtr, &tclByteCodeType)) {
+	    if (TclHasInternalRep(entryPtr->objPtr, &tclByteCodeType)) {
 		numByteCodeLits++;
 	    }
 	    (void) TclGetStringFromObj(entryPtr->objPtr, &length);
@@ -53,7 +53,7 @@ Tcl_GetInt(
    if (obj.refCount > 1) {
 	Tcl_Panic("invalid sharing of Tcl_Obj on C stack");
    }
-    TclFreeIntRep(&obj);
+    TclFreeInternalRep(&obj);
    return code;
 }

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

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

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

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

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

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

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

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

    if (chan == NULL) {
 	if (resPtr) {
-	    Tcl_StoreIntRep(objPtr, &chanObjType, NULL);
+	    Tcl_StoreInternalRep(objPtr, &chanObjType, NULL);
 	}
 	return TCL_ERROR;
    }
@@ -1560,7 +1560,7 @@ TclGetChannelFromObj(
    } else {
 	resPtr = (ResolvedChanName *) ckalloc(sizeof(ResolvedChanName));
 	resPtr->refCount = 0;
-	ChanSetIntRep(objPtr, resPtr);		/* Overwrites, if needed */
+	ChanSetInternalRep(objPtr, resPtr);		/* Overwrites, if needed */
    }
    statePtr = ((Channel *)chan)->state;
    resPtr->statePtr = statePtr;
@@ -11274,7 +11274,7 @@ Tcl_ChannelTruncateProc(
 /*
 *----------------------------------------------------------------------
 *
- * DupChannelIntRep --
+ * DupChannelInternalRep --
 *
 *	Initialize the internal representation of a new Tcl_Obj to a copy of
 *	the internal representation of an existing string object.
@@ -11290,7 +11290,7 @@ Tcl_ChannelTruncateProc(
 */

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

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

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

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

-    ChanGetIntRep(objPtr, resPtr);
+    ChanGetInternalRep(objPtr, resPtr);
    assert(resPtr);
    if (resPtr->refCount-- > 1) {
 	return;
@@ -2766,6 +2766,8 @@ DeleteReflectedChannelMap(
 	MarkDead(rcPtr);
 	Tcl_DeleteHashEntry(hPtr);
    }
+#else
+    (void)interp;
 #endif
 }

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

    /*
@@ -122,7 +122,7 @@ Tcl_GetIndexFromObj(
     * the common case where the result is cached).
     */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-    if (!TclHasIntRep(value, &indexType)
+    if (!TclHasInternalRep(value, &indexType)
 	    && TclGetIntFromObj(NULL, value, codePtr) == TCL_OK) {
 	return TCL_OK;
    }
@@ -2926,6 +2926,9 @@ 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 int	TclAsyncNotifier(int sigNumber, Tcl_ThreadId threadId,
+			    ClientData clientData, int *flagPtr, int value);
+MODULE_SCOPE void	TclAsyncMarkFromNotifier(void);
 MODULE_SCOPE double	TclBignumToDouble(const void *bignum);
 MODULE_SCOPE int	TclByteArrayMatch(const unsigned char *string,
 			    int strLen, const unsigned char *pattern,
@@ -2990,6 +2993,7 @@ MODULE_SCOPE char *	TclDStringAppendDString(Tcl_DString *dsPtr,
 MODULE_SCOPE Tcl_Obj *	TclDStringToObj(Tcl_DString *dsPtr);
 MODULE_SCOPE Tcl_Obj *const *TclFetchEnsembleRoot(Tcl_Interp *interp,
 			    Tcl_Obj *const *objv, int objc, int *objcPtr);
+MODULE_SCOPE Tcl_Obj *const *TclEnsembleGetRewriteValues(Tcl_Interp *interp);
 MODULE_SCOPE Tcl_Namespace *TclEnsureNamespace(Tcl_Interp *interp,
 			    Tcl_Namespace *namespacePtr);
 MODULE_SCOPE void	TclFinalizeAllocSubsystem(void);
@@ -3141,6 +3145,7 @@ MODULE_SCOPE Tcl_Obj *  TclpTempFileNameForLibrary(Tcl_Interp *interp,
 MODULE_SCOPE Tcl_Obj *	TclNewFSPathObj(Tcl_Obj *dirPtr, const char *addStrRep,
 			    int len);
 MODULE_SCOPE void	TclpAlertNotifier(ClientData clientData);
+MODULE_SCOPE ClientData	TclpNotifierData(void);
 MODULE_SCOPE void	TclpServiceModeHook(int mode);
 MODULE_SCOPE void	TclpSetTimer(const Tcl_Time *timePtr);
 MODULE_SCOPE int	TclpWaitForEvent(const Tcl_Time *timePtr);
@@ -3214,7 +3219,7 @@ 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,
+MODULE_SCOPE void	TclSetBignumInternalRep(Tcl_Obj *objPtr,
 			    void *bignumValue);
 MODULE_SCOPE int	TclSetBooleanFromAny(Tcl_Interp *interp,
 			    Tcl_Obj *objPtr);
@@ -4531,11 +4536,11 @@ MODULE_SCOPE void	TclDbInitNewObj(Tcl_Obj *objPtr, const char *file,
 * representation. Does not actually reset the rep's bytes. The ANSI C
 * "prototype" for this macro is:
 *
- * MODULE_SCOPE void	TclFreeIntRep(Tcl_Obj *objPtr);
+ * MODULE_SCOPE void	TclFreeInternalRep(Tcl_Obj *objPtr);
 *----------------------------------------------------------------
 */

-#define TclFreeIntRep(objPtr) \
+#define TclFreeInternalRep(objPtr) \
    if ((objPtr)->typePtr != NULL) { \
 	if ((objPtr)->typePtr->freeIntRepProc != NULL) { \
 	    (objPtr)->typePtr->freeIntRepProc(objPtr); \
@@ -4543,6 +4548,10 @@ MODULE_SCOPE void	TclDbInitNewObj(Tcl_Obj *objPtr, const char *file,
 	(objPtr)->typePtr = NULL; \
    }

+#if !defined(TCL_NO_DEPRECATED) && TCL_MAJOR_VERSION < 8
+#   define TclFreeIntRep(objPtr) TclFreeInternalRep(objPtr)
+#endif
+
 /*
 *----------------------------------------------------------------
 * Macro used by the Tcl core to clean out an object's string representation.
@@ -4753,10 +4762,10 @@ MODULE_SCOPE const TclFileAttrProcs	tclpFileAttrProcs[];
 MODULE_SCOPE int	TclIsPureByteArray(Tcl_Obj *objPtr);
 #define TclIsPureDict(objPtr) \
 	(((objPtr)->bytes==NULL) && ((objPtr)->typePtr==&tclDictType))
-#define TclHasIntRep(objPtr, type) \
+#define TclHasInternalRep(objPtr, type) \
 	((objPtr)->typePtr == (type))
-#define TclFetchIntRep(objPtr, type) \
-	(TclHasIntRep((objPtr), (type)) ? &((objPtr)->internalRep) : NULL)
+#define TclFetchInternalRep(objPtr, type) \
+	(TclHasInternalRep((objPtr), (type)) ? &((objPtr)->internalRep) : NULL)


 /*
@@ -4846,18 +4855,18 @@ MODULE_SCOPE Tcl_LibraryInitProc Procbodytest_SafeInit;

 #define TclSetIntObj(objPtr, i) \
    do {						\
-	Tcl_ObjIntRep ir;				\
+	Tcl_ObjInternalRep ir;				\
 	ir.wideValue = (Tcl_WideInt) i;			\
 	TclInvalidateStringRep(objPtr);			\
-	Tcl_StoreIntRep(objPtr, &tclIntType, &ir);	\
+	Tcl_StoreInternalRep(objPtr, &tclIntType, &ir);	\
    } while (0)

 #define TclSetDoubleObj(objPtr, d) \
    do {						\
-	Tcl_ObjIntRep ir;				\
+	Tcl_ObjInternalRep ir;				\
 	ir.doubleValue = (double) d;			\
 	TclInvalidateStringRep(objPtr);			\
-	Tcl_StoreIntRep(objPtr, &tclDoubleType, &ir);	\
+	Tcl_StoreInternalRep(objPtr, &tclDoubleType, &ir);	\
    } while (0)

 /*
@@ -5205,8 +5214,7 @@ typedef struct NRE_callback {

 #ifdef MAC_OSX_TCL
 #define TCL_MAC_EMPTY_FILE(name) \
-    static __attribute__((used)) const void *const TclUnusedFile_ ## name; \
-    static const void *const TclUnusedFile_ ## name = NULL;
+    static __attribute__((used)) const void *const TclUnusedFile_ ## name = NULL;
 #else
 #define TCL_MAC_EMPTY_FILE(name)
 #endif /* MAC_OSX_TCL */
@@ -588,7 +588,7 @@ GetDouble(
 	return 0;
    } else {
 #ifdef ACCEPT_NAN
-	Tcl_ObjIntRep *irPtr = TclFetchIntRep(objPtr, &tclDoubleType);
+	Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objPtr, &tclDoubleType);

 	if (irPtr != NULL) {
 	    *dblPtr = irPtr->doubleValue;
@@ -656,7 +656,7 @@ SetInvalidRealFromAny(
 		double doubleValue = 0.0;

 		Tcl_GetDoubleFromObj(NULL, objPtr, &doubleValue);
-		TclFreeIntRep(objPtr);
+		TclFreeInternalRep(objPtr);
 		objPtr->typePtr = &invalidRealType;
 		objPtr->internalRep.doubleValue = doubleValue;
 		return TCL_OK;
@@ -705,7 +705,7 @@ GetInvalidDoubleFromObj(
 {
    int intValue;

-    if (TclHasIntRep(objPtr, &invalidRealType)) {
+    if (TclHasInternalRep(objPtr, &invalidRealType)) {
 	goto gotdouble;
    }
    if (GetInvalidIntFromObj(objPtr, &intValue) == TCL_OK) {
@@ -20,7 +20,7 @@

 static List *		AttemptNewList(Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
-static List *		NewListIntRep(int objc, Tcl_Obj *const objv[], int p);
+static List *		NewListInternalRep(int objc, Tcl_Obj *const objv[], int p);
 static void		DupListInternalRep(Tcl_Obj *srcPtr, Tcl_Obj *copyPtr);
 static void		FreeListInternalRep(Tcl_Obj *listPtr);
 static int		SetListFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr);
@@ -49,24 +49,24 @@ const Tcl_ObjType tclListType = {

 /* Macros to manipulate the List internal rep */

-#define ListSetIntRep(objPtr, listRepPtr)				\
+#define ListSetInternalRep(objPtr, listRepPtr)				\
    do {								\
-	Tcl_ObjIntRep ir;						\
+	Tcl_ObjInternalRep ir;						\
 	ir.twoPtrValue.ptr1 = (listRepPtr);				\
 	ir.twoPtrValue.ptr2 = NULL;					\
 	(listRepPtr)->refCount++;					\
-	Tcl_StoreIntRep((objPtr), &tclListType, &ir);			\
+	Tcl_StoreInternalRep((objPtr), &tclListType, &ir);			\
    } while (0)

-#define ListGetIntRep(objPtr, listRepPtr)				\
+#define ListGetInternalRep(objPtr, listRepPtr)				\
    do {								\
-	const Tcl_ObjIntRep *irPtr;					\
-	irPtr = TclFetchIntRep((objPtr), &tclListType);		\
+	const Tcl_ObjInternalRep *irPtr;					\
+	irPtr = TclFetchInternalRep((objPtr), &tclListType);		\
 	(listRepPtr) = irPtr ? (List *)irPtr->twoPtrValue.ptr1 : NULL;		\
    } while (0)

-#define ListResetIntRep(objPtr, listRepPtr) \
-    TclFetchIntRep((objPtr), &tclListType)->twoPtrValue.ptr1 = (listRepPtr)
+#define ListResetInternalRep(objPtr, listRepPtr) \
+    TclFetchInternalRep((objPtr), &tclListType)->twoPtrValue.ptr1 = (listRepPtr)

 #ifndef TCL_MIN_ELEMENT_GROWTH
 #define TCL_MIN_ELEMENT_GROWTH TCL_MIN_GROWTH/sizeof(Tcl_Obj *)
@@ -75,7 +75,7 @@ const Tcl_ObjType tclListType = {
 /*
 *----------------------------------------------------------------------
 *
- * NewListIntRep --
+ * NewListInternalRep --
 *
 *	Creates a list internal rep with space for objc elements.  objc
 *	must be > 0.  If objv!=NULL, initializes with the first objc values
@@ -96,7 +96,7 @@ const Tcl_ObjType tclListType = {
 */

 static List *
-NewListIntRep(
+NewListInternalRep(
    int objc,
    Tcl_Obj *const objv[],
    int p)
@@ -104,7 +104,7 @@ NewListIntRep(
    List *listRepPtr;

    if (objc <= 0) {
-	Tcl_Panic("NewListIntRep: expects postive element count");
+	Tcl_Panic("NewListInternalRep: expects postive element count");
    }

    /*
@@ -179,7 +179,7 @@ AttemptNewList(
    int objc,
    Tcl_Obj *const objv[])
 {
-    List *listRepPtr = NewListIntRep(objc, objv, 0);
+    List *listRepPtr = NewListInternalRep(objc, objv, 0);

    if (interp != NULL && listRepPtr == NULL) {
 	if (objc > LIST_MAX) {
@@ -253,14 +253,14 @@ Tcl_NewListObj(
     * Create the internal rep.
     */

-    listRepPtr = NewListIntRep(objc, objv, 1);
+    listRepPtr = NewListInternalRep(objc, objv, 1);

    /*
     * Now create the object.
     */

    TclInvalidateStringRep(listPtr);
-    ListSetIntRep(listPtr, listRepPtr);
+    ListSetInternalRep(listPtr, listRepPtr);
    return listPtr;
 }
 #endif /* if TCL_MEM_DEBUG */
@@ -318,14 +318,14 @@ Tcl_DbNewListObj(
     * Create the internal rep.
     */

-    listRepPtr = NewListIntRep(objc, objv, 1);
+    listRepPtr = NewListInternalRep(objc, objv, 1);

    /*
     * Now create the object.
     */

    TclInvalidateStringRep(listPtr);
-    ListSetIntRep(listPtr, listRepPtr);
+    ListSetInternalRep(listPtr, listRepPtr);

    return listPtr;
 }
@@ -381,7 +381,7 @@ Tcl_SetListObj(
     * Free any old string rep and any internal rep for the old type.
     */

-    TclFreeIntRep(objPtr);
+    TclFreeInternalRep(objPtr);
    TclInvalidateStringRep(objPtr);

    /*
@@ -391,8 +391,8 @@ Tcl_SetListObj(
     */

    if (objc > 0) {
-	listRepPtr = NewListIntRep(objc, objv, 1);
-	ListSetIntRep(objPtr, listRepPtr);
+	listRepPtr = NewListInternalRep(objc, objv, 1);
+	ListSetInternalRep(objPtr, listRepPtr);
    } else {
 	Tcl_InitStringRep(objPtr, NULL, 0);
    }
@@ -428,7 +428,7 @@ TclListObjCopy(
    Tcl_Obj *copyPtr;
    List *listRepPtr;

-    ListGetIntRep(listPtr, listRepPtr);
+    ListGetInternalRep(listPtr, listRepPtr);
    if (NULL == listRepPtr) {
 	if (SetListFromAny(interp, listPtr) != TCL_OK) {
 	    return NULL;
@@ -566,7 +566,7 @@ Tcl_ListObjGetElements(
 {
    List *listRepPtr;

-    ListGetIntRep(listPtr, listRepPtr);
+    ListGetInternalRep(listPtr, listRepPtr);

    if (listRepPtr == NULL) {
 	int result, length;
@@ -581,7 +581,7 @@ Tcl_ListObjGetElements(
 	if (result != TCL_OK) {
 	    return result;
 	}
-	ListGetIntRep(listPtr, listRepPtr);
+	ListGetInternalRep(listPtr, listRepPtr);
    }
    *objcPtr = listRepPtr->elemCount;
    *objvPtr = &listRepPtr->elements;
@@ -680,7 +680,7 @@ Tcl_ListObjAppendElement(
 	Tcl_Panic("%s called with shared object", "Tcl_ListObjAppendElement");
    }

-    ListGetIntRep(listPtr, listRepPtr);
+    ListGetInternalRep(listPtr, listRepPtr);
    if (listRepPtr == NULL) {
 	int result, length;

@@ -693,7 +693,7 @@ Tcl_ListObjAppendElement(
 	if (result != TCL_OK) {
 	    return result;
 	}
-	ListGetIntRep(listPtr, listRepPtr);
+	ListGetInternalRep(listPtr, listRepPtr);
    }

    numElems = listRepPtr->elemCount;
@@ -713,7 +713,7 @@ Tcl_ListObjAppendElement(

    if (needGrow && !isShared) {
 	/*
-	 * Need to grow + unshared intrep => try to realloc
+	 * Need to grow + unshared internalrep => try to realloc
 	 */

 	attempt = 2 * numRequired;
@@ -741,8 +741,8 @@ Tcl_ListObjAppendElement(
 	Tcl_Obj **dst, **src = &listRepPtr->elements;

 	/*
-	 * Either we have a shared intrep and we must copy to write, or we
-	 * need to grow and realloc attempts failed.  Attempt intrep copy.
+	 * Either we have a shared internalrep and we must copy to write, or we
+	 * need to grow and realloc attempts failed.  Attempt internalrep copy.
 	 */

 	attempt = 2 * numRequired;
@@ -773,7 +773,7 @@ Tcl_ListObjAppendElement(

 	if (isShared) {
 	    /*
-	     * The original intrep must remain undisturbed.  Copy into the new
+	     * The original internalrep must remain undisturbed.  Copy into the new
 	     * one and bump refcounts
 	     */
 	    while (numElems--) {
@@ -783,7 +783,7 @@ Tcl_ListObjAppendElement(
 	    listRepPtr->refCount--;
 	} else {
 	    /*
-	     * Old intrep to be freed, re-use refCounts.
+	     * Old internalrep to be freed, re-use refCounts.
 	     */

 	    memcpy(dst, src, numElems * sizeof(Tcl_Obj *));
@@ -791,10 +791,10 @@ Tcl_ListObjAppendElement(
 	}
 	listRepPtr = newPtr;
    }
-    ListResetIntRep(listPtr, listRepPtr);
+    ListResetInternalRep(listPtr, listRepPtr);
    listRepPtr->refCount++;
-    TclFreeIntRep(listPtr);
-    ListSetIntRep(listPtr, listRepPtr);
+    TclFreeInternalRep(listPtr);
+    ListSetInternalRep(listPtr, listRepPtr);
    listRepPtr->refCount--;

    /*
@@ -850,7 +850,7 @@ Tcl_ListObjIndex(
 {
    List *listRepPtr;

-    ListGetIntRep(listPtr, listRepPtr);
+    ListGetInternalRep(listPtr, listRepPtr);
    if (listRepPtr == NULL) {
 	int result, length;

@@ -863,7 +863,7 @@ Tcl_ListObjIndex(
 	if (result != TCL_OK) {
 	    return result;
 	}
-	ListGetIntRep(listPtr, listRepPtr);
+	ListGetInternalRep(listPtr, listRepPtr);
    }

    if ((index < 0) || (index >= listRepPtr->elemCount)) {
@@ -905,7 +905,7 @@ Tcl_ListObjLength(
 {
    List *listRepPtr;

-    ListGetIntRep(listPtr, listRepPtr);
+    ListGetInternalRep(listPtr, listRepPtr);
    if (listRepPtr == NULL) {
 	int result, length;

@@ -918,7 +918,7 @@ Tcl_ListObjLength(
 	if (result != TCL_OK) {
 	    return result;
 	}
-	ListGetIntRep(listPtr, listRepPtr);
+	ListGetInternalRep(listPtr, listRepPtr);
    }

    *intPtr = listRepPtr->elemCount;
@@ -981,7 +981,7 @@ Tcl_ListObjReplace(
 	Tcl_Panic("%s called with shared object", "Tcl_ListObjReplace");
    }

-    ListGetIntRep(listPtr, listRepPtr);
+    ListGetInternalRep(listPtr, listRepPtr);
    if (listRepPtr == NULL) {
 	int length;

@@ -998,7 +998,7 @@ Tcl_ListObjReplace(
 		return result;
 	    }
 	}
-	ListGetIntRep(listPtr, listRepPtr);
+	ListGetInternalRep(listPtr, listRepPtr);
    }

    /*
@@ -1062,7 +1062,7 @@ Tcl_ListObjReplace(
 	}
 	if (newPtr) {
 	    listRepPtr = newPtr;
-	    ListResetIntRep(listPtr, listRepPtr);
+	    ListResetInternalRep(listPtr, listRepPtr);
 	    elemPtrs = &listRepPtr->elements;
 	    listRepPtr->maxElemCount = attempt;
 	    needGrow = numRequired > listRepPtr->maxElemCount;
@@ -1135,7 +1135,7 @@ Tcl_ListObjReplace(
 	    }
 	}

-	ListResetIntRep(listPtr, listRepPtr);
+	ListResetInternalRep(listPtr, listRepPtr);
 	listRepPtr->refCount++;

 	elemPtrs = &listRepPtr->elements;
@@ -1213,8 +1213,8 @@ Tcl_ListObjReplace(
     */

    listRepPtr->refCount++;
-    TclFreeIntRep(listPtr);
-    ListSetIntRep(listPtr, listRepPtr);
+    TclFreeInternalRep(listPtr);
+    ListSetInternalRep(listPtr, listRepPtr);
    listRepPtr->refCount--;

    TclInvalidateStringRep(listPtr);
@@ -1240,7 +1240,7 @@ Tcl_ListObjReplace(
 *	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
+ *	in such a way that we tend to keep the most useful internalreps and/or
 *	avoid the most expensive conversions.
 *
 *----------------------------------------------------------------------
@@ -1263,7 +1263,7 @@ TclLindexList(
     * shimmering; see TIP#22 and TIP#33 for the details.
     */

-    ListGetIntRep(argPtr, listRepPtr);
+    ListGetInternalRep(argPtr, listRepPtr);
    if ((listRepPtr == NULL)
 	    && TclGetIntForIndexM(NULL , argPtr, INT_MAX - 1, &index) == TCL_OK) {
 	/*
@@ -1295,7 +1295,7 @@ TclLindexList(
 	return TclLindexFlat(interp, listPtr, 1, &argPtr);
    }

-    ListGetIntRep(indexListCopy, listRepPtr);
+    ListGetInternalRep(indexListCopy, listRepPtr);

    assert(listRepPtr != NULL);

@@ -1418,7 +1418,7 @@ TclLindexFlat(
 *	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
+ *	in such a way that we tend to keep the most useful internalreps and/or
 *	avoid the most expensive conversions.
 *
 *----------------------------------------------------------------------
@@ -1444,7 +1444,7 @@ TclLsetList(
     * shimmering; see TIP #22 and #23 for details.
     */

-    ListGetIntRep(indexArgPtr, listRepPtr);
+    ListGetInternalRep(indexArgPtr, listRepPtr);
    if (listRepPtr == NULL
 	    && TclGetIntForIndexM(NULL, indexArgPtr, INT_MAX - 1, &index) == TCL_OK) {
 	/*
@@ -1531,7 +1531,7 @@ TclLsetFlat(
 {
    int index, result, len;
    Tcl_Obj *subListPtr, *retValuePtr, *chainPtr;
-    Tcl_ObjIntRep *irPtr;
+    Tcl_ObjInternalRep *irPtr;

    /*
     * If there are no indices, simply return the new value.  (Without
@@ -1636,8 +1636,8 @@ TclLsetFlat(
 	    /*
 	     * Replace the original elemPtr[index] in parentList with a copy
 	     * we know to be unshared.  This call will also deal with the
-	     * situation where parentList shares its intrep with other
-	     * Tcl_Obj's.  Dealing with the shared intrep case can cause
+	     * situation where parentList shares its internalrep with other
+	     * Tcl_Obj's.  Dealing with the shared internalrep case can cause
 	     * subListPtr to become shared again, so detect that case and make
 	     * and store another copy.
 	     */
@@ -1662,11 +1662,11 @@ TclLsetFlat(
 	     * variable.  Later on, when we set valuePtr in its proper place,
 	     * then all containing lists will have their values changed, and
 	     * will need their string reps spoiled.  We maintain a list of all
-	     * those Tcl_Obj's (via a little intrep surgery) so we can spoil
+	     * those Tcl_Obj's (via a little internalrep surgery) so we can spoil
 	     * them at that time.
 	     */

-	    irPtr = TclFetchIntRep(parentList, &tclListType);
+	    irPtr = TclFetchInternalRep(parentList, &tclListType);
 	    irPtr->twoPtrValue.ptr2 = chainPtr;
 	    chainPtr = parentList;
 	}
@@ -1684,10 +1684,10 @@ TclLsetFlat(
 	List *listRepPtr;

 	/*
-	 * Clear away our intrep surgery mess.
+	 * Clear away our internalrep surgery mess.
 	 */

-	irPtr = TclFetchIntRep(objPtr, &tclListType);
+	irPtr = TclFetchInternalRep(objPtr, &tclListType);
 	listRepPtr = (List *)irPtr->twoPtrValue.ptr1;
 	chainPtr = (Tcl_Obj *)irPtr->twoPtrValue.ptr2;

@@ -1699,8 +1699,8 @@ TclLsetFlat(
 	     */

 	    listRepPtr->refCount++;
-	    TclFreeIntRep(objPtr);
-	    ListSetIntRep(objPtr, listRepPtr);
+	    TclFreeInternalRep(objPtr);
+	    ListSetInternalRep(objPtr, listRepPtr);
 	    listRepPtr->refCount--;

 	    TclInvalidateStringRep(objPtr);
@@ -1793,7 +1793,7 @@ TclListObjSetElement(
 	Tcl_Panic("%s called with shared object", "TclListObjSetElement");
    }

-    ListGetIntRep(listPtr, listRepPtr);
+    ListGetInternalRep(listPtr, listRepPtr);
    if (listRepPtr == NULL) {
 	int result, length;

@@ -1811,7 +1811,7 @@ TclListObjSetElement(
 	if (result != TCL_OK) {
 	    return result;
 	}
-	ListGetIntRep(listPtr, listRepPtr);
+	ListGetInternalRep(listPtr, listRepPtr);
    }

    elemCount = listRepPtr->elemCount;
@@ -1857,7 +1857,7 @@ TclListObjSetElement(
 	listRepPtr->refCount--;

 	listRepPtr = newPtr;
-	ListResetIntRep(listPtr, listRepPtr);
+	ListResetInternalRep(listPtr, listRepPtr);
    }
    elemPtrs = &listRepPtr->elements;

@@ -1880,13 +1880,13 @@ TclListObjSetElement(
    elemPtrs[index] = valuePtr;

    /*
-     * Invalidate outdated intreps.
+     * Invalidate outdated internalreps.
     */

-    ListGetIntRep(listPtr, listRepPtr);
+    ListGetInternalRep(listPtr, listRepPtr);
    listRepPtr->refCount++;
-    TclFreeIntRep(listPtr);
-    ListSetIntRep(listPtr, listRepPtr);
+    TclFreeInternalRep(listPtr);
+    ListSetInternalRep(listPtr, listRepPtr);
    listRepPtr->refCount--;

    TclInvalidateStringRep(listPtr);
@@ -1918,7 +1918,7 @@ FreeListInternalRep(
 {
    List *listRepPtr;

-    ListGetIntRep(listPtr, listRepPtr);
+    ListGetInternalRep(listPtr, listRepPtr);
    assert(listRepPtr != NULL);

    if (listRepPtr->refCount-- <= 1) {
@@ -1956,9 +1956,9 @@ DupListInternalRep(
 {
    List *listRepPtr;

-    ListGetIntRep(srcPtr, listRepPtr);
+    ListGetInternalRep(srcPtr, listRepPtr);
    assert(listRepPtr != NULL);
-    ListSetIntRep(copyPtr, listRepPtr);
+    ListSetInternalRep(copyPtr, listRepPtr);
 }

 /*
@@ -1996,7 +1996,7 @@ SetListFromAny(
     * describe duplicate keys).
     */

-    if (!TclHasStringRep(objPtr) && TclHasIntRep(objPtr, &tclDictType)) {
+    if (!TclHasStringRep(objPtr) && TclHasInternalRep(objPtr, &tclDictType)) {
 	Tcl_Obj *keyPtr, *valuePtr;
 	Tcl_DictSearch search;
 	int done, size;
@@ -2099,7 +2099,7 @@ SetListFromAny(
     * Tcl_GetStringFromObj, to use the old internalRep.
     */

-    ListSetIntRep(objPtr, listRepPtr);
+    ListSetInternalRep(objPtr, listRepPtr);
    return TCL_OK;
 }

@@ -2136,7 +2136,7 @@ UpdateStringOfList(
    Tcl_Obj **elemPtrs;
    List *listRepPtr;

-    ListGetIntRep(listPtr, listRepPtr);
+    ListGetInternalRep(listPtr, listRepPtr);

    assert(listRepPtr != NULL);

@@ -1045,7 +1045,7 @@ RebuildLiteralTable(
 *
 * Side effects:
 *	Resets the internal representation of the CmdName Tcl_Obj
- *	using TclFreeIntRep().
+ *	using TclFreeInternalRep().
 *
 *----------------------------------------------------------------------
 */
@@ -1064,8 +1064,8 @@ TclInvalidateCmdLiteral(
 	    strlen(name), -1, NULL, nsPtr, 0, NULL);

    if (literalObjPtr != NULL) {
-	if (TclHasIntRep(literalObjPtr, &tclCmdNameType)) {
-	    TclFreeIntRep(literalObjPtr);
+	if (TclHasInternalRep(literalObjPtr, &tclCmdNameType)) {
+	    TclFreeInternalRep(literalObjPtr);
 	}
 	/* Balance the refcount effects of TclCreateLiteral() above */
 	Tcl_IncrRefCount(literalObjPtr);
@@ -133,19 +133,19 @@ static const Tcl_ObjType nsNameType = {
    SetNsNameFromAny		/* setFromAnyProc */
 };

-#define NsNameSetIntRep(objPtr, nnPtr)					\
+#define NsNameSetInternalRep(objPtr, nnPtr)					\
    do {								\
-	Tcl_ObjIntRep ir;						\
+	Tcl_ObjInternalRep ir;						\
 	(nnPtr)->refCount++;						\
 	ir.twoPtrValue.ptr1 = (nnPtr);					\
 	ir.twoPtrValue.ptr2 = NULL;					\
-	Tcl_StoreIntRep((objPtr), &nsNameType, &ir);			\
+	Tcl_StoreInternalRep((objPtr), &nsNameType, &ir);			\
    } while (0)

-#define NsNameGetIntRep(objPtr, nnPtr)					\
+#define NsNameGetInternalRep(objPtr, nnPtr)					\
    do {								\
-	const Tcl_ObjIntRep *irPtr;					\
-	irPtr = TclFetchIntRep((objPtr), &nsNameType);			\
+	const Tcl_ObjInternalRep *irPtr;					\
+	irPtr = TclFetchInternalRep((objPtr), &nsNameType);			\
 	(nnPtr) = irPtr ? (ResolvedNsName *)irPtr->twoPtrValue.ptr1 : NULL;		\
    } while (0)

@@ -2928,7 +2928,7 @@ GetNamespaceFromObj(
 {
    ResolvedNsName *resNamePtr;

-    NsNameGetIntRep(objPtr, resNamePtr);
+    NsNameGetInternalRep(objPtr, resNamePtr);
    if (resNamePtr) {
 	Namespace *nsPtr, *refNsPtr;

@@ -2945,10 +2945,10 @@ GetNamespaceFromObj(
 	    *nsPtrPtr = (Tcl_Namespace *) nsPtr;
 	    return TCL_OK;
 	}
-	Tcl_StoreIntRep(objPtr, &nsNameType, NULL);
+	Tcl_StoreInternalRep(objPtr, &nsNameType, NULL);
    }
    if (SetNsNameFromAny(interp, objPtr) == TCL_OK) {
-	NsNameGetIntRep(objPtr, resNamePtr);
+	NsNameGetInternalRep(objPtr, resNamePtr);
 	assert(resNamePtr != NULL);
 	*nsPtrPtr = (Tcl_Namespace *) resNamePtr->nsPtr;
 	return TCL_OK;
@@ -4722,7 +4722,7 @@ FreeNsNameInternalRep(
 {
    ResolvedNsName *resNamePtr;

-    NsNameGetIntRep(objPtr, resNamePtr);
+    NsNameGetInternalRep(objPtr, resNamePtr);
    assert(resNamePtr != NULL);

    /*
@@ -4768,9 +4768,9 @@ DupNsNameInternalRep(
 {
    ResolvedNsName *resNamePtr;

-    NsNameGetIntRep(srcPtr, resNamePtr);
+    NsNameGetInternalRep(srcPtr, resNamePtr);
    assert(resNamePtr != NULL);
-    NsNameSetIntRep(copyPtr, resNamePtr);
+    NsNameSetInternalRep(copyPtr, resNamePtr);
 }

 /*
@@ -4833,7 +4833,7 @@ SetNsNameFromAny(
 	resNamePtr->refNsPtr = (Namespace *) TclGetCurrentNamespace(interp);
    }
    resNamePtr->refCount = 0;
-    NsNameSetIntRep(objPtr, resNamePtr);
+    NsNameSetInternalRep(objPtr, resNamePtr);
    return TCL_OK;
 }

@@ -4921,8 +4921,9 @@ TclLogCommandInfo(
 				 * command (must be <= command). */
    const char *command,	/* First character in command that generated
 				 * the error. */
-    int length,			/* Number of bytes in command (-1 means use
-				 * all bytes up to first null byte). */
+    int length,			/* Number of bytes in command (TCL_INDEX_NONE
+				 * 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 */
@@ -5012,7 +5013,7 @@ TclLogCommandInfo(
 	Tcl_ListObjLength(interp, iPtr->errorStack, &len);

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

 	Tcl_ListObjReplace(interp, iPtr->errorStack, 0, len, 0, NULL);
@@ -5097,7 +5098,7 @@ TclErrorStackResetIf(
 	Tcl_ListObjLength(interp, iPtr->errorStack, &len);

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

 	Tcl_ListObjReplace(interp, iPtr->errorStack, 0, len, 0, NULL);
@@ -3144,6 +3144,26 @@ Tcl_ObjectSetMethodNameMapper(
 {
    ((Object *) object)->mapMethodNameProc = mapMethodNameProc;
 }
+
+Tcl_Class
+Tcl_GetClassOfObject(
+    Tcl_Object object)
+{
+    return (Tcl_Class) ((Object *) object)->selfCls;
+}
+
+Tcl_Obj *
+Tcl_GetObjectClassName(
+    Tcl_Interp *interp,
+    Tcl_Object object)
+{
+    Tcl_Object classObj = (Tcl_Object) (((Object *) object)->selfCls)->thisPtr;
+
+    if (classObj == NULL) {
+	return NULL;
+    }
+    return Tcl_GetObjectName(interp, classObj);
+}

 /*
 * Local Variables:
@@ -129,6 +129,12 @@ declare 28 {
 declare 29 {
    int Tcl_MethodIsPrivate(Tcl_Method method)
 }
+declare 30 {
+    Tcl_Class Tcl_GetClassOfObject(Tcl_Object object)
+}
+declare 31 {
+    Tcl_Obj *Tcl_GetObjectClassName(Tcl_Interp *interp, Tcl_Object object)
+}

 ######################################################################
 # Private API, exposed to support advanced OO systems that plug in on top of
@@ -247,12 +247,12 @@ StashCallChain(
    Tcl_Obj *objPtr,
    CallChain *callPtr)
 {
-    Tcl_ObjIntRep ir;
+    Tcl_ObjInternalRep ir;

    callPtr->refCount++;
    TclGetString(objPtr);
    ir.twoPtrValue.ptr1 = callPtr;
-    Tcl_StoreIntRep(objPtr, &methodNameType, &ir);
+    Tcl_StoreInternalRep(objPtr, &methodNameType, &ir);
 }

 void
@@ -280,7 +280,7 @@ DupMethodNameRep(
    Tcl_Obj *dstPtr)
 {
    StashCallChain(dstPtr,
-	    (CallChain *)TclFetchIntRep(srcPtr, &methodNameType)->twoPtrValue.ptr1);
+	    (CallChain *)TclFetchInternalRep(srcPtr, &methodNameType)->twoPtrValue.ptr1);
 }

 static void
@@ -288,7 +288,7 @@ FreeMethodNameRep(
    Tcl_Obj *objPtr)
 {
    TclOODeleteChain(
-	    (CallChain *)TclFetchIntRep(objPtr, &methodNameType)->twoPtrValue.ptr1);
+	    (CallChain *)TclFetchInternalRep(objPtr, &methodNameType)->twoPtrValue.ptr1);
 }

 /*
@@ -1189,16 +1189,16 @@ TclOOGetCallContext(
 	 * the object, and in the class).
 	 */

-	const Tcl_ObjIntRep *irPtr;
+	const Tcl_ObjInternalRep *irPtr;
 	const int reuseMask = (WANT_PUBLIC(flags) ? ~0 : ~PUBLIC_METHOD);

-	if ((irPtr = TclFetchIntRep(cacheInThisObj, &methodNameType))) {
+	if ((irPtr = TclFetchInternalRep(cacheInThisObj, &methodNameType))) {
 	    callPtr = (CallChain *)irPtr->twoPtrValue.ptr1;
 	    if (IsStillValid(callPtr, oPtr, flags, reuseMask)) {
 		callPtr->refCount++;
 		goto returnContext;
 	    }
-	    Tcl_StoreIntRep(cacheInThisObj, &methodNameType, NULL);
+	    Tcl_StoreInternalRep(cacheInThisObj, &methodNameType, NULL);
 	}

 	if (oPtr->flags & USE_CLASS_CACHE) {
@@ -118,6 +118,11 @@ TCLAPI Tcl_Obj *	Tcl_GetObjectName(Tcl_Interp *interp,
 				Tcl_Object object);
 /* 29 */
 TCLAPI int		Tcl_MethodIsPrivate(Tcl_Method method);
+/* 30 */
+TCLAPI Tcl_Class	Tcl_GetClassOfObject(Tcl_Object object);
+/* 31 */
+TCLAPI Tcl_Obj *	Tcl_GetObjectClassName(Tcl_Interp *interp,
+				Tcl_Object object);

 typedef struct {
    const struct TclOOIntStubs *tclOOIntStubs;
@@ -157,6 +162,8 @@ typedef struct TclOOStubs {
    void (*tcl_ClassSetDestructor) (Tcl_Interp *interp, Tcl_Class clazz, Tcl_Method method); /* 27 */
    Tcl_Obj * (*tcl_GetObjectName) (Tcl_Interp *interp, Tcl_Object object); /* 28 */
    int (*tcl_MethodIsPrivate) (Tcl_Method method); /* 29 */
+    Tcl_Class (*tcl_GetClassOfObject) (Tcl_Object object); /* 30 */
+    Tcl_Obj * (*tcl_GetObjectClassName) (Tcl_Interp *interp, Tcl_Object object); /* 31 */
 } TclOOStubs;

 extern const TclOOStubs *tclOOStubsPtr;
@@ -231,6 +238,10 @@ extern const TclOOStubs *tclOOStubsPtr;
 	(tclOOStubsPtr->tcl_GetObjectName) /* 28 */
 #define Tcl_MethodIsPrivate \
 	(tclOOStubsPtr->tcl_MethodIsPrivate) /* 29 */
+#define Tcl_GetClassOfObject \
+	(tclOOStubsPtr->tcl_GetClassOfObject) /* 30 */
+#define Tcl_GetObjectClassName \
+	(tclOOStubsPtr->tcl_GetObjectClassName) /* 31 */

 #endif /* defined(USE_TCLOO_STUBS) */

@@ -859,7 +859,7 @@ PushMethodCallFrame(
     * alternative is *so* slow...
     */

-    ByteCodeGetIntRep(pmPtr->procPtr->bodyPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetInternalRep(pmPtr->procPtr->bodyPtr, &tclByteCodeType, codePtr);
    if (codePtr) {
 	codePtr->nsPtr = nsPtr;
    }
@@ -1338,7 +1338,7 @@ CloneProcedureMethod(

    bodyObj = Tcl_DuplicateObj(pmPtr->procPtr->bodyPtr);
    Tcl_GetString(bodyObj);
-    Tcl_StoreIntRep(pmPtr->procPtr->bodyPtr, &tclByteCodeType, NULL);
+    Tcl_StoreInternalRep(pmPtr->procPtr->bodyPtr, &tclByteCodeType, NULL);

    /*
     * Create the actual copy of the method record, manufacturing a new proc
@@ -74,6 +74,8 @@ const TclOOStubs tclOOStubs = {
    Tcl_ClassSetDestructor, /* 27 */
    Tcl_GetObjectName, /* 28 */
    Tcl_MethodIsPrivate, /* 29 */
+    Tcl_GetClassOfObject, /* 30 */
+    Tcl_GetObjectClassName, /* 31 */
 };

 /* !END!: Do not edit above this line. */
@@ -1373,7 +1373,7 @@ TclFreeObj(

 	    PopObjToDelete(context, objToFree);
 	    TCL_DTRACE_OBJ_FREE(objToFree);
-	    TclFreeIntRep(objToFree);
+	    TclFreeInternalRep(objToFree);

 	    Tcl_MutexLock(&tclObjMutex);
 	    ckfree(objToFree);
@@ -1592,7 +1592,7 @@ TclSetDuplicateObj(
 	Tcl_Panic("%s called with shared object", "TclSetDuplicateObj");
    }
    TclInvalidateStringRep(dupPtr);
-    TclFreeIntRep(dupPtr);
+    TclFreeInternalRep(dupPtr);
    SetDuplicateObj(dupPtr, objPtr);
 }

@@ -1892,13 +1892,13 @@ Tcl_HasStringRep(
 /*
 *----------------------------------------------------------------------
 *
- * Tcl_StoreIntRep --
+ * Tcl_StoreInternalRep --
 *
 *	This function is called to set the object's internal
 *	representation to match a particular type.
 *
 *	It is the caller's responsibility to guarantee that
- *	the value of the submitted IntRep is in agreement with
+ *	the value of the submitted internalrep is in agreement with
 *	the value of any existing string rep.
 *
 * Results:
@@ -1912,17 +1912,17 @@ Tcl_HasStringRep(
 */

 void
-Tcl_StoreIntRep(
+Tcl_StoreInternalRep(
    Tcl_Obj *objPtr,		/* Object whose internal rep should be set. */
    const Tcl_ObjType *typePtr,	/* New type for the object */
-    const Tcl_ObjIntRep *irPtr)	/* New IntRep for the object */
+    const Tcl_ObjInternalRep *irPtr)	/* New internalrep for the object */
 {
-    /* Clear out any existing IntRep ( "shimmer" ) */
-    TclFreeIntRep(objPtr);
+    /* Clear out any existing internalrep ( "shimmer" ) */
+    TclFreeInternalRep(objPtr);

-    /* When irPtr == NULL, just leave objPtr with no IntRep for typePtr */
+    /* When irPtr == NULL, just leave objPtr with no internalrep for typePtr */
    if (irPtr) {
-	/* Copy the new IntRep into place */
+	/* Copy the new internalrep into place */
 	objPtr->internalRep = *irPtr;

 	/* Set the type to match */
@@ -1933,13 +1933,13 @@ Tcl_StoreIntRep(
 /*
 *----------------------------------------------------------------------
 *
- * Tcl_FetchIntRep --
+ * Tcl_FetchInternalRep --
 *
 *	This function is called to retrieve the object's internal
 *	representation matching a requested type, if any.
 *
 * Results:
- *	A read-only pointer to the associated Tcl_ObjIntRep, or
+ *	A read-only pointer to the associated Tcl_ObjInternalRep, or
 *	NULL if no such internal representation exists.
 *
 * Side effects:
@@ -1949,18 +1949,18 @@ Tcl_StoreIntRep(
 *----------------------------------------------------------------------
 */

-Tcl_ObjIntRep *
-Tcl_FetchIntRep(
+Tcl_ObjInternalRep *
+Tcl_FetchInternalRep(
    Tcl_Obj *objPtr,		/* Object to fetch from. */
    const Tcl_ObjType *typePtr)	/* Requested type */
 {
-    return TclFetchIntRep(objPtr, typePtr);
+    return TclFetchInternalRep(objPtr, typePtr);
 }

 /*
 *----------------------------------------------------------------------
 *
- * Tcl_FreeIntRep --
+ * Tcl_FreeInternalRep --
 *
 *	This function is called to free an object's internal representation.
 *
@@ -1975,10 +1975,10 @@ Tcl_FetchIntRep(
 */

 void
-Tcl_FreeIntRep(
+Tcl_FreeInternalRep(
    Tcl_Obj *objPtr)	/* Object whose internal rep should be freed. */
 {
-    TclFreeIntRep(objPtr);
+    TclFreeInternalRep(objPtr);
 }

 /*
@@ -2134,7 +2134,7 @@ Tcl_SetBooleanObj(
 *	result unless "interp" is NULL.
 *
 * Side effects:
- *	The intrep of *objPtr may be changed.
+ *	The internalrep of *objPtr may be changed.
 *
 *----------------------------------------------------------------------
 */
@@ -2157,7 +2157,7 @@ Tcl_GetBooleanFromObj(
 	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
+	     * Tcl_ObjType and then compare the internalrep to 0.0. This isn't
 	     * reliable because a "double" Tcl_ObjType can hold the NaN value.
 	     * Use the API Tcl_GetDoubleFromObj, which does the checking and
 	     * sets the proper error message for us.
@@ -2357,13 +2357,13 @@ ParseBoolean(
     */

  goodBoolean:
-    TclFreeIntRep(objPtr);
+    TclFreeInternalRep(objPtr);
    objPtr->internalRep.longValue = newBool;
    objPtr->typePtr = &tclBooleanType;
    return TCL_OK;

  numericBoolean:
-    TclFreeIntRep(objPtr);
+    TclFreeInternalRep(objPtr);
    objPtr->internalRep.wideValue = newBool;
    objPtr->typePtr = &tclIntType;
    return TCL_OK;
@@ -3639,7 +3639,7 @@ GetBignumFromObj(
 		}
 	    } else {
 		TclUnpackBignum(objPtr, *bignumValue);
-		/* Optimized TclFreeIntRep */
+		/* Optimized TclFreeInternalRep */
 		objPtr->internalRep.twoPtrValue.ptr1 = NULL;
 		objPtr->internalRep.twoPtrValue.ptr2 = NULL;
 		objPtr->typePtr = NULL;
@@ -3793,14 +3793,14 @@ Tcl_SetBignumObj(
    return;
  tooLargeForWide:
    TclInvalidateStringRep(objPtr);
-    TclFreeIntRep(objPtr);
-    TclSetBignumIntRep(objPtr, bignumValue);
+    TclFreeInternalRep(objPtr);
+    TclSetBignumInternalRep(objPtr, bignumValue);
 }

 /*
 *----------------------------------------------------------------------
 *
- * TclSetBignumIntRep --
+ * TclSetBignumInternalRep --
 *
 *	Install a bignum into the internal representation of an object.
 *
@@ -3816,7 +3816,7 @@ Tcl_SetBignumObj(
 */

 void
-TclSetBignumIntRep(
+TclSetBignumInternalRep(
    Tcl_Obj *objPtr,
    void *big)
 {
@@ -4554,7 +4554,7 @@ SetCmdNameObj(
    }

    if (resPtr == NULL) {
-	TclFreeIntRep(objPtr);
+	TclFreeInternalRep(objPtr);

 	objPtr->internalRep.twoPtrValue.ptr1 = fillPtr;
 	objPtr->internalRep.twoPtrValue.ptr2 = NULL;
@@ -85,13 +85,13 @@ typedef struct FsPath {
 * fields.
 */

-#define PATHOBJ(pathPtr) ((FsPath *) (TclFetchIntRep((pathPtr), &fsPathType)->twoPtrValue.ptr1))
+#define PATHOBJ(pathPtr) ((FsPath *) (TclFetchInternalRep((pathPtr), &fsPathType)->twoPtrValue.ptr1))
 #define SETPATHOBJ(pathPtr,fsPathPtr) \
 	do {							\
-		Tcl_ObjIntRep ir;				\
+		Tcl_ObjInternalRep ir;				\
 		ir.twoPtrValue.ptr1 = (void *) (fsPathPtr);	\
 		ir.twoPtrValue.ptr2 = NULL;			\
-		Tcl_StoreIntRep((pathPtr), &fsPathType, &ir);	\
+		Tcl_StoreInternalRep((pathPtr), &fsPathType, &ir);	\
 	} while (0)
 #define PATHFLAGS(pathPtr) (PATHOBJ(pathPtr)->flags)

@@ -544,7 +544,7 @@ TclPathPart(
    Tcl_Obj *pathPtr,		/* Path to take dirname of */
    Tcl_PathPart portion)	/* Requested portion of name */
 {
-    if (TclHasIntRep(pathPtr, &fsPathType)) {
+    if (TclHasInternalRep(pathPtr, &fsPathType)) {
 	FsPath *fsPathPtr = PATHOBJ(pathPtr);

 	if (PATHFLAGS(pathPtr) != 0) {
@@ -843,7 +843,7 @@ TclJoinPath(

    if (elements == 2) {
 	Tcl_Obj *elt = objv[0];
-	Tcl_ObjIntRep *eltIr = TclFetchIntRep(elt, &fsPathType);
+	Tcl_ObjInternalRep *eltIr = TclFetchInternalRep(elt, &fsPathType);

 	/*
 	 * This is a special case where we can be much more efficient, where
@@ -1149,13 +1149,13 @@ Tcl_FSConvertToPathType(
     * path.
     */

-    if (TclHasIntRep(pathPtr, &fsPathType)) {
+    if (TclHasInternalRep(pathPtr, &fsPathType)) {
 	if (TclFSEpochOk(PATHOBJ(pathPtr)->filesystemEpoch)) {
 	    return TCL_OK;
 	}

 	TclGetString(pathPtr);
-	Tcl_StoreIntRep(pathPtr, &fsPathType, NULL);
+	Tcl_StoreInternalRep(pathPtr, &fsPathType, NULL);
    }

    return SetFsPathFromAny(interp, pathPtr);
@@ -1349,7 +1349,7 @@ AppendPath(
     * 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
+     * internalrep 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, &numBytes);
@@ -1391,7 +1391,7 @@ TclFSMakePathRelative(
 {
    int cwdLen, len;
    const char *tempStr;
-    Tcl_ObjIntRep *irPtr = TclFetchIntRep(pathPtr, &fsPathType);
+    Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(pathPtr, &fsPathType);

    if (irPtr) {
 	FsPath *fsPathPtr = PATHOBJ(pathPtr);
@@ -1461,7 +1461,7 @@ MakePathFromNormalized(
 {
    FsPath *fsPathPtr;

-    if (TclHasIntRep(pathPtr, &fsPathType)) {
+    if (TclHasInternalRep(pathPtr, &fsPathType)) {
 	return TCL_OK;
    }

@@ -1532,7 +1532,7 @@ Tcl_FSNewNativePath(
     * safe.
     */

-    Tcl_StoreIntRep(pathPtr, &fsPathType, NULL);
+    Tcl_StoreInternalRep(pathPtr, &fsPathType, NULL);
    fsPathPtr = (FsPath *)ckalloc(sizeof(FsPath));

    fsPathPtr->translatedPathPtr = NULL;
@@ -1598,7 +1598,7 @@ Tcl_FSGetTranslatedPath(

 	    Tcl_Obj *translatedCwdPtr = Tcl_FSGetTranslatedPath(interp,
 		    srcFsPathPtr->cwdPtr);
-	    Tcl_ObjIntRep *translatedCwdIrPtr;
+	    Tcl_ObjInternalRep *translatedCwdIrPtr;

 	    if (translatedCwdPtr == NULL) {
 		return NULL;
@@ -1607,7 +1607,7 @@ Tcl_FSGetTranslatedPath(
 	    retObj = Tcl_FSJoinToPath(translatedCwdPtr, 1,
 		    &srcFsPathPtr->normPathPtr);
 	    Tcl_IncrRefCount(srcFsPathPtr->translatedPathPtr = retObj);
-	    translatedCwdIrPtr = TclFetchIntRep(translatedCwdPtr, &fsPathType);
+	    translatedCwdIrPtr = TclFetchInternalRep(translatedCwdPtr, &fsPathType);
 	    if (translatedCwdIrPtr) {
 		srcFsPathPtr->filesystemEpoch
 			= PATHOBJ(translatedCwdPtr)->filesystemEpoch;
@@ -1802,7 +1802,7 @@ Tcl_FSGetNormalizedPath(
    if (fsPathPtr->cwdPtr != NULL) {
 	if (!TclFSCwdPointerEquals(&fsPathPtr->cwdPtr)) {
 	    TclGetString(pathPtr);
-	    Tcl_StoreIntRep(pathPtr, &fsPathType, NULL);
+	    Tcl_StoreInternalRep(pathPtr, &fsPathType, NULL);
 	    if (SetFsPathFromAny(interp, pathPtr) != TCL_OK) {
 		return NULL;
 	    }
@@ -2048,7 +2048,7 @@ TclFSEnsureEpochOk(
 {
    FsPath *srcFsPathPtr;

-    if (!TclHasIntRep(pathPtr, &fsPathType)) {
+    if (!TclHasInternalRep(pathPtr, &fsPathType)) {
 	return TCL_OK;
    }

@@ -2062,7 +2062,7 @@ TclFSEnsureEpochOk(
 	 */

 	TclGetString(pathPtr);
-	Tcl_StoreIntRep(pathPtr, &fsPathType, NULL);
+	Tcl_StoreInternalRep(pathPtr, &fsPathType, NULL);
 	if (SetFsPathFromAny(NULL, pathPtr) != TCL_OK) {
 	    return TCL_ERROR;
 	}
@@ -2106,7 +2106,7 @@ TclFSSetPathDetails(
     * Make sure pathPtr is of the correct type.
     */

-    if (!TclHasIntRep(pathPtr, &fsPathType)) {
+    if (!TclHasInternalRep(pathPtr, &fsPathType)) {
 	if (SetFsPathFromAny(NULL, pathPtr) != TCL_OK) {
 	    return;
 	}
@@ -2206,7 +2206,7 @@ SetFsPathFromAny(
    Tcl_Obj *transPtr;
    const char *name;

-    if (TclHasIntRep(pathPtr, &fsPathType)) {
+    if (TclHasInternalRep(pathPtr, &fsPathType)) {
 	return TCL_OK;
    }

@@ -2519,7 +2519,7 @@ TclNativePathInFilesystem(
     * semantics of Tcl (at present anyway), so we have to abide by them here.
     */

-    if (TclHasIntRep(pathPtr, &fsPathType)) {
+    if (TclHasInternalRep(pathPtr, &fsPathType)) {
 	if (pathPtr->bytes != NULL && pathPtr->bytes[0] == '\0') {
 	    /*
 	     * We reject the empty path "".
@@ -67,19 +67,19 @@ const Tcl_ObjType tclProcBodyType = {
 				 * should panic instead. */
 };

-#define ProcSetIntRep(objPtr, procPtr)					\
+#define ProcSetInternalRep(objPtr, procPtr)					\
    do {								\
-	Tcl_ObjIntRep ir;						\
+	Tcl_ObjInternalRep ir;						\
 	(procPtr)->refCount++;						\
 	ir.twoPtrValue.ptr1 = (procPtr);				\
 	ir.twoPtrValue.ptr2 = NULL;					\
-	Tcl_StoreIntRep((objPtr), &tclProcBodyType, &ir);		\
+	Tcl_StoreInternalRep((objPtr), &tclProcBodyType, &ir);		\
    } while (0)

-#define ProcGetIntRep(objPtr, procPtr)					\
+#define ProcGetInternalRep(objPtr, procPtr)					\
    do {								\
-	const Tcl_ObjIntRep *irPtr;					\
-	irPtr = TclFetchIntRep((objPtr), &tclProcBodyType);		\
+	const Tcl_ObjInternalRep *irPtr;					\
+	irPtr = TclFetchInternalRep((objPtr), &tclProcBodyType);		\
 	(procPtr) = irPtr ? (Proc *)irPtr->twoPtrValue.ptr1 : NULL;		\
    } while (0)

@@ -113,19 +113,19 @@ static const Tcl_ObjType lambdaType = {
    SetLambdaFromAny		/* setFromAnyProc */
 };

-#define LambdaSetIntRep(objPtr, procPtr, nsObjPtr)			\
+#define LambdaSetInternalRep(objPtr, procPtr, nsObjPtr)			\
    do {								\
-	Tcl_ObjIntRep ir;						\
+	Tcl_ObjInternalRep ir;						\
 	ir.twoPtrValue.ptr1 = (procPtr);				\
 	ir.twoPtrValue.ptr2 = (nsObjPtr);				\
 	Tcl_IncrRefCount((nsObjPtr));					\
-	Tcl_StoreIntRep((objPtr), &lambdaType, &ir);			\
+	Tcl_StoreInternalRep((objPtr), &lambdaType, &ir);			\
    } while (0)

-#define LambdaGetIntRep(objPtr, procPtr, nsObjPtr)			\
+#define LambdaGetInternalRep(objPtr, procPtr, nsObjPtr)			\
    do {								\
-	const Tcl_ObjIntRep *irPtr;					\
-	irPtr = TclFetchIntRep((objPtr), &lambdaType);			\
+	const Tcl_ObjInternalRep *irPtr;					\
+	irPtr = TclFetchInternalRep((objPtr), &lambdaType);			\
 	(procPtr) = irPtr ? (Proc *)irPtr->twoPtrValue.ptr1 : NULL;		\
 	(nsObjPtr) = irPtr ? (Tcl_Obj *)irPtr->twoPtrValue.ptr2 : NULL;		\
    } while (0)
@@ -327,7 +327,7 @@ Tcl_ProcObjCmd(
     *	   of all procs whose argument list is just _args_
     */

-    if (TclHasIntRep(objv[3], &tclProcBodyType)) {
+    if (TclHasInternalRep(objv[3], &tclProcBodyType)) {
 	goto done;
    }

@@ -409,7 +409,7 @@ TclCreateProc(
    Tcl_Obj **argArray;
    int precompiled = 0;

-    ProcGetIntRep(bodyPtr, procPtr);
+    ProcGetInternalRep(bodyPtr, procPtr);
    if (procPtr != NULL) {
 	/*
 	 * Because the body is a TclProProcBody, the actual body is already
@@ -724,7 +724,7 @@ TclGetFrame(
 	obj.length = strlen(name);
 	obj.typePtr = NULL;
 	result = TclObjGetFrame(interp, &obj, framePtrPtr);
-	TclFreeIntRep(&obj);
+	TclFreeInternalRep(&obj);
 	return result;
 }

@@ -762,7 +762,7 @@ TclObjGetFrame(
 {
    Interp *iPtr = (Interp *) interp;
    int curLevel, level, result;
-    const Tcl_ObjIntRep *irPtr;
+    const Tcl_ObjInternalRep *irPtr;
    const char *name = NULL;
    Tcl_WideInt w;

@@ -788,7 +788,7 @@ TclObjGetFrame(
 	    level = curLevel - level;
 	    result = 1;
 	}
-    } else if ((irPtr = TclFetchIntRep(objPtr, &levelReferenceType))) {
+    } else if ((irPtr = TclFetchInternalRep(objPtr, &levelReferenceType))) {
 	level = irPtr->wideValue;
 	result = 1;
    } else {
@@ -798,10 +798,10 @@ TclObjGetFrame(
 		if (level < 0 || (level > 0 && name[1] == '-')) {
 		    result = -1;
 		} else {
-		    Tcl_ObjIntRep ir;
+		    Tcl_ObjInternalRep ir;

 		    ir.wideValue = level;
-		    Tcl_StoreIntRep(objPtr, &levelReferenceType, &ir);
+		    Tcl_StoreInternalRep(objPtr, &levelReferenceType, &ir);
 		    result = 1;
 		}
 	    } else {
@@ -1151,7 +1151,7 @@ TclInitCompiledLocals(
    ByteCode *codePtr;

    bodyPtr = framePtr->procPtr->bodyPtr;
-    ByteCodeGetIntRep(bodyPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetInternalRep(bodyPtr, &tclByteCodeType, codePtr);
    if (codePtr == NULL) {
 	Tcl_Panic("body object for proc attached to frame is not a byte code type");
    }
@@ -1327,7 +1327,7 @@ InitLocalCache(
    CompiledLocal *localPtr;
    int isNew;

-    ByteCodeGetIntRep(procPtr->bodyPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetInternalRep(procPtr->bodyPtr, &tclByteCodeType, codePtr);

    /*
     * Cache the names and initial values of local variables; store the
@@ -1400,7 +1400,7 @@ InitArgsAndLocals(
    int localCt = procPtr->numCompiledLocals, numArgs, argCt, i, imax;
    Tcl_Obj *const *argObjs;

-    ByteCodeGetIntRep(procPtr->bodyPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetInternalRep(procPtr->bodyPtr, &tclByteCodeType, codePtr);

    /*
     * Make sure that the local cache of variable names and initial values has
@@ -1576,7 +1576,7 @@ TclPushProcCallFrame(
     * local variables are found while compiling.
     */

-    ByteCodeGetIntRep(procPtr->bodyPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetInternalRep(procPtr->bodyPtr, &tclByteCodeType, codePtr);
    if (codePtr != NULL) {
 	Interp *iPtr = (Interp *) interp;

@@ -1786,7 +1786,7 @@ TclNRInterpProcCore(
     */

    procPtr->refCount++;
-    ByteCodeGetIntRep(procPtr->bodyPtr, &tclByteCodeType, codePtr);
+    ByteCodeGetInternalRep(procPtr->bodyPtr, &tclByteCodeType, codePtr);

    TclNRAddCallback(interp, InterpProcNR2, procNameObj, errorProc,
 	    NULL, NULL);
@@ -1920,7 +1920,7 @@ TclProcCompileProc(
    Tcl_CallFrame *framePtr;
    ByteCode *codePtr;

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

    /*
     * If necessary, compile the procedure's body. The compiler will allocate
@@ -1955,7 +1955,7 @@ TclProcCompileProc(
 	    codePtr->compileEpoch = iPtr->compileEpoch;
 	    codePtr->nsPtr = nsPtr;
 	} else {
-	    Tcl_StoreIntRep(bodyPtr, &tclByteCodeType, NULL);
+	    Tcl_StoreInternalRep(bodyPtr, &tclByteCodeType, NULL);
 	    codePtr = NULL;
 	}
    }
@@ -2312,7 +2312,7 @@ TclNewProcBodyObj(

    TclNewObj(objPtr);
    if (objPtr) {
-	ProcSetIntRep(objPtr, procPtr);
+	ProcSetInternalRep(objPtr, procPtr);
    }

    return objPtr;
@@ -2341,9 +2341,9 @@ ProcBodyDup(
    Tcl_Obj *dupPtr)		/* Target object for the duplication. */
 {
    Proc *procPtr;
-    ProcGetIntRep(srcPtr, procPtr);
+    ProcGetInternalRep(srcPtr, procPtr);

-    ProcSetIntRep(dupPtr, procPtr);
+    ProcSetInternalRep(dupPtr, procPtr);
 }

 /*
@@ -2371,7 +2371,7 @@ ProcBodyFree(
 {
    Proc *procPtr;

-    ProcGetIntRep(objPtr, procPtr);
+    ProcGetInternalRep(objPtr, procPtr);

    if (procPtr->refCount-- <= 1) {
 	TclProcCleanupProc(procPtr);
@@ -2400,12 +2400,12 @@ DupLambdaInternalRep(
    Proc *procPtr;
    Tcl_Obj *nsObjPtr;

-    LambdaGetIntRep(srcPtr, procPtr, nsObjPtr);
+    LambdaGetInternalRep(srcPtr, procPtr, nsObjPtr);
    assert(procPtr != NULL);

    procPtr->refCount++;

-    LambdaSetIntRep(copyPtr, procPtr, nsObjPtr);
+    LambdaSetInternalRep(copyPtr, procPtr, nsObjPtr);
 }

 static void
@@ -2416,7 +2416,7 @@ FreeLambdaInternalRep(
    Proc *procPtr;
    Tcl_Obj *nsObjPtr;

-    LambdaGetIntRep(objPtr, procPtr, nsObjPtr);
+    LambdaGetInternalRep(objPtr, procPtr, nsObjPtr);
    assert(procPtr != NULL);

    if (procPtr->refCount-- <= 1) {
@@ -2590,7 +2590,7 @@ SetLambdaFromAny(
     * conversion to lambdaType.
     */

-    LambdaSetIntRep(objPtr, procPtr, nsObjPtr);
+    LambdaSetInternalRep(objPtr, procPtr, nsObjPtr);
    return TCL_OK;
 }

@@ -2603,13 +2603,13 @@ TclGetLambdaFromObj(
    Proc *procPtr;
    Tcl_Obj *nsObjPtr;

-    LambdaGetIntRep(objPtr, procPtr, nsObjPtr);
+    LambdaGetInternalRep(objPtr, procPtr, nsObjPtr);

    if (procPtr == NULL) {
 	if (SetLambdaFromAny(interp, objPtr) != TCL_OK) {
 	    return NULL;
 	}
-	LambdaGetIntRep(objPtr, procPtr, nsObjPtr);
+	LambdaGetInternalRep(objPtr, procPtr, nsObjPtr);
    }

    assert(procPtr != NULL);
@@ -109,19 +109,19 @@ const Tcl_ObjType tclRegexpType = {
    SetRegexpFromAny			/* setFromAnyProc */
 };

-#define RegexpSetIntRep(objPtr, rePtr)					\
+#define RegexpSetInternalRep(objPtr, rePtr)					\
    do {								\
-	Tcl_ObjIntRep ir;						\
+	Tcl_ObjInternalRep ir;						\
 	(rePtr)->refCount++;						\
 	ir.twoPtrValue.ptr1 = (rePtr);					\
 	ir.twoPtrValue.ptr2 = NULL;					\
-	Tcl_StoreIntRep((objPtr), &tclRegexpType, &ir);			\
+	Tcl_StoreInternalRep((objPtr), &tclRegexpType, &ir);			\
    } while (0)

-#define RegexpGetIntRep(objPtr, rePtr)					\
+#define RegexpGetInternalRep(objPtr, rePtr)					\
    do {								\
-	const Tcl_ObjIntRep *irPtr;					\
-	irPtr = TclFetchIntRep((objPtr), &tclRegexpType);		\
+	const Tcl_ObjInternalRep *irPtr;					\
+	irPtr = TclFetchInternalRep((objPtr), &tclRegexpType);		\
 	(rePtr) = irPtr ? (TclRegexp *)irPtr->twoPtrValue.ptr1 : NULL;		\
    } while (0)

@@ -598,7 +598,7 @@ Tcl_GetRegExpFromObj(
    TclRegexp *regexpPtr;
    const char *pattern;

-    RegexpGetIntRep(objPtr, regexpPtr);
+    RegexpGetInternalRep(objPtr, regexpPtr);

    if ((regexpPtr == NULL) || (regexpPtr->flags != flags)) {
 	pattern = TclGetStringFromObj(objPtr, &length);
@@ -608,7 +608,7 @@ Tcl_GetRegExpFromObj(
 	    return NULL;
 	}

-	RegexpSetIntRep(objPtr, regexpPtr);
+	RegexpSetInternalRep(objPtr, regexpPtr);
    }
    return (Tcl_RegExp) regexpPtr;
 }
@@ -757,7 +757,7 @@ FreeRegexpInternalRep(
 {
    TclRegexp *regexpRepPtr;

-    RegexpGetIntRep(objPtr, regexpRepPtr);
+    RegexpGetInternalRep(objPtr, regexpRepPtr);

    assert(regexpRepPtr != NULL);

@@ -794,11 +794,11 @@ DupRegexpInternalRep(
 {
    TclRegexp *regexpPtr;

-    RegexpGetIntRep(srcPtr, regexpPtr);
+    RegexpGetInternalRep(srcPtr, regexpPtr);

    assert(regexpPtr != NULL);

-    RegexpSetIntRep(copyPtr, regexpPtr);
+    RegexpSetInternalRep(copyPtr, regexpPtr);
 }

 /*
@@ -1013,7 +1013,7 @@ ResetObjResult(
 	    objResultPtr->bytes = &tclEmptyString;
 	    objResultPtr->length = 0;
 	}
-	TclFreeIntRep(objResultPtr);
+	TclFreeInternalRep(objResultPtr);
    }
 }

@@ -1336,7 +1336,7 @@ TclProcessReturn(
            Tcl_ListObjLength(interp, iPtr->errorStack, &len);

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

            Tcl_ListObjReplace(interp, iPtr->errorStack, 0, len, valueObjc,
@@ -1017,8 +1017,8 @@ Tcl_ScanObjCmd(
 		double dvalue;
 		if (Tcl_GetDoubleFromObj(NULL, objPtr, &dvalue) != TCL_OK) {
 #ifdef ACCEPT_NAN
-		    const Tcl_ObjIntRep *irPtr
-			    = TclFetchIntRep(objPtr, &tclDoubleType);
+		    const Tcl_ObjInternalRep *irPtr
+			    = TclFetchInternalRep(objPtr, &tclDoubleType);
 		    if (irPtr) {
 			dvalue = irPtr->doubleValue;
 		    } else
@@ -553,11 +553,11 @@ TclParseNumber(

    if (bytes == NULL) {
 	if (interp == NULL && endPtrPtr == NULL) {
-	    if (TclHasIntRep(objPtr, &tclDictType)) {
+	    if (TclHasInternalRep(objPtr, &tclDictType)) {
 		/* A dict can never be a (single) number */
 		return TCL_ERROR;
 	    }
-	    if (TclHasIntRep(objPtr, &tclListType)) {
+	    if (TclHasInternalRep(objPtr, &tclListType)) {
 		int length;
 		/* A list can only be a (single) number if its length == 1 */
 		TclListObjLength(NULL, objPtr, &length);
@@ -1295,7 +1295,7 @@ TclParseNumber(
     */

    if (status == TCL_OK && objPtr != NULL) {
-	TclFreeIntRep(objPtr);
+	TclFreeInternalRep(objPtr);
 	switch (acceptState) {
 	case SIGNUM:
 	case BAD_OCTAL:
@@ -1405,7 +1405,7 @@ TclParseNumber(
 		if (signum) {
 		    err = mp_neg(&octalSignificandBig, &octalSignificandBig);
 		}
-		TclSetBignumIntRep(objPtr, &octalSignificandBig);
+		TclSetBignumInternalRep(objPtr, &octalSignificandBig);
 	    }
 	    if (err != MP_OKAY) {
 		return TCL_ERROR;
@@ -1441,7 +1441,7 @@ TclParseNumber(
 		if (signum) {
 		    err = mp_neg(&significandBig, &significandBig);
 		}
-		TclSetBignumIntRep(objPtr, &significandBig);
+		TclSetBignumInternalRep(objPtr, &significandBig);
 	    }
 	    if (err != MP_OKAY) {
 		return TCL_ERROR;
@@ -836,7 +836,7 @@ Tcl_SetStringObj(
     * Set the type to NULL and free any internal rep for the old type.
     */

-    TclFreeIntRep(objPtr);
+    TclFreeInternalRep(objPtr);

    /*
     * Free any old string rep, then set the string rep to a copy of the
@@ -1098,7 +1098,7 @@ Tcl_SetUnicodeObj(
    if (Tcl_IsShared(objPtr)) {
 	Tcl_Panic("%s called with shared object", "Tcl_SetUnicodeObj");
    }
-    TclFreeIntRep(objPtr);
+    TclFreeInternalRep(objPtr);
    SetUnicodeObj(objPtr, unicode, numChars);
 }

@@ -1443,7 +1443,7 @@ Tcl_AppendObjToObj(
 	 * If appendObjPtr is not of the "String" type, don't convert it.
 	 */

-	if (TclHasIntRep(appendObjPtr, &tclStringType)) {
+	if (TclHasInternalRep(appendObjPtr, &tclStringType)) {
 	    Tcl_UniChar *unicode =
 		    Tcl_GetUnicodeFromObj(appendObjPtr, &numChars);

@@ -1464,7 +1464,7 @@ Tcl_AppendObjToObj(
    bytes = TclGetStringFromObj(appendObjPtr, &length);

    numChars = stringPtr->numChars;
-    if ((numChars >= 0) && TclHasIntRep(appendObjPtr, &tclStringType)) {
+    if ((numChars >= 0) && TclHasInternalRep(appendObjPtr, &tclStringType)) {
 	String *appendStringPtr = GET_STRING(appendObjPtr);

 	appendNumChars = appendStringPtr->numChars;
@@ -2869,7 +2869,7 @@ TclGetStringStorage(
 {
    String *stringPtr;

-    if (!TclHasIntRep(objPtr, &tclStringType) || objPtr->bytes == NULL) {
+    if (!TclHasInternalRep(objPtr, &tclStringType) || objPtr->bytes == NULL) {
 	return TclGetStringFromObj(objPtr, (int *)sizePtr);
    }

@@ -2917,7 +2917,7 @@ TclStringRepeat(
     */

    if (!binary) {
-	if (TclHasIntRep(objPtr, &tclStringType)) {
+	if (TclHasInternalRep(objPtr, &tclStringType)) {
 	    String *stringPtr = GET_STRING(objPtr);
 	    if (stringPtr->hasUnicode) {
 		unichar = 1;
@@ -3001,7 +3001,7 @@ TclStringRepeat(
 	if (!inPlace || Tcl_IsShared(objPtr)) {
 	    objResultPtr = Tcl_NewStringObj(Tcl_GetString(objPtr), length);
 	} else {
-	    TclFreeIntRep(objPtr);
+	    TclFreeInternalRep(objPtr);
 	    objResultPtr = objPtr;
 	}
        if (0 == Tcl_AttemptSetObjLength(objResultPtr, count*length)) {
@@ -3096,7 +3096,7 @@ TclStringCat(
 	} else {
 	    /* assert (objPtr->typePtr != NULL) -- stork! */
 	    binary = 0;
-	    if (TclHasIntRep(objPtr, &tclStringType)) {
+	    if (TclHasInternalRep(objPtr, &tclStringType)) {
 		/* Have a pure Unicode value; ask to preserve it */
 		requestUniChar = 1;
 	    } else {
@@ -3363,7 +3363,7 @@ TclStringCat(
 	    dst = Tcl_GetString(objResultPtr) + start;

 	    /* assert ( length > start ) */
-	    TclFreeIntRep(objResultPtr);
+	    TclFreeInternalRep(objResultPtr);
 	} else {
 	    TclNewObj(objResultPtr);	/* PANIC? */
 	    if (0 == Tcl_AttemptSetObjLength(objResultPtr, length)) {
@@ -3449,8 +3449,8 @@ TclStringCmp(
 	    s1 = (char *) Tcl_GetByteArrayFromObj(value1Ptr, &s1len);
 	    s2 = (char *) Tcl_GetByteArrayFromObj(value2Ptr, &s2len);
 	    memCmpFn = memcmp;
-	} else if (TclHasIntRep(value1Ptr, &tclStringType)
-		&& TclHasIntRep(value2Ptr, &tclStringType)) {
+	} else if (TclHasInternalRep(value1Ptr, &tclStringType)
+		&& TclHasInternalRep(value2Ptr, &tclStringType)) {
 	    /*
 	     * Do a unicode-specific comparison if both of the args are of
 	     * String type. If the char length == byte length, we can do a
@@ -4284,7 +4284,7 @@ SetStringFromAny(
    TCL_UNUSED(Tcl_Interp *),
    Tcl_Obj *objPtr)		/* The object to convert. */
 {
-    if (!TclHasIntRep(objPtr, &tclStringType)) {
+    if (!TclHasInternalRep(objPtr, &tclStringType)) {
 	String *stringPtr = stringAlloc(0);

 	/*
@@ -4292,10 +4292,10 @@ SetStringFromAny(
 	 */

 	(void) TclGetString(objPtr);
-	TclFreeIntRep(objPtr);
+	TclFreeInternalRep(objPtr);

 	/*
-	 * Create a basic String intrep that just points to the UTF-8 string
+	 * Create a basic String internalrep that just points to the UTF-8 string
 	 * already in place at objPtr->bytes.
 	 */

@@ -186,7 +186,7 @@ static const char *TclUtfPrev(const char *src, const char *start) {
 #define TclBN_s_mp_sub s_mp_sub
 #define TclBN_mp_toom_mul s_mp_toom_mul
 #define TclBN_mp_toom_sqr s_mp_toom_sqr
-#define TclUnusedStubEntry NULL
+#define TclUnusedStubEntry 0

 /* See bug 510001: TclSockMinimumBuffers needs plat imp */
 #if defined(_WIN64) || defined(TCL_NO_DEPRECATED) || TCL_MAJOR_VERSION > 8
@@ -1920,10 +1920,10 @@ const TclStubs tclStubs = {
    TclZipfs_Unmount, /* 633 */
    TclZipfs_TclLibrary, /* 634 */
    TclZipfs_MountBuffer, /* 635 */
-    Tcl_FreeIntRep, /* 636 */
+    Tcl_FreeInternalRep, /* 636 */
    Tcl_InitStringRep, /* 637 */
-    Tcl_FetchIntRep, /* 638 */
-    Tcl_StoreIntRep, /* 639 */
+    Tcl_FetchInternalRep, /* 638 */
+    Tcl_StoreInternalRep, /* 639 */
    Tcl_HasStringRep, /* 640 */
    Tcl_IncrRefCount, /* 641 */
    Tcl_DecrRefCount, /* 642 */
@@ -1942,6 +1942,9 @@ const TclStubs tclStubs = {
    Tcl_UtfNext, /* 655 */
    Tcl_UtfPrev, /* 656 */
    Tcl_UniCharIsUnicode, /* 657 */
+    0, /* 658 */
+    0, /* 659 */
+    Tcl_AsyncMarkFromSignal, /* 660 */
 };

 /* !END!: Do not edit above this line. */
@@ -163,9 +163,7 @@ static TestChannel *firstDetached;

 static int		AsyncHandlerProc(void *clientData,
 			    Tcl_Interp *interp, int code);
-#if TCL_THREADS
 static Tcl_ThreadCreateType AsyncThreadProc(void *);
-#endif
 static void		CleanupTestSetassocdataTests(
 			    void *clientData, Tcl_Interp *interp);
 static void		CmdDelProc1(void *clientData);
@@ -821,7 +819,6 @@ TestasyncCmd(
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(argv[3], -1));
 	Tcl_MutexUnlock(&asyncTestMutex);
 	return code;
-#if TCL_THREADS
    } else if (strcmp(argv[1], "marklater") == 0) {
 	if (argc != 3) {
 	    goto wrongNumArgs;
@@ -849,12 +846,6 @@ TestasyncCmd(
 	Tcl_AppendResult(interp, "bad option \"", argv[1],
 		"\": must be create, delete, int, mark, or marklater", NULL);
 	return TCL_ERROR;
-#else /* !TCL_THREADS */
-    } else {
-	Tcl_AppendResult(interp, "bad option \"", argv[1],
-		"\": must be create, delete, int, or mark", NULL);
-	return TCL_ERROR;
-#endif
    }
    return TCL_OK;
 }
@@ -920,7 +911,6 @@ AsyncHandlerProc(
 *----------------------------------------------------------------------
 */

-#if TCL_THREADS
 static Tcl_ThreadCreateType
 AsyncThreadProc(
    void *clientData)	/* Parameter is the id of a
@@ -942,7 +932,6 @@ AsyncThreadProc(
    Tcl_ExitThread(TCL_OK);
    TCL_THREAD_CREATE_RETURN;
 }
-#endif

 static int
 TestbumpinterpepochObjCmd(
@@ -1665,7 +1654,7 @@ TestdoubledigitsObjCmd(
    status = Tcl_GetDoubleFromObj(interp, objv[1], &d);
    if (status != TCL_OK) {
 	doubleType = Tcl_GetObjType("double");
-	if (Tcl_FetchIntRep(objv[1], doubleType)
+	if (Tcl_FetchInternalRep(objv[1], doubleType)
 	    && TclIsNaN(objv[1]->internalRep.doubleValue)) {
 	    status = TCL_OK;
 	    memcpy(&d, &(objv[1]->internalRep.doubleValue), sizeof(double));
@@ -1902,7 +1891,7 @@ TestencodingObjCmd(
 	}
 	Tcl_FreeEncoding(encoding);	/* Free returned reference */
 	Tcl_FreeEncoding(encoding);	/* Free to match CREATE */
-	TclFreeIntRep(objv[2]);		/* Free the cached ref */
+	TclFreeInternalRep(objv[2]);		/* Free the cached ref */
 	break;
    }
    return TCL_OK;
@@ -80,7 +80,7 @@ Tcl_GetThreadData(
    if (*keyPtr == NULL) {
 	result = ckalloc(size);
 	memset(result, 0, size);
-	*keyPtr = result;
+	*keyPtr = (Tcl_ThreadDataKey)result;
 	RememberSyncObject(keyPtr, &keyRecord);
    } else {
 	result = *keyPtr;
@@ -488,30 +488,30 @@ Tcl_ExitThread(
 #undef Tcl_ConditionWait
 void
 Tcl_ConditionWait(
-    Tcl_Condition *condPtr,	/* Really (pthread_cond_t **) */
-    Tcl_Mutex *mutexPtr,	/* Really (pthread_mutex_t **) */
-    const Tcl_Time *timePtr) /* Timeout on waiting period */
+    TCL_UNUSED(Tcl_Condition *),	/* Really (pthread_cond_t **) */
+    TCL_UNUSED(Tcl_Mutex *),	/* Really (pthread_mutex_t **) */
+    TCL_UNUSED(const Tcl_Time *)) /* Timeout on waiting period */
 {
 }

 #undef Tcl_ConditionNotify
 void
 Tcl_ConditionNotify(
-    Tcl_Condition *condPtr)
+    TCL_UNUSED(Tcl_Condition *))
 {
 }

 #undef Tcl_MutexLock
 void
 Tcl_MutexLock(
-    Tcl_Mutex *mutexPtr)
+    TCL_UNUSED(Tcl_Mutex *))
 {
 }

 #undef Tcl_MutexUnlock
 void
 Tcl_MutexUnlock(
-    Tcl_Mutex *mutexPtr)
+    TCL_UNUSED(Tcl_Mutex *))
 {
 }
 #endif /* !TCL_THREADS */
@@ -123,7 +123,7 @@ static int		FindElement(Tcl_Interp *interp, const char *string,
 * represents a list index in the form, "end-offset". It is used as a
 * performance optimization in Tcl_GetIntForIndex. The internal rep is
 * stored directly in the wideValue, so no memory management is required
- * for it. This is a caching intrep, keeping the result of a parse
+ * for it. This is a caching internalrep, keeping the result of a parse
 * around. This type is only created from a pre-existing string, so an
 * updateStringProc will never be called and need not exist. The type
 * is unregistered, so has no need of a setFromAnyProc either.
@@ -2589,7 +2589,7 @@ TclStringMatchObj(
    trivial = nocase ? 0 : TclMatchIsTrivial(TclGetString(ptnObj));
     */

-    if (TclHasIntRep(strObj, &tclStringType) || (strObj->typePtr == NULL)) {
+    if (TclHasInternalRep(strObj, &tclStringType) || (strObj->typePtr == NULL)) {
 	Tcl_UniChar *udata, *uptn;

 	udata = Tcl_GetUnicodeFromObj(strObj, &length);
@@ -3035,7 +3035,7 @@ Tcl_DStringGetResult(
 	    dsPtr->string = TclGetString(iPtr->objResultPtr);
 	    dsPtr->length = iPtr->objResultPtr->length;
 	    dsPtr->spaceAvl = dsPtr->length + 1;
-	    TclFreeIntRep(iPtr->objResultPtr);
+	    TclFreeInternalRep(iPtr->objResultPtr);
 	    iPtr->objResultPtr->bytes = &tclEmptyString;
 	    iPtr->objResultPtr->length = 0;
 	}
@@ -3752,12 +3752,12 @@ GetEndOffsetFromObj(
    Tcl_WideInt *widePtr)       /* Location filled in with an integer
                                 * representing an index. */
 {
-    Tcl_ObjIntRep *irPtr;
+    Tcl_ObjInternalRep *irPtr;
    Tcl_WideInt offset = -1;	/* Offset in the "end-offset" expression - 1 */
    ClientData cd;

-    while ((irPtr = TclFetchIntRep(objPtr, &endOffsetType)) == NULL) {
-	Tcl_ObjIntRep ir;
+    while ((irPtr = TclFetchInternalRep(objPtr, &endOffsetType)) == NULL) {
+	Tcl_ObjInternalRep ir;
 	int length;
 	const char *bytes = TclGetStringFromObj(objPtr, &length);

@@ -3816,8 +3816,8 @@ GetEndOffsetFromObj(
 			}
 		    }
 		}
-		/* Clear invalid intreps left by TclParseNumber */
-		TclFreeIntRep(objPtr);
+		/* Clear invalid internalreps left by TclParseNumber */
+		TclFreeInternalRep(objPtr);

 		if (t1 && t2) {
 		    /* We have both integer values */
@@ -3942,7 +3942,7 @@ GetEndOffsetFromObj(
    parseOK:
 	/* Success. Store the new internal rep. */
 	ir.wideValue = offset;
-	Tcl_StoreIntRep(objPtr, &endOffsetType, &ir);
+	Tcl_StoreInternalRep(objPtr, &endOffsetType, &ir);
    }

    offset = irPtr->wideValue;
@@ -4047,7 +4047,7 @@ TclIndexEncode(
    int idx;

    if (TCL_OK == GetWideForIndex(interp, objPtr, (unsigned)TCL_INDEX_END , &wide)) {
-	const Tcl_ObjIntRep *irPtr = TclFetchIntRep(objPtr, &endOffsetType);
+	const Tcl_ObjInternalRep *irPtr = TclFetchInternalRep(objPtr, &endOffsetType);
 	if (irPtr && irPtr->wideValue >= 0) {
 	    /* "int[+-]int" syntax, works the same here as "int" */
 	    irPtr = NULL;
@@ -4330,7 +4330,7 @@ TclSetProcessGlobalValue(

    /*
     * Fill the local thread copy directly with the Tcl_Obj value to avoid
-     * loss of the intrep. Increment newValue refCount early to handle case
+     * loss of the internalrep. Increment newValue refCount early to handle case
     * where we set a PGV to itself.
     */

@@ -253,20 +253,20 @@ static const Tcl_ObjType localVarNameType = {
    FreeLocalVarName, DupLocalVarName, NULL, NULL
 };

-#define LocalSetIntRep(objPtr, index, namePtr)				\
+#define LocalSetInternalRep(objPtr, index, namePtr)				\
    do {								\
-	Tcl_ObjIntRep ir;						\
+	Tcl_ObjInternalRep ir;						\
 	Tcl_Obj *ptr = (namePtr);					\
 	if (ptr) {Tcl_IncrRefCount(ptr);}				\
 	ir.twoPtrValue.ptr1 = ptr;					\
 	ir.twoPtrValue.ptr2 = INT2PTR(index);				\
-	Tcl_StoreIntRep((objPtr), &localVarNameType, &ir);		\
+	Tcl_StoreInternalRep((objPtr), &localVarNameType, &ir);		\
    } while (0)

-#define LocalGetIntRep(objPtr, index, name)				\
+#define LocalGetInternalRep(objPtr, index, name)				\
    do {								\
-	const Tcl_ObjIntRep *irPtr;					\
-	irPtr = TclFetchIntRep((objPtr), &localVarNameType);		\
+	const Tcl_ObjInternalRep *irPtr;					\
+	irPtr = TclFetchInternalRep((objPtr), &localVarNameType);		\
 	(name) = irPtr ? (Tcl_Obj *)irPtr->twoPtrValue.ptr1 : NULL;		\
 	(index) = irPtr ? PTR2INT(irPtr->twoPtrValue.ptr2) : -1;	\
    } while (0)
@@ -276,22 +276,22 @@ static const Tcl_ObjType parsedVarNameType = {
    FreeParsedVarName, DupParsedVarName, NULL, NULL
 };

-#define ParsedSetIntRep(objPtr, arrayPtr, elem)				\
+#define ParsedSetInternalRep(objPtr, arrayPtr, elem)				\
    do {								\
-	Tcl_ObjIntRep ir;						\
+	Tcl_ObjInternalRep ir;						\
 	Tcl_Obj *ptr1 = (arrayPtr);					\
 	Tcl_Obj *ptr2 = (elem);						\
 	if (ptr1) {Tcl_IncrRefCount(ptr1);}				\
 	if (ptr2) {Tcl_IncrRefCount(ptr2);}				\
 	ir.twoPtrValue.ptr1 = ptr1;					\
 	ir.twoPtrValue.ptr2 = ptr2;					\
-	Tcl_StoreIntRep((objPtr), &parsedVarNameType, &ir);		\
+	Tcl_StoreInternalRep((objPtr), &parsedVarNameType, &ir);		\
    } while (0)

-#define ParsedGetIntRep(objPtr, parsed, array, elem)			\
+#define ParsedGetInternalRep(objPtr, parsed, array, elem)			\
    do {								\
-	const Tcl_ObjIntRep *irPtr;					\
-	irPtr = TclFetchIntRep((objPtr), &parsedVarNameType);		\
+	const Tcl_ObjInternalRep *irPtr;					\
+	irPtr = TclFetchInternalRep((objPtr), &parsedVarNameType);		\
 	(parsed) = (irPtr != NULL);					\
 	(array) = irPtr ? (Tcl_Obj *)irPtr->twoPtrValue.ptr1 : NULL;		\
 	(elem) = irPtr ? (Tcl_Obj *)irPtr->twoPtrValue.ptr2 : NULL;		\
@@ -615,7 +615,7 @@ TclObjLookupVarEx(
    *arrayPtrPtr = NULL;

  restart:
-    LocalGetIntRep(part1Ptr, localIndex, namePtr);
+    LocalGetInternalRep(part1Ptr, localIndex, namePtr);
    if (localIndex >= 0) {
 	if (HasLocalVars(varFramePtr)
 		&& !(flags & (TCL_GLOBAL_ONLY | TCL_NAMESPACE_ONLY))
@@ -639,7 +639,7 @@ TclObjLookupVarEx(
     * If part1Ptr is a parsedVarNameType, retrieve the pre-parsed parts.
     */

-    ParsedGetIntRep(part1Ptr, parsed, arrayPtr, elem);
+    ParsedGetInternalRep(part1Ptr, parsed, arrayPtr, elem);
    if (parsed && arrayPtr) {
 	    if (part2Ptr != NULL) {
 		/*
@@ -685,7 +685,7 @@ TclObjLookupVarEx(
 		part2Ptr = Tcl_NewStringObj(part2 + 1,
 			len - (part2 - part1) - 2);

-		ParsedSetIntRep(part1Ptr, arrayPtr, part2Ptr);
+		ParsedSetInternalRep(part1Ptr, arrayPtr, part2Ptr);

 		part1Ptr = arrayPtr;
 	    }
@@ -721,16 +721,16 @@ TclObjLookupVarEx(
 	Tcl_Obj *cachedNamePtr = localName(varFramePtr, index);

 	if (part1Ptr == cachedNamePtr) {
-	    LocalSetIntRep(part1Ptr, index, NULL);
+	    LocalSetInternalRep(part1Ptr, index, NULL);
 	} else {
 	    /*
 	     * [80304238ac] Trickiness here.  We will store and incr the
 	     * refcount on cachedNamePtr.  Trouble is that it's possible
-	     * (see test var-22.1) for cachedNamePtr to have an intrep
+	     * (see test var-22.1) for cachedNamePtr to have an internalrep
 	     * that contains a stored and refcounted part1Ptr.  This
 	     * would be a reference cycle which leads to a memory leak.
 	     *
-	     * The solution here is to wipe away all intrep(s) in
+	     * The solution here is to wipe away all internalrep(s) in
 	     * cachedNamePtr and leave it as string only.  This is
 	     * radical and destructive, so a better idea would be welcome.
 	     */
@@ -739,24 +739,24 @@ TclObjLookupVarEx(
 	     * Firstly set cached local var reference (avoid free before set,
 	     * see [45b9faf103f2])
 	     */
-	    LocalSetIntRep(part1Ptr, index, cachedNamePtr);
+	    LocalSetInternalRep(part1Ptr, index, cachedNamePtr);

 	    /* Then wipe it */
-	    TclFreeIntRep(cachedNamePtr);
+	    TclFreeInternalRep(cachedNamePtr);

 	    /*
 	     * Now go ahead and convert it the the "localVarName" type,
 	     * since we suspect at least some use of the value as a
 	     * varname and we want to resolve it quickly.
 	     */
-	    LocalSetIntRep(cachedNamePtr, index, NULL);
+	    LocalSetInternalRep(cachedNamePtr, index, NULL);
 	}
    } else {
 	/*
 	 * At least mark part1Ptr as already parsed.
 	 */

-	ParsedSetIntRep(part1Ptr, NULL, NULL);
+	ParsedSetInternalRep(part1Ptr, NULL, NULL);
    }

  donePart1:
@@ -4115,7 +4115,7 @@ ArraySetCmd(
     */

    arrayElemObj = objv[2];
-    if (TclHasIntRep(arrayElemObj, &tclDictType) && arrayElemObj->bytes == NULL) {
+    if (TclHasInternalRep(arrayElemObj, &tclDictType) && arrayElemObj->bytes == NULL) {
 	Tcl_Obj *keyPtr, *valuePtr;
 	Tcl_DictSearch search;
 	int done;
@@ -5788,7 +5788,7 @@ FreeLocalVarName(
    int index;
    Tcl_Obj *namePtr;

-    LocalGetIntRep(objPtr, index, namePtr);
+    LocalGetInternalRep(objPtr, index, namePtr);

    index++;	/* Compiler warning bait. */
    if (namePtr) {
@@ -5804,11 +5804,11 @@ DupLocalVarName(
    int index;
    Tcl_Obj *namePtr;

-    LocalGetIntRep(srcPtr, index, namePtr);
+    LocalGetInternalRep(srcPtr, index, namePtr);
    if (!namePtr) {
 	namePtr = srcPtr;
    }
-    LocalSetIntRep(dupPtr, index, namePtr);
+    LocalSetInternalRep(dupPtr, index, namePtr);
 }

 /*
@@ -5827,7 +5827,7 @@ FreeParsedVarName(
    Tcl_Obj *arrayPtr, *elem;
    int parsed;

-    ParsedGetIntRep(objPtr, parsed, arrayPtr, elem);
+    ParsedGetInternalRep(objPtr, parsed, arrayPtr, elem);

    parsed++;				/* Silence compiler. */
    if (arrayPtr != NULL) {
@@ -5844,10 +5844,10 @@ DupParsedVarName(
    Tcl_Obj *arrayPtr, *elem;
    int parsed;

-    ParsedGetIntRep(srcPtr, parsed, arrayPtr, elem);
+    ParsedGetInternalRep(srcPtr, parsed, arrayPtr, elem);

    parsed++;				/* Silence compiler. */
-    ParsedSetIntRep(dupPtr, arrayPtr, elem);
+    ParsedSetInternalRep(dupPtr, arrayPtr, elem);
 }

 /*
@@ -3913,7 +3913,7 @@ TclZipfs_TclLibrary(void)
    }
 #elif !defined(NO_DLFCN_H)
    Dl_info dlinfo;
-    if (dladdr(TclZipfs_TclLibrary, &dlinfo) && (dlinfo.dli_fname != NULL)
+    if (dladdr((const void *)TclZipfs_TclLibrary, &dlinfo) && (dlinfo.dli_fname != NULL)
 	&& (ZipfsAppHookFindTclInit(dlinfo.dli_fname) == TCL_OK)) {
 	return Tcl_NewStringObj(zipfs_literal_tcl_library, -1);
    }
@@ -10,9 +10,9 @@
 #       initially implemented by Mary Ann May-Pumphrey of Sun
 #	Microsystems.
 #
-# Copyright (c) 1994-1997 Sun Microsystems, Inc.
-# Copyright (c) 1998-1999 Scriptics Corporation.
-# Copyright (c) 2000 Ajuba Solutions
+# Copyright © 1994-1997 Sun Microsystems, Inc.
+# Copyright © 1998-1999 Scriptics Corporation.
+# Copyright © 2000 Ajuba Solutions
 # Contributions from Don Porter, NIST, 2002.  (not subject to US copyright)
 # All rights reserved.

@@ -1,66 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-
-set TZData(:Africa/Accra) {
-    {-9223372036854775808 -52 0 LMT}
-    {-1709337548 0 0 GMT}
-    {-1581206400 1200 1 +0020}
-    {-1577917200 0 0 GMT}
-    {-1556834400 1200 1 +0020}
-    {-1546294800 0 0 GMT}
-    {-1525298400 1200 1 +0020}
-    {-1514758800 0 0 GMT}
-    {-1493762400 1200 1 +0020}
-    {-1483222800 0 0 GMT}
-    {-1462226400 1200 1 +0020}
-    {-1451686800 0 0 GMT}
-    {-1430604000 1200 1 +0020}
-    {-1420064400 0 0 GMT}
-    {-1399068000 1200 1 +0020}
-    {-1388528400 0 0 GMT}
-    {-1367532000 1200 1 +0020}
-    {-1356992400 0 0 GMT}
-    {-1335996000 1200 1 +0020}
-    {-1325456400 0 0 GMT}
-    {-1304373600 1200 1 +0020}
-    {-1293834000 0 0 GMT}
-    {-1272837600 1200 1 +0020}
-    {-1262298000 0 0 GMT}
-    {-1241301600 1200 1 +0020}
-    {-1230762000 0 0 GMT}
-    {-1209765600 1200 1 +0020}
-    {-1199226000 0 0 GMT}
-    {-1178143200 1200 1 +0020}
-    {-1167603600 0 0 GMT}
-    {-1146607200 1200 1 +0020}
-    {-1136067600 0 0 GMT}
-    {-1115071200 1200 1 +0020}
-    {-1104531600 0 0 GMT}
-    {-1083535200 1200 1 +0020}
-    {-1072995600 0 0 GMT}
-    {-1051912800 1200 1 +0020}
-    {-1041373200 0 0 GMT}
-    {-1020376800 1200 1 +0020}
-    {-1009837200 0 0 GMT}
-    {-988840800 1200 1 +0020}
-    {-978301200 0 0 GMT}
-    {-957304800 1200 1 +0020}
-    {-946765200 0 0 GMT}
-    {-936309600 1200 1 +0020}
-    {-915142800 0 0 GMT}
-    {-904773600 1200 1 +0020}
-    {-883606800 0 0 GMT}
-    {-880329600 1800 0 +0030}
-    {-756952200 0 0 GMT}
-    {-610149600 1800 1 +0030}
-    {-599610600 0 0 GMT}
-    {-578613600 1800 1 +0030}
-    {-568074600 0 0 GMT}
-    {-546991200 1800 1 +0030}
-    {-536452200 0 0 GMT}
-    {-515455200 1800 1 +0030}
-    {-504916200 0 0 GMT}
-    {-483919200 1800 1 +0030}
-    {-473380200 0 0 GMT}
-    {-452383200 1800 1 +0030}
-    {-441844200 0 0 GMT}
+if {![info exists TZData(Africa/Abidjan)]} {
+    LoadTimeZoneFile Africa/Abidjan
 }
+set TZData(:Africa/Accra) $TZData(:Africa/Abidjan)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/Anguilla) $TZData(:America/Port_of_Spain)
+set TZData(:America/Anguilla) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/Antigua) $TZData(:America/Port_of_Spain)
+set TZData(:America/Antigua) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Curacao)]} {
-    LoadTimeZoneFile America/Curacao
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/Aruba) $TZData(:America/Curacao)
+set TZData(:America/Aruba) $TZData(:America/Puerto_Rico)
@@ -1,12 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-
-set TZData(:America/Atikokan) {
-    {-9223372036854775808 -21988 0 LMT}
-    {-2366733212 -21600 0 CST}
-    {-1632067200 -18000 1 CDT}
-    {-1615136400 -21600 0 CST}
-    {-923248800 -18000 1 CDT}
-    {-880214400 -18000 0 CWT}
-    {-769395600 -18000 1 CPT}
-    {-765388800 -18000 0 EST}
+if {![info exists TZData(America/Panama)]} {
+    LoadTimeZoneFile America/Panama
 }
+set TZData(:America/Atikokan) $TZData(:America/Panama)
@@ -2,8 +2,15 @@

 set TZData(:America/Barbados) {
    {-9223372036854775808 -14309 0 LMT}
-    {-1451678491 -14309 0 BMT}
-    {-1199217691 -14400 0 AST}
+    {-1841256091 -14400 0 AST}
+    {-874263600 -10800 1 ADT}
+    {-862682400 -14400 0 AST}
+    {-841604400 -10800 1 ADT}
+    {-830714400 -14400 0 AST}
+    {-820526400 -14400 0 -0330}
+    {-811882800 -12600 1 AST}
+    {-798660000 -14400 0 -0330}
+    {-788904000 -14400 0 AST}
    {234943200 -10800 1 ADT}
    {244616400 -14400 0 AST}
    {261554400 -10800 1 ADT}
@@ -1,12 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-
-set TZData(:America/Blanc-Sablon) {
-    {-9223372036854775808 -13708 0 LMT}
-    {-2713896692 -14400 0 AST}
-    {-1632074400 -10800 1 ADT}
-    {-1615143600 -14400 0 AST}
-    {-880221600 -10800 1 AWT}
-    {-769395600 -10800 1 APT}
-    {-765399600 -14400 0 AST}
-    {14400 -14400 0 AST}
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
+set TZData(:America/Blanc-Sablon) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Atikokan)]} {
-    LoadTimeZoneFile America/Atikokan
+if {![info exists TZData(America/Panama)]} {
+    LoadTimeZoneFile America/Panama
 }
-set TZData(:America/Coral_Harbour) $TZData(:America/Atikokan)
+set TZData(:America/Coral_Harbour) $TZData(:America/Panama)
@@ -1,8 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-
-set TZData(:America/Creston) {
-    {-9223372036854775808 -27964 0 LMT}
-    {-2713882436 -25200 0 MST}
-    {-1680454800 -28800 0 PST}
-    {-1627833600 -25200 0 MST}
+if {![info exists TZData(America/Phoenix)]} {
+    LoadTimeZoneFile America/Phoenix
 }
+set TZData(:America/Creston) $TZData(:America/Phoenix)
@@ -1,7 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-
-set TZData(:America/Curacao) {
-    {-9223372036854775808 -16547 0 LMT}
-    {-1826738653 -16200 0 -0430}
-    {-157750200 -14400 0 AST}
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
+set TZData(:America/Curacao) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/Dominica) $TZData(:America/Port_of_Spain)
+set TZData(:America/Dominica) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/Grenada) $TZData(:America/Port_of_Spain)
+set TZData(:America/Grenada) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/Guadeloupe) $TZData(:America/Port_of_Spain)
+set TZData(:America/Guadeloupe) $TZData(:America/Puerto_Rico)
@@ -1,8 +1,9 @@
 # created by tools/tclZIC.tcl - do not edit

 set TZData(:America/Guyana) {
-    {-9223372036854775808 -13960 0 LMT}
-    {-1730578040 -13500 0 -0345}
-    {176010300 -10800 0 -03}
-    {662698800 -14400 0 -04}
+    {-9223372036854775808 -13959 0 LMT}
+    {-1843589241 -14400 0 -04}
+    {-1730577600 -13500 0 -0345}
+    {176096700 -10800 0 -03}
+    {701841600 -14400 0 -04}
 }
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Curacao)]} {
-    LoadTimeZoneFile America/Curacao
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/Kralendijk) $TZData(:America/Curacao)
+set TZData(:America/Kralendijk) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Curacao)]} {
-    LoadTimeZoneFile America/Curacao
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/Lower_Princes) $TZData(:America/Curacao)
+set TZData(:America/Lower_Princes) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/Marigot) $TZData(:America/Port_of_Spain)
+set TZData(:America/Marigot) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/Montserrat) $TZData(:America/Port_of_Spain)
+set TZData(:America/Montserrat) $TZData(:America/Puerto_Rico)
@@ -1,284 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-
-set TZData(:America/Nassau) {
-    {-9223372036854775808 -18570 0 LMT}
-    {-1825095030 -18000 0 EST}
-    {-873140400 -14400 1 EWT}
-    {-788904000 -18000 0 EST}
-    {-786222000 -14400 1 EWT}
-    {-769395600 -14400 1 EPT}
-    {-763848000 -18000 0 EST}
-    {-179341200 -14400 1 EDT}
-    {-163620000 -18000 0 EST}
-    {-147891600 -14400 1 EDT}
-    {-131565600 -18000 0 EST}
-    {-116442000 -14400 1 EDT}
-    {-100116000 -18000 0 EST}
-    {-84387600 -14400 1 EDT}
-    {-68666400 -18000 0 EST}
-    {-52938000 -14400 1 EDT}
-    {-37216800 -18000 0 EST}
-    {-21488400 -14400 1 EDT}
-    {-5767200 -18000 0 EST}
-    {9961200 -14400 1 EDT}
-    {25682400 -18000 0 EST}
-    {41410800 -14400 1 EDT}
-    {57736800 -18000 0 EST}
-    {73465200 -14400 1 EDT}
-    {89186400 -18000 0 EST}
-    {104914800 -14400 1 EDT}
-    {120636000 -18000 0 EST}
-    {136364400 -14400 1 EDT}
-    {152085600 -18000 0 EST}
-    {167814000 -14400 1 EDT}
-    {183535200 -18000 0 EST}
-    {189320400 -18000 0 EST}
-    {199263600 -14400 1 EDT}
-    {215589600 -18000 0 EST}
-    {230713200 -14400 1 EDT}
-    {247039200 -18000 0 EST}
-    {262767600 -14400 1 EDT}
-    {278488800 -18000 0 EST}
-    {294217200 -14400 1 EDT}
-    {309938400 -18000 0 EST}
-    {325666800 -14400 1 EDT}
-    {341388000 -18000 0 EST}
-    {357116400 -14400 1 EDT}
-    {372837600 -18000 0 EST}
-    {388566000 -14400 1 EDT}
-    {404892000 -18000 0 EST}
-    {420015600 -14400 1 EDT}
-    {436341600 -18000 0 EST}
-    {452070000 -14400 1 EDT}
-    {467791200 -18000 0 EST}
-    {483519600 -14400 1 EDT}
-    {499240800 -18000 0 EST}
-    {514969200 -14400 1 EDT}
-    {530690400 -18000 0 EST}
-    {544604400 -14400 1 EDT}
-    {562140000 -18000 0 EST}
-    {576054000 -14400 1 EDT}
-    {594194400 -18000 0 EST}
-    {607503600 -14400 1 EDT}
-    {625644000 -18000 0 EST}
-    {638953200 -14400 1 EDT}
-    {657093600 -18000 0 EST}
-    {671007600 -14400 1 EDT}
-    {688543200 -18000 0 EST}
-    {702457200 -14400 1 EDT}
-    {719992800 -18000 0 EST}
-    {733906800 -14400 1 EDT}
-    {752047200 -18000 0 EST}
-    {765356400 -14400 1 EDT}
-    {783496800 -18000 0 EST}
-    {796806000 -14400 1 EDT}
-    {814946400 -18000 0 EST}
-    {828860400 -14400 1 EDT}
-    {846396000 -18000 0 EST}
-    {860310000 -14400 1 EDT}
-    {877845600 -18000 0 EST}
-    {891759600 -14400 1 EDT}
-    {909295200 -18000 0 EST}
-    {923209200 -14400 1 EDT}
-    {941349600 -18000 0 EST}
-    {954658800 -14400 1 EDT}
-    {972799200 -18000 0 EST}
-    {986108400 -14400 1 EDT}
-    {1004248800 -18000 0 EST}
-    {1018162800 -14400 1 EDT}
-    {1035698400 -18000 0 EST}
-    {1049612400 -14400 1 EDT}
-    {1067148000 -18000 0 EST}
-    {1081062000 -14400 1 EDT}
-    {1099202400 -18000 0 EST}
-    {1112511600 -14400 1 EDT}
-    {1130652000 -18000 0 EST}
-    {1143961200 -14400 1 EDT}
-    {1162101600 -18000 0 EST}
-    {1173596400 -14400 1 EDT}
-    {1194156000 -18000 0 EST}
-    {1205046000 -14400 1 EDT}
-    {1225605600 -18000 0 EST}
-    {1236495600 -14400 1 EDT}
-    {1257055200 -18000 0 EST}
-    {1268550000 -14400 1 EDT}
-    {1289109600 -18000 0 EST}
-    {1299999600 -14400 1 EDT}
-    {1320559200 -18000 0 EST}
-    {1331449200 -14400 1 EDT}
-    {1352008800 -18000 0 EST}
-    {1362898800 -14400 1 EDT}
-    {1383458400 -18000 0 EST}
-    {1394348400 -14400 1 EDT}
-    {1414908000 -18000 0 EST}
-    {1425798000 -14400 1 EDT}
-    {1446357600 -18000 0 EST}
-    {1457852400 -14400 1 EDT}
-    {1478412000 -18000 0 EST}
-    {1489302000 -14400 1 EDT}
-    {1509861600 -18000 0 EST}
-    {1520751600 -14400 1 EDT}
-    {1541311200 -18000 0 EST}
-    {1552201200 -14400 1 EDT}
-    {1572760800 -18000 0 EST}
-    {1583650800 -14400 1 EDT}
-    {1604210400 -18000 0 EST}
-    {1615705200 -14400 1 EDT}
-    {1636264800 -18000 0 EST}
-    {1647154800 -14400 1 EDT}
-    {1667714400 -18000 0 EST}
-    {1678604400 -14400 1 EDT}
-    {1699164000 -18000 0 EST}
-    {1710054000 -14400 1 EDT}
-    {1730613600 -18000 0 EST}
-    {1741503600 -14400 1 EDT}
-    {1762063200 -18000 0 EST}
-    {1772953200 -14400 1 EDT}
-    {1793512800 -18000 0 EST}
-    {1805007600 -14400 1 EDT}
-    {1825567200 -18000 0 EST}
-    {1836457200 -14400 1 EDT}
-    {1857016800 -18000 0 EST}
-    {1867906800 -14400 1 EDT}
-    {1888466400 -18000 0 EST}
-    {1899356400 -14400 1 EDT}
-    {1919916000 -18000 0 EST}
-    {1930806000 -14400 1 EDT}
-    {1951365600 -18000 0 EST}
-    {1962860400 -14400 1 EDT}
-    {1983420000 -18000 0 EST}
-    {1994310000 -14400 1 EDT}
-    {2014869600 -18000 0 EST}
-    {2025759600 -14400 1 EDT}
-    {2046319200 -18000 0 EST}
-    {2057209200 -14400 1 EDT}
-    {2077768800 -18000 0 EST}
-    {2088658800 -14400 1 EDT}
-    {2109218400 -18000 0 EST}
-    {2120108400 -14400 1 EDT}
-    {2140668000 -18000 0 EST}
-    {2152162800 -14400 1 EDT}
-    {2172722400 -18000 0 EST}
-    {2183612400 -14400 1 EDT}
-    {2204172000 -18000 0 EST}
-    {2215062000 -14400 1 EDT}
-    {2235621600 -18000 0 EST}
-    {2246511600 -14400 1 EDT}
-    {2267071200 -18000 0 EST}
-    {2277961200 -14400 1 EDT}
-    {2298520800 -18000 0 EST}
-    {2309410800 -14400 1 EDT}
-    {2329970400 -18000 0 EST}
-    {2341465200 -14400 1 EDT}
-    {2362024800 -18000 0 EST}
-    {2372914800 -14400 1 EDT}
-    {2393474400 -18000 0 EST}
-    {2404364400 -14400 1 EDT}
-    {2424924000 -18000 0 EST}
-    {2435814000 -14400 1 EDT}
-    {2456373600 -18000 0 EST}
-    {2467263600 -14400 1 EDT}
-    {2487823200 -18000 0 EST}
-    {2499318000 -14400 1 EDT}
-    {2519877600 -18000 0 EST}
-    {2530767600 -14400 1 EDT}
-    {2551327200 -18000 0 EST}
-    {2562217200 -14400 1 EDT}
-    {2582776800 -18000 0 EST}
-    {2593666800 -14400 1 EDT}
-    {2614226400 -18000 0 EST}
-    {2625116400 -14400 1 EDT}
-    {2645676000 -18000 0 EST}
-    {2656566000 -14400 1 EDT}
-    {2677125600 -18000 0 EST}
-    {2688620400 -14400 1 EDT}
-    {2709180000 -18000 0 EST}
-    {2720070000 -14400 1 EDT}
-    {2740629600 -18000 0 EST}
-    {2751519600 -14400 1 EDT}
-    {2772079200 -18000 0 EST}
-    {2782969200 -14400 1 EDT}
-    {2803528800 -18000 0 EST}
-    {2814418800 -14400 1 EDT}
-    {2834978400 -18000 0 EST}
-    {2846473200 -14400 1 EDT}
-    {2867032800 -18000 0 EST}
-    {2877922800 -14400 1 EDT}
-    {2898482400 -18000 0 EST}
-    {2909372400 -14400 1 EDT}
-    {2929932000 -18000 0 EST}
-    {2940822000 -14400 1 EDT}
-    {2961381600 -18000 0 EST}
-    {2972271600 -14400 1 EDT}
-    {2992831200 -18000 0 EST}
-    {3003721200 -14400 1 EDT}
-    {3024280800 -18000 0 EST}
-    {3035775600 -14400 1 EDT}
-    {3056335200 -18000 0 EST}
-    {3067225200 -14400 1 EDT}
-    {3087784800 -18000 0 EST}
-    {3098674800 -14400 1 EDT}
-    {3119234400 -18000 0 EST}
-    {3130124400 -14400 1 EDT}
-    {3150684000 -18000 0 EST}
-    {3161574000 -14400 1 EDT}
-    {3182133600 -18000 0 EST}
-    {3193023600 -14400 1 EDT}
-    {3213583200 -18000 0 EST}
-    {3225078000 -14400 1 EDT}
-    {3245637600 -18000 0 EST}
-    {3256527600 -14400 1 EDT}
-    {3277087200 -18000 0 EST}
-    {3287977200 -14400 1 EDT}
-    {3308536800 -18000 0 EST}
-    {3319426800 -14400 1 EDT}
-    {3339986400 -18000 0 EST}
-    {3350876400 -14400 1 EDT}
-    {3371436000 -18000 0 EST}
-    {3382930800 -14400 1 EDT}
-    {3403490400 -18000 0 EST}
-    {3414380400 -14400 1 EDT}
-    {3434940000 -18000 0 EST}
-    {3445830000 -14400 1 EDT}
-    {3466389600 -18000 0 EST}
-    {3477279600 -14400 1 EDT}
-    {3497839200 -18000 0 EST}
-    {3508729200 -14400 1 EDT}
-    {3529288800 -18000 0 EST}
-    {3540178800 -14400 1 EDT}
-    {3560738400 -18000 0 EST}
-    {3572233200 -14400 1 EDT}
-    {3592792800 -18000 0 EST}
-    {3603682800 -14400 1 EDT}
-    {3624242400 -18000 0 EST}
-    {3635132400 -14400 1 EDT}
-    {3655692000 -18000 0 EST}
-    {3666582000 -14400 1 EDT}
-    {3687141600 -18000 0 EST}
-    {3698031600 -14400 1 EDT}
-    {3718591200 -18000 0 EST}
-    {3730086000 -14400 1 EDT}
-    {3750645600 -18000 0 EST}
-    {3761535600 -14400 1 EDT}
-    {3782095200 -18000 0 EST}
-    {3792985200 -14400 1 EDT}
-    {3813544800 -18000 0 EST}
-    {3824434800 -14400 1 EDT}
-    {3844994400 -18000 0 EST}
-    {3855884400 -14400 1 EDT}
-    {3876444000 -18000 0 EST}
-    {3887334000 -14400 1 EDT}
-    {3907893600 -18000 0 EST}
-    {3919388400 -14400 1 EDT}
-    {3939948000 -18000 0 EST}
-    {3950838000 -14400 1 EDT}
-    {3971397600 -18000 0 EST}
-    {3982287600 -14400 1 EDT}
-    {4002847200 -18000 0 EST}
-    {4013737200 -14400 1 EDT}
-    {4034296800 -18000 0 EST}
-    {4045186800 -14400 1 EDT}
-    {4065746400 -18000 0 EST}
-    {4076636400 -14400 1 EDT}
-    {4097196000 -18000 0 EST}
+if {![info exists TZData(America/Toronto)]} {
+    LoadTimeZoneFile America/Toronto
 }
+set TZData(:America/Nassau) $TZData(:America/Toronto)
@@ -1,6 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-
-set TZData(:America/Port_of_Spain) {
-    {-9223372036854775808 -14764 0 LMT}
-    {-1825098836 -14400 0 AST}
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
+set TZData(:America/Port_of_Spain) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/St_Barthelemy) $TZData(:America/Port_of_Spain)
+set TZData(:America/St_Barthelemy) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/St_Kitts) $TZData(:America/Port_of_Spain)
+set TZData(:America/St_Kitts) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/St_Lucia) $TZData(:America/Port_of_Spain)
+set TZData(:America/St_Lucia) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/St_Thomas) $TZData(:America/Port_of_Spain)
+set TZData(:America/St_Thomas) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/St_Vincent) $TZData(:America/Port_of_Spain)
+set TZData(:America/St_Vincent) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/Tortola) $TZData(:America/Port_of_Spain)
+set TZData(:America/Tortola) $TZData(:America/Puerto_Rico)
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(America/Port_of_Spain)]} {
-    LoadTimeZoneFile America/Port_of_Spain
+if {![info exists TZData(America/Puerto_Rico)]} {
+    LoadTimeZoneFile America/Puerto_Rico
 }
-set TZData(:America/Virgin) $TZData(:America/Port_of_Spain)
+set TZData(:America/Virgin) $TZData(:America/Puerto_Rico)
@@ -1,8 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-
-set TZData(:Antarctica/DumontDUrville) {
-    {-9223372036854775808 0 0 -00}
-    {-725846400 36000 0 +10}
-    {-566992800 0 0 -00}
-    {-415497600 36000 0 +10}
+if {![info exists TZData(Pacific/Port_Moresby)]} {
+    LoadTimeZoneFile Pacific/Port_Moresby
 }
+set TZData(:Antarctica/DumontDUrville) $TZData(:Pacific/Port_Moresby)
@@ -1,6 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-
-set TZData(:Antarctica/Syowa) {
-    {-9223372036854775808 0 0 -00}
-    {-407808000 10800 0 +03}
+if {![info exists TZData(Asia/Riyadh)]} {
+    LoadTimeZoneFile Asia/Riyadh
 }
+set TZData(:Antarctica/Syowa) $TZData(:Asia/Riyadh)
@@ -87,160 +87,160 @@ set TZData(:Asia/Amman) {
    {1604008800 7200 0 EET}
    {1616709600 10800 1 EEST}
    {1635458400 7200 0 EET}
-    {1648764000 10800 1 EEST}
+    {1645740000 10800 1 EEST}
    {1666908000 7200 0 EET}
-    {1680213600 10800 1 EEST}
+    {1677189600 10800 1 EEST}
    {1698357600 7200 0 EET}
-    {1711663200 10800 1 EEST}
+    {1709244000 10800 1 EEST}
    {1729807200 7200 0 EET}
-    {1743112800 10800 1 EEST}
+    {1740693600 10800 1 EEST}
    {1761861600 7200 0 EET}
-    {1774562400 10800 1 EEST}
+    {1772143200 10800 1 EEST}
    {1793311200 7200 0 EET}
-    {1806012000 10800 1 EEST}
+    {1803592800 10800 1 EEST}
    {1824760800 7200 0 EET}
-    {1838066400 10800 1 EEST}
+    {1835042400 10800 1 EEST}
    {1856210400 7200 0 EET}
-    {1869516000 10800 1 EEST}
+    {1866492000 10800 1 EEST}
    {1887660000 7200 0 EET}
-    {1900965600 10800 1 EEST}
+    {1898546400 10800 1 EEST}
    {1919109600 7200 0 EET}
-    {1932415200 10800 1 EEST}
+    {1929996000 10800 1 EEST}
    {1951164000 7200 0 EET}
-    {1963864800 10800 1 EEST}
+    {1961445600 10800 1 EEST}
    {1982613600 7200 0 EET}
-    {1995919200 10800 1 EEST}
+    {1992895200 10800 1 EEST}
    {2014063200 7200 0 EET}
-    {2027368800 10800 1 EEST}
+    {2024344800 10800 1 EEST}
    {2045512800 7200 0 EET}
-    {2058818400 10800 1 EEST}
+    {2055794400 10800 1 EEST}
    {2076962400 7200 0 EET}
-    {2090268000 10800 1 EEST}
+    {2087848800 10800 1 EEST}
    {2109016800 7200 0 EET}
-    {2121717600 10800 1 EEST}
+    {2119298400 10800 1 EEST}
    {2140466400 7200 0 EET}
-    {2153167200 10800 1 EEST}
+    {2150748000 10800 1 EEST}
    {2171916000 7200 0 EET}
-    {2185221600 10800 1 EEST}
+    {2182197600 10800 1 EEST}
    {2203365600 7200 0 EET}
-    {2216671200 10800 1 EEST}
+    {2213647200 10800 1 EEST}
    {2234815200 7200 0 EET}
-    {2248120800 10800 1 EEST}
+    {2245701600 10800 1 EEST}
    {2266264800 7200 0 EET}
-    {2279570400 10800 1 EEST}
+    {2277151200 10800 1 EEST}
    {2298319200 7200 0 EET}
-    {2311020000 10800 1 EEST}
+    {2308600800 10800 1 EEST}
    {2329768800 7200 0 EET}
-    {2343074400 10800 1 EEST}
+    {2340050400 10800 1 EEST}
    {2361218400 7200 0 EET}
-    {2374524000 10800 1 EEST}
+    {2371500000 10800 1 EEST}
    {2392668000 7200 0 EET}
-    {2405973600 10800 1 EEST}
+    {2402949600 10800 1 EEST}
    {2424117600 7200 0 EET}
-    {2437423200 10800 1 EEST}
+    {2435004000 10800 1 EEST}
    {2455567200 7200 0 EET}
-    {2468872800 10800 1 EEST}
+    {2466453600 10800 1 EEST}
    {2487621600 7200 0 EET}
-    {2500322400 10800 1 EEST}
+    {2497903200 10800 1 EEST}
    {2519071200 7200 0 EET}
-    {2532376800 10800 1 EEST}
+    {2529352800 10800 1 EEST}
    {2550520800 7200 0 EET}
-    {2563826400 10800 1 EEST}
+    {2560802400 10800 1 EEST}
    {2581970400 7200 0 EET}
-    {2595276000 10800 1 EEST}
+    {2592856800 10800 1 EEST}
    {2613420000 7200 0 EET}
-    {2626725600 10800 1 EEST}
+    {2624306400 10800 1 EEST}
    {2645474400 7200 0 EET}
-    {2658175200 10800 1 EEST}
+    {2655756000 10800 1 EEST}
    {2676924000 7200 0 EET}
-    {2689624800 10800 1 EEST}
+    {2687205600 10800 1 EEST}
    {2708373600 7200 0 EET}
-    {2721679200 10800 1 EEST}
+    {2718655200 10800 1 EEST}
    {2739823200 7200 0 EET}
-    {2753128800 10800 1 EEST}
+    {2750104800 10800 1 EEST}
    {2771272800 7200 0 EET}
-    {2784578400 10800 1 EEST}
+    {2782159200 10800 1 EEST}
    {2802722400 7200 0 EET}
-    {2816028000 10800 1 EEST}
+    {2813608800 10800 1 EEST}
    {2834776800 7200 0 EET}
-    {2847477600 10800 1 EEST}
+    {2845058400 10800 1 EEST}
    {2866226400 7200 0 EET}
-    {2879532000 10800 1 EEST}
+    {2876508000 10800 1 EEST}
    {2897676000 7200 0 EET}
-    {2910981600 10800 1 EEST}
+    {2907957600 10800 1 EEST}
    {2929125600 7200 0 EET}
-    {2942431200 10800 1 EEST}
+    {2939407200 10800 1 EEST}
    {2960575200 7200 0 EET}
-    {2973880800 10800 1 EEST}
+    {2971461600 10800 1 EEST}
    {2992629600 7200 0 EET}
-    {3005330400 10800 1 EEST}
+    {3002911200 10800 1 EEST}
    {3024079200 7200 0 EET}
-    {3036780000 10800 1 EEST}
+    {3034360800 10800 1 EEST}
    {3055528800 7200 0 EET}
-    {3068834400 10800 1 EEST}
+    {3065810400 10800 1 EEST}
    {3086978400 7200 0 EET}
-    {3100284000 10800 1 EEST}
+    {3097260000 10800 1 EEST}
    {3118428000 7200 0 EET}
-    {3131733600 10800 1 EEST}
+    {3129314400 10800 1 EEST}
    {3149877600 7200 0 EET}
-    {3163183200 10800 1 EEST}
+    {3160764000 10800 1 EEST}
    {3181932000 7200 0 EET}
-    {3194632800 10800 1 EEST}
+    {3192213600 10800 1 EEST}
    {3213381600 7200 0 EET}
-    {3226687200 10800 1 EEST}
+    {3223663200 10800 1 EEST}
    {3244831200 7200 0 EET}
-    {3258136800 10800 1 EEST}
+    {3255112800 10800 1 EEST}
    {3276280800 7200 0 EET}
-    {3289586400 10800 1 EEST}
+    {3286562400 10800 1 EEST}
    {3307730400 7200 0 EET}
-    {3321036000 10800 1 EEST}
+    {3318616800 10800 1 EEST}
    {3339180000 7200 0 EET}
-    {3352485600 10800 1 EEST}
+    {3350066400 10800 1 EEST}
    {3371234400 7200 0 EET}
-    {3383935200 10800 1 EEST}
+    {3381516000 10800 1 EEST}
    {3402684000 7200 0 EET}
-    {3415989600 10800 1 EEST}
+    {3412965600 10800 1 EEST}
    {3434133600 7200 0 EET}
-    {3447439200 10800 1 EEST}
+    {3444415200 10800 1 EEST}
    {3465583200 7200 0 EET}
-    {3478888800 10800 1 EEST}
+    {3476469600 10800 1 EEST}
    {3497032800 7200 0 EET}
-    {3510338400 10800 1 EEST}
+    {3507919200 10800 1 EEST}
    {3529087200 7200 0 EET}
-    {3541788000 10800 1 EEST}
+    {3539368800 10800 1 EEST}
    {3560536800 7200 0 EET}
-    {3573237600 10800 1 EEST}
+    {3570818400 10800 1 EEST}
    {3591986400 7200 0 EET}
-    {3605292000 10800 1 EEST}
+    {3602268000 10800 1 EEST}
    {3623436000 7200 0 EET}
-    {3636741600 10800 1 EEST}
+    {3633717600 10800 1 EEST}
    {3654885600 7200 0 EET}
-    {3668191200 10800 1 EEST}
+    {3665772000 10800 1 EEST}
    {3686335200 7200 0 EET}
-    {3699640800 10800 1 EEST}
+    {3697221600 10800 1 EEST}
    {3718389600 7200 0 EET}
-    {3731090400 10800 1 EEST}
+    {3728671200 10800 1 EEST}
    {3749839200 7200 0 EET}
-    {3763144800 10800 1 EEST}
+    {3760120800 10800 1 EEST}
    {3781288800 7200 0 EET}
-    {3794594400 10800 1 EEST}
+    {3791570400 10800 1 EEST}
    {3812738400 7200 0 EET}
-    {3826044000 10800 1 EEST}
+    {3823020000 10800 1 EEST}
    {3844188000 7200 0 EET}
-    {3857493600 10800 1 EEST}
+    {3855074400 10800 1 EEST}
    {3876242400 7200 0 EET}
-    {3888943200 10800 1 EEST}
+    {3886524000 10800 1 EEST}
    {3907692000 7200 0 EET}
-    {3920392800 10800 1 EEST}
+    {3917973600 10800 1 EEST}
    {3939141600 7200 0 EET}
-    {3952447200 10800 1 EEST}
+    {3949423200 10800 1 EEST}
    {3970591200 7200 0 EET}
-    {3983896800 10800 1 EEST}
+    {3980872800 10800 1 EEST}
    {4002040800 7200 0 EET}
-    {4015346400 10800 1 EEST}
+    {4012927200 10800 1 EEST}
    {4033490400 7200 0 EET}
-    {4046796000 10800 1 EEST}
+    {4044376800 10800 1 EEST}
    {4065544800 7200 0 EET}
-    {4078245600 10800 1 EEST}
+    {4075826400 10800 1 EEST}
    {4096994400 7200 0 EET}
 }
@@ -66,6 +66,8 @@ set TZData(:Atlantic/Azores) {
    {-670449600 -7200 0 -02}
    {-654724800 -3600 1 -01}
    {-639000000 -7200 0 -02}
+    {-623275200 -3600 1 -01}
+    {-607550400 -7200 0 -02}
    {-591825600 -3600 1 -01}
    {-575496000 -7200 0 -02}
    {-559771200 -3600 1 -01}
@@ -1,5 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-if {![info exists TZData(Europe/Oslo)]} {
-    LoadTimeZoneFile Europe/Oslo
+if {![info exists TZData(Europe/Berlin)]} {
+    LoadTimeZoneFile Europe/Berlin
 }
-set TZData(:Atlantic/Jan_Mayen) $TZData(:Europe/Oslo)
+set TZData(:Atlantic/Jan_Mayen) $TZData(:Europe/Berlin)
@@ -66,6 +66,8 @@ set TZData(:Atlantic/Madeira) {
    {-670453200 -3600 0 -01}
    {-654728400 0 1 +00}
    {-639003600 -3600 0 -01}
+    {-623278800 0 1 +00}
+    {-607554000 -3600 0 -01}
    {-591829200 0 1 +00}
    {-575499600 -3600 0 -01}
    {-559774800 0 1 +00}
@@ -70,6 +70,8 @@ set TZData(:Europe/Lisbon) {
    {-670456800 0 0 WET}
    {-654732000 3600 1 WEST}
    {-639007200 0 0 WET}
+    {-623282400 3600 1 WEST}
+    {-607557600 0 0 WET}
    {-591832800 3600 1 WEST}
    {-575503200 0 0 WET}
    {-559778400 3600 1 WEST}
@@ -28,161 +28,4 @@ set TZData(:Pacific/Apia) {
    {1586008800 46800 0 +13}
    {1601128800 50400 1 +13}
    {1617458400 46800 0 +13}
-    {1632578400 50400 1 +13}
-    {1648908000 46800 0 +13}
-    {1664028000 50400 1 +13}
-    {1680357600 46800 0 +13}
-    {1695477600 50400 1 +13}
-    {1712412000 46800 0 +13}
-    {1727532000 50400 1 +13}
-    {1743861600 46800 0 +13}
-    {1758981600 50400 1 +13}
-    {1775311200 46800 0 +13}
-    {1790431200 50400 1 +13}
-    {1806760800 46800 0 +13}
-    {1821880800 50400 1 +13}
-    {1838210400 46800 0 +13}
-    {1853330400 50400 1 +13}
-    {1869660000 46800 0 +13}
-    {1885384800 50400 1 +13}
-    {1901714400 46800 0 +13}
-    {1916834400 50400 1 +13}
-    {1933164000 46800 0 +13}
-    {1948284000 50400 1 +13}
-    {1964613600 46800 0 +13}
-    {1979733600 50400 1 +13}
-    {1996063200 46800 0 +13}
-    {2011183200 50400 1 +13}
-    {2027512800 46800 0 +13}
-    {2042632800 50400 1 +13}
-    {2058962400 46800 0 +13}
-    {2074687200 50400 1 +13}
-    {2091016800 46800 0 +13}
-    {2106136800 50400 1 +13}
-    {2122466400 46800 0 +13}
-    {2137586400 50400 1 +13}
-    {2153916000 46800 0 +13}
-    {2169036000 50400 1 +13}
-    {2185365600 46800 0 +13}
-    {2200485600 50400 1 +13}
-    {2216815200 46800 0 +13}
-    {2232540000 50400 1 +13}
-    {2248869600 46800 0 +13}
-    {2263989600 50400 1 +13}
-    {2280319200 46800 0 +13}
-    {2295439200 50400 1 +13}
-    {2311768800 46800 0 +13}
-    {2326888800 50400 1 +13}
-    {2343218400 46800 0 +13}
-    {2358338400 50400 1 +13}
-    {2374668000 46800 0 +13}
-    {2389788000 50400 1 +13}
-    {2406117600 46800 0 +13}
-    {2421842400 50400 1 +13}
-    {2438172000 46800 0 +13}
-    {2453292000 50400 1 +13}
-    {2469621600 46800 0 +13}
-    {2484741600 50400 1 +13}
-    {2501071200 46800 0 +13}
-    {2516191200 50400 1 +13}
-    {2532520800 46800 0 +13}
-    {2547640800 50400 1 +13}
-    {2563970400 46800 0 +13}
-    {2579090400 50400 1 +13}
-    {2596024800 46800 0 +13}
-    {2611144800 50400 1 +13}
-    {2627474400 46800 0 +13}
-    {2642594400 50400 1 +13}
-    {2658924000 46800 0 +13}
-    {2674044000 50400 1 +13}
-    {2690373600 46800 0 +13}
-    {2705493600 50400 1 +13}
-    {2721823200 46800 0 +13}
-    {2736943200 50400 1 +13}
-    {2753272800 46800 0 +13}
-    {2768997600 50400 1 +13}
-    {2785327200 46800 0 +13}
-    {2800447200 50400 1 +13}
-    {2816776800 46800 0 +13}
-    {2831896800 50400 1 +13}
-    {2848226400 46800 0 +13}
-    {2863346400 50400 1 +13}
-    {2879676000 46800 0 +13}
-    {2894796000 50400 1 +13}
-    {2911125600 46800 0 +13}
-    {2926245600 50400 1 +13}
-    {2942575200 46800 0 +13}
-    {2958300000 50400 1 +13}
-    {2974629600 46800 0 +13}
-    {2989749600 50400 1 +13}
-    {3006079200 46800 0 +13}
-    {3021199200 50400 1 +13}
-    {3037528800 46800 0 +13}
-    {3052648800 50400 1 +13}
-    {3068978400 46800 0 +13}
-    {3084098400 50400 1 +13}
-    {3100428000 46800 0 +13}
-    {3116152800 50400 1 +13}
-    {3132482400 46800 0 +13}
-    {3147602400 50400 1 +13}
-    {3163932000 46800 0 +13}
-    {3179052000 50400 1 +13}
-    {3195381600 46800 0 +13}
-    {3210501600 50400 1 +13}
-    {3226831200 46800 0 +13}
-    {3241951200 50400 1 +13}
-    {3258280800 46800 0 +13}
-    {3273400800 50400 1 +13}
-    {3289730400 46800 0 +13}
-    {3305455200 50400 1 +13}
-    {3321784800 46800 0 +13}
-    {3336904800 50400 1 +13}
-    {3353234400 46800 0 +13}
-    {3368354400 50400 1 +13}
-    {3384684000 46800 0 +13}
-    {3399804000 50400 1 +13}
-    {3416133600 46800 0 +13}
-    {3431253600 50400 1 +13}
-    {3447583200 46800 0 +13}
-    {3462703200 50400 1 +13}
-    {3479637600 46800 0 +13}
-    {3494757600 50400 1 +13}
-    {3511087200 46800 0 +13}
-    {3526207200 50400 1 +13}
-    {3542536800 46800 0 +13}
-    {3557656800 50400 1 +13}
-    {3573986400 46800 0 +13}
-    {3589106400 50400 1 +13}
-    {3605436000 46800 0 +13}
-    {3620556000 50400 1 +13}
-    {3636885600 46800 0 +13}
-    {3652610400 50400 1 +13}
-    {3668940000 46800 0 +13}
-    {3684060000 50400 1 +13}
-    {3700389600 46800 0 +13}
-    {3715509600 50400 1 +13}
-    {3731839200 46800 0 +13}
-    {3746959200 50400 1 +13}
-    {3763288800 46800 0 +13}
-    {3778408800 50400 1 +13}
-    {3794738400 46800 0 +13}
-    {3809858400 50400 1 +13}
-    {3826188000 46800 0 +13}
-    {3841912800 50400 1 +13}
-    {3858242400 46800 0 +13}
-    {3873362400 50400 1 +13}
-    {3889692000 46800 0 +13}
-    {3904812000 50400 1 +13}
-    {3921141600 46800 0 +13}
-    {3936261600 50400 1 +13}
-    {3952591200 46800 0 +13}
-    {3967711200 50400 1 +13}
-    {3984040800 46800 0 +13}
-    {3999765600 50400 1 +13}
-    {4016095200 46800 0 +13}
-    {4031215200 50400 1 +13}
-    {4047544800 46800 0 +13}
-    {4062664800 50400 1 +13}
-    {4078994400 46800 0 +13}
-    {4094114400 50400 1 +13}
 }
@@ -1,8 +1,5 @@
 # created by tools/tclZIC.tcl - do not edit
-
-set TZData(:Pacific/Enderbury) {
-    {-9223372036854775808 -41060 0 LMT}
-    {-2177411740 -43200 0 -12}
-    {307627200 -39600 0 -11}
-    {788871600 46800 0 +13}
+if {![info exists TZData(Pacific/Kanton)]} {
+    LoadTimeZoneFile Pacific/Kanton
 }
+set TZData(:Pacific/Enderbury) $TZData(:Pacific/Kanton)
@@ -2,7 +2,6 @@

 set TZData(:Pacific/Niue) {
    {-9223372036854775808 -40780 0 LMT}
-    {-2177412020 -40800 0 -1120}
-    {-599575200 -41400 0 -1130}
-    {276089400 -39600 0 -11}
+    {-543069620 -40800 0 -1120}
+    {-173623200 -39600 0 -11}
 }
@@ -1,8 +1,9 @@
 # created by tools/tclZIC.tcl - do not edit

 set TZData(:Pacific/Rarotonga) {
-    {-9223372036854775808 -38344 0 LMT}
-    {-2177414456 -37800 0 -1030}
+    {-9223372036854775808 48056 0 LMT}
+    {-2209555256 -38344 0 LMT}
+    {-543072056 -37800 0 -1030}
    {279714600 -34200 0 -10}
    {289387800 -36000 0 -10}
    {309952800 -34200 1 -10}
@@ -1,9 +1,9 @@
 # created by tools/tclZIC.tcl - do not edit

 set TZData(:Pacific/Tongatapu) {
-    {-9223372036854775808 44360 0 LMT}
-    {-2177497160 44400 0 +1220}
-    {-915193200 46800 0 +13}
+    {-9223372036854775808 44352 0 LMT}
+    {-767189952 44400 0 +1220}
+    {-284041200 46800 0 +13}
    {915102000 46800 0 +13}
    {939214800 50400 1 +13}
    {953384400 46800 0 +13}
@@ -577,7 +577,7 @@ GetOSTypeFromObj(
 {
    int result = TCL_OK;

-    if (!TclHasIntRep(objPtr, &tclOSTypeType)) {
+    if (!TclHasInternalRep(objPtr, &tclOSTypeType)) {
 	result = SetOSTypeFromAny(interp, objPtr);
    }
    *osTypePtr = (OSType) objPtr->internalRep.wideValue;
@@ -659,7 +659,7 @@ SetOSTypeFromAny(
 		 (OSType) bytes[1] << 16 |
 		 (OSType) bytes[2] <<  8 |
 		 (OSType) bytes[3];
-	TclFreeIntRep(objPtr);
+	TclFreeInternalRep(objPtr);
 	objPtr->internalRep.wideValue = (Tcl_WideInt) osType;
 	objPtr->typePtr = &tclOSTypeType;
    }
@@ -457,6 +457,20 @@ static int receivePipe = -1; /* Output end of triggerPipe */

 static int notifierThreadRunning;

+/*
+ * The following static flag indicates that async handlers are pending.
+ */
+
+#if TCL_THREADS
+static int asyncPending = 0;
+#endif
+
+/*
+ * Signal mask information for notifier thread.
+ */
+static sigset_t notifierSigMask;
+static sigset_t allSigMask;
+
 /*
 * This is the thread ID of the notifier thread that does select. Only valid
 * when notifierThreadRunning is non-zero.
@@ -803,6 +817,15 @@ StartNotifierThread(void)
 	int result;
 	pthread_attr_t attr;

+	/*
+	 * Arrange for the notifier thread to start with all
+	 * signals blocked. In its mainloop it unblocks the
+	 * signals at safe points.
+	 */
+
+	sigfillset(&allSigMask);
+	pthread_sigmask(SIG_BLOCK, &allSigMask, &notifierSigMask);
+
 	pthread_attr_init(&attr);
 	pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
 	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
@@ -814,6 +837,12 @@ StartNotifierThread(void)
 	    Tcl_Panic("StartNotifierThread: unable to start notifier thread");
 	}
 	notifierThreadRunning = 1;
+
+	/*
+	 * Restore original signal mask.
+	 */
+
+	pthread_sigmask(SIG_SETMASK, &notifierSigMask, NULL);
    }
    UNLOCK_NOTIFIER_INIT;
 }
@@ -876,6 +905,14 @@ TclpFinalizeNotifier(
 			    "thread");
 		}
 		notifierThreadRunning = 0;
+
+		/*
+		 * If async marks are outstanding, perform actions now.
+		 */
+		if (asyncPending) {
+		    asyncPending = 0;
+		    TclAsyncMarkFromNotifier();
+		}
 	    }

 	    close(receivePipe);
@@ -1280,6 +1317,29 @@ FileHandlerEventProc(
    return 1;
 }

+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpNotifierData --
+ *
+ *	This function returns a ClientData pointer to be associated
+ *	with a Tcl_AsyncHandler.
+ *
+ * Results:
+ *	On MacOSX, returns always NULL.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+ClientData
+TclpNotifierData(void)
+{
+    return NULL;
+}
+
 /*
 *----------------------------------------------------------------------
 *
@@ -1826,6 +1886,61 @@ TclUnixWaitForFile(
    return result;
 }

+/*
+ *----------------------------------------------------------------------
+ *
+ * TclAsyncNotifier --
+ *
+ *	This procedure sets the async mark of an async handler to a
+ *	given value, if it is called from the notifier thread.
+ *
+ * Result:
+ *	True, when the handler will be marked, false otherwise.
+ *
+ * Side effetcs:
+ *	The trigger pipe is written when called from the notifier
+ *	thread.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+TclAsyncNotifier(
+    int sigNumber,		/* Signal number. */
+    TCL_UNUSED(Tcl_ThreadId),	/* Target thread. */
+    TCL_UNUSED(ClientData),	/* Notifier data. */
+    int *flagPtr,		/* Flag to mark. */
+    int value)			/* Value of mark. */
+{
+#if TCL_THREADS
+    /*
+     * WARNING:
+     * This code most likely runs in a signal handler. Thus,
+     * only few async-signal-safe system calls are allowed,
+     * e.g. pthread_self(), sem_post(), write().
+     */
+
+    if (pthread_equal(pthread_self(), (pthread_t) notifierThread)) {
+	if (notifierThreadRunning) {
+	    *flagPtr = value;
+	    if (!asyncPending) {
+		asyncPending = 1;
+		write(triggerPipe, "S", 1);
+	    }
+	    return 1;
+	}
+	return 0;
+    }
+
+    /*
+     * Re-send the signal to the notifier thread.
+     */
+
+    pthread_kill((pthread_t) notifierThread, sigNumber);
+#endif
+    return 0;
+}
+
 /*
 *----------------------------------------------------------------------
 *
@@ -1856,7 +1971,7 @@ NotifierThreadProc(
 {
    ThreadSpecificData *tsdPtr;
    fd_set readableMask, writableMask, exceptionalMask;
-    int i, numFdBits = 0, polling;
+    int i, ret, numFdBits = 0, polling;
    struct timeval poll = {0., 0.}, *timePtr;
    char buf[2];

@@ -1909,8 +2024,25 @@ NotifierThreadProc(
 	}
 	FD_SET(receivePipe, &readableMask);

-	if (select(numFdBits, &readableMask, &writableMask, &exceptionalMask,
-		timePtr) == -1) {
+	/*
+	 * Signals are unblocked only during select().
+	 */
+
+	pthread_sigmask(SIG_SETMASK, &notifierSigMask, NULL);
+	ret = select(numFdBits, &readableMask, &writableMask, &exceptionalMask,
+		    timePtr);
+	pthread_sigmask(SIG_BLOCK, &allSigMask, NULL);
+
+	if (ret == -1) {
+	    /*
+	     * In case a signal was caught during select(),
+	     * perform work on async handlers now.
+	     */
+	    if (errno == EINTR && asyncPending) {
+		asyncPending = 0;
+		TclAsyncMarkFromNotifier();
+	    }
+
 	    /*
 	     * Try again immediately on an error.
 	     */
@@ -1998,6 +2130,11 @@ NotifierThreadProc(

 		break;
 	    }
+
+	    if (asyncPending) {
+		asyncPending = 0;
+		TclAsyncMarkFromNotifier();
+	    }
 	}
    }
    pthread_exit(0);
@@ -2084,12 +2221,17 @@ AtForkChild(void)
     */

 #if defined(USE_OS_UNFAIR_LOCK)
-    tsdPtr->tsdLock = OS_UNFAIR_LOCK_INIT;
+    notifierInitLock = OS_UNFAIR_LOCK_INIT;
+    notifierLock     = OS_UNFAIR_LOCK_INIT;
+    tsdPtr->tsdLock  = OS_UNFAIR_LOCK_INIT;
 #else
-       UNLOCK_NOTIFIER_TSD;
-       UNLOCK_NOTIFIER;
-       UNLOCK_NOTIFIER_INIT;
+    UNLOCK_NOTIFIER_TSD;
+    UNLOCK_NOTIFIER;
+    UNLOCK_NOTIFIER_INIT;
 #endif
+
+    asyncPending = 0;
+
    if (tsdPtr->runLoop) {
 	tsdPtr->runLoop = NULL;
 	if (!noCFafterFork) {
@@ -2119,6 +2261,12 @@ AtForkChild(void)
 	if (!noCFafterFork) {
 	    Tcl_InitNotifier();
 	}
+
+	/*
+	 * Restart the notifier thread for signal handling.
+	 */
+
+	StartNotifierThread();
    }
 }
 #endif /* HAVE_PTHREAD_ATFORK */
@@ -19,6 +19,7 @@ if {"::tcltest" ni [namespace children]} {
 ::tcltest::loadTestedCommands
 catch [list package require -exact tcl::test [info patchlevel]]

+testConstraint thread [expr {0 == [catch {package require Thread 2.7-}]}]
 testConstraint testasync [llength [info commands testasync]]
 testConstraint knownMsvcBug [expr {![info exists ::env(CI_BUILD_WITH_MSVC)]}]

@@ -149,7 +150,7 @@ test async-3.1 {deleting handlers} testasync {
 } {3 del2 {0 0 0 del1 del2}}

 test async-4.1 {async interrupting bytecode sequence} -constraints {
-    testasync
+    testasync thread
 } -setup {
    set hm [testasync create async3]
    proc nothing {} {
@@ -178,7 +179,7 @@ test async-4.1 {async interrupting bytecode sequence} -constraints {
    testasync delete $hm
 }
 test async-4.2 {async interrupting straight bytecode sequence} -constraints {
-    testasync
+    testasync thread
 } -setup {
    set hm [testasync create async3]
 } -body {
@@ -203,7 +204,7 @@ test async-4.2 {async interrupting straight bytecode sequence} -constraints {
    testasync delete $hm
 }
 test async-4.3 {async interrupting loop-less bytecode sequence} -constraints {
-    testasync knownMsvcBug
+    testasync thread knownMsvcBug
 } -setup {
    set hm [testasync create async3]
 } -body {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
jan.nijtmans	0b1f6ed09a	Change "IntRep" to "InternalRep", as discussed in the Tcl Core mailing list	2021-10-06 19:33:03 +00:00
jan.nijtmans	fa2cb7883b	Fix problem with application manifest, supporting UTF-8 console (it appears that mingw is stricter than msvc on this)	2021-10-06 14:00:44 +00:00
pooryorick	2e1d5a50d8	Rewrite comments for clarity and conciseness.	2021-10-04 21:09:02 +00:00
jan.nijtmans	9a44b606e8	Merge 8.6	2021-09-30 08:03:06 +00:00
jan.nijtmans	01cdc3483c	Fix [e0f728b381]: Manpage msgcat.n contains two write errors	2021-09-30 07:49:10 +00:00
jan.nijtmans	8cb8adf9b7	Set activeCodePage to UTF-8, for (Windows) systems that support it.	2021-09-29 13:46:51 +00:00
jan.nijtmans	4d029b8f63	TIP #605 implementation: Function to get class name from object	2021-09-27 13:01:37 +00:00
jan.nijtmans	448e5e0f2e	Merge 8.6	2021-09-26 20:51:09 +00:00
jan.nijtmans	140023c551	Remove unix/config.status.lineno	2021-09-26 20:48:17 +00:00
jan.nijtmans	f5df020920	Update TZ info to tzdata2021b.	2021-09-26 20:43:51 +00:00
José Ignacio Marín	22557de7f2	Update TZ info to tzdata2021b (via merge).	2021-09-25 09:01:40 +00:00
José Ignacio Marín	ae23664336	Update TZ info to tzdata2021b.	2021-09-25 09:01:00 +00:00
jan.nijtmans	3d43898853	Merge 8.6	2021-09-14 13:35:11 +00:00
jan.nijtmans	8b26b82863	Update all tables to Unicode 14	2021-09-14 13:34:08 +00:00
jan.nijtmans	b5a045b670	Update all tables to Unicode 14	2021-09-14 13:31:49 +00:00
jan.nijtmans	4dd741ab26	Merge 8.6	2021-09-08 14:26:02 +00:00
jan.nijtmans	8d0f9082f2	close fork	2021-09-08 14:24:13 +00:00
jan.nijtmans	e26fa5de83	merge-mark	2021-09-03 06:43:42 +00:00
pooryorick	dff41a451d	Merge fixes for [ccc448a6bfd5], namespace ensemble subcommand name prefix matching and a subsequent error results in a segmentation fault.	2021-09-02 23:03:07 +00:00
pooryorick	7687170880	Backport fixes for [ccc448a6bfd5], namespace ensemble subcommand name prefix matching and a subsequent error results in a segmentation fault.	2021-09-02 22:38:32 +00:00
jan.nijtmans	274f7dbfe0	Few more (c) -> ©	2021-09-02 14:46:55 +00:00
jan.nijtmans	6fc4828aad	(c) -> ©, now that TIP #587 is accepted	2021-09-02 14:41:53 +00:00
jan.nijtmans	e882b751f3	Merge 8.7	2021-09-01 13:07:18 +00:00
jan.nijtmans	fdf0eab428	Merge 8.6	2021-08-27 07:10:33 +00:00
jan.nijtmans	975416ffc0	Follow-up previous commit (thanks, Don!). Missing #undef	2021-08-27 07:09:25 +00:00
dgp	c3d1d436bc	repair broken build	2021-08-26 19:14:01 +00:00
dgp	a0d2c4332f	repair broken build	2021-08-26 19:12:39 +00:00
jan.nijtmans	3c6ee745c3	Merge 8.6	2021-08-26 15:27:05 +00:00
jan.nijtmans	9c9b2cacae	Add a few spare unused stub entries in TclOO	2021-08-26 15:15:06 +00:00
jan.nijtmans	a5048e8dd9	Make everything compile warning-free when TCL_THREADS=0	2021-08-23 13:00:47 +00:00
jan.nijtmans	a5448b6c8b	Merge 8.5	2021-08-23 10:35:16 +00:00
jan.nijtmans	4c3b4b2a2b	Add FALLTHRU markers, to help GCC emit less false warnings	2021-08-23 10:01:35 +00:00
jan.nijtmans	d0288f61d3	Code formatting	2021-08-23 09:59:26 +00:00
jan.nijtmans	94b338844e	TIP #511 implementation: Implement Tcl_AsyncMarkFromSignal()	2021-08-20 12:46:09 +00:00
jan.nijtmans	c7dbd69076	Merge-mark 8.6. Update to autoconf-2.71	2021-08-19 08:51:29 +00:00
jan.nijtmans	aee8e4fe56	Merge 8.5	2021-08-19 08:45:09 +00:00
jan.nijtmans	45a3da6414	Reserve a few more unused stub entries	2021-08-19 08:38:27 +00:00
jan.nijtmans	d296d56f36	Apply macos-tip511.diff. Resolve conflict with TIP #601	2021-08-19 08:05:47 +00:00
jan.nijtmans	f69a86b714	Fix use of TCL_THREADS macro: In Tcl 8.7, this is always defined, but can have value '1' or '0'	2021-08-18 14:31:55 +00:00
jan.nijtmans	5f83d31ece	tip#511 proposed implementation	2021-08-17 16:16:29 +00:00
jan.nijtmans	58502bda0b	Make TCL_MAC_EMPTY_FILE macro work with C++ compiler	2021-08-15 21:47:28 +00:00
jan.nijtmans	0a6f1e351d	Make tclZipfs.c compilable with a C++ compiler	2021-08-15 21:37:09 +00:00
oehhar	774d9c6cf3	Refine 'string replace' documentation wording. Thanks to Ted Brown on clt.	2021-08-05 16:19:26 +00:00
jan.nijtmans	16105b9833	Merge 8.6	2021-08-05 11:20:10 +00:00
oehhar	1b1500534d	Clarify description of corner case 'string replace "" 0 0 A' to return the empty string.	2021-08-05 07:30:15 +00:00
dkf	36dbbdbb72	Turn code snippets in TIP into a branch.	2021-08-01 11:47:23 +00:00
jan.nijtmans	6118cd549e	merge-mark	2021-07-31 16:00:46 +00:00
jan.nijtmans	e62d47d725	Backout last 2 commits: It appears that on Windows-2016 the GITHUB-installed version of msys works better than the official msys2	2021-07-31 15:59:11 +00:00
jan.nijtmans	2002b28cbb	try to update msys2 to latest version in GITHUB build	2021-07-30 08:08:30 +00:00
jan.nijtmans	2a56bd9e36	Experiment: Switch tclsh console to UTF-8 by default on Windows, if possible, using the manifest.	2021-07-29 14:03:30 +00:00
jan.nijtmans	f107311e0a	Use mingw-w64-ucrt-x86_64 toolchain for onfiledist build (starting with 8.7, since it needs Vista+)	2021-07-23 12:52:16 +00:00
jan.nijtmans	95e8a2b516	Missing "env:" label in win-build.yml	2021-07-23 09:49:13 +00:00
jan.nijtmans	179a97b763	Merge 8.7	2021-06-10 10:59:50 +00:00
jan.nijtmans	552e9c6542	Merge 8.7	2021-02-12 15:12:06 +00:00
jan.nijtmans	a5f5cc7742	Replace Unicode 13 tables with Unicode 14 (still not finailized). Let's see how it goes so far.	2021-02-12 10:59:37 +00:00