base-4.20.2.0: Core data structures and operations

License | BSD-style (see the file LICENSE)
Maintainer | libraries@haskell.org
Stability | internal
Portability | portable
Safe Haskell | Safe
Language | Haskell2010

GHC.ResponseFile

Description

GCC style response files.

Since: base-4.12.0.0

Synopsis

- getArgsWithResponseFiles :: IO [String]
- unescapeArgs :: String -> [String]
- escapeArgs :: [String] -> String
- expandResponse :: [String] -> IO [String]

# Documentation

getArgsWithResponseFiles :: IO [String] Source #

Like `getArgs`, but can also read arguments supplied via response files.

For example, consider a program `foo`:

    main :: IO ()
    main = do
      args <- getArgsWithResponseFiles
      putStrLn (show args)

And a response file `args.txt`:

    --one 1
    --'two' 2
    --"three" 3

Then the result of invoking `foo` with `args.txt` is:

    > ./foo @args.txt
    ["--one","1","--two","2","--three","3"]

unescapeArgs :: String -> [String] Source #

Given a string of concatenated strings, separate each by removing a layer of quoting and/or escaping of certain characters.

These characters are: any whitespace, single quote, double quote, and the backslash character. The backslash character always escapes (i.e., passes through without further consideration) the character which follows. Characters can also be escaped in blocks by quoting (i.e., surrounding the blocks with matching pairs of either single- or double-quotes which are not themselves escaped).

Any whitespace which appears outside of either of the quoting and escaping mechanisms, is interpreted as having been added by this special concatenation process to designate where the boundaries are between the original, un-concatenated list of strings. These added whitespace characters are removed from the output.

    unescapeArgs "hello\\ \\\"world\\\"\n" == ["hello \"world\""]

escapeArgs :: [String] -> String Source #

Given a list of strings, concatenate them into a single string with escaping of certain characters, and the addition of a newline between each string. The escaping is done by adding a single backslash character before any whitespace, single quote, double quote, or backslash character, so this escaping character must be removed. Unescaped whitespace (in this case, newline) is part of this "transport" format to indicate the end of the previous string and the start of a new string.

While `unescapeArgs` allows using quoting (i.e., convenient escaping of many characters) by having matching sets of single- or double-quotes,`escapeArgs` does not use the quoting mechanism, and thus will always escape any whitespace, quotes, and backslashes.

    escapeArgs ["hello \"world\""] == "hello\\ \\\"world\\\"\n"

expandResponse :: [String] -> IO [String] Source #

Arguments which look like `@foo` will be replaced with the contents of file `foo`. A gcc-like syntax for response files arguments is expected. This must re-constitute the argument list by doing an inverse of the escaping mechanism done by the calling-program side.

We quit if the file is not found or reading somehow fails. (A convenience routine for haddock or possibly other clients)