[Tcl-bugs] [ tcl-Bugs-219418 ] Build errors - tcltest errors in io.test and others

[<no...@so...>]

Bugs item #219418, was opened at 2000-10-25 22:12
You can respond by visiting: 
http://sourceforge.net/tracker/?func=detail&atid=110894&aid=219418&group_id=10894

Category: 24. Channel System
Group: = 8.3.2
Status: Open
Resolution: None
Priority: 4
Submitted By: Nobody/Anonymous (nobody)
>Assigned to: Donal K. Fellows (dkf)
Summary: Build errors - tcltest errors in io.test and others

Initial Comment:
OriginalBugID: 6367 Bug
Version: 8.3.2
SubmitDate: '2000-10-16'
LastModified: '2000-10-25'
Severity: CRIT
Status: UnAssn
Submitter: techsupp
OS: Digital Unix
OSVersion: Tru64 Unix V5.0a
Machine: Alphaserver 8400
FixedDate: '2000-10-25'
ClosedDate: '2000-10-25'


Name:
Stephen Smith

Extensions:
None.

CustomShell:
None

Comments:
There are compilation warning messages during the make, all can be
    categorised as data type mismatches, which can often be ignored.
    However, the modules affected sound very much like those that might be
    tested in io.test.  These are:

    cc: Info: ./../generic/tclEncoding.c, line 1337: In this statement, an
    array sub
    script expression is either less than zero or greater than the largest
    value tha
    t can be represented by the size_t type. (badsubscript)
        hex = staticHex - '0';
    ----------------------^

    cc: Info: ./../generic/tclIO.c, line 3535: In this statement, an array
    is being 
    accessed outside the bounds specified for the array type. (subscrbounds)
                memcpy((VOID *) (nextPtr->buf + BUFFER_PADDING - extra),
    --------------------------------------------^
    cc: Info: ./../generic/tclIO.c, line 3683: In this statement, an array
    is being 
    accessed outside the bounds specified for the array type. (subscrbounds)
                            (VOID *) (nextPtr->buf + BUFFER_PADDING -
    extra),
    -------------------------------------------------^

    cc: Warning: ./../generic/tclIOGT.c, line 174: The redefinition of the
    macro "DE
    LAY" conflicts with a current definition because one is object-like and
    the othe
    r is function-like.  The redefinition is now in effect. (macroredef)
    #define DELAY (5)
    --------------^

    cc: Warning: ./../generic/tclIOSock.c, line 100: In this statement, the
    referenc
    ed type of the pointer value "&len" is "unsigned long", which is not
    compatible 
    with "int". (ptrmismatch)
        getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&current, &len);
    --------------------------------------------------------------^
    cc: Warning: ./../generic/tclIOSock.c, line 106: In this statement, the
    referenc
    ed type of the pointer value "&len" is "unsigned long", which is not
    compatible 
    with "int". (ptrmismatch)
        getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&current, &len);
    --------------------------------------------------------------^

    cc: Warning: ./../unix/tclUnixChan.c, line 235: In the initializer for
    fileChann
    elType.version, the referenced type of the pointer value
    "FileBlockModeProc" is 
    "function (pointer to void, int) returning int", which is not compatible
    with "s
    truct Tcl_ChannelTypeVersion_". (ptrmismatch)
        FileBlockModeProc,                  /* Set blocking/nonblocking
    mode.*/
    ----^

    cc: Warning: ./../unix/tclUnixChan.c, line 254: In the initializer for
    ttyChanne
    lType.version, the referenced type of the pointer value
    "FileBlockModeProc" is "
    function (pointer to void, int) returning int", which is not compatible
    with "st
    ruct Tcl_ChannelTypeVersion_". (ptrmismatch)
        FileBlockModeProc,                  /* Set blocking/nonblocking
    mode.*/
    ----^

    cc: Warning: ./../unix/tclUnixChan.c, line 273: In the initializer for
    tcpChanne
    lType.version, the referenced type of the pointer value
    "TcpBlockModeProc" is "f
    unction (pointer to void, int) returning int", which is not compatible
    with "str
    uct Tcl_ChannelTypeVersion_". (ptrmismatch)
        TcpBlockModeProc,                   /* Set blocking/nonblocking
    mode.*/
    ----^

    cc: Warning: ./../unix/tclUnixPipe.c, line 71: In the initializer for
    pipeChanne
    lType.version, the referenced type of the pointer value
    "PipeBlockModeProc" is "
    function (pointer to void, int) returning int", which is not compatible
    with "st
    ruct Tcl_ChannelTypeVersion_". (ptrmismatch)
        PipeBlockModeProc,                  /* Set blocking/nonblocking
    mode.*/
    ----^

