-----------------------------------------------------------------------------
--
--- (c) The University of Glasgow 2001
+-- (c) The University of Glasgow 2001-2003
--
-- Access to system tools: gcc, cp, rm etc
--
setPgms,
setPgma,
setPgml,
+ setPgmDLL,
#ifdef ILX
setPgmI,
setPgmi,
getTopDir, -- IO String -- The value of $libdir
getPackageConfigPath, -- IO String -- Where package.conf is
+ getUsageMsgPaths, -- IO (String,String)
-- Interface to system tools
runUnlit, runCpp, runCc, -- [Option] -> IO ()
-- Temporary-file management
setTmpDir,
newTempName,
- cleanTempFiles, cleanTempFilesExcept, removeTmpFiles,
+ cleanTempFiles, cleanTempFilesExcept,
addFilesToClean,
-- System interface
- getProcessID, -- IO Int
system, -- String -> IO ExitCode
-- Misc
- showGhcUsage, -- IO () Shows usage message and exits
getSysMan, -- IO String Parallel system only
Option(..)
#include "HsVersions.h"
import DriverUtil
+import DriverPhases ( isHaskellUserSrcFilename )
import Config
import Outputable
-import Panic ( progName, GhcException(..) )
-import Util ( global, notNull )
+import Panic ( GhcException(..) )
+import Util ( global, notNull, toArgs )
import CmdLineOpts ( dynFlag, verbosity )
import EXCEPTION ( throwDyn )
import DATA_INT
import Monad ( when, unless )
-import System ( ExitCode(..), exitWith, getEnv, system )
+import System ( ExitCode(..), getEnv, system )
import IO ( try, catch,
- openFile, hPutChar, hPutStrLn, hPutStr, hClose, hFlush, IOMode(..),
+ openFile, hPutStrLn, hPutStr, hClose, hFlush, IOMode(..),
stderr )
import Directory ( doesFileExist, removeFile )
-import List ( intersperse )
+import List ( partition )
#include "../includes/config.h"
-- GHC <= 4.08 didn't have rawSystem, and runs into problems with long command
-- lines on mingw32, so we disallow it now.
-#if defined(mingw32_HOST_OS) && (__GLASGOW_HASKELL__ <= 408)
-#error GHC <= 4.08 is not supported for bootstrapping GHC on i386-unknown-mingw32
+#if __GLASGOW_HASKELL__ < 500
+#error GHC >= 5.00 is required for bootstrapping GHC
#endif
#ifndef mingw32_HOST_OS
#if __GLASGOW_HASKELL__ > 504
import qualified System.Posix.Internals
-import System.Posix.Process ( executeFile, getProcessStatus, forkProcess, ProcessStatus(..))
-import System.Posix.Signals ( installHandler, sigCHLD, sigCONT, Handler(..) )
#else
import qualified Posix
-import Posix ( executeFile, getProcessStatus, forkProcess, ProcessStatus(..), installHandler,
- sigCHLD, sigCONT, Handler(..) )
#endif
#else /* Must be Win32 */
import List ( isPrefixOf )
import CString ( CString, peekCString )
#endif
-#ifdef mingw32_HOST_OS
-#if __GLASGOW_HASKELL__ > 504
-import System.Cmd ( rawSystem )
+#if __GLASGOW_HASKELL__ < 601
+import Foreign ( withMany, withArray0, nullPtr, Ptr )
+import CForeign ( CString, withCString, throwErrnoIfMinus1 )
#else
-import SystemExts ( rawSystem )
-#endif
+import System.Cmd ( rawSystem )
#endif
\end{code}
GLOBAL_VAR(v_Pgm_CP, error "pgm_CP", String) -- cp
GLOBAL_VAR(v_Path_package_config, error "path_package_config", String)
-GLOBAL_VAR(v_Path_usage, error "ghc_usage.txt", String)
+GLOBAL_VAR(v_Path_usages, error "ghc_usage.txt", (String,String))
GLOBAL_VAR(v_TopDir, error "TopDir", String) -- -B<dir>
| am_installed = installed "ghc-usage.txt"
| otherwise = inplace cGHC_DRIVER_DIR_REL "ghc-usage.txt"
+ ghci_usage_msg_path
+ | am_installed = installed "ghci-usage.txt"
+ | otherwise = inplace cGHC_DRIVER_DIR_REL "ghci-usage.txt"
+
-- For all systems, unlit, split, mangle are GHC utilities
-- architecture-specific stuff is done when building Config.hs
unlit_path
-- On Win32, consult GetTempPath() for a temp dir.
-- => it first tries TMP, TEMP, then finally the
-- Windows directory(!). The directory is in short-path
- -- form and *does* have a trailing backslash.
+ -- form.
; IO.try (do
let len = (2048::Int)
buf <- mallocArray len
ret <- getTempPath len buf
tdir <-
if ret == 0 then do
- -- failed, consult TEMP.
+ -- failed, consult TMPDIR.
free buf
- getEnv "TMP"
+ getEnv "TMPDIR"
else do
s <- peekCString buf
free buf
return s
- let
- -- strip the trailing backslash (awful, but
- -- we only do this once).
- tmpdir =
- case last tdir of
- '/' -> init tdir
- '\\' -> init tdir
- _ -> tdir
- setTmpDir tmpdir
- return ())
+ setTmpDir tdir)
#endif
-- Check that the package config exists
-- Initialise the global vars
; writeIORef v_Path_package_config pkgconfig_path
- ; writeIORef v_Path_usage ghc_usage_msg_path
+ ; writeIORef v_Path_usages (ghc_usage_msg_path,
+ ghci_usage_msg_path)
; writeIORef v_Pgm_sysman (top_dir ++ "/ghc/rts/parallel/SysMan")
-- Hans: this isn't right in general, but you can
setPgms = writeIORef v_Pgm_s
setPgma = writeIORef v_Pgm_a
setPgml = writeIORef v_Pgm_l
+setPgmDLL = writeIORef v_Pgm_MkDLL
#ifdef ILX
setPgmI = writeIORef v_Pgm_I
setPgmi = writeIORef v_Pgm_i
getSysMan = readIORef v_Pgm_sysman
\end{code}
-%************************************************************************
-%* *
-\subsection{GHC Usage message}
-%* *
-%************************************************************************
-
-Show the usage message and exit
-
\begin{code}
-showGhcUsage = do { usage_path <- readIORef v_Path_usage
- ; usage <- readFile usage_path
- ; dump usage
- ; exitWith ExitSuccess }
- where
- dump "" = return ()
- dump ('$':'$':s) = hPutStr stderr progName >> dump s
- dump (c:s) = hPutChar stderr c >> dump s
+getUsageMsgPaths :: IO (FilePath,FilePath)
+ -- the filenames of the usage messages (ghc, ghci)
+getUsageMsgPaths = readIORef v_Path_usages
\end{code}
\end{code}
\begin{code}
-setTmpDir dir = writeIORef v_TmpDir dir
+setTmpDir dir = writeIORef v_TmpDir (canonicalise dir)
+ where
+#if !defined(mingw32_HOST_OS)
+ canonicalise p = normalisePath p
+#else
+ -- Canonicalisation of temp path under win32 is a bit more
+ -- involved: (a) strip trailing slash,
+ -- (b) normalise slashes
+ -- (c) just in case, if there is a prefix /cygdrive/x/, change to x:
+ --
+ canonicalise path = normalisePath (xltCygdrive (removeTrailingSlash path))
+
+ -- if we're operating under cygwin, and TMP/TEMP is of
+ -- the form "/cygdrive/drive/path", translate this to
+ -- "drive:/path" (as GHC isn't a cygwin app and doesn't
+ -- understand /cygdrive paths.)
+ xltCygdrive path
+ | "/cygdrive/" `isPrefixOf` path =
+ case drop (length "/cygdrive/") path of
+ drive:xs@('/':_) -> drive:':':xs
+ _ -> path
+ | otherwise = path
+
+ -- strip the trailing backslash (awful, but we only do this once).
+ removeTrailingSlash path =
+ case last path of
+ '/' -> init path
+ '\\' -> init path
+ _ -> path
+#endif
cleanTempFiles :: Int -> IO ()
-cleanTempFiles verb = do fs <- readIORef v_FilesToClean
- removeTmpFiles verb fs
+cleanTempFiles verb
+ = do fs <- readIORef v_FilesToClean
+ removeTmpFiles verb fs
+ writeIORef v_FilesToClean []
cleanTempFilesExcept :: Int -> [FilePath] -> IO ()
cleanTempFilesExcept verb dont_delete
- = do fs <- readIORef v_FilesToClean
- let leftovers = filter (`notElem` dont_delete) fs
- removeTmpFiles verb leftovers
- writeIORef v_FilesToClean dont_delete
+ = do files <- readIORef v_FilesToClean
+ let (to_keep, to_delete) = partition (`elem` dont_delete) files
+ removeTmpFiles verb to_delete
+ writeIORef v_FilesToClean to_keep
-- find a temporary name that doesn't already exist.
removeTmpFiles :: Int -> [FilePath] -> IO ()
removeTmpFiles verb fs
- = traceCmd "Deleting temp files"
- ("Deleting: " ++ unwords fs)
- (mapM_ rm fs)
+ = warnNon $
+ traceCmd "Deleting temp files"
+ ("Deleting: " ++ unwords deletees)
+ (mapM_ rm deletees)
where
+ -- Flat out refuse to delete files that are likely to be source input
+ -- files (is there a worse bug than having a compiler delete your source
+ -- files?)
+ --
+ -- Deleting source files is a sign of a bug elsewhere, so prominently flag
+ -- the condition.
+ warnNon act
+ | null non_deletees = act
+ | otherwise = do
+ hPutStrLn stderr ("WARNING - NOT deleting source files: " ++ unwords non_deletees)
+ act
+
+ (non_deletees, deletees) = partition isHaskellUserSrcFilename fs
+
rm f = removeFile f `IO.catch`
(\_ignored ->
when (verb >= 2) $
-- runSomething will dos-ify them
-> IO ()
-runSomething phase_name pgm args
- = traceCmd phase_name (concat (intersperse " " (pgm:quoteargs))) $
- do
-#ifdef mingw32_HOST_OS
- let showOptions :: [Option] -> String
- showOptions ls = unwords (map (quote . showOpt) ls)
-
- quote :: String -> String
- quote "" = ""
- quote s = "\"" ++ escapeDoubleQuotes s ++ "\""
-
- escapeDoubleQuotes :: String -> String
- escapeDoubleQuotes "" = ""
- escapeDoubleQuotes ('\\':'"':cs) = '\\':'"':escapeDoubleQuotes cs
- escapeDoubleQuotes ( '"':cs) = '\\':'"':escapeDoubleQuotes cs
- escapeDoubleQuotes (c :cs) = c :escapeDoubleQuotes cs
-
- -- The pgm is already in native format (appropriate dir separators)
- exit_code <- rawSystem (pgm ++ ' ':showOptions args)
-#else
- mpid <- forkProcess
- exit_code <- case mpid of
- Nothing -> do -- Child
- executeFile pgm True quoteargs Nothing
- exitWith (ExitFailure 127)
- -- NOT REACHED
- return ExitSuccess
- Just child -> do -- Parent
-#if __GLASGOW_HASKELL__ <= 504
- -- avoid interaction with broken getProcessStatus-FFI:
- oldHandler <- installHandler sigCONT Ignore Nothing
-#endif
- Just (Exited res) <- getProcessStatus True False child
-#if __GLASGOW_HASKELL__ <= 504
- -- restore handler
- installHandler sigCONT oldHandler Nothing
-#endif
-
- return res
-#endif
- when (exit_code /= ExitSuccess) $
- throwDyn (PhaseFailed phase_name exit_code)
- return ()
- where
- quoteargs = filter (not . null) (map showOpt args)
+runSomething phase_name pgm args = do
+ let real_args = filter notNull (map showOpt args)
+ -- Don't assume that 'pgm' contains the program path only,
+ -- but split it up and shift any arguments over to the arg vector.
+ let (real_pgm, argv) =
+ case toArgs pgm of
+ [] -> (pgm, real_args) -- let rawSystem be the bearer of bad news..
+ (x:xs) -> (x, xs ++ real_args)
+ traceCmd phase_name (unwords (pgm:real_args)) $ do
+ exit_code <- rawSystem real_pgm argv
+ if (exit_code /= ExitSuccess)
+ then throwDyn (PhaseFailed phase_name exit_code)
+ else return ()
traceCmd :: String -> String -> IO () -> IO ()
-- a) trace the command (at two levels of verbosity)
handle_exn verb exn = do { when (verb >= 2) (hPutStr stderr "\n")
; when (verb >= 3) (hPutStrLn stderr ("Failed: " ++ cmd_line ++ (show exn)))
; throwDyn (PhaseFailed phase_name (ExitFailure 1)) }
+
+-- -----------------------------------------------------------------------------
+-- rawSystem: run an external command
+
+#if __GLASGOW_HASKELL__ < 601
+
+-- This code is copied from System.Cmd on GHC 6.1.
+
+rawSystem :: FilePath -> [String] -> IO ExitCode
+
+#ifndef mingw32_TARGET_OS
+
+rawSystem cmd args =
+ withCString cmd $ \pcmd ->
+ withMany withCString (cmd:args) $ \cstrs ->
+ withArray0 nullPtr cstrs $ \arr -> do
+ status <- throwErrnoIfMinus1 "rawSystem" (c_rawSystem pcmd arr)
+ case status of
+ 0 -> return ExitSuccess
+ n -> return (ExitFailure n)
+
+foreign import ccall "rawSystem" unsafe
+ c_rawSystem :: CString -> Ptr CString -> IO Int
+
+#else
+
+-- On Windows, the command line is passed to the operating system as
+-- a single string. Command-line parsing is done by the executable
+-- itself.
+rawSystem cmd args = do
+ -- NOTE: 'cmd' is assumed to contain the application to run _only_,
+ -- as it'll be quoted surrounded in quotes here.
+ let cmdline = translate cmd ++ concat (map ((' ':) . translate) args)
+ withCString cmdline $ \pcmdline -> do
+ status <- throwErrnoIfMinus1 "rawSystem" (c_rawSystem pcmdline)
+ case status of
+ 0 -> return ExitSuccess
+ n -> return (ExitFailure n)
+
+translate :: String -> String
+translate str@('"':_) = str -- already escaped.
+translate str = '"' : foldr escape "\"" str
+ where escape '"' str = '\\' : '"' : str
+ escape '\\' str = '\\' : '\\' : str
+ escape c str = c : str
+
+foreign import ccall "rawSystem" unsafe
+ c_rawSystem :: CString -> IO Int
+
+#endif
+#endif
\end{code}
-----------------------------------------------------------------------------
-- Convert filepath into platform / MSDOS form.
--- platformPath does two things
--- a) change '/' to '\'
--- b) remove initial '/cygdrive/'
-
normalisePath :: String -> String
--- Just change '\' to '/'
+-- Just changes '\' to '/'
pgmPath :: String -- Directory string in Unix format
-> String -- Program name with no directory separators
\begin{code}
slash :: String -> String -> String
-absPath, relPath :: [String] -> String
-
-relPath [] = ""
-relPath xs = foldr1 slash xs
-
-absPath xs = "" `slash` relPath xs
-
slash s1 s2 = s1 ++ ('/' : s2)
\end{code}
projects / ghc-hetmet.git / blobdiff