content: {-# LANGUAGE CPP #-}
  -- | Unlifted "System.Process".
  --
  -- @since 0.2.5.0
  
  module UnliftIO.Process (
    -- * Running sub-processes
    CreateProcess(..), CmdSpec(..), StdStream(..), ProcessHandle, createProcess
  
  #if MIN_VERSION_process(1,2,1)
    , createProcess_
  #endif
  
    , P.shell, P.proc
  
    -- ** Simpler functions for common tasks
    , callProcess, callCommand, spawnProcess, spawnCommand
  
  #if MIN_VERSION_process(1,2,3)
    , readCreateProcess
  #endif
  
    , readProcess
  
  #if MIN_VERSION_process(1,2,3)
    , readCreateProcessWithExitCode
  #endif
  
    , readProcessWithExitCode
  
  #if MIN_VERSION_process(1,4,3)
    , withCreateProcess
  #endif
  
    -- ** Related utilities
    , P.showCommandForUser
  
    -- * Process completion
    , waitForProcess, getProcessExitCode, terminateProcess, interruptProcessGroupOf
  
  #if MIN_VERSION_process(1,2,1)
    -- * Interprocess communication
    , createPipe
  #endif
  
  #if MIN_VERSION_process(1,4,2)
    , createPipeFd
  #endif
    ) where
  
  import Control.Monad.IO.Unlift
  import System.Exit
  import System.IO
  import System.Posix.Internals
  import System.Process
    ( CmdSpec(..)
    , CreateProcess(..)
    , ProcessHandle
    , StdStream(..)
    )
  import qualified System.Process as P
  
  -- | Lifted 'P.createProcess'.
  --
  -- @since 0.2.5.0
  {-# INLINE createProcess #-}
  createProcess ::
       MonadIO m
    => CreateProcess
    -> m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
  createProcess = liftIO . P.createProcess
  
  #if MIN_VERSION_process(1,2,1)
  -- | Lifted 'P.createProcess_'.
  --
  -- @since 0.2.5.0
  {-# INLINE createProcess_ #-}
  createProcess_ ::
       MonadIO m
    => String
    -> CreateProcess
    -> m (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)
  createProcess_ msg proc_ = liftIO (P.createProcess_ msg proc_)
  #endif
  
  -- | Lifted 'P.callProcess'.
  --
  -- @since 0.2.5.0
  {-# INLINE callProcess #-}
  callProcess :: MonadIO m => FilePath -> [String] -> m ()
  callProcess cmd args = liftIO (P.callProcess cmd args)
  
  -- | Lifted 'P.callCommand'.
  --
  -- @since 0.2.5.0
  {-# INLINE callCommand #-}
  callCommand :: MonadIO m => String -> m ()
  callCommand = liftIO . P.callCommand
  
  -- | Lifted 'P.spawnProcess'.
  --
  -- @since 0.2.5.0
  {-# INLINE spawnProcess #-}
  spawnProcess :: MonadIO m => FilePath -> [String] -> m ProcessHandle
  spawnProcess cmd args = liftIO (P.spawnProcess cmd args)
  
  -- | Lifted 'P.spawnCommand'.
  --
  -- @since 0.2.5.0
  {-# INLINE spawnCommand #-}
  spawnCommand :: MonadIO m => String -> m ProcessHandle
  spawnCommand = liftIO . P.spawnCommand
  
  #if MIN_VERSION_process(1,2,3)
  -- | Lifted 'P.readCreateProcess'.
  --
  -- @since 0.2.5.0
  {-# INLINE readCreateProcess #-}
  readCreateProcess :: MonadIO m => CreateProcess -> String -> m String
  readCreateProcess cp input = liftIO (P.readCreateProcess cp input)
  #endif
  
  -- | Lifted 'P.readProcess'.
  --
  -- @since 0.2.5.0
  {-# INLINE readProcess #-}
  readProcess :: MonadIO m => FilePath -> [String] -> String -> m String
  readProcess cmd args input = liftIO (P.readProcess cmd args input)
  
  #if MIN_VERSION_process(1,2,3)
  -- | Lifted 'P.readCreateProcessWithExitCode'.
  --
  -- @since 0.2.5.0
  {-# INLINE readCreateProcessWithExitCode #-}
  readCreateProcessWithExitCode ::
       MonadIO m => CreateProcess -> String -> m (ExitCode, String, String)
  readCreateProcessWithExitCode cp input =
    liftIO (P.readCreateProcessWithExitCode cp input)
  #endif
  
  -- | Lifted 'P.readProcessWithExitCode'.
  --
  -- @since 0.2.5.0
  {-# INLINE readProcessWithExitCode #-}
  readProcessWithExitCode ::
       MonadIO m => FilePath -> [String] -> String -> m (ExitCode, String, String)
  readProcessWithExitCode cmd args input =
    liftIO (P.readProcessWithExitCode cmd args input)
  
  #if MIN_VERSION_process(1,4,3)
  -- | Unlifted 'P.withCreateProcess'.
  --
  -- @since 0.2.5.0
  {-# INLINE withCreateProcess #-}
  withCreateProcess ::
       MonadUnliftIO m
    => CreateProcess
    -> (Maybe Handle -> Maybe Handle -> Maybe Handle -> ProcessHandle -> m a)
    -> m a
  withCreateProcess c action =
    withRunInIO
      (\u ->
         P.withCreateProcess
           c
           (\stdin_h stdout_h stderr_h proc_h ->
              u (action stdin_h stdout_h stderr_h proc_h)))
  #endif
  
  -- | Lifted 'P.waitForProcess'.
  --
  -- @since 0.2.5.0
  {-# INLINE waitForProcess #-}
  waitForProcess :: MonadIO m => ProcessHandle -> m ExitCode
  waitForProcess = liftIO . P.waitForProcess
  
  -- | Lifted 'P.getProcessExitCode'.
  --
  -- @since 0.2.5.0
  {-# INLINE getProcessExitCode #-}
  getProcessExitCode :: MonadIO m => ProcessHandle -> m (Maybe ExitCode)
  getProcessExitCode = liftIO . P.getProcessExitCode
  
  -- | Lifted 'P.terminateProcess'.
  --
  -- @since 0.2.5.0
  {-# INLINE terminateProcess #-}
  terminateProcess :: MonadIO m => ProcessHandle -> m ()
  terminateProcess = liftIO . P.terminateProcess
  
  -- | Lifted 'P.interruptProcessGroupOf'.
  --
  -- @since 0.2.5.0
  {-# INLINE interruptProcessGroupOf #-}
  interruptProcessGroupOf :: MonadIO m => ProcessHandle -> m ()
  interruptProcessGroupOf = liftIO . P.interruptProcessGroupOf
  
  #if MIN_VERSION_process(1,2,1)
  -- | Lifted 'P.createPipe'.
  --
  -- @since 0.2.5.0
  {-# INLINE createPipe #-}
  createPipe :: MonadIO m => m (Handle, Handle)
  createPipe = liftIO P.createPipe
  #endif
  
  #if MIN_VERSION_process(1,4,2)
  -- | Lifted 'P.createPipeFd'.
  --
  -- @since 0.2.5.0
  {-# INLINE createPipeFd #-}
  createPipeFd :: MonadIO m => m (FD, FD)
  createPipeFd = liftIO P.createPipeFd
  #endif
  