    {-# LANGUAGE Trustworthy #-}
    {-# LANGUAGE InterruptibleFFI #-}
    {-# LANGUAGE CPP, NoImplicitPrelude, CApiFFI #-}
    {-# LANGUAGE LambdaCase #-}
    {-# LANGUAGE UnboxedTuples #-}
    {-# LANGUAGE MagicHash #-}
    {-# OPTIONS_HADDOCK not-home #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  GHC.Internal.System.Posix.Internals
    -- Copyright   :  (c) The University of Glasgow, 1992-2002
    -- License     :  see libraries/base/LICENSE
    --
    -- Maintainer  :  ghc-devs@haskell.org
    -- Stability   :  internal
    -- Portability :  non-portable (requires POSIX)
    --
    -- POSIX support layer for the standard libraries.
    --
    -- /The API of this module is unstable and not meant to be consumed by the general public./
    -- If you absolutely must depend on it, make sure to use a tight upper
    -- bound, e.g., @base < 4.X@ rather than @base < 5@, because the interface can
    -- change rapidly without much warning.
    --
    -- This library is built on *every* platform, including Win32.
    --
    -- Non-POSIX compliant in order to support the following features:
    --  * S_ISSOCK (no sockets in POSIX)
    --
    -----------------------------------------------------------------------------

    module GHC.Internal.System.Posix.Internals where

    #include <ghcplatform.h>
    #include "HsBaseConfig.h"

    import GHC.Internal.System.Posix.Types

    import GHC.Internal.Foreign.C.Error
    import GHC.Internal.Foreign.Marshal.Alloc
    import GHC.Internal.Foreign.C.String
    import GHC.Internal.Foreign.C.Types

    import GHC.Internal.Data.Maybe

    #if !defined(HTYPE_TCFLAG_T)
    import GHC.Internal.System.IO.Error
    #endif

    import GHC.Internal.Base
    import GHC.Internal.Bits
    import GHC.Internal.Num
    import GHC.Internal.Real
    import GHC.Internal.Word
    import GHC.Internal.IO
    import GHC.Internal.IO.IOMode
    import GHC.Internal.IO.Exception
    import GHC.Internal.IO.Device
    import GHC.Internal.Ptr

    #if defined(javascript_HOST_ARCH)
    import GHC.Internal.Int (Int64)
    #endif

    #if !defined(mingw32_HOST_OS)
    import {-# SOURCE #-} GHC.Internal.IO.Encoding (getFileSystemEncoding)
    import GHC.Internal.Foreign.Marshal.Utils
    import GHC.Internal.Foreign.Storable
    import qualified GHC.Internal.Foreign.C.String.Encoding as GHC
    #else
    import GHC.Internal.Int
    import GHC.Internal.Data.OldList (elem)
    #endif

    -- ---------------------------------------------------------------------------
    -- Debugging the base package

    puts :: String -> IO ()
    puts :: String -> IO ()
    puts String
    s = String -> (CStringLen -> IO ()) -> IO ()
    forall a. String -> (CStringLen -> IO a) -> IO a
    withCAStringLen (String
    s String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "\n") ((CStringLen -> IO ()) -> IO ()) -> (CStringLen -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \(Ptr CChar
    p, Int
    len) -> do
                -- In reality should be withCString, but assume ASCII to avoid loop
                -- if this is called by GHC.Internal.Foreign
               _ <- CInt -> Ptr Word8 -> CSize -> IO CSsize
    c_write CInt
    1 (Ptr CChar -> Ptr Word8
    forall a b. Ptr a -> Ptr b
    castPtr Ptr CChar
    p) (Int -> CSize
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    len)
               return ()

    -- ---------------------------------------------------------------------------
    -- Types

    data {-# CTYPE "struct flock" #-} CFLock
    data {-# CTYPE "struct group" #-} CGroup
    data {-# CTYPE "struct lconv" #-} CLconv
    data {-# CTYPE "struct passwd" #-} CPasswd
    data {-# CTYPE "struct sigaction" #-} CSigaction
    data {-# CTYPE "sigset_t" #-} CSigset
    data {-# CTYPE "struct stat" #-}  CStat
    data {-# CTYPE "struct termios" #-} CTermios
    data {-# CTYPE "struct tm" #-} CTm
    data {-# CTYPE "struct tms" #-} CTms
    data {-# CTYPE "struct utimbuf" #-} CUtimbuf
    data {-# CTYPE "struct utsname" #-} CUtsname

    type FD = CInt

    -- ---------------------------------------------------------------------------
    -- stat()-related stuff

    fdFileSize :: FD -> IO Integer
    fdFileSize :: CInt -> IO Integer
    fdFileSize CInt
    fd =
      Int -> (Ptr CStat -> IO Integer) -> IO Integer
    forall a b. Int -> (Ptr a -> IO b) -> IO b
    allocaBytes Int
    sizeof_stat ((Ptr CStat -> IO Integer) -> IO Integer)
    -> (Ptr CStat -> IO Integer) -> IO Integer
    forall a b. (a -> b) -> a -> b
    $ \ Ptr CStat
    p_stat -> do
        String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1Retry_ String
    "fileSize" (IO CInt -> IO ()) -> IO CInt -> IO ()
    forall a b. (a -> b) -> a -> b
    $
            CInt -> Ptr CStat -> IO CInt
    c_fstat CInt
    fd Ptr CStat
    p_stat
        c_mode <- Ptr CStat -> IO CMode
    st_mode Ptr CStat
    p_stat :: IO CMode
        if not (s_isreg c_mode)
            then return (-1)
            else do
          c_size <- st_size p_stat
          return (fromIntegral c_size)

    fileType :: FilePath -> IO IODeviceType
    fileType :: String -> IO IODeviceType
    fileType String
    file =
      Int -> (Ptr CStat -> IO IODeviceType) -> IO IODeviceType
    forall a b. Int -> (Ptr a -> IO b) -> IO b
    allocaBytes Int
    sizeof_stat ((Ptr CStat -> IO IODeviceType) -> IO IODeviceType)
    -> (Ptr CStat -> IO IODeviceType) -> IO IODeviceType
    forall a b. (a -> b) -> a -> b
    $ \ Ptr CStat
    p_stat ->
      String -> (Ptr CChar -> IO IODeviceType) -> IO IODeviceType
    forall a. String -> (Ptr CChar -> IO a) -> IO a
    withFilePath String
    file ((Ptr CChar -> IO IODeviceType) -> IO IODeviceType)
    -> (Ptr CChar -> IO IODeviceType) -> IO IODeviceType
    forall a b. (a -> b) -> a -> b
    $ \Ptr CChar
    p_file -> do
        String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1Retry_ String
    "fileType" (IO CInt -> IO ()) -> IO CInt -> IO ()
    forall a b. (a -> b) -> a -> b
    $
          Ptr CChar -> Ptr CStat -> IO CInt
    c_stat Ptr CChar
    p_file Ptr CStat
    p_stat
        Ptr CStat -> IO IODeviceType
    statGetType Ptr CStat
    p_stat

    -- NOTE: On Win32 platforms, this will only work with file descriptors
    -- referring to file handles. i.e., it'll fail for socket FDs.
    fdStat :: FD -> IO (IODeviceType, CDev, CIno)
    fdStat :: CInt -> IO (IODeviceType, CDev, CIno)
    fdStat CInt
    fd =
      Int
    -> (Ptr CStat -> IO (IODeviceType, CDev, CIno))
    -> IO (IODeviceType, CDev, CIno)
    forall a b. Int -> (Ptr a -> IO b) -> IO b
    allocaBytes Int
    sizeof_stat ((Ptr CStat -> IO (IODeviceType, CDev, CIno))
     -> IO (IODeviceType, CDev, CIno))
    -> (Ptr CStat -> IO (IODeviceType, CDev, CIno))
    -> IO (IODeviceType, CDev, CIno)
    forall a b. (a -> b) -> a -> b
    $ \ Ptr CStat
    p_stat -> do
        String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1Retry_ String
    "fdType" (IO CInt -> IO ()) -> IO CInt -> IO ()
    forall a b. (a -> b) -> a -> b
    $
            CInt -> Ptr CStat -> IO CInt
    c_fstat CInt
    fd Ptr CStat
    p_stat
        ty <- Ptr CStat -> IO IODeviceType
    statGetType Ptr CStat
    p_stat
        dev <- st_dev p_stat
        ino <- st_ino p_stat
        return (ty,dev,ino)

    fdType :: FD -> IO IODeviceType
    fdType :: CInt -> IO IODeviceType
    fdType CInt
    fd = do (ty,_,_) <- CInt -> IO (IODeviceType, CDev, CIno)
    fdStat CInt
    fd; return ty

    -- | Return a known device type or throw an exception if the device
    -- type is unknown.
    statGetType :: Ptr CStat -> IO IODeviceType
    statGetType :: Ptr CStat -> IO IODeviceType
    statGetType Ptr CStat
    p_stat = do
       dev_ty_m <- Ptr CStat -> IO (Maybe IODeviceType)
    statGetType_maybe Ptr CStat
    p_stat
       case dev_ty_m of
          Maybe IODeviceType
    Nothing -> IOError -> IO IODeviceType
    forall a. HasCallStack => IOError -> IO a
    ioError IOError
    ioe_unknownfiletype
          Just IODeviceType
    dev_ty -> IODeviceType -> IO IODeviceType
    forall a. a -> IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IODeviceType
    dev_ty

    -- | Unlike @statGetType@, @statGetType_maybe@ will not throw an exception
    -- if the CStat refers to a unknown device type.
    --
    -- @since base-4.20.1.0
    statGetType_maybe :: Ptr CStat -> IO (Maybe IODeviceType)
    statGetType_maybe :: Ptr CStat -> IO (Maybe IODeviceType)
    statGetType_maybe Ptr CStat
    p_stat = do
      c_mode <- Ptr CStat -> IO CMode
    st_mode Ptr CStat
    p_stat :: IO CMode
      case () of
          ()
    _ | CMode -> Bool
    s_isdir CMode
    c_mode        -> Maybe IODeviceType -> IO (Maybe IODeviceType)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe IODeviceType -> IO (Maybe IODeviceType))
    -> Maybe IODeviceType -> IO (Maybe IODeviceType)
    forall a b. (a -> b) -> a -> b
    $ IODeviceType -> Maybe IODeviceType
    forall a. a -> Maybe a
    Just IODeviceType
    Directory
            | CMode -> Bool
    s_isfifo CMode
    c_mode Bool -> Bool -> Bool
    || CMode -> Bool
    s_issock CMode
    c_mode Bool -> Bool -> Bool
    || CMode -> Bool
    s_ischr  CMode
    c_mode
                                    -> Maybe IODeviceType -> IO (Maybe IODeviceType)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe IODeviceType -> IO (Maybe IODeviceType))
    -> Maybe IODeviceType -> IO (Maybe IODeviceType)
    forall a b. (a -> b) -> a -> b
    $ IODeviceType -> Maybe IODeviceType
    forall a. a -> Maybe a
    Just IODeviceType
    Stream
            | CMode -> Bool
    s_isreg CMode
    c_mode        -> Maybe IODeviceType -> IO (Maybe IODeviceType)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe IODeviceType -> IO (Maybe IODeviceType))
    -> Maybe IODeviceType -> IO (Maybe IODeviceType)
    forall a b. (a -> b) -> a -> b
    $ IODeviceType -> Maybe IODeviceType
    forall a. a -> Maybe a
    Just IODeviceType
    RegularFile
             -- Q: map char devices to RawDevice too?
            | CMode -> Bool
    s_isblk CMode
    c_mode        -> Maybe IODeviceType -> IO (Maybe IODeviceType)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe IODeviceType -> IO (Maybe IODeviceType))
    -> Maybe IODeviceType -> IO (Maybe IODeviceType)
    forall a b. (a -> b) -> a -> b
    $ IODeviceType -> Maybe IODeviceType
    forall a. a -> Maybe a
    Just IODeviceType
    RawDevice
            | Bool
    otherwise             -> Maybe IODeviceType -> IO (Maybe IODeviceType)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe IODeviceType
    forall a. Maybe a
    Nothing

    ioe_unknownfiletype :: IOException
    ioe_unknownfiletype :: IOError
    ioe_unknownfiletype = Maybe Handle
    -> IOErrorType
    -> String
    -> String
    -> Maybe CInt
    -> Maybe String
    -> IOError
    IOError Maybe Handle
    forall a. Maybe a
    Nothing IOErrorType
    UnsupportedOperation String
    "fdType"
                            String
    "unknown file type"
                            Maybe CInt
    forall a. Maybe a
    Nothing
                            Maybe String
    forall a. Maybe a
    Nothing

    fdGetMode :: FD -> IO IOMode
    #if defined(mingw32_HOST_OS) || defined(javascript_HOST_ARCH)
    fdGetMode _ = do
        -- We don't have a way of finding out which flags are set on FDs
        -- on Windows/JS, so make a handle that thinks that anything goes.
        let flags = o_RDWR
    #else
    fdGetMode :: CInt -> IO IOMode
    fdGetMode CInt
    fd = do
        flags <- String -> IO CInt -> IO CInt
    forall a. (Eq a, Num a) => String -> IO a -> IO a
    throwErrnoIfMinus1Retry String
    "fdGetMode"
                    (CInt -> CInt -> IO CInt
    c_fcntl_read CInt
    fd CInt
    const_f_getfl)
    #endif
        let
           wH  = (CInt
    flags CInt -> CInt -> CInt
    forall a. Bits a => a -> a -> a
    .&. CInt
    o_WRONLY) CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0
           aH  = (CInt
    flags CInt -> CInt -> CInt
    forall a. Bits a => a -> a -> a
    .&. CInt
    o_APPEND) CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0
           rwH = (CInt
    flags CInt -> CInt -> CInt
    forall a. Bits a => a -> a -> a
    .&. CInt
    o_RDWR) CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0

           mode
             | Bool
    wH Bool -> Bool -> Bool
    && Bool
    aH  = IOMode
    AppendMode
             | Bool
    wH        = IOMode
    WriteMode
             | Bool
    rwH       = IOMode
    ReadWriteMode
             | Bool
    otherwise = IOMode
    ReadMode

        return mode

    #if defined(mingw32_HOST_OS)
    withFilePath :: FilePath -> (CWString -> IO a) -> IO a
    withFilePath fp f = do
        checkForInteriorNuls fp
        withCWString fp f

    newFilePath :: FilePath -> IO CWString
    newFilePath fp = do
        checkForInteriorNuls fp
        newCWString fp

    peekFilePath :: CWString -> IO FilePath
    peekFilePath = peekCWString

    -- | Check a 'FilePath' for internal NUL codepoints as these are
    -- disallowed in Windows filepaths. See #13660.
    checkForInteriorNuls :: FilePath -> IO ()
    checkForInteriorNuls fp = when ('\0' `elem` fp) (throwInternalNulError fp)

    #else

    withFilePath :: FilePath -> (CString -> IO a) -> IO a
    newFilePath :: FilePath -> IO CString
    peekFilePath :: CString -> IO FilePath
    peekFilePathLen :: CStringLen -> IO FilePath

    withFilePath :: forall a. String -> (Ptr CChar -> IO a) -> IO a
    withFilePath String
    fp Ptr CChar -> IO a
    f = do
        enc <- IO TextEncoding
    getFileSystemEncoding
        GHC.withCStringLen0 enc fp $ \(Ptr CChar
    str, Int
    len) -> do
            String -> CStringLen -> IO ()
    checkForInteriorNuls String
    fp (Ptr CChar
    str, Int
    len)
            Ptr CChar -> IO a
    f Ptr CChar
    str
    newFilePath :: String -> IO (Ptr CChar)
    newFilePath String
    fp = do
        enc <- IO TextEncoding
    getFileSystemEncoding
        (str, len) <- GHC.newCStringLen0 enc fp
        checkForInteriorNuls fp (str, len)
        return str
    peekFilePath :: Ptr CChar -> IO String
    peekFilePath Ptr CChar
    fp = IO TextEncoding
    getFileSystemEncoding IO TextEncoding -> (TextEncoding -> IO String) -> IO String
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \TextEncoding
    enc -> TextEncoding -> Ptr CChar -> IO String
    GHC.peekCString TextEncoding
    enc Ptr CChar
    fp
    peekFilePathLen :: CStringLen -> IO String
    peekFilePathLen CStringLen
    fp = IO TextEncoding
    getFileSystemEncoding IO TextEncoding -> (TextEncoding -> IO String) -> IO String
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \TextEncoding
    enc -> TextEncoding -> CStringLen -> IO String
    GHC.peekCStringLen TextEncoding
    enc CStringLen
    fp

    -- | Check an encoded 'FilePath' for internal NUL octets as these are
    -- disallowed in POSIX filepaths. See #13660.
    checkForInteriorNuls :: FilePath -> CStringLen -> IO ()
    checkForInteriorNuls :: String -> CStringLen -> IO ()
    checkForInteriorNuls String
    fp (Ptr CChar
    str, Int
    len) =
        Bool -> IO () -> IO ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (Int
    len' Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Int
    len) (String -> IO ()
    forall a. String -> IO a
    throwInternalNulError String
    fp)
        -- N.B. If the string contains internal NUL codeunits then the strlen will
        -- indicate a size smaller than that returned by withCStringLen.
      where
        len' :: Int
    len' = case Ptr CChar
    str of Ptr Addr#
    ptr -> Int# -> Int
    I# (Addr# -> Int#
    cstringLength# Addr#
    ptr)
    #endif

    throwInternalNulError :: FilePath -> IO a
    throwInternalNulError :: forall a. String -> IO a
    throwInternalNulError String
    fp = IOError -> IO a
    forall a. HasCallStack => IOError -> IO a
    ioError IOError
    err
      where
        err :: IOError
    err =
          IOError
            { ioe_handle :: Maybe Handle
    ioe_handle = Maybe Handle
    forall a. Maybe a
    Nothing
            , ioe_type :: IOErrorType
    ioe_type = IOErrorType
    InvalidArgument
            , ioe_location :: String
    ioe_location = String
    "checkForInteriorNuls"
            , ioe_description :: String
    ioe_description = String
    "FilePaths must not contain internal NUL code units."
            , ioe_errno :: Maybe CInt
    ioe_errno = Maybe CInt
    forall a. Maybe a
    Nothing
            , ioe_filename :: Maybe String
    ioe_filename = String -> Maybe String
    forall a. a -> Maybe a
    Just String
    fp
            }

    -- ---------------------------------------------------------------------------
    -- Terminal-related stuff

    #if defined(HTYPE_TCFLAG_T)

    setEcho :: FD -> Bool -> IO ()
    setEcho :: CInt -> Bool -> IO ()
    setEcho CInt
    fd Bool
    on =
      CInt -> (Ptr CTermios -> IO ()) -> IO ()
    forall a. CInt -> (Ptr CTermios -> IO a) -> IO a
    tcSetAttr CInt
    fd ((Ptr CTermios -> IO ()) -> IO ())
    -> (Ptr CTermios -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ Ptr CTermios
    p_tios -> do
        lflag <- Ptr CTermios -> IO CTcflag
    c_lflag Ptr CTermios
    p_tios :: IO CTcflag
        let new_lflag
             | Bool
    on        = CTcflag
    lflag CTcflag -> CTcflag -> CTcflag
    forall a. Bits a => a -> a -> a
    .|. CInt -> CTcflag
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral CInt
    const_echo
             | Bool
    otherwise = CTcflag
    lflag CTcflag -> CTcflag -> CTcflag
    forall a. Bits a => a -> a -> a
    .&. CTcflag -> CTcflag
    forall a. Bits a => a -> a
    complement (CInt -> CTcflag
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral CInt
    const_echo)
        poke_c_lflag p_tios (new_lflag :: CTcflag)

    getEcho :: FD -> IO Bool
    getEcho :: CInt -> IO Bool
    getEcho CInt
    fd =
      CInt -> (Ptr CTermios -> IO Bool) -> IO Bool
    forall a. CInt -> (Ptr CTermios -> IO a) -> IO a
    tcSetAttr CInt
    fd ((Ptr CTermios -> IO Bool) -> IO Bool)
    -> (Ptr CTermios -> IO Bool) -> IO Bool
    forall a b. (a -> b) -> a -> b
    $ \ Ptr CTermios
    p_tios -> do
        lflag <- Ptr CTermios -> IO CTcflag
    c_lflag Ptr CTermios
    p_tios :: IO CTcflag
        return ((lflag .&. fromIntegral const_echo) /= 0)

    setCooked :: FD -> Bool -> IO ()
    setCooked :: CInt -> Bool -> IO ()
    setCooked CInt
    fd Bool
    cooked =
      CInt -> (Ptr CTermios -> IO ()) -> IO ()
    forall a. CInt -> (Ptr CTermios -> IO a) -> IO a
    tcSetAttr CInt
    fd ((Ptr CTermios -> IO ()) -> IO ())
    -> (Ptr CTermios -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ Ptr CTermios
    p_tios -> do

        -- turn on/off ICANON
        lflag <- Ptr CTermios -> IO CTcflag
    c_lflag Ptr CTermios
    p_tios :: IO CTcflag
        let new_lflag | Bool
    cooked    = CTcflag
    lflag CTcflag -> CTcflag -> CTcflag
    forall a. Bits a => a -> a -> a
    .|. (CInt -> CTcflag
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral CInt
    const_icanon)
                      | Bool
    otherwise = CTcflag
    lflag CTcflag -> CTcflag -> CTcflag
    forall a. Bits a => a -> a -> a
    .&. CTcflag -> CTcflag
    forall a. Bits a => a -> a
    complement (CInt -> CTcflag
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral CInt
    const_icanon)
        poke_c_lflag p_tios (new_lflag :: CTcflag)

        -- set VMIN & VTIME to 1/0 respectively
        when (not cooked) $ do
                c_cc <- ptr_c_cc p_tios
                let vmin  = (Ptr Word8
    c_cc Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` (CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral CInt
    const_vmin))  :: Ptr Word8
                    vtime = (Ptr Word8
    c_cc Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` (CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral CInt
    const_vtime)) :: Ptr Word8
                poke vmin  1
                poke vtime 0

    tcSetAttr :: FD -> (Ptr CTermios -> IO a) -> IO a
    tcSetAttr :: forall a. CInt -> (Ptr CTermios -> IO a) -> IO a
    tcSetAttr CInt
    fd Ptr CTermios -> IO a
    fun =
         Int -> (Ptr CTermios -> IO a) -> IO a
    forall a b. Int -> (Ptr a -> IO b) -> IO b
    allocaBytes Int
    sizeof_termios  ((Ptr CTermios -> IO a) -> IO a) -> (Ptr CTermios -> IO a) -> IO a
    forall a b. (a -> b) -> a -> b
    $ \Ptr CTermios
    p_tios -> do
            String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1Retry_ String
    "tcSetAttr"
               (CInt -> Ptr CTermios -> IO CInt
    c_tcgetattr CInt
    fd Ptr CTermios
    p_tios)

            -- Save a copy of termios, if this is a standard file descriptor.
            -- These terminal settings are restored in hs_exit().
            Bool -> IO () -> IO ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (CInt
    fd CInt -> CInt -> Bool
    forall a. Ord a => a -> a -> Bool
    <= CInt
    2) (IO () -> IO ()) -> IO () -> IO ()
    forall a b. (a -> b) -> a -> b
    $ do
              p <- CInt -> IO (Ptr CTermios)
    get_saved_termios CInt
    fd
              when (p == nullPtr) $ do
                 saved_tios <- mallocBytes sizeof_termios
                 copyBytes saved_tios p_tios sizeof_termios
                 set_saved_termios fd saved_tios

            -- tcsetattr() when invoked by a background process causes the process
            -- to be sent SIGTTOU regardless of whether the process has TOSTOP set
            -- in its terminal flags (try it...).  This function provides a
            -- wrapper which temporarily blocks SIGTTOU around the call, making it
            -- transparent.
            Int -> (Ptr CSigset -> IO a) -> IO a
    forall a b. Int -> (Ptr a -> IO b) -> IO b
    allocaBytes Int
    sizeof_sigset_t ((Ptr CSigset -> IO a) -> IO a) -> (Ptr CSigset -> IO a) -> IO a
    forall a b. (a -> b) -> a -> b
    $ \ Ptr CSigset
    p_sigset ->
              Int -> (Ptr CSigset -> IO a) -> IO a
    forall a b. Int -> (Ptr a -> IO b) -> IO b
    allocaBytes Int
    sizeof_sigset_t ((Ptr CSigset -> IO a) -> IO a) -> (Ptr CSigset -> IO a) -> IO a
    forall a b. (a -> b) -> a -> b
    $ \ Ptr CSigset
    p_old_sigset -> do
                 String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1_ String
    "sigemptyset" (IO CInt -> IO ()) -> IO CInt -> IO ()
    forall a b. (a -> b) -> a -> b
    $
                     Ptr CSigset -> IO CInt
    c_sigemptyset Ptr CSigset
    p_sigset
                 String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1_ String
    "sigaddset" (IO CInt -> IO ()) -> IO CInt -> IO ()
    forall a b. (a -> b) -> a -> b
    $
                     Ptr CSigset -> CInt -> IO CInt
    c_sigaddset   Ptr CSigset
    p_sigset CInt
    const_sigttou
                 String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1_ String
    "sigprocmask" (IO CInt -> IO ()) -> IO CInt -> IO ()
    forall a b. (a -> b) -> a -> b
    $
                     CInt -> Ptr CSigset -> Ptr CSigset -> IO CInt
    c_sigprocmask CInt
    const_sig_block Ptr CSigset
    p_sigset Ptr CSigset
    p_old_sigset
                 r <- Ptr CTermios -> IO a
    fun Ptr CTermios
    p_tios  -- do the business
                 throwErrnoIfMinus1Retry_ "tcSetAttr" $
                     c_tcsetattr fd const_tcsanow p_tios
                 throwErrnoIfMinus1_ "sigprocmask" $
                     c_sigprocmask const_sig_setmask p_old_sigset nullPtr
                 return r

    foreign import ccall unsafe "HsBase.h __hscore_get_saved_termios"
       get_saved_termios :: CInt -> IO (Ptr CTermios)

    foreign import ccall unsafe "HsBase.h __hscore_set_saved_termios"
       set_saved_termios :: CInt -> (Ptr CTermios) -> IO ()

    #elif defined(mingw32_HOST_OS)

    -- 'raw' mode for Win32 means turn off 'line input' (=> buffering and
    -- character translation for the console.) The Win32 API for doing
    -- this is GetConsoleMode(), which also requires echoing to be disabled
    -- when turning off 'line input' processing. Notice that turning off
    -- 'line input' implies enter/return is reported as '\r' (and it won't
    -- report that character until another character is input..odd.) This
    -- latter feature doesn't sit too well with IO actions like IO.hGetLine..
    -- consider yourself warned.
    setCooked :: FD -> Bool -> IO ()
    setCooked fd cooked = do
      x <- set_console_buffering fd (if cooked then 1 else 0)
      if (x /= 0)
       then ioError (ioe_unk_error "setCooked" "failed to set buffering")
       else return ()

    ioe_unk_error :: String -> String -> IOException
    ioe_unk_error loc msg
     = ioeSetErrorString (mkIOError OtherError loc Nothing Nothing) msg

    -- Note: echoing goes hand in hand with enabling 'line input' / raw-ness
    -- for Win32 consoles, hence setEcho ends up being the inverse of setCooked.
    setEcho :: FD -> Bool -> IO ()
    setEcho fd on = do
      x <- set_console_echo fd (if on then 1 else 0)
      if (x /= 0)
       then ioError (ioe_unk_error "setEcho" "failed to set echoing")
       else return ()

    getEcho :: FD -> IO Bool
    getEcho fd = do
      r <- get_console_echo fd
      if (r == (-1))
       then ioError (ioe_unk_error "getEcho" "failed to get echoing")
       else return (r == 1)

    foreign import ccall unsafe "consUtils.h set_console_buffering__"
       set_console_buffering :: CInt -> CInt -> IO CInt

    foreign import ccall unsafe "consUtils.h set_console_echo__"
       set_console_echo :: CInt -> CInt -> IO CInt

    foreign import ccall unsafe "consUtils.h get_console_echo__"
       get_console_echo :: CInt -> IO CInt

    foreign import ccall unsafe "consUtils.h is_console__"
       is_console :: CInt -> IO CInt

    #else

    setCooked :: FD -> Bool -> IO ()
    setCooked _ _ = errorWithoutStackTrace "setCooked"

    setEcho :: FD -> Bool -> IO ()
    setEcho _ _ = errorWithoutStackTrace "setEcho"

    getEcho :: FD -> IO Bool
    getEcho _ = errorWithoutStackTrace "getEcho"

    #endif

    -- ---------------------------------------------------------------------------
    -- Turning on non-blocking for a file descriptor

    setNonBlockingFD :: FD -> Bool -> IO ()
    #if !defined(mingw32_HOST_OS)
    setNonBlockingFD :: CInt -> Bool -> IO ()
    setNonBlockingFD CInt
    fd Bool
    set = do
      flags <- String -> IO CInt -> IO CInt
    forall a. (Eq a, Num a) => String -> IO a -> IO a
    throwErrnoIfMinus1Retry String
    "setNonBlockingFD"
                     (CInt -> CInt -> IO CInt
    c_fcntl_read CInt
    fd CInt
    const_f_getfl)
      let flags' | Bool
    set       = CInt
    flags CInt -> CInt -> CInt
    forall a. Bits a => a -> a -> a
    .|. CInt
    o_NONBLOCK
                 | Bool
    otherwise = CInt
    flags CInt -> CInt -> CInt
    forall a. Bits a => a -> a -> a
    .&. CInt -> CInt
    forall a. Bits a => a -> a
    complement CInt
    o_NONBLOCK
      when (flags /= flags') $ do
        -- An error when setting O_NONBLOCK isn't fatal: on some systems
        -- there are certain file handles on which this will fail (eg. /dev/null
        -- on FreeBSD) so we throw away the return code from fcntl_write.
        _ <- c_fcntl_write fd const_f_setfl (fromIntegral flags')
        return ()
    #else

    -- bogus defns for win32
    setNonBlockingFD _ _ = return ()

    #endif

    -- -----------------------------------------------------------------------------
    -- Set close-on-exec for a file descriptor

    #if !defined(mingw32_HOST_OS)
    setCloseOnExec :: FD -> IO ()
    setCloseOnExec :: CInt -> IO ()
    setCloseOnExec CInt
    fd =
      String -> IO CInt -> IO ()
    forall a. (Eq a, Num a) => String -> IO a -> IO ()
    throwErrnoIfMinus1_ String
    "setCloseOnExec" (IO CInt -> IO ()) -> IO CInt -> IO ()
    forall a b. (a -> b) -> a -> b
    $
        CInt -> CInt -> CLong -> IO CInt
    c_fcntl_write CInt
    fd CInt
    const_f_setfd CLong
    const_fd_cloexec
    #endif

    -- -----------------------------------------------------------------------------
    -- foreign imports

    #if !defined(mingw32_HOST_OS)
    type CFilePath = CString
    #else
    type CFilePath = CWString
    #endif

    -- | The same as 'c_safe_open', but an /interruptible operation/
    -- as described in "Control.Exception"—it respects `uninterruptibleMask`
    -- but not `mask`.
    --
    -- We want to be able to interrupt an openFile call if
    -- it's expensive (NFS, FUSE, etc.), and we especially
    -- need to be able to interrupt a blocking open call.
    -- See #17912.
    --
    -- @since base-4.16.0.0
    c_interruptible_open :: CFilePath -> CInt -> CMode -> IO CInt
    c_interruptible_open :: Ptr CChar -> CInt -> CMode -> IO CInt
    c_interruptible_open Ptr CChar
    filepath CInt
    oflags CMode
    mode =
      IO MaskingState
    getMaskingState IO MaskingState -> (MaskingState -> IO CInt) -> IO CInt
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \case
        -- If we're in an uninterruptible mask, there's basically
        -- no point in using an interruptible FFI call. The open system call
        -- will be interrupted, but the exception won't be delivered
        -- unless the caller manually futzes with the masking state. So
        -- then the caller (assuming they're following the usual conventions)
        -- will retry the call (in response to EINTR), and we've just
        -- wasted everyone's time.
        MaskingState
    MaskedUninterruptible -> Ptr CChar -> CInt -> CMode -> IO CInt
    c_safe_open_ Ptr CChar
    filepath CInt
    oflags CMode
    mode
        MaskingState
    _ -> do
          open_res <- Ptr CChar -> CInt -> CMode -> IO CInt
    c_interruptible_open_ Ptr CChar
    filepath CInt
    oflags CMode
    mode
          -- c_interruptible_open_ is an interruptible foreign call.
          -- If the call is interrupted by an exception handler
          -- before the system call has returned (so the file is
          -- not yet open), we want to deliver the exception.
          -- In point of fact, we deliver any pending exception
          -- here regardless of the *reason* the system call
          -- fails.
          when (open_res == -1) $
            if hostIsThreaded
              then
                -- GHC.Internal.Control.Exception.allowInterrupt, inlined to avoid
                -- messing with any Haddock links.
                interruptible (pure ())
              else
                -- Try to make this work somewhat better on the non-threaded
                -- RTS. See #8684. This inlines the definition of `yield`; module
                -- dependencies look pretty hairy here and I don't want to make
                -- things worse for one little wrapper.
                interruptible (IO $ \State# RealWorld
    s -> (# State# RealWorld -> State# RealWorld
    yield# State# RealWorld
    s, () #))
          pure open_res

    c_safe_open :: CFilePath -> CInt -> CMode -> IO CInt
    c_safe_open :: Ptr CChar -> CInt -> CMode -> IO CInt
    c_safe_open Ptr CChar
    filepath CInt
    oflags CMode
    mode =
      IO MaskingState
    getMaskingState IO MaskingState -> (MaskingState -> IO CInt) -> IO CInt
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \case
        -- When exceptions are unmasked, we use an interruptible
        -- open call. If the system call is successfully
        -- interrupted, the situation will be the same as if
        -- the exception had arrived before this function was
        -- called.
        MaskingState
    Unmasked -> Ptr CChar -> CInt -> CMode -> IO CInt
    c_interruptible_open_ Ptr CChar
    filepath CInt
    oflags CMode
    mode
        MaskingState
    _ -> Ptr CChar -> CInt -> CMode -> IO CInt
    c_safe_open_ Ptr CChar
    filepath CInt
    oflags CMode
    mode

    -- | Consult the RTS to find whether it is threaded.
    --
    -- @since base-4.16.0.0
    hostIsThreaded :: Bool
    hostIsThreaded :: Bool
    hostIsThreaded = Int
    rtsIsThreaded_ Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Int
    0

    #if !defined(javascript_HOST_ARCH)
    foreign import ccall unsafe "HsBase.h __hscore_open"
       c_open :: CFilePath -> CInt -> CMode -> IO CInt

    -- |
    --
    -- @since base-4.16.0.0
    foreign import ccall interruptible "HsBase.h __hscore_open"
       c_interruptible_open_ :: CFilePath -> CInt -> CMode -> IO CInt

    -- |
    --
    -- @since base-4.16.0.0
    foreign import ccall unsafe "rts_isThreaded" rtsIsThreaded_ :: Int

    foreign import ccall safe "HsBase.h __hscore_open"
       c_safe_open_ :: CFilePath -> CInt -> CMode -> IO CInt

    foreign import ccall unsafe "HsBase.h __hscore_fstat"
       c_fstat :: CInt -> Ptr CStat -> IO CInt

    foreign import ccall unsafe "HsBase.h __hscore_lstat"
       lstat :: CFilePath -> Ptr CStat -> IO CInt
    #endif

    #if defined(javascript_HOST_ARCH)

    foreign import javascript unsafe "h$rts_isThreaded" rtsIsThreaded_ :: Int
    foreign import javascript interruptible "h$base_access"
        c_access :: CString -> CInt -> IO CInt
    foreign import javascript interruptible "h$base_chmod"
        c_chmod :: CString -> CMode -> IO CInt
    foreign import javascript interruptible "h$base_close"
        c_close :: CInt -> IO CInt
    foreign import javascript interruptible "h$base_creat"
        c_creat :: CString -> CMode -> IO CInt
    foreign import javascript interruptible "h$base_dup"
        c_dup :: CInt -> IO CInt
    foreign import javascript interruptible "h$base_dup2"
        c_dup2 :: CInt -> CInt -> IO CInt
    foreign import javascript interruptible "h$base_fstat" -- fixme wrong type
        c_fstat :: CInt -> Ptr CStat -> IO CInt
    foreign import javascript unsafe "h$base_isatty"
        c_isatty :: CInt -> IO CInt
    foreign import javascript interruptible "h$base_lseek"
       c_lseek :: CInt -> COff -> CInt -> IO COff
    foreign import javascript interruptible "h$base_lstat"
       lstat :: CFilePath -> Ptr CStat -> IO CInt
    foreign import javascript interruptible "h$open"
       c_open :: CFilePath -> CInt -> CMode -> IO CInt
    foreign import javascript interruptible "h$open"
       c_interruptible_open_ :: CFilePath -> CInt -> CMode -> IO CInt
    foreign import javascript interruptible "h$open"
       c_safe_open_ :: CFilePath -> CInt -> CMode -> IO CInt
    foreign import javascript interruptible "h$openat"
       c_openat :: CInt -> CFilePath -> CInt -> CMode -> IO CInt
    foreign import javascript interruptible "h$base_read"
       c_read :: CInt -> Ptr Word8 -> CSize -> IO CSsize
    foreign import javascript interruptible "h$base_read"
       c_safe_read :: CInt -> Ptr Word8 -> CSize -> IO CSsize
    foreign import javascript interruptible "h$base_stat" -- fixme wrong type
       c_stat :: CFilePath -> Ptr CStat -> IO CInt
    foreign import javascript unsafe "h$base_umask"
       c_umask :: CMode -> IO CMode
    foreign import javascript interruptible "h$base_write"
       c_write :: CInt -> Ptr Word8 -> CSize -> IO CSsize
    foreign import javascript interruptible "h$base_write"
       c_safe_write :: CInt -> Ptr Word8 -> CSize -> IO CSsize
    foreign import javascript interruptible "h$base_ftruncate" -- fixme COff
       c_ftruncate :: CInt -> FileOffset -> IO CInt
    foreign import javascript interruptible "h$base_unlink"
       c_unlink :: CString -> IO CInt
    foreign import javascript unsafe "h$base_getpid"
       c_getpid :: IO CPid
    -- foreign import ccall unsafe "HsBase.h fork"
    --   c_fork :: IO CPid
    foreign import javascript interruptible "h$base_link"
       c_link :: CString -> CString -> IO CInt
    foreign import javascript interruptible "h$base_mkfifo"
       c_mkfifo :: CString -> CMode -> IO CInt
    foreign import javascript interruptible "h$base_pipe"
      c_pipe :: Ptr CInt -> IO CInt
    foreign import javascript unsafe "h$base_sigemptyset"
       c_sigemptyset :: Ptr CSigset -> IO CInt
    foreign import javascript unsafe "h$base_sigaddset"
       c_sigaddset :: Ptr CSigset -> CInt -> IO CInt
    foreign import javascript unsafe "h$base_sigprocmask"
       c_sigprocmask :: CInt -> Ptr CSigset -> Ptr CSigset -> IO CInt
    foreign import javascript unsafe "h$base_tcgetattr"
       c_tcgetattr :: CInt -> Ptr CTermios -> IO CInt
    foreign import javascript unsafe "h$base_tcsetattr"
       c_tcsetattr :: CInt -> CInt -> Ptr CTermios -> IO CInt
    foreign import javascript interruptible "h$base_utime"
       c_utime :: CString -> Ptr CUtimbuf -> IO CInt
    foreign import javascript interruptible "h$base_waitpid"
       c_waitpid :: CPid -> Ptr CInt -> CInt -> IO CPid

    foreign import javascript unsafe "(() => { return h$base_o_rdonly; })"   o_RDONLY   :: CInt
    foreign import javascript unsafe "(() => { return h$base_o_wronly; })"   o_WRONLY   :: CInt
    foreign import javascript unsafe "(() => { return h$base_o_rdwr; })"     o_RDWR     :: CInt
    foreign import javascript unsafe "(() => { return h$base_o_append; })"   o_APPEND   :: CInt
    foreign import javascript unsafe "(() => { return h$base_o_creat; })"    o_CREAT    :: CInt
    foreign import javascript unsafe "(() => { return h$base_o_excl; })"     o_EXCL     :: CInt
    foreign import javascript unsafe "(() => { return h$base_o_trunc; })"    o_TRUNC    :: CInt
    foreign import javascript unsafe "(() => { return h$base_o_noctty; })"   o_NOCTTY   :: CInt
    foreign import javascript unsafe "(() => { return h$base_o_nonblock; })" o_NONBLOCK :: CInt
    foreign import javascript unsafe "(() => { return h$base_o_binary; })"   o_BINARY   :: CInt

    foreign import javascript unsafe "h$base_c_s_isreg"  c_s_isreg  :: CMode -> CInt
    foreign import javascript unsafe "h$base_c_s_ischr"  c_s_ischr  :: CMode -> CInt
    foreign import javascript unsafe "h$base_c_s_isblk"  c_s_isblk  :: CMode -> CInt
    foreign import javascript unsafe "h$base_c_s_isdir"  c_s_isdir  :: CMode -> CInt
    foreign import javascript unsafe "h$base_c_s_isfifo" c_s_isfifo :: CMode -> CInt

    s_isreg  :: CMode -> Bool
    s_isreg cm = c_s_isreg cm /= 0
    s_ischr  :: CMode -> Bool
    s_ischr cm = c_s_ischr cm /= 0
    s_isblk  :: CMode -> Bool
    s_isblk cm = c_s_isblk cm /= 0
    s_isdir  :: CMode -> Bool
    s_isdir cm = c_s_isdir cm /= 0
    s_isfifo :: CMode -> Bool
    s_isfifo cm = c_s_isfifo cm /= 0

    foreign import javascript unsafe "h$base_sizeof_stat" sizeof_stat :: Int
    foreign import javascript unsafe "h$base_st_mtime"    st_mtime :: Ptr CStat -> IO CTime
    foreign import javascript unsafe "h$base_st_size"     st_size :: Ptr CStat -> IO Int64
    foreign import javascript unsafe "h$base_st_mode"     st_mode :: Ptr CStat -> IO CMode
    foreign import javascript unsafe "h$base_st_dev"      st_dev :: Ptr CStat -> IO CDev
    foreign import javascript unsafe "h$base_st_ino"      st_ino :: Ptr CStat -> IO CIno

    foreign import javascript unsafe "(() => { return h$base_echo; })"            const_echo :: CInt
    foreign import javascript unsafe "(() => { return h$base_tcsanow; })"         const_tcsanow :: CInt
    foreign import javascript unsafe "(() => { return h$base_icanon; })"          const_icanon :: CInt
    foreign import javascript unsafe "(() => { return h$base_vmin; })"            const_vmin   :: CInt
    foreign import javascript unsafe "(() => { return h$base_vtime; })"           const_vtime  :: CInt
    foreign import javascript unsafe "(() => { return h$base_sigttou; })"         const_sigttou :: CInt
    foreign import javascript unsafe "(() => { return h$base_sig_block; })"       const_sig_block :: CInt
    foreign import javascript unsafe "(() => { return h$base_sig_setmask; })"     const_sig_setmask :: CInt
    foreign import javascript unsafe "(() => { return h$base_f_getfl; })"         const_f_getfl :: CInt
    foreign import javascript unsafe "(() => { return h$base_f_setfl; })"         const_f_setfl :: CInt
    foreign import javascript unsafe "(() => { return h$base_f_setfd; })"         const_f_setfd :: CInt
    foreign import javascript unsafe "(() => { return h$base_fd_cloexec; })"      const_fd_cloexec :: CLong
    foreign import javascript unsafe "(() => { return h$base_sizeof_termios; })"  sizeof_termios :: Int
    foreign import javascript unsafe "(() => { return h$base_sizeof_sigset_t; })" sizeof_sigset_t :: Int
    foreign import javascript unsafe "h$base_lflag"           c_lflag :: Ptr CTermios -> IO CTcflag
    foreign import javascript unsafe "h$base_poke_lflag"      poke_c_lflag :: Ptr CTermios -> CTcflag -> IO ()
    foreign import javascript unsafe "h$base_ptr_c_cc"        ptr_c_cc  :: Ptr CTermios -> IO (Ptr Word8)
    s_issock :: CMode -> Bool
    s_issock cmode = c_s_issock cmode /= 0
    foreign import javascript unsafe "h$base_c_s_issock"          c_s_issock :: CMode -> CInt
    foreign import javascript unsafe "(() => { return h$base_default_buffer_size; })" dEFAULT_BUFFER_SIZE :: Int
    foreign import javascript unsafe "(() => { return h$base_SEEK_CUR; })"            sEEK_CUR :: CInt
    foreign import javascript unsafe "(() => { return h$base_SEEK_SET; })"            sEEK_SET :: CInt
    foreign import javascript unsafe "(() => { return h$base_SEEK_END; })"            sEEK_END :: CInt

    -- fixme, unclear if these can be supported, remove?
    foreign import javascript unsafe "h$base_c_fcntl_read"  c_fcntl_read  :: CInt -> CInt -> IO CInt
    foreign import javascript unsafe "h$base_c_fcntl_write" c_fcntl_write :: CInt -> CInt -> CLong -> IO CInt
    foreign import javascript unsafe "h$base_c_fcntl_lock"  c_fcntl_lock  :: CInt -> CInt -> Ptr CFLock -> IO CInt

    #else

    #if defined(mingw32_HOST_OS)
    -- See Note [Windows types]
    foreign import capi unsafe "HsBase.h _read"
       c_read :: CInt -> Ptr Word8 -> CUInt -> IO CInt

    -- See Note [Windows types]
    foreign import capi safe "HsBase.h _read"
       c_safe_read :: CInt -> Ptr Word8 -> CUInt -> IO CInt

    foreign import ccall unsafe "HsBase.h _umask"
       c_umask :: CMode -> IO CMode

    -- See Note [Windows types]
    foreign import capi unsafe "HsBase.h _write"
       c_write :: CInt -> Ptr Word8 -> CUInt -> IO CInt

    -- See Note [Windows types]
    foreign import capi safe "HsBase.h _write"
       c_safe_write :: CInt -> Ptr Word8 -> CUInt -> IO CInt

    foreign import ccall unsafe "HsBase.h _pipe"
       c_pipe :: Ptr CInt -> IO CInt

    foreign import capi unsafe "HsBase.h _lseeki64"
       c_lseek :: CInt -> Int64 -> CInt -> IO Int64

    foreign import capi unsafe "HsBase.h _access"
       c_access :: CString -> CInt -> IO CInt

    #if !defined(HAVE_CHMOD)
    c_chmod :: CString -> CMode -> IO CInt
    c_chmod _ _ = ioError (ioeSetLocation unsupportedOperation "_chmod")
    #else
    foreign import ccall unsafe "HsBase.h _chmod"
       c_chmod :: CString -> CMode -> IO CInt
    #endif

    foreign import capi unsafe "HsBase.h _close"
       c_close :: CInt -> IO CInt

    foreign import capi unsafe "HsBase.h _creat"
       c_creat :: CString -> CMode -> IO CInt

    #if !defined(HAVE_DUP)
    c_dup :: CInt -> IO CInt
    c_dup _ = ioError (ioeSetLocation unsupportedOperation "_dup")

    c_dup2 :: CInt -> CInt -> IO CInt
    c_dup2 _ _ = ioError (ioeSetLocation unsupportedOperation "_dup2")
    #else
    foreign import ccall unsafe "HsBase.h _dup"
       c_dup :: CInt -> IO CInt

    foreign import ccall unsafe "HsBase.h _dup2"
       c_dup2 :: CInt -> CInt -> IO CInt
    #endif

    foreign import capi unsafe "HsBase.h _isatty"
       c_isatty :: CInt -> IO CInt

    foreign import capi unsafe "HsBase.h _unlink"
       c_unlink :: CString -> IO CInt

    foreign import capi unsafe "HsBase.h _utime"
       c_utime :: CString -> Ptr CUtimbuf -> IO CInt

    foreign import capi unsafe "HsBase.h _getpid"
       c_getpid :: IO CPid
    #else
    -- We use CAPI as on some OSs (eg. Linux) this is wrapped by a macro
    -- which redirects to the 64-bit-off_t versions when large file
    -- support is enabled.

    -- See Note [Windows types]
    foreign import capi unsafe "HsBase.h read"
       c_read :: CInt -> Ptr Word8 -> CSize -> IO CSsize

    -- See Note [Windows types]
    foreign import capi safe "HsBase.h read"
       c_safe_read :: CInt -> Ptr Word8 -> CSize -> IO CSsize

    #if !defined(HAVE_UMASK)
    c_umask :: CMode -> IO CMode
    c_umask _ = ioError (ioeSetLocation unsupportedOperation "umask")
    #else
    foreign import ccall unsafe "HsBase.h umask"
       c_umask :: CMode -> IO CMode
    #endif

    -- See Note [Windows types]
    foreign import capi unsafe "HsBase.h write"
       c_write :: CInt -> Ptr Word8 -> CSize -> IO CSsize

    -- See Note [Windows types]
    foreign import capi safe "HsBase.h write"
       c_safe_write :: CInt -> Ptr Word8 -> CSize -> IO CSsize

    #if !defined(HAVE_PIPE)
    c_pipe :: Ptr CInt -> IO CInt
    c_pipe _ = ioError (ioeSetLocation unsupportedOperation "pipe")
    #else
    foreign import ccall unsafe "HsBase.h pipe"
       c_pipe :: Ptr CInt -> IO CInt
    #endif

    foreign import capi unsafe "unistd.h lseek"
       c_lseek :: CInt -> COff -> CInt -> IO COff

    foreign import ccall unsafe "HsBase.h access"
       c_access :: CString -> CInt -> IO CInt

    #if !defined(HAVE_CHMOD)
    c_chmod :: CString -> CMode -> IO CInt
    c_chmod _ _ = ioError (ioeSetLocation unsupportedOperation "chmod")
    #else
    foreign import ccall unsafe "HsBase.h chmod"
       c_chmod :: CString -> CMode -> IO CInt
    #endif

    foreign import ccall unsafe "HsBase.h close"
       c_close :: CInt -> IO CInt

    foreign import ccall unsafe "HsBase.h creat"
       c_creat :: CString -> CMode -> IO CInt

    #if !defined(HAVE_DUP)
    c_dup :: CInt -> IO CInt
    c_dup _ = ioError (ioeSetLocation unsupportedOperation "dup")

    c_dup2 :: CInt -> CInt -> IO CInt
    c_dup2 _ _ = ioError (ioeSetLocation unsupportedOperation "dup2")
    #else
    foreign import ccall unsafe "HsBase.h dup"
       c_dup :: CInt -> IO CInt

    foreign import ccall unsafe "HsBase.h dup2"
       c_dup2 :: CInt -> CInt -> IO CInt
    #endif

    foreign import ccall unsafe "HsBase.h isatty"
       c_isatty :: CInt -> IO CInt

    foreign import ccall unsafe "HsBase.h unlink"
       c_unlink :: CString -> IO CInt

    foreign import capi unsafe "HsBase.h utime"
       c_utime :: CString -> Ptr CUtimbuf -> IO CInt

    #if !defined(HAVE_GETPID)
    c_getpid :: IO CPid
    c_getpid = pure 1
    #else
    foreign import ccall unsafe "HsBase.h getpid"
       c_getpid :: IO CPid
    #endif
    #endif

    #if !defined(javascript_HOST_ARCH)
    foreign import ccall unsafe "HsBase.h __hscore_stat"
       c_stat :: CFilePath -> Ptr CStat -> IO CInt

    foreign import ccall unsafe "HsBase.h __hscore_ftruncate"
       c_ftruncate :: CInt -> COff -> IO CInt
    #endif

    #if !defined(mingw32_HOST_OS) && !defined(javascript_HOST_ARCH)
    foreign import capi unsafe "HsBase.h fcntl"
       c_fcntl_read  :: CInt -> CInt -> IO CInt

    foreign import capi unsafe "HsBase.h fcntl"
       c_fcntl_write :: CInt -> CInt -> CLong -> IO CInt

    foreign import capi unsafe "HsBase.h fcntl"
       c_fcntl_lock  :: CInt -> CInt -> Ptr CFLock -> IO CInt

    #if !defined(HAVE_FORK)
    c_fork :: IO CPid
    c_fork = ioError (ioeSetLocation unsupportedOperation "fork")
    #else
    foreign import ccall unsafe "HsBase.h fork"
       c_fork :: IO CPid
    #endif

    foreign import ccall unsafe "HsBase.h link"
       c_link :: CString -> CString -> IO CInt

    #if !defined(HAVE_MKFIFO)
    c_mkfifo :: CString -> CMode -> IO CInt
    c_mkfifo _ _ = ioError (ioeSetLocation unsupportedOperation "mkfifo")
    #else
    -- capi is required at least on Android
    foreign import capi unsafe "HsBase.h mkfifo"
       c_mkfifo :: CString -> CMode -> IO CInt
    #endif

    #if HAVE_SIGNAL_H
    foreign import capi unsafe "signal.h sigemptyset"
       c_sigemptyset :: Ptr CSigset -> IO CInt

    foreign import capi unsafe "signal.h sigaddset"
       c_sigaddset :: Ptr CSigset -> CInt -> IO CInt

    foreign import capi unsafe "signal.h sigprocmask"
       c_sigprocmask :: CInt -> Ptr CSigset -> Ptr CSigset -> IO CInt
    #endif

    #if !defined(HAVE_TERMIOS_H)

    c_tcgetattr :: CInt -> Ptr CTermios -> IO CInt
    c_tcgetattr _ _ = ioError (ioeSetLocation unsupportedOperation "tcgetattr")

    c_tcsetattr :: CInt -> CInt -> Ptr CTermios -> IO CInt
    c_tcsetattr _ _ _ = ioError (ioeSetLocation unsupportedOperation "tcsetattr")

    #else

    -- capi is required at least on Android
    foreign import capi unsafe "HsBase.h tcgetattr"
       c_tcgetattr :: CInt -> Ptr CTermios -> IO CInt

    -- capi is required at least on Android
    foreign import capi unsafe "HsBase.h tcsetattr"
       c_tcsetattr :: CInt -> CInt -> Ptr CTermios -> IO CInt

    #endif

    #if defined(HAVE_GETPID)
    foreign import ccall unsafe "HsBase.h waitpid"
       c_waitpid :: CPid -> Ptr CInt -> CInt -> IO CPid
    #else
    c_waitpid :: CPid -> Ptr CInt -> CInt -> IO CPid
    c_waitpid _ _ _ = ioError (ioeSetLocation unsupportedOperation "waitpid")
    #endif

    #endif

    #if !defined(javascript_HOST_ARCH)
    -- POSIX flags only:
    foreign import ccall unsafe "HsBase.h __hscore_o_rdonly" o_RDONLY :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_o_wronly" o_WRONLY :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_o_rdwr"   o_RDWR   :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_o_append" o_APPEND :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_o_creat"  o_CREAT  :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_o_excl"   o_EXCL   :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_o_trunc"  o_TRUNC  :: CInt

    -- non-POSIX flags.
    foreign import ccall unsafe "HsBase.h __hscore_o_noctty"   o_NOCTTY   :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_o_nonblock" o_NONBLOCK :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_o_binary"   o_BINARY   :: CInt

    foreign import capi unsafe "sys/stat.h S_ISREG"  c_s_isreg  :: CMode -> CInt
    foreign import capi unsafe "sys/stat.h S_ISCHR"  c_s_ischr  :: CMode -> CInt
    foreign import capi unsafe "sys/stat.h S_ISBLK"  c_s_isblk  :: CMode -> CInt
    foreign import capi unsafe "sys/stat.h S_ISDIR"  c_s_isdir  :: CMode -> CInt
    foreign import capi unsafe "sys/stat.h S_ISFIFO" c_s_isfifo :: CMode -> CInt

    s_isreg  :: CMode -> Bool
    s_isreg :: CMode -> Bool
    s_isreg CMode
    cm = CMode -> CInt
    c_s_isreg CMode
    cm CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0
    s_ischr  :: CMode -> Bool
    s_ischr :: CMode -> Bool
    s_ischr CMode
    cm = CMode -> CInt
    c_s_ischr CMode
    cm CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0
    s_isblk  :: CMode -> Bool
    s_isblk :: CMode -> Bool
    s_isblk CMode
    cm = CMode -> CInt
    c_s_isblk CMode
    cm CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0
    s_isdir  :: CMode -> Bool
    s_isdir :: CMode -> Bool
    s_isdir CMode
    cm = CMode -> CInt
    c_s_isdir CMode
    cm CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0
    s_isfifo :: CMode -> Bool
    s_isfifo :: CMode -> Bool
    s_isfifo CMode
    cm = CMode -> CInt
    c_s_isfifo CMode
    cm CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0

    foreign import ccall unsafe "HsBase.h __hscore_sizeof_stat" sizeof_stat :: Int
    foreign import ccall unsafe "HsBase.h __hscore_st_mtime" st_mtime :: Ptr CStat -> IO CTime
    #if defined(mingw32_HOST_OS)
    foreign import ccall unsafe "HsBase.h __hscore_st_size" st_size :: Ptr CStat -> IO Int64
    #else
    foreign import ccall unsafe "HsBase.h __hscore_st_size" st_size :: Ptr CStat -> IO COff
    #endif
    foreign import ccall unsafe "HsBase.h __hscore_st_mode" st_mode :: Ptr CStat -> IO CMode
    foreign import ccall unsafe "HsBase.h __hscore_st_dev" st_dev :: Ptr CStat -> IO CDev
    foreign import ccall unsafe "HsBase.h __hscore_st_ino" st_ino :: Ptr CStat -> IO CIno

    foreign import ccall unsafe "HsBase.h __hscore_echo"         const_echo :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_tcsanow"      const_tcsanow :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_icanon"       const_icanon :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_vmin"         const_vmin   :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_vtime"        const_vtime  :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_sigttou"      const_sigttou :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_sig_block"    const_sig_block :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_sig_setmask"  const_sig_setmask :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_f_getfl"      const_f_getfl :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_f_setfl"      const_f_setfl :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_f_setfd"      const_f_setfd :: CInt
    foreign import ccall unsafe "HsBase.h __hscore_fd_cloexec"   const_fd_cloexec :: CLong

    #if defined(HTYPE_TCFLAG_T)
    foreign import ccall unsafe "HsBase.h __hscore_sizeof_termios"  sizeof_termios :: Int
    foreign import ccall unsafe "HsBase.h __hscore_sizeof_sigset_t" sizeof_sigset_t :: Int

    foreign import ccall unsafe "HsBase.h __hscore_lflag" c_lflag :: Ptr CTermios -> IO CTcflag
    foreign import ccall unsafe "HsBase.h __hscore_poke_lflag" poke_c_lflag :: Ptr CTermios -> CTcflag -> IO ()
    foreign import ccall unsafe "HsBase.h __hscore_ptr_c_cc" ptr_c_cc  :: Ptr CTermios -> IO (Ptr Word8)
    #endif

    s_issock :: CMode -> Bool
    #if !defined(mingw32_HOST_OS)
    s_issock :: CMode -> Bool
    s_issock CMode
    cmode = CMode -> CInt
    c_s_issock CMode
    cmode CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0
    foreign import capi unsafe "sys/stat.h S_ISSOCK" c_s_issock :: CMode -> CInt
    #else
    s_issock _ = False
    #endif

    foreign import ccall unsafe "__hscore_bufsiz"  dEFAULT_BUFFER_SIZE :: Int
    foreign import capi  unsafe "stdio.h value SEEK_CUR" sEEK_CUR :: CInt
    foreign import capi  unsafe "stdio.h value SEEK_SET" sEEK_SET :: CInt
    foreign import capi  unsafe "stdio.h value SEEK_END" sEEK_END :: CInt
    #endif
    #endif

    {-
    Note [Windows types]
    ~~~~~~~~~~~~~~~~~~~~

    Windows' _read and _write have types that differ from POSIX. They take an
    unsigned int for length and return a signed int where POSIX uses size_t and
    ssize_t. Those are different on x86_64 and equivalent on x86. We import them
    with the types in Microsoft's documentation which means that c_read,
    c_safe_read, c_write and c_safe_write have different Haskell types depending on
    the OS.
    -}