ReproducibleScript:
cd /usr/local/builds/tcl8.3.2/unix
./configure
make
make install
make test
Ctrl-C once it starts running test otherwise it hangs in http.test (exits in clock.test)
chown -R <username> /usr/local/builds/tcl8.3.2
chmod -R 755 /usr/local
tcltest ../tests/io.test

ObservedBehavior:
Errors in the test results for the io module.

EDCDW01:root:/usr/local/builds/tcl8.3.2/unix> tcltest ../tests/io.test

==== io-14.9 reuse of stdio special channels FAILED
==== Contents of test case:

    removeFile script
    removeFile test1
    set f [open script w]
    puts $f {
        set f [open test1 w]
        puts $f hello
        close $f
        close stderr
        set f [open "|[list [info nameofexecutable] cat test1]" r]
        puts [gets $f]
    }
    close $f
    set f [open "|[list $::tcltest::tcltest script]" r]
    set c [gets $f]
    close $f
    set c

---- Result was:

---- Result should have been:
hello
==== io-14.9 FAILED

==== io-29.34 Tcl_Close, async flush on close, using sockets FAILED
==== Contents of test case:

    set c 0
    set x running
    set l abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqr
stuvwxyz
    proc writelots {s l} {
        for {set i 0} {$i < 2000} {incr i} {
            puts $s $l
        }
    }
    proc accept {s a p} {
        global x
        fileevent $s readable [list readit $s]
        fconfigure $s -blocking off
        set x accepted
    }
    proc readit {s} {
        global c x
        set l [gets $s]

        if {[eof $s]} {
            close $s
            set x done
        } elseif {([string length $l] > 0) || ![fblocked $s]} {
            incr c
        }
    }
    set ss [socket -server accept 2828]
    set cs [socket [info hostname] 2828]
    vwait x
    fconfigure $cs -blocking off
    writelots $cs $l
    close $cs
    close $ss
    vwait x
    set c

==== Test generated error:
couldn't open socket: address already in use
---- Result should have been:
2000
==== io-29.34 FAILED

==== io-29.35 Tcl_Close vs fileevent vs multiple interpreters FAILED
==== Contents of test case:

    # On Mac, this test screws up sockets such that subsequent tests using port 
2828 
    # either cause errors or panic().

    catch {interp delete x}
    catch {interp delete y}
    interp create x
    interp create y
    set s [socket -server accept 2828]
    proc accept {s a p} {
        puts $s hello
        close $s
    }
    set c [socket [info hostname] 2828]
    interp share {} $c x
    interp share {} $c y
    close $c
    x eval {
        proc readit {s} {
            gets $s
            if {[eof $s]} {
                close $s
            }
        }
    }
    y eval {
        proc readit {s} {
            gets $s
            if {[eof $s]} {
                close $s
            }
        }
    }
    x eval "fileevent $c readable \{readit $c\}"
    y eval "fileevent $c readable \{readit $c\}"
    y eval [list close $c]
    update
    close $s
    interp delete x
    interp delete y

==== Test generated error:
couldn't open socket: address already in use
---- Result should have been:

==== io-29.35 FAILED

==== io-32.7 Tcl_Read, nonblocking, file FAILED
==== Contents of test case:

    set f1 [open longfile r]
    fconfigure $f1 -blocking off
    set z [read $f1 20]
    close $f1
    set l [string length $z]
    set x ok
    if {$l != 20} {
        set x broken
    }
    set x

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
ok
==== io-32.7 FAILED

==== io-32.8 Tcl_Read, nonblocking, file FAILED
==== Contents of test case:

    set f1 [open longfile r]
    fconfigure $f1 -blocking off
    set z [read $f1 1000000]
    close $f1
    set x ok
    set l [string length $z]]
    set z [file size longfile]]
    if {$z != $l} {
        set x broken
    }
  set x

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
ok
==== io-32.8 FAILED

