     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88

    use crate::io::{self, IoSlice, IoSliceMut};
    use crate::mem::ManuallyDrop;
    use crate::sys::fd::FileDesc;

    pub struct Stdin(());
    pub struct Stdout(());
    pub struct Stderr(());

    impl Stdin {
        pub fn new() -> io::Result<Stdin> {
            Ok(Stdin(()))
        }
    }

    impl io::Read for Stdin {
        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
            ManuallyDrop::new(FileDesc::new(libc::STDIN_FILENO)).read(buf)
        }

        fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
            ManuallyDrop::new(FileDesc::new(libc::STDIN_FILENO)).read_vectored(bufs)
        }

        #[inline]
        fn is_read_vectored(&self) -> bool {
            true
        }
    }

    impl Stdout {
        pub fn new() -> io::Result<Stdout> {
            Ok(Stdout(()))
        }
    }

    impl io::Write for Stdout {
        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
            ManuallyDrop::new(FileDesc::new(libc::STDOUT_FILENO)).write(buf)
        }

        fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
            ManuallyDrop::new(FileDesc::new(libc::STDOUT_FILENO)).write_vectored(bufs)
        }

        #[inline]
        fn is_write_vectored(&self) -> bool {
            true
        }

        fn flush(&mut self) -> io::Result<()> {
            Ok(())
        }
    }

    impl Stderr {
        pub fn new() -> io::Result<Stderr> {
            Ok(Stderr(()))
        }
    }

    impl io::Write for Stderr {
        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
            ManuallyDrop::new(FileDesc::new(libc::STDERR_FILENO)).write(buf)
        }

        fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
            ManuallyDrop::new(FileDesc::new(libc::STDERR_FILENO)).write_vectored(bufs)
        }

        #[inline]
        fn is_write_vectored(&self) -> bool {
            true
        }

        fn flush(&mut self) -> io::Result<()> {
            Ok(())
        }
    }

    pub fn is_ebadf(err: &io::Error) -> bool {
        err.raw_os_error() == Some(libc::EBADF as i32)
    }

    pub const STDIN_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE;

    pub fn panic_output() -> Option<impl io::Write> {
        Stderr::new().ok()
    }