# Bug fixes
 - [On Unix, IsTimeNative() always defined but not always used](https://core.tcl-lang.org/tcl/tktview/6b8e39)
 - [Tweak install permissions](https://core.tcl-lang.org/tcl/tktview/31d4fa)
 - [interp creation resets encoding directory search path](https://core.tcl-lang.org/tcl/tktview/87b697)
 - [Pointer arithmetic with NULL in buildInfoObjCmd()](https://core.tcl-lang.org/tcl/tktview/85fc8b)

# Updated bundled packages, libraries, standards, data
 - http 2.10.1
 - platform 1.1.0
 - sqlite3 3.50.4
 - tcltest 2.5.10
 - Thread 3.0.3
 - TDBC\* 1.1.12

Release Tcl 9.0.2 arises from the check-in with tag `core-9-0-2`.

		Finish $token $nhl
		return
	    } elseif {$nhl == 0} {
		##Log header done - token $token
		Log ^E$tk end of response headers - token $token
		# We have now read all headers
		# We ignore HTTP/1.1 100 Continue returns. RFC2616 sec 8.2.3
		if {    ($state(http) eq "")
		     || ([regexp {^\S+\s(\d+)} $state(http) {} x] && $x == 100)
		} {
		    set state(state) "connecting"
		    continue
		    # This was a "return" in the pre-coroutine code.
		}

		append cpu _32
	    }
	}
    }

    switch -glob -- $plat {
	windows {
	    if {$tcl_platform(platform) eq "unix"} {
		set plat cygwin
	    } else {
		set plat win32
	    }
	    if {$cpu eq "amd64"} {
		# Do not check wordSize, win32-x64 is an IL32P64 platform.
		set cpu x86_64

\#123456789abcdef01
\#"
    }
    chan close $f

    set path(cat) [makeFile {
	set f stdin
	if {$argv ne ""} {
	    set f [open [lindex $argv 0]]
	}
	chan configure $f -translation binary -blocking 0 -eofchar \x1A
	chan configure stdout -translation binary -buffering none
	chan event $f readable "foo $f"
	proc foo {f} {
	    set x [chan read $f]

    lappend res [namespace eval tst a]
    rename p {}
    rename a {}
    namespace delete tst
    set res
 } {GLOBAL GLOBAL}

if {[info command nonexistent-command-in-parent] ne ""} {
    rename nonexistent-command-in-parent {}
}

# Part 9: Aliasing between interpreters
test interp-10.1 {testing aliasing between interpreters} {
    catch {interp delete a}
    catch {interp delete b}

\#123456789abcdef01
\#"
    }
close $f

set path(cat) [makeFile {
    set f stdin
    if {$argv ne ""} {
	set f [open [lindex $argv 0]]
    }
    fconfigure $f -translation binary -blocking 0 -eofchar \x1A
    fconfigure stdout -translation binary -buffering none
    fileevent $f readable "foo $f"
    proc foo {f} {
	set x [read $f]

    close $fd
} -result {xxxxxxx 1 {POSIX EILSEQ {invalid or incomplete multibyte or wide character}}}

# Test standard handle management. The functions tested are
# Tcl_SetStdChannel and Tcl_GetStdChannel. Incidentally we are
# also testing channel table management.

if {[info commands testchannel] ne ""} {
    set consoleFileNames [lsort [testchannel open]]
} else {
    # just to avoid an error
    set consoleFileNames [list]
}

test io-14.1 {Tcl_SetStdChannel and Tcl_GetStdChannel} {testchannel} {

    }
    proc doit {s} {
	variable counter
	variable after

	incr counter
	set l [gets $s]
	if {"$l" eq ""} {
	    fileevent $s readable [namespace code "doit1 $s"]
	    set after [after 1000 [namespace code newline]]
	}
    }
    proc doit1 {s} {
	variable counter
	variable accept

    } -result {transport endpoint is not connected} -returnCodes 1
test socket-14.12 {[socket -async] background progress triggered by [fconfigure -error]} \
    -constraints {socket} \
    -body {
	set s [socket -async localhost [randport]]
	for {set i 0} {$i < 50} {incr i} {
	    set x [fconfigure $s -error]
	    if {$x ne ""} break
	    after 200
	}
	set x
    } -cleanup {
	close $s
	unset x s
    } -result {connection refused}

set oldcwd [pwd]
cd [temporaryDirectory]

# Several tests require need to match results against the Unix username
set user {}
if {[testConstraint unix]} {
    catch {set user [exec whoami]}
    if {$user eq ""} {
	catch {regexp {^[^(]*\(([^)]*)\)} [exec id] dummy user}
    }
    if {$user eq ""} {
	set user "root"
    }
}

# Find a group that exists on this system, or else skip tests that require
# groups
testConstraint foundGroup 0

	    flush stdout
	}
	set timeout [after 30000 ::DoTimeout]

	# Define a restricted handler.
	proc Handler1 {cmd} {
	    if {$cmd eq "stop"} {set ::done 1}
	    if {$cmd eq ""} {
		set cmd "null data"
	    }
	    puts $cmd ; flush stdout
	    return
	}
	proc Handler2 {cmd} {
	    if {$cmd eq "stop"} {set ::done 1}

    set fileId [open $inFileName r]

    set i 0
    while {[gets $fileId line] >= 0} {

	set len [string length $line]

	if {($len > 0) && ([string index $line [expr {$len - 1}]] eq "\\")} {
	    if {[info exists lineArray(c$i)] == 0} {
		set lineArray(c$i) 1
	    } else {
		incr lineArray(c$i)
	    }
	    set line [string range $line 0 [expr {$len - 2}]]
	    append lineArray($i) $line

    set srcLineNum 1
    while {$lineNum < $numLines} {

	set currentLine $lineArray($lineNum)

	# copy comment string to output file and continue

	if {[string index $currentLine 0] eq "#"} {
	    puts $fileId $currentLine
	    incr srcLineNum $lineArray(c$lineNum)
	    incr lineNum
	    continue
	}

	set len [llength $currentLine]