==== io-35.4 Tcl_Eof, eof detection on nonblocking file FAILED
==== Contents of test case:

    removeFile test1
    set f [open test1 w]
    close $f
    set f [open test1 r]
    fconfigure $f -blocking off
    set l ""
    lappend l [gets $f]
    lappend l [eof $f]
    close $f
    set l

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
{} 1
==== io-35.4 FAILED

==== io-36.5 Tcl_InputBlocked vs files, short read, nonblocking FAILED
==== Contents of test case:

    removeFile test1
    set f [open test1 w]
    puts $f abcdefghijklmnop
    close $f
    set f [open test1 r]
    fconfigure $f -blocking off
    set l ""
    lappend l [fblocked $f]
    lappend l [read $f 3]
    lappend l [fblocked $f]
    lappend l [read -nonewline $f]
    lappend l [fblocked $f]
    lappend l [eof $f]
    close $f
    set l

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
0 abc 0 defghijklmnop 0 1
==== io-36.5 FAILED

==== io-36.6 Tcl_InputBlocked vs files, event driven read FAILED
==== Contents of test case:

    proc in {f} {
        global l x
        lappend l [read $f 3]
        if {[eof $f]} {lappend l eof; close $f; set x done}
    }
    removeFile test1
    set f [open test1 w]
    puts $f abcdefghijklmnop
    close $f
    set f [open test1 r]
    fconfigure $f -blocking off
    set l ""
    fileevent $f readable [list in $f]
    vwait x
    set l

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
abc def ghi jkl mno {p
} eof
==== io-36.6 FAILED

==== io-39.9 Tcl_SetChannelOption, blocking mode FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open test1 w]
    close $f1
    set f1 [open test1 r]
    set x ""
    lappend x [fconfigure $f1 -blocking]
    fconfigure $f1 -blocking off
    lappend x [fconfigure $f1 -blocking]
    lappend x [gets $f1]
    lappend x [read $f1 1000]
    lappend x [fblocked $f1]
    lappend x [eof $f1]
    close $f1
    set x

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
1 0 {} {} 0 1
==== io-39.9 FAILED

==== io-44.5 FileEventProc procedure: end of file FAILED
==== Contents of test case:

    set f4 [open "|[list $::tcltest::tcltest cat << foo]" r]
    fileevent $f4 readable {
        if {[gets $f4 line] < 0} {
            lappend x eof
            fileevent $f4 readable {}
        } else {
            lappend x $line
        }
    }
    set x initial
    vwait x
    vwait x
    close $f4
    set x

==== Test generated error:
can't wait for variable "x":  would wait forever
---- Result should have been:
initial foo eof
==== io-44.5 FAILED

==== io-48.2 testing readability conditions FAILED
==== Contents of test case:

    set f [open bar w]
    puts $f abcdefg
    puts $f abcdefg
    puts $f abcdefg
    puts $f abcdefg
    puts $f abcdefg
    close $f
    set f [open bar r]
    fileevent $f readable [list consume $f]
    fconfigure $f -blocking off
    proc consume {f} {
        global x l
        lappend l called
        if {[eof $f]} {
            close $f
            set x done
        } else {
            gets $f
        }
    }
    set l ""
    set x not_done
    vwait x
    list $x $l

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
done {called called called called called called called}
==== io-48.2 FAILED

==== io-48.3 testing readability conditions FAILED
==== Contents of test case:

    set f [open bar w]
    puts $f abcdefg
    puts $f abcdefg
    puts $f abcdefg
    puts $f abcdefg
    puts $f abcdefg
    close $f
    set f [open my_script w]
    puts $f {
        proc copy_slowly {f} {
            while {![eof $f]} {
                puts [gets $f]
                after 200
            }
            close $f
        }
    }
    close $f
    set f [open "|[list $::tcltest::tcltest]" r+]
    fileevent $f readable [list consume $f]
    fconfigure $f -buffering line
    fconfigure $f -blocking off
    proc consume {f} {
        global x l
        if {[eof $f]} {
            set x done
        } else {
            gets $f
            lappend l [fblocked $f]
            gets $f
            lappend l [fblocked $f]
        }
    }
    set l ""
    set x not_done
    puts $f {source my_script}
    puts $f {set f [open bar r]}
    puts $f {copy_slowly $f}
    puts $f {exit}
    vwait x
    close $f
    list $x $l

