{-# LINE 1 "libraries\\ghci\\GHCi\\Utils.hsc" #-}
{-# LANGUAGE CPP #-}
module GHCi.Utils
  ( getGhcHandle
  , readGhcHandle
  )
where

import Prelude
import Foreign.C
import GHC.IO.Handle (Handle())

{-# LINE 12 "libraries\\ghci\\GHCi\\Utils.hsc" #-}
import Foreign.Ptr (ptrToIntPtr,wordPtrToPtr)
import GHC.IO (onException)
import GHC.IO.Handle.FD (fdToHandle)
import GHC.Windows (HANDLE)
import GHC.IO.SubSystem ((<!>))
import GHC.IO.Handle.Windows (mkHandleFromHANDLE)
import GHC.IO.Device as IODevice
import GHC.IO.Encoding (getLocaleEncoding)
import GHC.IO.IOMode
import GHC.IO.Windows.Handle (fromHANDLE, Io(), NativeHandle())




{-# LINE 28 "libraries\\ghci\\GHCi\\Utils.hsc" #-}

-- | Gets a GHC Handle File description from the given OS Handle or POSIX fd.



{-# LINE 32 "libraries\\ghci\\GHCi\\Utils.hsc" #-}
getGhcHandle :: HANDLE -> IO Handle
getGhcHandle :: HANDLE -> IO Handle
getGhcHandle = HANDLE -> IO Handle
getGhcHandlePOSIX (HANDLE -> IO Handle)
-> (HANDLE -> IO Handle) -> HANDLE -> IO Handle
forall a. a -> a -> a
<!> HANDLE -> IO Handle
getGhcHandleNative

getGhcHandlePOSIX :: HANDLE -> IO Handle
getGhcHandlePOSIX :: HANDLE -> IO Handle
getGhcHandlePOSIX HANDLE
handle = do
  let intptr :: IntPtr
intptr = HANDLE -> IntPtr
forall a. Ptr a -> IntPtr
ptrToIntPtr HANDLE
handle
  CInt -> CInt -> IO CInt
_open_osfhandle (IntPtr -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral IntPtr
intptr) (CInt
32768) IO CInt -> (CInt -> IO Handle) -> IO Handle
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CInt -> IO Handle
fdToHandle
{-# LINE 39 "libraries\\ghci\\GHCi\\Utils.hsc" #-}

getGhcHandleNative :: HANDLE -> IO Handle
getGhcHandleNative :: HANDLE -> IO Handle
getGhcHandleNative HANDLE
hwnd =
  do Maybe TextEncoding
mb_codec <- (TextEncoding -> Maybe TextEncoding)
-> IO TextEncoding -> IO (Maybe TextEncoding)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TextEncoding -> Maybe TextEncoding
forall a. a -> Maybe a
Just IO TextEncoding
getLocaleEncoding
     let iomode :: IOMode
iomode = IOMode
ReadWriteMode
         native_handle :: Io NativeHandle
native_handle = HANDLE -> Io NativeHandle
forall a. RawHandle a => HANDLE -> a
fromHANDLE HANDLE
hwnd :: Io NativeHandle
     IODeviceType
hw_type <- Io NativeHandle -> IO IODeviceType
forall a. IODevice a => a -> IO IODeviceType
IODevice.devType (Io NativeHandle -> IO IODeviceType)
-> Io NativeHandle -> IO IODeviceType
forall a b. (a -> b) -> a -> b
$ Io NativeHandle
native_handle
     Io NativeHandle
-> IODeviceType
-> FilePath
-> IOMode
-> Maybe TextEncoding
-> IO Handle
forall dev.
(RawIO dev, IODevice dev, BufferedIO dev, Typeable dev) =>
dev
-> IODeviceType
-> FilePath
-> IOMode
-> Maybe TextEncoding
-> IO Handle
mkHandleFromHANDLE Io NativeHandle
native_handle IODeviceType
hw_type (HANDLE -> FilePath
forall a. Show a => a -> FilePath
show HANDLE
hwnd) IOMode
iomode Maybe TextEncoding
mb_codec
       IO Handle -> IO () -> IO Handle
forall a b. IO a -> IO b -> IO a
`onException` Io NativeHandle -> IO ()
forall a. IODevice a => a -> IO ()
IODevice.close Io NativeHandle
native_handle

foreign import ccall "io.h _open_osfhandle" _open_osfhandle ::
    CInt -> CInt -> IO CInt

{-# LINE 55 "libraries\\ghci\\GHCi\\Utils.hsc" #-}

-- | Read a handle passed on the command-line and prepare it to be used with the IO manager

readGhcHandle :: String -> IO Handle
readGhcHandle :: FilePath -> IO Handle
readGhcHandle FilePath
s = do

{-# LINE 60 "libraries\\ghci\\GHCi\\Utils.hsc" #-}
  let fd = wordPtrToPtr (Prelude.read s)

{-# LINE 67 "libraries\\ghci\\GHCi\\Utils.hsc" #-}

{-# LINE 70 "libraries\\ghci\\GHCi\\Utils.hsc" #-}
  getGhcHandle fd