From 468b1a434681f98ea64d399abce7ddd8c605617d Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sat, 28 Jan 2023 18:50:32 +0000
Subject: Fix "format %c 0x10000041", should give the same answer as in Tcl 8.6
 (Handling of TCL_COMBINE flag should not be visible at script level)

---
 generic/tclStringObj.c | 3 +++
 tests/format.test      | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/generic/tclStringObj.c b/generic/tclStringObj.c
index a041d4c..e1376f4 100644
--- a/generic/tclStringObj.c
+++ b/generic/tclStringObj.c
@@ -2130,6 +2130,9 @@ Tcl_AppendFormatToObj(
 	    if (TclGetIntFromObj(interp, segment, &code) != TCL_OK) {
 		goto error;
 	    }
+	    if ((unsigned)code > 0x10FFFF) {
+	    	code = 0xFFFD;
+	    }
 	    length = Tcl_UniCharToUtf(code, buf);
 #if TCL_UTF_MAX < 4
 	    if ((code >= 0xD800) && (length < 3)) {
diff --git a/tests/format.test b/tests/format.test
index c47774a..8cabbf1 100644
--- a/tests/format.test
+++ b/tests/format.test
@@ -402,6 +402,9 @@ test format-8.26 {Undocumented formats} -body {
 test format-8.27 {Undocumented formats} -constraints pointerIs64bit -body {
     format "%p %#llx" [expr {2**33}] [expr {2**33}]
 } -result {0x200000000 0x200000000}
+test format-8.28 {Internal use of TCL_COMBINE flag should not be visiable at script level} {
+    format %c 0x10000041
+} \uFFFD
 
 test format-9.1 {long result} {
     set a {1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ 1 2 3 4 5 6 7 8 9 0 a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z}
-- 
cgit v0.12


From 5b86b255d41b6a0948597ccc8b7499efde42c4d7 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sat, 28 Jan 2023 20:50:36 +0000
Subject: Another situation where TCL_COMBINE handling gives a strange result
 (utf-32 encoder)

---
 generic/tclEncoding.c | 10 ++++++++--
 tests/encoding.test   |  4 ++++
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index e548663..46508b7 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -2505,8 +2505,14 @@ Utf32ToUtfProc(
 	} else {
 	    ch = (src[0] & 0xFF) << 24 | (src[1] & 0xFF) << 16 | (src[2] & 0xFF) << 8 | (src[3] & 0xFF);
 	}
-	if  ((unsigned)ch > 0x10FFFF || (((flags & TCL_ENCODING_STRICT) == TCL_ENCODING_STRICT)
-		&& ((ch  & ~0x7FF) == 0xD800))) {
+	if  ((unsigned)ch > 0x10FFFF) {
+	    if (STOPONERROR) {
+		result = TCL_CONVERT_SYNTAX;
+		break;
+	    }
+	    ch = 0xFFFD;
+	} else if (((flags & TCL_ENCODING_STRICT) == TCL_ENCODING_STRICT)
+		&& ((ch  & ~0x7FF) == 0xD800)) {
 	    if (STOPONERROR) {
 		result = TCL_CONVERT_SYNTAX;
 		break;
diff --git a/tests/encoding.test b/tests/encoding.test
index a6c8a80..1971360 100644
--- a/tests/encoding.test
+++ b/tests/encoding.test
@@ -482,6 +482,10 @@ test encoding-16.7 {Utf32ToUtfProc} -body {
     set val [encoding convertfrom utf-32be \0\0NN]
     list $val [format %x [scan $val %c]]
 } -result "乎 4e4e"
+test encoding-16.8 {Utf32ToUtfProc} -body {
+    set val [encoding convertfrom -nocomplain utf-32 \x41\x00\x00\x41]
+    list $val [format %x [scan $val %c]]
+} -result "\uFFFD fffd"
 
 test encoding-17.1 {UtfToUtf16Proc} -body {
     encoding convertto utf-16 "\U460DC"
-- 
cgit v0.12


From 4d235ca93a0588d63b0b2a0d1cdceb594a1a3a32 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Mon, 30 Jan 2023 11:22:28 +0000
Subject: Make Tcl_UniCharToUtf() a little easier to read.

---
 generic/tclUtf.c | 48 ++++++++++++++++++++++++++----------------------
 1 file changed, 26 insertions(+), 22 deletions(-)

diff --git a/generic/tclUtf.c b/generic/tclUtf.c
index 92bcf4f..ee0724c 100644
--- a/generic/tclUtf.c
+++ b/generic/tclUtf.c
@@ -231,8 +231,8 @@ Tcl_UniCharToUtf(
     }
     if (ch >= 0) {
 	if (ch <= 0x7FF) {
-	    buf[1] = (char) ((ch | 0x80) & 0xBF);
-	    buf[0] = (char) ((ch >> 6) | 0xC0);
+	    buf[1] = (char) (0x80 | (0x3F & ch));
+	    buf[0] = (char) (0xC0 | (ch >> 6));
 	    return 2;
 	}
 	if (ch <= 0xFFFF) {
@@ -243,10 +243,11 @@ Tcl_UniCharToUtf(
 		    ((ch & 0xF800) == 0xD800)) {
 		if (ch & 0x0400) {
 		    /* Low surrogate */
-		    if (((buf[0] & 0xC0) == 0x80) && ((buf[1] & 0xCF) == 0)) {
+		    if (   (0x80 == (0xC0 & buf[0]))
+			&& (0    == (0xCF & buf[1]))) {
 			/* Previous Tcl_UniChar was a high surrogate, so combine */
-			buf[2] = (char) ((ch & 0x3F) | 0x80);
-			buf[1] |= (char) (((ch >> 6) & 0x0F) | 0x80);
+			buf[2]  = (char) (0x80 | (0x3F & ch));
+			buf[1] |= (char) (0x80 | (0x0F & (ch >> 6)));
 			return 3;
 		    }
 		    /* Previous Tcl_UniChar was not a high surrogate, so just output */
@@ -255,38 +256,41 @@ Tcl_UniCharToUtf(
 		    ch += 0x40;
 		    /* Fill buffer with specific 3-byte (invalid) byte combination,
 		       so following low surrogate can recognize it and combine */
-		    buf[2] = (char) ((ch << 4) & 0x30);
-		    buf[1] = (char) (((ch >> 2) & 0x3F) | 0x80);
-		    buf[0] = (char) (((ch >> 8) & 0x07) | 0xF0);
+		    buf[2] = (char) (        0x03 & ch);
+		    buf[1] = (char) (0x80 | (0x3F & (ch >> 2)));
+		    buf[0] = (char) (0xF0 | (0x07 & (ch >> 8)));
 		    return 1;
 		}
 	    }
 	    goto three;
 	}
 	if (ch <= 0x10FFFF) {
-	    buf[3] = (char) ((ch | 0x80) & 0xBF);
-	    buf[2] = (char) (((ch >> 6) | 0x80) & 0xBF);
-	    buf[1] = (char) (((ch >> 12) | 0x80) & 0xBF);
-	    buf[0] = (char) ((ch >> 18) | 0xF0);
+	    buf[3] = (char) (0x80 | (0x3F & ch));
+	    buf[2] = (char) (0xBF & (0x80 | (ch >> 6)));
+	    buf[1] = (char) (0xBF & (0x80 | (ch >> 12)));
+	    buf[0] = (char) (0xF0 |         (ch >> 18));
 	    return 4;
 	}
     } else if (ch == -1) {
-	if (((buf[0] & 0xC0) == 0x80) && ((buf[1] & 0xCF) == 0)
-		&& ((buf[-1] & 0xF8) == 0xF0)) {
-	    ch = 0xD7C0 + ((buf[-1] & 0x07) << 8) + ((buf[0] & 0x3F) << 2)
-		    + ((buf[1] & 0x30) >> 4);
-	    buf[1] = (char) ((ch | 0x80) & 0xBF);
-	    buf[0] = (char) (((ch >> 6) | 0x80) & 0xBF);
-	    buf[-1] = (char) ((ch >> 12) | 0xE0);
+	if (   (0x80 == (0xC0 & buf[0]))
+	    && (0    == (0xCF & buf[1]))
+	    && (0xF0 == (0xF8 & buf[-1]))) {
+	    ch = 0xD7C0
+		+ ((0x07 & buf[-1]) << 8)
+		+ ((0x3F & buf[0])  << 2)
+		+ ((0x30 & buf[1])  >> 4);
+	    buf[1]  = (char) (0xBF & (0x80 | ch));
+	    buf[0]  = (char) (0xBF & (0x80 | (ch >> 6)));
+	    buf[-1] = (char) (0xE0 | (ch >> 12));
 	    return 2;
 	}
     }
 
     ch = 0xFFFD;
 three:
-    buf[2] = (char) ((ch | 0x80) & 0xBF);
-    buf[1] = (char) (((ch >> 6) | 0x80) & 0xBF);
-    buf[0] = (char) ((ch >> 12) | 0xE0);
+    buf[2] = (char) (0x80 | (0x3F & ch));
+    buf[1] = (char) (0x80 | (0x3F & (ch >> 6)));
+    buf[0] = (char) (0xE0 |         (ch >> 12));
     return 3;
 }
 
-- 
cgit v0.12


From 8c0f76a7de2b22a611f26c3a08a434b5b85ce261 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Mon, 30 Jan 2023 11:59:41 +0000
Subject: A few more readability changes to Tcl_UniCharToUtf()

jn: Please, don't do that here. Tcl_UniCharToUtf() is shared between 8.6, 8.7 and 9.0. So if you want to make it easier to read, it should be done on all 3 branches. I know you only care about "trunk", but it makes maintenance on 8.6/8.7/9.0 harder than it already is. I don't want to spend time on reviewing such kind of changes, and no-one else is doing it. Thanks for understanding (I hope)!
---
 generic/tclUtf.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/generic/tclUtf.c b/generic/tclUtf.c
index ee0724c..ab27f1b 100644
--- a/generic/tclUtf.c
+++ b/generic/tclUtf.c
@@ -266,8 +266,8 @@ Tcl_UniCharToUtf(
 	}
 	if (ch <= 0x10FFFF) {
 	    buf[3] = (char) (0x80 | (0x3F & ch));
-	    buf[2] = (char) (0xBF & (0x80 | (ch >> 6)));
-	    buf[1] = (char) (0xBF & (0x80 | (ch >> 12)));
+	    buf[2] = (char) (0x80 | (0x3F & (ch >> 6)));
+	    buf[1] = (char) (0x80 | (0x3F & (ch >> 12)));
 	    buf[0] = (char) (0xF0 |         (ch >> 18));
 	    return 4;
 	}
@@ -279,8 +279,8 @@ Tcl_UniCharToUtf(
 		+ ((0x07 & buf[-1]) << 8)
 		+ ((0x3F & buf[0])  << 2)
 		+ ((0x30 & buf[1])  >> 4);
-	    buf[1]  = (char) (0xBF & (0x80 | ch));
-	    buf[0]  = (char) (0xBF & (0x80 | (ch >> 6)));
+	    buf[1]  = (char) (0x80 | (0x3F & ch));
+	    buf[0]  = (char) (0x80 | (0x3F & (ch >> 6)));
 	    buf[-1] = (char) (0xE0 | (ch >> 12));
 	    return 2;
 	}
-- 
cgit v0.12


From 078a694834be8669ba6f79def0adbb61afacc0e2 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Tue, 31 Jan 2023 22:15:02 +0000
Subject: Fix error introduced in [3e5e37f83b058f3d] for Tcl_UniCharToUtf, and
 add test.

---
 generic/tclUtf.c    |  2 +-
 tests/encoding.test | 24 ++++++++++++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/generic/tclUtf.c b/generic/tclUtf.c
index ab27f1b..bef32f0 100644
--- a/generic/tclUtf.c
+++ b/generic/tclUtf.c
@@ -256,7 +256,7 @@ Tcl_UniCharToUtf(
 		    ch += 0x40;
 		    /* Fill buffer with specific 3-byte (invalid) byte combination,
 		       so following low surrogate can recognize it and combine */
-		    buf[2] = (char) (        0x03 & ch);
+		    buf[2] = (char) ((ch << 4) & 0x30);
 		    buf[1] = (char) (0x80 | (0x3F & (ch >> 2)));
 		    buf[0] = (char) (0xF0 | (0x07 & (ch >> 8)));
 		    return 1;
diff --git a/tests/encoding.test b/tests/encoding.test
index 1971360..8351c91 100644
--- a/tests/encoding.test
+++ b/tests/encoding.test
@@ -487,6 +487,30 @@ test encoding-16.8 {Utf32ToUtfProc} -body {
     list $val [format %x [scan $val %c]]
 } -result "\uFFFD fffd"
 
+test encoding-16.8 {
+    Utf16ToUtfProc, Tcl_UniCharToUtf, surrogate pairs in utf-16
+} -body {
+    apply [list {} {
+	for {set i 0xD800} {$i < 0xDBFF} {incr i} {
+	    for {set j 0xDC00} {$j < 0xDFFF} {incr j} {
+		set string [binary format S2 [list $i $j]]
+		set status [catch {
+		    set decoded [encoding convertfrom utf-16be $string]
+		    set encoded [encoding convertto utf-16be $decoded]
+		}]
+		if {$status || ( $encoded ne $string )} {
+		    return [list [format %x $i] [format %x $j]]
+		}
+	    }
+	}
+	return done
+    } [namespace current]]
+} -result done
+
+
+
+
+
 test encoding-17.1 {UtfToUtf16Proc} -body {
     encoding convertto utf-16 "\U460DC"
 } -result "\xD8\xD8\xDC\xDC"
-- 
cgit v0.12


From 6d674a96a1b99426cabf17e5b52272399c73e8bc Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Thu, 16 Feb 2023 21:29:07 +0000
Subject: Final part of [10c2c17c32]: UTF-LE32 encoder mapping of surrogates.
 Problem was in testcase, not in actual code

---
 tests/encoding.test | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/encoding.test b/tests/encoding.test
index ed41937..a46fa5f 100644
--- a/tests/encoding.test
+++ b/tests/encoding.test
@@ -525,9 +525,9 @@ test encoding-16.13 {Utf16ToUtfProc} -body {
 test encoding-16.14 {Utf16ToUtfProc} -body {
     encoding convertfrom utf-16le \x00\xDC
 } -result \uDC00
-test encoding-16.15 {Utf16ToUtfProc} -constraints knownBug -body {
+test encoding-16.15 {Utf16ToUtfProc} -body {
     encoding convertfrom utf-16le \x00\xD8\x00\xDC
-} -result \uD800\uDC00
+} -result \U010000
 test encoding-16.16 {Utf16ToUtfProc} -body {
     encoding convertfrom utf-16le \x00\xDC\x00\xD8
 } -result \uDC00\uD800
-- 
cgit v0.12


From 8390c51fcaeaa278ec7ec40ec5d31ee187c25208 Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Sat, 25 Feb 2023 07:35:21 +0000
Subject: Fix [1d074b177a]. Failure to read .tclshrc

---
 unix/tclAppInit.c | 11 ++++++-----
 win/tclAppInit.c  |  7 +++++--
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/unix/tclAppInit.c b/unix/tclAppInit.c
index 05d25de..e3d95bc 100644
--- a/unix/tclAppInit.c
+++ b/unix/tclAppInit.c
@@ -158,15 +158,16 @@ Tcl_AppInit(
      * is the name of the application. If this line is deleted then no
      * user-specific startup file will be run under any conditions.
      */
-
 #ifdef DJGPP
-    Tcl_ObjSetVar2(interp, Tcl_NewStringObj("tcl_rcFileName", TCL_INDEX_NONE), NULL,
-	    Tcl_NewStringObj("~/tclsh.rc", TCL_INDEX_NONE), TCL_GLOBAL_ONLY);
+#define INITFILENAME "tclshrc.tcl"
 #else
-    Tcl_ObjSetVar2(interp, Tcl_NewStringObj("tcl_rcFileName", TCL_INDEX_NONE), NULL,
-	    Tcl_NewStringObj("~/.tclshrc", TCL_INDEX_NONE), TCL_GLOBAL_ONLY);
+#define INITFILENAME ".tclshrc"
 #endif
 
+    (void)Tcl_EvalEx(interp,
+		     "set tcl_rcFileName [file tildeexpand ~/" INITFILENAME "]",
+		     -1,
+		     TCL_EVAL_GLOBAL);
     return TCL_OK;
 }
 
diff --git a/win/tclAppInit.c b/win/tclAppInit.c
index 30127fd..077500a 100644
--- a/win/tclAppInit.c
+++ b/win/tclAppInit.c
@@ -215,8 +215,11 @@ Tcl_AppInit(
      * user-specific startup file will be run under any conditions.
      */
 
-    Tcl_ObjSetVar2(interp, Tcl_NewStringObj("tcl_rcFileName", TCL_INDEX_NONE), NULL,
-	    Tcl_NewStringObj("~/tclshrc.tcl", TCL_INDEX_NONE), TCL_GLOBAL_ONLY);
+    (void)Tcl_EvalEx(interp,
+		     "set tcl_rcFileName [file tildeexpand ~/tclshrc.tcl]",
+		     -1,
+		     TCL_EVAL_GLOBAL);
+
     return TCL_OK;
 }
 
-- 
cgit v0.12


From a826e66f11a2823847cb7788a1d929a9799c95ad Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Sat, 25 Feb 2023 08:58:31 +0000
Subject: Add tests for Bug [46dda6fc29]

---
 tests/dstring.test | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/tests/dstring.test b/tests/dstring.test
index 314cee8..8699a5e 100644
--- a/tests/dstring.test
+++ b/tests/dstring.test
@@ -211,6 +211,38 @@ test dstring-2.15 {appending list elements} -constraints testdstring -setup {
 } -cleanup {
     testdstring free
 } -result {x  #}
+test dstring-2.16 {appending list elements - bug [46dda6fc29] segfault} -constraints testdstring -setup {
+    testdstring free
+} -body {
+    testdstring element "\\\n"; # Will setfault
+    testdstring get
+} -cleanup {
+    testdstring free
+} -result {}
+test dstring-2.17 {appending list elements - bug [46dda6fc29] segfault} -constraints testdstring -setup {
+    testdstring free
+} -body {
+    testdstring element "\\\{"; # Will setfault
+    testdstring get
+} -cleanup {
+    testdstring free
+} -result {}
+test dstring-2.18 {appending list elements - bug [46dda6fc29] segfault} -constraints testdstring -setup {
+    testdstring free
+} -body {
+    testdstring element "\\\}"; # Will setfault
+    testdstring get
+} -cleanup {
+    testdstring free
+} -result {}
+test dstring-2.19 {appending list elements - bug [46dda6fc29] segfault} -constraints testdstring -setup {
+    testdstring free
+} -body {
+    testdstring element "\\\\"; # Will setfault
+    testdstring get
+} -cleanup {
+    testdstring free
+} -result {}
 
 test dstring-3.1 {nested sublists} -constraints testdstring -setup {
     testdstring free
-- 
cgit v0.12


From aa2b48262b02b2f6f23ba7f032f8ea1fb0bddbe3 Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Sat, 25 Feb 2023 09:26:06 +0000
Subject: Fix and tests for [46dda6fc29]

---
 generic/tclUtil.c  | 4 ++--
 tests/dstring.test | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/generic/tclUtil.c b/generic/tclUtil.c
index e96a564..8f2c16f 100644
--- a/generic/tclUtil.c
+++ b/generic/tclUtil.c
@@ -1143,13 +1143,13 @@ TclScanElement(
 		 */
 
 		requireEscape = 1;
-		length -= (length > 0);
+		length -= (length+1 > 1);
 		p++;
 		break;
 	    }
 	    if ((p[1] == '{') || (p[1] == '}') || (p[1] == '\\')) {
 		extra++;	/* Escape sequences all one byte longer. */
-		length -= (length > 0);
+		length -= (length+1 > 1);
 		p++;
 	    }
 	    forbidNone = 1;
diff --git a/tests/dstring.test b/tests/dstring.test
index 8699a5e..23863d0 100644
--- a/tests/dstring.test
+++ b/tests/dstring.test
@@ -218,7 +218,7 @@ test dstring-2.16 {appending list elements - bug [46dda6fc29] segfault} -constra
     testdstring get
 } -cleanup {
     testdstring free
-} -result {}
+} -result \\\\\\n
 test dstring-2.17 {appending list elements - bug [46dda6fc29] segfault} -constraints testdstring -setup {
     testdstring free
 } -body {
@@ -226,7 +226,7 @@ test dstring-2.17 {appending list elements - bug [46dda6fc29] segfault} -constra
     testdstring get
 } -cleanup {
     testdstring free
-} -result {}
+} -result [list [list \{]]
 test dstring-2.18 {appending list elements - bug [46dda6fc29] segfault} -constraints testdstring -setup {
     testdstring free
 } -body {
@@ -234,7 +234,7 @@ test dstring-2.18 {appending list elements - bug [46dda6fc29] segfault} -constra
     testdstring get
 } -cleanup {
     testdstring free
-} -result {}
+} -result [list [list \}]]
 test dstring-2.19 {appending list elements - bug [46dda6fc29] segfault} -constraints testdstring -setup {
     testdstring free
 } -body {
@@ -242,7 +242,7 @@ test dstring-2.19 {appending list elements - bug [46dda6fc29] segfault} -constra
     testdstring get
 } -cleanup {
     testdstring free
-} -result {}
+} -result [list [list \\]]
 
 test dstring-3.1 {nested sublists} -constraints testdstring -setup {
     testdstring free
-- 
cgit v0.12


From 2a5b403768444ddf2d6379ffe3644e9d5b230e19 Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Sat, 25 Feb 2023 16:29:09 +0000
Subject: Experimental fix for [fb368527ae] - length truncation

---
 generic/tclEncoding.c | 86 +++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 67 insertions(+), 19 deletions(-)

diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index ce5626f..3a39966 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -1160,8 +1160,8 @@ Tcl_ExternalToUtfDStringEx(
     char *dst;
     Tcl_EncodingState state;
     const Encoding *encodingPtr;
-    int result, soFar, srcRead, dstWrote, dstChars;
-    Tcl_Size dstLen;
+    int result;
+    Tcl_Size dstLen, soFar;
     const char *srcStart = src;
 
     Tcl_DStringInit(dstPtr);
@@ -1179,23 +1179,47 @@ Tcl_ExternalToUtfDStringEx(
 	srcLen = encodingPtr->lengthProc(src);
     }
 
-    flags |= TCL_ENCODING_START | TCL_ENCODING_END;
+    flags |= TCL_ENCODING_START;
     if (encodingPtr->toUtfProc == UtfToUtfProc) {
 	flags |= ENCODING_INPUT;
     }
 
     while (1) {
-	result = encodingPtr->toUtfProc(encodingPtr->clientData, src, srcLen,
-		flags, &state, dst, dstLen, &srcRead, &dstWrote, &dstChars);
-	soFar = dst + dstWrote - Tcl_DStringValue(dstPtr);
+	int srcChunkLen, srcChunkRead;
+	int dstChunkLen, dstChunkWrote, dstChunkChars;
+	
+	if (srcLen > INT_MAX) {
+	    srcChunkLen = INT_MAX;
+	} else {
+	    srcChunkLen = srcLen;
+	    flags |= TCL_ENCODING_END; /* Last chunk */
+	}
+	dstChunkLen = dstLen > INT_MAX ? INT_MAX : dstLen;
+
+	result = encodingPtr->toUtfProc(encodingPtr->clientData, src,
+		srcChunkLen, flags, &state, dst, dstChunkLen,
+		&srcChunkRead, &dstChunkWrote, &dstChunkChars);
+	soFar = dst + dstChunkWrote - Tcl_DStringValue(dstPtr);
 
-	src += srcRead;
-	if (result != TCL_CONVERT_NOSPACE) {
+	src += srcChunkRead;
+	srcLen -= srcChunkRead;
+
+	/*
+	 * Keep looping in two case -
+	 *   - our destination buffer did not have enough room
+	 *   - we had not passed in all the data and error indicated fragment
+	 *     of a multibyte character
+	 * In both cases we have to grow buffer, move the input source pointer
+	 * and loop. Otherwise, return the result we got. 
+	 */
+	if ((result != TCL_CONVERT_NOSPACE) &&
+	    !(result == TCL_CONVERT_MULTIBYTE && (flags & TCL_ENCODING_END))) {
 	    Tcl_DStringSetLength(dstPtr, soFar);
 	    return (result == TCL_OK) ? TCL_INDEX_NONE : (Tcl_Size)(src - srcStart);
 	}
+
 	flags &= ~TCL_ENCODING_START;
-	srcLen -= srcRead;
+
 	if (Tcl_DStringLength(dstPtr) == 0) {
 	    Tcl_DStringSetLength(dstPtr, dstLen);
 	}
@@ -1398,9 +1422,9 @@ Tcl_UtfToExternalDStringEx(
     char *dst;
     Tcl_EncodingState state;
     const Encoding *encodingPtr;
-    int result, soFar, srcRead, dstWrote, dstChars;
+    int result;
+    Tcl_Size dstLen, soFar;
     const char *srcStart = src;
-    Tcl_Size dstLen;
 
     Tcl_DStringInit(dstPtr);
     dst = Tcl_DStringValue(dstPtr);
@@ -1416,16 +1440,40 @@ Tcl_UtfToExternalDStringEx(
     } else if (srcLen == TCL_INDEX_NONE) {
 	srcLen = strlen(src);
     }
-    flags |= TCL_ENCODING_START | TCL_ENCODING_END;
+    flags |= TCL_ENCODING_START;
     while (1) {
+	int srcChunkLen, srcChunkRead;
+	int dstChunkLen, dstChunkWrote, dstChunkChars;
+
+	if (srcLen > INT_MAX) {
+	    srcChunkLen = INT_MAX;
+	} else {
+	    srcChunkLen = srcLen;
+	    flags |= TCL_ENCODING_END; /* Last chunk */
+	}
+	dstChunkLen = dstLen > INT_MAX ? INT_MAX : dstLen;
+
 	result = encodingPtr->fromUtfProc(encodingPtr->clientData, src,
-		srcLen, flags, &state, dst, dstLen,
-		&srcRead, &dstWrote, &dstChars);
-	soFar = dst + dstWrote - Tcl_DStringValue(dstPtr);
+		srcChunkLen, flags, &state, dst, dstChunkLen,
+		&srcChunkRead, &dstChunkWrote, &dstChunkChars);
+	soFar = dst + dstChunkWrote - Tcl_DStringValue(dstPtr);
 
-	src += srcRead;
-	if (result != TCL_CONVERT_NOSPACE) {
-	    int i = soFar + encodingPtr->nullSize - 1;
+	/* Move past the part processed in this go around */
+	src += srcChunkRead;
+	srcLen -= srcChunkRead;
+
+	/*
+	 * Keep looping in two case -
+	 *   - our destination buffer did not have enough room
+	 *   - we had not passed in all the data and error indicated fragment
+	 *     of a multibyte character
+	 * In both cases we have to grow buffer, move the input source pointer
+	 * and loop. Otherwise, return the result we got. 
+	 */
+	if ((result != TCL_CONVERT_NOSPACE) &&
+	    !(result == TCL_CONVERT_MULTIBYTE && (flags & TCL_ENCODING_END))) {
+	    size_t i = soFar + encodingPtr->nullSize - 1;
+	    /* Loop as DStringSetLength only stores one nul byte at a time */
 	    while (i >= soFar) {
 		Tcl_DStringSetLength(dstPtr, i--);
 	    }
@@ -1433,7 +1481,7 @@ Tcl_UtfToExternalDStringEx(
 	}
 
 	flags &= ~TCL_ENCODING_START;
-	srcLen -= srcRead;
+
 	if (Tcl_DStringLength(dstPtr) == 0) {
 	    Tcl_DStringSetLength(dstPtr, dstLen);
 	}
-- 
cgit v0.12


From 7b0b2ebd37ef0e7ea2e38a394ee476fed9829a35 Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Sat, 25 Feb 2023 17:23:42 +0000
Subject: Fix large writes to file. Need to break into INT_MAX size chunks.

---
 generic/tclIO.c | 39 ++++++++++++++++++++++++++++++++-------
 1 file changed, 32 insertions(+), 7 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 26d0011..82887d9 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -4231,7 +4231,6 @@ Tcl_WriteObj(
     Channel *chanPtr;
     ChannelState *statePtr;	/* State info for channel */
     const char *src;
-    size_t srcLen = 0;
 
     statePtr = ((Channel *) chan)->state;
     chanPtr = statePtr->topChanPtr;
@@ -4240,19 +4239,45 @@ Tcl_WriteObj(
 	return TCL_INDEX_NONE;
     }
     if (statePtr->encoding == NULL) {
-	size_t result;
+	size_t srcLen;
+	size_t totalWritten = 0;
 
 	src = (char *) Tcl_GetByteArrayFromObj(objPtr, &srcLen);
+	/* TODO - refactor common code below */
 	if (src == NULL) {
 	    Tcl_SetErrno(EILSEQ);
-	    result = TCL_INDEX_NONE;
+	    totalWritten = TCL_INDEX_NONE;
 	} else {
-	    result = WriteBytes(chanPtr, src, srcLen);
-	}
-	return result;
+	    int chunkSize = srcLen > INT_MAX ? INT_MAX : srcLen;
+	    int written;
+	    written = WriteBytes(chanPtr, src, chunkSize);
+	    if (written < 0) {
+		return TCL_INDEX_NONE;
+	    }
+	    totalWritten += written;
+	    srcLen -= chunkSize;
+	} while (srcLen);
+		   
+	return totalWritten;
     } else {
+	size_t srcLen;
+	size_t totalWritten = 0;
 	src = Tcl_GetStringFromObj(objPtr, &srcLen);
-	return WriteChars(chanPtr, src, srcLen);
+	/*
+	 * Note original code always called WriteChars even if srcLen 0
+	 * so we will too.
+	 */
+	do {
+	    int chunkSize = srcLen > INT_MAX ? INT_MAX : srcLen;
+	    int written;
+	    written = WriteChars(chanPtr, src, chunkSize);
+	    if (written < 0) {
+		   return TCL_INDEX_NONE;
+	    }
+	    totalWritten += written;
+	    srcLen -= chunkSize;
+	} while (srcLen);
+	return totalWritten;
     }
 }
 
-- 
cgit v0.12


From 2fb6b99620807fff819ce6c0c7ac60ae4774fc73 Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Sun, 26 Feb 2023 06:26:01 +0000
Subject: Minor refactor, add tests

---
 generic/tclIO.c | 59 ++++++++++++++++++++++++---------------------------------
 tests/io.test   | 29 ++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+), 34 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 82887d9..ff0e7fb 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -4238,47 +4238,38 @@ Tcl_WriteObj(
     if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) {
 	return TCL_INDEX_NONE;
     }
-    if (statePtr->encoding == NULL) {
-	size_t srcLen;
-	size_t totalWritten = 0;
 
+    size_t srcLen;
+    if (statePtr->encoding == NULL) {
 	src = (char *) Tcl_GetByteArrayFromObj(objPtr, &srcLen);
-	/* TODO - refactor common code below */
 	if (src == NULL) {
 	    Tcl_SetErrno(EILSEQ);
-	    totalWritten = TCL_INDEX_NONE;
-	} else {
-	    int chunkSize = srcLen > INT_MAX ? INT_MAX : srcLen;
-	    int written;
-	    written = WriteBytes(chanPtr, src, chunkSize);
-	    if (written < 0) {
-		return TCL_INDEX_NONE;
-	    }
-	    totalWritten += written;
-	    srcLen -= chunkSize;
-	} while (srcLen);
-		   
-	return totalWritten;
+	    return TCL_INDEX_NONE;
+	}
     } else {
-	size_t srcLen;
-	size_t totalWritten = 0;
 	src = Tcl_GetStringFromObj(objPtr, &srcLen);
-	/*
-	 * Note original code always called WriteChars even if srcLen 0
-	 * so we will too.
-	 */
-	do {
-	    int chunkSize = srcLen > INT_MAX ? INT_MAX : srcLen;
-	    int written;
-	    written = WriteChars(chanPtr, src, chunkSize);
-	    if (written < 0) {
-		   return TCL_INDEX_NONE;
-	    }
-	    totalWritten += written;
-	    srcLen -= chunkSize;
-	} while (srcLen);
-	return totalWritten;
     }
+
+    size_t totalWritten = 0;
+    /*
+     * Note original code always called WriteChars even if srcLen 0
+     * so we will too.
+     */
+    do {
+	int chunkSize = srcLen > INT_MAX ? INT_MAX : srcLen;
+	int written;
+	if (statePtr->encoding == NULL) {
+	    written = WriteBytes(chanPtr, src, chunkSize);
+	} else {
+	    written = WriteChars(chanPtr, src, chunkSize);
+	}
+	if (written < 0) {
+	    return TCL_INDEX_NONE;
+	}
+	totalWritten += written;
+	srcLen -= chunkSize;
+    } while (srcLen);
+    return totalWritten;
 }
 
 static void
diff --git a/tests/io.test b/tests/io.test
index cb1c691..83735c3 100644
--- a/tests/io.test
+++ b/tests/io.test
@@ -36,6 +36,7 @@ namespace eval ::tcl::test::io {
     }
     source [file join [file dirname [info script]] tcltests.tcl]
 
+testConstraint pointerIs64bit [expr {$::tcl_platform(pointerSize) >= 8}]
 testConstraint testbytestring [llength [info commands testbytestring]]
 testConstraint testchannel      [llength [info commands testchannel]]
 testConstraint testfevent       [llength [info commands testfevent]]
@@ -194,6 +195,20 @@ test io-1.9 {Tcl_WriteChars: WriteChars} {
     set sizes
 } {19 19 19 19 19}
 
+test io-1.10 {WriteChars: large file (> INT_MAX). Bug 3d01d51bc4} -constraints {
+    pointerIs64bit
+} -setup {
+    set tmpfile [file join [temporaryDirectory] io-1.10.tmp]
+} -cleanup {
+    file delete $tmpfile
+} -body {
+    set fd [open $tmpfile w]
+    puts -nonewline $fd [string repeat A 0x80000000]
+    close $fd
+    # TODO - Should really read it back in but large reads are not currently working!
+    file size $tmpfile
+} -result 2147483648
+
 test io-2.1 {WriteBytes} {
     # loop until all bytes are written
 
@@ -236,6 +251,20 @@ test io-2.4 {WriteBytes: reset sawLF after each buffer} {
     lappend x [contents $path(test1)]
 } [list "abcdefg\nhijklmno" "abcdefg\nhijklmnopqrstuvwxyz"]
 
+test io-2.5 {WriteBytes: large file (> INT_MAX). Bug 3d01d51bc4} -constraints {
+    pointerIs64bit
+} -setup {
+    set tmpfile [file join [temporaryDirectory] io-2.5.tmp]
+} -cleanup {
+    file delete $tmpfile
+} -body {
+    set fd [open $tmpfile wb]
+    puts -nonewline $fd [string repeat A 0x80000000]
+    close $fd
+    # TODO - Should really read it back in but large reads are not currently working!
+    file size $tmpfile
+} -result 2147483648
+
 test io-3.1 {WriteChars: compatibility with WriteBytes} {
     # loop until all bytes are written
 
-- 
cgit v0.12


From deec081e744286a433ade1f6dad4e8fca0a20705 Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Sun, 26 Feb 2023 07:15:06 +0000
Subject: Also fix [90ff9b7f73] - writes of exactly 4294967295 bytes

---
 generic/tclIOCmd.c |  6 +++---
 tests/io.test      | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+), 3 deletions(-)

diff --git a/generic/tclIOCmd.c b/generic/tclIOCmd.c
index 4ce27bb..9493a67 100644
--- a/generic/tclIOCmd.c
+++ b/generic/tclIOCmd.c
@@ -106,7 +106,7 @@ Tcl_PutsObjCmd(
     Tcl_Obj *string;		/* String to write. */
     Tcl_Obj *chanObjPtr = NULL;	/* channel object. */
     int newline;		/* Add a newline at end? */
-    int result;			/* Result of puts operation. */
+    size_t result;		/* Result of puts operation. */
     int mode;			/* Mode in which channel is opened. */
 
     switch (objc) {
@@ -163,12 +163,12 @@ Tcl_PutsObjCmd(
 
     TclChannelPreserve(chan);
     result = Tcl_WriteObj(chan, string);
-    if (result == -1) {
+    if (result == (size_t) -1) {
 	goto error;
     }
     if (newline != 0) {
 	result = Tcl_WriteChars(chan, "\n", 1);
-	if (result == -1) {
+	if (result == (size_t) -1) {
 	    goto error;
 	}
     }
diff --git a/tests/io.test b/tests/io.test
index 83735c3..20b240f 100644
--- a/tests/io.test
+++ b/tests/io.test
@@ -208,6 +208,33 @@ test io-1.10 {WriteChars: large file (> INT_MAX). Bug 3d01d51bc4} -constraints {
     # TODO - Should really read it back in but large reads are not currently working!
     file size $tmpfile
 } -result 2147483648
+test io-1.11 {WriteChars: large file (> UINT_MAX). Bug 3d01d51bc4} -constraints {
+    pointerIs64bit
+} -setup {
+    set tmpfile [file join [temporaryDirectory] io-1.11.tmp]
+} -cleanup {
+    file delete $tmpfile
+} -body {
+    set fd [open $tmpfile w]
+    puts -nonewline $fd [string repeat A 0x100000000]
+    close $fd
+    # TODO - Should really read it back in but large reads are not currently working!
+    file size $tmpfile
+} -result 4294967296
+test io-1.12 {WriteChars: large file (== UINT_MAX). Bug 90ff9b7f73} -constraints {
+    pointerIs64bit
+} -setup {
+    set tmpfile [file join [temporaryDirectory] io-1.12.tmp]
+} -cleanup {
+    file delete $tmpfile
+} -body {
+    set fd [open $tmpfile w]
+    # *Exactly* UINT_MAX - separate bug from the general large file tests
+    puts -nonewline $fd [string repeat A 0xffffffff]
+    close $fd
+    # TODO - Should really read it back in but large reads are not currently working!
+    file size $tmpfile
+} -result 4294967295
 
 test io-2.1 {WriteBytes} {
     # loop until all bytes are written
@@ -264,6 +291,33 @@ test io-2.5 {WriteBytes: large file (> INT_MAX). Bug 3d01d51bc4} -constraints {
     # TODO - Should really read it back in but large reads are not currently working!
     file size $tmpfile
 } -result 2147483648
+test io-2.6 {WriteBytes: large file (> UINT_MAX). Bug 3d01d51bc4} -constraints {
+    pointerIs64bit
+} -setup {
+    set tmpfile [file join [temporaryDirectory] io-2.6.tmp]
+} -cleanup {
+    file delete $tmpfile
+} -body {
+    set fd [open $tmpfile wb]
+    puts -nonewline $fd [string repeat A 0x100000000]
+    close $fd
+    # TODO - Should really read it back in but large reads are not currently working!
+    file size $tmpfile
+} -result 4294967296
+test io-2.7 {WriteBytes: large file (== UINT_MAX). Bug 90ff9b7f73} -constraints {
+    pointerIs64bit
+} -setup {
+    set tmpfile [file join [temporaryDirectory] io-2.7.tmp]
+} -cleanup {
+    file delete $tmpfile
+} -body {
+    set fd [open $tmpfile wb]
+    # *Exactly* UINT_MAX - separate bug from the general large file tests
+    puts -nonewline $fd [string repeat A 0xffffffff]
+    close $fd
+    # TODO - Should really read it back in but large reads are not currently working!
+    file size $tmpfile
+} -result 4294967295
 
 test io-3.1 {WriteChars: compatibility with WriteBytes} {
     # loop until all bytes are written
-- 
cgit v0.12


From 79cbdf745a36be243633e74267ba4dd96e62d8a5 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 26 Feb 2023 12:27:43 +0000
Subject: (size_t) -1 -> TCL_INDEX_NONE

---
 generic/tclIOCmd.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/generic/tclIOCmd.c b/generic/tclIOCmd.c
index 9493a67..197ca32 100644
--- a/generic/tclIOCmd.c
+++ b/generic/tclIOCmd.c
@@ -163,12 +163,12 @@ Tcl_PutsObjCmd(
 
     TclChannelPreserve(chan);
     result = Tcl_WriteObj(chan, string);
-    if (result == (size_t) -1) {
+    if (result == TCL_INDEX_NONE) {
 	goto error;
     }
     if (newline != 0) {
 	result = Tcl_WriteChars(chan, "\n", 1);
-	if (result == (size_t) -1) {
+	if (result == TCL_INDEX_NONE) {
 	    goto error;
 	}
     }
-- 
cgit v0.12


From 5ffda39949b785859a8ab5b9b4977536dde6f9f2 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 26 Feb 2023 12:56:18 +0000
Subject: Move the "srcLen -= srcChunkRead;" past the "if ((result !=
 TCL_CONVERT_NOSPACE)..." (where it originally was), since this isn't needed
 if the loop ends anyway.

---
 generic/tclEncoding.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index 3a39966..a6ecc26 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -1187,7 +1187,7 @@ Tcl_ExternalToUtfDStringEx(
     while (1) {
 	int srcChunkLen, srcChunkRead;
 	int dstChunkLen, dstChunkWrote, dstChunkChars;
-	
+
 	if (srcLen > INT_MAX) {
 	    srcChunkLen = INT_MAX;
 	} else {
@@ -1202,7 +1202,6 @@ Tcl_ExternalToUtfDStringEx(
 	soFar = dst + dstChunkWrote - Tcl_DStringValue(dstPtr);
 
 	src += srcChunkRead;
-	srcLen -= srcChunkRead;
 
 	/*
 	 * Keep looping in two case -
@@ -1210,7 +1209,7 @@ Tcl_ExternalToUtfDStringEx(
 	 *   - we had not passed in all the data and error indicated fragment
 	 *     of a multibyte character
 	 * In both cases we have to grow buffer, move the input source pointer
-	 * and loop. Otherwise, return the result we got. 
+	 * and loop. Otherwise, return the result we got.
 	 */
 	if ((result != TCL_CONVERT_NOSPACE) &&
 	    !(result == TCL_CONVERT_MULTIBYTE && (flags & TCL_ENCODING_END))) {
@@ -1219,6 +1218,7 @@ Tcl_ExternalToUtfDStringEx(
 	}
 
 	flags &= ~TCL_ENCODING_START;
+	srcLen -= srcChunkRead;
 
 	if (Tcl_DStringLength(dstPtr) == 0) {
 	    Tcl_DStringSetLength(dstPtr, dstLen);
@@ -1460,7 +1460,6 @@ Tcl_UtfToExternalDStringEx(
 
 	/* Move past the part processed in this go around */
 	src += srcChunkRead;
-	srcLen -= srcChunkRead;
 
 	/*
 	 * Keep looping in two case -
@@ -1468,7 +1467,7 @@ Tcl_UtfToExternalDStringEx(
 	 *   - we had not passed in all the data and error indicated fragment
 	 *     of a multibyte character
 	 * In both cases we have to grow buffer, move the input source pointer
-	 * and loop. Otherwise, return the result we got. 
+	 * and loop. Otherwise, return the result we got.
 	 */
 	if ((result != TCL_CONVERT_NOSPACE) &&
 	    !(result == TCL_CONVERT_MULTIBYTE && (flags & TCL_ENCODING_END))) {
@@ -1481,6 +1480,7 @@ Tcl_UtfToExternalDStringEx(
 	}
 
 	flags &= ~TCL_ENCODING_START;
+	srcLen -= srcChunkRead;
 
 	if (Tcl_DStringLength(dstPtr) == 0) {
 	    Tcl_DStringSetLength(dstPtr, dstLen);
-- 
cgit v0.12


From cbda5cb9b212067d1d831ec476057502e3c70531 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 26 Feb 2023 16:41:06 +0000
Subject: Make Tcl_UtfToExternal()/Tcl_ExternalToUtf() report the error, if
 srcLen and dstLen are both > INT_MAX and therefore not all characters can be
 handled by this function.

---
 generic/tclEncoding.c | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index ce5626f..67e67e9 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -1229,7 +1229,7 @@ Tcl_ExternalToUtf(
     Tcl_Encoding encoding,	/* The encoding for the source string, or NULL
 				 * for the default system encoding. */
     const char *src,		/* Source string in specified encoding. */
-    Tcl_Size srcLen,		/* Source string length in bytes, or < 0 for
+    Tcl_Size srcLen,		/* Source string length in bytes, or TCL_INDEX_NONE for
 				 * encoding-specific string length. */
     int flags,			/* Conversion control flags. */
     Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
@@ -1271,7 +1271,15 @@ Tcl_ExternalToUtf(
 	srcLen = encodingPtr->lengthProc(src);
     }
     if (statePtr == NULL) {
-	flags |= TCL_ENCODING_START | TCL_ENCODING_END;
+	flags |= TCL_ENCODING_START;
+	if (srcLen > INT_MAX) {
+	    srcLen = INT_MAX;
+	} else {
+	    flags |= TCL_ENCODING_END;
+	}
+	if (dstLen > INT_MAX) {
+	    dstLen = INT_MAX;
+	}
 	statePtr = &state;
     }
     if (srcReadPtr == NULL) {
@@ -1467,7 +1475,7 @@ Tcl_UtfToExternal(
     Tcl_Encoding encoding,	/* The encoding for the converted string, or
 				 * NULL for the default system encoding. */
     const char *src,		/* Source string in UTF-8. */
-    Tcl_Size srcLen,		/* Source string length in bytes, or < 0 for
+    Tcl_Size srcLen,		/* Source string length in bytes, or TCL_INDEX_NONE for
 				 * strlen(). */
     int flags,			/* Conversion control flags. */
     Tcl_EncodingState *statePtr,/* Place for conversion routine to store state
@@ -1506,7 +1514,15 @@ Tcl_UtfToExternal(
 	srcLen = strlen(src);
     }
     if (statePtr == NULL) {
-	flags |= TCL_ENCODING_START | TCL_ENCODING_END;
+	flags |= TCL_ENCODING_START;
+	if (srcLen > INT_MAX) {
+	    srcLen = INT_MAX;
+	} else {
+	    flags |= TCL_ENCODING_END;
+	}
+	if (dstLen > INT_MAX) {
+	    dstLen = INT_MAX;
+	}
 	statePtr = &state;
     }
     if (srcReadPtr == NULL) {
-- 
cgit v0.12


From baf9b5e9bb89e1e13583fb510f6cb134d39126ff Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 26 Feb 2023 16:54:02 +0000
Subject: Handle statePtr != NULL as well

---
 generic/tclEncoding.c | 34 ++++++++++++++++------------------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index 67e67e9..e639d3a 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -1271,17 +1271,16 @@ Tcl_ExternalToUtf(
 	srcLen = encodingPtr->lengthProc(src);
     }
     if (statePtr == NULL) {
-	flags |= TCL_ENCODING_START;
-	if (srcLen > INT_MAX) {
-	    srcLen = INT_MAX;
-	} else {
-	    flags |= TCL_ENCODING_END;
-	}
-	if (dstLen > INT_MAX) {
-	    dstLen = INT_MAX;
-	}
+	flags |= TCL_ENCODING_START | TCL_ENCODING_END;
 	statePtr = &state;
     }
+    if (srcLen > INT_MAX) {
+	srcLen = INT_MAX;
+	flags &= ~TCL_ENCODING_END;
+    }
+    if (dstLen > INT_MAX) {
+	dstLen = INT_MAX;
+    }
     if (srcReadPtr == NULL) {
 	srcReadPtr = &srcRead;
     }
@@ -1514,17 +1513,16 @@ Tcl_UtfToExternal(
 	srcLen = strlen(src);
     }
     if (statePtr == NULL) {
-	flags |= TCL_ENCODING_START;
-	if (srcLen > INT_MAX) {
-	    srcLen = INT_MAX;
-	} else {
-	    flags |= TCL_ENCODING_END;
-	}
-	if (dstLen > INT_MAX) {
-	    dstLen = INT_MAX;
-	}
+	flags |= TCL_ENCODING_START | TCL_ENCODING_END;
 	statePtr = &state;
     }
+    if (srcLen > INT_MAX) {
+	srcLen = INT_MAX;
+	flags &= ~TCL_ENCODING_END;
+    }
+    if (dstLen > INT_MAX) {
+	dstLen = INT_MAX;
+    }
     if (srcReadPtr == NULL) {
 	srcReadPtr = &srcRead;
     }
-- 
cgit v0.12


From 152d7203ac1b3f7f560995985c15f7527f2ecdc9 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 26 Feb 2023 17:19:07 +0000
Subject: Handle Tcl_UtfToExternal error in tclZlib.c

---
 generic/tclZlib.c | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/generic/tclZlib.c b/generic/tclZlib.c
index 5a6dbc4..ea18c16 100644
--- a/generic/tclZlib.c
+++ b/generic/tclZlib.c
@@ -444,9 +444,13 @@ GenerateHeader(
 	goto error;
     } else if (value != NULL) {
 	valueStr = Tcl_GetStringFromObj(value, &length);
-	Tcl_UtfToExternal(NULL, latin1enc, valueStr, length, 0, NULL,
+	if (Tcl_UtfToExternal(NULL, latin1enc, valueStr, length, 0, NULL,
 		headerPtr->nativeCommentBuf, MAX_COMMENT_LEN-1, NULL, &len,
-		NULL);
+		NULL) != TCL_OK) {
+	    result = TCL_ERROR;
+	    Tcl_AppendResult(interp, "Cannot encode comment", NULL);
+	    goto error;
+	}
 	headerPtr->nativeCommentBuf[len] = '\0';
 	headerPtr->header.comment = (Bytef *) headerPtr->nativeCommentBuf;
 	if (extraSizePtr != NULL) {
@@ -465,8 +469,13 @@ GenerateHeader(
 	goto error;
     } else if (value != NULL) {
 	valueStr = Tcl_GetStringFromObj(value, &length);
-	Tcl_UtfToExternal(NULL, latin1enc, valueStr, length, 0, NULL,
-		headerPtr->nativeFilenameBuf, MAXPATHLEN-1, NULL, &len, NULL);
+	if (Tcl_UtfToExternal(NULL, latin1enc, valueStr, length, 0, NULL,
+		headerPtr->nativeCommentBuf, MAX_COMMENT_LEN-1, NULL, &len,
+		NULL) != TCL_OK) {
+	    result = TCL_ERROR;
+	    Tcl_AppendResult(interp, "Cannot encode filename", NULL);
+	    goto error;
+	}
 	headerPtr->nativeFilenameBuf[len] = '\0';
 	headerPtr->header.name = (Bytef *) headerPtr->nativeFilenameBuf;
 	if (extraSizePtr != NULL) {
-- 
cgit v0.12


From ed360ca42f9908e5d8da5e8f4742b07d0b148b17 Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Mon, 27 Feb 2023 03:13:38 +0000
Subject: Add perf constraint to large io tests to prevent memory faults on
 systems with limited memory

---
 tests/io.test | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/io.test b/tests/io.test
index 20b240f..c245add 100644
--- a/tests/io.test
+++ b/tests/io.test
@@ -196,7 +196,7 @@ test io-1.9 {Tcl_WriteChars: WriteChars} {
 } {19 19 19 19 19}
 
 test io-1.10 {WriteChars: large file (> INT_MAX). Bug 3d01d51bc4} -constraints {
-    pointerIs64bit
+    pointerIs64bit perf
 } -setup {
     set tmpfile [file join [temporaryDirectory] io-1.10.tmp]
 } -cleanup {
@@ -209,7 +209,7 @@ test io-1.10 {WriteChars: large file (> INT_MAX). Bug 3d01d51bc4} -constraints {
     file size $tmpfile
 } -result 2147483648
 test io-1.11 {WriteChars: large file (> UINT_MAX). Bug 3d01d51bc4} -constraints {
-    pointerIs64bit
+    pointerIs64bit perf
 } -setup {
     set tmpfile [file join [temporaryDirectory] io-1.11.tmp]
 } -cleanup {
@@ -222,7 +222,7 @@ test io-1.11 {WriteChars: large file (> UINT_MAX). Bug 3d01d51bc4} -constraints
     file size $tmpfile
 } -result 4294967296
 test io-1.12 {WriteChars: large file (== UINT_MAX). Bug 90ff9b7f73} -constraints {
-    pointerIs64bit
+    pointerIs64bit perf
 } -setup {
     set tmpfile [file join [temporaryDirectory] io-1.12.tmp]
 } -cleanup {
@@ -279,7 +279,7 @@ test io-2.4 {WriteBytes: reset sawLF after each buffer} {
 } [list "abcdefg\nhijklmno" "abcdefg\nhijklmnopqrstuvwxyz"]
 
 test io-2.5 {WriteBytes: large file (> INT_MAX). Bug 3d01d51bc4} -constraints {
-    pointerIs64bit
+    pointerIs64bit perf
 } -setup {
     set tmpfile [file join [temporaryDirectory] io-2.5.tmp]
 } -cleanup {
@@ -292,7 +292,7 @@ test io-2.5 {WriteBytes: large file (> INT_MAX). Bug 3d01d51bc4} -constraints {
     file size $tmpfile
 } -result 2147483648
 test io-2.6 {WriteBytes: large file (> UINT_MAX). Bug 3d01d51bc4} -constraints {
-    pointerIs64bit
+    pointerIs64bit perf
 } -setup {
     set tmpfile [file join [temporaryDirectory] io-2.6.tmp]
 } -cleanup {
@@ -305,7 +305,7 @@ test io-2.6 {WriteBytes: large file (> UINT_MAX). Bug 3d01d51bc4} -constraints {
     file size $tmpfile
 } -result 4294967296
 test io-2.7 {WriteBytes: large file (== UINT_MAX). Bug 90ff9b7f73} -constraints {
-    pointerIs64bit
+    pointerIs64bit perf
 } -setup {
     set tmpfile [file join [temporaryDirectory] io-2.7.tmp]
 } -cleanup {
-- 
cgit v0.12


From e2d89615d52e47ed3b683498567e058e809aea39 Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Mon, 27 Feb 2023 04:15:07 +0000
Subject: Tests for encoding strings > 4GB (under perf constraint)

---
 tests/encoding.test | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/tests/encoding.test b/tests/encoding.test
index e0e1598..8b14353 100644
--- a/tests/encoding.test
+++ b/tests/encoding.test
@@ -1046,6 +1046,32 @@ test encoding-29.0 {get encoding nul terminator lengths} -constraints {
         [testencoding nullength ksc5601]
 } -result {1 2 4 2 2}
 
+test encoding-30.0 {encoding convertto large strings UINT_MAX} -constraints {
+    perf
+} -body {
+    # Test to ensure not misinterpreted as -1
+    list [string length [set s [string repeat A 0xFFFFFFFF]]] [string equal $s [encoding convertto ascii $s]]
+} -result {4294967295 1}
+
+test encoding-30.1 {encoding convertto large strings > 4GB} -constraints {
+    perf
+} -body {
+    list [string length [set s [string repeat A 0x100000000]]] [string equal $s [encoding convertto ascii $s]]
+} -result {4294967296 1}
+
+test encoding-30.2 {encoding convertfrom large strings UINT_MAX} -constraints {
+    perf
+} -body {
+    # Test to ensure not misinterpreted as -1
+    list [string length [set s [string repeat A 0xFFFFFFFF]]] [string equal $s [encoding convertfrom ascii $s]]
+} -result {4294967295 1}
+
+test encoding-30.3 {encoding convertfrom large strings > 4GB} -constraints {
+    perf
+} -body {
+    list [string length [set s [string repeat A 0x100000000]]] [string equal $s [encoding convertfrom ascii $s]]
+} -result {4294967296 1}
+
 
 # cleanup
 namespace delete ::tcl::test::encoding
-- 
cgit v0.12


From 85bf0db1e84ab483fce7962c151bedeb3f5e0993 Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Mon, 27 Feb 2023 12:31:49 +0000
Subject: Fix crash. int->size_t needs +1 in comparisons.

---
 generic/tclEncoding.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index a6ecc26..d0756c7 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -1473,7 +1473,7 @@ Tcl_UtfToExternalDStringEx(
 	    !(result == TCL_CONVERT_MULTIBYTE && (flags & TCL_ENCODING_END))) {
 	    size_t i = soFar + encodingPtr->nullSize - 1;
 	    /* Loop as DStringSetLength only stores one nul byte at a time */
-	    while (i >= soFar) {
+	    while (i+1 >= soFar+1) {
 		Tcl_DStringSetLength(dstPtr, i--);
 	    }
 	    return (result == TCL_OK) ? TCL_INDEX_NONE : (Tcl_Size)(src - srcStart);
-- 
cgit v0.12


From a947270ff77379afdeda26a33f5f444337b820bc Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Tue, 28 Feb 2023 07:45:27 +0000
Subject: In case of combining TIP #494 (TCL_8_COMPAT) and #628 (building for
 Tcl 8.7 with 9.0 headers), ignore TCL_8_COMPAT  macro. More Tcl_Size usage.

---
 generic/tcl.h      | 14 +++++++-------
 generic/tclDecls.h |  2 +-
 generic/tclTest.c  | 22 +++++++++++-----------
 3 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/generic/tcl.h b/generic/tcl.h
index fa4da26..1a1452e 100644
--- a/generic/tcl.h
+++ b/generic/tcl.h
@@ -311,10 +311,10 @@ typedef unsigned TCL_WIDE_INT_TYPE	Tcl_WideUInt;
 #define Tcl_WideAsDouble(val)	((double)((Tcl_WideInt)(val)))
 #define Tcl_DoubleAsWide(val)	((Tcl_WideInt)((double)(val)))
 
-#if TCL_MAJOR_VERSION > 8
-typedef size_t Tcl_Size;
-#else
+#if TCL_MAJOR_VERSION < 9
 typedef int Tcl_Size;
+#else
+typedef size_t Tcl_Size;
 #endif
 
 #ifdef _WIN32
@@ -452,17 +452,17 @@ typedef void (Tcl_ThreadCreateProc) (void *clientData);
 
 #if TCL_MAJOR_VERSION > 8
 typedef struct Tcl_RegExpIndices {
-    size_t start;			/* Character offset of first character in
+    Tcl_Size start;			/* Character offset of first character in
 				 * match. */
-    size_t end;			/* Character offset of first character after
+    Tcl_Size end;			/* Character offset of first character after
 				 * the match. */
 } Tcl_RegExpIndices;
 
 typedef struct Tcl_RegExpInfo {
-    size_t nsubs;			/* Number of subexpressions in the compiled
+    Tcl_Size nsubs;			/* Number of subexpressions in the compiled
 				 * expression. */
     Tcl_RegExpIndices *matches;	/* Array of nsubs match offset pairs. */
-    size_t extendStart;		/* The offset at which a subsequent match
+    Tcl_Size extendStart;		/* The offset at which a subsequent match
 				 * might begin. */
 } Tcl_RegExpInfo;
 #else
diff --git a/generic/tclDecls.h b/generic/tclDecls.h
index f219500..ed2eb74 100644
--- a/generic/tclDecls.h
+++ b/generic/tclDecls.h
@@ -4229,7 +4229,7 @@ extern const TclStubs *tclStubsPtr;
 #define Tcl_GlobalEvalObj(interp, objPtr) \
     Tcl_EvalObjEx(interp, objPtr, TCL_EVAL_GLOBAL)
 
-#if defined(TCL_8_COMPAT) && !defined(BUILD_tcl)
+#if defined(TCL_8_COMPAT) && !defined(BUILD_tcl) && TCL_MAJOR_VERSION > 8
 #   ifdef USE_TCL_STUBS
 #	undef Tcl_Gets
 #	undef Tcl_GetsObj
diff --git a/generic/tclTest.c b/generic/tclTest.c
index 652c5aa..b6c7f77 100644
--- a/generic/tclTest.c
+++ b/generic/tclTest.c
@@ -4105,7 +4105,7 @@ TestregexpObjCmd(
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
     int i, indices, stringLength, match, about;
-    size_t ii;
+    Tcl_Size ii;
     int hasxflags, cflags, eflags;
     Tcl_RegExp regExpr;
     const char *string;
@@ -4217,7 +4217,7 @@ TestregexpObjCmd(
 	if (objc > 2 && (cflags&REG_EXPECT) && indices) {
 	    const char *varName;
 	    const char *value;
-	    size_t start, end;
+	    Tcl_Size start, end;
 	    char resinfo[TCL_INTEGER_SPACE * 2];
 
 	    varName = Tcl_GetString(objv[2]);
@@ -4257,11 +4257,11 @@ TestregexpObjCmd(
 
     Tcl_RegExpGetInfo(regExpr, &info);
     for (i = 0; i < objc; i++) {
-	size_t start, end;
+	Tcl_Size start, end;
 	Tcl_Obj *newPtr, *varPtr, *valuePtr;
 
 	varPtr = objv[i];
-	ii = ((cflags&REG_EXPECT) && i == objc-1) ? TCL_INDEX_NONE : (size_t)i;
+	ii = ((cflags&REG_EXPECT) && i == objc-1) ? TCL_INDEX_NONE : (Tcl_Size)i;
 	if (indices) {
 	    Tcl_Obj *objs[2];
 
@@ -6476,10 +6476,10 @@ static int
 TestWrongNumArgsObjCmd(
     TCL_UNUSED(void *),
     Tcl_Interp *interp,		/* Current interpreter. */
-    size_t objc,			/* Number of arguments. */
+    Tcl_Size objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    size_t i, length;
+    Tcl_Size i, length;
     const char *msg;
 
     if (objc + 1 < 4) {
@@ -7187,7 +7187,7 @@ TestUtfPrevCmd(
     int objc,
     Tcl_Obj *const objv[])
 {
-    size_t numBytes, offset;
+    Tcl_Size numBytes, offset;
     char *bytes;
     const char *result;
 
@@ -7228,7 +7228,7 @@ TestNumUtfCharsCmd(
     Tcl_Obj *const objv[])
 {
     if (objc > 1) {
-	size_t numBytes, len, limit = TCL_INDEX_NONE;
+	Tcl_Size numBytes, len, limit = TCL_INDEX_NONE;
 	const char *bytes = Tcl_GetStringFromObj(objv[1], &numBytes);
 
 	if (objc > 2) {
@@ -7296,7 +7296,7 @@ TestGetIntForIndexCmd(
     int objc,
     Tcl_Obj *const objv[])
 {
-    size_t result;
+    Tcl_Size result;
     Tcl_WideInt endvalue;
 
     if (objc != 3) {
@@ -7415,7 +7415,7 @@ TestHashSystemHashCmd(
 	Tcl_SetHashValue(hPtr, INT2PTR(i+42));
     }
 
-    if (hash.numEntries != (size_t)limit) {
+    if (hash.numEntries != (Tcl_Size)limit) {
 	Tcl_AppendResult(interp, "unexpected maximal size", NULL);
 	Tcl_DeleteHashTable(&hash);
 	return TCL_ERROR;
@@ -8175,7 +8175,7 @@ static int
 InterpCompiledVarResolver(
     TCL_UNUSED(Tcl_Interp *),
     const char *name,
-    TCL_UNUSED(size_t) /*length*/,
+    TCL_UNUSED(Tcl_Size) /*length*/,
     TCL_UNUSED(Tcl_Namespace *),
     Tcl_ResolvedVarInfo **rPtr)
 {
-- 
cgit v0.12


From 8b417f0e1ec2ff11fe856ea3d521356489c8dae0 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Tue, 28 Feb 2023 09:59:29 +0000
Subject: Fix formatting issue in Tcl.n

---
 doc/Tcl.n | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/doc/Tcl.n b/doc/Tcl.n
index 8e0b342..0f784af 100644
--- a/doc/Tcl.n
+++ b/doc/Tcl.n
@@ -156,6 +156,8 @@ special processing.
 The following table lists the backslash sequences that are
 handled specially, along with the value that replaces each sequence.
 .RS
+.RS
+.RS
 .TP 7
 \e\fBa\fR
 Audible alert (bell) (Unicode U+000007).
@@ -222,6 +224,7 @@ inserted, in the range U+000000\(enU+10FFFF.  The parser will stop just
 before this range overflows, or when the maximum of eight digits
 is reached.  The upper bits of the Unicode character will be 0.
 .RE
+.RE
 .PP
 Backslash substitution is not performed on words enclosed in braces,
 except for backslash-newline as described above.
-- 
cgit v0.12


From 57d266423a5638cbedc01dc406d5af47a146ca20 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Tue, 28 Feb 2023 10:13:25 +0000
Subject: Make the descriptions in doc/Tcl.n more concise and intuitive.

---
 doc/Tcl.n | 315 ++++++++++++++++++++++++--------------------------------------
 1 file changed, 121 insertions(+), 194 deletions(-)

diff --git a/doc/Tcl.n b/doc/Tcl.n
index 0f784af..d13f3ea 100644
--- a/doc/Tcl.n
+++ b/doc/Tcl.n
@@ -1,6 +1,7 @@
 '\"
 '\" Copyright (c) 1993 The Regents of the University of California.
 '\" Copyright (c) 1994-1996 Sun Microsystems, Inc.
+'\" Copyright (c) 2023 Nathan Coulter
 '\"
 '\" See the file "license.terms" for information on usage and redistribution
 '\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
@@ -16,178 +17,152 @@ Summary of Tcl language syntax.
 .SH DESCRIPTION
 .PP
 The following rules define the syntax and semantics of the Tcl language:
-.IP "[1] \fBCommands.\fR"
-A Tcl script is a string containing one or more commands.
-Semi-colons and newlines are command separators unless quoted as
-described below.
-Close brackets are command terminators during command substitution
-(see below) unless quoted.
-.IP "[2] \fBEvaluation.\fR"
-A command is evaluated in two steps.
-First, the Tcl interpreter breaks the command into \fIwords\fR
-and performs substitutions as described below.
-These substitutions are performed in the same way for all
-commands.
-Secondly, the first word is used to locate a routine to
-carry out the command, and the remaining words of the command are
-passed to that routine.
-The routine is free to interpret each of its words
-in any way it likes, such as an integer, variable name, list,
-or Tcl script.
-Different commands interpret their words differently.
-.IP "[3] \fBWords.\fR"
-Words of a command are separated by white space (except for
-newlines, which are command separators).
-.IP "[4] \fBDouble quotes.\fR"
-If the first character of a word is double-quote
+.
+.IP "[1] \fBScript.\fR"
+A script is composed of zero or more commands delimited by semi-colons or
+newlines.
+.IP "[2] \fBCommand.\fR"
+A command is composed of zero or more words delimited by whitespace.  The
+replacement for a substitution is included verbatim in the word. For example, a
+space in the replacement is included in the word rather than becoming a
+delimiter, and \fI\\\\\fR becomes a single backslash in the word.  Each word is
+processed from left to right and each substitution is performed as soon as it
+is complete.
+For example, the command
+.RS
+.PP
+.CS
+set y [set x 0][incr x][incr x]
+.CE
+.PP
+is composed of three words, and sets the value of \fIy\fR to \fI012\fR.
+.PP
+If hash
+.PQ #
+is the first character of what would otherwise be the first word of a command,
+all characters up to the next newline are ignored.
+.RE
+.
+.IP "[3] \fBBraced word.\fR"
+If a word is enclosed in braces
+.PQ {
+and
+.PQ } ""
+, the braces are removed and the enclosed characters become the word.  No
+substitutions are performed.  Nested pairs of braces may occur within the word.
+A brace preceded by an odd number of backslashes is not considered part of a
+pair, and neither brace nor the backslashes are removed from the word.
+.
+.IP "[4] \fBQuoted word.\fR"
+If a word is enclosed in double quotes
 .PQ \N'34'
-then the word is terminated by the next double-quote character.
-If semi-colons, close brackets, or white space characters
-(including newlines) appear between the quotes then they are treated
-as ordinary characters and included in the word.
-Command substitution, variable substitution, and backslash substitution
-are performed on the characters between the quotes as described below.
-The double-quotes are not retained as part of the word.
-.IP "[5] \fBArgument expansion.\fR"
-If a word starts with the string
-.QW {*}
-followed by a non-whitespace character, then the leading
+, the double quotes are removed and the enclosed characters become the word.
+Substitutions are performed.
+.
+.IP "[5] \fBList.\fR"
+A list has the form of a single command.  Newline is whitespace, and semicolon
+has no special interpretation.  There is no script evaluation so there is no
+argument expansion, variable substitution, or command substitution: Dollar-sign
+and open bracket have no special interpretation, and what would be argument
+expansion in a script is invalid in a list.
+.
+.IP "[6] \fBArgument expansion.\fR"
+If
 .QW {*}
-is removed and the rest of the word is parsed and substituted as any other
-word. After substitution, the word is parsed as a list (without command or
-variable substitutions; backslash substitutions are performed as is normal for
-a list and individual internal words may be surrounded by either braces or
-double-quote characters), and its words are added to the command being
-substituted. For instance,
-.QW "cmd a {*}{b [c]} d {*}{$e f {g h}}"
+prefixes a word, it is removed.  After any remaining enclosing braces or quotes
+are processed and applicable substitutions performed, the word, which must
+be a list, is removed from the command, and in its place each word in the
+list becomes an additional word in the command.  For example,
+.CS
+cmd a {*}{b [c]} d {*}{$e f {g h}}
+.CE
 is equivalent to
-.QW "cmd a b {[c]} d {$e} f {g h}" .
-.IP "[6] \fBBraces.\fR"
-If the first character of a word is an open brace
-.PQ {
-and rule [5] does not apply, then
-the word is terminated by the matching close brace
-.PQ } "" .
-Braces nest within the word: for each additional open
-brace there must be an additional close brace (however,
-if an open brace or close brace within the word is
-quoted with a backslash then it is not counted in locating the
-matching close brace).
-No substitutions are performed on the characters between the
-braces except for backslash-newline substitutions described
-below, nor do semi-colons, newlines, close brackets,
-or white space receive any special interpretation.
-The word will consist of exactly the characters between the
-outer braces, not including the braces themselves.
-.IP "[7] \fBCommand substitution.\fR"
-If a word contains an open bracket
+.CS
+cmd a b {[c]} d {$e} f {g h} .
+.CE
+.
+.IP "[7] \fBEvaluation.\fR"
+To evaluate a script, an interpreter evaluates each successive command.  The
+first word identifies a procedure, and the remaining words are passed to that
+procedure for further evaluation.  The procedure interprets each argument in
+its own way, e.g. as an integer, variable name, list, mathematical expression,
+script, or in some other arbitrary way.  The result of the last command is the
+result of the script.
+.
+.IP "[8] \fBCommand substitution.\fR"
+Each pair of brackets
 .PQ [
-then Tcl performs \fIcommand substitution\fR.
-To do this it invokes the Tcl interpreter recursively to process
-the characters following the open bracket as a Tcl script.
-The script may contain any number of commands and must be terminated
-by a close bracket
-.PQ ] "" .
-The result of the script (i.e. the result of its last command) is
-substituted into the word in place of the brackets and all of the
-characters between them.
-There may be any number of command substitutions in a single word.
-Command substitution is not performed on words enclosed in braces.
-.IP "[8] \fBVariable substitution.\fR"
-If a word contains a dollar-sign
+and 
+.PQ ] ""
+encloses a script and is replaced by the result of that script.
+.IP "[9] \fBVariable substitution.\fR"
+Each of the following forms begins with dollar sign
 .PQ $
-followed by one of the forms
-described below, then Tcl performs \fIvariable
-substitution\fR:  the dollar-sign and the following characters are
-replaced in the word by the value of a variable.
-Variable substitution may take any of the following forms:
+and is replaced by the value of the identified variable.  \fIname\fR names the
+variable and is composed of ASCII letters (\fBA\fR\(en\fBZ\fR and
+\fBa\fR\(en\fBz\fR), digits (\fB0\fR\(en\fB9\fR), underscores, or namespace
+delimiters (two or more colons).  \fIindex\fR is the name of an individual
+variable within an array variable, and may be empty.
 .RS
 .TP 15
 \fB$\fIname\fR
 .
-\fIName\fR is the name of a scalar variable;  the name is a sequence
-of one or more characters that are a letter, digit, underscore,
-or namespace separators (two or more colons).
-Letters and digits are \fIonly\fR the standard ASCII ones (\fB0\fR\(en\fB9\fR,
-\fBA\fR\(en\fBZ\fR and \fBa\fR\(en\fBz\fR).
+\fIname\fR may not be empty.
+
 .TP 15
 \fB$\fIname\fB(\fIindex\fB)\fR
 .
-\fIName\fR gives the name of an array variable and \fIindex\fR gives
-the name of an element within that array.
-\fIName\fR must contain only letters, digits, underscores, and
-namespace separators, and may be an empty string.
-Letters and digits are \fIonly\fR the standard ASCII ones (\fB0\fR\(en\fB9\fR,
-\fBA\fR\(en\fBZ\fR and \fBa\fR\(en\fBz\fR).
-Command substitutions, variable substitutions, and backslash
-substitutions are performed on the characters of \fIindex\fR.
+\fIname\fR may be empty.  Substitutions are performed on \fIindex\fR.
 .TP 15
 \fB${\fIname\fB}\fR
+\fIname\fR may be empty.
+.TP 15
+\fB${\fIname(index)\fB}\fR
 .
-\fIName\fR is the name of a scalar variable or array element.  It may contain
-any characters whatsoever except for close braces.  It indicates an array
-element if \fIname\fR is in the form
-.QW \fIarrayName\fB(\fIindex\fB)\fR
-where \fIarrayName\fR does not contain any open parenthesis characters,
-.QW \fB(\fR ,
-or close brace characters,
-.QW \fB}\fR ,
-and \fIindex\fR can be any sequence of characters except for close brace
-characters.  No further
-substitutions are performed during the parsing of \fIname\fR.
-.PP
-There may be any number of variable substitutions in a single word.
-Variable substitution is not performed on words enclosed in braces.
-.PP
-Note that variables may contain character sequences other than those listed
-above, but in that case other mechanisms must be used to access them (e.g.,
-via the \fBset\fR command's single-argument form).
+\fIname\fR may be empty. No substitutions are performed.
 .RE
-.IP "[9] \fBBackslash substitution.\fR"
-If a backslash
+Variables that are not accessible through one of the forms above may be
+accessed through other mechanisms, e.g. the \fBset\fR command.
+.IP "[10] \fBBackslash substitution.\fR"
+Each backslash
 .PQ \e
-appears within a word then \fIbackslash substitution\fR occurs.
-In all cases but those described below the backslash is dropped and
-the following character is treated as an ordinary
-character and included in the word.
-This allows characters such as double quotes, close brackets,
-and dollar signs to be included in words without triggering
-special processing.
-The following table lists the backslash sequences that are
-handled specially, along with the value that replaces each sequence.
+that is not part of one of the forms listed below is removed, and the next
+character is included in the word verbatim, which allows the inclusion of
+characters that would normally be interpreted, namely whitespace, braces,
+brackets, double quote, dollar sign, and backslash.  The following sequences
+are replaced as described:
 .RS
 .RS
 .RS
 .TP 7
 \e\fBa\fR
-Audible alert (bell) (Unicode U+000007).
+Audible alert (bell) (U+7).
 .TP 7
 \e\fBb\fR
-Backspace (Unicode U+000008).
+Backspace (U+8).
 .TP 7
 \e\fBf\fR
-Form feed (Unicode U+00000C).
+Form feed (U+C).
 .TP 7
 \e\fBn\fR
-Newline (Unicode U+00000A).
+Newline (U+A).
 .TP 7
 \e\fBr\fR
-Carriage-return (Unicode U+00000D).
+Carriage-return (U+D).
 .TP 7
 \e\fBt\fR
-Tab (Unicode U+000009).
+Tab (U+9).
 .TP 7
 \e\fBv\fR
-Vertical tab (Unicode U+00000B).
+Vertical tab (U+B).
 .TP 7
 \e\fB<newline>\fIwhiteSpace\fR
 .
-A single space character replaces the backslash, newline, and all spaces
-and tabs after the newline.  This backslash sequence is unique in that it
-is replaced in a separate pre-pass before the command is actually parsed.
-This means that it will be replaced even when it occurs between braces,
-and the resulting space will be treated as a word separator if it is not
-in braces or quotes.
+Newline preceded by an odd number of backslashes, along with the consecutive
+spaces and tabs that immediately follow it, is replaced by a single space.
+Because this happens before the command is split into words, it occurs even
+within braced words, and if the resulting space may subsequently be treated as
+a word delimiter.
 .TP 7
 \e\e
 Backslash
@@ -195,78 +170,30 @@ Backslash
 .TP 7
 \e\fIooo\fR
 .
-The digits \fIooo\fR (one, two, or three of them) give a eight-bit octal
-value for the Unicode character that will be inserted, in the range
-\fI000\fR\(en\fI377\fR (i.e., the range U+000000\(enU+0000FF).
-The parser will stop just before this range overflows, or when
-the maximum of three digits is reached.  The upper bits of the Unicode
-character will be 0.
+Up to three octal digits form an eight-bit value for a Unicode character in the
+range \fI0\fR\(en\fI377\fR, i.e. U+0\(enU+FF.  Only the digits that result in a
+number in this range are consumed.
 .TP 7
 \e\fBx\fIhh\fR
 .
-The hexadecimal digits \fIhh\fR (one or two of them) give an eight-bit
-hexadecimal value for the Unicode character that will be inserted.  The upper
-bits of the Unicode character will be 0 (i.e., the character will be in the
-range U+000000\(enU+0000FF).
+Up to two hexadecimal digits form an eight-bit value for a Unicode character in
+the range \fI0\fR\(en\fIFF\fR.
 .TP 7
 \e\fBu\fIhhhh\fR
 .
-The hexadecimal digits \fIhhhh\fR (one, two, three, or four of them) give a
-sixteen-bit hexadecimal value for the Unicode character that will be
-inserted.  The upper bits of the Unicode character will be 0 (i.e., the
-character will be in the range U+000000\(enU+00FFFF).
+Up to four hexadecimal digits form a 16-bit value for a Unicode character in
+the range \fI0\fR\(en\fIFFFF\fR.
 .TP 7
 \e\fBU\fIhhhhhhhh\fR
 .
-The hexadecimal digits \fIhhhhhhhh\fR (one up to eight of them) give a
-twenty-one-bit hexadecimal value for the Unicode character that will be
-inserted, in the range U+000000\(enU+10FFFF.  The parser will stop just
-before this range overflows, or when the maximum of eight digits
-is reached.  The upper bits of the Unicode character will be 0.
-.RE
+Up to eight hexadecimal digits form a 21-bit value for a Unicode character in
+the range \fI0\fR\(en\fI10FFFF\fR.  Only the digits that result in a number in
+this range are consumed.
 .RE
-.PP
-Backslash substitution is not performed on words enclosed in braces,
-except for backslash-newline as described above.
 .RE
-.IP "[10] \fBComments.\fR"
-If a hash character
-.PQ #
-appears at a point where Tcl is
-expecting the first character of the first word of a command,
-then the hash character and the characters that follow it, up
-through the next newline, are treated as a comment and ignored.
-The comment character only has significance when it appears
-at the beginning of a command.
-.IP "[11] \fBOrder of substitution.\fR"
-Each character is processed exactly once by the Tcl interpreter
-as part of creating the words of a command.
-For example, if variable substitution occurs then no further
-substitutions are performed on the value of the variable;  the
-value is inserted into the word verbatim.
-If command substitution occurs then the nested command is
-processed entirely by the recursive call to the Tcl interpreter;
-no substitutions are performed before making the recursive
-call and no additional substitutions are performed on the result
-of the nested script.
-.RS
 .PP
-Substitutions take place from left to right, and each substitution is
-evaluated completely before attempting to evaluate the next.  Thus, a
-sequence like
-.PP
-.CS
-set y [set x 0][incr x][incr x]
-.CE
-.PP
-will always set the variable \fIy\fR to the value, \fI012\fR.
 .RE
-.IP "[12] \fBSubstitution and word boundaries.\fR"
-Substitutions do not affect the word boundaries of a command,
-except for argument expansion as specified in rule [5].
-For example, during variable substitution the entire value of
-the variable becomes part of a single word, even if the variable's
-value contains spaces.
+.
 .SH KEYWORDS
 backslash, command, comment, script, substitution, variable
 '\" Local Variables:
-- 
cgit v0.12


From 7661972907da4bc9f9d49d64cf6db1c0748936f9 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Tue, 28 Feb 2023 11:57:03 +0000
Subject: Reverted [d156af9fb76dd2f4] and removed tests io-52.20 io-75.6
 io-75.7, as this commit, intended to fix issue [b8f575aa2398b0e4], breaks the
 semantics of [read] and [gets].  Such a change would require an accepted TIP.
 See [b8f575aa2398b0e4] for further discussion.

jn: @pouryorick See [b8f575aa2398b0e4] for the reason why this commit is not appropriate: It gets core-8-branch back in the buggy state it was, without even providing a real solution everyone agrees on. You shouldn't revert my patch just because I reverted yours.

pooryorick:  As I explained, the reason for this reversion is that it hard-codes an unapproved change in the semantics of [read] and [gets] into the test suite.  Jan, your statement that it's a "revenge" reversion is false.  I spent a month trying to find some alternative to this reversion before actually performing it.  A commit that codifes in its tests changes in semantcs to [read]/[gets] simply shouldn't be on core-8-branch.
---
 generic/tclIO.c |  4 ++--
 tests/io.test   | 63 ---------------------------------------------------------
 2 files changed, 2 insertions(+), 65 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 768a5c5..36889c7 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -7552,7 +7552,7 @@ Tcl_Eof(
     ChannelState *statePtr = ((Channel *) chan)->state;
 				/* State of real channel structure. */
 
-    return (GotFlag(statePtr, CHANNEL_EOF) && !GotFlag(statePtr, CHANNEL_ENCODING_ERROR)) ? 1 : 0;
+    return GotFlag(statePtr, CHANNEL_EOF) ? 1 : 0;
 }
 
 /*
@@ -8223,7 +8223,7 @@ Tcl_SetChannelOption(
 	statePtr->inputEncodingFlags = TCL_ENCODING_START;
 	statePtr->outputEncodingState = NULL;
 	statePtr->outputEncodingFlags = TCL_ENCODING_START;
-	ResetFlag(statePtr, CHANNEL_NEED_MORE_DATA|CHANNEL_ENCODING_ERROR);
+	ResetFlag(statePtr, CHANNEL_NEED_MORE_DATA);
 	UpdateInterest(chanPtr);
 	return TCL_OK;
     } else if (HaveOpt(2, "-eofchar")) {
diff --git a/tests/io.test b/tests/io.test
index c245add..59b6c66 100644
--- a/tests/io.test
+++ b/tests/io.test
@@ -7692,27 +7692,6 @@ test io-52.19 {coverage of eofChar handling} {
     close $out
     file size $path(test2)
 } 8
-test io-52.20 {TclCopyChannel & encodings} -setup {
-    set out [open $path(utf8-fcopy.txt) w]
-    fconfigure $out -encoding utf-8 -translation lf
-    puts $out "Á"
-    close $out
-} -constraints {fcopy} -body {
-    # binary to encoding => the input has to be
-    # in utf-8 to make sense to the encoder
-
-    set in  [open $path(utf8-fcopy.txt) r]
-    set out [open $path(kyrillic.txt) w]
-
-    # Using "-encoding ascii" means reading the "Á" gives an error
-    fconfigure $in  -encoding ascii -strictencoding 1
-    fconfigure $out -encoding koi8-r -translation lf
-
-    fcopy $in $out
-} -cleanup {
-    close $in
-    close $out
-} -returnCodes 1 -match glob -result {error reading "file*": illegal byte sequence}
 test io-52.21 {TclCopyChannel & encodings} -setup {
     set out [open $path(utf8-fcopy.txt) w]
     fconfigure $out -encoding utf-8 -translation lf
@@ -9223,48 +9202,6 @@ test io-75.5 {invalid utf-8 encoding read is ignored (-nocomplainencoding 1)} -s
     removeFile io-75.5
 } -result 4181
 
-test io-75.6 {invalid utf-8 encoding read is not ignored (-strictencoding 1)} -setup {
-    set fn [makeFile {} io-75.6]
-    set f [open $fn w+]
-    fconfigure $f -encoding binary
-    # \x81 is invalid in utf-8
-    puts -nonewline $f A\x81
-    flush $f
-    seek $f 0
-    fconfigure $f -encoding utf-8 -buffering none -eofchar "" -translation lf -strictencoding 1
-} -body {
-    set d [read $f]
-    binary scan $d H* hd
-    lappend hd [catch {read $f} msg]
-    close $f
-    lappend hd $msg
-} -cleanup {
-    removeFile io-75.6
-} -match glob -result {41 1 {error reading "*": illegal byte sequence}}
-
-test io-75.7 {invalid utf-8 encoding eof handling (-strictencoding 1)} -setup {
-    set fn [makeFile {} io-75.7]
-    set f [open $fn w+]
-    fconfigure $f -encoding binary
-    # \xA1 is invalid in utf-8. -eofchar is not detected, because it comes later.
-    puts -nonewline $f A\xA1\x1A
-    flush $f
-    seek $f 0
-    fconfigure $f -encoding utf-8 -buffering none -eofchar \x1A -translation lf -strictencoding 1
-} -body {
-    set d [read $f]
-    binary scan $d H* hd
-    lappend hd [eof $f]
-    lappend hd [catch {read $f} msg]
-    lappend hd $msg
-    fconfigure $f -encoding iso8859-1
-    lappend hd [read $f];# We changed encoding, so now we can read the \xA1
-    close $f
-    set hd
-} -cleanup {
-    removeFile io-75.7
-} -match glob -result {41 0 1 {error reading "*": illegal byte sequence} ¡}
-
 test io-75.8 {invalid utf-8 encoding eof handling (-strictencoding 1)} -setup {
     set fn [makeFile {} io-75.8]
     set f [open $fn w+]
-- 
cgit v0.12


From a6b4ef3d29565b68fb8c7104b11b03a99e0b153e Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Wed, 1 Mar 2023 07:56:03 +0000
Subject: Fix [f8ef6b3670] crash. TclpSysAlloc macro was truncating size
 request to 32 bits on Windows.

---
 win/tclWinPort.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/win/tclWinPort.h b/win/tclWinPort.h
index 2c01a6b..cc9453b 100644
--- a/win/tclWinPort.h
+++ b/win/tclWinPort.h
@@ -518,11 +518,11 @@ typedef DWORD_PTR * PDWORD_PTR;
  */
 
 #define TclpSysAlloc(size)		((void*)HeapAlloc(GetProcessHeap(), \
-					    (DWORD)0, (DWORD)size))
+					    0, size))
 #define TclpSysFree(ptr)		(HeapFree(GetProcessHeap(), \
-					    (DWORD)0, (HGLOBAL)ptr))
+					    0, (HGLOBAL)ptr))
 #define TclpSysRealloc(ptr, size)	((void*)HeapReAlloc(GetProcessHeap(), \
-					    (DWORD)0, (LPVOID)ptr, (DWORD)size))
+					    0, (LPVOID)ptr, size))
 
 /* This type is not defined in the Windows headers */
 #define socklen_t       int
-- 
cgit v0.12


From 261c174d97c0b75e9c557c4c05514db34e52e58b Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Wed, 1 Mar 2023 11:06:17 +0000
Subject: Fix msvc build (with OPTS=symbols)

---
 generic/tclZlib.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/generic/tclZlib.c b/generic/tclZlib.c
index a0e79ac..6278628 100644
--- a/generic/tclZlib.c
+++ b/generic/tclZlib.c
@@ -444,8 +444,8 @@ GenerateHeader(
 	goto error;
     } else if (value != NULL) {
 	Tcl_EncodingState state;
-	valueStr = Tcl_GetStringFromObj(value, &len);
-	result = Tcl_UtfToExternal(NULL, latin1enc, valueStr, len,
+	valueStr = Tcl_GetStringFromObj(value, &length);
+	result = Tcl_UtfToExternal(NULL, latin1enc, valueStr, length,
 		TCL_ENCODING_START|TCL_ENCODING_END|TCL_ENCODING_STOPONERROR, &state,
 		headerPtr->nativeCommentBuf, MAX_COMMENT_LEN-1, NULL, &len,
 		NULL);
@@ -476,8 +476,8 @@ GenerateHeader(
 	goto error;
     } else if (value != NULL) {
 	Tcl_EncodingState state;
-	valueStr = Tcl_GetStringFromObj(value, &len);
-	result = Tcl_UtfToExternal(NULL, latin1enc, valueStr, len,
+	valueStr = Tcl_GetStringFromObj(value, &length);
+	result = Tcl_UtfToExternal(NULL, latin1enc, valueStr, length,
 		TCL_ENCODING_START|TCL_ENCODING_END|TCL_ENCODING_STOPONERROR, &state,
 		headerPtr->nativeFilenameBuf, MAXPATHLEN-1, NULL, &len,
 		NULL);
@@ -570,7 +570,7 @@ ExtractHeader(
 	    }
 	}
 
-	Tcl_ExternalToUtfDString(latin1enc, (char *) headerPtr->comment, -1,
+	(void)Tcl_ExternalToUtfDString(latin1enc, (char *) headerPtr->comment, -1,
 		&tmp);
 	SetValue(dictObj, "comment", Tcl_DStringToObj(&tmp));
     }
@@ -587,7 +587,7 @@ ExtractHeader(
 	    }
 	}
 
-	Tcl_ExternalToUtfDString(latin1enc, (char *) headerPtr->name, -1,
+	(void)Tcl_ExternalToUtfDString(latin1enc, (char *) headerPtr->name, -1,
 		&tmp);
 	SetValue(dictObj, "filename", Tcl_DStringToObj(&tmp));
     }
-- 
cgit v0.12


From 30a9b333ba194339f5e8f68575626df0701b2a50 Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Wed, 1 Mar 2023 13:18:17 +0000
Subject: Bug [9a978f8323]: crash reading large files

---
 generic/tclIO.c |  26 ++++++++------
 tests/io.test   | 104 +++++++++++++++++++++++---------------------------------
 2 files changed, 58 insertions(+), 72 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index ff74a99..ce0dcc8 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -191,9 +191,9 @@ static int		DetachChannel(Tcl_Interp *interp, Tcl_Channel chan);
 static void		DiscardInputQueued(ChannelState *statePtr,
 			    int discardSavedBuffers);
 static void		DiscardOutputQueued(ChannelState *chanPtr);
-static int		DoRead(Channel *chanPtr, char *dst, Tcl_Size bytesToRead,
+static Tcl_Size		DoRead(Channel *chanPtr, char *dst, Tcl_Size bytesToRead,
 			    int allowShortReads);
-static int		DoReadChars(Channel *chan, Tcl_Obj *objPtr, Tcl_Size toRead,
+static Tcl_Size		DoReadChars(Channel *chan, Tcl_Obj *objPtr, Tcl_Size toRead,
 			    int appendFlag);
 static int		FilterInputBytes(Channel *chanPtr,
 			    GetsState *statePtr);
@@ -5946,11 +5946,11 @@ Tcl_ReadChars(
  *---------------------------------------------------------------------------
  */
 
-static int
+static Tcl_Size
 DoReadChars(
     Channel *chanPtr,		/* The channel to read. */
     Tcl_Obj *objPtr,		/* Input data is stored in this object. */
-    Tcl_Size toRead,			/* Maximum number of characters to store, or
+    Tcl_Size toRead,		/* Maximum number of characters to store, or
 				 * TCL_INDEX_NONE to read all available data (up to EOF or
 				 * when channel blocks). */
     int appendFlag)		/* If non-zero, data read from the channel
@@ -5961,7 +5961,8 @@ DoReadChars(
     ChannelState *statePtr = chanPtr->state;
 				/* State info for channel */
     ChannelBuffer *bufPtr;
-    int copied, copiedNow, result;
+    Tcl_Size copied;
+    int result;
     Tcl_Encoding encoding = statePtr->encoding;
     int binaryMode;
 #define UTF_EXPANSION_FACTOR	1024
@@ -6046,8 +6047,8 @@ DoReadChars(
     }
     ResetFlag(statePtr, CHANNEL_BLOCKED|CHANNEL_EOF);
     statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
-    for (copied = 0; toRead > 0; ) {
-	copiedNow = -1;
+    for (copied = 0; toRead > 0 || toRead == TCL_INDEX_NONE; ) {
+	int copiedNow = -1;
 	if (statePtr->inQueueHead != NULL) {
 	    if (binaryMode) {
 		copiedNow = ReadBytes(statePtr, objPtr, toRead);
@@ -6093,7 +6094,9 @@ DoReadChars(
 	    }
 	} else {
 	    copied += copiedNow;
-	    toRead -= copiedNow;
+	    if (toRead != TCL_INDEX_NONE) {
+		toRead -= copiedNow; /* Only decr if not reading whole file */
+	    }
 	}
     }
 
@@ -6269,7 +6272,7 @@ ReadChars(
 	size_t size;
 
 	dst = TclGetStringStorage(objPtr, &size) + numBytes;
-	dstLimit = size - numBytes;
+	dstLimit = (size - numBytes) > INT_MAX ? INT_MAX : (size - numBytes);
     } else {
 	dst = TclGetString(objPtr) + numBytes;
     }
@@ -9671,9 +9674,10 @@ CopyData(
     Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL, *msg = NULL;
     Tcl_Channel inChan, outChan;
     ChannelState *inStatePtr, *outStatePtr;
-    int result = TCL_OK, size;
+    int result = TCL_OK;
     Tcl_Size sizeb;
     Tcl_WideInt total;
+    Tcl_WideInt size; /* TODO - be careful if total and size are made unsigned  */
     const char *buffer;
     int inBinary, outBinary, sameEncoding;
 				/* Encoding control */
@@ -10011,7 +10015,7 @@ CopyData(
  *----------------------------------------------------------------------
  */
 
-static int
+static Tcl_Size
 DoRead(
     Channel *chanPtr,		/* The channel from which to read. */
     char *dst,			/* Where to store input read. */
diff --git a/tests/io.test b/tests/io.test
index 065eb4c..5b81dde 100644
--- a/tests/io.test
+++ b/tests/io.test
@@ -195,46 +195,50 @@ test io-1.9 {Tcl_WriteChars: WriteChars} {
     set sizes
 } {19 19 19 19 19}
 
+proc testreadwrite {size {mode ""} args} {
+    set tmpfile [file join [temporaryDirectory] io-1.10.tmp]
+    set w [string repeat A $size]
+    try {
+        set fd [open $tmpfile w$mode]
+        try {
+            if {[llength $args]} {
+                fconfigure $fd {*}$args
+            }
+            puts -nonewline $fd $w
+        } finally {
+            close $fd
+        }
+        set fd [open $tmpfile r$mode]
+        try {
+            if {[llength $args]} {
+                fconfigure $fd {*}$args
+            }
+            set r [read $fd]
+        } finally {
+            close $fd
+        }
+    } finally {
+        file delete $tmpfile
+    }
+    string equal $w $r
+}
+
 test io-1.10 {WriteChars: large file (> INT_MAX). Bug 3d01d51bc4} -constraints {
     pointerIs64bit perf
-} -setup {
-    set tmpfile [file join [temporaryDirectory] io-1.10.tmp]
-} -cleanup {
-    file delete $tmpfile
 } -body {
-    set fd [open $tmpfile w]
-    puts -nonewline $fd [string repeat A 0x80000000]
-    close $fd
-    # TODO - Should really read it back in but large reads are not currently working!
-    file size $tmpfile
-} -result 2147483648
+    testreadwrite 0x80000000
+} -result 1
 test io-1.11 {WriteChars: large file (> UINT_MAX). Bug 3d01d51bc4} -constraints {
     pointerIs64bit perf
-} -setup {
-    set tmpfile [file join [temporaryDirectory] io-1.11.tmp]
-} -cleanup {
-    file delete $tmpfile
 } -body {
-    set fd [open $tmpfile w]
-    puts -nonewline $fd [string repeat A 0x100000000]
-    close $fd
-    # TODO - Should really read it back in but large reads are not currently working!
-    file size $tmpfile
-} -result 4294967296
+    testreadwrite 0x100000000 "" -buffersize 1000000
+} -result 1
 test io-1.12 {WriteChars: large file (== UINT_MAX). Bug 90ff9b7f73} -constraints {
     pointerIs64bit perf
-} -setup {
-    set tmpfile [file join [temporaryDirectory] io-1.12.tmp]
-} -cleanup {
-    file delete $tmpfile
 } -body {
-    set fd [open $tmpfile w]
     # *Exactly* UINT_MAX - separate bug from the general large file tests
-    puts -nonewline $fd [string repeat A 0xffffffff]
-    close $fd
-    # TODO - Should really read it back in but large reads are not currently working!
-    file size $tmpfile
-} -result 4294967295
+    testreadwrite 0xffffffff
+} -result 1
 
 test io-2.1 {WriteBytes} {
     # loop until all bytes are written
@@ -277,47 +281,25 @@ test io-2.4 {WriteBytes: reset sawLF after each buffer} {
     close $f
     lappend x [contents $path(test1)]
 } [list "abcdefg\nhijklmno" "abcdefg\nhijklmnopqrstuvwxyz"]
-
 test io-2.5 {WriteBytes: large file (> INT_MAX). Bug 3d01d51bc4} -constraints {
     pointerIs64bit perf
-} -setup {
-    set tmpfile [file join [temporaryDirectory] io-2.5.tmp]
-} -cleanup {
-    file delete $tmpfile
 } -body {
-    set fd [open $tmpfile wb]
-    puts -nonewline $fd [string repeat A 0x80000000]
-    close $fd
-    # TODO - Should really read it back in but large reads are not currently working!
-    file size $tmpfile
-} -result 2147483648
+    # Binary mode
+    testreadwrite 0x80000000 b
+} -result 1
 test io-2.6 {WriteBytes: large file (> UINT_MAX). Bug 3d01d51bc4} -constraints {
     pointerIs64bit perf
-} -setup {
-    set tmpfile [file join [temporaryDirectory] io-2.6.tmp]
-} -cleanup {
-    file delete $tmpfile
 } -body {
-    set fd [open $tmpfile wb]
-    puts -nonewline $fd [string repeat A 0x100000000]
-    close $fd
-    # TODO - Should really read it back in but large reads are not currently working!
-    file size $tmpfile
-} -result 4294967296
+    # Binary mode
+    testreadwrite 0x100000000 b -buffersize 1000000
+} -result 1
 test io-2.7 {WriteBytes: large file (== UINT_MAX). Bug 90ff9b7f73} -constraints {
     pointerIs64bit perf
-} -setup {
-    set tmpfile [file join [temporaryDirectory] io-2.7.tmp]
-} -cleanup {
-    file delete $tmpfile
 } -body {
-    set fd [open $tmpfile wb]
     # *Exactly* UINT_MAX - separate bug from the general large file tests
-    puts -nonewline $fd [string repeat A 0xffffffff]
-    close $fd
-    # TODO - Should really read it back in but large reads are not currently working!
-    file size $tmpfile
-} -result 4294967295
+    testreadwrite 0xffffffff b
+} -result 1
+
 
 test io-3.1 {WriteChars: compatibility with WriteBytes} {
     # loop until all bytes are written
-- 
cgit v0.12


From 64e7f77040596a0716b5bd1f02942c8eb6124759 Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Wed, 1 Mar 2023 13:58:52 +0000
Subject: Disable file permission tests under WSL as WSL does not support Unix
 file attrs without special config

---
 tests/fCmd.test | 39 +++++++++++++++++++++------------------
 1 file changed, 21 insertions(+), 18 deletions(-)

diff --git a/tests/fCmd.test b/tests/fCmd.test
index 93793d1..02b70cb 100644
--- a/tests/fCmd.test
+++ b/tests/fCmd.test
@@ -42,6 +42,9 @@ if {[testConstraint win]} {
 }
 testConstraint notInCIenv [expr {![info exists ::env(CI)] || !$::env(CI)}]
 
+# File permissions broken on wsl without some "exotic" wsl configuration
+testConstraint notInWsl [expr {[llength [array names ::env *WSL*]] == 0}]
+
 set tmpspace /tmp;# default value
 # Find a group that exists on this Unix system, or else skip tests that
 # require Unix groups.
@@ -449,7 +452,7 @@ test fCmd-4.10 {TclFileMakeDirsCmd: exists, is dir} -setup {
 } -result {1 1}
 test fCmd-4.11 {TclFileMakeDirsCmd: doesn't exist: errno != ENOENT} -setup {
     cleanup
-} -constraints {unix notRoot testchmod} -returnCodes error -body {
+} -constraints {unix notRoot testchmod notInWsl} -returnCodes error -body {
     file mkdir td1/td2/td3
     testchmod 0 td1/td2
     file mkdir td1/td2/td3/td4
@@ -467,7 +470,7 @@ test fCmd-4.13 {TclFileMakeDirsCmd: doesn't exist: errno == ENOENT} -setup {
 test fCmd-4.14 {TclFileMakeDirsCmd: TclpCreateDirectory fails} -setup {
     cleanup
     file delete -force foo
-} -constraints {unix notRoot} -body {
+} -constraints {unix notRoot notInWsl} -body {
     file mkdir foo
     file attr foo -perm 0o40000
     file mkdir foo/tf1
@@ -593,7 +596,7 @@ test fCmd-6.5 {CopyRenameOneFile: lstat(target) != 0} -setup {
 } -result {tf2}
 test fCmd-6.6 {CopyRenameOneFile: errno != ENOENT} -setup {
     cleanup
-} -constraints {unix notRoot testchmod} -body {
+} -constraints {unix notRoot testchmod notInWsl} -body {
     file mkdir td1
     testchmod 0 td1
     createfile tf1
@@ -712,7 +715,7 @@ test fCmd-6.22 {CopyRenameOneFile: copy/rename: !S_ISDIR(source)} -setup {
 } -result [file join $tmpspace tf1]
 test fCmd-6.23 {CopyRenameOneFile: TclpCopyDirectory failed} -setup {
     cleanup $tmpspace
-} -constraints {xdev notRoot} -body {
+} -constraints {xdev notRoot notInWsl} -body {
     file mkdir td1/td2/td3
     file attributes td1 -permissions 0
     file rename td1 $tmpspace
@@ -764,7 +767,7 @@ test fCmd-6.27 {CopyRenameOneFile: TclpCopyDirectory failed} -setup {
 } -match glob -result {error renaming "td1" to "/tmp/tcl*/td1": file already exists}
 test fCmd-6.28 {CopyRenameOneFile: TclpCopyDirectory failed} -setup {
     cleanup $tmpspace
-} -constraints {notRoot xdev} -body {
+} -constraints {notRoot xdev notInWsl} -body {
     file mkdir td1/td2/td3
     file attributes td1/td2/td3 -permissions 0
     file rename td1 $tmpspace
@@ -781,7 +784,7 @@ test fCmd-6.29 {CopyRenameOneFile: TclpCopyDirectory passed} -setup {
 } -result [file join $tmpspace td1 td2]
 test fCmd-6.30 {CopyRenameOneFile: TclpRemoveDirectory failed} -setup {
     cleanup $tmpspace
-} -constraints {unix notRoot} -body {
+} -constraints {unix notRoot notInWsl} -body {
     file mkdir foo/bar
     file attr foo -perm 0o40555
     file rename foo/bar $tmpspace
@@ -856,7 +859,7 @@ test fCmd-8.3 {file copy and path translation: ensure correct error} -body {
 
 test fCmd-9.1 {file rename: comprehensive: EACCES} -setup {
     cleanup
-} -constraints {unix notRoot} -body {
+} -constraints {unix notRoot notInWsl} -body {
     file mkdir td1
     file mkdir td2
     file attr td2 -perm 0o40000
@@ -882,7 +885,7 @@ test fCmd-9.3 {file rename: comprehensive: file to new name} -setup {
 } -result {{tf3 tf4} 1 0}
 test fCmd-9.4 {file rename: comprehensive: dir to new name} -setup {
     cleanup
-} -constraints {unix notRoot testchmod notDarwin9} -body {
+} -constraints {unix notRoot testchmod notDarwin9 notInWsl} -body {
     file mkdir td1 td2
     testchmod 0o555 td2
     file rename td1 td3
@@ -903,7 +906,7 @@ test fCmd-9.5 {file rename: comprehensive: file to self} -setup {
 } -result {tf1 tf2 1 0}
 test fCmd-9.6 {file rename: comprehensive: dir to self} -setup {
     cleanup
-} -constraints {unix notRoot testchmod} -body {
+} -constraints {unix notRoot testchmod notInWsl} -body {
     file mkdir td1
     file mkdir td2
     testchmod 0o555 td2
@@ -1097,7 +1100,7 @@ test fCmd-10.2 {file copy: comprehensive: file to new name} -setup {
 } -result {{tf1 tf2 tf3 tf4} tf1 tf2 1 0}
 test fCmd-10.3 {file copy: comprehensive: dir to new name} -setup {
     cleanup
-} -constraints {unix notRoot testchmod} -body {
+} -constraints {unix notRoot testchmod notInWsl} -body {
     file mkdir [file join td1 tdx]
     file mkdir [file join td2 tdy]
     testchmod 0o555 td2
@@ -1174,7 +1177,7 @@ test fCmd-10.5 {file copy: comprehensive: dir to empty dir} -setup {
 } -result [subst {{td1 td2 tdd1 tdd2 tdd3 tdd4 tds1 tds2 tds3 tds4} {1 {error copying "td1" to "[file join td2 td1]": file already exists}} {1 {error copying "tds1" to "[file join tdd1 tds1]": file already exists}} 1 1 1}]
 test fCmd-10.6 {file copy: comprehensive: dir to non-empty dir} -setup {
     cleanup
-} -constraints {notRoot unixOrWin testchmod} -body {
+} -constraints {notRoot unixOrWin testchmod notInWsl} -body {
     file mkdir tds1
     file mkdir tds2
     file mkdir [file join tdd1 tds1 xxx]
@@ -1198,7 +1201,7 @@ test fCmd-10.7 {file rename: comprehensive: file to new name and dir} -setup {
 } -result [subst {{tf1 tf2} {[file join td1 tf3] [file join td1 tf4]} 1 0}]
 test fCmd-10.8 {file rename: comprehensive: dir to new name and dir} -setup {
     cleanup
-} -constraints {unix notRoot testchmod} -body {
+} -constraints {unix notRoot testchmod notInWsl} -body {
     file mkdir td1
     file mkdir td2
     file mkdir td3
@@ -1395,7 +1398,7 @@ test fCmd-12.7 {renamefile: renaming directory into offspring} -setup {
 } -result {1}
 test fCmd-12.8 {renamefile: generic error} -setup {
     catch {file delete -force -- tfa}
-} -constraints {unix notRoot} -body {
+} -constraints {unix notRoot notInWsl} -body {
     file mkdir tfa
     file mkdir tfa/dir
     file attributes tfa -permissions 0o555
@@ -1582,7 +1585,7 @@ test fCmd-14.7 {copyfile: copy directory succeeding} -setup {
 } -result {1 1}
 test fCmd-14.8 {copyfile: copy directory failing} -setup {
     catch {file delete -force -- tfa}
-} -constraints {unix notRoot} -body {
+} -constraints {unix notRoot notInWsl} -body {
     file mkdir tfa/dir/a/b/c
     file attributes tfa/dir -permissions 0
     catch {file copy tfa tfa2}
@@ -1727,7 +1730,7 @@ test fCmd-16.8 {remove a normal file} -constraints {notRoot} -setup {
 } -result {1}
 test fCmd-16.9 {error while deleting file} -setup {
     catch {file delete -force -- tfa}
-} -constraints {unix notRoot} -body {
+} -constraints {unix notRoot notInWsl} -body {
     file mkdir tfa
     createfile tfa/a
     file attributes tfa -permissions 0o555
@@ -1758,7 +1761,7 @@ test fCmd-16.11 {TclFileDeleteCmd: removing a nonexistant file} -setup {
 # More coverage tests for mkpath()
 test fCmd-17.1 {mkdir stat failing on target but not ENOENT} -setup {
      catch {file delete -force -- tfa1}
-} -constraints {unix notRoot} -body {
+} -constraints {unix notRoot notInWsl} -body {
      file mkdir tfa1
      file attributes tfa1 -permissions 0o555
      catch {file mkdir tfa1/tfa2}
@@ -1968,7 +1971,7 @@ test fCmd-19.1 {remove empty directory} -constraints {notRoot} -setup {
 } -result {0}
 test fCmd-19.2 {rmdir error besides EEXIST} -setup {
     catch {file delete -force -- tfa}
-} -constraints {unix notRoot} -body {
+} -constraints {unix notRoot notInWsl} -body {
     file mkdir tfa
     file mkdir tfa/a
     file attributes tfa -permissions 0o555
@@ -1996,7 +1999,7 @@ test fCmd-19.3 {recursive remove} -constraints {notRoot} -setup {
 #
 test fCmd-20.1 {TraverseUnixTree : failure opening a subdirectory directory} -setup {
     catch {file delete -force -- tfa}
-} -constraints {unix notRoot} -body {
+} -constraints {unix notRoot notInWsl} -body {
     file mkdir tfa
     file mkdir tfa/a
     file attributes tfa/a -permissions 00000
-- 
cgit v0.12


From e7b37f1737b55c5d6bfaa56a41432a10e0ed91f9 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Fri, 3 Mar 2023 12:39:09 +0000
Subject: Fix Valgrind "still reachable" report in TestcmdtokenCmd().

---
 generic/tclTest.c  | 44 ++++++++++++++++++++++++++++++--------------
 tests/basic.test   |  6 +++---
 tests/cmdInfo.test |  6 +++---
 3 files changed, 36 insertions(+), 20 deletions(-)

diff --git a/generic/tclTest.c b/generic/tclTest.c
index b6c7f77..72eca6c 100644
--- a/generic/tclTest.c
+++ b/generic/tclTest.c
@@ -1206,7 +1206,7 @@ TestcmdtokenCmd(
     int argc,			/* Number of arguments. */
     const char **argv)		/* Argument strings. */
 {
-    TestCommandTokenRef *refPtr;
+    TestCommandTokenRef *refPtr, *prevRefPtr;
     char buf[30];
     int id;
 
@@ -1225,9 +1225,7 @@ TestcmdtokenCmd(
 	firstCommandTokenRef = refPtr;
 	sprintf(buf, "%d", refPtr->id);
 	Tcl_AppendResult(interp, buf, NULL);
-    } else if (strcmp(argv[1], "name") == 0) {
-	Tcl_Obj *objPtr;
-
+    } else {
 	if (sscanf(argv[2], "%d", &id) != 1) {
 	    Tcl_AppendResult(interp, "bad command token \"", argv[2],
 		    "\"", NULL);
@@ -1247,18 +1245,36 @@ TestcmdtokenCmd(
 	    return TCL_ERROR;
 	}
 
-	objPtr = Tcl_NewObj();
-	Tcl_GetCommandFullName(interp, refPtr->token, objPtr);
+	if (strcmp(argv[1], "name") == 0) {
+	    Tcl_Obj *objPtr;
 
-	Tcl_AppendElement(interp,
-		Tcl_GetCommandName(interp, refPtr->token));
-	Tcl_AppendElement(interp, Tcl_GetString(objPtr));
-	Tcl_DecrRefCount(objPtr);
-    } else {
-	Tcl_AppendResult(interp, "bad option \"", argv[1],
-		"\": must be create or name", NULL);
-	return TCL_ERROR;
+	    objPtr = Tcl_NewObj();
+	    Tcl_GetCommandFullName(interp, refPtr->token, objPtr);
+
+	    Tcl_AppendElement(interp,
+		    Tcl_GetCommandName(interp, refPtr->token));
+	    Tcl_AppendElement(interp, Tcl_GetString(objPtr));
+	    Tcl_DecrRefCount(objPtr);
+	} else if (strcmp(argv[1], "free") == 0) {
+	    prevRefPtr = NULL;
+	    for (refPtr = firstCommandTokenRef; refPtr != NULL;
+		    refPtr = refPtr->nextPtr) {
+		if (refPtr->id == id) {
+		    if (prevRefPtr != NULL) {
+			prevRefPtr->nextPtr = refPtr->nextPtr;
+		    }
+		    ckfree(refPtr);
+		    break;
+		}
+		prevRefPtr = refPtr;
+	    }
+	} else {
+	    Tcl_AppendResult(interp, "bad option \"", argv[1],
+		    "\": must be create, name, or free", NULL);
+	    return TCL_ERROR;
+	}
     }
+
     return TCL_OK;
 }
 
diff --git a/tests/basic.test b/tests/basic.test
index f4c57fe..de986c7 100644
--- a/tests/basic.test
+++ b/tests/basic.test
@@ -336,19 +336,19 @@ test basic-20.1 {Tcl_GetCommandInfo, names for commands created inside namespace
     }]
     list [testcmdtoken name $x] \
          [rename ::p q] \
-         [testcmdtoken name $x]
+         [testcmdtoken name $x][testcmdtoken free $x]
 } {{p ::p} {} {q ::q}}
 test basic-20.2 {Tcl_GetCommandInfo, names for commands created outside namespaces} {testcmdtoken} {
     catch {rename q ""}
     set x [testcmdtoken create test_ns_basic::test_ns_basic2::p]
     list [testcmdtoken name $x] \
          [rename test_ns_basic::test_ns_basic2::p q] \
-         [testcmdtoken name $x]
+         [testcmdtoken name $x][testcmdtoken free $x]
 } {{p ::test_ns_basic::test_ns_basic2::p} {} {q ::q}}
 test basic-20.3 {Tcl_GetCommandInfo, #-quoting} testcmdtoken {
     catch {rename \# ""}
     set x [testcmdtoken create \#]
-    testcmdtoken name $x
+    return [testcmdtoken name $x][testcmdtoken free $x]
 } {{#} ::#}
 
 test basic-21.1 {Tcl_GetCommandName} {emptyTest} {
diff --git a/tests/cmdInfo.test b/tests/cmdInfo.test
index 37b8a0b..ad564d7 100644
--- a/tests/cmdInfo.test
+++ b/tests/cmdInfo.test
@@ -70,7 +70,7 @@ test cmdinfo-4.1 {Tcl_GetCommandName/Tcl_GetCommandFullName procedures} \
     rename x1 newName
     set y [testcmdtoken name $x]
     rename newName x1
-    lappend y {*}[testcmdtoken name $x]
+    lappend y {*}[testcmdtoken name $x][testcmdtoken free $x]
 } {newName ::newName x1 ::x1}
 
 catch {rename newTestCmd {}}
@@ -87,7 +87,7 @@ test cmdinfo-5.1 {Names for commands created when inside namespaces} \
     }]
     set y [testcmdtoken name $x]
     rename ::testCmd newTestCmd
-    lappend y {*}[testcmdtoken name $x]
+    lappend y {*}[testcmdtoken name $x][testcmdtoken free $x]
 } {testCmd ::testCmd newTestCmd ::newTestCmd}
 
 test cmdinfo-6.1 {Names for commands created when outside namespaces} \
@@ -95,7 +95,7 @@ test cmdinfo-6.1 {Names for commands created when outside namespaces} \
     set x [testcmdtoken create cmdInfoNs1::cmdInfoNs2::testCmd]
     set y [testcmdtoken name $x]
     rename cmdInfoNs1::cmdInfoNs2::testCmd newTestCmd2
-    lappend y {*}[testcmdtoken name $x]
+    lappend y {*}[testcmdtoken name $x][testcmdtoken free $x]
 } {testCmd ::cmdInfoNs1::cmdInfoNs2::testCmd newTestCmd2 ::newTestCmd2}
 
 # cleanup
-- 
cgit v0.12


From 7f3d1257ffc45e37ee8c71b666c37088eb2f1c48 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Fri, 3 Mar 2023 13:03:02 +0000
Subject: ckfree() shouldn't be used in Tcl 9 core code any more

---
 generic/tclTest.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/generic/tclTest.c b/generic/tclTest.c
index 72eca6c..a5d2e0b 100644
--- a/generic/tclTest.c
+++ b/generic/tclTest.c
@@ -1263,7 +1263,7 @@ TestcmdtokenCmd(
 		    if (prevRefPtr != NULL) {
 			prevRefPtr->nextPtr = refPtr->nextPtr;
 		    }
-		    ckfree(refPtr);
+		    Tcl_Free(refPtr);
 		    break;
 		}
 		prevRefPtr = refPtr;
-- 
cgit v0.12


From 8f18e27691fabd477dde7d468fa26440ed5da4c2 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Fri, 3 Mar 2023 13:04:11 +0000
Subject: Adapt type-casts to Tcl 9.0 signature of
 Tcl_Free/Tcl_Realloc/Tcl_AttemptRealloc

---
 generic/tcl.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/generic/tcl.h b/generic/tcl.h
index 1a1452e..ec78052 100644
--- a/generic/tcl.h
+++ b/generic/tcl.h
@@ -2377,9 +2377,9 @@ EXTERN const char *TclZipfs_AppHook(int *argc, char ***argv);
 #   define attemptckalloc Tcl_AttemptAlloc
 #   ifdef _MSC_VER
 	/* Silence invalid C4090 warnings */
-#	define ckfree(a) Tcl_Free((char *)(a))
-#	define ckrealloc(a,b) Tcl_Realloc((char *)(a),(b))
-#	define attemptckrealloc(a,b) Tcl_AttemptRealloc((char *)(a),(b))
+#	define ckfree(a) Tcl_Free((void *)(a))
+#	define ckrealloc(a,b) Tcl_Realloc((void *)(a),(b))
+#	define attemptckrealloc(a,b) Tcl_AttemptRealloc((void *)(a),(b))
 #   else
 #	define ckfree Tcl_Free
 #	define ckrealloc Tcl_Realloc
-- 
cgit v0.12


From 33d81b98be1160ae0475a3d162cec7359264c8c8 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sat, 4 Mar 2023 18:12:49 +0000
Subject: Make dltest/pkg*.c simple example how to use Tcl_Size with
 Tcl_GetStringFromObj()

---
 unix/dltest/pkga.c          | 2 +-
 unix/dltest/pkgua.c         | 2 +-
 "unix/dltest/pkg\317\200.c" | 3 ---
 3 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/unix/dltest/pkga.c b/unix/dltest/pkga.c
index 579c323..aacb9cd 100644
--- a/unix/dltest/pkga.c
+++ b/unix/dltest/pkga.c
@@ -40,7 +40,7 @@ Pkga_EqObjCmd(
 {
     int result;
     const char *str1, *str2;
-    int len1, len2;
+    Tcl_Size len1, len2;
     (void)dummy;
 
     if (objc != 3) {
diff --git a/unix/dltest/pkgua.c b/unix/dltest/pkgua.c
index 16684a8..b14fca8 100644
--- a/unix/dltest/pkgua.c
+++ b/unix/dltest/pkgua.c
@@ -127,7 +127,7 @@ PkguaEqObjCmd(
 {
     int result;
     const char *str1, *str2;
-    int len1, len2;
+    Tcl_Size len1, len2;
     (void)dummy;
 
     if (objc != 3) {
diff --git "a/unix/dltest/pkg\317\200.c" "b/unix/dltest/pkg\317\200.c"
index dc01fbd..58b36db 100644
--- "a/unix/dltest/pkg\317\200.c"
+++ "b/unix/dltest/pkg\317\200.c"
@@ -38,9 +38,6 @@ Pkg\u03C0_\u03A0ObjCmd(
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
 {
-    int result;
-    const char *str1, *str2;
-    int len1, len2;
     (void)dummy;
 
     if (objc != 1) {
-- 
cgit v0.12


From 923ff1e3ca4171dd5d562edfcfc4aaab9dfb8d7a Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 5 Mar 2023 00:26:54 +0000
Subject: More -1 -> TCL_INDEX_NONE

---
 generic/tclArithSeries.c     |  4 +--
 generic/tclCkalloc.c         |  2 +-
 generic/tclCompCmds.c        | 32 +++++++++---------
 generic/tclCompCmdsSZ.c      | 10 +++---
 generic/tclCompile.c         |  2 +-
 generic/tclConfig.c          | 12 +++----
 generic/tclDictObj.c         | 10 +++---
 generic/tclEnv.c             |  8 ++---
 generic/tclExecute.c         |  2 +-
 generic/tclFCmd.c            |  4 +--
 generic/tclHistory.c         |  2 +-
 generic/tclIOCmd.c           |  2 +-
 generic/tclLink.c            | 10 +++---
 generic/tclListObj.c         |  2 +-
 generic/tclLiteral.c         |  2 +-
 generic/tclLoad.c            | 26 +++++++--------
 generic/tclLoadNone.c        |  2 +-
 generic/tclOOCall.c          |  2 +-
 generic/tclOOMethod.c        | 10 +++---
 generic/tclPathObj.c         |  2 +-
 generic/tclPkg.c             | 22 ++++++-------
 generic/tclProc.c            | 18 +++++-----
 generic/tclRegexp.c          |  6 ++--
 generic/tclResult.c          |  6 ++--
 generic/tclStrToD.c          |  4 +--
 generic/tclStringObj.c       |  6 ++--
 generic/tclStubInit.c        |  4 +--
 generic/tclTestObj.c         | 42 ++++++++++++------------
 generic/tclTestProcBodyObj.c |  2 +-
 generic/tclThreadTest.c      | 10 +++---
 generic/tclTimer.c           | 28 ++++++++--------
 generic/tclZipfs.c           | 78 ++++++++++++++++++++++----------------------
 generic/tclZlib.c            | 62 +++++++++++++++++------------------
 macosx/tclMacOSXFCmd.c       |  6 ++--
 34 files changed, 220 insertions(+), 220 deletions(-)

diff --git a/generic/tclArithSeries.c b/generic/tclArithSeries.c
index 48efa8c..0232746 100755
--- a/generic/tclArithSeries.c
+++ b/generic/tclArithSeries.c
@@ -357,7 +357,7 @@ TclNewArithSeriesObj(
     if (TCL_MAJOR_VERSION < 9 && len > ListSizeT_MAX) {
 	Tcl_SetObjResult(
 	    interp,
-	    Tcl_NewStringObj("max length of a Tcl list exceeded", -1));
+	    Tcl_NewStringObj("max length of a Tcl list exceeded", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
 	return TCL_ERROR;
     }
@@ -865,7 +865,7 @@ TclArithSeriesGetElements(
 		    if (interp) {
 			Tcl_SetObjResult(
 			    interp,
-			    Tcl_NewStringObj("max length of a Tcl list exceeded", -1));
+			    Tcl_NewStringObj("max length of a Tcl list exceeded", TCL_INDEX_NONE));
 			Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
 		    }
 		    return TCL_ERROR;
diff --git a/generic/tclCkalloc.c b/generic/tclCkalloc.c
index f7cab9f..6f31940 100644
--- a/generic/tclCkalloc.c
+++ b/generic/tclCkalloc.c
@@ -189,7 +189,7 @@ TclDumpMemoryInfo(
 	fprintf((FILE *)clientData, "%s", buf);
     } else {
 	/* Assume objPtr to append to */
-	Tcl_AppendToObj((Tcl_Obj *) clientData, buf, -1);
+	Tcl_AppendToObj((Tcl_Obj *) clientData, buf, TCL_INDEX_NONE);
     }
     return 1;
 }
diff --git a/generic/tclCompCmds.c b/generic/tclCompCmds.c
index cb3cf1e..3a61a94 100644
--- a/generic/tclCompCmds.c
+++ b/generic/tclCompCmds.c
@@ -2300,7 +2300,7 @@ PrintDictUpdateInfo(
 
     for (i=0 ; i<duiPtr->length ; i++) {
 	if (i) {
-	    Tcl_AppendToObj(appendObj, ", ", -1);
+	    Tcl_AppendToObj(appendObj, ", ", TCL_INDEX_NONE);
 	}
 	Tcl_AppendPrintfToObj(appendObj, "%%v%" TCL_Z_MODIFIER "u", duiPtr->varIndices[i]);
     }
@@ -2322,7 +2322,7 @@ DisassembleDictUpdateInfo(
 	Tcl_ListObjAppendElement(NULL, variables,
 		Tcl_NewWideIntObj(duiPtr->varIndices[i]));
     }
-    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("variables", -1),
+    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("variables", TCL_INDEX_NONE),
 	    variables);
 }
 
@@ -2982,11 +2982,11 @@ PrintForeachInfo(
     ForeachVarList *varsPtr;
     size_t i, j;
 
-    Tcl_AppendToObj(appendObj, "data=[", -1);
+    Tcl_AppendToObj(appendObj, "data=[", TCL_INDEX_NONE);
 
     for (i=0 ; i<infoPtr->numLists ; i++) {
 	if (i) {
-	    Tcl_AppendToObj(appendObj, ", ", -1);
+	    Tcl_AppendToObj(appendObj, ", ", TCL_INDEX_NONE);
 	}
 	Tcl_AppendPrintfToObj(appendObj, "%%v%" TCL_Z_MODIFIER "u",
 		(infoPtr->firstValueTemp + i));
@@ -2995,19 +2995,19 @@ PrintForeachInfo(
 	    infoPtr->loopCtTemp);
     for (i=0 ; i<infoPtr->numLists ; i++) {
 	if (i) {
-	    Tcl_AppendToObj(appendObj, ",", -1);
+	    Tcl_AppendToObj(appendObj, ",", TCL_INDEX_NONE);
 	}
 	Tcl_AppendPrintfToObj(appendObj, "\n\t\t it%%v%" TCL_Z_MODIFIER "u\t[",
 		(infoPtr->firstValueTemp + i));
 	varsPtr = infoPtr->varLists[i];
 	for (j=0 ; j<varsPtr->numVars ; j++) {
 	    if (j) {
-		Tcl_AppendToObj(appendObj, ", ", -1);
+		Tcl_AppendToObj(appendObj, ", ", TCL_INDEX_NONE);
 	    }
 	    Tcl_AppendPrintfToObj(appendObj, "%%v%" TCL_Z_MODIFIER "u",
 		    varsPtr->varIndexes[j]);
 	}
-	Tcl_AppendToObj(appendObj, "]", -1);
+	Tcl_AppendToObj(appendObj, "]", TCL_INDEX_NONE);
     }
 }
 
@@ -3026,18 +3026,18 @@ PrintNewForeachInfo(
 	    infoPtr->loopCtTemp);
     for (i=0 ; i<infoPtr->numLists ; i++) {
 	if (i) {
-	    Tcl_AppendToObj(appendObj, ",", -1);
+	    Tcl_AppendToObj(appendObj, ",", TCL_INDEX_NONE);
 	}
-	Tcl_AppendToObj(appendObj, "[", -1);
+	Tcl_AppendToObj(appendObj, "[", TCL_INDEX_NONE);
 	varsPtr = infoPtr->varLists[i];
 	for (j=0 ; j<varsPtr->numVars ; j++) {
 	    if (j) {
-		Tcl_AppendToObj(appendObj, ",", -1);
+		Tcl_AppendToObj(appendObj, ",", TCL_INDEX_NONE);
 	    }
 	    Tcl_AppendPrintfToObj(appendObj, "%%v%" TCL_Z_MODIFIER "u",
 		    varsPtr->varIndexes[j]);
 	}
-	Tcl_AppendToObj(appendObj, "]", -1);
+	Tcl_AppendToObj(appendObj, "]", TCL_INDEX_NONE);
     }
 }
 
@@ -3062,13 +3062,13 @@ DisassembleForeachInfo(
 	Tcl_ListObjAppendElement(NULL, objPtr,
 		Tcl_NewWideIntObj(infoPtr->firstValueTemp + i));
     }
-    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("data", -1), objPtr);
+    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("data", TCL_INDEX_NONE), objPtr);
 
     /*
      * Loop counter.
      */
 
-    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("loop", -1),
+    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("loop", TCL_INDEX_NONE),
 	   Tcl_NewWideIntObj(infoPtr->loopCtTemp));
 
     /*
@@ -3085,7 +3085,7 @@ DisassembleForeachInfo(
 	}
 	Tcl_ListObjAppendElement(NULL, objPtr, innerPtr);
     }
-    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("assign", -1), objPtr);
+    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("assign", TCL_INDEX_NONE), objPtr);
 }
 
 static void
@@ -3104,7 +3104,7 @@ DisassembleNewForeachInfo(
      * Jump offset.
      */
 
-    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("jumpOffset", -1),
+    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("jumpOffset", TCL_INDEX_NONE),
 	   Tcl_NewWideIntObj(infoPtr->loopCtTemp));
 
     /*
@@ -3121,7 +3121,7 @@ DisassembleNewForeachInfo(
 	}
 	Tcl_ListObjAppendElement(NULL, objPtr, innerPtr);
     }
-    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("assign", -1), objPtr);
+    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("assign", TCL_INDEX_NONE), objPtr);
 }
 
 /*
diff --git a/generic/tclCompCmdsSZ.c b/generic/tclCompCmdsSZ.c
index 0e98584..b86aa43 100644
--- a/generic/tclCompCmdsSZ.c
+++ b/generic/tclCompCmdsSZ.c
@@ -2604,9 +2604,9 @@ PrintJumptableInfo(
 	offset = PTR2INT(Tcl_GetHashValue(hPtr));
 
 	if (i++) {
-	    Tcl_AppendToObj(appendObj, ", ", -1);
+	    Tcl_AppendToObj(appendObj, ", ", TCL_INDEX_NONE);
 	    if (i%4==0) {
-		Tcl_AppendToObj(appendObj, "\n\t\t", -1);
+		Tcl_AppendToObj(appendObj, "\n\t\t", TCL_INDEX_NONE);
 	    }
 	}
 	Tcl_AppendPrintfToObj(appendObj, "\"%s\"->pc %" TCL_Z_MODIFIER "u",
@@ -2633,10 +2633,10 @@ DisassembleJumptableInfo(
     for (; hPtr ; hPtr = Tcl_NextHashEntry(&search)) {
 	keyPtr = (const char *)Tcl_GetHashKey(&jtPtr->hashTable, hPtr);
 	offset = PTR2INT(Tcl_GetHashValue(hPtr));
-	Tcl_DictObjPut(NULL, mapping, Tcl_NewStringObj(keyPtr, -1),
+	Tcl_DictObjPut(NULL, mapping, Tcl_NewStringObj(keyPtr, TCL_INDEX_NONE),
 		Tcl_NewWideIntObj(offset));
     }
-    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("mapping", -1), mapping);
+    Tcl_DictObjPut(NULL, dictObj, Tcl_NewStringObj("mapping", TCL_INDEX_NONE), mapping);
 }
 
 /*
@@ -4081,7 +4081,7 @@ CompileAssociativeBinaryOpCmd(
 	CompileWord(envPtr, tokenPtr, interp, words);
     }
     if (parsePtr->numWords <= 2) {
-	PushLiteral(envPtr, identity, -1);
+	PushLiteral(envPtr, identity, TCL_INDEX_NONE);
 	words++;
     }
     if (words > 3) {
diff --git a/generic/tclCompile.c b/generic/tclCompile.c
index 9708255..be308e3 100644
--- a/generic/tclCompile.c
+++ b/generic/tclCompile.c
@@ -2161,7 +2161,7 @@ TclCompileScript(
      */
     if (iPtr->numLevels / 5 > iPtr->maxNestingDepth / 4) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-	    "too many nested compilations (infinite loop?)", -1));
+	    "too many nested compilations (infinite loop?)", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "LIMIT", "STACK", NULL);
 	TclCompileSyntaxError(interp, envPtr);
 	return;
diff --git a/generic/tclConfig.c b/generic/tclConfig.c
index 1ece31c..17490bd 100644
--- a/generic/tclConfig.c
+++ b/generic/tclConfig.c
@@ -85,7 +85,7 @@ Tcl_RegisterConfig(
     } else {
 	cdPtr->encoding = NULL;
     }
-    cdPtr->pkg = Tcl_NewStringObj(pkgName, -1);
+    cdPtr->pkg = Tcl_NewStringObj(pkgName, TCL_INDEX_NONE);
 
     /*
      * Phase I: Adding the provided information to the internal database of
@@ -127,7 +127,7 @@ Tcl_RegisterConfig(
      */
 
     for (cfg=configuration ; cfg->key!=NULL && cfg->key[0]!='\0' ; cfg++) {
-	Tcl_DictObjPut(interp, pkgDict, Tcl_NewStringObj(cfg->key, -1),
+	Tcl_DictObjPut(interp, pkgDict, Tcl_NewStringObj(cfg->key, TCL_INDEX_NONE),
 		Tcl_NewByteArrayObj((unsigned char *)cfg->value, strlen(cfg->value)));
     }
 
@@ -144,7 +144,7 @@ Tcl_RegisterConfig(
 
     Tcl_DStringInit(&cmdName);
     TclDStringAppendLiteral(&cmdName, "::");
-    Tcl_DStringAppend(&cmdName, pkgName, -1);
+    Tcl_DStringAppend(&cmdName, pkgName, TCL_INDEX_NONE);
 
     /*
      * The incomplete command name is the name of the namespace to place it
@@ -227,7 +227,7 @@ QueryConfigObjCmd(
 	 * present.
 	 */
 
-	Tcl_SetObjResult(interp, Tcl_NewStringObj("package not known", -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj("package not known", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "FATAL", "PKGCFG_BASE",
 		TclGetString(pkgName), NULL);
 	return TCL_ERROR;
@@ -242,7 +242,7 @@ QueryConfigObjCmd(
 
 	if (Tcl_DictObjGet(interp, pkgDict, objv[2], &val) != TCL_OK
 		|| val == NULL) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj("key not known", -1));
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj("key not known", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "CONFIG",
 		    TclGetString(objv[2]), NULL);
 	    return TCL_ERROR;
@@ -279,7 +279,7 @@ QueryConfigObjCmd(
 
 	if (!listPtr) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "insufficient memory to create list", -1));
+		    "insufficient memory to create list", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
 	    return TCL_ERROR;
 	}
diff --git a/generic/tclDictObj.c b/generic/tclDictObj.c
index 04a909f..5c18c8a 100644
--- a/generic/tclDictObj.c
+++ b/generic/tclDictObj.c
@@ -717,7 +717,7 @@ SetDictFromAny(
   missingValue:
     if (interp != NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"missing value to go with key", -1));
+		"missing value to go with key", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "VALUE", "DICTIONARY", NULL);
     }
   errorInFindDictElement:
@@ -2119,7 +2119,7 @@ DictInfoCmd(
     }
 
     statsStr = Tcl_HashStats(&dict->table);
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(statsStr, -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(statsStr, TCL_INDEX_NONE));
     Tcl_Free(statsStr);
     return TCL_OK;
 }
@@ -2481,7 +2481,7 @@ DictForNRCmd(
     }
     if (varc != 2) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"must have exactly two variable names", -1));
+		"must have exactly two variable names", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "SYNTAX", "dict", "for", NULL);
 	return TCL_ERROR;
     }
@@ -2676,7 +2676,7 @@ DictMapNRCmd(
     }
     if (varc != 2) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"must have exactly two variable names", -1));
+		"must have exactly two variable names", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "SYNTAX", "dict", "map", NULL);
 	return TCL_ERROR;
     }
@@ -3116,7 +3116,7 @@ DictFilterCmd(
 	}
 	if (varc != 2) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "must have exactly two variable names", -1));
+		    "must have exactly two variable names", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "SYNTAX", "dict", "filter", NULL);
 	    return TCL_ERROR;
 	}
diff --git a/generic/tclEnv.c b/generic/tclEnv.c
index 630e89c..6dae72a 100644
--- a/generic/tclEnv.c
+++ b/generic/tclEnv.c
@@ -185,8 +185,8 @@ TclSetupEnv(
 		p1 = "COMSPEC";
 	    }
 #endif
-	    obj1 = Tcl_NewStringObj(p1, -1);
-	    obj2 = Tcl_NewStringObj(p2, -1);
+	    obj1 = Tcl_NewStringObj(p1, TCL_INDEX_NONE);
+	    obj2 = Tcl_NewStringObj(p2, TCL_INDEX_NONE);
 	    Tcl_DStringFree(&envString);
 
 	    Tcl_IncrRefCount(obj1);
@@ -406,7 +406,7 @@ Tcl_PutEnv(
      * name and value parts, and call TclSetEnv to do all of the real work.
      */
 
-    name = Tcl_ExternalToUtfDString(NULL, assignment, -1, &nameString);
+    name = Tcl_ExternalToUtfDString(NULL, assignment, TCL_INDEX_NONE, &nameString);
     value = (char *)strchr(name, '=');
 
     if ((value != NULL) && (value != name)) {
@@ -582,7 +582,7 @@ TclGetEnv(
 	if (*result == '=') {
 	    result++;
 	    Tcl_DStringInit(valuePtr);
-	    Tcl_DStringAppend(valuePtr, result, -1);
+	    Tcl_DStringAppend(valuePtr, result, TCL_INDEX_NONE);
 	    result = Tcl_DStringValue(valuePtr);
 	} else {
 	    result = NULL;
diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index 1e23517..81ce1a7 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -5039,7 +5039,7 @@ TEBCresume(
 
     case INST_LREPLACE4:
 	{
-	Tcl_Size numToDelete, numNewElems;
+	size_t numToDelete, numNewElems;
 	int end_indicator;
 	int haveSecondIndex, flags;
 	Tcl_Obj *fromIdxObj, *toIdxObj;
diff --git a/generic/tclFCmd.c b/generic/tclFCmd.c
index 89550d9..c1dbc88 100644
--- a/generic/tclFCmd.c
+++ b/generic/tclFCmd.c
@@ -1042,7 +1042,7 @@ TclFileAttrsCmd(
 	    res = Tcl_FSFileAttrsGet(interp, index, filePtr, &objPtrAttr);
 	    if (res == TCL_OK) {
 		Tcl_Obj *objPtr =
-			Tcl_NewStringObj(attributeStrings[index], -1);
+			Tcl_NewStringObj(attributeStrings[index], TCL_INDEX_NONE);
 
 		Tcl_ListObjAppendElement(interp, listPtr, objPtr);
 		Tcl_ListObjAppendElement(interp, listPtr, objPtrAttr);
@@ -1492,7 +1492,7 @@ TclFileTemporaryCmd(
 	    return TCL_ERROR;
 	}
     }
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(Tcl_GetChannelName(chan), -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(Tcl_GetChannelName(chan), TCL_INDEX_NONE));
     return TCL_OK;
 }
 
diff --git a/generic/tclHistory.c b/generic/tclHistory.c
index dc5a67d..8083b4d 100644
--- a/generic/tclHistory.c
+++ b/generic/tclHistory.c
@@ -69,7 +69,7 @@ Tcl_RecordAndEval(
 	 * Call Tcl_RecordAndEvalObj to do the actual work.
 	 */
 
-	cmdPtr = Tcl_NewStringObj(cmd, -1);
+	cmdPtr = Tcl_NewStringObj(cmd, TCL_INDEX_NONE);
 	Tcl_IncrRefCount(cmdPtr);
 	result = Tcl_RecordAndEvalObj(interp, cmdPtr, flags);
 
diff --git a/generic/tclIOCmd.c b/generic/tclIOCmd.c
index 197ca32..2298d48 100644
--- a/generic/tclIOCmd.c
+++ b/generic/tclIOCmd.c
@@ -1080,7 +1080,7 @@ Tcl_OpenObjCmd(
 	if (objc == 4) {
 	    const char *permString = TclGetString(objv[3]);
 	    int code = TCL_ERROR;
-	    int scanned = TclParseAllWhiteSpace(permString, -1);
+	    int scanned = TclParseAllWhiteSpace(permString, TCL_INDEX_NONE);
 
 	    /*
 	     * Support legacy octal numbers.
diff --git a/generic/tclLink.c b/generic/tclLink.c
index 37c104b..eec778a 100644
--- a/generic/tclLink.c
+++ b/generic/tclLink.c
@@ -175,7 +175,7 @@ Tcl_LinkVar(
     linkPtr = (Link *)Tcl_Alloc(sizeof(Link));
     linkPtr->interp = interp;
     linkPtr->nsPtr = NULL;
-    linkPtr->varName = Tcl_NewStringObj(varName, -1);
+    linkPtr->varName = Tcl_NewStringObj(varName, TCL_INDEX_NONE);
     Tcl_IncrRefCount(linkPtr->varName);
     linkPtr->addr = addr;
     linkPtr->type = type & ~TCL_LINK_READ_ONLY;
@@ -256,7 +256,7 @@ Tcl_LinkArray(
 
     if (size < 1) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"wrong array size given", -1));
+		"wrong array size given", TCL_INDEX_NONE));
 	return TCL_ERROR;
     }
 
@@ -340,7 +340,7 @@ Tcl_LinkArray(
     default:
 	LinkFree(linkPtr);
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"bad linked array variable type", -1));
+		"bad linked array variable type", TCL_INDEX_NONE));
 	return TCL_ERROR;
     }
 
@@ -380,7 +380,7 @@ Tcl_LinkArray(
      */
 
     linkPtr->interp = interp;
-    linkPtr->varName = Tcl_NewStringObj(varName, -1);
+    linkPtr->varName = Tcl_NewStringObj(varName, TCL_INDEX_NONE);
     Tcl_IncrRefCount(linkPtr->varName);
 
     TclGetNamespaceForQualName(interp, varName, NULL, TCL_GLOBAL_ONLY,
@@ -1433,7 +1433,7 @@ ObjValue(
 	    TclNewLiteralStringObj(resultObj, "NULL");
 	    return resultObj;
 	}
-	return Tcl_NewStringObj(p, -1);
+	return Tcl_NewStringObj(p, TCL_INDEX_NONE);
 
     case TCL_LINK_CHARS:
 	if (linkPtr->flags & LINK_ALLOC_LAST) {
diff --git a/generic/tclListObj.c b/generic/tclListObj.c
index 9102af0..7cf96cb 100644
--- a/generic/tclListObj.c
+++ b/generic/tclListObj.c
@@ -526,7 +526,7 @@ ListLimitExceededError(Tcl_Interp *interp)
     if (interp != NULL) {
 	Tcl_SetObjResult(
 	    interp,
-	    Tcl_NewStringObj("max length of a Tcl list exceeded", -1));
+	    Tcl_NewStringObj("max length of a Tcl list exceeded", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
     }
     return TCL_ERROR;
diff --git a/generic/tclLiteral.c b/generic/tclLiteral.c
index dfb92cb..24e99fc 100644
--- a/generic/tclLiteral.c
+++ b/generic/tclLiteral.c
@@ -1057,7 +1057,7 @@ TclInvalidateCmdLiteral(
 {
     Interp *iPtr = (Interp *) interp;
     Tcl_Obj *literalObjPtr = TclCreateLiteral(iPtr, name,
-	    strlen(name), -1, NULL, nsPtr, 0, NULL);
+	    strlen(name), TCL_INDEX_NONE, NULL, nsPtr, 0, NULL);
 
     if (literalObjPtr != NULL) {
 	if (TclHasInternalRep(literalObjPtr, &tclCmdNameType)) {
diff --git a/generic/tclLoad.c b/generic/tclLoad.c
index fa0b584..b66122d 100644
--- a/generic/tclLoad.c
+++ b/generic/tclLoad.c
@@ -192,7 +192,7 @@ Tcl_LoadObjCmd(
     }
     if ((fullFileName[0] == 0) && (prefix == NULL)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"must specify either file name or prefix", -1));
+		"must specify either file name or prefix", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "LOAD", "NOLIBRARY",
 		NULL);
 	code = TCL_ERROR;
@@ -232,9 +232,9 @@ Tcl_LoadObjCmd(
 	    namesMatch = 0;
 	} else {
 	    TclDStringClear(&pfx);
-	    Tcl_DStringAppend(&pfx, prefix, -1);
+	    Tcl_DStringAppend(&pfx, prefix, TCL_INDEX_NONE);
 	    TclDStringClear(&tmp);
-	    Tcl_DStringAppend(&tmp, libraryPtr->prefix, -1);
+	    Tcl_DStringAppend(&tmp, libraryPtr->prefix, TCL_INDEX_NONE);
 	    if (strcmp(Tcl_DStringValue(&tmp),
 		    Tcl_DStringValue(&pfx)) == 0) {
 		namesMatch = 1;
@@ -307,7 +307,7 @@ Tcl_LoadObjCmd(
 	 */
 
 	if (prefix != NULL) {
-	    Tcl_DStringAppend(&pfx, prefix, -1);
+	    Tcl_DStringAppend(&pfx, prefix, TCL_INDEX_NONE);
 	} else {
 	    Tcl_Obj *splitPtr, *pkgGuessPtr;
 	    size_t pElements;
@@ -487,7 +487,7 @@ Tcl_LoadObjCmd(
 	     * this interp are incompatible in their stubs mechanisms, and
 	     * recorded the error in the oldest legacy place we have to do so.
 	     */
-	    Tcl_SetObjResult(target, Tcl_NewStringObj(iPtr->legacyResult, -1));
+	    Tcl_SetObjResult(target, Tcl_NewStringObj(iPtr->legacyResult, TCL_INDEX_NONE));
 	    iPtr->legacyResult = NULL;
 	    iPtr->legacyFreeProc = (void (*) (void))-1;
 	}
@@ -625,7 +625,7 @@ Tcl_UnloadObjCmd(
     }
     if ((fullFileName[0] == 0) && (prefix == NULL)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"must specify either file name or prefix", -1));
+		"must specify either file name or prefix", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "UNLOAD", "NOLIBRARY",
 		NULL);
 	code = TCL_ERROR;
@@ -665,9 +665,9 @@ Tcl_UnloadObjCmd(
 	    namesMatch = 0;
 	} else {
 	    TclDStringClear(&pfx);
-	    Tcl_DStringAppend(&pfx, prefix, -1);
+	    Tcl_DStringAppend(&pfx, prefix, TCL_INDEX_NONE);
 	    TclDStringClear(&tmp);
-	    Tcl_DStringAppend(&tmp, libraryPtr->prefix, -1);
+	    Tcl_DStringAppend(&tmp, libraryPtr->prefix, TCL_INDEX_NONE);
 	    if (strcmp(Tcl_DStringValue(&tmp),
 		    Tcl_DStringValue(&pfx)) == 0) {
 		namesMatch = 1;
@@ -1121,8 +1121,8 @@ TclGetLoadedLibraries(
 	Tcl_MutexLock(&libraryMutex);
 	for (libraryPtr = firstLibraryPtr; libraryPtr != NULL;
 		libraryPtr = libraryPtr->nextPtr) {
-	    pkgDesc[0] = Tcl_NewStringObj(libraryPtr->fileName, -1);
-	    pkgDesc[1] = Tcl_NewStringObj(libraryPtr->prefix, -1);
+	    pkgDesc[0] = Tcl_NewStringObj(libraryPtr->fileName, TCL_INDEX_NONE);
+	    pkgDesc[1] = Tcl_NewStringObj(libraryPtr->prefix, TCL_INDEX_NONE);
 	    Tcl_ListObjAppendElement(NULL, resultObj,
 		    Tcl_NewListObj(2, pkgDesc));
 	}
@@ -1147,7 +1147,7 @@ TclGetLoadedLibraries(
 	    libraryPtr = ipPtr->libraryPtr;
 
 	    if (!strcmp(prefix, libraryPtr->prefix)) {
-		resultObj = Tcl_NewStringObj(libraryPtr->fileName, -1);
+		resultObj = Tcl_NewStringObj(libraryPtr->fileName, TCL_INDEX_NONE);
 		break;
 	    }
 	}
@@ -1166,8 +1166,8 @@ TclGetLoadedLibraries(
     TclNewObj(resultObj);
     for (; ipPtr != NULL; ipPtr = ipPtr->nextPtr) {
 	libraryPtr = ipPtr->libraryPtr;
-	pkgDesc[0] = Tcl_NewStringObj(libraryPtr->fileName, -1);
-	pkgDesc[1] = Tcl_NewStringObj(libraryPtr->prefix, -1);
+	pkgDesc[0] = Tcl_NewStringObj(libraryPtr->fileName, TCL_INDEX_NONE);
+	pkgDesc[1] = Tcl_NewStringObj(libraryPtr->prefix, TCL_INDEX_NONE);
 	Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewListObj(2, pkgDesc));
     }
     Tcl_SetObjResult(interp, resultObj);
diff --git a/generic/tclLoadNone.c b/generic/tclLoadNone.c
index f60f843..abf6eda 100644
--- a/generic/tclLoadNone.c
+++ b/generic/tclLoadNone.c
@@ -81,7 +81,7 @@ TclpLoadMemory(
 {
     if (interp) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj("dynamic loading from memory "
-		"is not available on this system", -1));
+		"is not available on this system", TCL_INDEX_NONE));
     }
     return TCL_ERROR;
 }
diff --git a/generic/tclOOCall.c b/generic/tclOOCall.c
index 450fc9f..fcf7f2b 100644
--- a/generic/tclOOCall.c
+++ b/generic/tclOOCall.c
@@ -1848,7 +1848,7 @@ TclOORenderCallChain(
 		? Tcl_GetObjectName(interp,
 			(Tcl_Object) miPtr->mPtr->declaringClassPtr->thisPtr)
 		: objectLiteral;
-	descObjs[3] = Tcl_NewStringObj(miPtr->mPtr->typePtr->name, -1);
+	descObjs[3] = Tcl_NewStringObj(miPtr->mPtr->typePtr->name, TCL_INDEX_NONE);
 
 	objv[i] = Tcl_NewListObj(4, descObjs);
     }
diff --git a/generic/tclOOMethod.c b/generic/tclOOMethod.c
index 70f9503..2ac21b8 100644
--- a/generic/tclOOMethod.c
+++ b/generic/tclOOMethod.c
@@ -387,7 +387,7 @@ TclOONewBasicMethod(
 				/* Name of the method, whether it is public,
 				 * and the function to implement it. */
 {
-    Tcl_Obj *namePtr = Tcl_NewStringObj(dcm->name, -1);
+    Tcl_Obj *namePtr = Tcl_NewStringObj(dcm->name, TCL_INDEX_NONE);
 
     Tcl_IncrRefCount(namePtr);
     TclNewMethod(interp, (Tcl_Class) clsPtr, namePtr,
@@ -1410,7 +1410,7 @@ CloneProcedureMethod(
 
 	    TclNewObj(argObj);
 	    Tcl_ListObjAppendElement(NULL, argObj,
-		    Tcl_NewStringObj(localPtr->name, -1));
+		    Tcl_NewStringObj(localPtr->name, TCL_INDEX_NONE));
 	    if (localPtr->defValuePtr != NULL) {
 		Tcl_ListObjAppendElement(NULL, argObj, localPtr->defValuePtr);
 	    }
@@ -1481,7 +1481,7 @@ TclOONewForwardInstanceMethod(
     }
     if (prefixLen < 1) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"method forward prefix must be non-empty", -1));
+		"method forward prefix must be non-empty", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "BAD_FORWARD", NULL);
 	return NULL;
     }
@@ -1520,7 +1520,7 @@ TclOONewForwardMethod(
     }
     if (prefixLen < 1) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"method forward prefix must be non-empty", -1));
+		"method forward prefix must be non-empty", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "BAD_FORWARD", NULL);
 	return NULL;
     }
@@ -1707,7 +1707,7 @@ InitEnsembleRewrite(
     int *lengthPtr)		/* Where to write the resulting length of the
 				 * array of rewritten arguments. */
 {
-    unsigned len = rewriteLength + objc - toRewrite;
+    size_t len = rewriteLength + objc - toRewrite;
     Tcl_Obj **argObjs = (Tcl_Obj **)TclStackAlloc(interp, sizeof(Tcl_Obj *) * len);
 
     memcpy(argObjs, rewriteObjs, rewriteLength * sizeof(Tcl_Obj *));
diff --git a/generic/tclPathObj.c b/generic/tclPathObj.c
index d0826b7..19c1b9d 100644
--- a/generic/tclPathObj.c
+++ b/generic/tclPathObj.c
@@ -751,7 +751,7 @@ GetExtension(
     if (extension == NULL) {
 	TclNewObj(ret);
     } else {
-	ret = Tcl_NewStringObj(extension, -1);
+	ret = Tcl_NewStringObj(extension, TCL_INDEX_NONE);
     }
     Tcl_IncrRefCount(ret);
     return ret;
diff --git a/generic/tclPkg.c b/generic/tclPkg.c
index 34346f9..132a219 100644
--- a/generic/tclPkg.c
+++ b/generic/tclPkg.c
@@ -165,7 +165,7 @@ Tcl_PkgProvideEx(
 
     pkgPtr = FindPackage(interp, name);
     if (pkgPtr->version == NULL) {
-	pkgPtr->version = Tcl_NewStringObj(version, -1);
+	pkgPtr->version = Tcl_NewStringObj(version, TCL_INDEX_NONE);
 	Tcl_IncrRefCount(pkgPtr->version);
 	pkgPtr->clientData = clientData;
 	return TCL_OK;
@@ -291,7 +291,7 @@ TclPkgFileSeen(
 	} else {
 	    list = (Tcl_Obj *)Tcl_GetHashValue(entry);
 	}
-	Tcl_ListObjAppendElement(interp, list, Tcl_NewStringObj(fileName, -1));
+	Tcl_ListObjAppendElement(interp, list, Tcl_NewStringObj(fileName, TCL_INDEX_NONE));
     }
 }
 
@@ -407,7 +407,7 @@ Tcl_PkgRequireEx(
 		!= CheckVersionAndConvert(interp, version, NULL, NULL)) {
 	    return NULL;
 	}
-	ov = Tcl_NewStringObj(version, -1);
+	ov = Tcl_NewStringObj(version, TCL_INDEX_NONE);
 	if (exact) {
 	    Tcl_AppendStringsToObj(ov, "-", version, NULL);
 	}
@@ -531,7 +531,7 @@ PkgRequireCoreStep1(
      */
 
     Tcl_DStringInit(&command);
-    Tcl_DStringAppend(&command, script, -1);
+    Tcl_DStringAppend(&command, script, TCL_INDEX_NONE);
     Tcl_DStringAppendElement(&command, name);
     AddRequirementsToDString(&command, reqc, reqv);
 
@@ -839,7 +839,7 @@ SelectPackage(
 	Tcl_NRAddCallback(interp,
 		SelectPackageFinal, reqPtr, INT2PTR(reqc), (void *)reqv,
 		data[3]);
-	Tcl_NREvalObj(interp, Tcl_NewStringObj(bestPtr->script, -1),
+	Tcl_NREvalObj(interp, Tcl_NewStringObj(bestPtr->script, TCL_INDEX_NONE),
 		TCL_EVAL_GLOBAL);
     }
     return TCL_OK;
@@ -1200,7 +1200,7 @@ TclNRPackageObjCmd(
 		if (objc == 4) {
 		    Tcl_Free(argv3i);
 		    Tcl_SetObjResult(interp,
-			    Tcl_NewStringObj(availPtr->script, -1));
+			    Tcl_NewStringObj(availPtr->script, TCL_INDEX_NONE));
 		    return TCL_OK;
 		}
 		Tcl_EventuallyFree(availPtr->script, TCL_DYNAMIC);
@@ -1251,7 +1251,7 @@ TclNRPackageObjCmd(
 		pkgPtr = (Package *)Tcl_GetHashValue(hPtr);
 		if ((pkgPtr->version != NULL) || (pkgPtr->availPtr != NULL)) {
 		    Tcl_ListObjAppendElement(NULL,resultObj, Tcl_NewStringObj(
-			    (char *)Tcl_GetHashKey(tablePtr, hPtr), -1));
+			    (char *)Tcl_GetHashKey(tablePtr, hPtr), TCL_INDEX_NONE));
 		}
 	    }
 	    Tcl_SetObjResult(interp, resultObj);
@@ -1353,7 +1353,7 @@ TclNRPackageObjCmd(
 	     * Create a new-style requirement for the exact version.
 	     */
 
-	    ov = Tcl_NewStringObj(version, -1);
+	    ov = Tcl_NewStringObj(version, TCL_INDEX_NONE);
 	    Tcl_AppendStringsToObj(ov, "-", version, NULL);
 	    version = NULL;
 	    argv3 = TclGetString(objv[3]);
@@ -1404,7 +1404,7 @@ TclNRPackageObjCmd(
 	if (objc == 2) {
 	    if (iPtr->packageUnknown != NULL) {
 		Tcl_SetObjResult(interp,
-			Tcl_NewStringObj(iPtr->packageUnknown, -1));
+			Tcl_NewStringObj(iPtr->packageUnknown, TCL_INDEX_NONE));
 	    }
 	} else if (objc == 3) {
 	    if (iPtr->packageUnknown != NULL) {
@@ -1456,7 +1456,7 @@ TclNRPackageObjCmd(
 	 */
 
 	Tcl_SetObjResult(interp,
-		Tcl_NewStringObj(pkgPreferOptions[iPtr->packagePrefer], -1));
+		Tcl_NewStringObj(pkgPreferOptions[iPtr->packagePrefer], TCL_INDEX_NONE));
 	break;
     }
     case PKG_VCOMPARE:
@@ -1503,7 +1503,7 @@ TclNRPackageObjCmd(
 		for (availPtr = pkgPtr->availPtr; availPtr != NULL;
 			availPtr = availPtr->nextPtr) {
 		    Tcl_ListObjAppendElement(NULL, resultObj,
-			    Tcl_NewStringObj(availPtr->version, -1));
+			    Tcl_NewStringObj(availPtr->version, TCL_INDEX_NONE));
 		}
 	    }
 	    Tcl_SetObjResult(interp, resultObj);
diff --git a/generic/tclProc.c b/generic/tclProc.c
index 01bc337..c8a304a 100644
--- a/generic/tclProc.c
+++ b/generic/tclProc.c
@@ -524,9 +524,9 @@ TclCreateProc(
 	}
 	if (fieldCount > 2) {
 	    Tcl_Obj *errorObj = Tcl_NewStringObj(
-		"too many fields in argument specifier \"", -1);
+		"too many fields in argument specifier \"", TCL_INDEX_NONE);
 	    Tcl_AppendObjToObj(errorObj, argArray[i]);
-	    Tcl_AppendToObj(errorObj, "\"", -1);
+	    Tcl_AppendToObj(errorObj, "\"", TCL_INDEX_NONE);
 	    Tcl_SetObjResult(interp, errorObj);
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "PROC",
 		    "FORMALARGUMENTFORMAT", NULL);
@@ -534,7 +534,7 @@ TclCreateProc(
 	}
 	if ((fieldCount == 0) || (Tcl_GetCharLength(fieldValues[0]) == 0)) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "argument with no name", -1));
+		    "argument with no name", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "PROC",
 		    "FORMALARGUMENTFORMAT", NULL);
 	    goto procError;
@@ -560,9 +560,9 @@ TclCreateProc(
 		}
 	    } else if (*argnamei == ':' && *(argnamei+1) == ':') {
 		Tcl_Obj *errorObj = Tcl_NewStringObj(
-		    "formal parameter \"", -1);
+		    "formal parameter \"", TCL_INDEX_NONE);
 		Tcl_AppendObjToObj(errorObj, fieldValues[0]);
-		Tcl_AppendToObj(errorObj, "\" is not a simple name", -1);
+		Tcl_AppendToObj(errorObj, "\" is not a simple name", TCL_INDEX_NONE);
 		Tcl_SetObjResult(interp, errorObj);
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "PROC",
 			"FORMALARGUMENTFORMAT", NULL);
@@ -613,7 +613,7 @@ TclCreateProc(
 			    "procedure \"%s\": formal parameter \"", procName);
 		    Tcl_AppendObjToObj(errorObj, fieldValues[0]);
 		    Tcl_AppendToObj(errorObj, "\" has "
-			"default value inconsistent with precompiled body", -1);
+			"default value inconsistent with precompiled body", TCL_INDEX_NONE);
 		    Tcl_SetObjResult(interp, errorObj);
 		    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "PROC",
 			    "BYTECODELIES", NULL);
@@ -1080,7 +1080,7 @@ ProcWrongNumArgs(
 	    sizeof(Tcl_Obj *) * (numArgs+1));
 
     if (framePtr->isProcCallFrame & FRAME_IS_LAMBDA) {
-	desiredObjs[0] = Tcl_NewStringObj("lambdaExpr", -1);
+	desiredObjs[0] = Tcl_NewStringObj("lambdaExpr", TCL_INDEX_NONE);
     } else {
 	desiredObjs[0] = framePtr->objv[skip-1];
     }
@@ -1941,7 +1941,7 @@ TclProcCompileProc(
 	if (codePtr->flags & TCL_BYTECODE_PRECOMPILED) {
 	    if ((Interp *) *codePtr->interpHandle != iPtr) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"a precompiled script jumped interps", -1));
+			"a precompiled script jumped interps", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "PROC",
 			"CROSSINTERPBYTECODE", NULL);
 		return TCL_ERROR;
@@ -1969,7 +1969,7 @@ TclProcCompileProc(
 	    TclNewLiteralStringObj(message, "Compiling ");
 	    Tcl_IncrRefCount(message);
 	    Tcl_AppendStringsToObj(message, description, " \"", NULL);
-	    Tcl_AppendLimitedToObj(message, procName, -1, 50, NULL);
+	    Tcl_AppendLimitedToObj(message, procName, TCL_INDEX_NONE, 50, NULL);
 	    fprintf(stdout, "%s\"\n", TclGetString(message));
 	    Tcl_DecrRefCount(message);
 	}
diff --git a/generic/tclRegexp.c b/generic/tclRegexp.c
index 4e3c6c5..07beffd 100644
--- a/generic/tclRegexp.c
+++ b/generic/tclRegexp.c
@@ -221,9 +221,9 @@ Tcl_RegExpExec(
      */
 
     Tcl_DStringInit(&ds);
-    ustr = Tcl_UtfToUniCharDString(text, -1, &ds);
+    ustr = Tcl_UtfToUniCharDString(text, TCL_INDEX_NONE, &ds);
     numChars = Tcl_DStringLength(&ds) / sizeof(Tcl_UniChar);
-    result = RegExpExecUniChar(interp, re, ustr, numChars, -1 /* nmatches */,
+    result = RegExpExecUniChar(interp, re, ustr, numChars, TCL_INDEX_NONE /* nmatches */,
 	    flags);
     Tcl_DStringFree(&ds);
 
@@ -689,7 +689,7 @@ TclRegAbout(
     for (inf=infonames ; inf->bit != 0 ; inf++) {
 	if (regexpPtr->re.re_info & inf->bit) {
 	    Tcl_ListObjAppendElement(NULL, infoObj,
-		    Tcl_NewStringObj(inf->text, -1));
+		    Tcl_NewStringObj(inf->text, TCL_INDEX_NONE));
 	}
     }
     Tcl_ListObjAppendElement(NULL, resultObj, infoObj);
diff --git a/generic/tclResult.c b/generic/tclResult.c
index c0266bc..6a36fdf 100644
--- a/generic/tclResult.c
+++ b/generic/tclResult.c
@@ -317,7 +317,7 @@ Tcl_AppendResult(
 	if (bytes == NULL) {
 	    break;
 	}
-	Tcl_AppendToObj(objPtr, bytes, -1);
+	Tcl_AppendToObj(objPtr, bytes, TCL_INDEX_NONE);
     }
     Tcl_SetObjResult(interp, objPtr);
     va_end(argList);
@@ -354,7 +354,7 @@ Tcl_AppendElement(
 				 * to result. */
 {
     Interp *iPtr = (Interp *) interp;
-    Tcl_Obj *elementPtr = Tcl_NewStringObj(element, -1);
+    Tcl_Obj *elementPtr = Tcl_NewStringObj(element, TCL_INDEX_NONE);
     Tcl_Obj *listPtr = Tcl_NewListObj(1, &elementPtr);
     const char *bytes;
     size_t length;
@@ -511,7 +511,7 @@ Tcl_SetErrorCode(
 	if (elem == NULL) {
 	    break;
 	}
-	Tcl_ListObjAppendElement(NULL, errorObj, Tcl_NewStringObj(elem, -1));
+	Tcl_ListObjAppendElement(NULL, errorObj, Tcl_NewStringObj(elem, TCL_INDEX_NONE));
     }
     Tcl_SetObjErrorCode(interp, errorObj);
     va_end(argList);
diff --git a/generic/tclStrToD.c b/generic/tclStrToD.c
index 597fe77..2f29617 100644
--- a/generic/tclStrToD.c
+++ b/generic/tclStrToD.c
@@ -1523,7 +1523,7 @@ TclParseNumber(
 		    expected);
 
 	    Tcl_AppendLimitedToObj(msg, bytes, numBytes, 50, "");
-	    Tcl_AppendToObj(msg, "\"", -1);
+	    Tcl_AppendToObj(msg, "\"", TCL_INDEX_NONE);
 	    Tcl_SetObjResult(interp, msg);
 	    Tcl_SetErrorCode(interp, "TCL", "VALUE", "NUMBER", NULL);
 	}
@@ -4787,7 +4787,7 @@ Tcl_InitBignumFromDouble(
 	if (interp != NULL) {
 	    const char *s = "integer value too large to represent";
 
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(s, -1));
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(s, TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", s, NULL);
 	}
 	return TCL_ERROR;
diff --git a/generic/tclStringObj.c b/generic/tclStringObj.c
index e1376f4..0acc6e2 100644
--- a/generic/tclStringObj.c
+++ b/generic/tclStringObj.c
@@ -1683,7 +1683,7 @@ AppendUtfToUnicodeRep(
 	return;
     }
 
-    ExtendUnicodeRepWithString(objPtr, bytes, numBytes, -1);
+    ExtendUnicodeRepWithString(objPtr, bytes, numBytes, TCL_INDEX_NONE);
     TclInvalidateStringRep(objPtr);
     stringPtr = GET_STRING(objPtr);
     stringPtr->allocated = 0;
@@ -1812,7 +1812,7 @@ Tcl_AppendStringsToObj(
 	if (bytes == NULL) {
 	    break;
 	}
-	Tcl_AppendToObj(objPtr, bytes, -1);
+	Tcl_AppendToObj(objPtr, bytes, TCL_INDEX_NONE);
     }
     va_end(argList);
 }
@@ -2588,7 +2588,7 @@ Tcl_AppendFormatToObj(
 
   errorMsg:
     if (interp != NULL) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(msg, -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(msg, TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "FORMAT", errCode, NULL);
     }
   error:
diff --git a/generic/tclStubInit.c b/generic/tclStubInit.c
index 1186aa3..dbd8b52 100644
--- a/generic/tclStubInit.c
+++ b/generic/tclStubInit.c
@@ -337,7 +337,7 @@ static int exprInt(Tcl_Interp *interp, const char *expr, int *ptr){
 	    *ptr = (int)longValue;
 	} else {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "integer value too large to represent", -1));
+		    "integer value too large to represent", TCL_INDEX_NONE));
 	    result = TCL_ERROR;
 	}
     }
@@ -353,7 +353,7 @@ static int exprIntObj(Tcl_Interp *interp, Tcl_Obj*expr, int *ptr){
 	    *ptr = (int)longValue;
 	} else {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "integer value too large to represent", -1));
+		    "integer value too large to represent", TCL_INDEX_NONE));
 	    result = TCL_ERROR;
 	}
     }
diff --git a/generic/tclTestObj.c b/generic/tclTestObj.c
index 131601d..3bf6989 100644
--- a/generic/tclTestObj.c
+++ b/generic/tclTestObj.c
@@ -180,13 +180,13 @@ TestbignumobjCmd(
 	string = Tcl_GetString(objv[3]);
 	if (mp_init(&bignumValue) != MP_OKAY) {
 	    Tcl_SetObjResult(interp,
-		    Tcl_NewStringObj("error in mp_init", -1));
+		    Tcl_NewStringObj("error in mp_init", TCL_INDEX_NONE));
 	    return TCL_ERROR;
 	}
 	if (mp_read_radix(&bignumValue, string, 10) != MP_OKAY) {
 	    mp_clear(&bignumValue);
 	    Tcl_SetObjResult(interp,
-		    Tcl_NewStringObj("error in mp_read_radix", -1));
+		    Tcl_NewStringObj("error in mp_read_radix", TCL_INDEX_NONE));
 	    return TCL_ERROR;
 	}
 
@@ -230,7 +230,7 @@ TestbignumobjCmd(
 	if (mp_mul_d(&bignumValue, 10, &bignumValue) != MP_OKAY) {
 	    mp_clear(&bignumValue);
 	    Tcl_SetObjResult(interp,
-		    Tcl_NewStringObj("error in mp_mul_d", -1));
+		    Tcl_NewStringObj("error in mp_mul_d", TCL_INDEX_NONE));
 	    return TCL_ERROR;
 	}
 	if (!Tcl_IsShared(varPtr[varIndex])) {
@@ -255,7 +255,7 @@ TestbignumobjCmd(
 	if (mp_div_d(&bignumValue, 10, &bignumValue, NULL) != MP_OKAY) {
 	    mp_clear(&bignumValue);
 	    Tcl_SetObjResult(interp,
-		    Tcl_NewStringObj("error in mp_div_d", -1));
+		    Tcl_NewStringObj("error in mp_div_d", TCL_INDEX_NONE));
 	    return TCL_ERROR;
 	}
 	if (!Tcl_IsShared(varPtr[varIndex])) {
@@ -280,7 +280,7 @@ TestbignumobjCmd(
 	if (mp_mod_2d(&bignumValue, 1, &bignumValue) != MP_OKAY) {
 	    mp_clear(&bignumValue);
 	    Tcl_SetObjResult(interp,
-		    Tcl_NewStringObj("error in mp_mod_2d", -1));
+		    Tcl_NewStringObj("error in mp_mod_2d", TCL_INDEX_NONE));
 	    return TCL_ERROR;
 	}
 	if (!Tcl_IsShared(varPtr[varIndex])) {
@@ -598,7 +598,7 @@ TestindexobjCmd(
     }
 
     if (objc < 5) {
-	Tcl_AppendToObj(Tcl_GetObjResult(interp), "wrong # args", -1);
+	Tcl_AppendToObj(Tcl_GetObjResult(interp), "wrong # args", TCL_INDEX_NONE);
 	return TCL_ERROR;
     }
 
@@ -738,7 +738,7 @@ TestintobjCmd(
 	    return TCL_ERROR;
 	}
 	Tcl_AppendToObj(Tcl_GetObjResult(interp),
-		((wideValue == WIDE_MAX)? "1" : "0"), -1);
+		((wideValue == WIDE_MAX)? "1" : "0"), TCL_INDEX_NONE);
     } else if (strcmp(subCmd, "get") == 0) {
 	if (objc != 3) {
 	    goto wrongNumArgs;
@@ -754,7 +754,7 @@ TestintobjCmd(
 	if (CheckIfVarUnset(interp, varPtr,varIndex)) {
 	    return TCL_ERROR;
 	}
-	Tcl_AppendToObj(Tcl_GetObjResult(interp), Tcl_GetString(varPtr[varIndex]), -1);
+	Tcl_AppendToObj(Tcl_GetObjResult(interp), Tcl_GetString(varPtr[varIndex]), TCL_INDEX_NONE);
     } else if (strcmp(subCmd, "inttoobigtest") == 0) {
 	/*
 	 * If long ints have more bits than ints on this platform, verify that
@@ -767,7 +767,7 @@ TestintobjCmd(
 	    goto wrongNumArgs;
 	}
 #if (INT_MAX == LONG_MAX)   /* int is same size as long int */
-	Tcl_AppendToObj(Tcl_GetObjResult(interp), "1", -1);
+	Tcl_AppendToObj(Tcl_GetObjResult(interp), "1", TCL_INDEX_NONE);
 #else
 	if ((varPtr[varIndex] != NULL) && !Tcl_IsShared(varPtr[varIndex])) {
 	    Tcl_SetWideIntObj(varPtr[varIndex], LONG_MAX);
@@ -776,10 +776,10 @@ TestintobjCmd(
 	}
 	if (Tcl_GetIntFromObj(interp, varPtr[varIndex], &i) != TCL_OK) {
 	    Tcl_ResetResult(interp);
-	    Tcl_AppendToObj(Tcl_GetObjResult(interp), "1", -1);
+	    Tcl_AppendToObj(Tcl_GetObjResult(interp), "1", TCL_INDEX_NONE);
 	    return TCL_OK;
 	}
-	Tcl_AppendToObj(Tcl_GetObjResult(interp), "0", -1);
+	Tcl_AppendToObj(Tcl_GetObjResult(interp), "0", TCL_INDEX_NONE);
 #endif
     } else if (strcmp(subCmd, "mult10") == 0) {
 	if (objc != 3) {
@@ -1104,7 +1104,7 @@ TestobjCmd(
 	    const char *typeName;
 
 	    if (objv[2]->typePtr == NULL) {
-		Tcl_SetObjResult(interp, Tcl_NewStringObj("none", -1));
+		Tcl_SetObjResult(interp, Tcl_NewStringObj("none", TCL_INDEX_NONE));
 	    }
 	    else {
 		typeName = objv[2]->typePtr->name;
@@ -1113,7 +1113,7 @@ TestobjCmd(
 #ifndef TCL_WIDE_INT_IS_LONG
 	    else if (!strcmp(typeName, "wideInt")) typeName = "int";
 #endif
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(typeName, -1));
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(typeName, TCL_INDEX_NONE));
 	    }
 	}
 	return TCL_OK;
@@ -1207,15 +1207,15 @@ TestobjCmd(
 	    goto wrongNumArgs;
 	}
 	if (varPtr[varIndex]->typePtr == NULL) { /* a string! */
-	    Tcl_AppendToObj(Tcl_GetObjResult(interp), "string", -1);
+	    Tcl_AppendToObj(Tcl_GetObjResult(interp), "string", TCL_INDEX_NONE);
 #ifndef TCL_WIDE_INT_IS_LONG
 	} else if (!strcmp(varPtr[varIndex]->typePtr->name, "wideInt")) {
 	    Tcl_AppendToObj(Tcl_GetObjResult(interp),
-		    "int", -1);
+		    "int", TCL_INDEX_NONE);
 #endif
 	} else {
 	    Tcl_AppendToObj(Tcl_GetObjResult(interp),
-		    varPtr[varIndex]->typePtr->name, -1);
+		    varPtr[varIndex]->typePtr->name, TCL_INDEX_NONE);
 	}
 	break;
     default:
@@ -1346,7 +1346,7 @@ TeststringobjCmd(
 	    if (CheckIfVarUnset(interp, varPtr, varIndex)) {
 		return TCL_ERROR;
 	    }
-	    Tcl_AppendToObj(Tcl_GetObjResult(interp), Tcl_GetString(varPtr[varIndex]), -1);
+	    Tcl_AppendToObj(Tcl_GetObjResult(interp), Tcl_GetString(varPtr[varIndex]), TCL_INDEX_NONE);
 	    break;
 	case 4:				/* length */
 	    if (objc != 3) {
@@ -1459,7 +1459,7 @@ TeststringobjCmd(
 	    }
 	    if ((length < 0) || ((Tcl_WideUInt)length > (Tcl_WideUInt)size)) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"index value out of range", -1));
+			"index value out of range", TCL_INDEX_NONE));
 		return TCL_ERROR;
 	    }
 
@@ -1490,7 +1490,7 @@ TeststringobjCmd(
 	    }
 	    if ((length < 0) || ((Tcl_WideUInt)length > (Tcl_WideUInt)size)) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"index value out of range", -1));
+			"index value out of range", TCL_INDEX_NONE));
 		return TCL_ERROR;
 	    }
 
@@ -1567,7 +1567,7 @@ GetVariableIndex(
     }
     if (index < 0 || index >= NUMBER_OF_OBJECT_VARS) {
 	Tcl_ResetResult(interp);
-	Tcl_AppendToObj(Tcl_GetObjResult(interp), "bad variable index", -1);
+	Tcl_AppendToObj(Tcl_GetObjResult(interp), "bad variable index", TCL_INDEX_NONE);
 	return TCL_ERROR;
     }
 
@@ -1604,7 +1604,7 @@ CheckIfVarUnset(
 
 	sprintf(buf, "variable %" TCL_Z_MODIFIER "u is unset (NULL)", varIndex);
 	Tcl_ResetResult(interp);
-	Tcl_AppendToObj(Tcl_GetObjResult(interp), buf, -1);
+	Tcl_AppendToObj(Tcl_GetObjResult(interp), buf, TCL_INDEX_NONE);
 	return 1;
     }
     return 0;
diff --git a/generic/tclTestProcBodyObj.c b/generic/tclTestProcBodyObj.c
index 6d5e6ec..8d92c6e 100644
--- a/generic/tclTestProcBodyObj.c
+++ b/generic/tclTestProcBodyObj.c
@@ -146,7 +146,7 @@ RegisterCommand(
     if (cmdTablePtr->exportIt) {
 	sprintf(buf, "namespace eval %s { namespace export %s }",
 		namesp, cmdTablePtr->cmdName);
-	if (Tcl_EvalEx(interp, buf, -1, 0) != TCL_OK) {
+	if (Tcl_EvalEx(interp, buf, TCL_INDEX_NONE, 0) != TCL_OK) {
 	    return TCL_ERROR;
 	}
     }
diff --git a/generic/tclThreadTest.c b/generic/tclThreadTest.c
index 6f37124..5781329 100644
--- a/generic/tclThreadTest.c
+++ b/generic/tclThreadTest.c
@@ -607,7 +607,7 @@ NewTestThread(
      */
 
     Tcl_Preserve(tsdPtr->interp);
-    result = Tcl_EvalEx(tsdPtr->interp, threadEvalScript, -1, 0);
+    result = Tcl_EvalEx(tsdPtr->interp, threadEvalScript, TCL_INDEX_NONE, 0);
     if (result != TCL_OK) {
 	ThreadErrorProc(tsdPtr->interp);
     }
@@ -654,10 +654,10 @@ ThreadErrorProc(
     errorInfo = Tcl_GetVar2(interp, "errorInfo", NULL, TCL_GLOBAL_ONLY);
     if (errorProcString == NULL) {
 	errChannel = Tcl_GetStdChannel(TCL_STDERR);
-	Tcl_WriteChars(errChannel, "Error from thread ", -1);
-	Tcl_WriteChars(errChannel, buf, -1);
+	Tcl_WriteChars(errChannel, "Error from thread ", TCL_INDEX_NONE);
+	Tcl_WriteChars(errChannel, buf, TCL_INDEX_NONE);
 	Tcl_WriteChars(errChannel, "\n", 1);
-	Tcl_WriteChars(errChannel, errorInfo, -1);
+	Tcl_WriteChars(errChannel, errorInfo, TCL_INDEX_NONE);
 	Tcl_WriteChars(errChannel, "\n", 1);
     } else {
 	argv[0] = errorProcString;
@@ -982,7 +982,7 @@ ThreadCancel(
     Tcl_MutexUnlock(&threadMutex);
     Tcl_ResetResult(interp);
     return Tcl_CancelEval(tsdPtr->interp,
-    	(result != NULL) ? Tcl_NewStringObj(result, -1) : NULL, 0, flags);
+    	(result != NULL) ? Tcl_NewStringObj(result, TCL_INDEX_NONE) : NULL, 0, flags);
 }
 
 /*
diff --git a/generic/tclTimer.c b/generic/tclTimer.c
index d49c5c8..3b4741e 100644
--- a/generic/tclTimer.c
+++ b/generic/tclTimer.c
@@ -21,7 +21,7 @@
 typedef struct TimerHandler {
     Tcl_Time time;		/* When timer is to fire. */
     Tcl_TimerProc *proc;	/* Function to call. */
-    ClientData clientData;	/* Argument to pass to proc. */
+    void *clientData;	/* Argument to pass to proc. */
     Tcl_TimerToken token;	/* Identifies handler so it can be deleted. */
     struct TimerHandler *nextPtr;
 				/* Next event in queue, or NULL for end of
@@ -73,7 +73,7 @@ typedef struct AfterAssocData {
 
 typedef struct IdleHandler {
     Tcl_IdleProc *proc;		/* Function to call. */
-    ClientData clientData;	/* Value to pass to proc. */
+    void *clientData;	/* Value to pass to proc. */
     int generation;		/* Used to distinguish older handlers from
 				 * recently-created ones. */
     struct IdleHandler *nextPtr;/* Next in list of active handlers. */
@@ -150,18 +150,18 @@ static Tcl_ThreadDataKey dataKey;
  * Prototypes for functions referenced only in this file:
  */
 
-static void		AfterCleanupProc(ClientData clientData,
+static void		AfterCleanupProc(void *clientData,
 			    Tcl_Interp *interp);
 static int		AfterDelay(Tcl_Interp *interp, Tcl_WideInt ms);
-static void		AfterProc(ClientData clientData);
+static void		AfterProc(void *clientData);
 static void		FreeAfterPtr(AfterInfo *afterPtr);
 static AfterInfo *	GetAfterEvent(AfterAssocData *assocPtr,
 			    Tcl_Obj *commandPtr);
 static ThreadSpecificData *InitTimer(void);
-static void		TimerExitProc(ClientData clientData);
+static void		TimerExitProc(void *clientData);
 static int		TimerHandlerEventProc(Tcl_Event *evPtr, int flags);
-static void		TimerCheckProc(ClientData clientData, int flags);
-static void		TimerSetupProc(ClientData clientData, int flags);
+static void		TimerCheckProc(void *clientData, int flags);
+static void		TimerSetupProc(void *clientData, int flags);
 
 /*
  *----------------------------------------------------------------------
@@ -251,7 +251,7 @@ Tcl_CreateTimerHandler(
     int milliseconds,		/* How many milliseconds to wait before
 				 * invoking proc. */
     Tcl_TimerProc *proc,	/* Function to invoke. */
-    ClientData clientData)	/* Arbitrary data to pass to proc. */
+    void *clientData)	/* Arbitrary data to pass to proc. */
 {
     Tcl_Time time;
 
@@ -292,7 +292,7 @@ Tcl_TimerToken
 TclCreateAbsoluteTimerHandler(
     Tcl_Time *timePtr,
     Tcl_TimerProc *proc,
-    ClientData clientData)
+    void *clientData)
 {
     TimerHandler *timerHandlerPtr, *tPtr2, *prevPtr;
     ThreadSpecificData *tsdPtr = InitTimer();
@@ -619,7 +619,7 @@ TimerHandlerEventProc(
 void
 Tcl_DoWhenIdle(
     Tcl_IdleProc *proc,		/* Function to invoke. */
-    ClientData clientData)	/* Arbitrary value to pass to proc. */
+    void *clientData)	/* Arbitrary value to pass to proc. */
 {
     IdleHandler *idlePtr;
     Tcl_Time blockTime;
@@ -663,7 +663,7 @@ Tcl_DoWhenIdle(
 void
 Tcl_CancelIdleCall(
     Tcl_IdleProc *proc,		/* Function that was previously registered. */
-    ClientData clientData)	/* Arbitrary value to pass to proc. */
+    void *clientData)	/* Arbitrary value to pass to proc. */
 {
     IdleHandler *idlePtr, *prevPtr;
     IdleHandler *nextPtr;
@@ -974,7 +974,7 @@ Tcl_AfterObjCmd(
 	    Tcl_ListObjAppendElement(interp, resultListPtr,
 		    afterPtr->commandPtr);
 	    Tcl_ListObjAppendElement(interp, resultListPtr, Tcl_NewStringObj(
-		    (afterPtr->token == NULL) ? "idle" : "timer", -1));
+		    (afterPtr->token == NULL) ? "idle" : "timer", TCL_INDEX_NONE));
             Tcl_SetObjResult(interp, resultListPtr);
 	}
 	break;
@@ -1149,7 +1149,7 @@ GetAfterEvent(
 
 static void
 AfterProc(
-    ClientData clientData)	/* Describes command to execute. */
+    void *clientData)	/* Describes command to execute. */
 {
     AfterInfo *afterPtr = (AfterInfo *)clientData;
     AfterAssocData *assocPtr = afterPtr->assocPtr;
@@ -1251,7 +1251,7 @@ FreeAfterPtr(
 
 static void
 AfterCleanupProc(
-    ClientData clientData,	/* Points to AfterAssocData for the
+    void *clientData,	/* Points to AfterAssocData for the
 				 * interpreter. */
     TCL_UNUSED(Tcl_Interp *))
 {
diff --git a/generic/tclZipfs.c b/generic/tclZipfs.c
index f284704..1653dbe 100644
--- a/generic/tclZipfs.c
+++ b/generic/tclZipfs.c
@@ -42,14 +42,14 @@
 #define ZIPFS_ERROR(interp,errstr) \
     do {								\
 	if (interp) {							\
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(errstr, -1));	\
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(errstr, TCL_INDEX_NONE));	\
 	}								\
     } while (0)
 #define ZIPFS_MEM_ERROR(interp) \
     do {								\
 	if (interp) {							\
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(			\
-		    "out of memory", -1));				\
+		    "out of memory", TCL_INDEX_NONE));				\
 	    Tcl_SetErrorCode(interp, "TCL", "MALLOC", NULL);		\
 	}								\
     } while (0)
@@ -1708,8 +1708,8 @@ ZipFSCatalogFilesystem(
 	    Tcl_DString ds2;
 
 	    Tcl_DStringInit(&ds2);
-	    Tcl_DStringAppend(&ds2, "assets/.root/", -1);
-	    Tcl_DStringAppend(&ds2, path, -1);
+	    Tcl_DStringAppend(&ds2, "assets/.root/", TCL_INDEX_NONE);
+	    Tcl_DStringAppend(&ds2, path, TCL_INDEX_NONE);
 	    if (ZipFSLookup(Tcl_DStringValue(&ds2))) {
 		/* should not happen but skip it anyway */
 		Tcl_DStringFree(&ds2);
@@ -1785,7 +1785,7 @@ ZipFSCatalogFilesystem(
 
 	    Tcl_DStringSetLength(&ds, strlen(z->name) + 8);
 	    Tcl_DStringSetLength(&ds, 0);
-	    Tcl_DStringAppend(&ds, z->name, -1);
+	    Tcl_DStringAppend(&ds, z->name, TCL_INDEX_NONE);
 	    dir = Tcl_DStringValue(&ds);
 	    for (endPtr = strrchr(dir, '/'); endPtr && (endPtr != dir);
 		    endPtr = strrchr(dir, '/')) {
@@ -1907,9 +1907,9 @@ ListMountPoints(
 	    hPtr = Tcl_NextHashEntry(&search)) {
 	zf = (ZipFile *) Tcl_GetHashValue(hPtr);
 	Tcl_ListObjAppendElement(NULL, resultList, Tcl_NewStringObj(
-		zf->mountPoint, -1));
+		zf->mountPoint, TCL_INDEX_NONE));
 	Tcl_ListObjAppendElement(NULL, resultList, Tcl_NewStringObj(
-		zf->name, -1));
+		zf->name, TCL_INDEX_NONE));
     }
     Tcl_SetObjResult(interp, resultList);
     return TCL_OK;
@@ -1943,7 +1943,7 @@ DescribeMounted(
 	ZipFile *zf = ZipFSLookupZip(mountPoint);
 
 	if (zf) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(zf->name, -1));
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(zf->name, TCL_INDEX_NONE));
 	    return TCL_OK;
 	}
     }
@@ -2237,7 +2237,7 @@ ZipFSMountObjCmd(
 	zipFileObj = Tcl_FSGetNormalizedPath(interp, objv[2]);
 	if (!zipFileObj) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "could not normalize zip filename", -1));
+		    "could not normalize zip filename", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "NORMALIZE", NULL);
 	    return TCL_ERROR;
 	}
@@ -2333,7 +2333,7 @@ ZipFSRootObjCmd(
     TCL_UNUSED(int) /*objc*/,
     TCL_UNUSED(Tcl_Obj *const *)) /*objv*/
 {
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(ZIPFS_VOLUME, -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(ZIPFS_VOLUME, TCL_INDEX_NONE));
     return TCL_OK;
 }
 
@@ -2451,7 +2451,7 @@ RandomChar(
     double r;
     Tcl_Obj *ret;
 
-    if (Tcl_EvalEx(interp, "::tcl::mathfunc::rand", -1, 0) != TCL_OK) {
+    if (Tcl_EvalEx(interp, "::tcl::mathfunc::rand", TCL_INDEX_NONE, 0) != TCL_OK) {
 	goto failed;
     }
     ret = Tcl_GetObjResult(interp);
@@ -2540,7 +2540,7 @@ ZipAddFile(
      * crazy enough to embed NULs in filenames, they deserve what they get!
      */
 
-    zpathExt = Tcl_UtfToExternalDString(ZipFS.utf8, zpathTcl, -1, &zpathDs);
+    zpathExt = Tcl_UtfToExternalDString(ZipFS.utf8, zpathTcl, TCL_INDEX_NONE, &zpathDs);
     zpathlen = strlen(zpathExt);
     if (zpathlen + ZIP_CENTRAL_HEADER_LEN > bufsize) {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
@@ -2880,7 +2880,7 @@ ZipFSFind(
     Tcl_Obj *cmd[2];
     int result;
 
-    cmd[0] = Tcl_NewStringObj("::tcl::zipfs::find", -1);
+    cmd[0] = Tcl_NewStringObj("::tcl::zipfs::find", TCL_INDEX_NONE);
     cmd[1] = dirRoot;
     Tcl_IncrRefCount(cmd[0]);
     result = Tcl_EvalObjv(interp, 2, cmd, 0);
@@ -3208,7 +3208,7 @@ ZipFSMkZipOrImg(
 	}
 	z = (ZipEntry *) Tcl_GetHashValue(hPtr);
 
-	name = Tcl_UtfToExternalDString(ZipFS.utf8, z->name, -1, &ds);
+	name = Tcl_UtfToExternalDString(ZipFS.utf8, z->name, TCL_INDEX_NONE, &ds);
 	len = Tcl_DStringLength(&ds);
 	SerializeCentralDirectoryEntry(start, end, (unsigned char *) buf,
 		z, len);
@@ -3628,7 +3628,7 @@ ZipFSCanonicalObjCmd(
 	filename = TclGetString(objv[2]);
 	result = CanonicalPath(mntpoint, filename, &dPath, zipfs);
     }
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(result, -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(result, TCL_INDEX_NONE));
     return TCL_OK;
 }
 
@@ -3673,7 +3673,7 @@ ZipFSExistsObjCmd(
     filename = TclGetString(objv[1]);
     Tcl_DStringInit(&ds);
     Tcl_DStringAppend(&ds, ZIPFS_VOLUME, ZIPFS_VOLUME_LEN - 1);
-    Tcl_DStringAppend(&ds, filename, -1);
+    Tcl_DStringAppend(&ds, filename, TCL_INDEX_NONE);
     filename = Tcl_DStringValue(&ds);
 
     ReadLock();
@@ -3724,7 +3724,7 @@ ZipFSInfoObjCmd(
 	Tcl_Obj *result = Tcl_GetObjResult(interp);
 
 	Tcl_ListObjAppendElement(interp, result,
-		Tcl_NewStringObj(z->zipFilePtr->name, -1));
+		Tcl_NewStringObj(z->zipFilePtr->name, TCL_INDEX_NONE));
 	Tcl_ListObjAppendElement(interp, result,
 		Tcl_NewWideIntObj(z->numBytes));
 	Tcl_ListObjAppendElement(interp, result,
@@ -3810,7 +3810,7 @@ ZipFSListObjCmd(
 
 	    if (Tcl_StringMatch(z->name, pattern)) {
 		Tcl_ListObjAppendElement(interp, result,
-			Tcl_NewStringObj(z->name, -1));
+			Tcl_NewStringObj(z->name, TCL_INDEX_NONE));
 	    }
 	}
     } else if (regexp) {
@@ -3820,7 +3820,7 @@ ZipFSListObjCmd(
 
 	    if (Tcl_RegExpExec(interp, regexp, z->name, z->name)) {
 		Tcl_ListObjAppendElement(interp, result,
-			Tcl_NewStringObj(z->name, -1));
+			Tcl_NewStringObj(z->name, TCL_INDEX_NONE));
 	    }
 	}
     } else {
@@ -3829,7 +3829,7 @@ ZipFSListObjCmd(
 	    ZipEntry *z = (ZipEntry *) Tcl_GetHashValue(hPtr);
 
 	    Tcl_ListObjAppendElement(interp, result,
-		    Tcl_NewStringObj(z->name, -1));
+		    Tcl_NewStringObj(z->name, TCL_INDEX_NONE));
 	}
     }
     Unlock();
@@ -3873,7 +3873,7 @@ TclZipfs_TclLibrary(void)
      */
 
     if (zipfs_literal_tcl_library) {
-	return Tcl_NewStringObj(zipfs_literal_tcl_library, -1);
+	return Tcl_NewStringObj(zipfs_literal_tcl_library, TCL_INDEX_NONE);
     }
 
     /*
@@ -3887,7 +3887,7 @@ TclZipfs_TclLibrary(void)
     Tcl_DecrRefCount(vfsInitScript);
     if (found == TCL_OK) {
 	zipfs_literal_tcl_library = ZIPFS_APP_MOUNT "/tcl_library";
-	return Tcl_NewStringObj(zipfs_literal_tcl_library, -1);
+	return Tcl_NewStringObj(zipfs_literal_tcl_library, TCL_INDEX_NONE);
     }
 
     /*
@@ -3906,17 +3906,17 @@ TclZipfs_TclLibrary(void)
 #endif
 
     if (ZipfsAppHookFindTclInit(dllName) == TCL_OK) {
-	return Tcl_NewStringObj(zipfs_literal_tcl_library, -1);
+	return Tcl_NewStringObj(zipfs_literal_tcl_library, TCL_INDEX_NONE);
     }
 #elif !defined(NO_DLFCN_H)
     Dl_info dlinfo;
     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);
+	return Tcl_NewStringObj(zipfs_literal_tcl_library, TCL_INDEX_NONE);
     }
 #else
     if (ZipfsAppHookFindTclInit(CFG_RUNTIME_LIBDIR "/" CFG_RUNTIME_DLLFILE) == TCL_OK) {
-	return Tcl_NewStringObj(zipfs_literal_tcl_library, -1);
+	return Tcl_NewStringObj(zipfs_literal_tcl_library, TCL_INDEX_NONE);
     }
 #endif /* _WIN32 */
 #endif /* !defined(STATIC_BUILD) */
@@ -3927,7 +3927,7 @@ TclZipfs_TclLibrary(void)
      */
 
     if (zipfs_literal_tcl_library) {
-	return Tcl_NewStringObj(zipfs_literal_tcl_library, -1);
+	return Tcl_NewStringObj(zipfs_literal_tcl_library, TCL_INDEX_NONE);
     }
     return NULL;
 }
@@ -4936,7 +4936,7 @@ static Tcl_Obj *
 ZipFSFilesystemSeparatorProc(
     TCL_UNUSED(Tcl_Obj *) /*pathPtr*/)
 {
-    return Tcl_NewStringObj("/", -1);
+    return Tcl_NewStringObj("/", TCL_INDEX_NONE);
 }
 
 /*
@@ -4956,11 +4956,11 @@ AppendWithPrefix(
     Tcl_DString *prefix,	/* The prefix to add to the element, or NULL
 				 * for don't do that. */
     const char *name,		/* The name to append. */
-    int nameLen)		/* The length of the name. May be -1 for
+    size_t nameLen)		/* The length of the name. May be TCL_INDEX_NONE for
 				 * append-up-to-NUL-byte. */
 {
     if (prefix) {
-	int prefixLength = Tcl_DStringLength(prefix);
+	size_t prefixLength = Tcl_DStringLength(prefix);
 
 	Tcl_DStringAppend(prefix, name, nameLen);
 	Tcl_ListObjAppendElement(NULL, result, Tcl_NewStringObj(
@@ -5063,7 +5063,7 @@ ZipFSMatchInDirectoryProc(
 
 	if (z && ((dirOnly < 0) || (!dirOnly && !z->isDirectory)
 		|| (dirOnly && z->isDirectory))) {
-	    AppendWithPrefix(result, prefixBuf, z->name, -1);
+	    AppendWithPrefix(result, prefixBuf, z->name, TCL_INDEX_NONE);
 	}
 	goto end;
     }
@@ -5096,7 +5096,7 @@ ZipFSMatchInDirectoryProc(
 	    continue;
 	}
 	if ((z->depth == scnt) && Tcl_StringCaseMatch(z->name, pat, 0)) {
-	    AppendWithPrefix(result, prefixBuf, z->name + strip, -1);
+	    AppendWithPrefix(result, prefixBuf, z->name + strip, TCL_INDEX_NONE);
 	}
     }
     Tcl_Free(pat);
@@ -5286,7 +5286,7 @@ ZipFSPathInFilesystemProc(
 static Tcl_Obj *
 ZipFSListVolumesProc(void)
 {
-    return Tcl_NewStringObj(ZIPFS_VOLUME, -1);
+    return Tcl_NewStringObj(ZIPFS_VOLUME, TCL_INDEX_NONE);
 }
 
 /*
@@ -5400,10 +5400,10 @@ ZipFSFileAttrsGetProc(
 		z->zipFilePtr->mountPointLen);
 	break;
     case ZIP_ATTR_ARCHIVE:
-	*objPtrRef = Tcl_NewStringObj(z->zipFilePtr->name, -1);
+	*objPtrRef = Tcl_NewStringObj(z->zipFilePtr->name, TCL_INDEX_NONE);
 	break;
     case ZIP_ATTR_PERMISSIONS:
-	*objPtrRef = Tcl_NewStringObj("0o555", -1);
+	*objPtrRef = Tcl_NewStringObj("0o555", TCL_INDEX_NONE);
 	break;
     case ZIP_ATTR_CRC:
 	TclNewIntObj(*objPtrRef, z->crc32);
@@ -5464,7 +5464,7 @@ static Tcl_Obj *
 ZipFSFilesystemPathTypeProc(
     TCL_UNUSED(Tcl_Obj *) /*pathPtr*/)
 {
-    return Tcl_NewStringObj("zip", -1);
+    return Tcl_NewStringObj("zip", TCL_INDEX_NONE);
 }
 
 /*
@@ -5661,7 +5661,7 @@ TclZipfs_Init(
 	Tcl_Command ensemble;
 	Tcl_Obj *mapObj;
 
-	Tcl_EvalEx(interp, findproc, -1, TCL_EVAL_GLOBAL);
+	Tcl_EvalEx(interp, findproc, TCL_INDEX_NONE, TCL_EVAL_GLOBAL);
 	if (!Tcl_IsSafe(interp)) {
 	    Tcl_LinkVar(interp, "::tcl::zipfs::wrmax", (char *) &ZipFS.wrmax,
 		    TCL_LINK_INT);
@@ -5676,8 +5676,8 @@ TclZipfs_Init(
 	 */
 
 	Tcl_GetEnsembleMappingDict(NULL, ensemble, &mapObj);
-	Tcl_DictObjPut(NULL, mapObj, Tcl_NewStringObj("find", -1),
-		Tcl_NewStringObj("::tcl::zipfs::find", -1));
+	Tcl_DictObjPut(NULL, mapObj, Tcl_NewStringObj("find", TCL_INDEX_NONE),
+		Tcl_NewStringObj("::tcl::zipfs::find", TCL_INDEX_NONE));
 	Tcl_CreateObjCommand(interp, "::tcl::zipfs::tcl_library_init",
 		ZipFSTclLibraryObjCmd, NULL, NULL);
 	Tcl_PkgProvide(interp, "tcl::zipfs", "2.0");
@@ -5859,7 +5859,7 @@ TclZipfs_AppHook(
 	Tcl_DString ds;
 
 	Tcl_DStringInit(&ds);
-	archive = Tcl_WCharToUtfDString((*argvPtr)[1], -1, &ds);
+	archive = Tcl_WCharToUtfDString((*argvPtr)[1], TCL_INDEX_NONE, &ds);
 #else /* !_WIN32 */
 	archive = (*argvPtr)[1];
 #endif /* _WIN32 */
diff --git a/generic/tclZlib.c b/generic/tclZlib.c
index 718feb7..79aa9cb 100644
--- a/generic/tclZlib.c
+++ b/generic/tclZlib.c
@@ -313,7 +313,7 @@ ConvertError(
 	sprintf(codeStrBuf, "%d", code);
 	break;
     }
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(zError(code), -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(zError(code), TCL_INDEX_NONE));
 
     /*
      * Tricky point! We might pass NULL twice here (and will when the error
@@ -350,7 +350,7 @@ ConvertErrorToList(
 	return Tcl_NewListObj(3, objv);
     case Z_ERRNO:
 	TclNewLiteralStringObj(objv[2], "POSIX");
-	objv[3] = Tcl_NewStringObj(Tcl_ErrnoId(), -1);
+	objv[3] = Tcl_NewStringObj(Tcl_ErrnoId(), TCL_INDEX_NONE);
 	return Tcl_NewListObj(4, objv);
     case Z_NEED_DICT:
 	TclNewLiteralStringObj(objv[2], "NEED_DICT");
@@ -405,7 +405,7 @@ GetValue(
     const char *nameStr,
     Tcl_Obj **valuePtrPtr)
 {
-    Tcl_Obj *name = Tcl_NewStringObj(nameStr, -1);
+    Tcl_Obj *name = Tcl_NewStringObj(nameStr, TCL_INDEX_NONE);
     int result = Tcl_DictObjGet(interp, dictObj, name, valuePtrPtr);
 
     TclDecrRefCount(name);
@@ -557,7 +557,7 @@ GenerateHeader(
  */
 
 #define SetValue(dictObj, key, value) \
-	Tcl_DictObjPut(NULL, (dictObj), Tcl_NewStringObj((key), -1), (value))
+	Tcl_DictObjPut(NULL, (dictObj), Tcl_NewStringObj((key), TCL_INDEX_NONE), (value))
 
 static void
 ExtractHeader(
@@ -579,7 +579,7 @@ ExtractHeader(
 	    }
 	}
 
-	(void)Tcl_ExternalToUtfDString(latin1enc, (char *) headerPtr->comment, -1,
+	(void)Tcl_ExternalToUtfDString(latin1enc, (char *) headerPtr->comment, TCL_INDEX_NONE,
 		&tmp);
 	SetValue(dictObj, "comment", Tcl_DStringToObj(&tmp));
     }
@@ -596,7 +596,7 @@ ExtractHeader(
 	    }
 	}
 
-	(void)Tcl_ExternalToUtfDString(latin1enc, (char *) headerPtr->name, -1,
+	(void)Tcl_ExternalToUtfDString(latin1enc, (char *) headerPtr->name, TCL_INDEX_NONE,
 		&tmp);
 	SetValue(dictObj, "filename", Tcl_DStringToObj(&tmp));
     }
@@ -608,7 +608,7 @@ ExtractHeader(
     }
     if (headerPtr->text != Z_UNKNOWN) {
 	SetValue(dictObj, "type",
-		Tcl_NewStringObj(headerPtr->text ? "text" : "binary", -1));
+		Tcl_NewStringObj(headerPtr->text ? "text" : "binary", TCL_INDEX_NONE));
     }
 
     if (latin1enc != NULL) {
@@ -842,7 +842,7 @@ Tcl_ZlibStreamInit(
      */
 
     if (interp != NULL) {
-	if (Tcl_EvalEx(interp, "::incr ::tcl::zlib::cmdcounter", -1, 0) != TCL_OK) {
+	if (Tcl_EvalEx(interp, "::incr ::tcl::zlib::cmdcounter", TCL_INDEX_NONE, 0) != TCL_OK) {
 	    goto error;
 	}
 	Tcl_DStringInit(&cmdname);
@@ -851,7 +851,7 @@ Tcl_ZlibStreamInit(
 	if (Tcl_FindCommand(interp, Tcl_DStringValue(&cmdname),
 		NULL, 0) != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "BUG: Stream command name already exists", -1));
+		    "BUG: Stream command name already exists", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "BUG", "EXISTING_CMD", NULL);
 	    Tcl_DStringFree(&cmdname);
 	    goto error;
@@ -1242,7 +1242,7 @@ Tcl_ZlibStreamPut(
     if (zshPtr->streamEnd) {
 	if (zshPtr->interp) {
 	    Tcl_SetObjResult(zshPtr->interp, Tcl_NewStringObj(
-		    "already past compressed stream end", -1));
+		    "already past compressed stream end", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(zshPtr->interp, "TCL", "ZIP", "CLOSED", NULL);
 	}
 	return TCL_ERROR;
@@ -1473,7 +1473,7 @@ Tcl_ZlibStreamGet(
 		if (zshPtr->interp) {
 		    Tcl_SetObjResult(zshPtr->interp, Tcl_NewStringObj(
 			    "unexpected zlib internal state during"
-			    " decompression", -1));
+			    " decompression", TCL_INDEX_NONE));
 		    Tcl_SetErrorCode(zshPtr->interp, "TCL", "ZIP", "STATE",
 			    NULL);
 		}
@@ -2238,7 +2238,7 @@ ZlibCmd(
     return TCL_ERROR;
 
   badLevel:
-    Tcl_SetObjResult(interp, Tcl_NewStringObj("level must be 0 to 9", -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj("level must be 0 to 9", TCL_INDEX_NONE));
     Tcl_SetErrorCode(interp, "TCL", "VALUE", "COMPRESSIONLEVEL", NULL);
     if (extraInfoStr) {
 	Tcl_AddErrorInfo(interp, extraInfoStr);
@@ -2501,13 +2501,13 @@ ZlibPushSubcmd(
 
     if (mode == TCL_ZLIB_STREAM_DEFLATE && !(chanMode & TCL_WRITABLE)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"compression may only be applied to writable channels", -1));
+		"compression may only be applied to writable channels", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "ZIP", "UNWRITABLE", NULL);
 	return TCL_ERROR;
     }
     if (mode == TCL_ZLIB_STREAM_INFLATE && !(chanMode & TCL_READABLE)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"decompression may only be applied to readable channels",-1));
+		"decompression may only be applied to readable channels",TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "ZIP", "UNREADABLE", NULL);
 	return TCL_ERROR;
     }
@@ -2541,7 +2541,7 @@ ZlibPushSubcmd(
 	    }
 	    if (level < 0 || level > 9) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"level must be 0 to 9", -1));
+			"level must be 0 to 9", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "VALUE", "COMPRESSIONLEVEL",
 			NULL);
 		goto genericOptionError;
@@ -2563,7 +2563,7 @@ ZlibPushSubcmd(
 	    if (format == TCL_ZLIB_FORMAT_GZIP) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"a compression dictionary may not be set in the "
-			"gzip format", -1));
+			"gzip format", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "ZIP", "BADOPT", NULL);
 		goto genericOptionError;
 	    }
@@ -2775,7 +2775,7 @@ ZlibStreamAddCmd(
 	    if (i == objc-2) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"\"-buffer\" option must be followed by integer "
-			"decompression buffersize", -1));
+			"decompression buffersize", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "ZIP", "NOVAL", NULL);
 		return TCL_ERROR;
 	    }
@@ -2794,7 +2794,7 @@ ZlibStreamAddCmd(
 	    if (i == objc-2) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"\"-dictionary\" option must be followed by"
-			" compression dictionary bytes", -1));
+			" compression dictionary bytes", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "ZIP", "NOVAL", NULL);
 		return TCL_ERROR;
 	    }
@@ -2805,7 +2805,7 @@ ZlibStreamAddCmd(
 	if (flush == -2) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "\"-flush\", \"-fullflush\" and \"-finalize\" options"
-		    " are mutually exclusive", -1));
+		    " are mutually exclusive", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ZIP", "EXCLUSIVE", NULL);
 	    return TCL_ERROR;
 	}
@@ -2902,7 +2902,7 @@ ZlibStreamPutCmd(
 	    if (i == objc-2) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"\"-dictionary\" option must be followed by"
-			" compression dictionary bytes", -1));
+			" compression dictionary bytes", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "ZIP", "NOVAL", NULL);
 		return TCL_ERROR;
 	    }
@@ -2912,7 +2912,7 @@ ZlibStreamPutCmd(
 	if (flush == -2) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "\"-flush\", \"-fullflush\" and \"-finalize\" options"
-		    " are mutually exclusive", -1));
+		    " are mutually exclusive", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ZIP", "EXCLUSIVE", NULL);
 	    return TCL_ERROR;
 	}
@@ -2960,7 +2960,7 @@ ZlibStreamHeaderCmd(
     } else if (zshPtr->mode != TCL_ZLIB_STREAM_INFLATE
 	    || zshPtr->format != TCL_ZLIB_FORMAT_GZIP) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"only gunzip streams can produce header information", -1));
+		"only gunzip streams can produce header information", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "ZIP", "BADOP", NULL);
 	return TCL_ERROR;
     }
@@ -3274,7 +3274,7 @@ ZlibTransformOutput(
     Tcl_ListObjAppendElement(NULL, errObj,
 	    ConvertErrorToList(e, cd->outStream.adler));
     Tcl_ListObjAppendElement(NULL, errObj,
-	    Tcl_NewStringObj(cd->outStream.msg, -1));
+	    Tcl_NewStringObj(cd->outStream.msg, TCL_INDEX_NONE));
     Tcl_SetChannelError(cd->parent, errObj);
     *errorCodePtr = EINVAL;
     return -1;
@@ -3424,7 +3424,7 @@ ZlibTransformSetOption(			/* not used */
 		return TCL_ERROR;
 	    } else if (newLimit < 1 || newLimit > MAX_BUFFER_SIZE) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"-limit must be between 1 and 65536", -1));
+			"-limit must be between 1 and 65536", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "VALUE", "READLIMIT", NULL);
 		return TCL_ERROR;
 	    }
@@ -3498,7 +3498,7 @@ ZlibTransformGetOption(
 	    Tcl_DStringAppendElement(dsPtr, "-checksum");
 	    Tcl_DStringAppendElement(dsPtr, buf);
 	} else {
-	    Tcl_DStringAppend(dsPtr, buf, -1);
+	    Tcl_DStringAppend(dsPtr, buf, TCL_INDEX_NONE);
 	    return TCL_OK;
 	}
     }
@@ -3824,7 +3824,7 @@ ZlibStackChannelTransform(
     }
     cd->chan = chan;
     cd->parent = Tcl_GetStackedChannel(chan);
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(Tcl_GetChannelName(chan), -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(Tcl_GetChannelName(chan), TCL_INDEX_NONE));
     return chan;
 
   error:
@@ -3954,7 +3954,7 @@ ResultDecompress(
     Tcl_ListObjAppendElement(NULL, errObj,
 	    ConvertErrorToList(e, cd->inStream.adler));
     Tcl_ListObjAppendElement(NULL, errObj,
-	    Tcl_NewStringObj(cd->inStream.msg, -1));
+	    Tcl_NewStringObj(cd->inStream.msg, TCL_INDEX_NONE));
     Tcl_SetChannelError(cd->parent, errObj);
     *errorCodePtr = EINVAL;
     return -1;
@@ -3978,7 +3978,7 @@ TclZlibInit(
      * commands.
      */
 
-    Tcl_EvalEx(interp, "namespace eval ::tcl::zlib {variable cmdcounter 0}", -1, 0);
+    Tcl_EvalEx(interp, "namespace eval ::tcl::zlib {variable cmdcounter 0}", TCL_INDEX_NONE, 0);
 
     /*
      * Create the public scripted interface to this file's functionality.
@@ -4029,7 +4029,7 @@ Tcl_ZlibStreamInit(
     Tcl_ZlibStream *zshandle)
 {
     if (interp) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj("unimplemented", -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj("unimplemented", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "UNIMPLEMENTED", NULL);
     }
     return TCL_ERROR;
@@ -4097,7 +4097,7 @@ Tcl_ZlibDeflate(
     Tcl_Obj *gzipHeaderDictObj)
 {
     if (interp) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj("unimplemented", -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj("unimplemented", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "UNIMPLEMENTED", NULL);
     }
     return TCL_ERROR;
@@ -4112,7 +4112,7 @@ Tcl_ZlibInflate(
     Tcl_Obj *gzipHeaderDictObj)
 {
     if (interp) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj("unimplemented", -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj("unimplemented", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "UNIMPLEMENTED", NULL);
     }
     return TCL_ERROR;
diff --git a/macosx/tclMacOSXFCmd.c b/macosx/tclMacOSXFCmd.c
index 7bdc72a..7fc085c 100644
--- a/macosx/tclMacOSXFCmd.c
+++ b/macosx/tclMacOSXFCmd.c
@@ -203,7 +203,7 @@ TclMacOSXGetFileAttribute(
     return TCL_OK;
 #else
     Tcl_SetObjResult(interp, Tcl_NewStringObj(
-	    "Mac OS X file attributes not supported", -1));
+	    "Mac OS X file attributes not supported", TCL_INDEX_NONE));
     Tcl_SetErrorCode(interp, "TCL", "UNSUPPORTED", NULL);
     return TCL_ERROR;
 #endif /* HAVE_GETATTRLIST */
@@ -335,7 +335,7 @@ TclMacOSXSetFileAttribute(
 
 	    if (newRsrcForkSize != 0) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"setting nonzero rsrclength not supported", -1));
+			"setting nonzero rsrclength not supported", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "UNSUPPORTED", NULL);
 		return TCL_ERROR;
 	    }
@@ -376,7 +376,7 @@ TclMacOSXSetFileAttribute(
     return TCL_OK;
 #else
     Tcl_SetObjResult(interp, Tcl_NewStringObj(
-	    "Mac OS X file attributes not supported", -1));
+	    "Mac OS X file attributes not supported", TCL_INDEX_NONE));
     Tcl_SetErrorCode(interp, "TCL", "UNSUPPORTED", NULL);
     return TCL_ERROR;
 #endif
-- 
cgit v0.12


From e4e106233842d77095bf459f14bb82e953bc8c6f Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 5 Mar 2023 19:57:48 +0000
Subject: Another round of -1 -> TCL_INDEX_NONE

---
 generic/tclAssembly.c     |  30 ++++++------
 generic/tclBasic.c        |  72 ++++++++++++++--------------
 generic/tclBinary.c       |  12 ++---
 generic/tclCmdIL.c        |  72 ++++++++++++++--------------
 generic/tclCmdMZ.c        |  30 ++++++------
 generic/tclCompExpr.c     |   8 ++--
 generic/tclDisassemble.c  | 108 +++++++++++++++++++++---------------------
 generic/tclEnsemble.c     |  72 ++++++++++++++--------------
 generic/tclEvent.c        |  30 ++++++------
 generic/tclExecute.c      |  38 +++++++--------
 generic/tclFileName.c     |  28 +++++------
 generic/tclIOGT.c         |  52 ++++++++++-----------
 generic/tclIOSock.c       |   2 +-
 generic/tclIOUtil.c       |  10 ++--
 generic/tclIndexObj.c     |  12 ++---
 generic/tclInterp.c       | 116 +++++++++++++++++++++++-----------------------
 generic/tclNamesp.c       |  58 +++++++++++------------
 generic/tclOO.c           | 106 +++++++++++++++++++++---------------------
 generic/tclOOBasic.c      |  44 +++++++++---------
 generic/tclOODefineCmds.c | 112 ++++++++++++++++++++++----------------------
 generic/tclOOInfo.c       |  36 +++++++-------
 generic/tclObj.c          |  22 ++++-----
 generic/tclParse.c        |  22 ++++-----
 generic/tclPipe.c         |  14 +++---
 generic/tclProcess.c      |  32 ++++++-------
 generic/tclScan.c         |  22 ++++-----
 generic/tclVar.c          |  36 +++++++-------
 unix/dltest/pkgb.c        |   2 +-
 unix/dltest/pkgc.c        |   2 +-
 unix/dltest/pkgd.c        |   2 +-
 unix/dltest/pkge.c        |   2 +-
 unix/tclUnixFCmd.c        |   2 +-
 32 files changed, 603 insertions(+), 603 deletions(-)

diff --git a/generic/tclAssembly.c b/generic/tclAssembly.c
index a05a4d4..af95312 100644
--- a/generic/tclAssembly.c
+++ b/generic/tclAssembly.c
@@ -1384,7 +1384,7 @@ AssembleOneLine(
 	}
 	if (opnd < 0 || opnd > 3) {
 	    Tcl_SetObjResult(interp,
-			     Tcl_NewStringObj("operand must be [0..3]", -1));
+			     Tcl_NewStringObj("operand must be [0..3]", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ASSEM", "OPERAND<0,>3", NULL);
 	    goto cleanup;
 	}
@@ -1625,7 +1625,7 @@ AssembleOneLine(
 	if (opnd < 2) {
 	    if (assemEnvPtr->flags & TCL_EVAL_DIRECT) {
 		Tcl_SetObjResult(interp,
-			Tcl_NewStringObj("operand must be >=2", -1));
+			Tcl_NewStringObj("operand must be >=2", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "ASSEM", "OPERAND>=2", NULL);
 	    }
 	    goto cleanup;
@@ -2107,7 +2107,7 @@ GetNextOperand(
 	Tcl_DecrRefCount(operandObj);
 	if (assemEnvPtr->flags & TCL_EVAL_DIRECT) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "assembly code may not contain substitutions", -1));
+		    "assembly code may not contain substitutions", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ASSEM", "NOSUBST", NULL);
 	}
 	return TCL_ERROR;
@@ -2330,7 +2330,7 @@ FindLocalVar(
 	if (assemEnvPtr->flags & TCL_EVAL_DIRECT) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "cannot use this instruction to create a variable"
-		    " in a non-proc context", -1));
+		    " in a non-proc context", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ASSEM", "LVT", NULL);
 	}
 	return TCL_INDEX_NONE;
@@ -2400,7 +2400,7 @@ CheckOneByte(
     Tcl_Obj* result;		/* Error message */
 
     if (value < 0 || value > 0xFF) {
-	result = Tcl_NewStringObj("operand does not fit in one byte", -1);
+	result = Tcl_NewStringObj("operand does not fit in one byte", TCL_INDEX_NONE);
 	Tcl_SetObjResult(interp, result);
 	Tcl_SetErrorCode(interp, "TCL", "ASSEM", "1BYTE", NULL);
 	return TCL_ERROR;
@@ -2435,7 +2435,7 @@ CheckSignedOneByte(
     Tcl_Obj* result;		/* Error message */
 
     if (value > 0x7F || value < -0x80) {
-	result = Tcl_NewStringObj("operand does not fit in one byte", -1);
+	result = Tcl_NewStringObj("operand does not fit in one byte", TCL_INDEX_NONE);
 	Tcl_SetObjResult(interp, result);
 	Tcl_SetErrorCode(interp, "TCL", "ASSEM", "1BYTE", NULL);
 	return TCL_ERROR;
@@ -2468,7 +2468,7 @@ CheckNonNegative(
     Tcl_Obj* result;		/* Error message */
 
     if (value < 0) {
-	result = Tcl_NewStringObj("operand must be nonnegative", -1);
+	result = Tcl_NewStringObj("operand must be nonnegative", TCL_INDEX_NONE);
 	Tcl_SetObjResult(interp, result);
 	Tcl_SetErrorCode(interp, "TCL", "ASSEM", "NONNEGATIVE", NULL);
 	return TCL_ERROR;
@@ -2501,7 +2501,7 @@ CheckStrictlyPositive(
     Tcl_Obj* result;		/* Error message */
 
     if (value <= 0) {
-	result = Tcl_NewStringObj("operand must be positive", -1);
+	result = Tcl_NewStringObj("operand must be positive", TCL_INDEX_NONE);
 	Tcl_SetObjResult(interp, result);
 	Tcl_SetErrorCode(interp, "TCL", "ASSEM", "POSITIVE", NULL);
 	return TCL_ERROR;
@@ -3414,7 +3414,7 @@ StackCheckBasicBlock(
 	}
 	if (assemEnvPtr->flags & TCL_EVAL_DIRECT) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "inconsistent stack depths on two execution paths", -1));
+		    "inconsistent stack depths on two execution paths", TCL_INDEX_NONE));
 
 	    /*
 	     * TODO - add execution trace of both paths
@@ -3443,7 +3443,7 @@ StackCheckBasicBlock(
 
     if (initialStackDepth + blockPtr->minStackDepth < 0) {
 	if (assemEnvPtr->flags & TCL_EVAL_DIRECT) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj("stack underflow", -1));
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj("stack underflow", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ASSEM", "BADSTACK", NULL);
 	    AddBasicBlockRangeToErrorInfo(assemEnvPtr, blockPtr);
 	    Tcl_SetErrorLine(interp, blockPtr->startLine);
@@ -3462,8 +3462,8 @@ StackCheckBasicBlock(
 		+ blockPtr->enclosingCatch->finalStackDepth)) {
 	if (assemEnvPtr->flags & TCL_EVAL_DIRECT) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "code pops stack below level of enclosing catch", -1));
-	    Tcl_SetErrorCode(interp, "TCL", "ASSEM", "BADSTACKINCATCH", -1);
+		    "code pops stack below level of enclosing catch", TCL_INDEX_NONE));
+	    Tcl_SetErrorCode(interp, "TCL", "ASSEM", "BADSTACKINCATCH", TCL_INDEX_NONE);
 	    AddBasicBlockRangeToErrorInfo(assemEnvPtr, blockPtr);
 	    Tcl_SetErrorLine(interp, blockPtr->startLine);
 	}
@@ -3734,7 +3734,7 @@ ProcessCatchesInBasicBlock(
 	if (assemEnvPtr->flags & TCL_EVAL_DIRECT) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "execution reaches an instruction in inconsistent "
-		    "exception contexts", -1));
+		    "exception contexts", TCL_INDEX_NONE));
 	    Tcl_SetErrorLine(interp, bbPtr->startLine);
 	    Tcl_SetErrorCode(interp, "TCL", "ASSEM", "BADCATCH", NULL);
 	}
@@ -3793,7 +3793,7 @@ ProcessCatchesInBasicBlock(
 	if (enclosing == NULL) {
 	    if (assemEnvPtr->flags & TCL_EVAL_DIRECT) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"endCatch without a corresponding beginCatch", -1));
+			"endCatch without a corresponding beginCatch", TCL_INDEX_NONE));
 		Tcl_SetErrorLine(interp, bbPtr->startLine);
 		Tcl_SetErrorCode(interp, "TCL", "ASSEM", "BADENDCATCH", NULL);
 	    }
@@ -3868,7 +3868,7 @@ CheckForUnclosedCatches(
     if (assemEnvPtr->curr_bb->catchState >= BBCS_INCATCH) {
 	if (assemEnvPtr->flags & TCL_EVAL_DIRECT) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "catch still active on exit from assembly code", -1));
+		    "catch still active on exit from assembly code", TCL_INDEX_NONE));
 	    Tcl_SetErrorLine(interp,
 		    assemEnvPtr->curr_bb->enclosingCatch->startLine);
 	    Tcl_SetErrorCode(interp, "TCL", "ASSEM", "UNCLOSEDCATCH", NULL);
diff --git a/generic/tclBasic.c b/generic/tclBasic.c
index 1dbd90b..381d127 100644
--- a/generic/tclBasic.c
+++ b/generic/tclBasic.c
@@ -2152,7 +2152,7 @@ Tcl_HideCommand(
     if (strstr(hiddenCmdToken, "::") != NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"cannot use namespace qualifiers in hidden command"
-		" token (rename)", -1));
+		" token (rename)", TCL_INDEX_NONE));
         Tcl_SetErrorCode(interp, "TCL", "VALUE", "HIDDENTOKEN", NULL);
 	return TCL_ERROR;
     }
@@ -3188,11 +3188,11 @@ TclRenameCommand(
      */
 
     Tcl_DStringInit(&newFullName);
-    Tcl_DStringAppend(&newFullName, newNsPtr->fullName, -1);
+    Tcl_DStringAppend(&newFullName, newNsPtr->fullName, TCL_INDEX_NONE);
     if (newNsPtr != iPtr->globalNsPtr) {
 	TclDStringAppendLiteral(&newFullName, "::");
     }
-    Tcl_DStringAppend(&newFullName, newTail, -1);
+    Tcl_DStringAppend(&newFullName, newTail, TCL_INDEX_NONE);
     cmdPtr->refCount++;
     CallCommandTraces(iPtr, cmdPtr, TclGetString(oldFullName),
 	    Tcl_DStringValue(&newFullName), TCL_TRACE_RENAME);
@@ -3553,14 +3553,14 @@ Tcl_GetCommandFullName(
 
     if ((cmdPtr != NULL) && TclRoutineHasName(cmdPtr)) {
 	if (cmdPtr->nsPtr != NULL) {
-	    Tcl_AppendToObj(objPtr, cmdPtr->nsPtr->fullName, -1);
+	    Tcl_AppendToObj(objPtr, cmdPtr->nsPtr->fullName, TCL_INDEX_NONE);
 	    if (cmdPtr->nsPtr != iPtr->globalNsPtr) {
 		Tcl_AppendToObj(objPtr, "::", 2);
 	    }
 	}
 	if (cmdPtr->hPtr != NULL) {
 	    name = (char *)Tcl_GetHashKey(cmdPtr->hPtr->tablePtr, cmdPtr->hPtr);
-	    Tcl_AppendToObj(objPtr, name, -1);
+	    Tcl_AppendToObj(objPtr, name, TCL_INDEX_NONE);
 	}
     }
 }
@@ -4061,7 +4061,7 @@ TclInterpReady(
 
     if (iPtr->flags & DELETED) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to call eval in deleted interpreter", -1));
+		"attempt to call eval in deleted interpreter", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "IDELETE",
 		"attempt to call eval in deleted interpreter", NULL);
 	return TCL_ERROR;
@@ -4090,7 +4090,7 @@ TclInterpReady(
     }
 
     Tcl_SetObjResult(interp, Tcl_NewStringObj(
-	    "too many nested evaluations (infinite loop?)", -1));
+	    "too many nested evaluations (infinite loop?)", TCL_INDEX_NONE));
     Tcl_SetErrorCode(interp, "TCL", "LIMIT", "STACK", NULL);
     return TCL_ERROR;
 }
@@ -4224,7 +4224,7 @@ Tcl_Canceled(
             }
         }
 
-        Tcl_SetObjResult(interp, Tcl_NewStringObj(message, -1));
+        Tcl_SetObjResult(interp, Tcl_NewStringObj(message, TCL_INDEX_NONE));
         Tcl_SetErrorCode(interp, "TCL", "CANCEL", id, message, NULL);
     }
 
@@ -6361,10 +6361,10 @@ ProcessUnexpectedResult(
     Tcl_ResetResult(interp);
     if (returnCode == TCL_BREAK) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"invoked \"break\" outside of a loop", -1));
+		"invoked \"break\" outside of a loop", TCL_INDEX_NONE));
     } else if (returnCode == TCL_CONTINUE) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"invoked \"continue\" outside of a loop", -1));
+		"invoked \"continue\" outside of a loop", TCL_INDEX_NONE));
     } else {
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
 		"command returned bad code: %d", returnCode));
@@ -6410,7 +6410,7 @@ Tcl_ExprLong(
 
 	*ptr = 0;
     } else {
-	exprPtr = Tcl_NewStringObj(exprstring, -1);
+	exprPtr = Tcl_NewStringObj(exprstring, TCL_INDEX_NONE);
 	Tcl_IncrRefCount(exprPtr);
 	result = Tcl_ExprLongObj(interp, exprPtr, ptr);
 	Tcl_DecrRefCount(exprPtr);
@@ -6435,7 +6435,7 @@ Tcl_ExprDouble(
 
 	*ptr = 0.0;
     } else {
-	exprPtr = Tcl_NewStringObj(exprstring, -1);
+	exprPtr = Tcl_NewStringObj(exprstring, TCL_INDEX_NONE);
 	Tcl_IncrRefCount(exprPtr);
 	result = Tcl_ExprDoubleObj(interp, exprPtr, ptr);
 	Tcl_DecrRefCount(exprPtr);
@@ -6460,7 +6460,7 @@ Tcl_ExprBoolean(
 	return TCL_OK;
     } else {
 	int result;
-	Tcl_Obj *exprPtr = Tcl_NewStringObj(exprstring, -1);
+	Tcl_Obj *exprPtr = Tcl_NewStringObj(exprstring, TCL_INDEX_NONE);
 
 	Tcl_IncrRefCount(exprPtr);
 	result = Tcl_ExprBooleanObj(interp, exprPtr, ptr);
@@ -6673,7 +6673,7 @@ TclObjInvoke(
     }
     if ((objc < 1) || (objv == NULL)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "illegal argument vector", -1));
+                "illegal argument vector", TCL_INDEX_NONE));
 	return TCL_ERROR;
     }
     if ((flags & TCL_INVOKE_HIDDEN) == 0) {
@@ -6772,7 +6772,7 @@ Tcl_ExprString(
 
 	Tcl_SetObjResult(interp, Tcl_NewWideIntObj(0));
     } else {
-	Tcl_Obj *resultPtr, *exprObj = Tcl_NewStringObj(expr, -1);
+	Tcl_Obj *resultPtr, *exprObj = Tcl_NewStringObj(expr, TCL_INDEX_NONE);
 
 	Tcl_IncrRefCount(exprObj);
 	code = Tcl_ExprObj(interp, exprObj, &resultPtr);
@@ -6886,10 +6886,10 @@ Tcl_VarEval(
 	if (string == NULL) {
 	    break;
 	}
-	Tcl_DStringAppend(&buf, string, -1);
+	Tcl_DStringAppend(&buf, string, TCL_INDEX_NONE);
     }
 
-    result = Tcl_EvalEx(interp, Tcl_DStringValue(&buf), -1, 0);
+    result = Tcl_EvalEx(interp, Tcl_DStringValue(&buf), TCL_INDEX_NONE, 0);
     Tcl_DStringFree(&buf);
     return result;
 }
@@ -7192,7 +7192,7 @@ ExprIsqrtFunc(
 
   negarg:
     Tcl_SetObjResult(interp, Tcl_NewStringObj(
-            "square root of negative argument", -1));
+            "square root of negative argument", TCL_INDEX_NONE));
     Tcl_SetErrorCode(interp, "ARITH", "DOMAIN",
 	    "domain error: argument not in valid range", NULL);
     return TCL_ERROR;
@@ -8806,7 +8806,7 @@ TclNRTailcallObjCmd(
 
     if (!(iPtr->varFramePtr->isProcCallFrame & 1)) {
         Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "tailcall can only be called from a proc, lambda or method", -1));
+                "tailcall can only be called from a proc, lambda or method", TCL_INDEX_NONE));
         Tcl_SetErrorCode(interp, "TCL", "TAILCALL", "ILLEGAL", NULL);
 	return TCL_ERROR;
     }
@@ -8836,7 +8836,7 @@ TclNRTailcallObjCmd(
          * namespace, the rest the command to be tailcalled.
          */
 
-        nsObjPtr = Tcl_NewStringObj(nsPtr->fullName, -1);
+        nsObjPtr = Tcl_NewStringObj(nsPtr->fullName, TCL_INDEX_NONE);
         listPtr = Tcl_NewListObj(objc, objv);
  	TclListObjSetElement(interp, listPtr, 0, nsObjPtr);
 
@@ -8968,7 +8968,7 @@ TclNRYieldObjCmd(
 
     if (!corPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "yield can only be called in a coroutine", -1));
+                "yield can only be called in a coroutine", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ILLEGAL_YIELD", NULL);
 	return TCL_ERROR;
     }
@@ -9001,14 +9001,14 @@ TclNRYieldToObjCmd(
 
     if (!corPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "yieldto can only be called in a coroutine", -1));
+                "yieldto can only be called in a coroutine", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ILLEGAL_YIELD", NULL);
 	return TCL_ERROR;
     }
 
     if (((Namespace *) nsPtr)->flags & NS_DYING) {
         Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"yieldto called in deleted namespace", -1));
+		"yieldto called in deleted namespace", TCL_INDEX_NONE));
         Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "YIELDTO_IN_DELETED",
 		NULL);
         return TCL_ERROR;
@@ -9021,7 +9021,7 @@ TclNRYieldToObjCmd(
      */
 
     listPtr = Tcl_NewListObj(objc, objv);
-    nsObjPtr = Tcl_NewStringObj(nsPtr->fullName, -1);
+    nsObjPtr = Tcl_NewStringObj(nsPtr->fullName, TCL_INDEX_NONE);
     TclListObjSetElement(interp, listPtr, 0, nsObjPtr);
 
     /*
@@ -9243,7 +9243,7 @@ TclNRCoroutineActivateCallback(
 
 
             Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                    "cannot yield: C stack busy", -1));
+                    "cannot yield: C stack busy", TCL_INDEX_NONE));
             Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "CANT_YIELD",
                     NULL);
             return TCL_ERROR;
@@ -9332,7 +9332,7 @@ CoroTypeObjCmd(
     cmdPtr = (Command *) Tcl_GetCommandFromObj(interp, objv[1]);
     if ((!cmdPtr) || (cmdPtr->nreProc != TclNRInterpCoroutine)) {
         Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "can only get coroutine type of a coroutine", -1));
+                "can only get coroutine type of a coroutine", TCL_INDEX_NONE));
         Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "COROUTINE",
                 TclGetString(objv[1]), NULL);
         return TCL_ERROR;
@@ -9345,7 +9345,7 @@ CoroTypeObjCmd(
 
     corPtr = (CoroutineData *)cmdPtr->objClientData;
     if (!COR_IS_SUSPENDED(corPtr)) {
-        Tcl_SetObjResult(interp, Tcl_NewStringObj("active", -1));
+        Tcl_SetObjResult(interp, Tcl_NewStringObj("active", TCL_INDEX_NONE));
         return TCL_OK;
     }
 
@@ -9356,14 +9356,14 @@ CoroTypeObjCmd(
 
     switch (corPtr->nargs) {
     case COROUTINE_ARGUMENTS_SINGLE_OPTIONAL:
-        Tcl_SetObjResult(interp, Tcl_NewStringObj("yield", -1));
+        Tcl_SetObjResult(interp, Tcl_NewStringObj("yield", TCL_INDEX_NONE));
         return TCL_OK;
     case COROUTINE_ARGUMENTS_ARBITRARY:
-        Tcl_SetObjResult(interp, Tcl_NewStringObj("yieldto", -1));
+        Tcl_SetObjResult(interp, Tcl_NewStringObj("yieldto", TCL_INDEX_NONE));
         return TCL_OK;
     default:
         Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "unknown coroutine type", -1));
+                "unknown coroutine type", TCL_INDEX_NONE));
         Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "BAD_TYPE", NULL);
         return TCL_ERROR;
     }
@@ -9392,7 +9392,7 @@ GetCoroutineFromObj(
     Command *cmdPtr = (Command *) Tcl_GetCommandFromObj(interp, objPtr);
 
     if ((!cmdPtr) || (cmdPtr->nreProc != TclNRInterpCoroutine)) {
-        Tcl_SetObjResult(interp, Tcl_NewStringObj(errMsg, -1));
+        Tcl_SetObjResult(interp, Tcl_NewStringObj(errMsg, TCL_INDEX_NONE));
         Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "COROUTINE",
                 TclGetString(objPtr), NULL);
         return NULL;
@@ -9426,7 +9426,7 @@ TclNRCoroInjectObjCmd(
     }
     if (!COR_IS_SUSPENDED(corPtr)) {
         Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "can only inject a command into a suspended coroutine", -1));
+                "can only inject a command into a suspended coroutine", TCL_INDEX_NONE));
         Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ACTIVE", NULL);
         return TCL_ERROR;
     }
@@ -9560,10 +9560,10 @@ InjectHandler(
 
         if (nargs == COROUTINE_ARGUMENTS_SINGLE_OPTIONAL) {
             Tcl_ListObjAppendElement(NULL, listPtr,
-                    Tcl_NewStringObj("yield", -1));
+                    Tcl_NewStringObj("yield", TCL_INDEX_NONE));
         } else if (nargs == COROUTINE_ARGUMENTS_ARBITRARY) {
             Tcl_ListObjAppendElement(NULL, listPtr,
-                    Tcl_NewStringObj("yieldto", -1));
+                    Tcl_NewStringObj("yieldto", TCL_INDEX_NONE));
         } else {
             /*
              * I don't think this is reachable...
@@ -9662,7 +9662,7 @@ NRInjectObjCmd(
     }
     if (!COR_IS_SUSPENDED(corPtr)) {
         Tcl_SetObjResult(interp, Tcl_NewStringObj(
-                "can only inject a command into a suspended coroutine", -1));
+                "can only inject a command into a suspended coroutine", TCL_INDEX_NONE));
         Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ACTIVE", NULL);
         return TCL_ERROR;
     }
@@ -9716,7 +9716,7 @@ TclNRInterpCoroutine(
         if (corPtr->nargs + 1 != (size_t)objc) {
             Tcl_SetObjResult(interp,
                     Tcl_NewStringObj("wrong coro nargs; how did we get here? "
-                    "not implemented!", -1));
+                    "not implemented!", TCL_INDEX_NONE));
             Tcl_SetErrorCode(interp, "TCL", "WRONGARGS", NULL);
             return TCL_ERROR;
         }
diff --git a/generic/tclBinary.c b/generic/tclBinary.c
index e0d99c7..1083533 100644
--- a/generic/tclBinary.c
+++ b/generic/tclBinary.c
@@ -395,7 +395,7 @@ TclGetBytesFromObj(
 
 	    if (interp) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"byte sequence length exceeds INT_MAX", -1));
+			"byte sequence length exceeds INT_MAX", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "API", "OUTDATED", NULL);
 	    }
 	    return NULL;
@@ -1003,7 +1003,7 @@ BinaryFormatCmd(
 	case 'x':
 	    if (count == BINARY_ALL) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"cannot use \"*\" in format string with \"x\"", -1));
+			"cannot use \"*\" in format string with \"x\"", TCL_INDEX_NONE));
 		return TCL_ERROR;
 	    } else if (count == BINARY_NOCOUNT) {
 		count = 1;
@@ -1343,7 +1343,7 @@ BinaryFormatCmd(
     }
 
  error:
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(errorString, -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(errorString, TCL_INDEX_NONE));
     return TCL_ERROR;
 }
 
@@ -1724,7 +1724,7 @@ BinaryScanCmd(
     }
 
  error:
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(errorString, -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(errorString, TCL_INDEX_NONE));
     return TCL_ERROR;
 }
 
@@ -2654,7 +2654,7 @@ BinaryEncode64(
 	    }
 	    if (maxlen < 0) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"line length out of range", -1));
+			"line length out of range", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "BINARY", "ENCODE",
 			"LINE_LENGTH", NULL);
 		return TCL_ERROR;
@@ -2782,7 +2782,7 @@ BinaryEncodeUu(
 	    }
 	    if (lineLength < 5 || lineLength > 85) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"line length out of range", -1));
+			"line length out of range", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "BINARY", "ENCODE",
 			"LINE_LENGTH", NULL);
 		return TCL_ERROR;
diff --git a/generic/tclCmdIL.c b/generic/tclCmdIL.c
index 69d4484..e1949a5 100644
--- a/generic/tclCmdIL.c
+++ b/generic/tclCmdIL.c
@@ -504,7 +504,7 @@ InfoArgsCmd(
 	    localPtr = localPtr->nextPtr) {
 	if (TclIsVarArgument(localPtr)) {
 	    Tcl_ListObjAppendElement(interp, listObjPtr,
-		    Tcl_NewStringObj(localPtr->name, -1));
+		    Tcl_NewStringObj(localPtr->name, TCL_INDEX_NONE));
 	}
     }
     Tcl_SetObjResult(interp, listObjPtr);
@@ -716,7 +716,7 @@ InfoCommandsCmd(
 		Tcl_GetCommandFullName(interp, cmd, elemObjPtr);
 	    } else {
 		cmdName = (const char *)Tcl_GetHashKey(&nsPtr->cmdTable, entryPtr);
-		elemObjPtr = Tcl_NewStringObj(cmdName, -1);
+		elemObjPtr = Tcl_NewStringObj(cmdName, TCL_INDEX_NONE);
 	    }
 	    Tcl_ListObjAppendElement(interp, listPtr, elemObjPtr);
 	    Tcl_SetObjResult(interp, listPtr);
@@ -744,7 +744,7 @@ InfoCommandsCmd(
 	    if (entryPtr != NULL) {
 		cmdName = (const char *)Tcl_GetHashKey(tablePtr, entryPtr);
 		Tcl_ListObjAppendElement(interp, listPtr,
-			Tcl_NewStringObj(cmdName, -1));
+			Tcl_NewStringObj(cmdName, TCL_INDEX_NONE));
 		Tcl_SetObjResult(interp, listPtr);
 		return TCL_OK;
 	    }
@@ -766,7 +766,7 @@ InfoCommandsCmd(
 		    elemObjPtr = Tcl_NewObj();
 		    Tcl_GetCommandFullName(interp, cmd, elemObjPtr);
 		} else {
-		    elemObjPtr = Tcl_NewStringObj(cmdName, -1);
+		    elemObjPtr = Tcl_NewStringObj(cmdName, TCL_INDEX_NONE);
 		}
 		Tcl_ListObjAppendElement(interp, listPtr, elemObjPtr);
 	    }
@@ -789,7 +789,7 @@ InfoCommandsCmd(
 			|| Tcl_StringMatch(cmdName, simplePattern)) {
 		    if (Tcl_FindHashEntry(&nsPtr->cmdTable,cmdName) == NULL) {
 			Tcl_ListObjAppendElement(interp, listPtr,
-				Tcl_NewStringObj(cmdName, -1));
+				Tcl_NewStringObj(cmdName, TCL_INDEX_NONE));
 		    }
 		}
 		entryPtr = Tcl_NextHashEntry(&search);
@@ -818,7 +818,7 @@ InfoCommandsCmd(
 	    cmdName = (const char *)Tcl_GetHashKey(&nsPtr->cmdTable, entryPtr);
 	    if ((simplePattern == NULL)
 		    || Tcl_StringMatch(cmdName, simplePattern)) {
-		elemObjPtr = Tcl_NewStringObj(cmdName, -1);
+		elemObjPtr = Tcl_NewStringObj(cmdName, TCL_INDEX_NONE);
 		Tcl_ListObjAppendElement(interp, listPtr, elemObjPtr);
 		(void) Tcl_CreateHashEntry(&addedCommandsTable,
 			elemObjPtr, &isNew);
@@ -844,7 +844,7 @@ InfoCommandsCmd(
 		cmdName = (const char *)Tcl_GetHashKey(&pathNsPtr->cmdTable, entryPtr);
 		if ((simplePattern == NULL)
 			|| Tcl_StringMatch(cmdName, simplePattern)) {
-		    elemObjPtr = Tcl_NewStringObj(cmdName, -1);
+		    elemObjPtr = Tcl_NewStringObj(cmdName, TCL_INDEX_NONE);
 		    (void) Tcl_CreateHashEntry(&addedCommandsTable,
 			    elemObjPtr, &isNew);
 		    if (isNew) {
@@ -871,7 +871,7 @@ InfoCommandsCmd(
 		cmdName = (const char *)Tcl_GetHashKey(&globalNsPtr->cmdTable, entryPtr);
 		if ((simplePattern == NULL)
 			|| Tcl_StringMatch(cmdName, simplePattern)) {
-		    elemObjPtr = Tcl_NewStringObj(cmdName, -1);
+		    elemObjPtr = Tcl_NewStringObj(cmdName, TCL_INDEX_NONE);
 		    if (Tcl_FindHashEntry(&addedCommandsTable,
 			    (char *) elemObjPtr) == NULL) {
 			Tcl_ListObjAppendElement(interp, listPtr, elemObjPtr);
@@ -1291,7 +1291,7 @@ TclInfoFrame(
 	 * str.
 	 */
 
-	ADD_PAIR("type", Tcl_NewStringObj(typeString[framePtr->type], -1));
+	ADD_PAIR("type", Tcl_NewStringObj(typeString[framePtr->type], TCL_INDEX_NONE));
 	if (framePtr->line) {
 	    ADD_PAIR("line", Tcl_NewWideIntObj(framePtr->line[0]));
 	} else {
@@ -1305,7 +1305,7 @@ TclInfoFrame(
 	 * Precompiled. Result contains the type as signal, nothing else.
 	 */
 
-	ADD_PAIR("type", Tcl_NewStringObj(typeString[framePtr->type], -1));
+	ADD_PAIR("type", Tcl_NewStringObj(typeString[framePtr->type], TCL_INDEX_NONE));
 	break;
 
     case TCL_LOCATION_BC: {
@@ -1330,7 +1330,7 @@ TclInfoFrame(
 	 * Possibly modified: type, path!
 	 */
 
-	ADD_PAIR("type", Tcl_NewStringObj(typeString[fPtr->type], -1));
+	ADD_PAIR("type", Tcl_NewStringObj(typeString[fPtr->type], TCL_INDEX_NONE));
 	if (fPtr->line) {
 	    ADD_PAIR("line", Tcl_NewWideIntObj(fPtr->line[0]));
 	}
@@ -1358,7 +1358,7 @@ TclInfoFrame(
 	 * Evaluation of a script file.
 	 */
 
-	ADD_PAIR("type", Tcl_NewStringObj(typeString[framePtr->type], -1));
+	ADD_PAIR("type", Tcl_NewStringObj(typeString[framePtr->type], TCL_INDEX_NONE));
 	ADD_PAIR("line", Tcl_NewWideIntObj(framePtr->line[0]));
 	ADD_PAIR("file", framePtr->data.eval.path);
 
@@ -1404,7 +1404,7 @@ TclInfoFrame(
 	     */
 
 	    for (i=0 ; i<efiPtr->length ; i++) {
-		lv[lc++] = Tcl_NewStringObj(efiPtr->fields[i].name, -1);
+		lv[lc++] = Tcl_NewStringObj(efiPtr->fields[i].name, TCL_INDEX_NONE);
 		if (efiPtr->fields[i].proc) {
 		    lv[lc++] =
 			efiPtr->fields[i].proc(efiPtr->fields[i].clientData);
@@ -1492,7 +1492,7 @@ InfoFunctionsCmd(
 "		    }\n"
 "		}\n"
 "		::return $cmds\n"
-"	    } [::namespace current]] ", -1);
+"	    } [::namespace current]] ", TCL_INDEX_NONE);
 
     if (objc == 2) {
 	Tcl_Obj *arg = Tcl_NewListObj(1, &(objv[1]));
@@ -1545,12 +1545,12 @@ InfoHostnameCmd(
 
     name = Tcl_GetHostName();
     if (name) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(name, -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(name, TCL_INDEX_NONE));
 	return TCL_OK;
     }
 
     Tcl_SetObjResult(interp, Tcl_NewStringObj(
-	    "unable to determine name of host", -1));
+	    "unable to determine name of host", TCL_INDEX_NONE));
     Tcl_SetErrorCode(interp, "TCL", "OPERATION", "HOSTNAME", "UNKNOWN", NULL);
     return TCL_ERROR;
 }
@@ -1665,12 +1665,12 @@ InfoLibraryCmd(
 
     libDirName = Tcl_GetVar2(interp, "tcl_library", NULL, TCL_GLOBAL_ONLY);
     if (libDirName != NULL) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(libDirName, -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(libDirName, TCL_INDEX_NONE));
 	return TCL_OK;
     }
 
     Tcl_SetObjResult(interp, Tcl_NewStringObj(
-	    "no library has been specified for Tcl", -1));
+	    "no library has been specified for Tcl", TCL_INDEX_NONE));
     Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "VARIABLE", "tcl_library",NULL);
     return TCL_ERROR;
 }
@@ -1797,7 +1797,7 @@ InfoPatchLevelCmd(
     patchlevel = Tcl_GetVar2(interp, "tcl_patchLevel", NULL,
 	    (TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG));
     if (patchlevel != NULL) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(patchlevel, -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(patchlevel, TCL_INDEX_NONE));
 	return TCL_OK;
     }
     return TCL_ERROR;
@@ -1910,7 +1910,7 @@ InfoProcsCmd(
 		    Tcl_GetCommandFullName(interp, (Tcl_Command) cmdPtr,
 			    elemObjPtr);
 		} else {
-		    elemObjPtr = Tcl_NewStringObj(simplePattern, -1);
+		    elemObjPtr = Tcl_NewStringObj(simplePattern, TCL_INDEX_NONE);
 		}
 		Tcl_ListObjAppendElement(interp, listPtr, elemObjPtr);
 	    }
@@ -1938,7 +1938,7 @@ InfoProcsCmd(
 			Tcl_GetCommandFullName(interp, (Tcl_Command) cmdPtr,
 				elemObjPtr);
 		    } else {
-			elemObjPtr = Tcl_NewStringObj(cmdName, -1);
+			elemObjPtr = Tcl_NewStringObj(cmdName, TCL_INDEX_NONE);
 		    }
 		    Tcl_ListObjAppendElement(interp, listPtr, elemObjPtr);
 		}
@@ -1977,7 +1977,7 @@ InfoProcsCmd(
 			if (TclIsProc(cmdPtr) || ((realCmdPtr != NULL)
 				&& TclIsProc(realCmdPtr))) {
 			    Tcl_ListObjAppendElement(interp, listPtr,
-				    Tcl_NewStringObj(cmdName, -1));
+				    Tcl_NewStringObj(cmdName, TCL_INDEX_NONE));
 			}
 		    }
 		}
@@ -2075,7 +2075,7 @@ InfoSharedlibCmd(
     }
 
 #ifdef TCL_SHLIB_EXT
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(TCL_SHLIB_EXT, -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(TCL_SHLIB_EXT, TCL_INDEX_NONE));
 #endif
     return TCL_OK;
 }
@@ -2172,7 +2172,7 @@ InfoCmdTypeCmd(
 	Tcl_AppendResult(interp, "native", NULL);
     } else {
 	Tcl_SetObjResult(interp,
-		Tcl_NewStringObj(TclGetCommandTypeName(command), -1));
+		Tcl_NewStringObj(TclGetCommandTypeName(command), TCL_INDEX_NONE));
     }
     return TCL_OK;
 }
@@ -2652,7 +2652,7 @@ Tcl_LpopObjCmd(
 	if (!listLen) {
 	    /* empty list, throw the same error as with index "end" */
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"index \"end\" out of range", -1));
+		"index \"end\" out of range", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "VALUE", "INDEX"
 		"OUTOFRANGE", NULL);
 	    return TCL_ERROR;
@@ -3374,7 +3374,7 @@ Tcl_LsearchObjCmd(
 	    }
 	    if (i + 4 > (size_t)objc) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"missing starting index", -1));
+			"missing starting index", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING", NULL);
 		result = TCL_ERROR;
 		goto done;
@@ -3398,7 +3398,7 @@ Tcl_LsearchObjCmd(
 	    if (i + 4 > (size_t)objc) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"\"-stride\" option must be "
-			"followed by stride length", -1));
+			"followed by stride length", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING", NULL);
 		result = TCL_ERROR;
 		goto done;
@@ -3409,7 +3409,7 @@ Tcl_LsearchObjCmd(
 	    }
 	    if (wide < 1) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"stride length must be at least 1", -1));
+			"stride length must be at least 1", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "LSEARCH",
 			"BADSTRIDE", NULL);
 		result = TCL_ERROR;
@@ -3499,7 +3499,7 @@ Tcl_LsearchObjCmd(
 
     if (returnSubindices && sortInfo.indexc==0) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"-subindices cannot be used without -index option", -1));
+		"-subindices cannot be used without -index option", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "LSEARCH",
 		"BAD_OPTION_MIX", NULL);
 	result = TCL_ERROR;
@@ -3508,7 +3508,7 @@ Tcl_LsearchObjCmd(
 
     if (bisect && (allMatches || negatedMatch)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"-bisect is not compatible with -all or -not", -1));
+		"-bisect is not compatible with -all or -not", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "LSEARCH",
 		"BAD_OPTION_MIX", NULL);
 	result = TCL_ERROR;
@@ -3578,7 +3578,7 @@ Tcl_LsearchObjCmd(
 	    if (groupOffset >= groupSize) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"when used with \"-stride\", the leading \"-index\""
-			" value must be within the group", -1));
+			" value must be within the group", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "LSEARCH",
 			"BADINDEX", NULL);
 		result = TCL_ERROR;
@@ -4551,7 +4551,7 @@ Tcl_LsortObjCmd(
 	    if (i + 2 == (size_t)objc) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"\"-command\" option must be followed "
-			"by comparison command", -1));
+			"by comparison command", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING", NULL);
 		sortInfo.resultCode = TCL_ERROR;
 		goto done;
@@ -4638,7 +4638,7 @@ Tcl_LsortObjCmd(
 	    if (i + 2 == (size_t)objc) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"\"-stride\" option must be "
-			"followed by stride length", -1));
+			"followed by stride length", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING", NULL);
 		sortInfo.resultCode = TCL_ERROR;
 		goto done;
@@ -4649,7 +4649,7 @@ Tcl_LsortObjCmd(
 	    }
 	    if (wide < 2) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"stride length must be at least 2", -1));
+			"stride length must be at least 2", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "LSORT",
 			"BADSTRIDE", NULL);
 		sortInfo.resultCode = TCL_ERROR;
@@ -4771,7 +4771,7 @@ Tcl_LsortObjCmd(
 	    if (groupOffset >= groupSize) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"when used with \"-stride\", the leading \"-index\""
-			" value must be within the group", -1));
+			" value must be within the group", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "LSORT",
 			"BADINDEX", NULL);
 		sortInfo.resultCode = TCL_ERROR;
@@ -5298,7 +5298,7 @@ SortCompare(
 	if (TclGetIntFromObj(infoPtr->interp,
 		Tcl_GetObjResult(infoPtr->interp), &order) != TCL_OK) {
 	    Tcl_SetObjResult(infoPtr->interp, Tcl_NewStringObj(
-		    "-compare command returned non-integer result", -1));
+		    "-compare command returned non-integer result", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(infoPtr->interp, "TCL", "OPERATION", "LSORT",
 		    "COMPARISONFAILED", NULL);
 	    infoPtr->resultCode = TCL_ERROR;
diff --git a/generic/tclCmdMZ.c b/generic/tclCmdMZ.c
index f497f59..77c8cb4 100644
--- a/generic/tclCmdMZ.c
+++ b/generic/tclCmdMZ.c
@@ -227,7 +227,7 @@ Tcl_RegexpObjCmd(
 
     if (doinline && ((objc - 2) != 0)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"regexp match variables not allowed when using -inline", -1));
+		"regexp match variables not allowed when using -inline", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "REGEXP",
 		"MIX_VAR_INLINE", NULL);
 	goto optionError;
@@ -1695,7 +1695,7 @@ StringIsCmd(
 	    goto str_is_done;
 	}
 	end = string1 + length1;
-	if (TclParseNumber(NULL, objPtr, NULL, NULL, -1,
+	if (TclParseNumber(NULL, objPtr, NULL, NULL, TCL_INDEX_NONE,
 		(const char **) &stop, 0) != TCL_OK) {
 	    result = 0;
 	    failat = 0;
@@ -1725,7 +1725,7 @@ StringIsCmd(
 	    goto str_is_done;
 	}
 	end = string1 + length1;
-	if (TclParseNumber(NULL, objPtr, NULL, NULL, -1,
+	if (TclParseNumber(NULL, objPtr, NULL, NULL, TCL_INDEX_NONE,
 		(const char **) &stop, TCL_PARSE_INTEGER_ONLY) == TCL_OK) {
 	    if (stop == end) {
 		/*
@@ -1776,7 +1776,7 @@ StringIsCmd(
 	    break;
 	}
 	end = string1 + length1;
-	if (TclParseNumber(NULL, objPtr, NULL, NULL, -1,
+	if (TclParseNumber(NULL, objPtr, NULL, NULL, TCL_INDEX_NONE,
 		(const char **) &stop, TCL_PARSE_INTEGER_ONLY) == TCL_OK) {
 	    if (stop == end) {
 		/*
@@ -2047,7 +2047,7 @@ StringMapCmd(
 	     */
 
 	    Tcl_SetObjResult(interp,
-		    Tcl_NewStringObj("char map list unbalanced", -1));
+		    Tcl_NewStringObj("char map list unbalanced", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "MAP",
 		    "UNBALANCED", NULL);
 	    return TCL_ERROR;
@@ -2933,7 +2933,7 @@ StringLowerCmd(
 	length2 = Tcl_UtfToLower(string2);
 	Tcl_SetObjLength(resultPtr, length2 + (start - string1));
 
-	Tcl_AppendToObj(resultPtr, end, -1);
+	Tcl_AppendToObj(resultPtr, end, TCL_INDEX_NONE);
 	Tcl_SetObjResult(interp, resultPtr);
     }
 
@@ -3018,7 +3018,7 @@ StringUpperCmd(
 	length2 = Tcl_UtfToUpper(string2);
 	Tcl_SetObjLength(resultPtr, length2 + (start - string1));
 
-	Tcl_AppendToObj(resultPtr, end, -1);
+	Tcl_AppendToObj(resultPtr, end, TCL_INDEX_NONE);
 	Tcl_SetObjResult(interp, resultPtr);
     }
 
@@ -3103,7 +3103,7 @@ StringTitleCmd(
 	length2 = Tcl_UtfToTitle(string2);
 	Tcl_SetObjLength(resultPtr, length2 + (start - string1));
 
-	Tcl_AppendToObj(resultPtr, end, -1);
+	Tcl_AppendToObj(resultPtr, end, TCL_INDEX_NONE);
 	Tcl_SetObjResult(interp, resultPtr);
     }
 
@@ -3612,7 +3612,7 @@ TclNRSwitchObjCmd(
     if (objc % 2) {
 	Tcl_ResetResult(interp);
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"extra switch pattern with no body", -1));
+		"extra switch pattern with no body", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "SWITCH", "BADARM",
 		NULL);
 
@@ -3630,7 +3630,7 @@ TclNRSwitchObjCmd(
 		    Tcl_AppendToObj(Tcl_GetObjResult(interp),
 			    ", this may be due to a comment incorrectly"
 			    " placed outside of a switch body - see the"
-			    " \"switch\" documentation", -1);
+			    " \"switch\" documentation", TCL_INDEX_NONE);
 		    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "SWITCH",
 			    "BADARM", "COMMENT?", NULL);
 		    break;
@@ -3980,7 +3980,7 @@ Tcl_ThrowObjCmd(
 	return TCL_ERROR;
     } else if (len < 1) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"type must be non-empty list", -1));
+		"type must be non-empty list", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "THROW", "BADEXCEPTION",
 		NULL);
 	return TCL_ERROR;
@@ -4718,7 +4718,7 @@ TclNRTryObjCmd(
 	case TryFinally:	/* finally script */
 	    if (i < objc-2) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"finally clause must be last", -1));
+			"finally clause must be last", TCL_INDEX_NONE));
 		Tcl_DecrRefCount(handlersObj);
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "TRY", "FINALLY",
 			"NONTERMINAL", NULL);
@@ -4726,7 +4726,7 @@ TclNRTryObjCmd(
 	    } else if (i == objc-1) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"wrong # args to finally clause: must be"
-			" \"... finally script\"", -1));
+			" \"... finally script\"", TCL_INDEX_NONE));
 		Tcl_DecrRefCount(handlersObj);
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "TRY", "FINALLY",
 			"ARGUMENT", NULL);
@@ -4739,7 +4739,7 @@ TclNRTryObjCmd(
 	    if (i > objc-4) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"wrong # args to on clause: must be \"... on code"
-			" variableList script\"", -1));
+			" variableList script\"", TCL_INDEX_NONE));
 		Tcl_DecrRefCount(handlersObj);
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "TRY", "ON",
 			"ARGUMENT", NULL);
@@ -4800,7 +4800,7 @@ TclNRTryObjCmd(
     }
     if (bodyShared) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"last non-finally clause must not have a body of \"-\"", -1));
+		"last non-finally clause must not have a body of \"-\"", TCL_INDEX_NONE));
 	Tcl_DecrRefCount(handlersObj);
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "TRY", "BADFALLTHROUGH",
 		NULL);
diff --git a/generic/tclCompExpr.c b/generic/tclCompExpr.c
index b7bcf7c..c503304 100644
--- a/generic/tclCompExpr.c
+++ b/generic/tclCompExpr.c
@@ -798,14 +798,14 @@ ParseExpr(
 			    switch (start[1]) {
 			    case 'b':
 				Tcl_AppendToObj(post,
-					" (invalid binary number?)", -1);
+					" (invalid binary number?)", TCL_INDEX_NONE);
 				parsePtr->errorType = TCL_PARSE_BAD_NUMBER;
 				errCode = "BADNUMBER";
 				subErrCode = "BINARY";
 				break;
 			    case 'o':
 				Tcl_AppendToObj(post,
-					" (invalid octal number?)", -1);
+					" (invalid octal number?)", TCL_INDEX_NONE);
 				parsePtr->errorType = TCL_PARSE_BAD_NUMBER;
 				errCode = "BADNUMBER";
 				subErrCode = "OCTAL";
@@ -813,7 +813,7 @@ ParseExpr(
 			    default:
 				if (isdigit(UCHAR(start[1]))) {
 				    Tcl_AppendToObj(post,
-					    " (invalid octal number?)", -1);
+					    " (invalid octal number?)", TCL_INDEX_NONE);
 				    parsePtr->errorType = TCL_PARSE_BAD_NUMBER;
 				    errCode = "BADNUMBER";
 				    subErrCode = "OCTAL";
@@ -1462,7 +1462,7 @@ ParseExpr(
 	 */
 
 	if (post != NULL) {
-	    Tcl_AppendToObj(msg, ";\n", -1);
+	    Tcl_AppendToObj(msg, ";\n", TCL_INDEX_NONE);
 	    Tcl_AppendObjToObj(msg, post);
 	    Tcl_DecrRefCount(post);
 	}
diff --git a/generic/tclDisassemble.c b/generic/tclDisassemble.c
index 57adcf0..c06731f 100644
--- a/generic/tclDisassemble.c
+++ b/generic/tclDisassemble.c
@@ -280,7 +280,7 @@ DisassembleByteCodeObj(
     Tcl_AppendPrintfToObj(bufferObj,
 	    "ByteCode %p, refCt %" TCL_Z_MODIFIER "u, epoch %" TCL_Z_MODIFIER "u, interp %p (epoch %" TCL_Z_MODIFIER "u)\n",
 	    codePtr, codePtr->refCount, codePtr->compileEpoch, iPtr, iPtr->compileEpoch);
-    Tcl_AppendToObj(bufferObj, "  Source ", -1);
+    Tcl_AppendToObj(bufferObj, "  Source ", TCL_INDEX_NONE);
     PrintSourceToObj(bufferObj, codePtr->source,
 	    TclMin(codePtr->numSrcBytes, 55));
     GetLocationInformation(codePtr->procPtr, &fileObj, &line);
@@ -339,7 +339,7 @@ DisassembleByteCodeObj(
 			(localPtr->flags & VAR_TEMPORARY) ? ", temp" : "",
 			(localPtr->flags & VAR_RESOLVED) ? ", resolved" : "");
 		if (TclIsVarTemporary(localPtr)) {
-		    Tcl_AppendToObj(bufferObj, "\n", -1);
+		    Tcl_AppendToObj(bufferObj, "\n", TCL_INDEX_NONE);
 		} else {
 		    Tcl_AppendPrintfToObj(bufferObj, ", \"%s\"\n",
 			    localPtr->name);
@@ -389,7 +389,7 @@ DisassembleByteCodeObj(
     if (numCmds == 0) {
 	pc = codeStart;
 	while (pc < codeLimit) {
-	    Tcl_AppendToObj(bufferObj, "    ", -1);
+	    Tcl_AppendToObj(bufferObj, "    ", TCL_INDEX_NONE);
 	    pc += FormatInstruction(codePtr, pc, bufferObj);
 	}
 	return bufferObj;
@@ -451,7 +451,7 @@ DisassembleByteCodeObj(
 		srcOffset, (srcOffset + srcLen - 1));
     }
     if (numCmds > 0) {
-	Tcl_AppendToObj(bufferObj, "\n", -1);
+	Tcl_AppendToObj(bufferObj, "\n", TCL_INDEX_NONE);
     }
 
     /*
@@ -500,14 +500,14 @@ DisassembleByteCodeObj(
 	 */
 
 	while ((pc-codeStart) < codeOffset) {
-	    Tcl_AppendToObj(bufferObj, "    ", -1);
+	    Tcl_AppendToObj(bufferObj, "    ", TCL_INDEX_NONE);
 	    pc += FormatInstruction(codePtr, pc, bufferObj);
 	}
 
 	Tcl_AppendPrintfToObj(bufferObj, "  Command %d: ", i+1);
 	PrintSourceToObj(bufferObj, (codePtr->source + srcOffset),
 		TclMin(srcLen, 55));
-	Tcl_AppendToObj(bufferObj, "\n", -1);
+	Tcl_AppendToObj(bufferObj, "\n", TCL_INDEX_NONE);
     }
     if (pc < codeLimit) {
 	/*
@@ -515,7 +515,7 @@ DisassembleByteCodeObj(
 	 */
 
 	while (pc < codeLimit) {
-	    Tcl_AppendToObj(bufferObj, "    ", -1);
+	    Tcl_AppendToObj(bufferObj, "    ", TCL_INDEX_NONE);
 	    pc += FormatInstruction(codePtr, pc, bufferObj);
 	}
     }
@@ -654,7 +654,7 @@ FormatInstruction(
 	const char *bytes;
 	size_t length;
 
-	Tcl_AppendToObj(bufferObj, "\t# ", -1);
+	Tcl_AppendToObj(bufferObj, "\t# ", TCL_INDEX_NONE);
 	bytes = Tcl_GetStringFromObj(codePtr->objArrayPtr[opnd], &length);
 	PrintSourceToObj(bufferObj, bytes, TclMin(length, 40));
     } else if (suffixBuffer[0]) {
@@ -663,12 +663,12 @@ FormatInstruction(
 	    PrintSourceToObj(bufferObj, suffixSrc, 40);
 	}
     }
-    Tcl_AppendToObj(bufferObj, "\n", -1);
+    Tcl_AppendToObj(bufferObj, "\n", TCL_INDEX_NONE);
     if (auxPtr && auxPtr->type->printProc) {
-	Tcl_AppendToObj(bufferObj, "\t\t[", -1);
+	Tcl_AppendToObj(bufferObj, "\t\t[", TCL_INDEX_NONE);
 	auxPtr->type->printProc(auxPtr->clientData, bufferObj, codePtr,
 		pcOffset);
-	Tcl_AppendToObj(bufferObj, "]\n", -1);
+	Tcl_AppendToObj(bufferObj, "]\n", TCL_INDEX_NONE);
     }
     return numBytes;
 }
@@ -866,11 +866,11 @@ PrintSourceToObj(
     size_t i = 0, len;
 
     if (stringPtr == NULL) {
-	Tcl_AppendToObj(appendObj, "\"\"", -1);
+	Tcl_AppendToObj(appendObj, "\"\"", TCL_INDEX_NONE);
 	return;
     }
 
-    Tcl_AppendToObj(appendObj, "\"", -1);
+    Tcl_AppendToObj(appendObj, "\"", TCL_INDEX_NONE);
     p = stringPtr;
     for (;  (*p != '\0') && (i < maxChars);  p+=len) {
 	int ucs4;
@@ -878,27 +878,27 @@ PrintSourceToObj(
 	len = TclUtfToUCS4(p, &ucs4);
 	switch (ucs4) {
 	case '"':
-	    Tcl_AppendToObj(appendObj, "\\\"", -1);
+	    Tcl_AppendToObj(appendObj, "\\\"", TCL_INDEX_NONE);
 	    i += 2;
 	    continue;
 	case '\f':
-	    Tcl_AppendToObj(appendObj, "\\f", -1);
+	    Tcl_AppendToObj(appendObj, "\\f", TCL_INDEX_NONE);
 	    i += 2;
 	    continue;
 	case '\n':
-	    Tcl_AppendToObj(appendObj, "\\n", -1);
+	    Tcl_AppendToObj(appendObj, "\\n", TCL_INDEX_NONE);
 	    i += 2;
 	    continue;
 	case '\r':
-	    Tcl_AppendToObj(appendObj, "\\r", -1);
+	    Tcl_AppendToObj(appendObj, "\\r", TCL_INDEX_NONE);
 	    i += 2;
 	    continue;
 	case '\t':
-	    Tcl_AppendToObj(appendObj, "\\t", -1);
+	    Tcl_AppendToObj(appendObj, "\\t", TCL_INDEX_NONE);
 	    i += 2;
 	    continue;
 	case '\v':
-	    Tcl_AppendToObj(appendObj, "\\v", -1);
+	    Tcl_AppendToObj(appendObj, "\\v", TCL_INDEX_NONE);
 	    i += 2;
 	    continue;
 	default:
@@ -916,9 +916,9 @@ PrintSourceToObj(
 	}
     }
     if (*p != '\0') {
-	Tcl_AppendToObj(appendObj, "...", -1);
+	Tcl_AppendToObj(appendObj, "...", TCL_INDEX_NONE);
     }
-    Tcl_AppendToObj(appendObj, "\"", -1);
+    Tcl_AppendToObj(appendObj, "\"", TCL_INDEX_NONE);
 }
 
 /*
@@ -972,33 +972,33 @@ DisassembleByteCodeAsDicts(
 	    TclNewObj(descriptor[0]);
 	    if (!(localPtr->flags & (VAR_ARRAY|VAR_LINK))) {
 		Tcl_ListObjAppendElement(NULL, descriptor[0],
-			Tcl_NewStringObj("scalar", -1));
+			Tcl_NewStringObj("scalar", TCL_INDEX_NONE));
 	    }
 	    if (localPtr->flags & VAR_ARRAY) {
 		Tcl_ListObjAppendElement(NULL, descriptor[0],
-			Tcl_NewStringObj("array", -1));
+			Tcl_NewStringObj("array", TCL_INDEX_NONE));
 	    }
 	    if (localPtr->flags & VAR_LINK) {
 		Tcl_ListObjAppendElement(NULL, descriptor[0],
-			Tcl_NewStringObj("link", -1));
+			Tcl_NewStringObj("link", TCL_INDEX_NONE));
 	    }
 	    if (localPtr->flags & VAR_ARGUMENT) {
 		Tcl_ListObjAppendElement(NULL, descriptor[0],
-			Tcl_NewStringObj("arg", -1));
+			Tcl_NewStringObj("arg", TCL_INDEX_NONE));
 	    }
 	    if (localPtr->flags & VAR_TEMPORARY) {
 		Tcl_ListObjAppendElement(NULL, descriptor[0],
-			Tcl_NewStringObj("temp", -1));
+			Tcl_NewStringObj("temp", TCL_INDEX_NONE));
 	    }
 	    if (localPtr->flags & VAR_RESOLVED) {
 		Tcl_ListObjAppendElement(NULL, descriptor[0],
-			Tcl_NewStringObj("resolved", -1));
+			Tcl_NewStringObj("resolved", TCL_INDEX_NONE));
 	    }
 	    if (localPtr->flags & VAR_TEMPORARY) {
 		Tcl_ListObjAppendElement(NULL, variables,
 			Tcl_NewListObj(1, descriptor));
 	    } else {
-		descriptor[1] = Tcl_NewStringObj(localPtr->name, -1);
+		descriptor[1] = Tcl_NewStringObj(localPtr->name, TCL_INDEX_NONE);
 		Tcl_ListObjAppendElement(NULL, variables,
 			Tcl_NewListObj(2, descriptor));
 	    }
@@ -1016,7 +1016,7 @@ DisassembleByteCodeAsDicts(
 
 	TclNewObj(inst);
 	Tcl_ListObjAppendElement(NULL, inst, Tcl_NewStringObj(
-		instDesc->name, -1));
+		instDesc->name, TCL_INDEX_NONE));
 	opnd = pc + 1;
 	for (i=0 ; i<instDesc->numOperands ; i++) {
 	    switch (instDesc->opTypes[i]) {
@@ -1082,7 +1082,7 @@ DisassembleByteCodeAsDicts(
 			    ".%d", val));
 		} else if (val == -2) {
 		    Tcl_ListObjAppendElement(NULL, inst, Tcl_NewStringObj(
-			    ".end", -1));
+			    ".end", TCL_INDEX_NONE));
 		} else {
 		    Tcl_ListObjAppendElement(NULL, inst, Tcl_ObjPrintf(
 			    ".end-%d", -2-val));
@@ -1115,13 +1115,13 @@ DisassembleByteCodeAsDicts(
     TclNewObj(aux);
     for (i=0 ; i<(int)codePtr->numAuxDataItems ; i++) {
 	AuxData *auxData = &codePtr->auxDataArrayPtr[i];
-	Tcl_Obj *auxDesc = Tcl_NewStringObj(auxData->type->name, -1);
+	Tcl_Obj *auxDesc = Tcl_NewStringObj(auxData->type->name, TCL_INDEX_NONE);
 
 	if (auxData->type->disassembleProc) {
 	    Tcl_Obj *desc;
 
 	    TclNewObj(desc);
-	    Tcl_DictObjPut(NULL, desc, Tcl_NewStringObj("name", -1), auxDesc);
+	    Tcl_DictObjPut(NULL, desc, Tcl_NewStringObj("name", TCL_INDEX_NONE), auxDesc);
 	    auxDesc = desc;
 	    auxData->type->disassembleProc(auxData->clientData, auxDesc,
 		    codePtr, 0);
@@ -1188,9 +1188,9 @@ DisassembleByteCodeAsDicts(
 	sourceOffset += Decode(srcOffPtr);
 	sourceLength = Decode(srcLenPtr);
 	TclNewObj(cmd);
-	Tcl_DictObjPut(NULL, cmd, Tcl_NewStringObj("codefrom", -1),
+	Tcl_DictObjPut(NULL, cmd, Tcl_NewStringObj("codefrom", TCL_INDEX_NONE),
 		Tcl_NewWideIntObj(codeOffset));
-	Tcl_DictObjPut(NULL, cmd, Tcl_NewStringObj("codeto", -1),
+	Tcl_DictObjPut(NULL, cmd, Tcl_NewStringObj("codeto", TCL_INDEX_NONE),
 		Tcl_NewWideIntObj(codeOffset + codeLength - 1));
 
 	/*
@@ -1198,13 +1198,13 @@ DisassembleByteCodeAsDicts(
 	 * characters are present in the source!
 	 */
 
-	Tcl_DictObjPut(NULL, cmd, Tcl_NewStringObj("scriptfrom", -1),
+	Tcl_DictObjPut(NULL, cmd, Tcl_NewStringObj("scriptfrom", TCL_INDEX_NONE),
 		Tcl_NewWideIntObj(Tcl_NumUtfChars(codePtr->source,
 			sourceOffset)));
-	Tcl_DictObjPut(NULL, cmd, Tcl_NewStringObj("scriptto", -1),
+	Tcl_DictObjPut(NULL, cmd, Tcl_NewStringObj("scriptto", TCL_INDEX_NONE),
 		Tcl_NewWideIntObj(Tcl_NumUtfChars(codePtr->source,
 			sourceOffset + sourceLength - 1)));
-	Tcl_DictObjPut(NULL, cmd, Tcl_NewStringObj("script", -1),
+	Tcl_DictObjPut(NULL, cmd, Tcl_NewStringObj("script", TCL_INDEX_NONE),
 		Tcl_NewStringObj(codePtr->source+sourceOffset, sourceLength));
 	Tcl_ListObjAppendElement(NULL, commands, cmd);
     }
@@ -1223,32 +1223,32 @@ DisassembleByteCodeAsDicts(
      */
 
     TclNewObj(description);
-    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("literals", -1),
+    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("literals", TCL_INDEX_NONE),
 	    literals);
-    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("variables", -1),
+    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("variables", TCL_INDEX_NONE),
 	    variables);
-    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("exception", -1), exn);
-    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("instructions", -1),
+    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("exception", TCL_INDEX_NONE), exn);
+    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("instructions", TCL_INDEX_NONE),
 	    instructions);
-    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("auxiliary", -1), aux);
-    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("commands", -1),
+    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("auxiliary", TCL_INDEX_NONE), aux);
+    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("commands", TCL_INDEX_NONE),
 	    commands);
-    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("script", -1),
+    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("script", TCL_INDEX_NONE),
 	    Tcl_NewStringObj(codePtr->source, codePtr->numSrcBytes));
-    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("namespace", -1),
-	    Tcl_NewStringObj(codePtr->nsPtr->fullName, -1));
-    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("stackdepth", -1),
+    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("namespace", TCL_INDEX_NONE),
+	    Tcl_NewStringObj(codePtr->nsPtr->fullName, TCL_INDEX_NONE));
+    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("stackdepth", TCL_INDEX_NONE),
 	    Tcl_NewWideIntObj(codePtr->maxStackDepth));
-    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("exceptdepth", -1),
+    Tcl_DictObjPut(NULL, description, Tcl_NewStringObj("exceptdepth", TCL_INDEX_NONE),
 	    Tcl_NewWideIntObj(codePtr->maxExceptDepth));
     if (line >= 0) {
 	Tcl_DictObjPut(NULL, description,
-		Tcl_NewStringObj("initiallinenumber", -1),
+		Tcl_NewStringObj("initiallinenumber", TCL_INDEX_NONE),
 		Tcl_NewWideIntObj(line));
     }
     if (file) {
 	Tcl_DictObjPut(NULL, description,
-		Tcl_NewStringObj("sourcefile", -1), file);
+		Tcl_NewStringObj("sourcefile", TCL_INDEX_NONE), file);
     }
     return description;
 }
@@ -1410,7 +1410,7 @@ Tcl_DisassembleObjCmd(
 	procPtr = TclOOGetProcFromMethod(methodPtr);
 	if (procPtr == NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "body not available for this kind of constructor", -1));
+		    "body not available for this kind of constructor", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "DISASSEMBLE",
 		    "METHODTYPE", NULL);
 	    return TCL_ERROR;
@@ -1475,7 +1475,7 @@ Tcl_DisassembleObjCmd(
 	procPtr = TclOOGetProcFromMethod(methodPtr);
 	if (procPtr == NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "body not available for this kind of destructor", -1));
+		    "body not available for this kind of destructor", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "DISASSEMBLE",
 		    "METHODTYPE", NULL);
 	    return TCL_ERROR;
@@ -1565,7 +1565,7 @@ Tcl_DisassembleObjCmd(
 	procPtr = TclOOGetProcFromMethod((Method *)Tcl_GetHashValue(hPtr));
 	if (procPtr == NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "body not available for this kind of method", -1));
+		    "body not available for this kind of method", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "DISASSEMBLE",
 		    "METHODTYPE", NULL);
 	    return TCL_ERROR;
@@ -1602,7 +1602,7 @@ Tcl_DisassembleObjCmd(
 
     if (codePtr->flags & TCL_BYTECODE_PRECOMPILED) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"may not disassemble prebuilt bytecode", -1));
+		"may not disassemble prebuilt bytecode", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "DISASSEMBLE",
 		"BYTECODE", NULL);
 	return TCL_ERROR;
diff --git a/generic/tclEnsemble.c b/generic/tclEnsemble.c
index a84b188..98f4ae0 100644
--- a/generic/tclEnsemble.c
+++ b/generic/tclEnsemble.c
@@ -125,7 +125,7 @@ NewNsObj(
     if (namespacePtr == TclGetGlobalNamespace(nsPtr->interp)) {
 	return Tcl_NewStringObj("::", 2);
     }
-    return Tcl_NewStringObj(nsPtr->fullName, -1);
+    return Tcl_NewStringObj(nsPtr->fullName, TCL_INDEX_NONE);
 }
 
 /*
@@ -289,7 +289,7 @@ TclNamespaceEnsembleCmd(
 		    if (len < 1) {
 			Tcl_SetObjResult(interp, Tcl_NewStringObj(
 				"ensemble subcommand implementations "
-				"must be non-empty lists", -1));
+				"must be non-empty lists", TCL_INDEX_NONE));
 			Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE",
 				"EMPTY_TARGET", NULL);
 			Tcl_DictObjDone(&search);
@@ -460,7 +460,7 @@ TclNamespaceEnsembleCmd(
 
 	    /* -map option */
 	    Tcl_ListObjAppendElement(NULL, resultObj,
-		    Tcl_NewStringObj(ensembleConfigOptions[CONF_MAP], -1));
+		    Tcl_NewStringObj(ensembleConfigOptions[CONF_MAP], TCL_INDEX_NONE));
 	    Tcl_GetEnsembleMappingDict(NULL, token, &tmpObj);
 	    Tcl_ListObjAppendElement(NULL, resultObj,
 		    (tmpObj != NULL) ? tmpObj : Tcl_NewObj());
@@ -475,14 +475,14 @@ TclNamespaceEnsembleCmd(
 
 	    /* -parameters option */
 	    Tcl_ListObjAppendElement(NULL, resultObj,
-		    Tcl_NewStringObj(ensembleConfigOptions[CONF_PARAM], -1));
+		    Tcl_NewStringObj(ensembleConfigOptions[CONF_PARAM], TCL_INDEX_NONE));
 	    Tcl_GetEnsembleParameterList(NULL, token, &tmpObj);
 	    Tcl_ListObjAppendElement(NULL, resultObj,
 		    (tmpObj != NULL) ? tmpObj : Tcl_NewObj());
 
 	    /* -prefix option */
 	    Tcl_ListObjAppendElement(NULL, resultObj,
-		    Tcl_NewStringObj(ensembleConfigOptions[CONF_PREFIX], -1));
+		    Tcl_NewStringObj(ensembleConfigOptions[CONF_PREFIX], TCL_INDEX_NONE));
 	    Tcl_GetEnsembleFlags(NULL, token, &flags);
 	    Tcl_ListObjAppendElement(NULL, resultObj,
 		    Tcl_NewBooleanObj(flags & TCL_ENSEMBLE_PREFIX));
@@ -577,7 +577,7 @@ TclNamespaceEnsembleCmd(
 			if (len < 1) {
 			    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 				    "ensemble subcommand implementations "
-				    "must be non-empty lists", -1));
+				    "must be non-empty lists", TCL_INDEX_NONE));
 			    Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE",
 				    "EMPTY_TARGET", NULL);
 			    Tcl_DictObjDone(&search);
@@ -625,7 +625,7 @@ TclNamespaceEnsembleCmd(
 		}
 		case CONF_NAMESPACE:
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "option -namespace is read-only", -1));
+			    "option -namespace is read-only", TCL_INDEX_NONE));
 		    Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "READ_ONLY",
 			    NULL);
 		    goto freeMapAndError;
@@ -798,7 +798,7 @@ Tcl_SetEnsembleSubcommandList(
 
     if (cmdPtr->objProc != TclEnsembleImplementationCmd) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"command is not an ensemble", -1));
+		"command is not an ensemble", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "NOT_ENSEMBLE", NULL);
 	return TCL_ERROR;
     }
@@ -874,7 +874,7 @@ Tcl_SetEnsembleParameterList(
 
     if (cmdPtr->objProc != TclEnsembleImplementationCmd) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"command is not an ensemble", -1));
+		"command is not an ensemble", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "NOT_ENSEMBLE", NULL);
 	return TCL_ERROR;
     }
@@ -950,7 +950,7 @@ Tcl_SetEnsembleMappingDict(
 
     if (cmdPtr->objProc != TclEnsembleImplementationCmd) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"command is not an ensemble", -1));
+		"command is not an ensemble", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "NOT_ENSEMBLE", NULL);
 	return TCL_ERROR;
     }
@@ -1050,7 +1050,7 @@ Tcl_SetEnsembleUnknownHandler(
 
     if (cmdPtr->objProc != TclEnsembleImplementationCmd) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"command is not an ensemble", -1));
+		"command is not an ensemble", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "NOT_ENSEMBLE", NULL);
 	return TCL_ERROR;
     }
@@ -1116,7 +1116,7 @@ Tcl_SetEnsembleFlags(
 
     if (cmdPtr->objProc != TclEnsembleImplementationCmd) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"command is not an ensemble", -1));
+		"command is not an ensemble", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "NOT_ENSEMBLE", NULL);
 	return TCL_ERROR;
     }
@@ -1193,7 +1193,7 @@ Tcl_GetEnsembleSubcommandList(
     if (cmdPtr->objProc != TclEnsembleImplementationCmd) {
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "command is not an ensemble", -1));
+		    "command is not an ensemble", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "NOT_ENSEMBLE", NULL);
 	}
 	return TCL_ERROR;
@@ -1235,7 +1235,7 @@ Tcl_GetEnsembleParameterList(
     if (cmdPtr->objProc != TclEnsembleImplementationCmd) {
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "command is not an ensemble", -1));
+		    "command is not an ensemble", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "NOT_ENSEMBLE", NULL);
 	}
 	return TCL_ERROR;
@@ -1277,7 +1277,7 @@ Tcl_GetEnsembleMappingDict(
     if (cmdPtr->objProc != TclEnsembleImplementationCmd) {
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "command is not an ensemble", -1));
+		    "command is not an ensemble", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "NOT_ENSEMBLE", NULL);
 	}
 	return TCL_ERROR;
@@ -1318,7 +1318,7 @@ Tcl_GetEnsembleUnknownHandler(
     if (cmdPtr->objProc != TclEnsembleImplementationCmd) {
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "command is not an ensemble", -1));
+		    "command is not an ensemble", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "NOT_ENSEMBLE", NULL);
 	}
 	return TCL_ERROR;
@@ -1359,7 +1359,7 @@ Tcl_GetEnsembleFlags(
     if (cmdPtr->objProc != TclEnsembleImplementationCmd) {
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "command is not an ensemble", -1));
+		    "command is not an ensemble", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "NOT_ENSEMBLE", NULL);
 	}
 	return TCL_ERROR;
@@ -1400,7 +1400,7 @@ Tcl_GetEnsembleNamespace(
     if (cmdPtr->objProc != TclEnsembleImplementationCmd) {
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "command is not an ensemble", -1));
+		    "command is not an ensemble", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "NOT_ENSEMBLE", NULL);
 	}
 	return TCL_ERROR;
@@ -1549,7 +1549,7 @@ TclMakeEnsemble(
     Tcl_DStringInit(&buf);
     Tcl_DStringInit(&hiddenBuf);
     TclDStringAppendLiteral(&hiddenBuf, "tcl:");
-    Tcl_DStringAppend(&hiddenBuf, name, -1);
+    Tcl_DStringAppend(&hiddenBuf, name, TCL_INDEX_NONE);
     TclDStringAppendLiteral(&hiddenBuf, ":");
     hiddenLen = Tcl_DStringLength(&hiddenBuf);
     if (name[0] == ':' && name[1] == ':') {
@@ -1558,7 +1558,7 @@ TclMakeEnsemble(
 	 */
 
 	cmdName = name;
-	Tcl_DStringAppend(&buf, name, -1);
+	Tcl_DStringAppend(&buf, name, TCL_INDEX_NONE);
 	ensembleFlags = TCL_ENSEMBLE_PREFIX;
     } else {
 	/*
@@ -1574,7 +1574,7 @@ TclMakeEnsemble(
 
 	for (i = 0; i < nameCount; ++i) {
 	    TclDStringAppendLiteral(&buf, "::");
-	    Tcl_DStringAppend(&buf, nameParts[i], -1);
+	    Tcl_DStringAppend(&buf, nameParts[i], TCL_INDEX_NONE);
 	}
     }
 
@@ -1619,10 +1619,10 @@ TclMakeEnsemble(
 	TclDStringAppendLiteral(&buf, "::");
 	TclNewObj(mapDict);
 	for (i=0 ; map[i].name != NULL ; i++) {
-	    fromObj = Tcl_NewStringObj(map[i].name, -1);
+	    fromObj = Tcl_NewStringObj(map[i].name, TCL_INDEX_NONE);
 	    TclNewStringObj(toObj, Tcl_DStringValue(&buf),
 		    Tcl_DStringLength(&buf));
-	    Tcl_AppendToObj(toObj, map[i].name, -1);
+	    Tcl_AppendToObj(toObj, map[i].name, TCL_INDEX_NONE);
 	    Tcl_DictObjPut(NULL, mapDict, fromObj, toObj);
 
 	    if (map[i].proc || map[i].nreProc) {
@@ -1640,7 +1640,7 @@ TclMakeEnsemble(
 			    map[i].nreProc, map[i].clientData, NULL);
 		    Tcl_DStringSetLength(&hiddenBuf, hiddenLen);
 		    if (Tcl_HideCommand(interp, "___tmp",
-			    Tcl_DStringAppend(&hiddenBuf, map[i].name, -1))) {
+			    Tcl_DStringAppend(&hiddenBuf, map[i].name, TCL_INDEX_NONE))) {
 			Tcl_Panic("%s", Tcl_GetStringResult(interp));
 		    }
 		} else {
@@ -1737,7 +1737,7 @@ NsEnsembleImplementationCmdNR(
 	Tcl_DStringInit(&buf);
 	if (ensemblePtr->parameterList) {
 	    Tcl_DStringAppend(&buf,
-		    TclGetString(ensemblePtr->parameterList), -1);
+		    TclGetString(ensemblePtr->parameterList), TCL_INDEX_NONE);
 	    TclDStringAppendLiteral(&buf, " ");
 	}
 	TclDStringAppendLiteral(&buf, "subcommand ?arg ...?");
@@ -1754,7 +1754,7 @@ NsEnsembleImplementationCmdNR(
 
 	if (!Tcl_InterpDeleted(interp)) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "ensemble activated for deleted namespace", -1));
+		    "ensemble activated for deleted namespace", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "DEAD", NULL);
 	}
 	return TCL_ERROR;
@@ -1869,7 +1869,7 @@ NsEnsembleImplementationCmdNR(
 	 * Record the spelling correction for usage message.
 	 */
 
-	fix = Tcl_NewStringObj(fullName, -1);
+	fix = Tcl_NewStringObj(fullName, TCL_INDEX_NONE);
 
 	/*
 	 * Cache for later in the subcommand object.
@@ -1980,12 +1980,12 @@ NsEnsembleImplementationCmdNR(
 	    (ensemblePtr->flags & TCL_ENSEMBLE_PREFIX ? " or ambiguous" : ""),
 	    TclGetString(subObj));
     if (ensemblePtr->subcommandTable.numEntries == 1) {
-	Tcl_AppendToObj(errorObj, ensemblePtr->subcommandArrayPtr[0], -1);
+	Tcl_AppendToObj(errorObj, ensemblePtr->subcommandArrayPtr[0], TCL_INDEX_NONE);
     } else {
 	size_t i;
 
 	for (i=0 ; i<ensemblePtr->subcommandTable.numEntries-1 ; i++) {
-	    Tcl_AppendToObj(errorObj, ensemblePtr->subcommandArrayPtr[i], -1);
+	    Tcl_AppendToObj(errorObj, ensemblePtr->subcommandArrayPtr[i], TCL_INDEX_NONE);
 	    Tcl_AppendToObj(errorObj, ", ", 2);
 	}
 	Tcl_AppendPrintfToObj(errorObj, "or %s",
@@ -2326,7 +2326,7 @@ EnsembleUnknownCallback(
     if ((result == TCL_OK) && (ensemblePtr->flags & ENSEMBLE_DEAD)) {
 	if (!Tcl_InterpDeleted(interp)) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "unknown subcommand handler deleted its ensemble", -1));
+		    "unknown subcommand handler deleted its ensemble", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ENSEMBLE", "UNKNOWN_DELETED",
 		    NULL);
 	}
@@ -2374,16 +2374,16 @@ EnsembleUnknownCallback(
 	if (result != TCL_ERROR) {
 	    Tcl_ResetResult(interp);
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "unknown subcommand handler returned bad code: ", -1));
+		    "unknown subcommand handler returned bad code: ", TCL_INDEX_NONE));
 	    switch (result) {
 	    case TCL_RETURN:
-		Tcl_AppendToObj(Tcl_GetObjResult(interp), "return", -1);
+		Tcl_AppendToObj(Tcl_GetObjResult(interp), "return", TCL_INDEX_NONE);
 		break;
 	    case TCL_BREAK:
-		Tcl_AppendToObj(Tcl_GetObjResult(interp), "break", -1);
+		Tcl_AppendToObj(Tcl_GetObjResult(interp), "break", TCL_INDEX_NONE);
 		break;
 	    case TCL_CONTINUE:
-		Tcl_AppendToObj(Tcl_GetObjResult(interp), "continue", -1);
+		Tcl_AppendToObj(Tcl_GetObjResult(interp), "continue", TCL_INDEX_NONE);
 		break;
 	    default:
 		Tcl_AppendPrintfToObj(Tcl_GetObjResult(interp), "%d", result);
@@ -2625,7 +2625,7 @@ BuildEnsembleConfig(
                 name = TclGetString(subv[i+1]);
                 hPtr = Tcl_CreateHashEntry(hash, name, &isNew);
                 if (isNew) {
-                    cmdObj = Tcl_NewStringObj(name, -1);
+                    cmdObj = Tcl_NewStringObj(name, TCL_INDEX_NONE);
                     cmdPrefixObj = Tcl_NewListObj(1, &cmdObj);
                     Tcl_SetHashValue(hPtr, cmdPrefixObj);
                     Tcl_IncrRefCount(cmdPrefixObj);
@@ -2663,7 +2663,7 @@ BuildEnsembleConfig(
 		 * programmer (or [::unknown] of course) to provide the procedure.
                  */
 
-                cmdObj = Tcl_NewStringObj(name, -1);
+                cmdObj = Tcl_NewStringObj(name, TCL_INDEX_NONE);
                 cmdPrefixObj = Tcl_NewListObj(1, &cmdObj);
                 Tcl_SetHashValue(hPtr, cmdPrefixObj);
                 Tcl_IncrRefCount(cmdPrefixObj);
diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index 4a61d60..64935e6 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -281,7 +281,7 @@ HandleBgErrors(
 		Tcl_DecrRefCount(keyPtr);
 
 		Tcl_WriteChars(errChannel,
-			"error in background error handler:\n", -1);
+			"error in background error handler:\n", TCL_INDEX_NONE);
 		if (valuePtr) {
 		    Tcl_WriteObj(errChannel, valuePtr);
 		} else {
@@ -343,7 +343,7 @@ TclDefaultBgErrorHandlerObjCmd(
     Tcl_DecrRefCount(keyPtr);
     if (result != TCL_OK || valuePtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"missing return option \"-level\"", -1));
+		"missing return option \"-level\"", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING", NULL);
 	return TCL_ERROR;
     }
@@ -356,7 +356,7 @@ TclDefaultBgErrorHandlerObjCmd(
     Tcl_DecrRefCount(keyPtr);
     if (result != TCL_OK || valuePtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"missing return option \"-code\"", -1));
+		"missing return option \"-code\"", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING", NULL);
 	return TCL_ERROR;
     }
@@ -474,17 +474,17 @@ TclDefaultBgErrorHandlerObjCmd(
 		    Tcl_RestoreInterpState(interp, saved);
 		    Tcl_WriteObj(errChannel, Tcl_GetVar2Ex(interp,
 			    "errorInfo", NULL, TCL_GLOBAL_ONLY));
-		    Tcl_WriteChars(errChannel, "\n", -1);
+		    Tcl_WriteChars(errChannel, "\n", TCL_INDEX_NONE);
 		} else {
 		    Tcl_DiscardInterpState(saved);
 		    Tcl_WriteChars(errChannel,
-			    "bgerror failed to handle background error.\n",-1);
-		    Tcl_WriteChars(errChannel, "    Original error: ", -1);
+			    "bgerror failed to handle background error.\n", TCL_INDEX_NONE);
+		    Tcl_WriteChars(errChannel, "    Original error: ", TCL_INDEX_NONE);
 		    Tcl_WriteObj(errChannel, tempObjv[1]);
-		    Tcl_WriteChars(errChannel, "\n", -1);
-		    Tcl_WriteChars(errChannel, "    Error in bgerror: ", -1);
+		    Tcl_WriteChars(errChannel, "\n", TCL_INDEX_NONE);
+		    Tcl_WriteChars(errChannel, "    Error in bgerror: ", TCL_INDEX_NONE);
 		    Tcl_WriteObj(errChannel, resultPtr);
-		    Tcl_WriteChars(errChannel, "\n", -1);
+		    Tcl_WriteChars(errChannel, "\n", TCL_INDEX_NONE);
 		}
 		Tcl_DecrRefCount(resultPtr);
 		Tcl_Flush(errChannel);
@@ -1572,7 +1572,7 @@ Tcl_VwaitObjCmd(
 	    if (timeout < 0) {
 		Tcl_ResetResult(interp);
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"timeout must be positive", -1));
+			"timeout must be positive", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "EVENT", "NEGTIME", NULL);
 		result = TCL_ERROR;
 		goto done;
@@ -1652,7 +1652,7 @@ Tcl_VwaitObjCmd(
     if ((mask & (TCL_FILE_EVENTS | TCL_IDLE_EVENTS |
 		 TCL_TIMER_EVENTS | TCL_WINDOW_EVENTS)) == 0) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"can't wait: would block forever", -1));
+		"can't wait: would block forever", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "EVENT", "NO_SOURCES", NULL);
 	result = TCL_ERROR;
 	goto done;
@@ -1660,7 +1660,7 @@ Tcl_VwaitObjCmd(
 
     if ((timeout > 0) && ((mask & TCL_TIMER_EVENTS) == 0)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"timer events disabled with timeout specified", -1));
+		"timer events disabled with timeout specified", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "EVENT", "NO_TIME", NULL);
 	result = TCL_ERROR;
 	goto done;
@@ -1688,7 +1688,7 @@ Tcl_VwaitObjCmd(
 	for (i = 0; i < numItems; i++) {
 	    if (vwaitItems[i].mask) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"file events disabled with channel(s) specified", -1));
+			"file events disabled with channel(s) specified", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "EVENT", "NO_FILE_EVENT", NULL);
 		result = TCL_ERROR;
 		goto done;
@@ -1727,7 +1727,7 @@ Tcl_VwaitObjCmd(
 	}
 	if (Tcl_LimitExceeded(interp)) {
 	    Tcl_ResetResult(interp);
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj("limit exceeded", -1));
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj("limit exceeded", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "EVENT", "LIMIT", NULL);
 	    break;
 	}
@@ -1975,7 +1975,7 @@ Tcl_UpdateObjCmd(
 	}
 	if (Tcl_LimitExceeded(interp)) {
 	    Tcl_ResetResult(interp);
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj("limit exceeded", -1));
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj("limit exceeded", TCL_INDEX_NONE));
 	    return TCL_ERROR;
 	}
     }
diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index 81ce1a7..97122b9 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -2377,7 +2377,7 @@ TEBCresume(
 	if (!corPtr) {
 	    TRACE_APPEND(("ERROR: yield outside coroutine\n"));
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "yield can only be called in a coroutine", -1));
+		    "yield can only be called in a coroutine", TCL_INDEX_NONE));
 	    DECACHE_STACK_INFO();
 	    Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ILLEGAL_YIELD",
 		    NULL);
@@ -2408,7 +2408,7 @@ TEBCresume(
 	    TRACE(("[%.30s] => ERROR: yield outside coroutine\n",
 		    O2S(valuePtr)));
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "yieldto can only be called in a coroutine", -1));
+		    "yieldto can only be called in a coroutine", TCL_INDEX_NONE));
 	    DECACHE_STACK_INFO();
 	    Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "ILLEGAL_YIELD",
 		    NULL);
@@ -2419,7 +2419,7 @@ TEBCresume(
 	    TRACE(("[%.30s] => ERROR: yield in deleted\n",
 		    O2S(valuePtr)));
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "yieldto called in deleted namespace", -1));
+		    "yieldto called in deleted namespace", TCL_INDEX_NONE));
 	    DECACHE_STACK_INFO();
 	    Tcl_SetErrorCode(interp, "TCL", "COROUTINE", "YIELDTO_IN_DELETED",
 		    NULL);
@@ -2482,7 +2482,7 @@ TEBCresume(
 	if (!(iPtr->varFramePtr->isProcCallFrame & 1)) {
 	    TRACE(("%d => ERROR: tailcall in non-proc context\n", opnd));
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "tailcall can only be called from a proc or lambda", -1));
+		    "tailcall can only be called from a proc or lambda", TCL_INDEX_NONE));
 	    DECACHE_STACK_INFO();
 	    Tcl_SetErrorCode(interp, "TCL", "TAILCALL", "ILLEGAL", NULL);
 	    CACHE_STACK_INFO();
@@ -2511,7 +2511,7 @@ TEBCresume(
 	 */
 
 	listPtr = Tcl_NewListObj(opnd, &OBJ_AT_DEPTH(opnd-1));
-	nsObjPtr = Tcl_NewStringObj(iPtr->varFramePtr->nsPtr->fullName, -1);
+	nsObjPtr = Tcl_NewStringObj(iPtr->varFramePtr->nsPtr->fullName, TCL_INDEX_NONE);
 	TclListObjSetElement(interp, listPtr, 0, nsObjPtr);
 	if (iPtr->varFramePtr->tailcallPtr) {
 	    Tcl_DecrRefCount(iPtr->varFramePtr->tailcallPtr);
@@ -5150,7 +5150,7 @@ TEBCresume(
 	{
 	    int checkEq = ((*pc == INST_EQ) || (*pc == INST_NEQ)
 		    || (*pc == INST_STR_EQ) || (*pc == INST_STR_NEQ));
-	    match = TclStringCmp(valuePtr, value2Ptr, checkEq, 0, -1);
+	    match = TclStringCmp(valuePtr, value2Ptr, checkEq, 0, TCL_INDEX_NONE);
 	}
 
 	/*
@@ -5844,7 +5844,7 @@ TEBCresume(
 	    case INST_RSHIFT:
 		if (w2 < 0) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "negative shift argument", -1));
+			    "negative shift argument", TCL_INDEX_NONE));
 #ifdef ERROR_CODE_FOR_EARLY_DETECTED_ARITH_ERROR
 		    DECACHE_STACK_INFO();
 		    Tcl_SetErrorCode(interp, "ARITH", "DOMAIN",
@@ -5893,7 +5893,7 @@ TEBCresume(
 	    case INST_LSHIFT:
 		if (w2 < 0) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "negative shift argument", -1));
+			    "negative shift argument", TCL_INDEX_NONE));
 #ifdef ERROR_CODE_FOR_EARLY_DETECTED_ARITH_ERROR
 		    DECACHE_STACK_INFO();
 		    Tcl_SetErrorCode(interp, "ARITH", "DOMAIN",
@@ -5916,7 +5916,7 @@ TEBCresume(
 		     */
 
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "integer value too large to represent", -1));
+			    "integer value too large to represent", TCL_INDEX_NONE));
 #ifdef ERROR_CODE_FOR_EARLY_DETECTED_ARITH_ERROR
 		    DECACHE_STACK_INFO();
 		    Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW",
@@ -7422,14 +7422,14 @@ TEBCresume(
 	 */
 
     divideByZero:
-	Tcl_SetObjResult(interp, Tcl_NewStringObj("divide by zero", -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj("divide by zero", TCL_INDEX_NONE));
 	DECACHE_STACK_INFO();
 	Tcl_SetErrorCode(interp, "ARITH", "DIVZERO", "divide by zero", NULL);
 	CACHE_STACK_INFO();
 	goto gotError;
 
     outOfMemory:
-	Tcl_SetObjResult(interp, Tcl_NewStringObj("out of memory", -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj("out of memory", TCL_INDEX_NONE));
 	DECACHE_STACK_INFO();
 	Tcl_SetErrorCode(interp, "ARITH", "OUTOFMEMORY", "out of memory", NULL);
 	CACHE_STACK_INFO();
@@ -7442,7 +7442,7 @@ TEBCresume(
 
     exponOfZero:
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"exponentiation of zero by negative power", -1));
+		"exponentiation of zero by negative power", TCL_INDEX_NONE));
 	DECACHE_STACK_INFO();
 	Tcl_SetErrorCode(interp, "ARITH", "DOMAIN",
 		"exponentiation of zero by negative power", NULL);
@@ -8003,7 +8003,7 @@ ExecuteExtendedBinaryMathOp(
 	}
 	if (invalid) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "negative shift argument", -1));
+		    "negative shift argument", TCL_INDEX_NONE));
 	    return GENERAL_ARITHMETIC_ERROR;
 	}
 
@@ -8034,7 +8034,7 @@ ExecuteExtendedBinaryMathOp(
 		 */
 
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"integer value too large to represent", -1));
+			"integer value too large to represent", TCL_INDEX_NONE));
 		return GENERAL_ARITHMETIC_ERROR;
 	    }
 	    shift = (int)(*((const Tcl_WideInt *)ptr2));
@@ -8282,7 +8282,7 @@ ExecuteExtendedBinaryMathOp(
 
 	if (type2 != TCL_NUMBER_INT) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "exponent too large", -1));
+		    "exponent too large", TCL_INDEX_NONE));
 	    return GENERAL_ARITHMETIC_ERROR;
 	}
 
@@ -8362,7 +8362,7 @@ ExecuteExtendedBinaryMathOp(
 		|| (value2Ptr->typePtr != &tclIntType.objType)
 		|| (Tcl_WideUInt)w2 >= (1<<28)) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "exponent too large", -1));
+		    "exponent too large", TCL_INDEX_NONE));
 	    return GENERAL_ARITHMETIC_ERROR;
 	}
 	Tcl_TakeBignumFromObj(NULL, valuePtr, &big1);
@@ -9369,16 +9369,16 @@ TclExprFloatError(
 
     if ((errno == EDOM) || isnan(value)) {
 	s = "domain error: argument not in valid range";
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(s, -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(s, TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "ARITH", "DOMAIN", s, NULL);
     } else if ((errno == ERANGE) || isinf(value)) {
 	if (value == 0.0) {
 	    s = "floating-point value too small to represent";
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(s, -1));
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(s, TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "ARITH", "UNDERFLOW", s, NULL);
 	} else {
 	    s = "floating-point value too large to represent";
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(s, -1));
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(s, TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "ARITH", "OVERFLOW", s, NULL);
 	}
     } else {
diff --git a/generic/tclFileName.c b/generic/tclFileName.c
index 168355a..2581d37 100644
--- a/generic/tclFileName.c
+++ b/generic/tclFileName.c
@@ -537,7 +537,7 @@ Tcl_SplitPath(
      * Perform the splitting, using objectified, vfs-aware code.
      */
 
-    tmpPtr = Tcl_NewStringObj(path, -1);
+    tmpPtr = Tcl_NewStringObj(path, TCL_INDEX_NONE);
     Tcl_IncrRefCount(tmpPtr);
     resultPtr = Tcl_FSSplitPath(tmpPtr, argcPtr);
     Tcl_IncrRefCount(resultPtr);
@@ -943,7 +943,7 @@ Tcl_JoinPath(
     TclNewObj(listObj);
     for (i = 0; i < argc; i++) {
 	Tcl_ListObjAppendElement(NULL, listObj,
-		Tcl_NewStringObj(argv[i], -1));
+		Tcl_NewStringObj(argv[i], TCL_INDEX_NONE));
     }
 
     /*
@@ -1003,7 +1003,7 @@ Tcl_TranslateFileName(
     Tcl_DString *bufferPtr)	/* Uninitialized or free DString filled with
 				 * name. */
 {
-    Tcl_Obj *path = Tcl_NewStringObj(name, -1);
+    Tcl_Obj *path = Tcl_NewStringObj(name, TCL_INDEX_NONE);
     Tcl_Obj *transPtr;
 
     Tcl_IncrRefCount(path);
@@ -1171,7 +1171,7 @@ Tcl_GlobObjCmd(
 	case GLOB_DIR:				/* -dir */
 	    if (i == (objc-1)) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"missing argument to \"-directory\"", -1));
+			"missing argument to \"-directory\"", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING", NULL);
 		return TCL_ERROR;
 	    }
@@ -1199,7 +1199,7 @@ Tcl_GlobObjCmd(
 	case GLOB_PATH:				/* -path */
 	    if (i == (objc-1)) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"missing argument to \"-path\"", -1));
+			"missing argument to \"-path\"", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING", NULL);
 		return TCL_ERROR;
 	    }
@@ -1220,7 +1220,7 @@ Tcl_GlobObjCmd(
 	case GLOB_TYPE:				/* -types */
 	    if (i == (objc-1)) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"missing argument to \"-types\"", -1));
+			"missing argument to \"-types\"", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "MISSING", NULL);
 		return TCL_ERROR;
 	    }
@@ -1240,7 +1240,7 @@ Tcl_GlobObjCmd(
     if ((globFlags & TCL_GLOBMODE_TAILS) && (pathOrDir == NULL)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"\"-tails\" must be used with either "
-		"\"-directory\" or \"-path\"", -1));
+		"\"-directory\" or \"-path\"", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "GLOB",
 		"BADOPTIONCOMBINATION", NULL);
 	return TCL_ERROR;
@@ -1291,7 +1291,7 @@ Tcl_GlobObjCmd(
 		 * in TclGlob requires a non-NULL pathOrDir.
 		 */
 
-		Tcl_DStringAppend(&pref, first, -1);
+		Tcl_DStringAppend(&pref, first, TCL_INDEX_NONE);
 		globFlags &= ~TCL_GLOBMODE_TAILS;
 		pathOrDir = NULL;
 	    } else {
@@ -1330,7 +1330,7 @@ Tcl_GlobObjCmd(
 		}
 	    }
 	    if (*search != '\0') {
-		Tcl_DStringAppend(&prefix, search, -1);
+		Tcl_DStringAppend(&prefix, search, TCL_INDEX_NONE);
 	    }
 	    Tcl_DStringFree(&pref);
 	}
@@ -1460,7 +1460,7 @@ Tcl_GlobObjCmd(
 	    badMacTypesArg:
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			"only one MacOS type or creator argument"
-			" to \"-types\" allowed", -1));
+			" to \"-types\" allowed", TCL_INDEX_NONE));
 		result = TCL_ERROR;
 		Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "BAD", NULL);
 		join = 0;
@@ -1642,7 +1642,7 @@ TclGlob(
 		|| (tail[0] == '\\' && tail[1] == '\\'))) {
 	    size_t driveNameLen;
 	    Tcl_Obj *driveName;
-	    Tcl_Obj *temp = Tcl_NewStringObj(tail, -1);
+	    Tcl_Obj *temp = Tcl_NewStringObj(tail, TCL_INDEX_NONE);
 	    Tcl_IncrRefCount(temp);
 
 	    switch (TclGetPathType(temp, NULL, &driveNameLen, &driveName)) {
@@ -2033,14 +2033,14 @@ DoGlob(
 		break;
 	    }
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "unmatched open-brace in file name", -1));
+		    "unmatched open-brace in file name", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "GLOB", "BALANCE",
 		    NULL);
 	    return TCL_ERROR;
 
 	} else if (*p == '}') {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "unmatched close-brace in file name", -1));
+		    "unmatched close-brace in file name", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "GLOB", "BALANCE",
 		    NULL);
 	    return TCL_ERROR;
@@ -2072,7 +2072,7 @@ DoGlob(
 	    SkipToChar(&p, ',');
 	    Tcl_DStringSetLength(&newName, baseLength);
 	    Tcl_DStringAppend(&newName, element, p-element);
-	    Tcl_DStringAppend(&newName, closeBrace+1, -1);
+	    Tcl_DStringAppend(&newName, closeBrace+1, TCL_INDEX_NONE);
 	    result = DoGlob(interp, matchesObj, separators, pathPtr, flags,
 		    Tcl_DStringValue(&newName), types);
 	    if (result != TCL_OK) {
diff --git a/generic/tclIOGT.c b/generic/tclIOGT.c
index 868791a..532adbd 100644
--- a/generic/tclIOGT.c
+++ b/generic/tclIOGT.c
@@ -19,25 +19,25 @@
  * the transformation.
  */
 
-static int		TransformBlockModeProc(ClientData instanceData,
+static int		TransformBlockModeProc(void *instanceData,
 			    int mode);
-static int		TransformCloseProc(ClientData instanceData,
+static int		TransformCloseProc(void *instanceData,
 			    Tcl_Interp *interp, int flags);
-static int		TransformInputProc(ClientData instanceData, char *buf,
+static int		TransformInputProc(void *instanceData, char *buf,
 			    int toRead, int *errorCodePtr);
-static int		TransformOutputProc(ClientData instanceData,
+static int		TransformOutputProc(void *instanceData,
 			    const char *buf, int toWrite, int *errorCodePtr);
-static int		TransformSetOptionProc(ClientData instanceData,
+static int		TransformSetOptionProc(void *instanceData,
 			    Tcl_Interp *interp, const char *optionName,
 			    const char *value);
-static int		TransformGetOptionProc(ClientData instanceData,
+static int		TransformGetOptionProc(void *instanceData,
 			    Tcl_Interp *interp, const char *optionName,
 			    Tcl_DString *dsPtr);
-static void		TransformWatchProc(ClientData instanceData, int mask);
-static int		TransformGetFileHandleProc(ClientData instanceData,
-			    int direction, ClientData *handlePtr);
-static int		TransformNotifyProc(ClientData instanceData, int mask);
-static long long	TransformWideSeekProc(ClientData instanceData,
+static void		TransformWatchProc(void *instanceData, int mask);
+static int		TransformGetFileHandleProc(void *instanceData,
+			    int direction, void **handlePtr);
+static int		TransformNotifyProc(void *instanceData, int mask);
+static long long	TransformWideSeekProc(void *instanceData,
 			    long long offset, int mode, int *errorCodePtr);
 
 /*
@@ -45,7 +45,7 @@ static long long	TransformWideSeekProc(ClientData instanceData,
  * handling and generating fileeevents.
  */
 
-static void		TransformChannelHandlerTimer(ClientData clientData);
+static void		TransformChannelHandlerTimer(void *clientData);
 
 /*
  * Forward declarations of internal procedures. Third, helper procedures
@@ -268,7 +268,7 @@ TclChannelTransform(
 
     if (TCL_OK != TclListObjLengthM(interp, cmdObjPtr, &objc)) {
 	Tcl_SetObjResult(interp,
-		Tcl_NewStringObj("-command value is not a list", -1));
+		Tcl_NewStringObj("-command value is not a list", TCL_INDEX_NONE));
 	return TCL_ERROR;
     }
 
@@ -397,7 +397,7 @@ ExecuteCallback(
     }
 
     Tcl_IncrRefCount(command);
-    Tcl_ListObjAppendElement(NULL, command, Tcl_NewStringObj((char *) op, -1));
+    Tcl_ListObjAppendElement(NULL, command, Tcl_NewStringObj((char *) op, TCL_INDEX_NONE));
 
     /*
      * Use a byte-array to prevent the misinterpretation of binary data coming
@@ -510,7 +510,7 @@ ExecuteCallback(
 
 static int
 TransformBlockModeProc(
-    ClientData instanceData,	/* State of transformation. */
+    void *instanceData,	/* State of transformation. */
     int mode)			/* New blocking mode. */
 {
     TransformChannelData *dataPtr = (TransformChannelData *)instanceData;
@@ -542,7 +542,7 @@ TransformBlockModeProc(
 
 static int
 TransformCloseProc(
-    ClientData instanceData,
+    void *instanceData,
     Tcl_Interp *interp,
 	int flags)
 {
@@ -626,7 +626,7 @@ TransformCloseProc(
 
 static int
 TransformInputProc(
-    ClientData instanceData,
+    void *instanceData,
     char *buf,
     int toRead,
     int *errorCodePtr)
@@ -793,7 +793,7 @@ TransformInputProc(
 
 static int
 TransformOutputProc(
-    ClientData instanceData,
+    void *instanceData,
     const char *buf,
     int toWrite,
     int *errorCodePtr)
@@ -845,7 +845,7 @@ TransformOutputProc(
 
 static long long
 TransformWideSeekProc(
-    ClientData instanceData,	/* The channel to manipulate. */
+    void *instanceData,	/* The channel to manipulate. */
     long long offset,		/* Size of movement. */
     int mode,			/* How to move. */
     int *errorCodePtr)		/* Location of error flag. */
@@ -923,7 +923,7 @@ TransformWideSeekProc(
 
 static int
 TransformSetOptionProc(
-    ClientData instanceData,
+    void *instanceData,
     Tcl_Interp *interp,
     const char *optionName,
     const char *value)
@@ -961,7 +961,7 @@ TransformSetOptionProc(
 
 static int
 TransformGetOptionProc(
-    ClientData instanceData,
+    void *instanceData,
     Tcl_Interp *interp,
     const char *optionName,
     Tcl_DString *dsPtr)
@@ -1008,7 +1008,7 @@ TransformGetOptionProc(
 
 static void
 TransformWatchProc(
-    ClientData instanceData,	/* Channel to watch. */
+    void *instanceData,	/* Channel to watch. */
     int mask)			/* Events of interest. */
 {
     TransformChannelData *dataPtr = (TransformChannelData *)instanceData;
@@ -1086,9 +1086,9 @@ TransformWatchProc(
 
 static int
 TransformGetFileHandleProc(
-    ClientData instanceData,	/* Channel to query. */
+    void *instanceData,	/* Channel to query. */
     int direction,		/* Direction of interest. */
-    ClientData *handlePtr)	/* Place to store the handle into. */
+    void **handlePtr)	/* Place to store the handle into. */
 {
     TransformChannelData *dataPtr = (TransformChannelData *)instanceData;
 
@@ -1120,7 +1120,7 @@ TransformGetFileHandleProc(
 
 static int
 TransformNotifyProc(
-    ClientData clientData,	/* The state of the notified
+    void *clientData,	/* The state of the notified
 				 * transformation. */
     int mask)			/* The mask of occuring events. */
 {
@@ -1165,7 +1165,7 @@ TransformNotifyProc(
 
 static void
 TransformChannelHandlerTimer(
-    ClientData clientData)	/* Transformation to query. */
+    void *clientData)	/* Transformation to query. */
 {
     TransformChannelData *dataPtr = (TransformChannelData *)clientData;
 
diff --git a/generic/tclIOSock.c b/generic/tclIOSock.c
index f14c5c1..a925c3d 100644
--- a/generic/tclIOSock.c
+++ b/generic/tclIOSock.c
@@ -317,7 +317,7 @@ Tcl_OpenTcpServer(
     int port,
     const char *host,
     Tcl_TcpAcceptProc *acceptProc,
-    ClientData callbackData)
+    void *callbackData)
 {
     char portbuf[TCL_INTEGER_SPACE];
 
diff --git a/generic/tclIOUtil.c b/generic/tclIOUtil.c
index 470977e..436d364 100644
--- a/generic/tclIOUtil.c
+++ b/generic/tclIOUtil.c
@@ -1756,7 +1756,7 @@ Tcl_FSEvalFileEx(
      * Otherwise, replace them. [Bug 3466099]
      */
 
-    if (Tcl_ReadChars(chan, objPtr, -1,
+    if (Tcl_ReadChars(chan, objPtr, TCL_INDEX_NONE,
 	    memcmp(string, "\xEF\xBB\xBF", 3)) == TCL_IO_FAILURE) {
 	Tcl_CloseEx(interp, chan, 0);
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
@@ -1893,7 +1893,7 @@ TclNREvalFile(
      * Otherwise, replace them. [Bug 3466099]
      */
 
-    if (Tcl_ReadChars(chan, objPtr, -1,
+    if (Tcl_ReadChars(chan, objPtr, TCL_INDEX_NONE,
 	    memcmp(string, "\xEF\xBB\xBF", 3)) == TCL_IO_FAILURE) {
 	Tcl_CloseEx(interp, chan, 0);
 	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
@@ -2459,7 +2459,7 @@ TclFSFileAttrIndex(
 	 * It's a constant attribute table, so use T_GIFO.
 	 */
 
-	Tcl_Obj *tmpObj = Tcl_NewStringObj(attributeName, -1);
+	Tcl_Obj *tmpObj = Tcl_NewStringObj(attributeName, TCL_INDEX_NONE);
 	int result;
 
 	result = Tcl_GetIndexFromObj(NULL, tmpObj, attrTable, NULL, TCL_EXACT,
@@ -3292,7 +3292,7 @@ Tcl_LoadFile(
 	Tcl_DecrRefCount(copyToPtr);
 	if (interp) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "couldn't load from current filesystem", -1));
+		    "couldn't load from current filesystem", TCL_INDEX_NONE));
 	}
 	return TCL_ERROR;
     }
@@ -4612,7 +4612,7 @@ Tcl_FSFileSystemInfo(
 
     resPtr = Tcl_NewListObj(0, NULL);
     Tcl_ListObjAppendElement(NULL, resPtr,
-	    Tcl_NewStringObj(fsPtr->typeName, -1));
+	    Tcl_NewStringObj(fsPtr->typeName, TCL_INDEX_NONE));
 
     if (fsPtr->filesystemPathTypeProc != NULL) {
 	Tcl_Obj *typePtr = fsPtr->filesystemPathTypeProc(pathPtr);
diff --git a/generic/tclIndexObj.c b/generic/tclIndexObj.c
index 58bcc04..66d7f30 100644
--- a/generic/tclIndexObj.c
+++ b/generic/tclIndexObj.c
@@ -533,7 +533,7 @@ PrefixMatchObjCmd(
 	case PRFMATCH_MESSAGE:
 	    if (i > objc-4) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"missing value for -message", -1));
+			"missing value for -message", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "NOARG", NULL);
 		return TCL_ERROR;
 	    }
@@ -543,7 +543,7 @@ PrefixMatchObjCmd(
 	case PRFMATCH_ERROR:
 	    if (i > objc-4) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"missing value for -error", -1));
+			"missing value for -error", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "NOARG", NULL);
 		return TCL_ERROR;
 	    }
@@ -819,9 +819,9 @@ Tcl_WrongNumArgs(
     if (iPtr->flags & INTERP_ALTERNATE_WRONG_ARGS) {
 	iPtr->flags &= ~INTERP_ALTERNATE_WRONG_ARGS;
 	Tcl_AppendObjToObj(objPtr, Tcl_GetObjResult(interp));
-	Tcl_AppendToObj(objPtr, " or \"", -1);
+	Tcl_AppendToObj(objPtr, " or \"", TCL_INDEX_NONE);
     } else {
-	Tcl_AppendToObj(objPtr, "wrong # args: should be \"", -1);
+	Tcl_AppendToObj(objPtr, "wrong # args: should be \"", TCL_INDEX_NONE);
     }
 
     /*
@@ -1289,7 +1289,7 @@ PrintUsage(
      * Now add the option information, with pretty-printing.
      */
 
-    msg = Tcl_NewStringObj("Command-specific options:", -1);
+    msg = Tcl_NewStringObj("Command-specific options:", TCL_INDEX_NONE);
     for (infoPtr = argTable; infoPtr->type != TCL_ARGV_END; infoPtr++) {
 	if ((infoPtr->type == TCL_ARGV_HELP) && (infoPtr->keyStr == NULL)) {
 	    Tcl_AppendPrintfToObj(msg, "\n%s", infoPtr->helpStr);
@@ -1305,7 +1305,7 @@ PrintUsage(
 	    }
 	    numSpaces -= NUM_SPACES;
 	}
-	Tcl_AppendToObj(msg, infoPtr->helpStr, -1);
+	Tcl_AppendToObj(msg, infoPtr->helpStr, TCL_INDEX_NONE);
 	switch (infoPtr->type) {
 	case TCL_ARGV_INT:
 	    Tcl_AppendPrintfToObj(msg, "\n\t\tDefault value: %d",
diff --git a/generic/tclInterp.c b/generic/tclInterp.c
index 416f74e..ecc6e15 100644
--- a/generic/tclInterp.c
+++ b/generic/tclInterp.c
@@ -186,7 +186,7 @@ struct LimitHandler {
     int flags;			/* The state of this particular handler. */
     Tcl_LimitHandlerProc *handlerProc;
 				/* The handler callback. */
-    ClientData clientData;	/* Opaque argument to the handler callback. */
+    void *clientData;	/* Opaque argument to the handler callback. */
     Tcl_LimitHandlerDeleteProc *deleteProc;
 				/* How to delete the clientData. */
     LimitHandler *prevPtr;	/* Previous item in linked list of
@@ -265,12 +265,12 @@ static void		InheritLimitsFromParent(Tcl_Interp *childInterp,
 			    Tcl_Interp *parentInterp);
 static void		SetScriptLimitCallback(Tcl_Interp *interp, int type,
 			    Tcl_Interp *targetInterp, Tcl_Obj *scriptObj);
-static void		CallScriptLimitCallback(ClientData clientData,
+static void		CallScriptLimitCallback(void *clientData,
 			    Tcl_Interp *interp);
-static void		DeleteScriptLimitCallback(ClientData clientData);
+static void		DeleteScriptLimitCallback(void *clientData);
 static void		RunLimitHandlers(LimitHandler *handlerPtr,
 			    Tcl_Interp *interp);
-static void		TimeLimitCallback(ClientData clientData);
+static void		TimeLimitCallback(void *clientData);
 
 /* NRE enabling */
 static Tcl_NRPostProc	NRPostInvokeHidden;
@@ -339,7 +339,7 @@ Tcl_Init(
     pkgName.nextPtr = *names;
     *names = &pkgName;
     if (tclPreInitScript != NULL) {
-	if (Tcl_EvalEx(interp, tclPreInitScript, -1, 0) == TCL_ERROR) {
+	if (Tcl_EvalEx(interp, tclPreInitScript, TCL_INDEX_NONE, 0) == TCL_ERROR) {
 	    goto end;
 	}
     }
@@ -449,7 +449,7 @@ Tcl_Init(
 "    error $msg\n"
 "  }\n"
 "}\n"
-"tclInit", -1, 0);
+"tclInit", TCL_INDEX_NONE, 0);
 
 end:
     *names = (*names)->nextPtr;
@@ -601,7 +601,7 @@ InterpInfoDeleteProc(
 
 int
 Tcl_InterpObjCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,			/* Current interpreter. */
     int objc,				/* Number of arguments. */
     Tcl_Obj *const objv[])		/* Argument objects. */
@@ -837,7 +837,7 @@ NRInterpCmd(
 		    break;
 		}
 	    }
-	    childPtr = Tcl_NewStringObj(buf, -1);
+	    childPtr = Tcl_NewStringObj(buf, TCL_INDEX_NONE);
 	}
 	if (ChildCreate(interp, childPtr, safe) == NULL) {
 	    if (buf[0] != '\0') {
@@ -872,7 +872,7 @@ NRInterpCmd(
 		return TCL_ERROR;
 	    } else if (childInterp == interp) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"cannot delete the current interpreter", -1));
+			"cannot delete the current interpreter", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "INTERP",
 			"DELETESELF", NULL);
 		return TCL_ERROR;
@@ -1053,7 +1053,7 @@ NRInterpCmd(
 	for ( ; hPtr != NULL; hPtr = Tcl_NextHashEntry(&hashSearch)) {
 	    string = (char *)Tcl_GetHashKey(&iiPtr->parent.childTable, hPtr);
 	    Tcl_ListObjAppendElement(NULL, resultPtr,
-		    Tcl_NewStringObj(string, -1));
+		    Tcl_NewStringObj(string, TCL_INDEX_NONE));
 	}
 	Tcl_SetObjResult(interp, resultPtr);
 	return TCL_OK;
@@ -1207,14 +1207,14 @@ Tcl_CreateAlias(
 
     objv = (Tcl_Obj **)TclStackAlloc(childInterp, sizeof(Tcl_Obj *) * argc);
     for (i = 0; i < argc; i++) {
-	objv[i] = Tcl_NewStringObj(argv[i], -1);
+	objv[i] = Tcl_NewStringObj(argv[i], TCL_INDEX_NONE);
 	Tcl_IncrRefCount(objv[i]);
     }
 
-    childObjPtr = Tcl_NewStringObj(childCmd, -1);
+    childObjPtr = Tcl_NewStringObj(childCmd, TCL_INDEX_NONE);
     Tcl_IncrRefCount(childObjPtr);
 
-    targetObjPtr = Tcl_NewStringObj(targetCmd, -1);
+    targetObjPtr = Tcl_NewStringObj(targetCmd, TCL_INDEX_NONE);
     Tcl_IncrRefCount(targetObjPtr);
 
     result = AliasCreate(childInterp, childInterp, targetInterp, childObjPtr,
@@ -1258,10 +1258,10 @@ Tcl_CreateAliasObj(
     Tcl_Obj *childObjPtr, *targetObjPtr;
     int result;
 
-    childObjPtr = Tcl_NewStringObj(childCmd, -1);
+    childObjPtr = Tcl_NewStringObj(childCmd, TCL_INDEX_NONE);
     Tcl_IncrRefCount(childObjPtr);
 
-    targetObjPtr = Tcl_NewStringObj(targetCmd, -1);
+    targetObjPtr = Tcl_NewStringObj(targetCmd, TCL_INDEX_NONE);
     Tcl_IncrRefCount(targetObjPtr);
 
     result = AliasCreate(childInterp, childInterp, targetInterp, childObjPtr,
@@ -1820,7 +1820,7 @@ AliasList(
 
 static int
 AliasNRCmd(
-    ClientData clientData,	/* Alias record. */
+    void *clientData,	/* Alias record. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument vector. */
@@ -1873,7 +1873,7 @@ AliasNRCmd(
 
 int
 TclAliasObjCmd(
-    ClientData clientData,	/* Alias record. */
+    void *clientData,	/* Alias record. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument vector. */
@@ -1964,7 +1964,7 @@ TclAliasObjCmd(
 
 int
 TclLocalAliasObjCmd(
-    ClientData clientData,	/* Alias record. */
+    void *clientData,	/* Alias record. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument vector. */
@@ -2049,7 +2049,7 @@ TclLocalAliasObjCmd(
 
 static void
 AliasObjCmdDeleteProc(
-    ClientData clientData)	/* The alias record for this alias. */
+    void *clientData)	/* The alias record for this alias. */
 {
     Alias *aliasPtr = (Alias *)clientData;
     Target *targetPtr;
@@ -2116,7 +2116,7 @@ Tcl_CreateChild(
     Tcl_Obj *pathPtr;
     Tcl_Interp *childInterp;
 
-    pathPtr = Tcl_NewStringObj(childPath, -1);
+    pathPtr = Tcl_NewStringObj(childPath, TCL_INDEX_NONE);
     childInterp = ChildCreate(interp, pathPtr, isSafe);
     Tcl_DecrRefCount(pathPtr);
 
@@ -2147,7 +2147,7 @@ Tcl_GetChild(
     Tcl_Obj *pathPtr;
     Tcl_Interp *childInterp;
 
-    pathPtr = Tcl_NewStringObj(childPath, -1);
+    pathPtr = Tcl_NewStringObj(childPath, TCL_INDEX_NONE);
     childInterp = GetInterp(interp, pathPtr);
     Tcl_DecrRefCount(pathPtr);
 
@@ -2293,7 +2293,7 @@ Tcl_GetInterpPath(
     }
     Tcl_ListObjAppendElement(NULL, Tcl_GetObjResult(interp),
 	    Tcl_NewStringObj((const char *)Tcl_GetHashKey(&iiPtr->parent.childTable,
-		    iiPtr->child.childEntryPtr), -1));
+		    iiPtr->child.childEntryPtr), TCL_INDEX_NONE));
     return TCL_OK;
 }
 
@@ -2386,7 +2386,7 @@ ChildBgerror(
 	if (TCL_ERROR == TclListObjLengthM(NULL, objv[0], &length)
 		|| (length < 1)) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "cmdPrefix must be list of length >= 1", -1));
+		    "cmdPrefix must be list of length >= 1", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "INTERP",
 		    "BGERRORFORMAT", NULL);
 	    return TCL_ERROR;
@@ -2552,7 +2552,7 @@ ChildCreate(
 
 int
 TclChildObjCmd(
-    ClientData clientData,	/* Child interpreter. */
+    void *clientData,	/* Child interpreter. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
@@ -2562,7 +2562,7 @@ TclChildObjCmd(
 
 static int
 NRChildCmd(
-    ClientData clientData,	/* Child interpreter. */
+    void *clientData,	/* Child interpreter. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
@@ -2766,7 +2766,7 @@ NRChildCmd(
 
 static void
 ChildObjCmdDeleteProc(
-    ClientData clientData)	/* The ChildRecord for the command. */
+    void *clientData)	/* The ChildRecord for the command. */
 {
     Child *childPtr;		/* Interim storage for Child record. */
     Tcl_Interp *childInterp = (Tcl_Interp *)clientData;
@@ -2831,7 +2831,7 @@ ChildDebugCmd(
     if (objc == 0) {
 	TclNewObj(resultPtr);
 	Tcl_ListObjAppendElement(NULL, resultPtr,
-		Tcl_NewStringObj("-frame", -1));
+		Tcl_NewStringObj("-frame", TCL_INDEX_NONE));
 	Tcl_ListObjAppendElement(NULL, resultPtr,
 		Tcl_NewBooleanObj(iPtr->flags & INTERP_DEBUG_FRAME));
 	Tcl_SetObjResult(interp, resultPtr);
@@ -3001,7 +3001,7 @@ ChildRecursionLimit(
     if (objc) {
 	if (Tcl_IsSafe(interp)) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj("permission denied: "
-		    "safe interpreters cannot change recursion limit", -1));
+		    "safe interpreters cannot change recursion limit", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "INTERP", "UNSAFE",
 		    NULL);
 	    return TCL_ERROR;
@@ -3020,7 +3020,7 @@ ChildRecursionLimit(
 	iPtr = (Interp *) childInterp;
 	if (interp == childInterp && iPtr->numLevels > (size_t)limit) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "falling back due to new recursion limit", -1));
+		    "falling back due to new recursion limit", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "RECURSION", NULL);
 	    return TCL_ERROR;
 	}
@@ -3110,7 +3110,7 @@ ChildHidden(
 		hPtr != NULL;
 		hPtr = Tcl_NextHashEntry(&hSearch)) {
 	    Tcl_ListObjAppendElement(NULL, listObjPtr,
-		    Tcl_NewStringObj((const char *)Tcl_GetHashKey(hTblPtr, hPtr), -1));
+		    Tcl_NewStringObj((const char *)Tcl_GetHashKey(hTblPtr, hPtr), TCL_INDEX_NONE));
 	}
     }
     Tcl_SetObjResult(interp, listObjPtr);
@@ -3183,7 +3183,7 @@ ChildInvokeHidden(
 
 static int
 NRPostInvokeHidden(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     int result)
 {
@@ -3299,7 +3299,7 @@ TclMakeSafe(
 	 */
 
 	(void) Tcl_EvalEx(interp,
-		"namespace eval ::tcl {namespace eval mathfunc {}}", -1, 0);
+		"namespace eval ::tcl {namespace eval mathfunc {}}", TCL_INDEX_NONE, 0);
     }
 
     iPtr->flags |= SAFE_INTERP;
@@ -3479,7 +3479,7 @@ Tcl_LimitCheck(
 	    iPtr->limit.exceeded &= ~TCL_LIMIT_COMMANDS;
 	} else if (iPtr->limit.exceeded & TCL_LIMIT_COMMANDS) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "command count limit exceeded", -1));
+		    "command count limit exceeded", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "LIMIT", "COMMANDS", NULL);
 	    Tcl_Release(interp);
 	    return TCL_ERROR;
@@ -3505,7 +3505,7 @@ Tcl_LimitCheck(
 		iPtr->limit.exceeded &= ~TCL_LIMIT_TIME;
 	    } else if (iPtr->limit.exceeded & TCL_LIMIT_TIME) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"time limit exceeded", -1));
+			"time limit exceeded", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "LIMIT", "TIME", NULL);
 		Tcl_Release(interp);
 		return TCL_ERROR;
@@ -3608,7 +3608,7 @@ Tcl_LimitAddHandler(
     Tcl_Interp *interp,
     int type,
     Tcl_LimitHandlerProc *handlerProc,
-    ClientData clientData,
+    void *clientData,
     Tcl_LimitHandlerDeleteProc *deleteProc)
 {
     Interp *iPtr = (Interp *) interp;
@@ -3682,7 +3682,7 @@ Tcl_LimitRemoveHandler(
     Tcl_Interp *interp,
     int type,
     Tcl_LimitHandlerProc *handlerProc,
-    ClientData clientData)
+    void *clientData)
 {
     Interp *iPtr = (Interp *) interp;
     LimitHandler *handlerPtr;
@@ -4081,7 +4081,7 @@ Tcl_LimitSetTime(
 
 static void
 TimeLimitCallback(
-    ClientData clientData)
+    void *clientData)
 {
     Tcl_Interp *interp = (Tcl_Interp *)clientData;
     Interp *iPtr = (Interp *)clientData;
@@ -4225,7 +4225,7 @@ Tcl_LimitGetGranularity(
 
 static void
 DeleteScriptLimitCallback(
-    ClientData clientData)
+    void *clientData)
 {
     ScriptLimitCallback *limitCBPtr = (ScriptLimitCallback *)clientData;
 
@@ -4256,7 +4256,7 @@ DeleteScriptLimitCallback(
 
 static void
 CallScriptLimitCallback(
-    ClientData clientData,
+    void *clientData,
     TCL_UNUSED(Tcl_Interp *))
 {
     ScriptLimitCallback *limitCBPtr = (ScriptLimitCallback *)clientData;
@@ -4508,7 +4508,7 @@ ChildCommandLimitCmd(
 
     if (interp == childInterp) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"limits on current interpreter inaccessible", -1));
+		"limits on current interpreter inaccessible", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "INTERP", "SELF", NULL);
 	return TCL_ERROR;
     }
@@ -4523,7 +4523,7 @@ ChildCommandLimitCmd(
 	if (hPtr != NULL) {
 	    limitCBPtr = (ScriptLimitCallback *)Tcl_GetHashValue(hPtr);
 	    if (limitCBPtr != NULL && limitCBPtr->scriptObj != NULL) {
-		Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[0], -1),
+		Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[0], TCL_INDEX_NONE),
 			limitCBPtr->scriptObj);
 	    } else {
 		goto putEmptyCommandInDict;
@@ -4534,21 +4534,21 @@ ChildCommandLimitCmd(
 	putEmptyCommandInDict:
 	    TclNewObj(empty);
 	    Tcl_DictObjPut(NULL, dictPtr,
-		    Tcl_NewStringObj(options[0], -1), empty);
+		    Tcl_NewStringObj(options[0], TCL_INDEX_NONE), empty);
 	}
-	Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[1], -1),
+	Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[1], TCL_INDEX_NONE),
 		Tcl_NewWideIntObj(Tcl_LimitGetGranularity(childInterp,
 		TCL_LIMIT_COMMANDS)));
 
 	if (Tcl_LimitTypeEnabled(childInterp, TCL_LIMIT_COMMANDS)) {
-	    Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[2], -1),
+	    Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[2], TCL_INDEX_NONE),
 		    Tcl_NewWideIntObj(Tcl_LimitGetCommands(childInterp)));
 	} else {
 	    Tcl_Obj *empty;
 
 	    TclNewObj(empty);
 	    Tcl_DictObjPut(NULL, dictPtr,
-		    Tcl_NewStringObj(options[2], -1), empty);
+		    Tcl_NewStringObj(options[2], TCL_INDEX_NONE), empty);
 	}
 	Tcl_SetObjResult(interp, dictPtr);
 	return TCL_OK;
@@ -4607,7 +4607,7 @@ ChildCommandLimitCmd(
 		}
 		if (gran < 1) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "granularity must be at least 1", -1));
+			    "granularity must be at least 1", TCL_INDEX_NONE));
 		    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "INTERP",
 			    "BADVALUE", NULL);
 		    return TCL_ERROR;
@@ -4624,7 +4624,7 @@ ChildCommandLimitCmd(
 		}
 		if (limit < 0) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "command limit value must be at least 0", -1));
+			    "command limit value must be at least 0", TCL_INDEX_NONE));
 		    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "INTERP",
 			    "BADVALUE", NULL);
 		    return TCL_ERROR;
@@ -4696,7 +4696,7 @@ ChildTimeLimitCmd(
 
     if (interp == childInterp) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"limits on current interpreter inaccessible", -1));
+		"limits on current interpreter inaccessible", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "INTERP", "SELF", NULL);
 	return TCL_ERROR;
     }
@@ -4711,7 +4711,7 @@ ChildTimeLimitCmd(
 	if (hPtr != NULL) {
 	    limitCBPtr = (ScriptLimitCallback *)Tcl_GetHashValue(hPtr);
 	    if (limitCBPtr != NULL && limitCBPtr->scriptObj != NULL) {
-		Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[0], -1),
+		Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[0], TCL_INDEX_NONE),
 			limitCBPtr->scriptObj);
 	    } else {
 		goto putEmptyCommandInDict;
@@ -4721,9 +4721,9 @@ ChildTimeLimitCmd(
 	putEmptyCommandInDict:
 	    TclNewObj(empty);
 	    Tcl_DictObjPut(NULL, dictPtr,
-		    Tcl_NewStringObj(options[0], -1), empty);
+		    Tcl_NewStringObj(options[0], TCL_INDEX_NONE), empty);
 	}
-	Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[1], -1),
+	Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[1], TCL_INDEX_NONE),
 		Tcl_NewWideIntObj(Tcl_LimitGetGranularity(childInterp,
 		TCL_LIMIT_TIME)));
 
@@ -4731,18 +4731,18 @@ ChildTimeLimitCmd(
 	    Tcl_Time limitMoment;
 
 	    Tcl_LimitGetTime(childInterp, &limitMoment);
-	    Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[2], -1),
+	    Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[2], TCL_INDEX_NONE),
 		    Tcl_NewWideIntObj(limitMoment.usec/1000));
-	    Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[3], -1),
+	    Tcl_DictObjPut(NULL, dictPtr, Tcl_NewStringObj(options[3], TCL_INDEX_NONE),
 		    Tcl_NewWideIntObj(limitMoment.sec));
 	} else {
 	    Tcl_Obj *empty;
 
 	    TclNewObj(empty);
 	    Tcl_DictObjPut(NULL, dictPtr,
-		    Tcl_NewStringObj(options[2], -1), empty);
+		    Tcl_NewStringObj(options[2], TCL_INDEX_NONE), empty);
 	    Tcl_DictObjPut(NULL, dictPtr,
-		    Tcl_NewStringObj(options[3], -1), empty);
+		    Tcl_NewStringObj(options[3], TCL_INDEX_NONE), empty);
 	}
 	Tcl_SetObjResult(interp, dictPtr);
 	return TCL_OK;
@@ -4816,7 +4816,7 @@ ChildTimeLimitCmd(
 		}
 		if (gran < 1) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "granularity must be at least 1", -1));
+			    "granularity must be at least 1", TCL_INDEX_NONE));
 		    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "INTERP",
 			    "BADVALUE", NULL);
 		    return TCL_ERROR;
@@ -4870,7 +4870,7 @@ ChildTimeLimitCmd(
 		if (secObj != NULL && secLen == 0 && milliLen > 0) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			    "may only set -milliseconds if -seconds is not "
-			    "also being reset", -1));
+			    "also being reset", TCL_INDEX_NONE));
 		    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "INTERP",
 			    "BADUSAGE", NULL);
 		    return TCL_ERROR;
@@ -4878,7 +4878,7 @@ ChildTimeLimitCmd(
 		if (milliLen == 0 && (secObj == NULL || secLen > 0)) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 			    "may only reset -milliseconds if -seconds is "
-			    "also being reset", -1));
+			    "also being reset", TCL_INDEX_NONE));
 		    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "INTERP",
 			    "BADUSAGE", NULL);
 		    return TCL_ERROR;
diff --git a/generic/tclNamesp.c b/generic/tclNamesp.c
index 65e2a77..924ffd5 100644
--- a/generic/tclNamesp.c
+++ b/generic/tclNamesp.c
@@ -71,26 +71,26 @@ typedef struct {
  * Declarations for functions local to this file:
  */
 
-static void		DeleteImportedCmd(ClientData clientData);
+static void		DeleteImportedCmd(void *clientData);
 static int		DoImport(Tcl_Interp *interp,
 			    Namespace *nsPtr, Tcl_HashEntry *hPtr,
 			    const char *cmdName, const char *pattern,
 			    Namespace *importNsPtr, int allowOverwrite);
 static void		DupNsNameInternalRep(Tcl_Obj *objPtr,Tcl_Obj *copyPtr);
-static char *		ErrorCodeRead(ClientData clientData,Tcl_Interp *interp,
+static char *		ErrorCodeRead(void *clientData,Tcl_Interp *interp,
 			    const char *name1, const char *name2, int flags);
-static char *		ErrorInfoRead(ClientData clientData,Tcl_Interp *interp,
+static char *		ErrorInfoRead(void *clientData,Tcl_Interp *interp,
 			    const char *name1, const char *name2, int flags);
-static char *		EstablishErrorCodeTraces(ClientData clientData,
+static char *		EstablishErrorCodeTraces(void *clientData,
 			    Tcl_Interp *interp, const char *name1,
 			    const char *name2, int flags);
-static char *		EstablishErrorInfoTraces(ClientData clientData,
+static char *		EstablishErrorInfoTraces(void *clientData,
 			    Tcl_Interp *interp, const char *name1,
 			    const char *name2, int flags);
 static void		FreeNsNameInternalRep(Tcl_Obj *objPtr);
 static int		GetNamespaceFromObj(Tcl_Interp *interp,
 			    Tcl_Obj *objPtr, Tcl_Namespace **nsPtrPtr);
-static int		InvokeImportedNRCmd(ClientData clientData,
+static int		InvokeImportedNRCmd(void *clientData,
 			    Tcl_Interp *interp,int objc,Tcl_Obj *const objv[]);
 static Tcl_ObjCmdProc	NamespaceChildrenCmd;
 static Tcl_ObjCmdProc	NamespaceCodeCmd;
@@ -653,7 +653,7 @@ Tcl_CreateNamespace(
     const char *name,		/* Name for the new namespace. May be a
 				 * qualified name with names of ancestor
 				 * namespaces separated by "::"s. */
-    ClientData clientData,	/* One-word value to store with namespace. */
+    void *clientData,	/* One-word value to store with namespace. */
     Tcl_NamespaceDeleteProc *deleteProc)
 				/* Function called to delete client data when
 				 * the namespace is deleted. NULL if no
@@ -698,7 +698,7 @@ Tcl_CreateNamespace(
     if (deleteProc != NULL) {
 	nameStr = name + strlen(name) - 2;
 	if (nameStr >= name && nameStr[1] == ':' && nameStr[0] == ':') {
-	    Tcl_DStringAppend(&tmpBuffer, name, -1);
+	    Tcl_DStringAppend(&tmpBuffer, name, TCL_INDEX_NONE);
 	    while ((nameLen = Tcl_DStringLength(&tmpBuffer)) > 0
 		    && Tcl_DStringValue(&tmpBuffer)[nameLen-1] == ':') {
 		Tcl_DStringSetLength(&tmpBuffer, nameLen-1);
@@ -715,7 +715,7 @@ Tcl_CreateNamespace(
 
     if (*name == '\0') {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj("can't create namespace"
-                " \"\": only global namespace can have empty name", -1));
+                " \"\": only global namespace can have empty name", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "NAMESPACE",
 		"CREATEGLOBAL", NULL);
 	Tcl_DStringFree(&tmpBuffer);
@@ -833,7 +833,7 @@ Tcl_CreateNamespace(
 	    Tcl_DString *tempPtr = namePtr;
 
 	    TclDStringAppendLiteral(buffPtr, "::");
-	    Tcl_DStringAppend(buffPtr, ancestorPtr->name, -1);
+	    Tcl_DStringAppend(buffPtr, ancestorPtr->name, TCL_INDEX_NONE);
 	    TclDStringAppendDString(buffPtr, namePtr);
 
 	    /*
@@ -1542,7 +1542,7 @@ Tcl_AppendExportList(
 
     for (i = 0;  i < nsPtr->numExportPatterns;  i++) {
 	result = Tcl_ListObjAppendElement(interp, objPtr,
-		Tcl_NewStringObj(nsPtr->exportArrayPtr[i], -1));
+		Tcl_NewStringObj(nsPtr->exportArrayPtr[i], TCL_INDEX_NONE));
 	if (result != TCL_OK) {
 	    return result;
 	}
@@ -1621,7 +1621,7 @@ Tcl_Import(
 	int result;
 
 	TclNewLiteralStringObj(objv[0], "auto_import");
-	objv[1] = Tcl_NewStringObj(pattern, -1);
+	objv[1] = Tcl_NewStringObj(pattern, TCL_INDEX_NONE);
 
 	Tcl_IncrRefCount(objv[0]);
 	Tcl_IncrRefCount(objv[1]);
@@ -1762,11 +1762,11 @@ DoImport(
 	ImportRef *refPtr;
 
 	Tcl_DStringInit(&ds);
-	Tcl_DStringAppend(&ds, nsPtr->fullName, -1);
+	Tcl_DStringAppend(&ds, nsPtr->fullName, TCL_INDEX_NONE);
 	if (nsPtr != ((Interp *) interp)->globalNsPtr) {
 	    TclDStringAppendLiteral(&ds, "::");
 	}
-	Tcl_DStringAppend(&ds, cmdName, -1);
+	Tcl_DStringAppend(&ds, cmdName, TCL_INDEX_NONE);
 
 	/*
 	 * Check whether creating the new imported command in the current
@@ -2036,7 +2036,7 @@ TclGetOriginalCommand(
 
 static int
 InvokeImportedNRCmd(
-    ClientData clientData,	/* Points to the imported command's
+    void *clientData,	/* Points to the imported command's
 				 * ImportedCmdData structure. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
@@ -2051,7 +2051,7 @@ InvokeImportedNRCmd(
 
 int
 TclInvokeImportedCmd(
-    ClientData clientData,	/* Points to the imported command's
+    void *clientData,	/* Points to the imported command's
 				 * ImportedCmdData structure. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
@@ -2084,7 +2084,7 @@ TclInvokeImportedCmd(
 
 static void
 DeleteImportedCmd(
-    ClientData clientData)	/* Points to the imported command's
+    void *clientData)	/* Points to the imported command's
 				 * ImportedCmdData structure. */
 {
     ImportedCmdData *dataPtr = (ImportedCmdData *)clientData;
@@ -3049,11 +3049,11 @@ NamespaceChildrenCmd(
 	if ((*name == ':') && (*(name+1) == ':')) {
 	    pattern = name;
 	} else {
-	    Tcl_DStringAppend(&buffer, nsPtr->fullName, -1);
+	    Tcl_DStringAppend(&buffer, nsPtr->fullName, TCL_INDEX_NONE);
 	    if (nsPtr != globalNsPtr) {
 		TclDStringAppendLiteral(&buffer, "::");
 	    }
-	    Tcl_DStringAppend(&buffer, name, -1);
+	    Tcl_DStringAppend(&buffer, name, TCL_INDEX_NONE);
 	    pattern = Tcl_DStringValue(&buffer);
 	}
     }
@@ -3079,7 +3079,7 @@ NamespaceChildrenCmd(
 #endif
 	) {
 	    Tcl_ListObjAppendElement(interp, listPtr,
-		    Tcl_NewStringObj(pattern, -1));
+		    Tcl_NewStringObj(pattern, TCL_INDEX_NONE));
 	}
 	goto searchDone;
     }
@@ -3095,7 +3095,7 @@ NamespaceChildrenCmd(
 	childNsPtr = (Namespace *)Tcl_GetHashValue(entryPtr);
 	if ((pattern == NULL)
 		|| Tcl_StringMatch(childNsPtr->fullName, pattern)) {
-	    elemPtr = Tcl_NewStringObj(childNsPtr->fullName, -1);
+	    elemPtr = Tcl_NewStringObj(childNsPtr->fullName, TCL_INDEX_NONE);
 	    Tcl_ListObjAppendElement(interp, listPtr, elemPtr);
 	}
 	entryPtr = Tcl_NextHashEntry(&search);
@@ -3185,7 +3185,7 @@ NamespaceCodeCmd(
     if (currNsPtr == (Namespace *) TclGetGlobalNamespace(interp)) {
 	TclNewLiteralStringObj(objPtr, "::");
     } else {
-	objPtr = Tcl_NewStringObj(currNsPtr->fullName, -1);
+	objPtr = Tcl_NewStringObj(currNsPtr->fullName, TCL_INDEX_NONE);
     }
     Tcl_ListObjAppendElement(interp, listPtr, objPtr);
 
@@ -3243,7 +3243,7 @@ NamespaceCurrentCmd(
     if (currNsPtr == (Namespace *) TclGetGlobalNamespace(interp)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj("::", 2));
     } else {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(currNsPtr->fullName, -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(currNsPtr->fullName, TCL_INDEX_NONE));
     }
     return TCL_OK;
 }
@@ -3358,7 +3358,7 @@ NamespaceDeleteCmd(
 
 static int
 NamespaceEvalCmd(
-    ClientData clientData,	/* Arbitrary value passed to cmd. */
+    void *clientData,	/* Arbitrary value passed to cmd. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
@@ -3451,7 +3451,7 @@ NRNamespaceEvalCmd(
 
 static int
 NsEval_Callback(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     int result)
 {
@@ -3807,7 +3807,7 @@ NamespaceImportCmd(
 
 static int
 NamespaceInscopeCmd(
-    ClientData clientData,	/* Arbitrary value passed to cmd. */
+    void *clientData,	/* Arbitrary value passed to cmd. */
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
@@ -3999,7 +3999,7 @@ NamespaceParentCmd(
 
     if (nsPtr->parentPtr != NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		nsPtr->parentPtr->fullName, -1));
+		nsPtr->parentPtr->fullName, TCL_INDEX_NONE));
     }
     return TCL_OK;
 }
@@ -4060,7 +4060,7 @@ NamespacePathCmd(
 	for (i=0 ; i<nsPtr->commandPathLength ; i++) {
 	    if (nsPtr->commandPathArray[i].nsPtr != NULL) {
 		Tcl_ListObjAppendElement(NULL, resultObj, Tcl_NewStringObj(
-			nsPtr->commandPathArray[i].nsPtr->fullName, -1));
+			nsPtr->commandPathArray[i].nsPtr->fullName, TCL_INDEX_NONE));
 	    }
 	}
 	Tcl_SetObjResult(interp, resultObj);
@@ -4544,7 +4544,7 @@ NamespaceTailCmd(
     }
 
     if (p >= name) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(p, -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(p, TCL_INDEX_NONE));
     }
     return TCL_OK;
 }
diff --git a/generic/tclOO.c b/generic/tclOO.c
index 0d9c7da..bee06e2 100644
--- a/generic/tclOO.c
+++ b/generic/tclOO.c
@@ -67,9 +67,9 @@ static int		CloneClassMethod(Tcl_Interp *interp, Class *clsPtr,
 			    Method **newMPtrPtr);
 static int		CloneObjectMethod(Tcl_Interp *interp, Object *oPtr,
 			    Method *mPtr, Tcl_Obj *namePtr);
-static void		DeletedDefineNamespace(ClientData clientData);
-static void		DeletedObjdefNamespace(ClientData clientData);
-static void		DeletedHelpersNamespace(ClientData clientData);
+static void		DeletedDefineNamespace(void *clientData);
+static void		DeletedObjdefNamespace(void *clientData);
+static void		DeletedHelpersNamespace(void *clientData);
 static Tcl_NRPostProc	FinalizeAlloc;
 static Tcl_NRPostProc	FinalizeNext;
 static Tcl_NRPostProc	FinalizeObjectCall;
@@ -78,23 +78,23 @@ static void		InitClassSystemRoots(Tcl_Interp *interp,
 			    Foundation *fPtr);
 static int		InitFoundation(Tcl_Interp *interp);
 static Tcl_InterpDeleteProc	KillFoundation;
-static void		MyDeleted(ClientData clientData);
-static void		ObjectNamespaceDeleted(ClientData clientData);
+static void		MyDeleted(void *clientData);
+static void		ObjectNamespaceDeleted(void *clientData);
 static Tcl_CommandTraceProc	ObjectRenamedTrace;
-static inline void	RemoveClass(Class **list, int num, int idx);
-static inline void	RemoveObject(Object **list, int num, int idx);
+static inline void	RemoveClass(Class **list, size_t num, size_t idx);
+static inline void	RemoveObject(Object **list, size_t num, size_t idx);
 static inline void	SquelchCachedName(Object *oPtr);
 
-static int		PublicNRObjectCmd(ClientData clientData,
+static int		PublicNRObjectCmd(void *clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const *objv);
-static int		PrivateNRObjectCmd(ClientData clientData,
+static int		PrivateNRObjectCmd(void *clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const *objv);
-static int		MyClassNRObjCmd(ClientData clientData,
+static int		MyClassNRObjCmd(void *clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const *objv);
-static void		MyClassDeleted(ClientData clientData);
+static void		MyClassDeleted(void *clientData);
 
 /*
  * Methods in the oo::object and oo::class classes. First, we define a helper
@@ -201,10 +201,10 @@ MODULE_SCOPE const TclOOStubs tclOOStubs;
 static inline void
 RemoveClass(
     Class **list,
-    int num,
-    int idx)
+    size_t num,
+    size_t idx)
 {
-    for (; idx < num - 1; idx++) {
+    for (; idx + 1 < num; idx++) {
 	list[idx] = list[idx + 1];
     }
     list[idx] = NULL;
@@ -213,10 +213,10 @@ RemoveClass(
 static inline void
 RemoveObject(
     Object **list,
-    int num,
-    int idx)
+    size_t num,
+    size_t idx)
 {
-    for (; idx < num - 1; idx++) {
+    for (; idx + 1 < num; idx++) {
 	list[idx] = list[idx + 1];
     }
     list[idx] = NULL;
@@ -256,7 +256,7 @@ TclOOInit(
      * to be fully provided.
      */
 
-    if (Tcl_EvalEx(interp, initScript, -1, 0) != TCL_OK) {
+    if (Tcl_EvalEx(interp, initScript, TCL_INDEX_NONE, 0) != TCL_OK) {
 	return TCL_ERROR;
     }
 
@@ -352,14 +352,14 @@ InitFoundation(
     Tcl_DStringInit(&buffer);
     for (i = 0 ; defineCmds[i].name ; i++) {
 	TclDStringAppendLiteral(&buffer, "::oo::define::");
-	Tcl_DStringAppend(&buffer, defineCmds[i].name, -1);
+	Tcl_DStringAppend(&buffer, defineCmds[i].name, TCL_INDEX_NONE);
 	Tcl_CreateObjCommand(interp, Tcl_DStringValue(&buffer),
 		defineCmds[i].objProc, INT2PTR(defineCmds[i].flag), NULL);
 	Tcl_DStringFree(&buffer);
     }
     for (i = 0 ; objdefCmds[i].name ; i++) {
 	TclDStringAppendLiteral(&buffer, "::oo::objdefine::");
-	Tcl_DStringAppend(&buffer, objdefCmds[i].name, -1);
+	Tcl_DStringAppend(&buffer, objdefCmds[i].name, TCL_INDEX_NONE);
 	Tcl_CreateObjCommand(interp, Tcl_DStringValue(&buffer),
 		objdefCmds[i].objProc, INT2PTR(objdefCmds[i].flag), NULL);
 	Tcl_DStringFree(&buffer);
@@ -429,7 +429,7 @@ InitFoundation(
      * Evaluate the remaining definitions, which are a compiled-in Tcl script.
      */
 
-    return Tcl_EvalEx(interp, tclOOSetupScript, -1, 0);
+    return Tcl_EvalEx(interp, tclOOSetupScript, TCL_INDEX_NONE, 0);
 }
 
 /*
@@ -535,7 +535,7 @@ InitClassSystemRoots(
 
 static void
 DeletedDefineNamespace(
-    ClientData clientData)
+    void *clientData)
 {
     Foundation *fPtr = (Foundation *)clientData;
 
@@ -544,7 +544,7 @@ DeletedDefineNamespace(
 
 static void
 DeletedObjdefNamespace(
-    ClientData clientData)
+    void *clientData)
 {
     Foundation *fPtr = (Foundation *)clientData;
 
@@ -553,7 +553,7 @@ DeletedObjdefNamespace(
 
 static void
 DeletedHelpersNamespace(
-    ClientData clientData)
+    void *clientData)
 {
     Foundation *fPtr = (Foundation *)clientData;
 
@@ -789,7 +789,7 @@ SquelchCachedName(
 
 static void
 MyDeleted(
-    ClientData clientData)	/* Reference to the object whose [my] has been
+    void *clientData)	/* Reference to the object whose [my] has been
 				 * squelched. */
 {
     Object *oPtr = (Object *)clientData;
@@ -799,7 +799,7 @@ MyDeleted(
 
 static void
 MyClassDeleted(
-    ClientData clientData)
+    void *clientData)
 {
     Object *oPtr = (Object *)clientData;
     oPtr->myclassCommand = NULL;
@@ -820,7 +820,7 @@ MyClassDeleted(
 
 static void
 ObjectRenamedTrace(
-    ClientData clientData,	/* The object being deleted. */
+    void *clientData,	/* The object being deleted. */
     TCL_UNUSED(Tcl_Interp *),
     TCL_UNUSED(const char *) /*oldName*/,
     TCL_UNUSED(const char *) /*newName*/,
@@ -1038,7 +1038,7 @@ TclOOReleaseClassContents(
 
     if (clsPtr->metadataPtr != NULL) {
 	Tcl_ObjectMetadataType *metadataTypePtr;
-	ClientData value;
+	void *value;
 
 	FOREACH_HASH(metadataTypePtr, value, clsPtr->metadataPtr) {
 	    metadataTypePtr->deleteProc(value);
@@ -1110,7 +1110,7 @@ TclOOReleaseClassContents(
 
 static void
 ObjectNamespaceDeleted(
-    ClientData clientData)	/* Pointer to the class whose namespace is
+    void *clientData)	/* Pointer to the class whose namespace is
 				 * being deleted. */
 {
     Object *oPtr = (Object *)clientData;
@@ -1261,7 +1261,7 @@ ObjectNamespaceDeleted(
 
     if (oPtr->metadataPtr != NULL) {
 	Tcl_ObjectMetadataType *metadataTypePtr;
-	ClientData value;
+	void *value;
 
 	FOREACH_HASH(metadataTypePtr, value, oPtr->metadataPtr) {
 	    metadataTypePtr->deleteProc(value);
@@ -1675,7 +1675,7 @@ Tcl_NewObjectInstance(
 {
     Class *classPtr = (Class *) cls;
     Object *oPtr;
-    ClientData clientData[4];
+    void *clientData[4];
 
     oPtr = TclNewObjectInstanceCommon(interp, classPtr, nameStr, nsNameStr);
     if (oPtr == NULL) {
@@ -1854,7 +1854,7 @@ TclNewObjectInstanceCommon(
 
 static int
 FinalizeAlloc(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     int result)
 {
@@ -1870,7 +1870,7 @@ FinalizeAlloc(
 
     if (result != TCL_ERROR && Destructing(oPtr)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"object deleted in constructor", -1));
+		"object deleted in constructor", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "STILLBORN", NULL);
 	result = TCL_ERROR;
     }
@@ -1941,7 +1941,7 @@ Tcl_CopyObjectInstance(
 
     if (IsRootClass(oPtr)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"may not clone the class of classes", -1));
+		"may not clone the class of classes", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "CLONING_CLASS", NULL);
 	return NULL;
     }
@@ -1951,8 +1951,8 @@ Tcl_CopyObjectInstance(
      */
 
     o2Ptr = (Object *) Tcl_NewObjectInstance(interp,
-	    (Tcl_Class) oPtr->selfCls, targetName, targetNamespaceName, -1,
-	    NULL, -1);
+	    (Tcl_Class) oPtr->selfCls, targetName, targetNamespaceName, TCL_INDEX_NONE,
+	    NULL, TCL_INDEX_NONE);
     if (o2Ptr == NULL) {
 	return NULL;
     }
@@ -2037,7 +2037,7 @@ Tcl_CopyObjectInstance(
 
     if (oPtr->metadataPtr != NULL) {
 	Tcl_ObjectMetadataType *metadataTypePtr;
-	ClientData value, duplicate;
+	void *value, *duplicate;
 
 	FOREACH_HASH(metadataTypePtr, value, oPtr->metadataPtr) {
 	    if (metadataTypePtr->cloneProc == NULL) {
@@ -2182,7 +2182,7 @@ Tcl_CopyObjectInstance(
 
 	if (clsPtr->metadataPtr != NULL) {
 	    Tcl_ObjectMetadataType *metadataTypePtr;
-	    ClientData value, duplicate;
+	    void *value, *duplicate;
 
 	    FOREACH_HASH(metadataTypePtr, value, clsPtr->metadataPtr) {
 		if (metadataTypePtr->cloneProc == NULL) {
@@ -2254,7 +2254,7 @@ CloneObjectMethod(
 	TclNewInstanceMethod(interp, (Tcl_Object) oPtr, namePtr,
 		mPtr->flags & PUBLIC_METHOD, NULL, NULL);
     } else if (mPtr->typePtr->cloneProc) {
-	ClientData newClientData;
+	void *newClientData;
 
 	if (mPtr->typePtr->cloneProc(interp, mPtr->clientData,
 		&newClientData) != TCL_OK) {
@@ -2283,7 +2283,7 @@ CloneClassMethod(
 	m2Ptr = (Method *) TclNewMethod(interp, (Tcl_Class) clsPtr,
 		namePtr, mPtr->flags & PUBLIC_METHOD, NULL, NULL);
     } else if (mPtr->typePtr->cloneProc) {
-	ClientData newClientData;
+	void *newClientData;
 
 	if (mPtr->typePtr->cloneProc(interp, mPtr->clientData,
 		&newClientData) != TCL_OK) {
@@ -2329,7 +2329,7 @@ CloneClassMethod(
  * ----------------------------------------------------------------------
  */
 
-ClientData
+void *
 Tcl_ClassGetMetadata(
     Tcl_Class clazz,
     const Tcl_ObjectMetadataType *typePtr)
@@ -2366,7 +2366,7 @@ void
 Tcl_ClassSetMetadata(
     Tcl_Class clazz,
     const Tcl_ObjectMetadataType *typePtr,
-    ClientData metadata)
+    void *metadata)
 {
     Class *clsPtr = (Class *) clazz;
     Tcl_HashEntry *hPtr;
@@ -2409,7 +2409,7 @@ Tcl_ClassSetMetadata(
     Tcl_SetHashValue(hPtr, metadata);
 }
 
-ClientData
+void *
 Tcl_ObjectGetMetadata(
     Tcl_Object object,
     const Tcl_ObjectMetadataType *typePtr)
@@ -2446,7 +2446,7 @@ void
 Tcl_ObjectSetMetadata(
     Tcl_Object object,
     const Tcl_ObjectMetadataType *typePtr,
-    ClientData metadata)
+    void *metadata)
 {
     Object *oPtr = (Object *) object;
     Tcl_HashEntry *hPtr;
@@ -2504,7 +2504,7 @@ Tcl_ObjectSetMetadata(
 
 int
 TclOOPublicObjectCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2514,7 +2514,7 @@ TclOOPublicObjectCmd(
 
 static int
 PublicNRObjectCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2525,7 +2525,7 @@ PublicNRObjectCmd(
 
 int
 TclOOPrivateObjectCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2535,7 +2535,7 @@ TclOOPrivateObjectCmd(
 
 static int
 PrivateNRObjectCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2586,7 +2586,7 @@ TclOOInvokeObject(
 
 int
 TclOOMyClassObjCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2596,7 +2596,7 @@ TclOOMyClassObjCmd(
 
 static int
 MyClassNRObjCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2749,7 +2749,7 @@ TclOOObjectCmdCore(
 	}
 	if (contextPtr->index >= contextPtr->callPtr->numChain) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "no valid method implementation", -1));
+		    "no valid method implementation", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "METHOD",
 		    TclGetString(methodNamePtr), NULL);
 	    TclOODeleteContext(contextPtr);
@@ -2768,7 +2768,7 @@ TclOOObjectCmdCore(
 
 static int
 FinalizeObjectCall(
-    ClientData data[],
+    void *data[],
     TCL_UNUSED(Tcl_Interp *),
     int result)
 {
@@ -2929,7 +2929,7 @@ TclNRObjectContextInvokeNext(
 
 static int
 FinalizeNext(
-    ClientData data[],
+    void *data[],
     TCL_UNUSED(Tcl_Interp *),
     int result)
 {
diff --git a/generic/tclOOBasic.c b/generic/tclOOBasic.c
index ef554d7..d8ef59b 100644
--- a/generic/tclOOBasic.c
+++ b/generic/tclOOBasic.c
@@ -99,10 +99,10 @@ TclOO_Class_Constructor(
      * here (and the class definition delegate doesn't run any constructors).
      */
 
-    nameObj = Tcl_NewStringObj(oPtr->namespacePtr->fullName, -1);
-    Tcl_AppendToObj(nameObj, ":: oo ::delegate", -1);
+    nameObj = Tcl_NewStringObj(oPtr->namespacePtr->fullName, TCL_INDEX_NONE);
+    Tcl_AppendToObj(nameObj, ":: oo ::delegate", TCL_INDEX_NONE);
     Tcl_NewObjectInstance(interp, (Tcl_Class) oPtr->fPtr->classCls,
-	    TclGetString(nameObj), NULL, -1, NULL, -1);
+	    TclGetString(nameObj), NULL, TCL_INDEX_NONE, NULL, TCL_INDEX_NONE);
     Tcl_DecrRefCount(nameObj);
 
     /*
@@ -147,7 +147,7 @@ DecrRefsPostClassConstructor(
     TclDecrRefCount(invoke[0]);
     TclDecrRefCount(invoke[1]);
     TclDecrRefCount(invoke[2]);
-    invoke[0] = Tcl_NewStringObj("::oo::MixinClassDelegates", -1);
+    invoke[0] = Tcl_NewStringObj("::oo::MixinClassDelegates", TCL_INDEX_NONE);
     invoke[1] = TclOOObjectName(interp, oPtr);
     Tcl_IncrRefCount(invoke[0]);
     Tcl_IncrRefCount(invoke[1]);
@@ -213,7 +213,7 @@ TclOO_Class_Create(
 	    objv[Tcl_ObjectContextSkippedArgs(context)], &len);
     if (len == 0) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"object name must not be empty", -1));
+		"object name must not be empty", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "EMPTY_NAME", NULL);
 	return TCL_ERROR;
     }
@@ -278,7 +278,7 @@ TclOO_Class_CreateNs(
 	    objv[Tcl_ObjectContextSkippedArgs(context)], &len);
     if (len == 0) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"object name must not be empty", -1));
+		"object name must not be empty", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "EMPTY_NAME", NULL);
 	return TCL_ERROR;
     }
@@ -286,7 +286,7 @@ TclOO_Class_CreateNs(
 	    objv[Tcl_ObjectContextSkippedArgs(context)+1], &len);
     if (len == 0) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"namespace name must not be empty", -1));
+		"namespace name must not be empty", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "EMPTY_NAME", NULL);
 	return TCL_ERROR;
     }
@@ -598,14 +598,14 @@ TclOO_Object_Unknown(
 	    TclGetString(objv[skip]));
     for (i=0 ; i<numMethodNames-1 ; i++) {
 	if (i) {
-	    Tcl_AppendToObj(errorMsg, ", ", -1);
+	    Tcl_AppendToObj(errorMsg, ", ", TCL_INDEX_NONE);
 	}
-	Tcl_AppendToObj(errorMsg, methodNames[i], -1);
+	Tcl_AppendToObj(errorMsg, methodNames[i], TCL_INDEX_NONE);
     }
     if (i) {
-	Tcl_AppendToObj(errorMsg, " or ", -1);
+	Tcl_AppendToObj(errorMsg, " or ", TCL_INDEX_NONE);
     }
-    Tcl_AppendToObj(errorMsg, methodNames[i], -1);
+    Tcl_AppendToObj(errorMsg, methodNames[i], TCL_INDEX_NONE);
     Tcl_Free((void *)methodNames);
     Tcl_SetObjResult(interp, errorMsg);
     Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "METHOD",
@@ -814,7 +814,7 @@ TclOO_Object_VarName(
 	    }
 	}
 
-	varNamePtr = Tcl_NewStringObj(namespacePtr->fullName, -1);
+	varNamePtr = Tcl_NewStringObj(namespacePtr->fullName, TCL_INDEX_NONE);
 	Tcl_AppendToObj(varNamePtr, "::", 2);
 	Tcl_AppendObjToObj(varNamePtr, argPtr);
     }
@@ -840,10 +840,10 @@ TclOO_Object_VarName(
 	 * WARNING! This code pokes inside the implementation of hash tables!
 	 */
 
-	Tcl_AppendToObj(varNamePtr, "(", -1);
+	Tcl_AppendToObj(varNamePtr, "(", TCL_INDEX_NONE);
 	Tcl_AppendObjToObj(varNamePtr, ((VarInHash *)
 		varPtr)->entry.key.objPtr);
-	Tcl_AppendToObj(varNamePtr, ")", -1);
+	Tcl_AppendToObj(varNamePtr, ")", TCL_INDEX_NONE);
     } else {
 	Tcl_GetVariableFullName(interp, (Tcl_Var) varPtr, varNamePtr);
     }
@@ -1097,7 +1097,7 @@ TclOOSelfObjCmd(
 
 	if (clsPtr == NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "method not defined by a class", -1));
+		    "method not defined by a class", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OO", "UNMATCHED_CONTEXT", NULL);
 	    return TCL_ERROR;
 	}
@@ -1118,7 +1118,7 @@ TclOOSelfObjCmd(
     case SELF_FILTER:
 	if (!CurrentlyInvoked(contextPtr).isFilter) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "not inside a filtering context", -1));
+		    "not inside a filtering context", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OO", "UNMATCHED_CONTEXT", NULL);
 	    return TCL_ERROR;
 	} else {
@@ -1135,7 +1135,7 @@ TclOOSelfObjCmd(
 	    }
 
 	    result[0] = TclOOObjectName(interp, oPtr);
-	    result[1] = Tcl_NewStringObj(type, -1);
+	    result[1] = Tcl_NewStringObj(type, TCL_INDEX_NONE);
 	    result[2] = miPtr->mPtr->namePtr;
 	    Tcl_SetObjResult(interp, Tcl_NewListObj(3, result));
 	    return TCL_OK;
@@ -1144,7 +1144,7 @@ TclOOSelfObjCmd(
 	if ((framePtr->callerVarPtr == NULL) ||
 		!(framePtr->callerVarPtr->isProcCallFrame & FRAME_IS_METHOD)){
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "caller is not an object", -1));
+		    "caller is not an object", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OO", "CONTEXT_REQUIRED", NULL);
 	    return TCL_ERROR;
 	} else {
@@ -1162,7 +1162,7 @@ TclOOSelfObjCmd(
 		 */
 
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"method without declarer!", -1));
+			"method without declarer!", TCL_INDEX_NONE));
 		return TCL_ERROR;
 	    }
 
@@ -1194,7 +1194,7 @@ TclOOSelfObjCmd(
 		 */
 
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"method without declarer!", -1));
+			"method without declarer!", TCL_INDEX_NONE));
 		return TCL_ERROR;
 	    }
 
@@ -1212,7 +1212,7 @@ TclOOSelfObjCmd(
     case SELF_TARGET:
 	if (!CurrentlyInvoked(contextPtr).isFilter) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "not inside a filtering context", -1));
+		    "not inside a filtering context", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OO", "UNMATCHED_CONTEXT", NULL);
 	    return TCL_ERROR;
 	} else {
@@ -1239,7 +1239,7 @@ TclOOSelfObjCmd(
 		 */
 
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"method without declarer!", -1));
+			"method without declarer!", TCL_INDEX_NONE));
 		return TCL_ERROR;
 	    }
 	    result[0] = TclOOObjectName(interp, declarerPtr);
diff --git a/generic/tclOODefineCmds.c b/generic/tclOODefineCmds.c
index 63aca58..796a22f 100644
--- a/generic/tclOODefineCmds.c
+++ b/generic/tclOODefineCmds.c
@@ -78,49 +78,49 @@ static inline void	RecomputeClassCacheFlag(Object *oPtr);
 static int		RenameDeleteMethod(Tcl_Interp *interp, Object *oPtr,
 			    int useClass, Tcl_Obj *const fromPtr,
 			    Tcl_Obj *const toPtr);
-static int		ClassFilterGet(ClientData clientData,
+static int		ClassFilterGet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ClassFilterSet(ClientData clientData,
+static int		ClassFilterSet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ClassMixinGet(ClientData clientData,
+static int		ClassMixinGet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ClassMixinSet(ClientData clientData,
+static int		ClassMixinSet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ClassSuperGet(ClientData clientData,
+static int		ClassSuperGet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ClassSuperSet(ClientData clientData,
+static int		ClassSuperSet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ClassVarsGet(ClientData clientData,
+static int		ClassVarsGet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ClassVarsSet(ClientData clientData,
+static int		ClassVarsSet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ObjFilterGet(ClientData clientData,
+static int		ObjFilterGet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ObjFilterSet(ClientData clientData,
+static int		ObjFilterSet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ObjMixinGet(ClientData clientData,
+static int		ObjMixinGet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ObjMixinSet(ClientData clientData,
+static int		ObjMixinSet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ObjVarsGet(ClientData clientData,
+static int		ObjVarsGet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ObjVarsSet(ClientData clientData,
+static int		ObjVarsSet(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
-static int		ResolveClass(ClientData clientData,
+static int		ResolveClass(void *clientData,
 			    Tcl_Interp *interp, Tcl_ObjectContext context,
 			    int objc, Tcl_Obj *const *objv);
 
@@ -633,7 +633,7 @@ RenameDeleteMethod(
 	    if (hPtr == newHPtr) {
 	    renameToSelf:
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"cannot rename method to itself", -1));
+			"cannot rename method to itself", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "OO", "RENAME_TO_SELF", NULL);
 		return TCL_ERROR;
 	    } else if (!isNew) {
@@ -709,7 +709,7 @@ TclOOUnknownDefinition(
 
     if (objc < 2) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"bad call of unknown handler", -1));
+		"bad call of unknown handler", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "BAD_UNKNOWN", NULL);
 	return TCL_ERROR;
     }
@@ -743,7 +743,7 @@ TclOOUnknownDefinition(
 		TclStackAlloc(interp, sizeof(Tcl_Obj*) * (objc - 1));
 	int result;
 
-	newObjv[0] = Tcl_NewStringObj(matchedStr, -1);
+	newObjv[0] = Tcl_NewStringObj(matchedStr, TCL_INDEX_NONE);
 	Tcl_IncrRefCount(newObjv[0]);
 	if (objc > 2) {
 	    memcpy(newObjv + 1, objv + 2, sizeof(Tcl_Obj *) * (objc - 2));
@@ -846,7 +846,7 @@ InitDefineContext(
 
     if (namespacePtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"no definition namespace available", -1));
+		"no definition namespace available", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -887,7 +887,7 @@ TclOOGetDefineCmdContext(
 	    && iPtr->varFramePtr->isProcCallFrame != PRIVATE_FRAME)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"this command may only be called from within the context of"
-		" an ::oo::define or ::oo::objdefine command", -1));
+		" an ::oo::define or ::oo::objdefine command", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return NULL;
     }
@@ -895,7 +895,7 @@ TclOOGetDefineCmdContext(
     if (Tcl_ObjectDeleted(object)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		"this command cannot be called when the object has been"
-		" deleted", -1));
+		" deleted", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return NULL;
     }
@@ -938,7 +938,7 @@ GetClassInOuterContext(
 	return NULL;
     }
     if (oPtr->classPtr == NULL) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(errMsg, -1));
+	Tcl_SetObjResult(interp, Tcl_NewStringObj(errMsg, TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "CLASS",
 		TclGetString(className), NULL);
 	return NULL;
@@ -1344,7 +1344,7 @@ TclOODefineObjSelfObjCmd(
 
 int
 TclOODefinePrivateObjCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -1437,13 +1437,13 @@ TclOODefineClassObjCmd(
     }
     if (oPtr->flags & ROOT_OBJECT) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"may not modify the class of the root object class", -1));
+		"may not modify the class of the root object class", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
     if (oPtr->flags & ROOT_CLASS) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"may not modify the class of the class of classes", -1));
+		"may not modify the class of the class of classes", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -1463,7 +1463,7 @@ TclOODefineClassObjCmd(
     }
     if (oPtr == clsPtr->thisPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"may not change classes into an instance of themselves", -1));
+		"may not change classes into an instance of themselves", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -1616,7 +1616,7 @@ TclOODefineDefnNsObjCmd(
     }
     if (!oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -1647,7 +1647,7 @@ TclOODefineDefnNsObjCmd(
 	if (nsPtr == NULL) {
 	    return TCL_ERROR;
 	}
-	nsNamePtr = Tcl_NewStringObj(nsPtr->fullName, -1);
+	nsNamePtr = Tcl_NewStringObj(nsPtr->fullName, TCL_INDEX_NONE);
 	Tcl_IncrRefCount(nsNamePtr);
     }
 
@@ -1680,7 +1680,7 @@ TclOODefineDefnNsObjCmd(
 
 int
 TclOODefineDeleteMethodObjCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -1700,7 +1700,7 @@ TclOODefineDeleteMethodObjCmd(
     }
     if (!isInstanceDeleteMethod && !oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -1802,7 +1802,7 @@ TclOODefineDestructorObjCmd(
 
 int
 TclOODefineExportObjCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -1826,7 +1826,7 @@ TclOODefineExportObjCmd(
     clsPtr = oPtr->classPtr;
     if (!isInstanceExport && !clsPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -1898,7 +1898,7 @@ TclOODefineExportObjCmd(
 
 int
 TclOODefineForwardObjCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -1920,7 +1920,7 @@ TclOODefineForwardObjCmd(
     }
     if (!isInstanceForward && !oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -1962,7 +1962,7 @@ TclOODefineForwardObjCmd(
 
 int
 TclOODefineMethodObjCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -1998,7 +1998,7 @@ TclOODefineMethodObjCmd(
     }
     if (!isInstanceMethod && !oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -2058,7 +2058,7 @@ TclOODefineMethodObjCmd(
 
 int
 TclOODefineRenameMethodObjCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2077,7 +2077,7 @@ TclOODefineRenameMethodObjCmd(
     }
     if (!isInstanceRenameMethod && !oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -2115,7 +2115,7 @@ TclOODefineRenameMethodObjCmd(
 
 int
 TclOODefineUnexportObjCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int objc,
     Tcl_Obj *const *objv)
@@ -2139,7 +2139,7 @@ TclOODefineUnexportObjCmd(
     clsPtr = oPtr->classPtr;
     if (!isInstanceUnexport && !clsPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -2268,13 +2268,13 @@ TclOODefineSlots(
     Foundation *fPtr)
 {
     const struct DeclaredSlot *slotInfoPtr;
-    Tcl_Obj *getName = Tcl_NewStringObj("Get", -1);
-    Tcl_Obj *setName = Tcl_NewStringObj("Set", -1);
-    Tcl_Obj *resolveName = Tcl_NewStringObj("Resolve", -1);
+    Tcl_Obj *getName = Tcl_NewStringObj("Get", TCL_INDEX_NONE);
+    Tcl_Obj *setName = Tcl_NewStringObj("Set", TCL_INDEX_NONE);
+    Tcl_Obj *resolveName = Tcl_NewStringObj("Resolve", TCL_INDEX_NONE);
     Class *slotCls;
 
     slotCls = ((Object *) Tcl_NewObjectInstance(fPtr->interp, (Tcl_Class)
-	    fPtr->classCls, "::oo::Slot", NULL, -1, NULL, 0))->classPtr;
+	    fPtr->classCls, "::oo::Slot", NULL, TCL_INDEX_NONE, NULL, 0))->classPtr;
     if (slotCls == NULL) {
 	return TCL_ERROR;
     }
@@ -2283,7 +2283,7 @@ TclOODefineSlots(
     Tcl_IncrRefCount(resolveName);
     for (slotInfoPtr = slots ; slotInfoPtr->name ; slotInfoPtr++) {
 	Tcl_Object slotObject = Tcl_NewObjectInstance(fPtr->interp,
-		(Tcl_Class) slotCls, slotInfoPtr->name, NULL, -1, NULL, 0);
+		(Tcl_Class) slotCls, slotInfoPtr->name, NULL, TCL_INDEX_NONE, NULL, 0);
 
 	if (slotObject == NULL) {
 	    continue;
@@ -2335,7 +2335,7 @@ ClassFilterGet(
 	return TCL_ERROR;
     } else if (!oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -2371,7 +2371,7 @@ ClassFilterSet(
 	return TCL_ERROR;
     } else if (!oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     } else if (TclListObjGetElementsM(interp, objv[0], &filterc,
@@ -2416,7 +2416,7 @@ ClassMixinGet(
 	return TCL_ERROR;
     } else if (!oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -2455,7 +2455,7 @@ ClassMixinSet(
 	return TCL_ERROR;
     } else if (!oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     } else if (TclListObjGetElementsM(interp, objv[0], &mixinc,
@@ -2474,7 +2474,7 @@ ClassMixinSet(
 	}
 	if (TclOOIsReachable(oPtr->classPtr, mixins[i])) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "may not mix a class into itself", -1));
+		    "may not mix a class into itself", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OO", "SELF_MIXIN", NULL);
 	    goto freeAndError;
 	}
@@ -2522,7 +2522,7 @@ ClassSuperGet(
 	return TCL_ERROR;
     } else if (!oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -2561,12 +2561,12 @@ ClassSuperSet(
 	return TCL_ERROR;
     } else if (!oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     } else if (oPtr == oPtr->fPtr->objectCls->thisPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"may not modify the superclass of the root object", -1));
+		"may not modify the superclass of the root object", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     } else if (TclListObjGetElementsM(interp, objv[0], &superc,
@@ -2614,7 +2614,7 @@ ClassSuperSet(
 	    }
 	    if (TclOOIsReachable(oPtr->classPtr, superclasses[i])) {
 		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"attempt to form circular dependency graph", -1));
+			"attempt to form circular dependency graph", TCL_INDEX_NONE));
 		Tcl_SetErrorCode(interp, "TCL", "OO", "CIRCULARITY", NULL);
 	    failedAfterAlloc:
 		for (; i-- > 0 ;) {
@@ -2689,7 +2689,7 @@ ClassVarsGet(
 	return TCL_ERROR;
     } else if (!oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     }
@@ -2736,7 +2736,7 @@ ClassVarsSet(
 	return TCL_ERROR;
     } else if (!oPtr->classPtr) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"attempt to misuse API", -1));
+		"attempt to misuse API", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);
 	return TCL_ERROR;
     } else if (TclListObjGetElementsM(interp, objv[0], &varc,
diff --git a/generic/tclOOInfo.c b/generic/tclOOInfo.c
index b4f9c56..a49282c 100644
--- a/generic/tclOOInfo.c
+++ b/generic/tclOOInfo.c
@@ -120,10 +120,10 @@ TclOOInitInfo(
     infoCmd = Tcl_FindCommand(interp, "info", NULL, TCL_GLOBAL_ONLY);
     if (infoCmd) {
 	Tcl_GetEnsembleMappingDict(NULL, infoCmd, &mapDict);
-	Tcl_DictObjPut(NULL, mapDict, Tcl_NewStringObj("object", -1),
-		Tcl_NewStringObj("::oo::InfoObject", -1));
-	Tcl_DictObjPut(NULL, mapDict, Tcl_NewStringObj("class", -1),
-		Tcl_NewStringObj("::oo::InfoClass", -1));
+	Tcl_DictObjPut(NULL, mapDict, Tcl_NewStringObj("object", TCL_INDEX_NONE),
+		Tcl_NewStringObj("::oo::InfoObject", TCL_INDEX_NONE));
+	Tcl_DictObjPut(NULL, mapDict, Tcl_NewStringObj("class", TCL_INDEX_NONE),
+		Tcl_NewStringObj("::oo::InfoClass", TCL_INDEX_NONE));
 	Tcl_SetEnsembleMappingDict(interp, infoCmd, mapDict);
     }
 }
@@ -264,7 +264,7 @@ InfoObjectDefnCmd(
     procPtr = TclOOGetProcFromMethod((Method *)Tcl_GetHashValue(hPtr));
     if (procPtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"definition not available for this kind of method", -1));
+		"definition not available for this kind of method", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "METHOD",
 		TclGetString(objv[2]), NULL);
 	return TCL_ERROR;
@@ -278,7 +278,7 @@ InfoObjectDefnCmd(
 
 	    TclNewObj(argObj);
 	    Tcl_ListObjAppendElement(NULL, argObj,
-		    Tcl_NewStringObj(localPtr->name, -1));
+		    Tcl_NewStringObj(localPtr->name, TCL_INDEX_NONE));
 	    if (localPtr->defValuePtr != NULL) {
 		Tcl_ListObjAppendElement(NULL, argObj, localPtr->defValuePtr);
 	    }
@@ -610,7 +610,7 @@ InfoObjectMethodsCmd(
 
 	for (i=0 ; i<numNames ; i++) {
 	    Tcl_ListObjAppendElement(NULL, resultObj,
-		    Tcl_NewStringObj(names[i], -1));
+		    Tcl_NewStringObj(names[i], TCL_INDEX_NONE));
 	}
 	if (numNames > 0) {
 	    Tcl_Free((void *)names);
@@ -679,7 +679,7 @@ InfoObjectMethodTypeCmd(
 	goto unknownMethod;
     }
 
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(mPtr->typePtr->name, -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(mPtr->typePtr->name, TCL_INDEX_NONE));
     return TCL_OK;
 }
 
@@ -787,7 +787,7 @@ InfoObjectNsCmd(
     }
 
     Tcl_SetObjResult(interp,
-	    Tcl_NewStringObj(oPtr->namespacePtr->fullName, -1));
+	    Tcl_NewStringObj(oPtr->namespacePtr->fullName, TCL_INDEX_NONE));
     return TCL_OK;
 }
 
@@ -943,7 +943,7 @@ InfoClassConstrCmd(
     procPtr = TclOOGetProcFromMethod(clsPtr->constructorPtr);
     if (procPtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"definition not available for this kind of method", -1));
+		"definition not available for this kind of method", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "METHOD_TYPE", NULL);
 	return TCL_ERROR;
     }
@@ -956,7 +956,7 @@ InfoClassConstrCmd(
 
 	    TclNewObj(argObj);
 	    Tcl_ListObjAppendElement(NULL, argObj,
-		    Tcl_NewStringObj(localPtr->name, -1));
+		    Tcl_NewStringObj(localPtr->name, TCL_INDEX_NONE));
 	    if (localPtr->defValuePtr != NULL) {
 		Tcl_ListObjAppendElement(NULL, argObj, localPtr->defValuePtr);
 	    }
@@ -1010,7 +1010,7 @@ InfoClassDefnCmd(
     procPtr = TclOOGetProcFromMethod((Method *)Tcl_GetHashValue(hPtr));
     if (procPtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"definition not available for this kind of method", -1));
+		"definition not available for this kind of method", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "METHOD",
 		TclGetString(objv[2]), NULL);
 	return TCL_ERROR;
@@ -1024,7 +1024,7 @@ InfoClassDefnCmd(
 
 	    TclNewObj(argObj);
 	    Tcl_ListObjAppendElement(NULL, argObj,
-		    Tcl_NewStringObj(localPtr->name, -1));
+		    Tcl_NewStringObj(localPtr->name, TCL_INDEX_NONE));
 	    if (localPtr->defValuePtr != NULL) {
 		Tcl_ListObjAppendElement(NULL, argObj, localPtr->defValuePtr);
 	    }
@@ -1121,7 +1121,7 @@ InfoClassDestrCmd(
     procPtr = TclOOGetProcFromMethod(clsPtr->destructorPtr);
     if (procPtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"definition not available for this kind of method", -1));
+		"definition not available for this kind of method", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OO", "METHOD_TYPE", NULL);
 	return TCL_ERROR;
     }
@@ -1365,7 +1365,7 @@ InfoClassMethodsCmd(
 
 	for (i=0 ; i<numNames ; i++) {
 	    Tcl_ListObjAppendElement(NULL, resultObj,
-		    Tcl_NewStringObj(names[i], -1));
+		    Tcl_NewStringObj(names[i], TCL_INDEX_NONE));
 	}
 	if (numNames > 0) {
 	    Tcl_Free((void *)names);
@@ -1431,7 +1431,7 @@ InfoClassMethodTypeCmd(
 
 	goto unknownMethod;
     }
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(mPtr->typePtr->name, -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(mPtr->typePtr->name, TCL_INDEX_NONE));
     return TCL_OK;
 }
 
@@ -1663,7 +1663,7 @@ InfoObjectCallCmd(
 	    NULL);
     if (contextPtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"cannot construct any call chain", -1));
+		"cannot construct any call chain", TCL_INDEX_NONE));
 	return TCL_ERROR;
     }
     Tcl_SetObjResult(interp,
@@ -1708,7 +1708,7 @@ InfoClassCallCmd(
     callPtr = TclOOGetStereotypeCallChain(clsPtr, objv[2], PUBLIC_METHOD);
     if (callPtr == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"cannot construct any call chain", -1));
+		"cannot construct any call chain", TCL_INDEX_NONE));
 	return TCL_ERROR;
     }
     Tcl_SetObjResult(interp, TclOORenderCallChain(interp, callPtr));
diff --git a/generic/tclObj.c b/generic/tclObj.c
index eaa6766..16b9ca1 100644
--- a/generic/tclObj.c
+++ b/generic/tclObj.c
@@ -867,7 +867,7 @@ Tcl_AppendAllObjTypes(
     for (hPtr = Tcl_FirstHashEntry(&typeTable, &search);
 	    hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
 	Tcl_ListObjAppendElement(NULL, objPtr,
-		Tcl_NewStringObj((char *)Tcl_GetHashKey(&typeTable, hPtr), -1));
+		Tcl_NewStringObj((char *)Tcl_GetHashKey(&typeTable, hPtr), TCL_INDEX_NONE));
     }
     Tcl_MutexUnlock(&tableMutex);
     return TCL_OK;
@@ -2009,7 +2009,7 @@ Tcl_GetBoolFromObj(
 	if (interp) {
 	    TclNewObj(objPtr);
 	    TclParseNumber(interp, objPtr, (flags & TCL_NULL_OK)
-		    ? "boolean value or \"\"" : "boolean value", NULL, -1, NULL, 0);
+		    ? "boolean value or \"\"" : "boolean value", NULL, TCL_INDEX_NONE, NULL, 0);
 	    Tcl_DecrRefCount(objPtr);
 	}
 	return TCL_ERROR;
@@ -2132,7 +2132,7 @@ TclSetBooleanFromAny(
 
 	TclNewLiteralStringObj(msg, "expected boolean value but got \"");
 	Tcl_AppendLimitedToObj(msg, str, length, 50, "");
-	Tcl_AppendToObj(msg, "\"", -1);
+	Tcl_AppendToObj(msg, "\"", TCL_INDEX_NONE);
 	Tcl_SetObjResult(interp, msg);
 	Tcl_SetErrorCode(interp, "TCL", "VALUE", "BOOLEAN", NULL);
     }
@@ -2421,7 +2421,7 @@ Tcl_GetDoubleFromObj(
 	    if (isnan(objPtr->internalRep.doubleValue)) {
 		if (interp != NULL) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "floating point value is Not a Number", -1));
+			    "floating point value is Not a Number", TCL_INDEX_NONE));
                     Tcl_SetErrorCode(interp, "TCL", "VALUE", "DOUBLE", "NAN",
                             NULL);
 		}
@@ -2553,7 +2553,7 @@ Tcl_GetIntFromObj(
 	if (interp != NULL) {
 	    const char *s =
 		    "integer value too large to represent";
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(s, -1));
+	    Tcl_SetObjResult(interp, Tcl_NewStringObj(s, TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", s, NULL);
 	}
 	return TCL_ERROR;
@@ -2718,7 +2718,7 @@ Tcl_GetLongFromObj(
 #endif
 	    if (interp != NULL) {
 		const char *s = "integer value too large to represent";
-		Tcl_Obj *msg = Tcl_NewStringObj(s, -1);
+		Tcl_Obj *msg = Tcl_NewStringObj(s, TCL_INDEX_NONE);
 
 		Tcl_SetObjResult(interp, msg);
 		Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", s, NULL);
@@ -2953,7 +2953,7 @@ Tcl_GetWideIntFromObj(
 	    }
 	    if (interp != NULL) {
 		const char *s = "integer value too large to represent";
-		Tcl_Obj *msg = Tcl_NewStringObj(s, -1);
+		Tcl_Obj *msg = Tcl_NewStringObj(s, TCL_INDEX_NONE);
 
 		Tcl_SetObjResult(interp, msg);
 		Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", s, NULL);
@@ -3037,7 +3037,7 @@ Tcl_GetWideUIntFromObj(
 
 	    if (interp != NULL) {
 		const char *s = "integer value too large to represent";
-		Tcl_Obj *msg = Tcl_NewStringObj(s, -1);
+		Tcl_Obj *msg = Tcl_NewStringObj(s, TCL_INDEX_NONE);
 
 		Tcl_SetObjResult(interp, msg);
 		Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", s, NULL);
@@ -4539,12 +4539,12 @@ Tcl_RepresentationCmd(
     }
 
     if (objv[1]->bytes) {
-        Tcl_AppendToObj(descObj, ", string representation \"", -1);
+        Tcl_AppendToObj(descObj, ", string representation \"", TCL_INDEX_NONE);
 	Tcl_AppendLimitedToObj(descObj, objv[1]->bytes, objv[1]->length,
                 16, "...");
-	Tcl_AppendToObj(descObj, "\"", -1);
+	Tcl_AppendToObj(descObj, "\"", TCL_INDEX_NONE);
     } else {
-	Tcl_AppendToObj(descObj, ", no string representation", -1);
+	Tcl_AppendToObj(descObj, ", no string representation", TCL_INDEX_NONE);
     }
 
     Tcl_SetObjResult(interp, descObj);
diff --git a/generic/tclParse.c b/generic/tclParse.c
index 1209a3b..75ffa26 100644
--- a/generic/tclParse.c
+++ b/generic/tclParse.c
@@ -228,7 +228,7 @@ Tcl_ParseCommand(
     if ((start == NULL) && (numBytes != 0)) {
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "can't parse a NULL pointer", -1));
+		    "can't parse a NULL pointer", TCL_INDEX_NONE));
 	}
 	return TCL_ERROR;
     }
@@ -282,13 +282,13 @@ Tcl_ParseCommand(
 	    if (src[-1] == '"') {
 		if (interp != NULL) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "extra characters after close-quote", -1));
+			    "extra characters after close-quote", TCL_INDEX_NONE));
 		}
 		parsePtr->errorType = TCL_PARSE_QUOTE_EXTRA;
 	    } else {
 		if (interp != NULL) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "extra characters after close-brace", -1));
+			    "extra characters after close-brace", TCL_INDEX_NONE));
 		}
 		parsePtr->errorType = TCL_PARSE_BRACE_EXTRA;
 	    }
@@ -1179,7 +1179,7 @@ ParseTokens(
 		if (numBytes == 0) {
 		    if (parsePtr->interp != NULL) {
 			Tcl_SetObjResult(parsePtr->interp, Tcl_NewStringObj(
-				"missing close-bracket", -1));
+				"missing close-bracket", TCL_INDEX_NONE));
 		    }
 		    parsePtr->errorType = TCL_PARSE_MISSING_BRACKET;
 		    parsePtr->term = tokenPtr->start;
@@ -1425,7 +1425,7 @@ Tcl_ParseVarName(
 	if (numBytes == 0) {
 	    if (parsePtr->interp != NULL) {
 		Tcl_SetObjResult(parsePtr->interp, Tcl_NewStringObj(
-			"missing close-brace for variable name", -1));
+			"missing close-brace for variable name", TCL_INDEX_NONE));
 	    }
 	    parsePtr->errorType = TCL_PARSE_MISSING_VAR_BRACE;
 	    parsePtr->term = tokenPtr->start-1;
@@ -1483,7 +1483,7 @@ Tcl_ParseVarName(
 	    if (parsePtr->term == src+numBytes){
 		if (parsePtr->interp != NULL) {
 		    Tcl_SetObjResult(parsePtr->interp, Tcl_NewStringObj(
-			    "missing )", -1));
+			    "missing )", TCL_INDEX_NONE));
 		}
 		parsePtr->errorType = TCL_PARSE_MISSING_PAREN;
 		parsePtr->term = src;
@@ -1492,7 +1492,7 @@ Tcl_ParseVarName(
 	    } else if ((*parsePtr->term != ')')){
 		if (parsePtr->interp != NULL) {
 		    Tcl_SetObjResult(parsePtr->interp, Tcl_NewStringObj(
-			    "invalid character in array index", -1));
+			    "invalid character in array index", TCL_INDEX_NONE));
 		}
 		parsePtr->errorType = TCL_PARSE_SYNTAX;
 		parsePtr->term = src;
@@ -1558,7 +1558,7 @@ Tcl_ParseVar(
     int code;
     Tcl_Parse *parsePtr = (Tcl_Parse *)TclStackAlloc(interp, sizeof(Tcl_Parse));
 
-    if (Tcl_ParseVarName(interp, start, -1, parsePtr, 0) != TCL_OK) {
+    if (Tcl_ParseVarName(interp, start, TCL_INDEX_NONE, parsePtr, 0) != TCL_OK) {
 	TclStackFree(interp, parsePtr);
 	return NULL;
     }
@@ -1765,7 +1765,7 @@ Tcl_ParseBraces(
     }
 
     Tcl_SetObjResult(parsePtr->interp, Tcl_NewStringObj(
-	    "missing close-brace", -1));
+	    "missing close-brace", TCL_INDEX_NONE));
 
     /*
      * Guess if the problem is due to comments by searching the source string
@@ -1788,7 +1788,7 @@ Tcl_ParseBraces(
 	    case '#' :
 		if (openBrace && TclIsSpaceProcM(src[-1])) {
 		    Tcl_AppendToObj(Tcl_GetObjResult(parsePtr->interp),
-			    ": possible unbalanced brace in comment", -1);
+			    ": possible unbalanced brace in comment", TCL_INDEX_NONE);
 		    goto error;
 		}
 		break;
@@ -1867,7 +1867,7 @@ Tcl_ParseQuotedString(
     if (*parsePtr->term != '"') {
 	if (parsePtr->interp != NULL) {
 	    Tcl_SetObjResult(parsePtr->interp, Tcl_NewStringObj(
-		    "missing \"", -1));
+		    "missing \"", TCL_INDEX_NONE));
 	}
 	parsePtr->errorType = TCL_PARSE_MISSING_QUOTE;
 	parsePtr->term = start;
diff --git a/generic/tclPipe.c b/generic/tclPipe.c
index 137b415..b18b789 100644
--- a/generic/tclPipe.c
+++ b/generic/tclPipe.c
@@ -335,7 +335,7 @@ TclCleanupChildren(
 
 	    Tcl_Seek(errorChan, 0, SEEK_SET);
 	    TclNewObj(objPtr);
-	    count = Tcl_ReadChars(errorChan, objPtr, -1, 0);
+	    count = Tcl_ReadChars(errorChan, objPtr, TCL_INDEX_NONE, 0);
 	    if (count == -1) {
 		result = TCL_ERROR;
 		Tcl_DecrRefCount(objPtr);
@@ -361,7 +361,7 @@ TclCleanupChildren(
 
     if ((abnormalExit != 0) && (anyErrorInfo == 0) && (interp != NULL)) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"child process exited abnormally", -1));
+		"child process exited abnormally", TCL_INDEX_NONE));
     }
     return result;
 }
@@ -512,7 +512,7 @@ TclCreatePipeline(
 	    if (*p == '\0') {
 		if ((i == (lastBar + 1)) || (i == (argc - 1))) {
 		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "illegal use of | or |& in command", -1));
+			    "illegal use of | or |& in command", TCL_INDEX_NONE));
 		    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "EXEC",
 			    "PIPESYNTAX", NULL);
 		    goto error;
@@ -700,7 +700,7 @@ TclCreatePipeline(
 	 */
 
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"illegal use of | or |& in command", -1));
+		"illegal use of | or |& in command", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "EXEC", "PIPESYNTAX",
 		NULL);
 	goto error;
@@ -1054,7 +1054,7 @@ Tcl_OpenCommandChannel(
 	if ((flags & TCL_STDOUT) && (outPipe == NULL)) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "can't read output from command:"
-		    " standard output was redirected", -1));
+		    " standard output was redirected", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "EXEC",
 		    "BADREDIRECT", NULL);
 	    goto error;
@@ -1062,7 +1062,7 @@ Tcl_OpenCommandChannel(
 	if ((flags & TCL_STDIN) && (inPipe == NULL)) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
 		    "can't write input to command:"
-		    " standard input was redirected", -1));
+		    " standard input was redirected", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "EXEC",
 		    "BADREDIRECT", NULL);
 	    goto error;
@@ -1074,7 +1074,7 @@ Tcl_OpenCommandChannel(
 
     if (channel == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"pipe for command could not be created", -1));
+		"pipe for command could not be created", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "OPERATION", "EXEC", "NOPIPE", NULL);
 	goto error;
     }
diff --git a/generic/tclProcess.c b/generic/tclProcess.c
index 075877e..0dad7c4 100644
--- a/generic/tclProcess.c
+++ b/generic/tclProcess.c
@@ -233,9 +233,9 @@ WaitProcessStatus(
 	if (msgObjPtr) *msgObjPtr = Tcl_ObjPrintf(
 		"error waiting for process to exit: %s", msg);
 	if (errorObjPtr) {
-	    errorStrings[0] = Tcl_NewStringObj("POSIX", -1);
-	    errorStrings[1] = Tcl_NewStringObj(Tcl_ErrnoId(), -1);
-	    errorStrings[2] = Tcl_NewStringObj(msg, -1);
+	    errorStrings[0] = Tcl_NewStringObj("POSIX", TCL_INDEX_NONE);
+	    errorStrings[1] = Tcl_NewStringObj(Tcl_ErrnoId(), TCL_INDEX_NONE);
+	    errorStrings[2] = Tcl_NewStringObj(msg, TCL_INDEX_NONE);
 	    *errorObjPtr = Tcl_NewListObj(3, errorStrings);
 	}
 	return TCL_PROCESS_ERROR;
@@ -256,9 +256,9 @@ WaitProcessStatus(
 	     */
 
 	    if (msgObjPtr) *msgObjPtr = Tcl_NewStringObj(
-		    "child process exited abnormally", -1);
+		    "child process exited abnormally", TCL_INDEX_NONE);
 	    if (errorObjPtr) {
-		errorStrings[0] = Tcl_NewStringObj("CHILDSTATUS", -1);
+		errorStrings[0] = Tcl_NewStringObj("CHILDSTATUS", TCL_INDEX_NONE);
 		TclNewIntObj(errorStrings[1], resolvedPid);
 		TclNewIntObj(errorStrings[2], WEXITSTATUS(waitStatus));
 		*errorObjPtr = Tcl_NewListObj(3, errorStrings);
@@ -277,10 +277,10 @@ WaitProcessStatus(
 	if (msgObjPtr) *msgObjPtr = Tcl_ObjPrintf(
 		"child killed: %s", msg);
 	if (errorObjPtr) {
-	    errorStrings[0] = Tcl_NewStringObj("CHILDKILLED", -1);
+	    errorStrings[0] = Tcl_NewStringObj("CHILDKILLED", TCL_INDEX_NONE);
 	    TclNewIntObj(errorStrings[1], resolvedPid);
-	    errorStrings[2] = Tcl_NewStringObj(Tcl_SignalId(WTERMSIG(waitStatus)), -1);
-	    errorStrings[3] = Tcl_NewStringObj(msg, -1);
+	    errorStrings[2] = Tcl_NewStringObj(Tcl_SignalId(WTERMSIG(waitStatus)), TCL_INDEX_NONE);
+	    errorStrings[3] = Tcl_NewStringObj(msg, TCL_INDEX_NONE);
 	    *errorObjPtr = Tcl_NewListObj(4, errorStrings);
 	}
 	return TCL_PROCESS_SIGNALED;
@@ -296,10 +296,10 @@ WaitProcessStatus(
 	if (msgObjPtr) *msgObjPtr = Tcl_ObjPrintf(
 		"child suspended: %s", msg);
 	if (errorObjPtr) {
-	    errorStrings[0] = Tcl_NewStringObj("CHILDSUSP", -1);
+	    errorStrings[0] = Tcl_NewStringObj("CHILDSUSP", TCL_INDEX_NONE);
 	    TclNewIntObj(errorStrings[1], resolvedPid);
-	    errorStrings[2] = Tcl_NewStringObj(Tcl_SignalId(WSTOPSIG(waitStatus)), -1);
-	    errorStrings[3] = Tcl_NewStringObj(msg, -1);
+	    errorStrings[2] = Tcl_NewStringObj(Tcl_SignalId(WSTOPSIG(waitStatus)), TCL_INDEX_NONE);
+	    errorStrings[3] = Tcl_NewStringObj(msg, TCL_INDEX_NONE);
 	    *errorObjPtr = Tcl_NewListObj(4, errorStrings);
 	}
 	return TCL_PROCESS_STOPPED;
@@ -312,12 +312,12 @@ WaitProcessStatus(
 
 	if (codePtr) *codePtr = waitStatus;
 	if (msgObjPtr) *msgObjPtr = Tcl_NewStringObj(
-		"child wait status didn't make sense\n", -1);
+		"child wait status didn't make sense\n", TCL_INDEX_NONE);
 	if (errorObjPtr) {
-	    errorStrings[0] = Tcl_NewStringObj("TCL", -1);
-	    errorStrings[1] = Tcl_NewStringObj("OPERATION", -1);
-	    errorStrings[2] = Tcl_NewStringObj("EXEC", -1);
-	    errorStrings[3] = Tcl_NewStringObj("ODDWAITRESULT", -1);
+	    errorStrings[0] = Tcl_NewStringObj("TCL", TCL_INDEX_NONE);
+	    errorStrings[1] = Tcl_NewStringObj("OPERATION", TCL_INDEX_NONE);
+	    errorStrings[2] = Tcl_NewStringObj("EXEC", TCL_INDEX_NONE);
+	    errorStrings[3] = Tcl_NewStringObj("ODDWAITRESULT", TCL_INDEX_NONE);
 	    TclNewIntObj(errorStrings[4], resolvedPid);
 	    *errorObjPtr = Tcl_NewListObj(5, errorStrings);
 	}
diff --git a/generic/tclScan.c b/generic/tclScan.c
index ee18174..6a5bfb7 100644
--- a/generic/tclScan.c
+++ b/generic/tclScan.c
@@ -397,9 +397,9 @@ ValidateFormat(
 	    invalidFieldSize:
 		buf[Tcl_UniCharToUtf(ch, buf)] = '\0';
 		errorMsg = Tcl_NewStringObj(
-			"field size modifier may not be specified in %", -1);
-		Tcl_AppendToObj(errorMsg, buf, -1);
-		Tcl_AppendToObj(errorMsg, " conversion", -1);
+			"field size modifier may not be specified in %", TCL_INDEX_NONE);
+		Tcl_AppendToObj(errorMsg, buf, TCL_INDEX_NONE);
+		Tcl_AppendToObj(errorMsg, " conversion", TCL_INDEX_NONE);
 		Tcl_SetObjResult(interp, errorMsg);
 		Tcl_SetErrorCode(interp, "TCL", "FORMAT", "BADSIZE", NULL);
 		goto error;
@@ -452,15 +452,15 @@ ValidateFormat(
 	    break;
 	badSet:
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "unmatched [ in format string", -1));
+		    "unmatched [ in format string", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "FORMAT", "BRACKET", NULL);
 	    goto error;
 	default:
 	    buf[Tcl_UniCharToUtf(ch, buf)] = '\0';
 	    errorMsg = Tcl_NewStringObj(
-		    "bad scan conversion character \"", -1);
-	    Tcl_AppendToObj(errorMsg, buf, -1);
-	    Tcl_AppendToObj(errorMsg, "\"", -1);
+		    "bad scan conversion character \"", TCL_INDEX_NONE);
+	    Tcl_AppendToObj(errorMsg, buf, TCL_INDEX_NONE);
+	    Tcl_AppendToObj(errorMsg, "\"", TCL_INDEX_NONE);
 	    Tcl_SetObjResult(interp, errorMsg);
 	    Tcl_SetErrorCode(interp, "TCL", "FORMAT", "BADTYPE", NULL);
 	    goto error;
@@ -531,7 +531,7 @@ ValidateFormat(
   badIndex:
     if (gotXpg) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"\"%n$\" argument index out of range", -1));
+		"\"%n$\" argument index out of range", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "FORMAT", "INDEXRANGE", NULL);
     } else {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
@@ -926,7 +926,7 @@ Tcl_ScanObjCmd(
 		    mp_int big;
 		    if (mp_init_u64(&big, (Tcl_WideUInt)wideValue) != MP_OKAY) {
 			Tcl_SetObjResult(interp, Tcl_NewStringObj(
-				"insufficient memory to create bignum", -1));
+				"insufficient memory to create bignum", TCL_INDEX_NONE));
 			Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
 			return TCL_ERROR;
 		    } else {
@@ -953,7 +953,7 @@ Tcl_ScanObjCmd(
 			}
 			Tcl_DecrRefCount(objPtr);
 			Tcl_SetObjResult(interp, Tcl_NewStringObj(
-				"unsigned bignum scans are invalid", -1));
+				"unsigned bignum scans are invalid", TCL_INDEX_NONE));
 			Tcl_SetErrorCode(interp, "TCL", "FORMAT",
 				"BADUNSIGNED",NULL);
 			return TCL_ERROR;
@@ -972,7 +972,7 @@ Tcl_ScanObjCmd(
 		    mp_int big;
 		    if (mp_init_u64(&big, (unsigned long)value) != MP_OKAY) {
 			Tcl_SetObjResult(interp, Tcl_NewStringObj(
-				"insufficient memory to create bignum", -1));
+				"insufficient memory to create bignum", TCL_INDEX_NONE));
 			Tcl_SetErrorCode(interp, "TCL", "MEMORY", NULL);
 			return TCL_ERROR;
 		    } else {
diff --git a/generic/tclVar.c b/generic/tclVar.c
index f7ec7c8..bc94e73 100644
--- a/generic/tclVar.c
+++ b/generic/tclVar.c
@@ -301,7 +301,7 @@ TclVarHashCreateVar(
     Tcl_Obj *keyPtr;
     Var *varPtr;
 
-    keyPtr = Tcl_NewStringObj(key, -1);
+    keyPtr = Tcl_NewStringObj(key, TCL_INDEX_NONE);
     Tcl_IncrRefCount(keyPtr);
     varPtr = VarHashCreateVar(tablePtr, keyPtr, newPtr);
     Tcl_DecrRefCount(keyPtr);
@@ -469,7 +469,7 @@ TclLookupVar(
 				 * is set to NULL. */
 {
     Var *varPtr;
-    Tcl_Obj *part1Ptr = Tcl_NewStringObj(part1, -1);
+    Tcl_Obj *part1Ptr = Tcl_NewStringObj(part1, TCL_INDEX_NONE);
 
     if (createPart1) {
 	Tcl_IncrRefCount(part1Ptr);
@@ -551,7 +551,7 @@ TclObjLookupVar(
     Var *resPtr;
 
     if (part2) {
-	part2Ptr = Tcl_NewStringObj(part2, -1);
+	part2Ptr = Tcl_NewStringObj(part2, TCL_INDEX_NONE);
 	if (createPart2) {
 	    Tcl_IncrRefCount(part2Ptr);
 	}
@@ -949,7 +949,7 @@ TclLookupSimpleVar(
 		return NULL;
 	    }
 	    if (tail != varName) {
-		tailPtr = Tcl_NewStringObj(tail, -1);
+		tailPtr = Tcl_NewStringObj(tail, TCL_INDEX_NONE);
 	    } else {
 		tailPtr = varNamePtr;
 	    }
@@ -1173,10 +1173,10 @@ Tcl_GetVar2(
 				 * bits. */
 {
     Tcl_Obj *resultPtr;
-    Tcl_Obj *part2Ptr = NULL, *part1Ptr = Tcl_NewStringObj(part1, -1);
+    Tcl_Obj *part2Ptr = NULL, *part1Ptr = Tcl_NewStringObj(part1, TCL_INDEX_NONE);
 
     if (part2) {
-	part2Ptr = Tcl_NewStringObj(part2, -1);
+	part2Ptr = Tcl_NewStringObj(part2, TCL_INDEX_NONE);
 	Tcl_IncrRefCount(part2Ptr);
     }
 
@@ -1226,10 +1226,10 @@ Tcl_GetVar2Ex(
     int flags)			/* OR-ed combination of TCL_GLOBAL_ONLY, and
 				 * TCL_LEAVE_ERR_MSG bits. */
 {
-    Tcl_Obj *resPtr, *part2Ptr = NULL, *part1Ptr = Tcl_NewStringObj(part1, -1);
+    Tcl_Obj *resPtr, *part2Ptr = NULL, *part1Ptr = Tcl_NewStringObj(part1, TCL_INDEX_NONE);
 
     if (part2) {
-	part2Ptr = Tcl_NewStringObj(part2, -1);
+	part2Ptr = Tcl_NewStringObj(part2, TCL_INDEX_NONE);
 	Tcl_IncrRefCount(part2Ptr);
     }
 
@@ -1547,7 +1547,7 @@ Tcl_SetVar2(
 				 * TCL_LEAVE_ERR_MSG. */
 {
     Tcl_Obj *varValuePtr = Tcl_SetVar2Ex(interp, part1, part2,
-	    Tcl_NewStringObj(newValue, -1), flags);
+	    Tcl_NewStringObj(newValue, TCL_INDEX_NONE), flags);
 
     if (varValuePtr == NULL) {
 	return NULL;
@@ -1607,11 +1607,11 @@ Tcl_SetVar2Ex(
 				 * TCL_APPEND_VALUE, TCL_LIST_ELEMENT or
 				 * TCL_LEAVE_ERR_MSG. */
 {
-    Tcl_Obj *resPtr, *part2Ptr = NULL, *part1Ptr = Tcl_NewStringObj(part1, -1);
+    Tcl_Obj *resPtr, *part2Ptr = NULL, *part1Ptr = Tcl_NewStringObj(part1, TCL_INDEX_NONE);
 
     Tcl_IncrRefCount(part1Ptr);
     if (part2) {
-	part2Ptr = Tcl_NewStringObj(part2, -1);
+	part2Ptr = Tcl_NewStringObj(part2, TCL_INDEX_NONE);
 	Tcl_IncrRefCount(part2Ptr);
     }
 
@@ -2291,10 +2291,10 @@ Tcl_UnsetVar2(
 				 * TCL_LEAVE_ERR_MSG. */
 {
     int result;
-    Tcl_Obj *part2Ptr = NULL, *part1Ptr = Tcl_NewStringObj(part1, -1);
+    Tcl_Obj *part2Ptr = NULL, *part1Ptr = Tcl_NewStringObj(part1, TCL_INDEX_NONE);
 
     if (part2) {
-	part2Ptr = Tcl_NewStringObj(part2, -1);
+	part2Ptr = Tcl_NewStringObj(part2, TCL_INDEX_NONE);
     }
 
     /*
@@ -3070,7 +3070,7 @@ ArrayForNRCmd(
 
     if (numVars != 2) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"must have two variable names", -1));
+		"must have two variable names", TCL_INDEX_NONE));
 	Tcl_SetErrorCode(interp, "TCL", "SYNTAX", "array", "for", NULL);
 	return TCL_ERROR;
     }
@@ -3168,7 +3168,7 @@ ArrayForLoopCallback(
 	Tcl_ResetResult(interp);
 	if (done == TCL_ERROR) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "array changed during iteration", -1));
+		    "array changed during iteration", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "READ", "array", "for", NULL);
 	    varPtr->flags |= TCL_LEAVE_ERR_MSG;
 	    result = done;
@@ -4048,7 +4048,7 @@ ArraySetCmd(
 	}
 	if (elemLen & 1) {
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "list must have an even number of elements", -1));
+		    "list must have an even number of elements", TCL_INDEX_NONE));
 	    Tcl_SetErrorCode(interp, "TCL", "ARGUMENT", "FORMAT", NULL);
 	    return TCL_ERROR;
 	}
@@ -4218,10 +4218,10 @@ ArrayStatsCmd(
     stats = Tcl_HashStats((Tcl_HashTable *) varPtr->value.tablePtr);
     if (stats == NULL) {
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"error reading array statistics", -1));
+		"error reading array statistics", TCL_INDEX_NONE));
 	return TCL_ERROR;
     }
-    Tcl_SetObjResult(interp, Tcl_NewStringObj(stats, -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(stats, TCL_INDEX_NONE));
     Tcl_Free(stats);
     return TCL_OK;
 }
diff --git a/unix/dltest/pkgb.c b/unix/dltest/pkgb.c
index 651c132..750d270 100644
--- a/unix/dltest/pkgb.c
+++ b/unix/dltest/pkgb.c
@@ -84,7 +84,7 @@ Pkgb_UnsafeObjCmd(
     (void)objc;
     (void)objv;
 
-    return Tcl_EvalEx(interp, "list unsafe command invoked", -1, TCL_EVAL_GLOBAL);
+    return Tcl_EvalEx(interp, "list unsafe command invoked", TCL_INDEX_NONE, TCL_EVAL_GLOBAL);
 }
 
 static int
diff --git a/unix/dltest/pkgc.c b/unix/dltest/pkgc.c
index 8e9c829..582d457 100644
--- a/unix/dltest/pkgc.c
+++ b/unix/dltest/pkgc.c
@@ -81,7 +81,7 @@ Pkgc_UnsafeObjCmd(
     (void)objc;
     (void)objv;
 
-    Tcl_SetObjResult(interp, Tcl_NewStringObj("unsafe command invoked", -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj("unsafe command invoked", TCL_INDEX_NONE));
     return TCL_OK;
 }
 
diff --git a/unix/dltest/pkgd.c b/unix/dltest/pkgd.c
index 1b97d4c..52ba968 100644
--- a/unix/dltest/pkgd.c
+++ b/unix/dltest/pkgd.c
@@ -81,7 +81,7 @@ Pkgd_UnsafeObjCmd(
     (void)objc;
     (void)objv;
 
-    Tcl_SetObjResult(interp, Tcl_NewStringObj("unsafe command invoked", -1));
+    Tcl_SetObjResult(interp, Tcl_NewStringObj("unsafe command invoked", TCL_INDEX_NONE));
     return TCL_OK;
 }
 
diff --git a/unix/dltest/pkge.c b/unix/dltest/pkge.c
index 26a4b79..5f0db9b 100644
--- a/unix/dltest/pkge.c
+++ b/unix/dltest/pkge.c
@@ -41,5 +41,5 @@ Pkge_Init(
     if (Tcl_InitStubs(interp, "8.5-", 0) == NULL) {
 	return TCL_ERROR;
     }
-    return Tcl_EvalEx(interp, script, -1, 0);
+    return Tcl_EvalEx(interp, script, TCL_INDEX_NONE, 0);
 }
diff --git a/unix/tclUnixFCmd.c b/unix/tclUnixFCmd.c
index b205061..c9d7c45 100644
--- a/unix/tclUnixFCmd.c
+++ b/unix/tclUnixFCmd.c
@@ -1648,7 +1648,7 @@ SetPermissionsAttribute(
 	Tcl_Obj *modeObj;
 
 	TclNewLiteralStringObj(modeObj, "0o");
-	Tcl_AppendToObj(modeObj, modeStringPtr+scanned+1, -1);
+	Tcl_AppendToObj(modeObj, modeStringPtr+scanned+1, TCL_INDEX_NONE);
 	result = Tcl_GetWideIntFromObj(NULL, modeObj, &mode);
 	Tcl_DecrRefCount(modeObj);
     }
-- 
cgit v0.12


From 296e4767eaa58abc7f46c676e80546de26a997a2 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Mon, 6 Mar 2023 07:00:48 +0000
Subject: Add new valgrind suppression items.

---
 tools/valgrind_suppress | 137 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 137 insertions(+)

diff --git a/tools/valgrind_suppress b/tools/valgrind_suppress
index fb7f173..11ca880 100644
--- a/tools/valgrind_suppress
+++ b/tools/valgrind_suppress
@@ -1,3 +1,17 @@
+#{
+#    Tcl_GetChannelOption/TcpGetOptionProc/TcphostPortList/getnameinfo/gethostbyaddr_r
+#    Memcheck:Leak
+#    match-leak-kinds: reachable
+#    fun:malloc
+#    fun:strdup
+#    ...
+#    fun:module_load
+#    ...
+#    fun:getnameinfo
+#    ...
+#    fun:Tcl_GetChannelOption
+#}
+
 {
    TclCreatesocketAddress/getaddrinfo/calloc
    Memcheck:Leak
@@ -11,6 +25,16 @@
 {
    TclCreatesocketAddress/getaddrinfo/malloc
    Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   ...
+   fun:getaddrinfo
+   fun:TclCreateSocketAddress
+}
+
+{
+   TclCreatesocketAddress/getaddrinfo/malloc
+   Memcheck:Leak
    match-leak-kinds: reachable
    fun:malloc
    ...
@@ -19,6 +43,18 @@
 }
 
 {
+   TclpDlopen/decompose_rpath
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:malloc
+   fun:decompose_rpath
+   ...
+   fun:dlopen_doit
+   ...
+   fun:TclpDlopen
+}
+
+{
    TclpDlopen/load
    Memcheck:Leak
    match-leak-kinds: reachable
@@ -72,6 +108,46 @@
 }
 
 {
+    TclpGeHostByName/gethostbyname_r/strdup/malloc
+    Memcheck:Leak
+    match-leak-kinds: reachable
+    fun:malloc
+    fun:strdup
+    ...
+    fun:dl_open_worker
+    ...
+    fun:do_dlopen
+    ...
+    fun:TclpGetHostByName
+}
+
+{
+    TclpGeHostByName/gethostbyname_r/calloc
+    Memcheck:Leak
+    match-leak-kinds: reachable
+    fun:calloc
+    ...
+    fun:dl_open_worker
+    ...
+    fun:do_dlopen
+    ...
+    fun:TclpGetHostByName
+}
+
+{
+    TclpGeHostByName/gethostbyname_r/malloc
+    Memcheck:Leak
+    match-leak-kinds: reachable
+    fun:malloc
+    ...
+    fun:dl_open_worker
+    ...
+    fun:do_dlopen
+    ...
+    fun:TclpGetHostByName
+}
+
+{
    TclpGetPwNam/getpwname_r/__nss_next2/calloc
    Memcheck:Leak
    match-leak-kinds: reachable
@@ -105,6 +181,57 @@
 }
 
 {
+    TclpGetGrGid/getgrgid_r/module_load
+    Memcheck:Leak
+    match-leak-kinds: reachable
+    fun:calloc
+    ...
+    fun:module_load
+    ...
+    fun:TclpGetGrGid
+}
+
+{
+    TclpGetGrGid/getgrgid_r/module_load
+    Memcheck:Leak
+    match-leak-kinds: reachable
+    fun:malloc
+    ...
+    fun:module_load
+    ...
+    fun:TclpGetGrGid
+}
+
+{
+    TcphostPortList/getnameinfo/module_load/calloc
+    Memcheck:Leak
+    match-leak-kinds: definite,reachable
+    fun:calloc
+    ...
+    fun:dl_open_worker_begin
+    ...
+    fun:module_load
+    ...
+    fun:getnameinfo
+    fun:TcpHostPortList
+}
+
+{
+    # see sourceware glibc Bug 14984 - getnameinfo() might be leaking memory
+    TcphostPortList/getnameinfo/module_load/mallco
+    Memcheck:Leak
+    match-leak-kinds: definite,reachable
+    fun:malloc
+    ...
+    fun:dl_open_worker_begin
+    ...
+    fun:module_load
+    ...
+    fun:getnameinfo
+    fun:TcpHostPortList
+}
+
+{
 	TclpThreadExit/pthread_exit/calloc
     Memcheck:Leak
     match-leak-kinds: reachable
@@ -124,3 +251,13 @@
 	fun:TclpThreadExit
 }
 
+{
+	TclpThreadExit/pthread_exit/malloc
+    Memcheck:Leak
+    match-leak-kinds: definite
+	fun:malloc
+	...
+	fun:pthread_exit
+	fun:TclpThreadExit
+}
+
-- 
cgit v0.12


From 3eb68691b82d5c02de6081180225f886b140926c Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Mon, 6 Mar 2023 10:30:41 +0000
Subject: ckfree() -> Tcl_Free()

---
 generic/tclTest.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/generic/tclTest.c b/generic/tclTest.c
index 6399e37..06d5064 100644
--- a/generic/tclTest.c
+++ b/generic/tclTest.c
@@ -1197,7 +1197,7 @@ CmdDelProc0(
 	}
 	prevRefPtr = thisRefPtr;
     }
-    ckfree(refPtr);
+    Tcl_Free(refPtr);
 }
 
 static void
-- 
cgit v0.12


From 10f4d4565dc1c86e6b26623c99d5709cac033f0f Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Wed, 8 Mar 2023 15:01:20 +0000
Subject: More -Wconversion warning fixes

---
 generic/tclIOCmd.c    |  8 +++----
 generic/tclOOBasic.c  | 40 ++++++++++++++++---------------
 generic/tclPathObj.c  | 10 ++++----
 generic/tclPkg.c      | 52 ++++++++++++++++++++--------------------
 generic/tclPreserve.c |  8 +++----
 tests/fCmd.test       |  4 ++--
 unix/tclSelectNotfy.c | 10 ++++----
 unix/tclUnixFile.c    | 20 ++++++++--------
 unix/tclUnixNotfy.c   |  6 ++---
 unix/tclUnixThrd.c    |  2 +-
 win/tclWinFile.c      | 20 ++++++++--------
 win/tclWinLoad.c      |  2 +-
 win/tclWinNotify.c    | 16 ++++++-------
 win/tclWinPipe.c      | 20 ++++++++--------
 win/tclWinSerial.c    | 66 +++++++++++++++++++++++++--------------------------
 win/tclWinThrd.c      |  8 +++----
 16 files changed, 147 insertions(+), 145 deletions(-)

diff --git a/generic/tclIOCmd.c b/generic/tclIOCmd.c
index 2298d48..6ec5891 100644
--- a/generic/tclIOCmd.c
+++ b/generic/tclIOCmd.c
@@ -44,7 +44,7 @@ static void			RegisterTcpServerInterpCleanup(
 				    Tcl_Interp *interp,
 				    AcceptCallback *acceptCallbackPtr);
 static Tcl_InterpDeleteProc	TcpAcceptCallbacksDeleteProc;
-static void		TcpServerCloseProc(ClientData callbackData);
+static void		TcpServerCloseProc(void *callbackData);
 static void		UnregisterTcpServerInterpCleanupProc(
 			    Tcl_Interp *interp,
 			    AcceptCallback *acceptCallbackPtr);
@@ -1183,7 +1183,7 @@ Tcl_OpenObjCmd(
 
 static void
 TcpAcceptCallbacksDeleteProc(
-    ClientData clientData,	/* Data which was passed when the assocdata
+    void *clientData,	/* Data which was passed when the assocdata
 				 * was registered. */
     TCL_UNUSED(Tcl_Interp *))
 {
@@ -1311,7 +1311,7 @@ UnregisterTcpServerInterpCleanupProc(
 
 static void
 AcceptCallbackProc(
-    ClientData callbackData,	/* The data stored when the callback was
+    void *callbackData,	/* The data stored when the callback was
 				 * created in the call to
 				 * Tcl_OpenTcpServer. */
     Tcl_Channel chan,		/* Channel for the newly accepted
@@ -1402,7 +1402,7 @@ AcceptCallbackProc(
 
 static void
 TcpServerCloseProc(
-    ClientData callbackData)	/* The data passed in the call to
+    void *callbackData)	/* The data passed in the call to
 				 * Tcl_CreateCloseHandler. */
 {
     AcceptCallback *acceptCallbackPtr = (AcceptCallback *)callbackData;
diff --git a/generic/tclOOBasic.c b/generic/tclOOBasic.c
index d8ef59b..1ad351d 100644
--- a/generic/tclOOBasic.c
+++ b/generic/tclOOBasic.c
@@ -52,7 +52,7 @@ AddConstructionFinalizer(
 
 static int
 FinalizeConstruction(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     int result)
 {
@@ -86,11 +86,12 @@ TclOO_Class_Constructor(
     Object *oPtr = (Object *) Tcl_ObjectContextObject(context);
     Tcl_Obj **invoke, *nameObj;
 
-    if (objc-1 > (int)Tcl_ObjectContextSkippedArgs(context)) {
-	Tcl_WrongNumArgs(interp, Tcl_ObjectContextSkippedArgs(context), objv,
+    size_t skip = Tcl_ObjectContextSkippedArgs(context);
+    if ((size_t)objc > skip + 1) {
+	Tcl_WrongNumArgs(interp, skip, objv,
 		"?definitionScript?");
 	return TCL_ERROR;
-    } else if (objc == (int)Tcl_ObjectContextSkippedArgs(context)) {
+    } else if ((size_t)objc == skip) {
 	return TCL_OK;
     }
 
@@ -135,7 +136,7 @@ TclOO_Class_Constructor(
 
 static int
 DecrRefsPostClassConstructor(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     int result)
 {
@@ -204,7 +205,7 @@ TclOO_Class_Create(
      * Check we have the right number of (sensible) arguments.
      */
 
-    if (objc - Tcl_ObjectContextSkippedArgs(context) < 1) {
+    if ((size_t)objc < 1 + Tcl_ObjectContextSkippedArgs(context)) {
 	Tcl_WrongNumArgs(interp, Tcl_ObjectContextSkippedArgs(context), objv,
 		"objectName ?arg ...?");
 	return TCL_ERROR;
@@ -269,7 +270,7 @@ TclOO_Class_CreateNs(
      * Check we have the right number of (sensible) arguments.
      */
 
-    if (objc - Tcl_ObjectContextSkippedArgs(context) < 2) {
+    if ((size_t)objc + 1 < Tcl_ObjectContextSkippedArgs(context) + 3) {
 	Tcl_WrongNumArgs(interp, Tcl_ObjectContextSkippedArgs(context), objv,
 		"objectName namespaceName ?arg ...?");
 	return TCL_ERROR;
@@ -393,7 +394,7 @@ TclOO_Object_Destroy(
 
 static int
 AfterNRDestructor(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     int result)
 {
@@ -427,12 +428,12 @@ TclOO_Object_Eval(
 {
     CallContext *contextPtr = (CallContext *) context;
     Tcl_Object object = Tcl_ObjectContextObject(context);
-    const int skip = Tcl_ObjectContextSkippedArgs(context);
+    size_t skip = Tcl_ObjectContextSkippedArgs(context);
     CallFrame *framePtr, **framePtrPtr = &framePtr;
     Tcl_Obj *scriptPtr;
     CmdFrame *invoker;
 
-    if (objc-1 < skip) {
+    if ((size_t)objc < skip + 1) {
 	Tcl_WrongNumArgs(interp, skip, objv, "arg ?arg ...?");
 	return TCL_ERROR;
     }
@@ -460,7 +461,7 @@ TclOO_Object_Eval(
      * object when it decrements its refcount after eval'ing it.
      */
 
-    if (objc != skip+1) {
+    if ((size_t)objc != skip+1) {
 	scriptPtr = Tcl_ConcatObj(objc-skip, objv+skip);
 	invoker = NULL;
     } else {
@@ -479,7 +480,7 @@ TclOO_Object_Eval(
 
 static int
 FinalizeEval(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     int result)
 {
@@ -531,7 +532,8 @@ TclOO_Object_Unknown(
     Class *callerCls = NULL;
     Object *oPtr = contextPtr->oPtr;
     const char **methodNames;
-    int numMethodNames, i, skip = Tcl_ObjectContextSkippedArgs(context);
+    int numMethodNames, i;
+    size_t skip = Tcl_ObjectContextSkippedArgs(context);
     CallFrame *framePtr = ((Interp *) interp)->varFramePtr;
     Tcl_Obj *errorMsg;
 
@@ -541,7 +543,7 @@ TclOO_Object_Unknown(
      * name without an error).
      */
 
-    if (objc < skip+1) {
+    if ((size_t)objc < skip+1) {
 	Tcl_WrongNumArgs(interp, skip, objv, "method ?arg ...?");
 	return TCL_ERROR;
     }
@@ -635,7 +637,7 @@ TclOO_Object_LinkVar(
     Interp *iPtr = (Interp *) interp;
     Tcl_Object object = Tcl_ObjectContextObject(context);
     Namespace *savedNsPtr;
-    int i;
+    size_t i;
 
     if ((size_t)objc < Tcl_ObjectContextSkippedArgs(context)) {
 	Tcl_WrongNumArgs(interp, Tcl_ObjectContextSkippedArgs(context), objv,
@@ -653,7 +655,7 @@ TclOO_Object_LinkVar(
 	return TCL_OK;
     }
 
-    for (i=Tcl_ObjectContextSkippedArgs(context) ; i<objc ; i++) {
+    for (i = Tcl_ObjectContextSkippedArgs(context) ; i < (size_t)objc ; i++) {
 	Var *varPtr, *aryPtr;
 	const char *varName = TclGetString(objv[i]);
 
@@ -1007,7 +1009,7 @@ TclOONextToObjCmd(
 
 static int
 NextRestoreFrame(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     int result)
 {
@@ -1016,7 +1018,7 @@ NextRestoreFrame(
 
     iPtr->varFramePtr = (CallFrame *)data[0];
     if (contextPtr != NULL) {
-	contextPtr->index = PTR2INT(data[2]);
+	contextPtr->index = PTR2UINT(data[2]);
     }
     return result;
 }
@@ -1090,7 +1092,7 @@ TclOOSelfObjCmd(
 	return TCL_OK;
     case SELF_NS:
 	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		contextPtr->oPtr->namespacePtr->fullName,-1));
+		contextPtr->oPtr->namespacePtr->fullName, TCL_INDEX_NONE));
 	return TCL_OK;
     case SELF_CLASS: {
 	Class *clsPtr = CurrentlyInvoked(contextPtr).mPtr->declaringClassPtr;
diff --git a/generic/tclPathObj.c b/generic/tclPathObj.c
index 19c1b9d..b14fd8a 100644
--- a/generic/tclPathObj.c
+++ b/generic/tclPathObj.c
@@ -65,7 +65,7 @@ typedef struct {
 				 *  normPathPtr exists and is absolute. */
     int flags;			/* Flags to describe interpretation - see
 				 * below. */
-    ClientData nativePathPtr;	/* Native representation of this path, which
+    void *nativePathPtr;	/* Native representation of this path, which
 				 * is filesystem dependent. */
     size_t filesystemEpoch;	/* Used to ensure the path representation was
 				 * generated during the correct filesystem
@@ -1489,7 +1489,7 @@ MakePathFromNormalized(
 Tcl_Obj *
 Tcl_FSNewNativePath(
     const Tcl_Filesystem *fromFilesystem,
-    ClientData clientData)
+    void *clientData)
 {
     Tcl_Obj *pathPtr = NULL;
     FsPath *fsPathPtr;
@@ -1927,7 +1927,7 @@ Tcl_FSGetNormalizedPath(
  *---------------------------------------------------------------------------
  */
 
-ClientData
+void *
 Tcl_FSGetInternalRep(
     Tcl_Obj *pathPtr,
     const Tcl_Filesystem *fsPtr)
@@ -2074,7 +2074,7 @@ void
 TclFSSetPathDetails(
     Tcl_Obj *pathPtr,
     const Tcl_Filesystem *fsPtr,
-    ClientData clientData)
+    void *clientData)
 {
     FsPath *srcFsPathPtr;
 
@@ -2368,7 +2368,7 @@ UpdateStringOfFsPath(
 int
 TclNativePathInFilesystem(
     Tcl_Obj *pathPtr,
-    TCL_UNUSED(ClientData *))
+    TCL_UNUSED(void **))
 {
     /*
      * A special case is required to handle the empty path "". This is a valid
diff --git a/generic/tclPkg.c b/generic/tclPkg.c
index 132a219..989f133 100644
--- a/generic/tclPkg.c
+++ b/generic/tclPkg.c
@@ -96,15 +96,15 @@ static void		AddRequirementsToResult(Tcl_Interp *interp, int reqc,
 static void		AddRequirementsToDString(Tcl_DString *dstring,
 			    int reqc, Tcl_Obj *const reqv[]);
 static Package *	FindPackage(Tcl_Interp *interp, const char *name);
-static int		PkgRequireCore(ClientData data[], Tcl_Interp *interp, int result);
-static int		PkgRequireCoreFinal(ClientData data[], Tcl_Interp *interp, int result);
-static int		PkgRequireCoreCleanup(ClientData data[], Tcl_Interp *interp, int result);
-static int		PkgRequireCoreStep1(ClientData data[], Tcl_Interp *interp, int result);
-static int		PkgRequireCoreStep2(ClientData data[], Tcl_Interp *interp, int result);
-static int		TclNRPkgRequireProc(ClientData clientData, Tcl_Interp *interp, int reqc, Tcl_Obj *const reqv[]);
-static int		SelectPackage(ClientData data[], Tcl_Interp *interp, int result);
-static int		SelectPackageFinal(ClientData data[], Tcl_Interp *interp, int result);
-static int		TclNRPackageObjCmdCleanup(ClientData data[], Tcl_Interp *interp, int result);
+static int		PkgRequireCore(void *data[], Tcl_Interp *interp, int result);
+static int		PkgRequireCoreFinal(void *data[], Tcl_Interp *interp, int result);
+static int		PkgRequireCoreCleanup(void *data[], Tcl_Interp *interp, int result);
+static int		PkgRequireCoreStep1(void *data[], Tcl_Interp *interp, int result);
+static int		PkgRequireCoreStep2(void *data[], Tcl_Interp *interp, int result);
+static int		TclNRPkgRequireProc(void *clientData, Tcl_Interp *interp, int reqc, Tcl_Obj *const reqv[]);
+static int		SelectPackage(void *data[], Tcl_Interp *interp, int result);
+static int		SelectPackageFinal(void *data[], Tcl_Interp *interp, int result);
+static int		TclNRPackageObjCmdCleanup(void *data[], Tcl_Interp *interp, int result);
 
 /*
  * Helper macros.
@@ -225,7 +225,7 @@ Tcl_PkgProvideEx(
 
 static void
 PkgFilesCleanupProc(
-    ClientData clientData,
+    void *clientData,
     TCL_UNUSED(Tcl_Interp *))
 {
     PkgFiles *pkgFiles = (PkgFiles *) clientData;
@@ -442,7 +442,7 @@ Tcl_PkgRequireProc(
 
 static int
 TclNRPkgRequireProc(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,
     int reqc,
     Tcl_Obj *const reqv[])
@@ -457,12 +457,12 @@ TclNRPkgRequireProc(
 
 static int
 PkgRequireCore(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     TCL_UNUSED(int))
 {
     const char *name = (const char *)data[0];
-    int reqc = PTR2INT(data[1]);
+    int reqc = (int)PTR2INT(data[1]);
     Tcl_Obj **reqv = (Tcl_Obj **)data[2];
     int code = CheckAllRequirements(interp, reqc, reqv);
     Require *reqPtr;
@@ -488,14 +488,14 @@ PkgRequireCore(
 
 static int
 PkgRequireCoreStep1(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     TCL_UNUSED(int))
 {
     Tcl_DString command;
     char *script;
     Require *reqPtr = (Require *)data[0];
-    int reqc = PTR2INT(data[1]);
+    int reqc = (int)PTR2INT(data[1]);
     Tcl_Obj **const reqv = (Tcl_Obj **)data[2];
     const char *name = reqPtr->name /* Name of desired package. */;
 
@@ -547,12 +547,12 @@ PkgRequireCoreStep1(
 
 static int
 PkgRequireCoreStep2(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     int result)
 {
     Require *reqPtr = (Require *)data[0];
-    int reqc = PTR2INT(data[1]);
+    int reqc = (int)PTR2INT(data[1]);
     Tcl_Obj **const reqv = (Tcl_Obj **)data[2];
     const char *name = reqPtr->name; /* Name of desired package. */
 
@@ -582,12 +582,12 @@ PkgRequireCoreStep2(
 
 static int
 PkgRequireCoreFinal(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     TCL_UNUSED(int))
 {
     Require *reqPtr = (Require *)data[0];
-    int reqc = PTR2INT(data[1]), satisfies;
+    int reqc = (int)PTR2INT(data[1]), satisfies;
     Tcl_Obj **const reqv = (Tcl_Obj **)data[2];
     char *pkgVersionI;
     void *clientDataPtr = reqPtr->clientDataPtr;
@@ -634,7 +634,7 @@ PkgRequireCoreFinal(
 
 static int
 PkgRequireCoreCleanup(
-    ClientData data[],
+    void *data[],
     TCL_UNUSED(Tcl_Interp *),
     int result)
 {
@@ -644,7 +644,7 @@ PkgRequireCoreCleanup(
 
 static int
 SelectPackage(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     TCL_UNUSED(int))
 {
@@ -653,7 +653,7 @@ SelectPackage(
 				/* Internal rep. of versions */
     int availStable, satisfies;
     Require *reqPtr = (Require *)data[0];
-    int reqc = PTR2INT(data[1]);
+    int reqc = (int)PTR2INT(data[1]);
     Tcl_Obj **const reqv = (Tcl_Obj **)data[2];
     const char *name = reqPtr->name;
     Package *pkgPtr = reqPtr->pkgPtr;
@@ -847,12 +847,12 @@ SelectPackage(
 
 static int
 SelectPackageFinal(
-    ClientData data[],
+    void *data[],
     Tcl_Interp *interp,
     int result)
 {
     Require *reqPtr = (Require *)data[0];
-    int reqc = PTR2INT(data[1]);
+    int reqc = (int)PTR2INT(data[1]);
     Tcl_Obj **const reqv = (Tcl_Obj **)data[2];
     const char *name = reqPtr->name;
     char *versionToProvide = reqPtr->versionToProvide;
@@ -1053,7 +1053,7 @@ Tcl_PkgPresentEx(
  */
 int
 Tcl_PackageObjCmd(
-    ClientData clientData,
+    void *clientData,
     Tcl_Interp *interp,		/* Current interpreter. */
     int objc,			/* Number of arguments. */
     Tcl_Obj *const objv[])	/* Argument objects. */
@@ -1539,7 +1539,7 @@ TclNRPackageObjCmd(
 
 static int
 TclNRPackageObjCmdCleanup(
-    ClientData data[],
+    void *data[],
     TCL_UNUSED(Tcl_Interp *),
     int result)
 {
diff --git a/generic/tclPreserve.c b/generic/tclPreserve.c
index 5bc0a1a..ff4b45b 100644
--- a/generic/tclPreserve.c
+++ b/generic/tclPreserve.c
@@ -21,7 +21,7 @@
  */
 
 typedef struct {
-    ClientData clientData;	/* Address of preserved block. */
+    void *clientData;	/* Address of preserved block. */
     size_t refCount;		/* Number of Tcl_Preserve calls in effect for
 				 * block. */
     int mustFree;		/* Non-zero means Tcl_EventuallyFree was
@@ -117,7 +117,7 @@ TclFinalizePreserve(void)
 
 void
 Tcl_Preserve(
-    ClientData clientData)	/* Pointer to malloc'ed block of memory. */
+    void *clientData)	/* Pointer to malloc'ed block of memory. */
 {
     Reference *refPtr;
     size_t i;
@@ -180,7 +180,7 @@ Tcl_Preserve(
 
 void
 Tcl_Release(
-    ClientData clientData)	/* Pointer to malloc'ed block of memory. */
+    void *clientData)	/* Pointer to malloc'ed block of memory. */
 {
     Reference *refPtr;
     size_t i;
@@ -259,7 +259,7 @@ Tcl_Release(
 
 void
 Tcl_EventuallyFree(
-    ClientData clientData,	/* Pointer to malloc'ed block of memory. */
+    void *clientData,	/* Pointer to malloc'ed block of memory. */
     Tcl_FreeProc *freeProc)	/* Function to actually do free. */
 {
     Reference *refPtr;
diff --git a/tests/fCmd.test b/tests/fCmd.test
index d60e58c..dcfe270 100644
--- a/tests/fCmd.test
+++ b/tests/fCmd.test
@@ -136,7 +136,7 @@ proc gethomedirglob {user} {
             set sid [string trim $sid]
             # Get path from the Windows registry
             set home [registry get "HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList\\$sid" ProfileImagePath]
-            set home [string trim $home]
+            set home [string trim [string tolower $home]]
         } result]} {
             if {$home ne ""} {
                 # file join for \ -> /
@@ -147,7 +147,7 @@ proc gethomedirglob {user} {
 
     # Caller will need to use glob matching and hope user
     # name is in the home directory path
-    return *$user*
+    return *[string tolower $user]*
 }
 
 proc createfile {file {string a}} {
diff --git a/unix/tclSelectNotfy.c b/unix/tclSelectNotfy.c
index 7d14c26..feabfa8 100644
--- a/unix/tclSelectNotfy.c
+++ b/unix/tclSelectNotfy.c
@@ -32,7 +32,7 @@ typedef struct FileHandler {
 				 * for this file. */
     Tcl_FileProc *proc;		/* Function to call, in the style of
 				 * Tcl_CreateFileHandler. */
-    ClientData clientData;	/* Argument to pass to proc. */
+    void *clientData;	/* Argument to pass to proc. */
     struct FileHandler *nextPtr;/* Next in list of all files we care about. */
 } FileHandler;
 
@@ -214,7 +214,7 @@ static sigset_t allSigMask;
  */
 
 #if TCL_THREADS
-static TCL_NORETURN void NotifierThreadProc(ClientData clientData);
+static TCL_NORETURN void NotifierThreadProc(void *clientData);
 #if defined(HAVE_PTHREAD_ATFORK)
 static int atForkInit = 0;
 static void		AtForkChild(void);
@@ -313,7 +313,7 @@ static unsigned int __stdcall	NotifierProc(void *hwnd, unsigned int message,
  *----------------------------------------------------------------------
  */
 
-ClientData
+void *
 TclpInitNotifier(void)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
@@ -480,7 +480,7 @@ TclpCreateFileHandler(
 				 * called. */
     Tcl_FileProc *proc,		/* Function to call for each selected
 				 * event. */
-    ClientData clientData)	/* Arbitrary data to pass to proc. */
+    void *clientData)	/* Arbitrary data to pass to proc. */
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     FileHandler *filePtr = LookUpFileHandler(tsdPtr, fd, NULL);
@@ -1179,7 +1179,7 @@ NotifierThreadProc(
 	 */
 
 	do {
-	    i = read(receivePipe, buf, 1);
+	    i = (int)read(receivePipe, buf, 1);
 	    if (i <= 0) {
 		break;
 	    } else if ((i == 0) || ((i == 1) && (buf[0] == 'q'))) {
diff --git a/unix/tclUnixFile.c b/unix/tclUnixFile.c
index 830ed6f..673aa72 100644
--- a/unix/tclUnixFile.c
+++ b/unix/tclUnixFile.c
@@ -709,9 +709,9 @@ TclpObjLstat(
  *----------------------------------------------------------------------
  */
 
-ClientData
+void *
 TclpGetNativeCwd(
-    ClientData clientData)
+    void *clientData)
 {
     char buffer[MAXPATHLEN+1];
 
@@ -813,7 +813,7 @@ TclpReadlink(
 {
 #ifndef DJGPP
     char link[MAXPATHLEN];
-    int length;
+    ssize_t length;
     const char *native;
     Tcl_DString ds;
 
@@ -825,7 +825,7 @@ TclpReadlink(
 	return NULL;
     }
 
-    Tcl_ExternalToUtfDStringEx(NULL, link, length, TCL_ENCODING_NOCOMPLAIN, linkPtr);
+    Tcl_ExternalToUtfDStringEx(NULL, link, (size_t)length, TCL_ENCODING_NOCOMPLAIN, linkPtr);
     return Tcl_DStringValue(linkPtr);
 #else
     return NULL;
@@ -979,7 +979,7 @@ TclpObjLink(
 	Tcl_Obj *linkPtr = NULL;
 
 	char link[MAXPATHLEN];
-	int length;
+	ssize_t length;
 	Tcl_DString ds;
 	Tcl_Obj *transPtr;
 
@@ -994,7 +994,7 @@ TclpObjLink(
 	    return NULL;
 	}
 
-	Tcl_ExternalToUtfDStringEx(NULL, link, length, TCL_ENCODING_NOCOMPLAIN, &ds);
+	Tcl_ExternalToUtfDStringEx(NULL, link, (size_t)length, TCL_ENCODING_NOCOMPLAIN, &ds);
 	linkPtr = Tcl_DStringToObj(&ds);
 	Tcl_IncrRefCount(linkPtr);
 	return linkPtr;
@@ -1055,7 +1055,7 @@ TclpFilesystemPathType(
 
 Tcl_Obj *
 TclpNativeToNormalized(
-    ClientData clientData)
+    void *clientData)
 {
     Tcl_DString ds;
 
@@ -1079,7 +1079,7 @@ TclpNativeToNormalized(
  *---------------------------------------------------------------------------
  */
 
-ClientData
+void *
 TclNativeCreateNativeRep(
     Tcl_Obj *pathPtr)
 {
@@ -1146,9 +1146,9 @@ TclNativeCreateNativeRep(
  *---------------------------------------------------------------------------
  */
 
-ClientData
+void *
 TclNativeDupInternalRep(
-    ClientData clientData)
+    void *clientData)
 {
     char *copy;
     size_t len;
diff --git a/unix/tclUnixNotfy.c b/unix/tclUnixNotfy.c
index 943e7d7..6ecde5d 100644
--- a/unix/tclUnixNotfy.c
+++ b/unix/tclUnixNotfy.c
@@ -27,7 +27,7 @@ static int		FileHandlerEventProc(Tcl_Event *evPtr, int flags);
 # define NOTIFIER_SELECT
 #elif !defined(NOTIFIER_EPOLL) && !defined(NOTIFIER_KQUEUE)
 # define NOTIFIER_SELECT
-static TCL_NORETURN void NotifierThreadProc(ClientData clientData);
+static TCL_NORETURN void NotifierThreadProc(void *clientData);
 # if defined(HAVE_PTHREAD_ATFORK)
 static void		AtForkChild(void);
 # endif /* HAVE_PTHREAD_ATFORK */
@@ -497,13 +497,13 @@ AtForkChild(void)
  *----------------------------------------------------------------------
  */
 
-ClientData
+void *
 TclpNotifierData(void)
 {
 #if defined(NOTIFIER_EPOLL) || defined(NOTIFIER_KQUEUE)
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
-    return (ClientData) tsdPtr;
+    return (void *) tsdPtr;
 #else
     return NULL;
 #endif
diff --git a/unix/tclUnixThrd.c b/unix/tclUnixThrd.c
index 36f0648..cf3b7a1 100644
--- a/unix/tclUnixThrd.c
+++ b/unix/tclUnixThrd.c
@@ -213,7 +213,7 @@ int
 TclpThreadCreate(
     Tcl_ThreadId *idPtr,	/* Return, the ID of the thread */
     Tcl_ThreadCreateProc *proc,	/* Main() function of the thread */
-    ClientData clientData,	/* The one argument to Main() */
+    void *clientData,	/* The one argument to Main() */
     size_t stackSize,		/* Size of stack for the new thread */
     int flags)			/* Flags controlling behaviour of the new
 				 * thread. */
diff --git a/win/tclWinFile.c b/win/tclWinFile.c
index 4c63222..b16a707 100644
--- a/win/tclWinFile.c
+++ b/win/tclWinFile.c
@@ -170,7 +170,7 @@ static int		NativeWriteReparse(const WCHAR *LinkDirectory,
 static int		NativeMatchType(int isDrive, DWORD attr,
 			    const WCHAR *nativeName, Tcl_GlobTypeData *types);
 static int		WinIsDrive(const char *name, size_t nameLen);
-static Tcl_Size		WinIsReserved(const char *path);
+static size_t		WinIsReserved(const char *path);
 static Tcl_Obj *	WinReadLink(const WCHAR *LinkSource);
 static Tcl_Obj *	WinReadLinkDirectory(const WCHAR *LinkDirectory);
 static int		WinLink(const WCHAR *LinkSource,
@@ -921,7 +921,7 @@ TclpMatchInDirectory(
 
 	    DWORD attr;
 	    WIN32_FILE_ATTRIBUTE_DATA data;
-	    Tcl_Size len = 0;
+	    size_t len = 0;
 	    const char *str = Tcl_GetStringFromObj(norm, &len);
 
 	    native = (const WCHAR *)Tcl_FSGetNativePath(pathPtr);
@@ -943,7 +943,7 @@ TclpMatchInDirectory(
 	WIN32_FIND_DATAW data;
 	const char *dirName;	/* UTF-8 dir name, later with pattern
 				 * appended. */
-	Tcl_Size dirLength;
+	size_t dirLength;
 	int matchSpecialDots;
 	Tcl_DString ds;		/* Native encoding of dir, also used
 				 * temporarily for other things. */
@@ -1226,7 +1226,7 @@ WinIsDrive(
  * (not any trailing :).
  */
 
-static Tcl_Size
+static size_t
 WinIsReserved(
     const char *path)		/* Path in UTF-8 */
 {
@@ -2560,14 +2560,14 @@ TclpObjNormalizePath(
 		 */
 
 		if (isDrive) {
-		    Tcl_Size len = WinIsReserved(path);
+		    size_t len = WinIsReserved(path);
 
 		    if (len > 0) {
 			/*
 			 * Actually it does exist - COM1, etc.
 			 */
 
-			Tcl_Size i;
+			size_t i;
 
 			for (i=0 ; i<len ; i++) {
 			    WCHAR wc = ((WCHAR *)nativePath)[i];
@@ -2796,7 +2796,7 @@ TclpObjNormalizePath(
 	     */
 
 	    Tcl_Obj *tmpPathPtr;
-	    Tcl_Size len;
+	    size_t len;
 
 	    tmpPathPtr = Tcl_NewStringObj(Tcl_DStringValue(&ds),
 		    nextCheckpoint);
@@ -2885,7 +2885,7 @@ TclWinVolumeRelativeNormalize(
 	 * also on drive C.
 	 */
 
-	Tcl_Size cwdLen;
+	size_t cwdLen;
 	const char *drive = Tcl_GetStringFromObj(useThisCwd, &cwdLen);
 	char drive_cur = path[0];
 
@@ -2959,7 +2959,7 @@ TclpNativeToNormalized(
 {
     Tcl_DString ds;
     Tcl_Obj *objPtr;
-    Tcl_Size len;
+    size_t len;
     char *copy, *p;
 
     Tcl_DStringInit(&ds);
@@ -3022,7 +3022,7 @@ TclNativeCreateNativeRep(
     WCHAR *nativePathPtr = NULL;
     const char *str;
     Tcl_Obj *validPathPtr;
-    Tcl_Size len;
+    size_t len;
     WCHAR *wp;
 
     if (TclFSCwdIsNative()) {
diff --git a/win/tclWinLoad.c b/win/tclWinLoad.c
index ccedb9d..893313c 100644
--- a/win/tclWinLoad.c
+++ b/win/tclWinLoad.c
@@ -175,7 +175,7 @@ TclpDlopen(
      */
 
     handlePtr = (Tcl_LoadHandle)Tcl_Alloc(sizeof(struct Tcl_LoadHandle_));
-    handlePtr->clientData = (ClientData) hInstance;
+    handlePtr->clientData = (void *)hInstance;
     handlePtr->findSymbolProcPtr = &FindSymbol;
     handlePtr->unloadFileProcPtr = &UnloadFile;
     *loadHandle = handlePtr;
diff --git a/win/tclWinNotify.c b/win/tclWinNotify.c
index ec6fd51..bcb4e08 100644
--- a/win/tclWinNotify.c
+++ b/win/tclWinNotify.c
@@ -76,7 +76,7 @@ static LRESULT CALLBACK		NotifierProc(HWND hwnd, UINT message,
  *----------------------------------------------------------------------
  */
 
-ClientData
+void *
 TclpInitNotifier(void)
 {
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
@@ -148,7 +148,7 @@ TclpInitNotifier(void)
 
 void
 TclpFinalizeNotifier(
-    ClientData clientData)	/* Pointer to notifier data. */
+    void *clientData)	/* Pointer to notifier data. */
 {
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *) clientData;
 
@@ -218,7 +218,7 @@ TclpFinalizeNotifier(
 
 void
 TclpAlertNotifier(
-    ClientData clientData)	/* Pointer to thread data. */
+    void *clientData)	/* Pointer to thread data. */
 {
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *) clientData;
 
@@ -287,7 +287,7 @@ TclpSetTimer(
 	 * Windows seems to get confused by zero length timers.
 	 */
 
-	timeout = timePtr->sec * 1000 + timePtr->usec / 1000;
+	timeout = (UINT)timePtr->sec * 1000 + (unsigned long)timePtr->usec / 1000;
 	if (timeout == 0) {
 	    timeout = 1;
 	}
@@ -437,7 +437,7 @@ NotifierProc(
  *----------------------------------------------------------------------
  */
 
-ClientData
+void *
 TclpNotifierData(void)
 {
     return NULL;
@@ -490,7 +490,7 @@ TclpWaitForEvent(
 	    TclScaleTime(&myTime);
 	}
 
-	timeout = myTime.sec * 1000 + myTime.usec / 1000;
+	timeout = (DWORD)myTime.sec * 1000 + (unsigned long)myTime.usec / 1000;
     } else {
 	timeout = INFINITE;
     }
@@ -610,7 +610,7 @@ Tcl_Sleep(
      */
 
     TclScaleTime(&vdelay);
-    sleepTime = vdelay.sec * 1000 + vdelay.usec / 1000;
+    sleepTime = (DWORD)vdelay.sec * 1000 + (unsigned long)vdelay.usec / 1000;
 
     for (;;) {
 	SleepEx(sleepTime, TRUE);
@@ -625,7 +625,7 @@ Tcl_Sleep(
 	vdelay.usec = desired.usec - now.usec;
 
 	TclScaleTime(&vdelay);
-	sleepTime = vdelay.sec * 1000 + vdelay.usec / 1000;
+	sleepTime = (DWORD)vdelay.sec * 1000 + (unsigned long)vdelay.usec / 1000;
     }
 }
 
diff --git a/win/tclWinPipe.c b/win/tclWinPipe.c
index b7949d1..84e6ab0 100644
--- a/win/tclWinPipe.c
+++ b/win/tclWinPipe.c
@@ -104,7 +104,7 @@ typedef struct PipeInfo {
     TclFile readFile;		/* Output from pipe. */
     TclFile writeFile;		/* Input from pipe. */
     TclFile errorFile;		/* Error output from pipe. */
-    Tcl_Size numPids;		/* Number of processes attached to pipe. */
+    size_t numPids;		/* Number of processes attached to pipe. */
     Tcl_Pid *pidPtr;		/* Pids of attached processes. */
     Tcl_ThreadId threadId;	/* Thread to which events should be reported.
 				 * This value is used by the reader/writer
@@ -171,7 +171,7 @@ typedef struct {
 
 static int		ApplicationType(Tcl_Interp *interp,
 			    const char *fileName, char *fullName);
-static void		BuildCommandLine(const char *executable, Tcl_Size argc,
+static void		BuildCommandLine(const char *executable, size_t argc,
 			    const char **argv, Tcl_DString *linePtr);
 static BOOL		HasConsole(void);
 static int		PipeBlockModeProc(void *instanceData, int mode);
@@ -859,7 +859,7 @@ TclpCloseFile(
  *--------------------------------------------------------------------------
  */
 
-Tcl_Size
+size_t
 TclpGetPid(
     Tcl_Pid pid)		/* The HANDLE of the child process. */
 {
@@ -911,7 +911,7 @@ TclpCreateProcess(
 				 * occurred when creating the child process.
 				 * Error messages from the child process
 				 * itself are sent to errorFile. */
-    Tcl_Size argc,			/* Number of arguments in following array. */
+    size_t argc,			/* Number of arguments in following array. */
     const char **argv,		/* Array of argument strings. argv[0] contains
 				 * the name of the executable converted to
 				 * native format (using the
@@ -1536,14 +1536,14 @@ static void
 BuildCommandLine(
     const char *executable,	/* Full path of executable (including
 				 * extension). Replacement for argv[0]. */
-    Tcl_Size argc,			/* Number of arguments. */
+    size_t argc,			/* Number of arguments. */
     const char **argv,		/* Argument strings in UTF. */
     Tcl_DString *linePtr)	/* Initialized Tcl_DString that receives the
 				 * command line (WCHAR). */
 {
     const char *arg, *start, *special, *bspos;
     int quote = 0;
-    Tcl_Size i;
+    size_t i;
     Tcl_DString ds;
     static const char specMetaChars[] = "&|^<>!()%";
 				/* Characters to enclose in quotes if unpaired
@@ -1760,7 +1760,7 @@ TclpCreateCommandChannel(
     TclFile writeFile,		/* If non-null, gives the file for writing. */
     TclFile errorFile,		/* If non-null, gives the file where errors
 				 * can be read. */
-    Tcl_Size numPids,		/* The number of pids in the pid array. */
+    size_t numPids,		/* The number of pids in the pid array. */
     Tcl_Pid *pidPtr)		/* An array of process identifiers. */
 {
     char channelName[16 + TCL_INTEGER_SPACE];
@@ -1900,7 +1900,7 @@ TclGetAndDetachPids(
     PipeInfo *pipePtr;
     const Tcl_ChannelType *chanTypePtr;
     Tcl_Obj *pidsObj;
-    Tcl_Size i;
+    size_t i;
 
     /*
      * Punt if the channel is not a command channel.
@@ -2744,7 +2744,7 @@ Tcl_PidObjCmd(
     Tcl_Channel chan;
     const Tcl_ChannelType *chanTypePtr;
     PipeInfo *pipePtr;
-    Tcl_Size i;
+    size_t i;
     Tcl_Obj *resultPtr;
 
     if (objc > 2) {
@@ -3191,7 +3191,7 @@ TclpOpenTemporaryFile(
     char *namePtr;
     HANDLE handle;
     DWORD flags = FILE_ATTRIBUTE_TEMPORARY;
-    Tcl_Size length;
+    size_t length;
     int counter, counter2;
     Tcl_DString buf;
 
diff --git a/win/tclWinSerial.c b/win/tclWinSerial.c
index 3db36d5..78b47b9 100644
--- a/win/tclWinSerial.c
+++ b/win/tclWinSerial.c
@@ -85,7 +85,7 @@ typedef struct SerialInfo {
     int readable;		/* Flag that the channel is readable. */
     int writable;		/* Flag that the channel is writable. */
     int blockTime;		/* Maximum blocktime in msec. */
-    unsigned int lastEventTime;	/* Time in milliseconds since last readable
+    unsigned long long lastEventTime;	/* Time in milliseconds since last readable
 				 * event. */
 				/* Next readable event only after blockTime */
     DWORD error;		/* pending error code returned by
@@ -165,30 +165,30 @@ static COMMTIMEOUTS no_timeout = {
  * Declarations for functions used only in this file.
  */
 
-static int		SerialBlockProc(ClientData instanceData, int mode);
-static void		SerialCheckProc(ClientData clientData, int flags);
-static int		SerialCloseProc(ClientData instanceData,
+static int		SerialBlockProc(void *instanceData, int mode);
+static void		SerialCheckProc(void *clientData, int flags);
+static int		SerialCloseProc(void *instanceData,
 			    Tcl_Interp *interp, int flags);
 static int		SerialEventProc(Tcl_Event *evPtr, int flags);
-static void		SerialExitHandler(ClientData clientData);
-static int		SerialGetHandleProc(ClientData instanceData,
-			    int direction, ClientData *handlePtr);
+static void		SerialExitHandler(void *clientData);
+static int		SerialGetHandleProc(void *instanceData,
+			    int direction, void **handlePtr);
 static ThreadSpecificData *SerialInit(void);
-static int		SerialInputProc(ClientData instanceData, char *buf,
+static int		SerialInputProc(void *instanceData, char *buf,
 			    int toRead, int *errorCode);
-static int		SerialOutputProc(ClientData instanceData,
+static int		SerialOutputProc(void *instanceData,
 			    const char *buf, int toWrite, int *errorCode);
-static void		SerialSetupProc(ClientData clientData, int flags);
-static void		SerialWatchProc(ClientData instanceData, int mask);
-static void		ProcExitHandler(ClientData clientData);
-static int		SerialGetOptionProc(ClientData instanceData,
+static void		SerialSetupProc(void *clientData, int flags);
+static void		SerialWatchProc(void *instanceData, int mask);
+static void		ProcExitHandler(void *clientData);
+static int		SerialGetOptionProc(void *instanceData,
 			    Tcl_Interp *interp, const char *optionName,
 			    Tcl_DString *dsPtr);
-static int		SerialSetOptionProc(ClientData instanceData,
+static int		SerialSetOptionProc(void *instanceData,
 			    Tcl_Interp *interp, const char *optionName,
 			    const char *value);
 static DWORD WINAPI	SerialWriterThread(LPVOID arg);
-static void		SerialThreadActionProc(ClientData instanceData,
+static void		SerialThreadActionProc(void *instanceData,
 			    int action);
 static int		SerialBlockingRead(SerialInfo *infoPtr, LPVOID buf,
 			    DWORD bufSize, LPDWORD lpRead, LPOVERLAPPED osPtr);
@@ -373,14 +373,14 @@ SerialBlockTime(
  *----------------------------------------------------------------------
  */
 
-static unsigned int
+static unsigned long long
 SerialGetMilliseconds(void)
 {
     Tcl_Time time;
 
     Tcl_GetTime(&time);
 
-    return (time.sec * 1000 + time.usec / 1000);
+    return ((unsigned long long)time.sec * 1000 + (unsigned long)time.usec / 1000);
 }
 
 /*
@@ -469,7 +469,7 @@ SerialCheckProc(
     int needEvent;
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     COMSTAT cStat;
-    unsigned int time;
+    unsigned long long time;
 
     if (!(flags & TCL_FILE_EVENTS)) {
 	return;
@@ -519,8 +519,8 @@ SerialCheckProc(
 			    (infoPtr->error & SERIAL_READ_ERRORS)) {
 			infoPtr->readable = 1;
 			time = SerialGetMilliseconds();
-			if ((unsigned int) (time - infoPtr->lastEventTime)
-				>= (unsigned int) infoPtr->blockTime) {
+			if ((time - infoPtr->lastEventTime)
+				>= (unsigned long long) infoPtr->blockTime) {
 			    needEvent = 1;
 			    infoPtr->lastEventTime = time;
 			}
@@ -561,7 +561,7 @@ SerialCheckProc(
 
 static int
 SerialBlockProc(
-    ClientData instanceData,    /* Instance data for channel. */
+    void *instanceData,    /* Instance data for channel. */
     int mode)			/* TCL_MODE_BLOCKING or
 				 * TCL_MODE_NONBLOCKING. */
 {
@@ -600,7 +600,7 @@ SerialBlockProc(
 
 static int
 SerialCloseProc(
-    ClientData instanceData,    /* Pointer to SerialInfo structure. */
+    void *instanceData,    /* Pointer to SerialInfo structure. */
     TCL_UNUSED(Tcl_Interp *),
     int flags)
 {
@@ -796,7 +796,7 @@ SerialBlockingWrite(
     LeaveCriticalSection(&infoPtr->csWrite);
 
     if (result == FALSE) {
-	int err = GetLastError();
+	DWORD err = GetLastError();
 
 	switch (err) {
 	case ERROR_IO_PENDING:
@@ -855,7 +855,7 @@ SerialBlockingWrite(
 
 static int
 SerialInputProc(
-    ClientData instanceData,	/* Serial state. */
+    void *instanceData,	/* Serial state. */
     char *buf,			/* Where to store data read. */
     int bufSize,		/* How much space is available in the
 				 * buffer? */
@@ -918,7 +918,7 @@ SerialInputProc(
     }
 
     if (bufSize == 0) {
-	return bytesRead = 0;
+	return 0;
     }
 
     /*
@@ -962,7 +962,7 @@ SerialInputProc(
 
 static int
 SerialOutputProc(
-    ClientData instanceData,	/* Serial state. */
+    void *instanceData,	/* Serial state. */
     const char *buf,		/* The data buffer. */
     int toWrite,		/* How many bytes to write? */
     int *errorCode)		/* Where to store error code. */
@@ -1192,7 +1192,7 @@ SerialEventProc(
 
 static void
 SerialWatchProc(
-    ClientData instanceData,	/* Serial state. */
+    void *instanceData,	/* Serial state. */
     int mask)			/* What events to watch for, OR-ed combination
 				 * of TCL_READABLE, TCL_WRITABLE and
 				 * TCL_EXCEPTION. */
@@ -1249,13 +1249,13 @@ SerialWatchProc(
 
 static int
 SerialGetHandleProc(
-    ClientData instanceData,	/* The serial state. */
+    void *instanceData,	/* The serial state. */
     TCL_UNUSED(int) /*direction*/,
-    ClientData *handlePtr)	/* Where to store the handle. */
+    void **handlePtr)	/* Where to store the handle. */
 {
     SerialInfo *infoPtr = (SerialInfo *) instanceData;
 
-    *handlePtr = (ClientData) infoPtr->handle;
+    *handlePtr = (void *) infoPtr->handle;
     return TCL_OK;
 }
 
@@ -1613,7 +1613,7 @@ SerialModemStatusStr(
 
 static int
 SerialSetOptionProc(
-    ClientData instanceData,	/* File state. */
+    void *instanceData,	/* File state. */
     Tcl_Interp *interp,		/* For error reporting - can be NULL. */
     const char *optionName,	/* Which option to set? */
     const char *value)		/* New value for option. */
@@ -2037,7 +2037,7 @@ SerialSetOptionProc(
 
 static int
 SerialGetOptionProc(
-    ClientData instanceData,	/* File state. */
+    void *instanceData,	/* File state. */
     Tcl_Interp *interp,		/* For error reporting - can be NULL. */
     const char *optionName,	/* Option to get. */
     Tcl_DString *dsPtr)		/* Where to store value(s). */
@@ -2274,7 +2274,7 @@ SerialGetOptionProc(
 
 static void
 SerialThreadActionProc(
-    ClientData instanceData,
+    void *instanceData,
     int action)
 {
     SerialInfo *infoPtr = (SerialInfo *) instanceData;
diff --git a/win/tclWinThrd.c b/win/tclWinThrd.c
index 841a854..0195895 100644
--- a/win/tclWinThrd.c
+++ b/win/tclWinThrd.c
@@ -203,7 +203,7 @@ int
 TclpThreadCreate(
     Tcl_ThreadId *idPtr,	/* Return, the ID of the thread. */
     Tcl_ThreadCreateProc *proc,	/* Main() function of the thread. */
-    ClientData clientData,	/* The one argument to Main(). */
+    void *clientData,	/* The one argument to Main(). */
     size_t stackSize,		/* Size of stack for the new thread. */
     int flags)			/* Flags controlling behaviour of the new
 				 * thread. */
@@ -535,7 +535,7 @@ TclFinalizeLock(void)
 #if TCL_THREADS
 
 /* locally used prototype */
-static void		FinalizeConditionEvent(ClientData data);
+static void		FinalizeConditionEvent(void *data);
 
 /*
  *----------------------------------------------------------------------
@@ -725,7 +725,7 @@ Tcl_ConditionWait(
     if (timePtr == NULL) {
 	wtime = INFINITE;
     } else {
-	wtime = timePtr->sec * 1000 + timePtr->usec / 1000;
+	wtime = (DWORD)timePtr->sec * 1000 + (unsigned long)timePtr->usec / 1000;
     }
 
     /*
@@ -880,7 +880,7 @@ Tcl_ConditionNotify(
 
 static void
 FinalizeConditionEvent(
-    ClientData data)
+    void *data)
 {
     ThreadSpecificData *tsdPtr = (ThreadSpecificData *) data;
 
-- 
cgit v0.12


From 494b4c8127e703f7b20f85dbb342921e36a8b557 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Thu, 9 Mar 2023 20:55:43 +0000
Subject: Fix cmdAH-4.3.13.00D80000.solo.utf-32le.tcl8.a testcase from
 tip-656-tcl9 branch, when TCL_UTF_MAX=3

---
 generic/tclEncoding.c | 39 ++++++++++++++++++++++++++++++++++++---
 win/tclWinTest.c      | 10 +++++-----
 2 files changed, 41 insertions(+), 8 deletions(-)

diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index 61e3236..fc3397a 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -2545,7 +2545,7 @@ Utf32ToUtfProc(
     const char *srcStart, *srcEnd;
     const char *dstEnd, *dstStart;
     int result, numChars, charLimit = INT_MAX;
-    int ch, bytesLeft = srcLen % 4;
+    int ch = 0, bytesLeft = srcLen % 4;
 
     flags |= PTR2INT(clientData);
     if (flags & TCL_ENCODING_CHAR_LIMIT) {
@@ -2562,6 +2562,21 @@ Utf32ToUtfProc(
 	srcLen -= bytesLeft;
     }
 
+#if TCL_UTF_MAX < 4
+    /*
+     * If last code point is a high surrogate, we cannot handle that yet,
+     * unless we are at the end.
+     */
+
+    if (!(flags & TCL_ENCODING_END) && (srcLen >= 4) &&
+	    ((src[srcLen - ((flags & TCL_ENCODING_LE)?3:2)] & 0xFC) == 0xD8) &&
+	    ((src[srcLen - ((flags & TCL_ENCODING_LE)?2:3)]) == 0) &&
+	    ((src[srcLen - ((flags & TCL_ENCODING_LE)?1:4)]) == 0)) {
+	result = TCL_CONVERT_MULTIBYTE;
+	srcLen-= 4;
+    }
+#endif
+
     srcStart = src;
     srcEnd = src + srcLen;
 
@@ -2574,21 +2589,33 @@ Utf32ToUtfProc(
 	    break;
 	}
 
+#if TCL_UTF_MAX < 4
+	int prev = ch;
+#endif
 	if (flags & TCL_ENCODING_LE) {
 	    ch = (src[3] & 0xFF) << 24 | (src[2] & 0xFF) << 16 | (src[1] & 0xFF) << 8 | (src[0] & 0xFF);
 	} else {
 	    ch = (src[0] & 0xFF) << 24 | (src[1] & 0xFF) << 16 | (src[2] & 0xFF) << 8 | (src[3] & 0xFF);
 	}
-	if  ((unsigned)ch > 0x10FFFF) {
+#if TCL_UTF_MAX < 4
+	if (((prev  & ~0x3FF) == 0xD800) && ((ch  & ~0x3FF) != 0xDC00)) {
+	    /* Bug [10c2c17c32]. If Hi surrogate not followed by Lo surrogate, finish 3-byte UTF-8 */
+	    dst += Tcl_UniCharToUtf(-1, dst);
+	}
+#endif
+	if ((unsigned)ch > 0x10FFFF) {
+	    ch = 0xFFFD;
 	    if (STOPONERROR) {
 		result = TCL_CONVERT_SYNTAX;
 		break;
 	    }
-	    ch = 0xFFFD;
 	} else if (((flags & TCL_ENCODING_STRICT) == TCL_ENCODING_STRICT)
 		&& ((ch  & ~0x7FF) == 0xD800)) {
 	    if (STOPONERROR) {
 		result = TCL_CONVERT_SYNTAX;
+#if TCL_UTF_MAX < 4
+		ch = 0;
+#endif
 		break;
 	    }
 	}
@@ -2606,6 +2633,12 @@ Utf32ToUtfProc(
 	src += sizeof(unsigned int);
     }
 
+#if TCL_UTF_MAX < 4
+    if ((ch  & ~0x3FF) == 0xD800) {
+	/* Bug [10c2c17c32]. If Hi surrogate, finish 3-byte UTF-8 */
+	dst += Tcl_UniCharToUtf(-1, dst);
+    }
+#endif
     if ((flags & TCL_ENCODING_END) && (result == TCL_CONVERT_MULTIBYTE)) {
 	/* We have a single byte left-over at the end */
 	if (dst > dstEnd) {
diff --git a/win/tclWinTest.c b/win/tclWinTest.c
index c7abcdc..29bdfe4 100644
--- a/win/tclWinTest.c
+++ b/win/tclWinTest.c
@@ -398,7 +398,7 @@ TestplatformChmod(
     const char *nativePath,
     int pmode)
 {
-    /* 
+    /*
      * Note FILE_DELETE_CHILD missing from dirWriteMask because we do
      * not want overriding of child's delete setting when testing
      */
@@ -406,7 +406,7 @@ TestplatformChmod(
 	FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA |
 	FILE_ADD_FILE | FILE_ADD_SUBDIRECTORY | STANDARD_RIGHTS_WRITE | DELETE |
 	SYNCHRONIZE;
-    static const DWORD dirReadMask = 
+    static const DWORD dirReadMask =
 	FILE_READ_ATTRIBUTES | FILE_READ_EA | FILE_LIST_DIRECTORY |
 	STANDARD_RIGHTS_READ | SYNCHRONIZE;
     /* Note - default user privileges allow ignoring TRAVERSE setting */
@@ -416,7 +416,7 @@ TestplatformChmod(
     static const DWORD fileWriteMask =
 	FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_WRITE_DATA |
 	FILE_APPEND_DATA | STANDARD_RIGHTS_WRITE | DELETE | SYNCHRONIZE;
-    static const DWORD fileReadMask = 
+    static const DWORD fileReadMask =
 	FILE_READ_ATTRIBUTES | FILE_READ_EA | FILE_READ_DATA |
 	STANDARD_RIGHTS_READ | SYNCHRONIZE;
     static const DWORD fileExecuteMask =
@@ -450,7 +450,7 @@ TestplatformChmod(
     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken)) {
 	goto done;
     }
-    
+
     /* Get process SID */
     if (!GetTokenInformation(hToken, TokenUser, NULL, 0, &dw) &&
 	GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
@@ -468,7 +468,7 @@ TestplatformChmod(
 	Tcl_Free(aceEntry[nSids].pSid); /* Since we have not ++'ed nSids */
 	goto done;
     }
-    /* 
+    /*
      * Always include DACL modify rights so we don't get locked out
      */
     aceEntry[nSids].mask = READ_CONTROL | WRITE_DAC | WRITE_OWNER | SYNCHRONIZE |
-- 
cgit v0.12


From 93bf87ed859e04b2fc9b197239ad6838e761e85d Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Fri, 10 Mar 2023 13:32:47 +0000
Subject: Make test less fragile to changing set of options.

---
 tests/io.test | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/io.test b/tests/io.test
index 6d556da..181d028 100644
--- a/tests/io.test
+++ b/tests/io.test
@@ -5620,7 +5620,7 @@ test io-39.16a {Tcl_SetChannelOption: -encoding (invalid shortening to "-e"), er
     fconfigure $f -e foobar
 } -cleanup {
     close $f
-} -returnCodes 1 -result {bad option "-e": should be one of -blocking, -buffering, -buffersize, -encoding, -eofchar, or -translation}
+} -returnCodes 1 -match glob -result {bad option "-e": should be one of *}
 test io-39.17 {Tcl_SetChannelOption: -encoding, clearing CHANNEL_NEED_MORE_DATA} {stdio fileevent} {
     set f [open "|[list [interpreter] $path(cat)]" r+]
     fconfigure $f -encoding binary
-- 
cgit v0.12


From 1889ded1144a4dbd44d0c6f03e72a01d70115a51 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sat, 11 Mar 2023 22:00:29 +0000
Subject: Proposed fix for [db7a085bd9]: encoding convertfrom -strict utf-16
 accepts partial surrogates. TODO: testcases, and implement for 8.7 too

---
 generic/tclCmdAH.c    |  2 +-
 generic/tclEncoding.c | 30 ++++++++++++++++++++++++++----
 2 files changed, 27 insertions(+), 5 deletions(-)

diff --git a/generic/tclCmdAH.c b/generic/tclCmdAH.c
index 4df1216..ac504d0 100644
--- a/generic/tclCmdAH.c
+++ b/generic/tclCmdAH.c
@@ -514,7 +514,7 @@ EncodingConvertfromObjCmd(
 	    char buf[TCL_INTEGER_SPACE];
 	    sprintf(buf, "%" TCL_Z_MODIFIER "u", result);
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf("unexpected byte sequence starting at index %"
-		    TCL_Z_MODIFIER "u: '\\x%X'", result, UCHAR(bytesPtr[result])));
+		    TCL_Z_MODIFIER "u: '\\x%02X'", result, UCHAR(bytesPtr[result])));
 	    Tcl_SetErrorCode(interp, "TCL", "ENCODING", "ILLEGALSEQUENCE",
 		    buf, NULL);
 	    Tcl_DStringFree(&ds);
diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index fc3397a..4f334bb 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -2603,6 +2603,7 @@ Utf32ToUtfProc(
 	    dst += Tcl_UniCharToUtf(-1, dst);
 	}
 #endif
+
 	if ((unsigned)ch > 0x10FFFF) {
 	    ch = 0xFFFD;
 	    if (STOPONERROR) {
@@ -2639,6 +2640,7 @@ Utf32ToUtfProc(
 	dst += Tcl_UniCharToUtf(-1, dst);
     }
 #endif
+
     if ((flags & TCL_ENCODING_END) && (result == TCL_CONVERT_MULTIBYTE)) {
 	/* We have a single byte left-over at the end */
 	if (dst > dstEnd) {
@@ -2846,6 +2848,13 @@ Utf16ToUtfProc(
 	    ch = (src[0] & 0xFF) << 8 | (src[1] & 0xFF);
 	}
 	if (((prev  & ~0x3FF) == 0xD800) && ((ch  & ~0x3FF) != 0xDC00)) {
+	    if (((flags & TCL_ENCODING_STRICT) == TCL_ENCODING_STRICT)) {
+		result = TCL_CONVERT_UNKNOWN;
+		src -= 2; /* Go back to before the high surrogate */
+		dst--; /* Also undo writing a single byte too much */
+		numChars--;
+		break;
+	    }
 	    /* Bug [10c2c17c32]. If Hi surrogate not followed by Lo surrogate, finish 3-byte UTF-8 */
 	    dst += Tcl_UniCharToUtf(-1, dst);
 	}
@@ -2855,17 +2864,30 @@ Utf16ToUtfProc(
 	 * unsigned short-size data.
 	 */
 
-	if (ch && ch < 0x80) {
+	if ((unsigned)ch - 1 < 0x7F) {
 	    *dst++ = (ch & 0xFF);
-	} else {
+	} else if (((prev  & ~0x3FF) == 0xD800) || ((ch  & ~0x3FF) == 0xD800)) {
 	    dst += Tcl_UniCharToUtf(ch | TCL_COMBINE, dst);
+	} else if (((ch  & ~0x3FF) == 0xDC00) && ((flags & TCL_ENCODING_STRICT) == TCL_ENCODING_STRICT)) {
+	    /* Lo surrogate not preceded by Hi surrogate */
+	    result = TCL_CONVERT_UNKNOWN;
+	    break;
+	} else {
+	    dst += Tcl_UniCharToUtf(ch, dst);
 	}
 	src += sizeof(unsigned short);
     }
 
     if ((ch  & ~0x3FF) == 0xD800) {
-	/* Bug [10c2c17c32]. If Hi surrogate, finish 3-byte UTF-8 */
-	dst += Tcl_UniCharToUtf(-1, dst);
+	if ((flags & TCL_ENCODING_STRICT) == TCL_ENCODING_STRICT) {
+	    result = TCL_CONVERT_UNKNOWN;
+	    src -= 2;
+	    dst--;
+	    numChars--;
+	} else {
+	    /* Bug [10c2c17c32]. If Hi surrogate, finish 3-byte UTF-8 */
+	    dst += Tcl_UniCharToUtf(-1, dst);
+	}
     }
     if ((flags & TCL_ENCODING_END) && (result == TCL_CONVERT_MULTIBYTE)) {
 	/* We have a single byte left-over at the end */
-- 
cgit v0.12


From 8c5fc11b5ac89e8e6fd57484c9221a5e70c3c145 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 12 Mar 2023 10:49:18 +0000
Subject: Always output 2 hex characters in "unexpected byte sequence"
 exception message. make testcases io-38.3/chan-io-38.3 independant from
 system encoding

---
 generic/tclCmdAH.c | 2 +-
 tests/chanio.test  | 2 +-
 tests/io.test      | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/generic/tclCmdAH.c b/generic/tclCmdAH.c
index 4f743cc..c2424d6 100644
--- a/generic/tclCmdAH.c
+++ b/generic/tclCmdAH.c
@@ -656,7 +656,7 @@ EncodingConvertfromObjCmd(
 	    char buf[TCL_INTEGER_SPACE];
 	    sprintf(buf, "%u", result);
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf("unexpected byte sequence starting at index %"
-		    "u: '\\x%X'", result, UCHAR(bytesPtr[result])));
+		    "u: '\\x%02X'", result, UCHAR(bytesPtr[result])));
 	    Tcl_SetErrorCode(interp, "TCL", "ENCODING", "ILLEGALSEQUENCE",
 		    buf, NULL);
 	    Tcl_DStringFree(&ds);
diff --git a/tests/chanio.test b/tests/chanio.test
index 2915fc5..6814224 100644
--- a/tests/chanio.test
+++ b/tests/chanio.test
@@ -4982,7 +4982,7 @@ test chan-io-38.2 {Tcl_SetChannelBufferSize, Tcl_GetChannelBufferSize} -setup {
 test chan-io-38.3 {Tcl_SetChannelBufferSize, changing buffersize between reads} {
     # This test crashes the interp if Bug #427196 is not fixed
     set chan [open [info script] r]
-    chan configure $chan -buffersize 10
+    chan configure $chan -buffersize 10 -encoding utf-8
     set var [chan read $chan 2]
     chan configure $chan -buffersize 32
     append var [chan read $chan]
diff --git a/tests/io.test b/tests/io.test
index e762bba..3c0ec2e 100644
--- a/tests/io.test
+++ b/tests/io.test
@@ -5476,7 +5476,7 @@ test io-38.3 {Tcl_SetChannelBufferSize, changing buffersize between reads} {
     # This test crashes the interp if Bug #427196 is not fixed
 
     set chan [open [info script] r]
-    fconfigure $chan -buffersize 10
+    fconfigure $chan -buffersize 10 -encoding utf-8
     set var [read $chan 2]
     fconfigure $chan -buffersize 32
     append var [read $chan]
-- 
cgit v0.12


From b7f151f1268d4b49953da193f135d52e6e52f841 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 12 Mar 2023 11:24:24 +0000
Subject: Make test-output more readable when it contains non-printable
 characters (stolen from TIP #656 impl, thanks Ashok!) tcltest -> 2.5.6

---
 library/manifest.txt         |  2 +-
 library/tcltest/pkgIndex.tcl |  2 +-
 library/tcltest/tcltest.tcl  | 39 ++++++++++++++++++++++++++++++++++++---
 unix/Makefile.in             |  4 ++--
 win/Makefile.in              |  4 ++--
 5 files changed, 42 insertions(+), 9 deletions(-)

diff --git a/library/manifest.txt b/library/manifest.txt
index cc1e223..5a999f4 100644
--- a/library/manifest.txt
+++ b/library/manifest.txt
@@ -12,7 +12,7 @@ apply {{dir} {
     0 tcl::idna       1.0.1  {cookiejar idna.tcl}
     0 platform        1.0.19 {platform platform.tcl}
     0 platform::shell 1.1.4  {platform shell.tcl}
-    1 tcltest         2.5.5  {tcltest tcltest.tcl}
+    1 tcltest         2.5.6  {tcltest tcltest.tcl}
   } {
     if {$isafe && !$safe} continue
     package ifneeded $package $version  [list source [file join $dir {*}$file]]
diff --git a/library/tcltest/pkgIndex.tcl b/library/tcltest/pkgIndex.tcl
index 18b05e5..9903e32 100644
--- a/library/tcltest/pkgIndex.tcl
+++ b/library/tcltest/pkgIndex.tcl
@@ -9,4 +9,4 @@
 # full path name of this file's directory.
 
 if {![package vsatisfies [package provide Tcl] 8.5-]} {return}
-package ifneeded tcltest 2.5.5 [list source [file join $dir tcltest.tcl]]
+package ifneeded tcltest 2.5.6 [list source [file join $dir tcltest.tcl]]
diff --git a/library/tcltest/tcltest.tcl b/library/tcltest/tcltest.tcl
index 7344f9f..19b7d64 100644
--- a/library/tcltest/tcltest.tcl
+++ b/library/tcltest/tcltest.tcl
@@ -22,7 +22,7 @@ namespace eval tcltest {
     # When the version number changes, be sure to update the pkgIndex.tcl file,
     # and the install directory in the Makefiles.  When the minor version
     # changes (new feature) be sure to update the man page as well.
-    variable Version 2.5.5
+    variable Version 2.5.6
 
     # Compatibility support for dumb variables defined in tcltest 1
     # Do not use these.  Call [package provide Tcl] and [info patchlevel]
@@ -1134,6 +1134,39 @@ proc tcltest::SafeFetch {n1 n2 op} {
     }
 }
 
+
+# tcltest::Asciify --
+#
+#       Transforms the passed string to contain only printable ascii characters.
+#       Useful for printing to terminals. Non-printables are mapped to
+#       \x, \u or \U sequences.
+#
+# Arguments:
+#       s - string to transform
+#
+# Results:
+#       The transformed strings
+#
+# Side effects:
+#       None.
+
+proc tcltest::Asciify {s} {
+    set print ""
+    foreach c [split $s ""] {
+        set i [scan $c %c]
+        if {[string is print $c] && ($i <= 127) && ($i > 0)} {
+            append print $c
+        } elseif {$i <= 0xFF} {
+            append print \\x[format %02X $i]
+        } elseif {$i <= 0xFFFF} {
+            append print \\u[format %04X $i]
+        } else {
+            append print \\U[format %08X $i]
+        }
+    }
+    return $print
+}
+
 # tcltest::ConstraintInitializer --
 #
 #	Get or set a script that when evaluated in the tcltest namespace
@@ -2221,9 +2254,9 @@ proc tcltest::test {name description args} {
 	if {$scriptCompare} {
 	    puts [outputChannel] "---- Error testing result: $scriptMatch"
 	} else {
-	    puts [outputChannel] "---- Result was:\n$actualAnswer"
+	    puts [outputChannel] "---- Result was:\n[Asciify $actualAnswer]"
 	    puts [outputChannel] "---- Result should have been\
-		    ($match matching):\n$result"
+		    ($match matching):\n[Asciify $result]"
 	}
     }
     if {$errorCodeFailure} {
diff --git a/unix/Makefile.in b/unix/Makefile.in
index 1b2718e..da057d8 100644
--- a/unix/Makefile.in
+++ b/unix/Makefile.in
@@ -1071,9 +1071,9 @@ install-libraries: libraries
 	@echo "Installing package msgcat 1.7.1 as a Tcl Module"
 	@$(INSTALL_DATA) $(TOP_DIR)/library/msgcat/msgcat.tcl \
 		"$(MODULE_INSTALL_DIR)/8.7/msgcat-1.7.1.tm"
-	@echo "Installing package tcltest 2.5.5 as a Tcl Module"
+	@echo "Installing package tcltest 2.5.6 as a Tcl Module"
 	@$(INSTALL_DATA) $(TOP_DIR)/library/tcltest/tcltest.tcl \
-		"$(MODULE_INSTALL_DIR)/8.5/tcltest-2.5.5.tm"
+		"$(MODULE_INSTALL_DIR)/8.5/tcltest-2.5.6.tm"
 	@echo "Installing package platform 1.0.19 as a Tcl Module"
 	@$(INSTALL_DATA) $(TOP_DIR)/library/platform/platform.tcl \
 		"$(MODULE_INSTALL_DIR)/8.4/platform-1.0.19.tm"
diff --git a/win/Makefile.in b/win/Makefile.in
index 6d7bb7d..202b860 100644
--- a/win/Makefile.in
+++ b/win/Makefile.in
@@ -889,8 +889,8 @@ install-libraries: libraries install-tzdata install-msgs
 	    done;
 	@echo "Installing package msgcat 1.7.1 as a Tcl Module";
 	@$(COPY) $(ROOT_DIR)/library/msgcat/msgcat.tcl "$(MODULE_INSTALL_DIR)/8.7/msgcat-1.7.1.tm";
-	@echo "Installing package tcltest 2.5.5 as a Tcl Module";
-	@$(COPY) $(ROOT_DIR)/library/tcltest/tcltest.tcl "$(MODULE_INSTALL_DIR)/8.5/tcltest-2.5.5.tm";
+	@echo "Installing package tcltest 2.5.6 as a Tcl Module";
+	@$(COPY) $(ROOT_DIR)/library/tcltest/tcltest.tcl "$(MODULE_INSTALL_DIR)/8.5/tcltest-2.5.6.tm";
 	@echo "Installing package platform 1.0.19 as a Tcl Module";
 	@$(COPY) $(ROOT_DIR)/library/platform/platform.tcl "$(MODULE_INSTALL_DIR)/8.4/platform-1.0.19.tm";
 	@echo "Installing package platform::shell 1.1.4 as a Tcl Module";
-- 
cgit v0.12


From 8bf2e2ace2224e4066dfe647f47b531591fe8666 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 12 Mar 2023 11:32:52 +0000
Subject: Forgot that \x00 is not printable anyway

---
 library/tcltest/tcltest.tcl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/tcltest/tcltest.tcl b/library/tcltest/tcltest.tcl
index 19b7d64..6cb7d92 100644
--- a/library/tcltest/tcltest.tcl
+++ b/library/tcltest/tcltest.tcl
@@ -1154,7 +1154,7 @@ proc tcltest::Asciify {s} {
     set print ""
     foreach c [split $s ""] {
         set i [scan $c %c]
-        if {[string is print $c] && ($i <= 127) && ($i > 0)} {
+        if {[string is print $c] && ($i <= 127)} {
             append print $c
         } elseif {$i <= 0xFF} {
             append print \\x[format %02X $i]
-- 
cgit v0.12


From 131176ce2f937173892c6e7e3a78978f6e8da2b5 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 12 Mar 2023 16:37:12 +0000
Subject: Backport [6fb14ee3e876978c]. Add testcases

---
 generic/tclEncoding.c | 12 +++++-------
 tests/encoding.test   | 12 ++++++++++++
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index b3409d6..27f11d8 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -2605,17 +2605,15 @@ Utf32ToUtfProc(
 
 	if ((unsigned)ch > 0x10FFFF) {
 	    ch = 0xFFFD;
-	    if (STOPONERROR) {
+	    if ((flags & TCL_ENCODING_STRICT) == TCL_ENCODING_STRICT) {
 		result = TCL_CONVERT_SYNTAX;
 		break;
 	    }
 	} else if (((flags & TCL_ENCODING_STRICT) == TCL_ENCODING_STRICT)
 		&& ((ch  & ~0x7FF) == 0xD800)) {
-	    if (STOPONERROR) {
-		result = TCL_CONVERT_SYNTAX;
-		ch = 0;
-		break;
-	    }
+	    result = TCL_CONVERT_SYNTAX;
+	    ch = 0;
+	    break;
 	}
 
 	/*
@@ -2845,7 +2843,7 @@ Utf16ToUtfProc(
 	if (((prev  & ~0x3FF) == 0xD800) && ((ch  & ~0x3FF) != 0xDC00)) {
 	    if (((flags & TCL_ENCODING_STRICT) == TCL_ENCODING_STRICT)) {
 		result = TCL_CONVERT_UNKNOWN;
-		src -= 2; /* Go back to before the high surrogate */
+		src -= 2; /* Go back to beginning of high surrogate */
 		dst--; /* Also undo writing a single byte too much */
 		numChars--;
 		break;
diff --git a/tests/encoding.test b/tests/encoding.test
index 0fe64ce..cf63211 100644
--- a/tests/encoding.test
+++ b/tests/encoding.test
@@ -568,6 +568,12 @@ test encoding-16.22 {Utf16ToUtfProc, strict, bug [db7a085bd9]} -body {
 test encoding-16.23 {Utf16ToUtfProc, strict, bug [db7a085bd9]} -body {
     encoding convertfrom -strict utf-16le \x00\xDC
 } -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\x00'}
+test encoding-16.24 {Utf32ToUtfProc} -body {
+    encoding convertfrom utf-32 "\xFF\xFF\xFF\xFF"
+} -result \uFFFD
+test encoding-16.25 {Utf32ToUtfProc} -body {
+    encoding convertfrom utf-32 "\x01\x00\x00\x01"
+} -result \uFFFD
 
 test encoding-17.1 {UtfToUtf16Proc} -body {
     encoding convertto utf-16 "\U460DC"
@@ -599,6 +605,12 @@ test encoding-17.9 {Utf32ToUtfProc} -body {
 test encoding-17.10 {Utf32ToUtfProc} -body {
     encoding convertfrom -nocomplain utf-32 "\xFF\xFF\xFF\xFF"
 } -result \uFFFD
+test encoding-17.11 {Utf32ToUtfProc} -body {
+    encoding convertfrom -strict utf-32le "\x00\xD8\x00\x00"
+} -returnCodes error -result {unexpected byte sequence starting at index 0: '\x00'}
+test encoding-17.12 {Utf32ToUtfProc} -body {
+    encoding convertfrom -strict utf-32le "\x00\xDC\x00\x00"
+} -returnCodes error -result {unexpected byte sequence starting at index 0: '\x00'}
 
 test encoding-18.1 {TableToUtfProc on invalid input} -constraints deprecated -body {
 	list [catch {encoding convertto jis0208 \\} res] $res
-- 
cgit v0.12


From 967e55306e7bb0a58a7cf2c5b905a2608f395875 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Mon, 13 Mar 2023 12:22:06 +0000
Subject: Fix for issue [ea69b0258a9833cb], crash when using a channel
 transformation on TCP client socket.

---
 generic/tclIO.c    | 38 ++++++++++++++----------
 tests/ioTrans.test | 86 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 107 insertions(+), 17 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index 85ff39b..715f8c7 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -8551,6 +8551,7 @@ UpdateInterest(
 	    mask &= ~TCL_EXCEPTION;
 
 	    if (!statePtr->timer) {
+		TclChannelPreserve((Tcl_Channel)chanPtr);
 		statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME,
                         ChannelTimerProc, chanPtr);
 	    }
@@ -8584,23 +8585,28 @@ ChannelTimerProc(
     ChannelState *statePtr = chanPtr->state;
 				/* State info for channel */
 
-    if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA)
-	    && (statePtr->interestMask & TCL_READABLE)
-	    && (statePtr->inQueueHead != NULL)
-	    && IsBufferReady(statePtr->inQueueHead)) {
-	/*
-	 * Restart the timer in case a channel handler reenters the event loop
-	 * before UpdateInterest gets called by Tcl_NotifyChannel.
-	 */
-
-	statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME,
-                ChannelTimerProc,chanPtr);
-	Tcl_Preserve(statePtr);
-	Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_READABLE);
-	Tcl_Release(statePtr);
+    if (chanPtr->typePtr == NULL) {
+	TclChannelRelease((Tcl_Channel)chanPtr);
     } else {
-	statePtr->timer = NULL;
-	UpdateInterest(chanPtr);
+	if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA)
+		&& (statePtr->interestMask & TCL_READABLE)
+		&& (statePtr->inQueueHead != NULL)
+		&& IsBufferReady(statePtr->inQueueHead)) {
+	    /*
+	     * Restart the timer in case a channel handler reenters the event loop
+	     * before UpdateInterest gets called by Tcl_NotifyChannel.
+	     */
+
+	    statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME,
+		    ChannelTimerProc,chanPtr);
+	    Tcl_Preserve(statePtr);
+	    Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_READABLE);
+	    Tcl_Release(statePtr);
+	} else {
+	    statePtr->timer = NULL;
+	    UpdateInterest(chanPtr);
+	    TclChannelRelease((Tcl_Channel)chanPtr);
+	}
     }
 }
 
diff --git a/tests/ioTrans.test b/tests/ioTrans.test
index f185117..130ff80 100644
--- a/tests/ioTrans.test
+++ b/tests/ioTrans.test
@@ -634,6 +634,58 @@ test iortrans-4.9 {chan read, gets, bug 2921116} -setup {
         }
     }
 
+
+
+namespace eval reflector {
+    proc initialize {_ chan mode} {
+	return {initialize finalize watch read}
+    }
+
+
+    proc finalize {_ chan} {
+	namespace delete $_
+    }
+
+
+    proc read {_ chan count} {
+	namespace upvar $_ source source
+	set res [string range $source 0 $count-1]
+	set source [string range $source $count end]
+	return $res
+    }
+
+
+    proc watch {_ chan events} {
+	after 0 [list chan postevent $chan read]
+	return read
+    }
+
+    namespace ensemble create -parameters _
+    namespace export *
+}
+
+
+
+
+namespace eval inputfilter {
+    proc initialize {chan mode} {
+	return {initialize finalize read}
+    }
+    
+    proc read {chan buffer} {
+	return $buffer
+    }
+
+    proc finalize chan {
+	namespace delete $chan
+    }
+
+    namespace ensemble create
+    namespace export *
+}
+
+
+
 # Channel read transform that is just the identity - pass all through
     proc idxform {cmd handle args} {
       switch -- $cmd {
@@ -2089,7 +2141,39 @@ test iortrans.tf-11.1 {origin thread of moved transform destroyed during access}
     thread::release $tidb
 } -result {Owner lost}
 
-# ### ### ### ######### ######### #########
+
+test iortrans-ea69b0258a9833cb {
+    Crash when using a channel transformation on TCP client socket
+
+    "line two" does not make it into result.  This issue should probably be
+    addressed, but it is outside the scope of this test.
+} -setup {
+    set res {}
+    set read 0
+} -body {
+    namespace eval reflector1 {
+	variable source "line one\nline two"
+	interp alias {} [namespace current]::dispatch {} [
+	    namespace parent]::reflector [namespace current]
+    }
+    set chan [chan create read [namespace which reflector1::dispatch]]
+    chan configure $chan -blocking 0
+    chan push $chan inputfilter
+    chan event $chan read [list ::apply [list chan {
+	variable res
+	variable read
+	set gets [gets $chan]
+	append res $gets
+	incr read
+    } [namespace current]] $chan]
+    vwait [namespace current]::read
+    chan pop $chan
+    vwait [namespace current]::read
+    return $res
+} -cleanup {
+    catch {unset read}
+    close $chan
+} -result {line one}
 
 cleanupTests
 return
-- 
cgit v0.12


From df8a3a6ea4a6ede9d9be56eacae69d8f40d624ca Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Mon, 13 Mar 2023 13:36:52 +0000
Subject: Fix for issue [ea69b0258a9833cb], crash when using a channel
 transformation on TCP client socket.

---
 generic/tclIO.c    | 67 +++++++++++++++++++++++++-----------------
 tests/ioTrans.test | 86 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 125 insertions(+), 28 deletions(-)

diff --git a/generic/tclIO.c b/generic/tclIO.c
index da06171..58137a5 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -8804,6 +8804,7 @@ UpdateInterest(
 	    mask &= ~TCL_EXCEPTION;
 
 	    if (!statePtr->timer) {
+		TclChannelPreserve((Tcl_Channel)chanPtr);
 		statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME,
                         ChannelTimerProc, chanPtr);
 	    }
@@ -8814,6 +8815,7 @@ UpdateInterest(
 	&& mask & TCL_WRITABLE
 	&& GotFlag(statePtr, CHANNEL_NONBLOCKING)) {
 
+	TclChannelPreserve((Tcl_Channel)chanPtr);
 	statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME,
 	    ChannelTimerProc,chanPtr);
     }
@@ -8848,44 +8850,55 @@ ChannelTimerProc(
     /* State info for channel */
     ChannelState *statePtr = chanPtr->state;
 
-	/* Preserve chanPtr to guard against deallocation in Tcl_NotifyChannel. */
-    TclChannelPreserve((Tcl_Channel)chanPtr);
-    Tcl_Preserve(statePtr);
-    statePtr->timer = NULL;
-    if (statePtr->interestMask & TCL_WRITABLE
-	&& GotFlag(statePtr, CHANNEL_NONBLOCKING)
-	&& !GotFlag(statePtr, BG_FLUSH_SCHEDULED)
-	) {
-	/*
-	 * Restart the timer in case a channel handler reenters the event loop
-	 * before UpdateInterest gets called by Tcl_NotifyChannel.
-	 */
-	statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME,
-                ChannelTimerProc,chanPtr);
-	Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_WRITABLE);
-    }
+    /* TclChannelPreserve() must be called before the current function was
+     * scheduled, is already in effect.  In this function it guards against
+     * deallocation in Tcl_NotifyChannel and also keps the channel preserved
+     * until ChannelTimerProc is later called again.
+     */
 
-    /* The channel may have just been closed from within Tcl_NotifyChannel */
-    if (!GotFlag(statePtr, CHANNEL_INCLOSE)) {
-	if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA)
-		&& (statePtr->interestMask & TCL_READABLE)
-		&& (statePtr->inQueueHead != NULL)
-		&& IsBufferReady(statePtr->inQueueHead)) {
+    if (chanPtr->typePtr == NULL) {
+	TclChannelRelease((Tcl_Channel)chanPtr);
+    } else {
+	Tcl_Preserve(statePtr);
+	statePtr->timer = NULL;
+	if (statePtr->interestMask & TCL_WRITABLE
+	    && GotFlag(statePtr, CHANNEL_NONBLOCKING)
+	    && !GotFlag(statePtr, BG_FLUSH_SCHEDULED)
+	    ) {
 	    /*
 	     * Restart the timer in case a channel handler reenters the event loop
 	     * before UpdateInterest gets called by Tcl_NotifyChannel.
 	     */
-
 	    statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME,
 		    ChannelTimerProc,chanPtr);
-	    Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_READABLE);
+	    Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_WRITABLE);
 	} else {
-	    UpdateInterest(chanPtr);
+	    /* The channel may have just been closed from within Tcl_NotifyChannel */
+	    if (!GotFlag(statePtr, CHANNEL_INCLOSE)) {
+		if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA)
+			&& (statePtr->interestMask & TCL_READABLE)
+			&& (statePtr->inQueueHead != NULL)
+			&& IsBufferReady(statePtr->inQueueHead)) {
+		    /*
+		     * Restart the timer in case a channel handler reenters the event loop
+		     * before UpdateInterest gets called by Tcl_NotifyChannel.
+		     */
+
+		    statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME,
+			    ChannelTimerProc,chanPtr);
+		    Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_READABLE);
+		} else {
+		    TclChannelRelease((Tcl_Channel)chanPtr);
+		    UpdateInterest(chanPtr);
+		}
+	    } else {
+		TclChannelRelease((Tcl_Channel)chanPtr);
+	    }
 	}
+
+	Tcl_Release(statePtr);
     }
 
-    Tcl_Release(statePtr);
-    TclChannelRelease((Tcl_Channel)chanPtr);
 }
 
 /*
diff --git a/tests/ioTrans.test b/tests/ioTrans.test
index 79493e0..f481a17 100644
--- a/tests/ioTrans.test
+++ b/tests/ioTrans.test
@@ -634,6 +634,58 @@ test iortrans-4.9 {chan read, gets, bug 2921116} -setup {
         }
     }
 
+
+
+namespace eval reflector {
+    proc initialize {_ chan mode} {
+	return {initialize finalize watch read}
+    }
+
+
+    proc finalize {_ chan} {
+	namespace delete $_
+    }
+
+
+    proc read {_ chan count} {
+	namespace upvar $_ source source
+	set res [string range $source 0 $count-1]
+	set source [string range $source $count end]
+	return $res
+    }
+
+
+    proc watch {_ chan events} {
+	after 0 [list chan postevent $chan read]
+	return read
+    }
+
+    namespace ensemble create -parameters _
+    namespace export *
+}
+
+
+
+
+namespace eval inputfilter {
+    proc initialize {chan mode} {
+	return {initialize finalize read}
+    }
+    
+    proc read {chan buffer} {
+	return $buffer
+    }
+
+    proc finalize chan {
+	namespace delete $chan
+    }
+
+    namespace ensemble create
+    namespace export *
+}
+
+
+
 # Channel read transform that is just the identity - pass all through
     proc idxform {cmd handle args} {
       switch -- $cmd {
@@ -2089,7 +2141,39 @@ test iortrans.tf-11.1 {origin thread of moved transform destroyed during access}
     thread::release $tidb
 } -result {Owner lost}
 
-# ### ### ### ######### ######### #########
+
+test iortrans-ea69b0258a9833cb {
+    Crash when using a channel transformation on TCP client socket
+
+    "line two" does not make it into result.  This issue should probably be
+    addressed, but it is outside the scope of this test.
+} -setup {
+    set res {}
+    set read 0
+} -body {
+    namespace eval reflector1 {
+	variable source "line one\nline two"
+	interp alias {} [namespace current]::dispatch {} [
+	    namespace parent]::reflector [namespace current]
+    }
+    set chan [chan create read [namespace which reflector1::dispatch]]
+    chan configure $chan -blocking 0
+    chan push $chan inputfilter
+    chan event $chan read [list ::apply [list chan {
+	variable res
+	variable read
+	set gets [gets $chan]
+	append res $gets
+	incr read
+    } [namespace current]] $chan]
+    vwait [namespace current]::read
+    chan pop $chan
+    vwait [namespace current]::read
+    return $res
+} -cleanup {
+    catch {unset read}
+    close $chan
+} -result {line one}
 
 cleanupTests
 return
-- 
cgit v0.12


From 6d7423228211f312016f0c62ce1bc86c3d3777db Mon Sep 17 00:00:00 2001
From: apnadkarni <apnmbx-wits@yahoo.com>
Date: Mon, 13 Mar 2023 13:44:35 +0000
Subject: Bug [183a1adcc0]. Buffer overflow in Tcl_UtfToExternal

---
 generic/tclEncoding.c |  14 +++
 generic/tclTest.c     | 236 +++++++++++++++++++++++++++++++++++++++++++++++++-
 tests/encoding.test   |  35 ++++++++
 3 files changed, 283 insertions(+), 2 deletions(-)

diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index 2b3b614..92217f3 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -1233,6 +1233,9 @@ Tcl_ExternalToUtf(
     }
 
     if (!noTerminate) {
+        if (dstLen < 1) {
+            return TCL_CONVERT_NOSPACE;
+        }
 	/*
 	 * If there are any null characters in the middle of the buffer,
 	 * they will converted to the UTF-8 null character (\xC080). To get
@@ -1241,6 +1244,10 @@ Tcl_ExternalToUtf(
 	 */
 
 	dstLen--;
+    } else {
+        if (dstLen < 0) {
+            return TCL_CONVERT_NOSPACE;
+        }
     }
     do {
 	Tcl_EncodingState savedState = *statePtr;
@@ -1415,10 +1422,17 @@ Tcl_UtfToExternal(
 	dstCharsPtr = &dstChars;
     }
 
+    if (dstLen < encodingPtr->nullSize) {
+        return TCL_CONVERT_NOSPACE;
+    }
     dstLen -= encodingPtr->nullSize;
     result = encodingPtr->fromUtfProc(encodingPtr->clientData, src, srcLen,
 	    flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr,
 	    dstCharsPtr);
+    /*
+     * Buffer is terminated irrespective of result. Not sure this is
+     * reasonable but keep for historical/compatibility reasons.
+     */
     if (encodingPtr->nullSize == 2) {
 	dst[*dstWrotePtr + 1] = '\0';
     }
diff --git a/generic/tclTest.c b/generic/tclTest.c
index bc51c99..c2b7144 100644
--- a/generic/tclTest.c
+++ b/generic/tclTest.c
@@ -1817,6 +1817,234 @@ static void SpecialFree(blockPtr)
 }
 
 /*
+ *------------------------------------------------------------------------
+ *
+ * UtfTransformFn --
+ *
+ *    Implements a direct call into Tcl_UtfToExternal and Tcl_ExternalToUtf
+ *    as otherwise there is no script level command that directly exercises
+ *    these functions (i/o command cannot test all combinations)
+ *    The arguments at the script level are roughly those of the above
+ *    functions:
+ *        encodingname srcbytes flags state dstlen ?srcreadvar? ?dstwrotevar? ?dstcharsvar?
+ *
+ * Results:
+ *    TCL_OK or TCL_ERROR. This any errors running the test, NOT the
+ *    result of Tcl_UtfToExternal or Tcl_ExternalToUtf.
+ *
+ * Side effects:
+ *
+ *    The result in the interpreter is a list of the return code from the
+ *    Tcl_UtfToExternal/Tcl_ExternalToUtf functions, the encoding state, and
+ *    an encoded binary string of length dstLen. Note the string is the
+ *    entire output buffer, not just the part containing the decoded
+ *    portion. This allows for additional checks at test script level.
+ *
+ *    If any of the srcreadvar, dstwrotevar and
+ *    dstcharsvar are specified and not empty, they are treated as names
+ *    of variables where the *srcRead, *dstWrote and *dstChars output
+ *    from the functions are stored.
+ *
+ *    The function also checks internally whether nuls are correctly
+ *    appended as requested but the TCL_ENCODING_NO_TERMINATE flag
+ *    and that no buffer overflows occur.
+ *------------------------------------------------------------------------
+ */
+typedef int
+UtfTransformFn(Tcl_Interp *interp, Tcl_Encoding encoding, const char *src, int srcLen, int flags, Tcl_EncodingState *statePtr,
+               char *dst, int dstLen, int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr);
+static int UtfExtWrapper(
+    Tcl_Interp *interp, UtfTransformFn *transformer, int objc, Tcl_Obj *const objv[])
+{
+    Tcl_Encoding encoding;
+    Tcl_EncodingState encState, *encStatePtr;
+    int srcLen, bufLen;
+    const char *bytes;
+    char *bufPtr;
+    int srcRead, dstLen, dstWrote, dstChars;
+    Tcl_Obj *srcReadVar, *dstWroteVar, *dstCharsVar;
+    int result;
+    int flags;
+    Tcl_Obj **flagObjs;
+    int nflags;
+
+    if (objc < 7 || objc > 10) {
+        Tcl_WrongNumArgs(interp,
+                         2,
+                         objv,
+                         "encoding srcbytes flags state dstlen ?srcreadvar? ?dstwrotevar? ?dstcharsvar?");
+        return TCL_ERROR;
+    }
+    if (Tcl_GetEncodingFromObj(interp, objv[2], &encoding) != TCL_OK) {
+        return TCL_ERROR;
+    }
+
+    /* Flags may be specified as list of integers and keywords */
+    flags = 0;
+    if (Tcl_ListObjGetElements(interp, objv[4], &nflags, &flagObjs) != TCL_OK) {
+	return TCL_ERROR;
+    }
+
+    struct {
+	const char *flagKey;
+	int flag;
+    } flagMap[] = {
+	{"start", TCL_ENCODING_START},
+	{"end", TCL_ENCODING_END},
+	{"stoponerror", TCL_ENCODING_STOPONERROR},
+	{"noterminate", TCL_ENCODING_NO_TERMINATE},
+	{"charlimit", TCL_ENCODING_CHAR_LIMIT},
+	{NULL, 0}
+    };
+    int i;
+    for (i = 0; i < nflags; ++i) {
+	int flag;
+	if (Tcl_GetIntFromObj(NULL, flagObjs[i], &flag) == TCL_OK) {
+	    flags |= flag;
+	}
+	else {
+	    int idx;
+	    if (Tcl_GetIndexFromObjStruct(interp,
+					  flagObjs[i],
+					  flagMap,
+					  sizeof(flagMap[0]),
+					  "flag",
+					  0,
+					  &idx) != TCL_OK) {
+		return TCL_ERROR;
+	    }
+	    flags |= flagMap[idx].flag;
+	}
+    }
+
+    /* Assumes state is integer if not "" */
+    Tcl_WideInt wide;
+    if (Tcl_GetWideIntFromObj(interp, objv[5], &wide) == TCL_OK) {
+        encState = (Tcl_EncodingState) wide;
+        encStatePtr = &encState;
+    } else if (Tcl_GetCharLength(objv[5]) == 0) {
+        encStatePtr = NULL;
+    } else {
+        return TCL_ERROR;
+    }
+    if (Tcl_GetIntFromObj(interp, objv[6], &dstLen) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    srcReadVar = NULL;
+    dstWroteVar = NULL;
+    dstCharsVar = NULL;
+    if (objc > 7) {
+	/* Has caller requested srcRead? */
+	if (Tcl_GetCharLength(objv[7])) {
+	    srcReadVar = objv[7];
+	}
+	if (objc > 8) {
+	    /* Ditto for dstWrote */
+            if (Tcl_GetCharLength(objv[8])) {
+                dstWroteVar = objv[8];
+            }
+	    if (objc > 9) {
+                if (Tcl_GetCharLength(objv[9])) {
+                    dstCharsVar = objv[9];
+		}
+	    }
+	}
+    }
+    if (flags & TCL_ENCODING_CHAR_LIMIT) {
+	/* Caller should have specified the dest char limit */
+	Tcl_Obj *valueObj;
+	if (dstCharsVar == NULL ||
+	    (valueObj = Tcl_ObjGetVar2(interp, dstCharsVar, NULL, 0)) == NULL
+	) {
+	    Tcl_SetResult(interp,
+			 "dstCharsVar must be specified with integer value if "
+			 "TCL_ENCODING_CHAR_LIMIT set in flags.", TCL_STATIC);
+	    return TCL_ERROR;
+	}
+	if (Tcl_GetIntFromObj(interp, valueObj, &dstChars) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+    } else {
+	dstChars = 0; /* Only used for output */
+    }
+
+    bufLen = dstLen + 4; /* 4 -> overflow detection */
+    bufPtr = ckalloc(bufLen);
+    memset(bufPtr, 0xFF, dstLen); /* Need to check nul terminator */
+    memmove(bufPtr + dstLen, "\xAB\xCD\xEF\xAB", 4);   /* overflow detection */
+    bytes = (char *) Tcl_GetByteArrayFromObj(objv[3], &srcLen); /* Last! to avoid shimmering */
+    result = (*transformer)(interp, encoding, bytes, srcLen, flags,
+                               encStatePtr, bufPtr, dstLen,
+                               srcReadVar ? &srcRead : NULL,
+                               &dstWrote,
+                               dstCharsVar ? &dstChars : NULL);
+    if (memcmp(bufPtr + bufLen - 4, "\xAB\xCD\xEF\xAB", 4)) {
+        Tcl_SetResult(interp,
+                      "Tcl_ExternalToUtf wrote past output buffer",
+                      TCL_STATIC);
+        result = TCL_ERROR;
+    } else if (result != TCL_ERROR) {
+        Tcl_Obj *resultObjs[3];
+        switch (result) {
+        case TCL_OK:
+            resultObjs[0] = Tcl_NewStringObj("ok", -1);
+            break;
+        case TCL_CONVERT_MULTIBYTE:
+            resultObjs[0] = Tcl_NewStringObj("multibyte", -1);
+            break;
+        case TCL_CONVERT_SYNTAX:
+            resultObjs[0] = Tcl_NewStringObj("syntax", -1);
+            break;
+        case TCL_CONVERT_UNKNOWN:
+            resultObjs[0] = Tcl_NewStringObj("unknown", -1);
+            break;
+        case TCL_CONVERT_NOSPACE:
+            resultObjs[0] = Tcl_NewStringObj("nospace", -1);
+            break;
+        default:
+            resultObjs[0] = Tcl_NewIntObj(result);
+            break;
+        }
+        result = TCL_OK;
+        resultObjs[1] =
+            encStatePtr ? Tcl_NewWideIntObj((Tcl_WideInt)encState) : Tcl_NewObj();
+        resultObjs[2] = Tcl_NewByteArrayObj((unsigned char *)bufPtr, dstLen);
+        if (srcReadVar) {
+	    if (Tcl_ObjSetVar2(interp,
+			       srcReadVar,
+			       NULL,
+			       Tcl_NewIntObj(srcRead),
+			       TCL_LEAVE_ERR_MSG) == NULL) {
+		result = TCL_ERROR;
+	    }
+	}
+        if (dstWroteVar) {
+	    if (Tcl_ObjSetVar2(interp,
+			       dstWroteVar,
+			       NULL,
+			       Tcl_NewIntObj(dstWrote),
+			       TCL_LEAVE_ERR_MSG) == NULL) {
+		result = TCL_ERROR;
+	    }
+	}
+        if (dstCharsVar) {
+	    if (Tcl_ObjSetVar2(interp,
+			       dstCharsVar,
+			       NULL,
+			       Tcl_NewIntObj(dstChars),
+			       TCL_LEAVE_ERR_MSG) == NULL) {
+		result = TCL_ERROR;
+	    }
+	}
+        Tcl_SetObjResult(interp, Tcl_NewListObj(3, resultObjs));
+    }
+
+    ckfree(bufPtr);
+    Tcl_FreeEncoding(encoding); /* Free returned reference */
+    return result;
+}
+
+/*
  *----------------------------------------------------------------------
  *
  * TestencodingCmd --
@@ -1845,10 +2073,10 @@ TestencodingObjCmd(
     const char *string;
     TclEncoding *encodingPtr;
     static const char *const optionStrings[] = {
-	"create",	"delete",	NULL
+	"create", "delete", "Tcl_ExternalToUtf", "Tcl_UtfToExternal", NULL
     };
     enum options {
-	ENC_CREATE,	ENC_DELETE
+	ENC_CREATE, ENC_DELETE, ENC_EXTTOUTF, ENC_UTFTOEXT
     };
 
     if (Tcl_GetIndexFromObj(interp, objv[1], optionStrings, "option", 0,
@@ -1894,6 +2122,10 @@ TestencodingObjCmd(
 	Tcl_FreeEncoding(encoding);
 	Tcl_FreeEncoding(encoding);
 	break;
+    case ENC_EXTTOUTF:
+        return UtfExtWrapper(interp,Tcl_ExternalToUtf,objc,objv);
+    case ENC_UTFTOEXT:
+        return UtfExtWrapper(interp,Tcl_UtfToExternal,objc,objv);
     }
     return TCL_OK;
 }
diff --git a/tests/encoding.test b/tests/encoding.test
index f6f9abc..26efb19 100644
--- a/tests/encoding.test
+++ b/tests/encoding.test
@@ -739,6 +739,41 @@ test encoding-28.0 {all encodings load} -body {
 
 runtests
 
+test encoding-bug-183a1adcc0-1 {Bug [183a1adcc0] Buffer overflow Tcl_UtfToExternal} -constraints {
+    testencoding
+} -body {
+    # Note - buffers are initialized to \xff
+    list [catch {testencoding Tcl_UtfToExternal unicode A {start end} {} 1} result] $result
+} -result [list 0 [list nospace {} \xff]]
+
+test encoding-bug-183a1adcc0-2 {Bug [183a1adcc0] Buffer overflow Tcl_UtfToExternal} -constraints {
+    testencoding
+} -body {
+    # Note - buffers are initialized to \xff
+    list [catch {testencoding Tcl_UtfToExternal unicode A {start end} {} 0} result] $result
+} -result [list 0 [list nospace {} {}]]
+
+test encoding-bug-183a1adcc0-3 {Bug [183a1adcc0] Buffer overflow Tcl_UtfToExternal} -constraints {
+    testencoding
+} -body {
+    # Note - buffers are initialized to \xff
+    list [catch {testencoding Tcl_UtfToExternal unicode A {start end} {} 2} result] $result
+} -result [list 0 [list nospace {} \x00\x00]]
+
+test encoding-bug-183a1adcc0-4 {Bug [183a1adcc0] Buffer overflow Tcl_UtfToExternal} -constraints {
+    testencoding
+} -body {
+    # Note - buffers are initialized to \xff
+    list [catch {testencoding Tcl_UtfToExternal unicode A {start end} {} 3} result] $result
+} -result [list 0 [list nospace {} \x00\x00\xff]]
+
+test encoding-bug-183a1adcc0-5 {Bug [183a1adcc0] Buffer overflow Tcl_UtfToExternal} -constraints {
+    testencoding
+} -body {
+    # Note - buffers are initialized to \xff
+    list [catch {testencoding Tcl_UtfToExternal unicode A {start end} {} 4} result] $result
+} -result [list 0 [list ok {} [expr {$::tcl_platform(byteOrder) eq "littleEndian" ? "\x41\x00" : "\x00\x41"}]\x00\x00]]
+
 }
 
 # cleanup
-- 
cgit v0.12


From 18a99f2522b77516b62a0d44dca1c90b3479bda1 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Tue, 14 Mar 2023 10:05:24 +0000
Subject: Add "ucs-2" constraint to encoding-bug-183a1adcc0-5 testcase,
 otherwise it fails with TCL_UTF_MAX>3. Broken by [47857515422b8519|this]
 commit

---
 tests/encoding.test |  2 +-
 tests/ioTrans.test  |  2 +-
 win/tclWinTest.c    | 10 +++++-----
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/encoding.test b/tests/encoding.test
index 26efb19..bac80c9 100644
--- a/tests/encoding.test
+++ b/tests/encoding.test
@@ -768,7 +768,7 @@ test encoding-bug-183a1adcc0-4 {Bug [183a1adcc0] Buffer overflow Tcl_UtfToExtern
 } -result [list 0 [list nospace {} \x00\x00\xff]]
 
 test encoding-bug-183a1adcc0-5 {Bug [183a1adcc0] Buffer overflow Tcl_UtfToExternal} -constraints {
-    testencoding
+    testencoding ucs-2
 } -body {
     # Note - buffers are initialized to \xff
     list [catch {testencoding Tcl_UtfToExternal unicode A {start end} {} 4} result] $result
diff --git a/tests/ioTrans.test b/tests/ioTrans.test
index 130ff80..3a23e61 100644
--- a/tests/ioTrans.test
+++ b/tests/ioTrans.test
@@ -671,7 +671,7 @@ namespace eval inputfilter {
     proc initialize {chan mode} {
 	return {initialize finalize read}
     }
-    
+
     proc read {chan buffer} {
 	return $buffer
     }
diff --git a/win/tclWinTest.c b/win/tclWinTest.c
index d70d217..6ca49f6 100644
--- a/win/tclWinTest.c
+++ b/win/tclWinTest.c
@@ -419,7 +419,7 @@ TestplatformChmod(
     const char *nativePath,
     int pmode)
 {
-    /* 
+    /*
      * Note FILE_DELETE_CHILD missing from dirWriteMask because we do
      * not want overriding of child's delete setting when testing
      */
@@ -427,7 +427,7 @@ TestplatformChmod(
 	FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA |
 	FILE_ADD_FILE | FILE_ADD_SUBDIRECTORY | STANDARD_RIGHTS_WRITE | DELETE |
 	SYNCHRONIZE;
-    static const DWORD dirReadMask = 
+    static const DWORD dirReadMask =
 	FILE_READ_ATTRIBUTES | FILE_READ_EA | FILE_LIST_DIRECTORY |
 	STANDARD_RIGHTS_READ | SYNCHRONIZE;
     /* Note - default user privileges allow ignoring TRAVERSE setting */
@@ -437,7 +437,7 @@ TestplatformChmod(
     static const DWORD fileWriteMask =
 	FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_WRITE_DATA |
 	FILE_APPEND_DATA | STANDARD_RIGHTS_WRITE | DELETE | SYNCHRONIZE;
-    static const DWORD fileReadMask = 
+    static const DWORD fileReadMask =
 	FILE_READ_ATTRIBUTES | FILE_READ_EA | FILE_READ_DATA |
 	STANDARD_RIGHTS_READ | SYNCHRONIZE;
     static const DWORD fileExecuteMask =
@@ -471,7 +471,7 @@ TestplatformChmod(
     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken)) {
 	goto done;
     }
-    
+
     /* Get process SID */
     if (!GetTokenInformation(hToken, TokenUser, NULL, 0, &dw) &&
 	GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
@@ -489,7 +489,7 @@ TestplatformChmod(
 	ckfree(aceEntry[nSids].pSid); /* Since we have not ++'ed nSids */
 	goto done;
     }
-    /* 
+    /*
      * Always include DACL modify rights so we don't get locked out
      */
     aceEntry[nSids].mask = READ_CONTROL | WRITE_DAC | WRITE_OWNER | SYNCHRONIZE |
-- 
cgit v0.12