---- Result was:
done {0 0 0 0 0 0}
---- Result should have been:
done {0 1 0 1 0 1 0 1 0 1 0 1 0 0}
==== io-48.3 FAILED

==== io-48.4 lf write, testing readability, ^Z termination, auto read mode FAILE
D
==== Contents of test case:

    removeFile test1
    set f [open test1 w]
    fconfigure $f -translation lf
    set c [format "abc\ndef\n%c" 26]
    puts -nonewline $f $c
    close $f
    proc consume {f} {
        global c x l
        if {[eof $f]} {
           set x done
           close $f
        } else {
           lappend l [gets $f]
           incr c
        }
    }
    set c 0
    set l ""
    set f [open test1 r]
    fconfigure $f -translation auto -eofchar \x1a
    fileevent $f readable [list consume $f]
    vwait x
    list $c $l

---- Result was:
1 abc
---- Result should have been:
3 {abc def {}}
==== io-48.4 FAILED

==== io-48.5 lf write, testing readability, ^Z in middle, auto read mode FAILED
==== Contents of test case:

    removeFile test1
    set f [open test1 w]
    fconfigure $f -translation lf
    set c [format "abc\ndef\n%cfoo\nbar\n" 26]
    puts -nonewline $f $c
    close $f
    proc consume {f} {
        global c x l
        if {[eof $f]} {
           set x done
           close $f
        } else {
           lappend l [gets $f]
           incr c
        }
    }
    set c 0
    set l ""
    set f [open test1 r]
    fconfigure $f -eofchar \x1a -translation auto
    fileevent $f readable [list consume $f]
    vwait x
    list $c $l

---- Result was:
5 {abc def def {} {}}
---- Result should have been:
3 {abc def {}}
==== io-48.5 FAILED

