X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fmain%2FSysTools.lhs;h=0320cffa93f4c78c97ab603bdf58690d77c35443;hb=b2a9c48ee5593cda05748c2cd261897392c7152d;hp=4276874999cfe396d1e61d543fce5272ea7b5247;hpb=96517afb751c676dc658921650b1d78fb15c75e4;p=ghc-hetmet.git diff --git a/ghc/compiler/main/SysTools.lhs b/ghc/compiler/main/SysTools.lhs index 4276874..0320cff 100644 --- a/ghc/compiler/main/SysTools.lhs +++ b/ghc/compiler/main/SysTools.lhs @@ -1,7 +1,8 @@ ----------------------------------------------------------------------------- --- Access to system tools: gcc, cp, rm etc -- --- (c) The University of Glasgow 2000 +-- (c) The University of Glasgow 2001-2003 +-- +-- Access to system tools: gcc, cp, rm etc -- ----------------------------------------------------------------------------- @@ -9,65 +10,107 @@ module SysTools ( -- Initialisation initSysTools, - setPgm, -- String -> IO () + + setPgmL, -- String -> IO () + setPgmP, + setPgmF, + setPgmc, + setPgmm, + setPgms, + setPgma, + setPgml, + setPgmDLL, +#ifdef ILX + setPgmI, + setPgmi, +#endif -- Command-line override setDryRun, - packageConfigPath, -- IO String - -- Where package.conf is + 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, -- [String] -> IO () - runMangle, runSplit, -- [String] -> IO () - runAs, runLink, -- [String] -> IO () + runUnlit, runCpp, runCc, -- [Option] -> IO () + runPp, -- [Option] -> IO () + runMangle, runSplit, -- [Option] -> IO () + runAs, runLink, -- [Option] -> IO () runMkDLL, +#ifdef ILX + runIlx2il, runIlasm, -- [String] -> IO () +#endif + touch, -- String -> String -> IO () copy, -- String -> String -> String -> IO () + normalisePath, -- FilePath -> FilePath -- Temporary-file management setTmpDir, newTempName, - cleanTempFiles, cleanTempFilesExcept, removeTmpFiles, + cleanTempFiles, cleanTempFilesExcept, addFilesToClean, -- System interface - getProcessID, -- IO Int - system, -- String -> IO Int + system, -- String -> IO ExitCode -- Misc - showGhcUsage, -- IO () Shows usage message and exits - getSysMan -- IO String Parallel system only + getSysMan, -- IO String Parallel system only + + Option(..) ) where +#include "HsVersions.h" + import DriverUtil +import DriverPhases ( isHaskellUserSrcFilename ) import Config import Outputable -import Panic ( progName, GhcException(..) ) -import Util ( global ) +import Panic ( GhcException(..) ) +import Util ( global, notNull, toArgs ) import CmdLineOpts ( dynFlag, verbosity ) -import Exception ( throwDyn, catchAllIO ) -import IO -import Directory ( doesFileExist, removeFile ) -import IOExts ( IORef, readIORef, writeIORef ) -import Monad ( when, unless ) -import System ( system, ExitCode(..), exitWith, getEnv ) +import EXCEPTION ( throwDyn ) +import DATA_IOREF ( IORef, readIORef, writeIORef ) +import DATA_INT +import Monad ( when, unless ) +import System ( ExitCode(..), getEnv, system ) +import IO ( try, catch, + openFile, hPutStrLn, hPutStr, hClose, hFlush, IOMode(..), + stderr ) +import Directory ( doesFileExist, removeFile ) +import List ( partition ) + #include "../includes/config.h" -#if !defined(mingw32_TARGET_OS) -import qualified Posix +-- GHC <= 4.08 didn't have rawSystem, and runs into problems with long command +-- lines on mingw32, so we disallow it now. +#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 #else -import Win32DLL +import qualified Posix +#endif +#else /* Must be Win32 */ import List ( isPrefixOf ) +import Util ( dropList ) +import Foreign +import CString ( CString, peekCString ) #endif -import List ( isSuffixOf ) - -#include "HsVersions.h" - +#if __GLASGOW_HASKELL__ < 601 +import Foreign ( withMany, withArray0, nullPtr, Ptr ) +import CForeign ( CString, withCString, throwErrnoIfMinus1 ) +#else +import System.Cmd ( rawSystem ) +#endif \end{code} @@ -103,9 +146,9 @@ Config.hs contains two sorts of things etc They do *not* include paths - cUNLIT_DIR The *path* to the directory containing unlit, split etc - cSPLIT_DIR *relative* to the root of the build tree, - for use when running *in-place* in a build tree (only) + cUNLIT_DIR_REL The *path* to the directory containing unlit, split etc + cSPLIT_DIR_REL *relative* to the root of the build tree, + for use when running *in-place* in a build tree (only) @@ -144,11 +187,16 @@ All these pathnames are maintained IN THE NATIVE FORMAT OF THE HOST MACHINE. \begin{code} GLOBAL_VAR(v_Pgm_L, error "pgm_L", String) -- unlit -GLOBAL_VAR(v_Pgm_P, error "pgm_P", String) -- cpp +GLOBAL_VAR(v_Pgm_P, error "pgm_P", (String,[Option])) -- cpp +GLOBAL_VAR(v_Pgm_F, error "pgm_F", String) -- pp GLOBAL_VAR(v_Pgm_c, error "pgm_c", String) -- gcc GLOBAL_VAR(v_Pgm_m, error "pgm_m", String) -- asm code mangler GLOBAL_VAR(v_Pgm_s, error "pgm_s", String) -- asm code splitter GLOBAL_VAR(v_Pgm_a, error "pgm_a", String) -- as +#ifdef ILX +GLOBAL_VAR(v_Pgm_I, error "pgm_I", String) -- ilx2il +GLOBAL_VAR(v_Pgm_i, error "pgm_i", String) -- ilasm +#endif GLOBAL_VAR(v_Pgm_l, error "pgm_l", String) -- ld GLOBAL_VAR(v_Pgm_MkDLL, error "pgm_dll", String) -- mkdll @@ -156,10 +204,16 @@ GLOBAL_VAR(v_Pgm_T, error "pgm_T", String) -- touch 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 -- Parallel system only GLOBAL_VAR(v_Pgm_sysman, error "pgm_sysman", String) -- system manager + +-- ways to get at some of these variables from outside this module +getPackageConfigPath = readIORef v_Path_package_config +getTopDir = readIORef v_TopDir \end{code} @@ -172,58 +226,78 @@ GLOBAL_VAR(v_Pgm_sysman, error "pgm_sysman", String) -- system manager \begin{code} initSysTools :: [String] -- Command-line arguments starting "-B" - -> IO String -- Set all the mutable variables above, holding + -> IO () -- Set all the mutable variables above, holding -- (a) the system programs -- (b) the package-config file -- (c) the GHC usage message - -- Return TopDir initSysTools minusB_args - = do { (am_installed, top_dir) <- getTopDir minusB_args + = do { (am_installed, top_dir) <- findTopDir minusB_args + ; writeIORef v_TopDir top_dir -- top_dir -- for "installed" this is the root of GHC's support files -- for "in-place" it is the root of the build tree -- NB: top_dir is assumed to be in standard Unix format '/' separated ; let installed, installed_bin :: FilePath -> FilePath -#ifndef mingw32_TARGET_OS - installed_bin pgm = pgmPath (top_dir `slash` "extra-bin") pgm -#else - installed_bin pgm = pgmPath (top_dir `slash` "bin") pgm -#endif + installed_bin pgm = pgmPath top_dir pgm installed file = pgmPath top_dir file - inplace dir pgm = pgmPath (top_dir `slash` dir) pgm + inplace dir pgm = pgmPath (top_dir `slash` + cPROJECT_DIR `slash` dir) pgm ; let pkgconfig_path | am_installed = installed "package.conf" - | otherwise = inplace cGHC_DRIVER_DIR "package.conf.inplace" + | otherwise = inplace cGHC_DRIVER_DIR_REL "package.conf.inplace" ghc_usage_msg_path | am_installed = installed "ghc-usage.txt" - | otherwise = inplace cGHC_DRIVER_DIR "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 - | am_installed = installed_bin cGHC_UNLIT - | otherwise = inplace cGHC_UNLIT_DIR cGHC_UNLIT + | am_installed = installed_bin cGHC_UNLIT_PGM + | otherwise = inplace cGHC_UNLIT_DIR_REL cGHC_UNLIT_PGM -- split and mangle are Perl scripts split_script - | am_installed = installed_bin cGHC_SPLIT - | otherwise = inplace cGHC_SPLIT_DIR cGHC_SPLIT + | am_installed = installed_bin cGHC_SPLIT_PGM + | otherwise = inplace cGHC_SPLIT_DIR_REL cGHC_SPLIT_PGM mangle_script - | am_installed = installed_bin cGHC_MANGLER - | otherwise = inplace cGHC_MANGLER_DIR cGHC_MANGLER + | am_installed = installed_bin cGHC_MANGLER_PGM + | otherwise = inplace cGHC_MANGLER_DIR_REL cGHC_MANGLER_PGM -#ifndef mingw32_TARGET_OS +#ifndef mingw32_HOST_OS -- check whether TMPDIR is set in the environment ; IO.try (do dir <- getEnv "TMPDIR" -- fails if not set setTmpDir dir return () ) +#else + -- 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. + ; IO.try (do + let len = (2048::Int) + buf <- mallocArray len + ret <- getTempPath len buf + tdir <- + if ret == 0 then do + -- failed, consult TMPDIR. + free buf + getEnv "TMPDIR" + else do + s <- peekCString buf + free buf + return s + setTmpDir tdir) #endif -- Check that the package config exists @@ -232,7 +306,7 @@ initSysTools minusB_args throwDyn (InstallationError ("Can't find package.conf as " ++ pkgconfig_path)) -#if defined(mingw32_TARGET_OS) +#if defined(mingw32_HOST_OS) -- WINDOWS-SPECIFIC STUFF -- On Windows, gcc and friends are distributed with GHC, -- so when "installed" we look in TopDir/bin @@ -246,29 +320,41 @@ initSysTools minusB_args -- pick up whatever happens to be lying around in the path, -- possibly including those from a cygwin install on the target, -- which is exactly what we're trying to avoid. - ; let gcc_path | am_installed = installed_bin ("gcc -B" ++ installed "gcc-lib/" - ++ " -I" ++ installed "include/mingw") + ; let gcc_path | am_installed = installed_bin ("gcc -B\"" ++ installed "gcc-lib/\"") | otherwise = cGCC + -- The trailing "/" is absolutely essential; gcc seems + -- to construct file names simply by concatenating to this + -- -B path with no extra slash + -- We use "/" rather than "\\" because otherwise "\\\" is mangled + -- later on; although gcc_path is in NATIVE format, gcc can cope + -- (see comments with declarations of global variables) + -- + -- The quotes round the -B argument are in case TopDir has spaces in it + perl_path | am_installed = installed_bin cGHC_PERL | otherwise = cGHC_PERL -- 'touch' is a GHC util for Windows, and similarly unlit, mangle - ; let touch_path | am_installed = installed_bin cGHC_TOUCHY - | otherwise = inplace cGHC_TOUCHY_DIR cGHC_TOUCHY + ; let touch_path | am_installed = installed_bin cGHC_TOUCHY_PGM + | otherwise = inplace cGHC_TOUCHY_DIR_REL cGHC_TOUCHY_PGM -- On Win32 we don't want to rely on #!/bin/perl, so we prepend -- a call to Perl to get the invocation of split and mangle - ; let split_path = perl_path ++ " " ++ split_script - mangle_path = perl_path ++ " " ++ mangle_script - - ; let mkdll_path = cMKDLL + ; let split_path = perl_path ++ " \"" ++ split_script ++ "\"" + mangle_path = perl_path ++ " \"" ++ mangle_script ++ "\"" + + ; let mkdll_path + | am_installed = pgmPath (installed "gcc-lib/") cMKDLL ++ + " --dlltool-name " ++ pgmPath (installed "gcc-lib/") "dlltool" ++ + " --driver-name " ++ gcc_path + | otherwise = cMKDLL #else -- UNIX-SPECIFIC STUFF -- On Unix, the "standard" tools are assumed to be -- in the same place whether we are running "in-place" or "installed" -- That place is wherever the build-time configure script found them. ; let gcc_path = cGCC - touch_path = cGHC_TOUCHY + touch_path = "touch" mkdll_path = panic "Can't build DLLs on a non-Win32 system" -- On Unix, scripts are invoked using the '#!' method. Binary @@ -280,7 +366,9 @@ initSysTools minusB_args #endif -- cpp is derived from gcc on all platforms - ; let cpp_path = gcc_path ++ " -E " ++ cRAWCPP_FLAGS + -- HACK, see setPgmP below. We keep 'words' here to remember to fix + -- Config.hs one day. + ; let cpp_path = (gcc_path, (Option "-E"):(map Option (words cRAWCPP_FLAGS))) -- For all systems, copy and remove are provided by the host -- system; architecture-specific stuff is done when building Config.hs @@ -290,10 +378,16 @@ initSysTools minusB_args ; let as_path = gcc_path ld_path = gcc_path +#ifdef ILX + -- ilx2il and ilasm are specified in Config.hs + ; let ilx2il_path = cILX2IL + ilasm_path = cILASM +#endif -- 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 @@ -301,35 +395,51 @@ initSysTools minusB_args ; writeIORef v_Pgm_L unlit_path ; writeIORef v_Pgm_P cpp_path + ; writeIORef v_Pgm_F "" ; writeIORef v_Pgm_c gcc_path ; writeIORef v_Pgm_m mangle_path ; writeIORef v_Pgm_s split_path ; writeIORef v_Pgm_a as_path +#ifdef ILX + ; writeIORef v_Pgm_I ilx2il_path + ; writeIORef v_Pgm_i ilasm_path +#endif ; writeIORef v_Pgm_l ld_path ; writeIORef v_Pgm_MkDLL mkdll_path ; writeIORef v_Pgm_T touch_path ; writeIORef v_Pgm_CP cp_path - ; return top_dir + ; return () } + +#if defined(mingw32_HOST_OS) +foreign import stdcall "GetTempPathA" unsafe getTempPath :: Int -> CString -> IO Int32 +#endif \end{code} -setPgm is called when a command-line option like +The various setPgm functions are called when a command-line option +like + -pgmLld -is used to override a particular program with a new onw + +is used to override a particular program with a new one \begin{code} -setPgm :: String -> IO () --- The string is the flag, minus the '-pgm' prefix --- So the first character says which program to override - -setPgm ('P' : pgm) = writeIORef v_Pgm_P pgm -setPgm ('c' : pgm) = writeIORef v_Pgm_c pgm -setPgm ('m' : pgm) = writeIORef v_Pgm_m pgm -setPgm ('s' : pgm) = writeIORef v_Pgm_s pgm -setPgm ('a' : pgm) = writeIORef v_Pgm_a pgm -setPgm ('l' : pgm) = writeIORef v_Pgm_l pgm -setPgm pgm = unknownFlagErr ("-pgm" ++ pgm) +setPgmL = writeIORef v_Pgm_L +-- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"] +-- Config.hs should really use Option. +setPgmP arg = let (pgm:args) = words arg in writeIORef v_Pgm_P (pgm,map Option args) +setPgmF = writeIORef v_Pgm_F +setPgmc = writeIORef v_Pgm_c +setPgmm = writeIORef v_Pgm_m +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 +#endif \end{code} @@ -353,11 +463,11 @@ setPgm pgm = unknownFlagErr ("-pgm" ++ pgm) -- -- This is very gruesome indeed -getTopDir :: [String] +findTopDir :: [String] -> IO (Bool, -- True <=> am installed, False <=> in-place String) -- TopDir (in Unix format '/' separated) -getTopDir minusbs +findTopDir minusbs = do { top_dir <- get_proto -- Discover whether we're running in a build tree or in an installation, -- by looking for the package configuration file. @@ -366,80 +476,103 @@ getTopDir minusbs ; return (am_installed, top_dir) } where - -- get_proto returns a Unix-format path - get_proto | not (null minusbs) - = return (unDosifyPath (drop 2 (last minusbs))) -- 2 for "-B" + -- get_proto returns a Unix-format path (relying on getBaseDir to do so too) + get_proto | notNull minusbs + = return (normalisePath (drop 2 (last minusbs))) -- 2 for "-B" | otherwise - = do { maybe_exec_dir <- getExecDir -- Get directory of executable + = do { maybe_exec_dir <- getBaseDir -- Get directory of executable ; case maybe_exec_dir of -- (only works on Windows; -- returns Nothing on Unix) Nothing -> throwDyn (InstallationError "missing -B option") - Just dir -> return (remove_suffix (unDosifyPath dir)) + Just dir -> return dir } +\end{code} + + +%************************************************************************ +%* * +\subsection{Command-line options} +n%* * +%************************************************************************ + +When invoking external tools as part of the compilation pipeline, we +pass these a sequence of options on the command-line. Rather than +just using a list of Strings, we use a type that allows us to distinguish +between filepaths and 'other stuff'. [The reason being, of course, that +this type gives us a handle on transforming filenames, and filenames only, +to whatever format they're expected to be on a particular platform.] + +\begin{code} +data Option + = FileOption -- an entry that _contains_ filename(s) / filepaths. + String -- a non-filepath prefix that shouldn't be transformed (e.g., "/out=" + String -- the filepath/filename portion + | Option String + +showOpt (FileOption pre f) = pre ++ platformPath f +showOpt (Option "") = "" +showOpt (Option s) = s - -- In an installed tree, the ghc binary lives in $libexecdir, which - -- is normally $libdir/bin. So we strip off a /bin suffix here. - -- In a build tree, the ghc binary lives in $fptools/ghc/compiler, - -- so we strip off the /ghc/compiler suffix here too, leaving a - -- standard TOPDIR. - -- Unfortunately, getting top_dir like this and then using it to generate - -- the path on which to find binaries means that we're ignoring - -- $libexecdir anyway. - remove_suffix ghc_bin_dir -- ghc_bin_dir is in standard Unix format - | "/ghc/compiler" `isSuffixOf` ghc_bin_dir = back_two - | "/bin" `isSuffixOf` ghc_bin_dir = back_one - | otherwise = ghc_bin_dir - where - p1 = dropWhile (not . isSlash) (reverse ghc_bin_dir) - p2 = dropWhile (not . isSlash) (tail p1) -- head is '/' - back_two = reverse (tail p2) -- head is '/' - back_one = reverse (tail p1) \end{code} %************************************************************************ %* * \subsection{Running an external program} -n%* * +%* * %************************************************************************ \begin{code} -runUnlit :: [String] -> IO () +runUnlit :: [Option] -> IO () runUnlit args = do p <- readIORef v_Pgm_L runSomething "Literate pre-processor" p args -runCpp :: [String] -> IO () -runCpp args = do p <- readIORef v_Pgm_P - runSomething "C pre-processor" p args +runCpp :: [Option] -> IO () +runCpp args = do (p,baseArgs) <- readIORef v_Pgm_P + runSomething "C pre-processor" p (baseArgs ++ args) + +runPp :: [Option] -> IO () +runPp args = do p <- readIORef v_Pgm_F + runSomething "Haskell pre-processor" p args -runCc :: [String] -> IO () +runCc :: [Option] -> IO () runCc args = do p <- readIORef v_Pgm_c runSomething "C Compiler" p args -runMangle :: [String] -> IO () +runMangle :: [Option] -> IO () runMangle args = do p <- readIORef v_Pgm_m runSomething "Mangler" p args -runSplit :: [String] -> IO () +runSplit :: [Option] -> IO () runSplit args = do p <- readIORef v_Pgm_s runSomething "Splitter" p args -runAs :: [String] -> IO () +runAs :: [Option] -> IO () runAs args = do p <- readIORef v_Pgm_a runSomething "Assembler" p args -runLink :: [String] -> IO () +runLink :: [Option] -> IO () runLink args = do p <- readIORef v_Pgm_l runSomething "Linker" p args -runMkDLL :: [String] -> IO () +#ifdef ILX +runIlx2il :: [Option] -> IO () +runIlx2il args = do p <- readIORef v_Pgm_I + runSomething "Ilx2Il" p args + +runIlasm :: [Option] -> IO () +runIlasm args = do p <- readIORef v_Pgm_i + runSomething "Ilasm" p args +#endif + +runMkDLL :: [Option] -> IO () runMkDLL args = do p <- readIORef v_Pgm_MkDLL runSomething "Make DLL" p args touch :: String -> String -> IO () touch purpose arg = do p <- readIORef v_Pgm_T - runSomething purpose p [arg] + runSomething purpose p [FileOption "" arg] copy :: String -> String -> String -> IO () copy purpose from to = do @@ -459,25 +592,10 @@ getSysMan :: IO String -- How to invoke the system manager 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 - -packageConfigPath = readIORef v_Path_package_config +getUsageMsgPaths :: IO (FilePath,FilePath) + -- the filenames of the usage messages (ghc, ghci) +getUsageMsgPaths = readIORef v_Path_usages \end{code} @@ -494,18 +612,49 @@ GLOBAL_VAR(v_TmpDir, cDEFAULT_TMPDIR, String ) \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. @@ -528,11 +677,26 @@ addFilesToClean files = mapM_ (add v_FilesToClean) files 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 - rm f = removeFile f `catchAllIO` + -- 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) $ hPutStrLn stderr ("Warning: deleting non-existent " ++ f) @@ -559,20 +723,23 @@ setDryRun = writeIORef v_Dry_run True runSomething :: String -- For -v message -> String -- Command name (possibly a full path) -- assumed already dos-ified - -> [String] -- Arguments + -> [Option] -- Arguments -- runSomething will dos-ify them -> IO () -runSomething phase_name pgm args - = traceCmd phase_name cmd_line $ - do { exit_code <- system cmd_line - ; if exit_code /= ExitSuccess - then throwDyn (PhaseFailed phase_name exit_code) - else return () - } - where - cmd_line = unwords (pgm : dosifyPaths args) - -- The pgm is already in native format (appropriate dir separators) +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) @@ -588,12 +755,69 @@ traceCmd phase_name cmd_line action ; unless n $ do { -- And run it! - ; action `catchAllIO` handle_exn verb + ; action `IO.catch` handle_exn verb }} where handle_exn verb exn = do { when (verb >= 2) (hPutStr stderr "\n") - ; when (verb >= 3) (hPutStrLn stderr ("Failed: " ++ cmd_line)) + ; 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 +-- Returns a string wrapped in double-quotes +-- If the input string starts with double-quote, don't touch it +-- If not, wrap it in double-quotes and double any backslashes +-- foo\baz --> "foo\\baz" +-- "foo\baz" --> "foo\baz" + +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} @@ -608,21 +832,16 @@ the last moment. On Windows we dos-ify them just before passing them to the Windows command. The alternative, of using '/' consistently on Unix and '\' on Windows, -proved quite awkward. There were a lot more calls to dosifyPath, +proved quite awkward. There were a lot more calls to platformPath, and even on Windows we might invoke a unix-like utility (eg 'sh'), which interpreted a command line 'foo\baz' as 'foobaz'. \begin{code} ----------------------------------------------------------------------------- --- Convert filepath into MSDOS form. +-- Convert filepath into platform / MSDOS form. -dosifyPaths :: [String] -> [String] --- dosifyPaths does two things --- a) change '/' to '\' --- b) remove initial '/cygdrive/' - -unDosifyPath :: String -> String --- Just change '\' to '/' +normalisePath :: String -> String +-- Just changes '\' to '/' pgmPath :: String -- Directory string in Unix format -> String -- Program name with no directory separators @@ -631,36 +850,21 @@ pgmPath :: String -- Directory string in Unix format -#if defined(mingw32_TARGET_OS) - +#if defined(mingw32_HOST_OS) --------------------- Windows version ------------------ -dosifyPaths xs = map dosifyPath xs - -unDosifyPath xs = subst '\\' '/' xs +normalisePath xs = subst '\\' '/' xs +platformPath p = subst '/' '\\' p +pgmPath dir pgm = platformPath dir ++ '\\' : pgm -pgmPath dir pgm = dosifyPath dir ++ '\\' : pgm - -dosifyPath stuff - = subst '/' '\\' real_stuff - where - -- fully convince myself that /cygdrive/ prefixes cannot - -- really appear here. - cygdrive_prefix = "/cygdrive/" - - real_stuff - | cygdrive_prefix `isPrefixOf` stuff = drop (length cygdrive_prefix) stuff - | otherwise = stuff - +subst a b ls = map (\ x -> if x == a then b else x) ls #else - ---------------------- Unix version --------------------- -dosifyPaths ps = ps -unDosifyPath xs = xs -pgmPath dir pgm = dir ++ '/' : pgm +--------------------- Non-Windows version -------------- +normalisePath xs = xs +pgmPath dir pgm = dir ++ '/' : pgm +platformPath stuff = stuff -------------------------------------------------------- #endif -subst a b ls = map (\ x -> if x == a then b else x) ls \end{code} @@ -669,16 +873,6 @@ subst a b ls = map (\ x -> if x == a then b else x) ls \begin{code} slash :: String -> String -> String -absPath, relPath :: [String] -> String - -isSlash '/' = True -isSlash other = False - -relPath [] = "" -relPath xs = foldr1 slash xs - -absPath xs = "" `slash` relPath xs - slash s1 s2 = s1 ++ ('/' : s2) \end{code} @@ -691,21 +885,36 @@ slash s1 s2 = s1 ++ ('/' : s2) \begin{code} ----------------------------------------------------------------------------- --- Define getExecDir :: IO (Maybe String) +-- Define getBaseDir :: IO (Maybe String) + +#if defined(mingw32_HOST_OS) +getBaseDir :: IO (Maybe String) +-- Assuming we are running ghc, accessed by path $()/bin/ghc.exe, +-- return the path $(stuff). Note that we drop the "bin/" directory too. +getBaseDir = do let len = (2048::Int) -- plenty, PATH_MAX is 512 under Win32. + buf <- mallocArray len + ret <- getModuleFileName nullPtr buf len + if ret == 0 then free buf >> return Nothing + else do s <- peekCString buf + free buf + return (Just (rootDir s)) + where + rootDir s = reverse (dropList "/bin/ghc.exe" (reverse (normalisePath s))) -#if defined(mingw32_TARGET_OS) -getExecDir :: IO (Maybe String) -getExecDir = do h <- getModuleHandle Nothing - n <- getModuleFileName h - return (Just (reverse (tail (dropWhile (not . isSlash) (reverse (unDosifyPath n)))))) +foreign import stdcall "GetModuleFileNameA" unsafe + getModuleFileName :: Ptr () -> CString -> Int -> IO Int32 #else -getExecDir :: IO (Maybe String) = do return Nothing +getBaseDir :: IO (Maybe String) = do return Nothing #endif -#ifdef mingw32_TARGET_OS -foreign import "_getpid" getProcessID :: IO Int -- relies on Int == Int32 on Windows +#ifdef mingw32_HOST_OS +foreign import ccall "_getpid" unsafe getProcessID :: IO Int -- relies on Int == Int32 on Windows +#elif __GLASGOW_HASKELL__ > 504 +getProcessID :: IO Int +getProcessID = System.Posix.Internals.c_getpid >>= return . fromIntegral #else getProcessID :: IO Int getProcessID = Posix.getProcessID #endif + \end{code}