System.Process.Internals

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

Documentation

data ProcessHandle

Constructors

ProcessHandle !(MVar ProcessHandle__) !Bool

data ProcessHandle__

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

closePHANDLE :: PHANDLE -> IO ()

mkProcessHandle :: PHANDLE -> Bool -> IO ProcessHandle

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

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

data CreateProcess

Constructors

CreateProcess

Fields

cmdspec :: CmdSpec

Executable & arguments, or shell command

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

data CmdSpec

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

IsString CmdSpec

construct a ShellCommand from a string literal

Since: 1.2.1.0

data StdStream

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 Handles created by openFile).

createProcess_

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_

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).

startDelegateControlC :: IO ()

endDelegateControlC :: ExitCode -> IO ()

stopDelegateControlC :: IO ()

pPrPr_disableITimers :: IO ()

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

ignoreSignal :: CLong

defaultSignal :: CLong

withFilePathException :: FilePath -> IO a -> IO a

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

translate :: String -> String

fdToHandle :: FD -> IO Handle

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.