==== io-52.1 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open test1 w]
    fcopy $f1 $f2 -command { # }
    catch { fcopy $f1 $f2 } msg
    close $f1
    close $f2
    string compare $msg "channel \$f1\ is busy"

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
0
==== io-52.1 FAILED

==== io-52.2 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open test1 w]
    set f3 [open $thisScript]
    fcopy $f1 $f2 -command { # }
    catch { fcopy $f3 $f2 } msg
    close $f1
    close $f2
    close $f3
    string compare $msg "channel \$f2\ is busy"

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
0
==== io-52.2 FAILED

==== io-52.3 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open test1 w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation cr -blocking 0
    set s0 [fcopy $f1 $f2]
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    close $f1
    close $f2
    set s1 [file size $thisScript]
    set s2 [file size test1]
    if {("$s1" == "$s2") && ($s0 == $s1)} {
        lappend result ok
    }
    set result

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
0 0 ok
==== io-52.3 FAILED

==== io-52.4 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open test1 w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation cr -blocking 0
    fcopy $f1 $f2 -size 40
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    close $f1
    close $f2
    lappend result [file size test1]

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
0 0 40
==== io-52.4 FAILED

==== io-52.5 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open test1 w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation lf -blocking 0
    fcopy $f1 $f2 -size -1
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    close $f1
    close $f2
    set s1 [file size $thisScript]
    set s2 [file size test1]
    if {"$s1" == "$s2"} {
        lappend result ok
    }
    set result

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
0 0 ok
==== io-52.5 FAILED

==== io-52.6 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open test1 w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation lf -blocking 0
    set s0 [fcopy $f1 $f2 -size [expr [file size $thisScript] + 5]]
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    close $f1
    close $f2
    set s1 [file size $thisScript]
    set s2 [file size test1]
    if {("$s1" == "$s2") && ($s0 == $s1)} {
        lappend result ok
    }
    set result

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
0 0 ok
==== io-52.6 FAILED

==== io-52.7 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open test1 w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation lf -blocking 0
    fcopy $f1 $f2
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    set s1 [file size $thisScript]
    set s2 [file size test1]
    close $f1
    close $f2
    if {"$s1" == "$s2"} {
        lappend result ok
    }
    set result

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
0 0 ok
==== io-52.7 FAILED

==== io-53.1 CopyData FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open test1 w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation cr -blocking 0
    fcopy $f1 $f2 -size 0
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    close $f1
    close $f2
    lappend result [file size test1]

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
0 0 0
==== io-53.1 FAILED

==== io-53.2 CopyData FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open test1 w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation cr -blocking 0
    fcopy $f1 $f2 -command {set s0}
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    vwait s0
    close $f1
    close $f2
    set s1 [file size $thisScript]
    set s2 [file size test1]
    if {("$s1" == "$s2") && ($s0 == $s1)} {
        lappend result ok
    }
    set result

==== Test generated error:
error setting blocking mode: inappropriate device for ioctl
---- Result should have been:
0 0 ok
==== io-53.2 FAILED

==== io-53.5 CopyData: error during fcopy FAILED
==== Contents of test case:

    set listen [socket -server FcopyTestAccept 2828]
    set in [open $thisScript]   ;# 126 K
    set out [socket 127.0.0.1 2828]
    catch {unset fcopyTestDone}
    close $listen       ;# This means the socket open never really succeeds
    fcopy $in $out -command FcopyTestDone
    if ![info exists fcopyTestDone] {
        vwait fcopyTestDone             ;# The error occurs here in the b.g.
    }
    close $in
    close $out
    set fcopyTestDone   ;# 1 for error condition

==== Test generated error:
couldn't open socket: address already in use
---- Result should have been:
1
==== io-53.5 FAILED

==== io-53.6 CopyData: error during fcopy FAILED
==== Contents of test case:

    removeFile pipe
    removeFile test1
    catch {unset fcopyTestDone}
    set f1 [open pipe w]
    puts $f1 "exit 1"
    close $f1
    set in [open "|[list $::tcltest::tcltest pipe]" r+]
    set out [open test1 w]
    fcopy $in $out -command [list FcopyTestDone]
    if ![info exists fcopyTestDone] {
        vwait fcopyTestDone
    }
    catch {close $in}
    close $out
    set fcopyTestDone   ;# 0 for plain end of file

==== Test generated error:

---- Result should have been:
0
==== io-53.6 FAILED

==== io-54.1 Recursive channel events FAILED
==== Contents of test case:

    # This test checks to see if file events are delivered during recursive
    # event loops when there is buffered data on the channel.

    proc accept {s a p} {
        global as
        fconfigure $s -translation lf
        puts $s "line 1\nline2\nline3"
        flush $s
        set as $s
    }
    proc readit {s next} {
        global result x
        lappend result $next
        if {$next == 1} {
            fileevent $s readable [list readit $s 2]
            vwait x
        }
        incr x
    }
    set ss [socket -server accept 2828]

    # We need to delay on some systems until the creation of the
    # server socket completes.

    set done 0
    for {set i 0} {$i < 10} {incr i} {
        if {![catch {set cs [socket [info hostname] 2828]}]} {
            set done 1
            break
        }
        after 100
    }
    if {$done == 0} {
        close $ss
        error "failed to connect to server"
    }
    set result {}
    set x 0
    vwait as
    fconfigure $cs -translation lf
    lappend result [gets $cs]
    fconfigure $cs -blocking off
    fileevent $cs readable [list readit $cs 1]
    set a [after 2000 { set x failure }]
    vwait x
    after cancel $a
    close $as
    close $ss
    close $cs
    list $result $x

==== Test generated error:
couldn't open socket: address already in use
---- Result should have been:
{{line 1} 1 2} 2
==== io-54.1 FAILED

io.test:        Total   444     Passed  411     Skipped 7       Failed  26
Number of tests skipped for each constraint:
        1       emptyTest
        1       macOnly
        2       nonPortable
        2       pcOnly
        1       umask2
EDCDW01:root:/usr/local/builds/tcl8.3.2/unix>

DesiredBehavior:
one line containing...

io.test

Patch:
Sorry no patch

PatchFiles:
n/a





----------------------------------------------------------------------

>Comment By: Andreas Kupries (andreas_kupries)
Date: 2002-01-24 10:29

Message:
Logged In: YES 
user_id=75003

Donal, I believe that you have a Tru64 Digital Unix Alpha. 
Can you build the current head there and check if the 
errors are (partially) gone ?

----------------------------------------------------------------------

Comment By: Andreas Kupries (andreas_kupries)
Date: 2001-09-11 13:05

Message:
Logged In: YES 
user_id=75003

Stephen Smith <ste...@co...>


----------------------------------------------------------------------

Comment By: Jeffrey Hobbs (hobbs)
Date: 2000-11-20 11:14

Message:
Kupries' prio7 (A) noted warnings are already fixed in 8.4a2.  They are actually spurious and were intentionally left in 8.3.2, but "corrected" in 8.4a2 because it confused so many (served its purpose anyway).  I dropped the prio and recategorized to CodeCleanup, because I believe that's all that's necessary for the rest.

----------------------------------------------------------------------

Comment By: Andreas Kupries (andreas_kupries)
Date: 2000-11-19 23:18

Message:
This is a essentially shortened version of bug #119417 (The log was
reduced to the warnings), but contains additional warnings which where
not in 119417. Only the additional messages are covered in this
followup. For the other messages go to #119417.

