Copyright	(c) The University of Glasgow 2004
License	BSD-style (see the file libraries/base/LICENSE)
Maintainer	[email protected]
Stability	experimental
Portability	portable
Safe Haskell	Trustworthy
Language	Haskell2010

System.Process.Internals

Description

Note: This module exports internal implementation details that may change anytime. If you want a more stable API, use System.Process instead.

Synopsis

Documentation

data ProcessHandle Source #

Constructors

ProcessHandle !(MVar ProcessHandle__) !Bool

data ProcessHandle__ Source #

A handle to a process, which can be used to wait for termination of the process using waitForProcess.

None of the process-creation functions in this library wait for termination: they all return a ProcessHandle which may be used to wait for the process later.

Constructors

OpenHandle PHANDLE
ClosedHandle ExitCode

type PHANDLE = CPid Source #

closePHANDLE :: PHANDLE -> IO () Source #

mkProcessHandle :: PHANDLE -> Bool -> IO ProcessHandle Source #

modifyProcessHandle :: ProcessHandle -> (ProcessHandle__ -> IO (ProcessHandle__, a)) -> IO a Source #

withProcessHandle :: ProcessHandle -> (ProcessHandle__ -> IO a) -> IO a Source #

data CreateProcess Source #

Constructors

CreateProcess

Fields

cmdspec :: CmdSpec
Executable & arguments, or shell command. Relative paths are resolved with respect to cwd if given, and otherwise the current working directory.
cwd :: Maybe FilePath
Optional path to the working directory for the new process
env :: Maybe [(String, String)]
Optional environment (otherwise inherit from the current process)
std_in :: StdStream
How to determine stdin
std_out :: StdStream
How to determine stdout
std_err :: StdStream
How to determine stderr
close_fds :: Bool
Close all file descriptors except stdin, stdout and stderr in the new process (on Windows, only works if std_in, std_out, and std_err are all Inherit)
create_group :: Bool
Create a new process group
delegate_ctlc :: Bool
Delegate control-C handling. Use this for interactive console processes to let them handle control-C themselves (see below for details).
On Windows this has no effect.
Since: 1.2.0.0
detach_console :: Bool
Use the windows DETACHED_PROCESS flag when creating the process; does nothing on other platforms.
Since: 1.3.0.0
create_new_console :: Bool
Use the windows CREATE_NEW_CONSOLE flag when creating the process; does nothing on other platforms.
Default: False
Since: 1.3.0.0
new_session :: Bool
Use posix setsid to start the new process in a new session; does nothing on other platforms.
Since: 1.3.0.0
child_group :: Maybe GroupID
Use posix setgid to set child process's group id; does nothing on other platforms.
Default: Nothing
Since: 1.4.0.0
child_user :: Maybe UserID
Use posix setuid to set child process's user id; does nothing on other platforms.
Default: Nothing
Since: 1.4.0.0

Instances

Eq CreateProcess #
Methods (==) :: CreateProcess -> CreateProcess -> Bool # (/=) :: CreateProcess -> CreateProcess -> Bool #
Show CreateProcess #
Methods showsPrec :: Int -> CreateProcess -> ShowS Source # show :: CreateProcess -> String Source # showList :: [CreateProcess] -> ShowS Source #

data CmdSpec Source #

Constructors

ShellCommand String

A command line to execute using the shell

RawCommand FilePath [String]

The name of an executable with a list of arguments

The FilePath argument names the executable, and is interpreted according to the platform's standard policy for searching for executables. Specifically:

on Unix systems the execvp(3) semantics is used, where if the executable filename does not contain a slash (/) then the PATH environment variable is searched for the executable.
on Windows systems the Win32 CreateProcess semantics is used. Briefly: if the filename does not contain a path, then the directory containing the parent executable is searched, followed by the current directory, then some standard locations, and finally the current PATH. An .exe extension is added if the filename does not already have an extension. For full details see the documentation for the Windows SearchPath API.

Instances

Eq CmdSpec #
Methods (==) :: CmdSpec -> CmdSpec -> Bool # (/=) :: CmdSpec -> CmdSpec -> Bool #
Show CmdSpec #
Methods showsPrec :: Int -> CmdSpec -> ShowS Source # show :: CmdSpec -> String Source # showList :: [CmdSpec] -> ShowS Source #
IsString CmdSpec #	construct a `ShellCommand` from a string literal Since: 1.2.1.0
Methods fromString :: String -> CmdSpec Source #

data StdStream Source #

Constructors

Inherit	Inherit Handle from parent
UseHandle Handle	Use the supplied Handle
CreatePipe	Create a new pipe. The returned `Handle` will use the default encoding and newline translation mode (just like `Handle`s created by `openFile`).
NoStream	No stream handle will be passed

Instances

Eq StdStream #
Methods (==) :: StdStream -> StdStream -> Bool # (/=) :: StdStream -> StdStream -> Bool #
Show StdStream #
Methods showsPrec :: Int -> StdStream -> ShowS Source # show :: StdStream -> String Source # showList :: [StdStream] -> ShowS Source #

createProcess_ Source #

Arguments

:: String	function name (for error messages)
-> CreateProcess
-> IO (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)

This function is almost identical to createProcess. The only differences are:

Handles provided via UseHandle are not closed automatically.
This function takes an extra String argument to be used in creating error messages.

This function has been available from the System.Process.Internals module for some time, and is part of the System.Process module since version 1.2.1.0.

Since: 1.2.1.0

runGenProcess_ Source #

Arguments

:: String	function name (for error messages)
-> CreateProcess
-> Maybe CLong	handler for SIGINT
-> Maybe CLong	handler for SIGQUIT
-> IO (Maybe Handle, Maybe Handle, Maybe Handle, ProcessHandle)

Deprecated: Please do not use this anymore, use the ordinary createProcess. If you need the SIGINT handling, use delegate_ctlc = True (runGenProcess_ is now just an imperfectly emulated stub that probably duplicates or overrides your own signal handling).

fdToHandle :: FD -> IO Handle Source #

Turn an existing file descriptor into a Handle. This is used by various external libraries to make Handles.

Makes a binary Handle. This is for historical reasons; it should probably be a text Handle with the default encoding and newline translation instead.

startDelegateControlC :: IO () Source #

endDelegateControlC :: ExitCode -> IO () Source #

stopDelegateControlC :: IO () Source #

pPrPr_disableITimers :: IO () Source #

c_execvpe :: CString -> Ptr CString -> Ptr CString -> IO CInt Source #

ignoreSignal :: CLong Source #

defaultSignal :: CLong Source #

withFilePathException :: FilePath -> IO a -> IO a Source #

withCEnvironment :: [(String, String)] -> (Ptr CString -> IO a) -> IO a Source #

translate :: String -> String Source #

createPipe :: IO (Handle, Handle) Source #

Create a pipe for interprocess communication and return a (readEnd, writeEnd) Handle pair.

Since: 1.2.1.0

createPipeFd :: IO (FD, FD) Source #

Create a pipe for interprocess communication and return a (readEnd, writeEnd) FD pair.

Since: 1.4.2.0

interruptProcessGroupOf Source #

Arguments

:: ProcessHandle	A process in the process group
-> IO ()

Sends an interrupt signal to the process group of the given process.

On Unix systems, it sends the group the SIGINT signal.

On Windows systems, it generates a CTRL_BREAK_EVENT and will only work for processes created using createProcess and setting the create_group flag