Recat to "OtherIO", could be "CodeCleanup" as well.

Upfront summary
___________________________________________________

(A)	Priority 7, open

___________________________________________________
(A)	cc: Warning: ./../unix/tclUnixChan.c, line 235: In the
	initializer for fileChannelType.version, the referenced type
	of the pointer value "FileBlockModeProc" is "function (pointer
	to void, int) returning int", which is not compatible with
	"struct Tcl_ChannelTypeVersion_". (ptrmismatch)

        FileBlockModeProc,   /* Set blocking/nonblocking mode.*/
    ----^

	Same for lines 254 and 273 and

	cc: Warning: ./../unix/tclUnixPipe.c, line 71: In the
	initializer for pipeChannelType.version, the referenced type
	of the pointer value "PipeBlockModeProc" is "function (pointer
	to void, int) returning int", which is not compatible with
	"struct Tcl_ChannelTypeVersion_". (ptrmismatch)
        PipeBlockModeProc,   /* Set blocking/nonblocking mode.*/

	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	Comments
	--	In 8.3.2 the whole handling of stacked channels was
		rewritten (again) and this time the change affected
		the definition of Tcl_ChannelType as well. The field
		containing BlockModeProc is now a version field. For
		compatibility with older drivers, particular in
		extensions anything other than TCL_CHANNEL_VERSION_1
		or TCL_CHANNEL_VERSION_2 is considered as
		BlockModeProc and the driver as version 1.

	The simple solution would be to cast the BlockModeProc, but
	the right solution is to rewrite the structure and use
	explicit version numbers. As these drivers are built into the
	core there is no problem of (non-)compatibility with older
	versions of the core.

___________________________________________________
(B)	Failures of test suite

	Comments
	14.9	The failure could have been caused by the reported bugs
		because of 32/64bit issues, but the connection is not
		sure.

	29.34	'couldn't open socket: address already in use'
		Possible reasons:
		--	Socket not cleaned up from earlier test run.
		--	Some other application already uses the port
		=>	Please check.

	29.35	s.a.
	53.5	s.a.
	54.1

	32.7	error setting blocking mode: inappropriate device for ioctl

		The script tried to access a file, not a serial device or tty.
		Maybe a follow-on error from 14.9., i.e. the system
		believing that the file is thr stdin/out/err tty.
		Some other than me has to check this, sorry.

		Could also follow from the warning about BlockModeProc
		in the drivers.

	32.8	s.a.
	35.4	s.a.
	36.5	s.a.
	36.6	s.a.
	39.9	s.a.
	48.2	s.a.
	52.1	s.a.
	52.3	s.a.
	52.4	s.a.
	52.5	s.a.
	52.6	s.a.
	52.7	s.a.
	53.1	s.a.
	53.2	s.a.

	44.5	unclear	\
	48.3	unclear  |
	48.4	unclear  > = I see no 'obvious' reason.
	48.5	unclear  |
	53.6	unclear	/

	Advise rechecking after the obvious problems were corrected.


----------------------------------------------------------------------

Comment By: Donal K. Fellows (dkf)
Date: 2000-11-15 07:15

Message:
Gawd!  An omnium-gatherum bug report.  Assigning to build though it might also belong in test and I/O

----------------------------------------------------------------------

You can respond by visiting: 
http://sourceforge.net/tracker/?func=detail&atid=110894&aid=219418&group_id=10894