X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fmain%2FSysTools.lhs;h=f9138cdf2e0b126bad36de3771a72f66351ac744;hb=c447b9e272c0b2cfc3a15cc890e40daf7a500b8d;hp=83d833cb272a1d3aca63aee6aa28cf13f51f37c7;hpb=385cda3a02a61a025f70d20a2f5985d5883c5bdd;p=ghc-hetmet.git diff --git a/ghc/compiler/main/SysTools.lhs b/ghc/compiler/main/SysTools.lhs index 83d833c..f9138cd 100644 --- a/ghc/compiler/main/SysTools.lhs +++ b/ghc/compiler/main/SysTools.lhs @@ -11,7 +11,8 @@ module SysTools ( -- Initialisation initSysTools, - setPgmP, -- String -> IO () + setPgmL, -- String -> IO () + setPgmP, setPgmF, setPgmc, setPgmm, @@ -41,7 +42,7 @@ module SysTools ( touch, -- String -> String -> IO () copy, -- String -> String -> String -> IO () - unDosifyPath, -- String -> String + normalisePath, -- FilePath -> FilePath -- Temporary-file management setTmpDir, @@ -61,60 +62,54 @@ module SysTools ( ) where +#include "HsVersions.h" + import DriverUtil import Config import Outputable import Panic ( progName, GhcException(..) ) -import Util ( global, dropList, notNull ) +import Util ( global, notNull ) import CmdLineOpts ( dynFlag, verbosity ) -import Exception ( throwDyn ) -#if __GLASGOW_HASKELL__ > 408 -import qualified Exception ( catch ) -#else -import Exception ( catchAllIO ) -#endif -import IO -import Directory ( doesFileExist, removeFile ) -import IOExts ( IORef, readIORef, writeIORef ) +import EXCEPTION ( throwDyn ) +import DATA_IOREF ( IORef, readIORef, writeIORef ) +import DATA_INT + import Monad ( when, unless ) import System ( ExitCode(..), exitWith, getEnv, system ) -import CString -import Int -import Addr - +import IO ( try, catch, + openFile, hPutChar, hPutStrLn, hPutStr, hClose, hFlush, IOMode(..), + stderr ) +import Directory ( doesFileExist, removeFile ) +import List ( intersperse ) + #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 __GLASGOW_HASKELL__ < 500 +#error GHC >= 5.00 is required for bootstrapping GHC +#endif + #ifndef mingw32_HOST_OS -import qualified Posix +#if __GLASGOW_HASKELL__ > 504 +import qualified System.Posix.Internals #else +import qualified Posix +#endif +#else /* Must be Win32 */ import List ( isPrefixOf ) -import MarshalArray +import Util ( dropList ) import Foreign +import CString ( CString, peekCString ) #endif -#if __GLASGOW_HASKELL__ > 408 -# if __GLASGOW_HASKELL__ >= 503 -import GHC.IOBase -# else -# endif -# ifdef mingw32_HOST_OS -import SystemExts ( rawSystem ) -# endif +#if __GLASGOW_HASKELL__ < 601 +import Foreign ( withMany, withArray0, nullPtr, Ptr ) +import CForeign ( CString, withCString, throwErrnoIfMinus1 ) #else -import System ( system ) +import System.Cmd ( rawSystem ) #endif - - -#include "HsVersions.h" - --- Make catch work on older GHCs -#if __GLASGOW_HASKELL__ > 408 -myCatch = Exception.catch -#else -myCatch = catchAllIO -#endif - \end{code} @@ -191,7 +186,7 @@ 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 @@ -375,7 +370,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 @@ -431,7 +428,10 @@ like is used to override a particular program with a new one \begin{code} -setPgmP = writeIORef v_Pgm_P +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 @@ -478,11 +478,11 @@ findTopDir minusbs ; return (am_installed, top_dir) } where - -- get_proto returns a Unix-format path (relying on getExecDir to do so too) + -- get_proto returns a Unix-format path (relying on getBaseDir to do so too) get_proto | notNull minusbs - = return (unDosifyPath (drop 2 (last minusbs))) -- 2 for "-B" + = 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") @@ -511,11 +511,9 @@ data Option String -- the filepath/filename portion | Option String -showOptions :: [Option] -> String -showOptions ls = unwords (map (quote.showOpt) ls) - where - showOpt (FileOption pre f) = pre ++ dosifyPath f - showOpt (Option s) = s +showOpt (FileOption pre f) = pre ++ platformPath f +showOpt (Option "") = "" +showOpt (Option s) = s \end{code} @@ -533,8 +531,8 @@ runUnlit args = do p <- readIORef v_Pgm_L runSomething "Literate pre-processor" p args runCpp :: [Option] -> IO () -runCpp args = do p <- readIORef v_Pgm_P - runSomething "C pre-processor" p args +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 @@ -667,7 +665,7 @@ removeTmpFiles verb fs ("Deleting: " ++ unwords fs) (mapM_ rm fs) where - rm f = removeFile f `myCatch` + rm f = removeFile f `IO.catch` (\_ignored -> when (verb >= 2) $ hPutStrLn stderr ("Warning: deleting non-existent " ++ f) @@ -698,22 +696,13 @@ runSomething :: String -- For -v message -- runSomething will dos-ify them -> IO () -runSomething phase_name pgm args - = traceCmd phase_name cmd_line $ - do { -#ifndef mingw32_HOST_OS - exit_code <- system cmd_line -#else - exit_code <- rawSystem cmd_line -#endif - ; if exit_code /= ExitSuccess - then throwDyn (PhaseFailed phase_name exit_code) - else return () - } - where - -- The pgm is already in native format (appropriate dir separators) - cmd_line = pgm ++ ' ':showOptions args - -- unwords (pgm : dosifyPaths (map quote args)) +runSomething phase_name pgm args = do + let real_args = filter notNull (map showOpt args) + traceCmd phase_name (concat (intersperse " " (pgm:real_args))) $ do + exit_code <- rawSystem pgm real_args + 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) @@ -729,12 +718,63 @@ traceCmd phase_name cmd_line action ; unless n $ do { -- And run it! - ; action `myCatch` 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 unsafe "rawSystem" + 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 + let cmdline = {-translate-} cmd ++ concat (map ((' ':) . translate) args) + -- Urk, don't quote/escape the command name on Windows, because the + -- compiler is exceedingly naughty and sometimes uses 'perl "..."' + -- as the command name. + 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 = '"' : foldr escape "\"" str + where escape '"' str = '\\' : '"' : str + escape '\\' str = '\\' : '\\' : str + escape c str = c : str + +foreign import ccall unsafe "rawSystem" + c_rawSystem :: CString -> IO Int + +#endif +#endif \end{code} @@ -749,20 +789,19 @@ 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 +-- platformPath does two things -- a) change '/' to '\' -- b) remove initial '/cygdrive/' -unDosifyPath :: String -> String +normalisePath :: String -> String -- Just change '\' to '/' pgmPath :: String -- Directory string in Unix format @@ -773,36 +812,20 @@ pgmPath :: String -- Directory string in Unix format #if defined(mingw32_HOST_OS) - --------------------- Windows version ------------------ -dosifyPaths xs = map dosifyPath xs - -unDosifyPath xs = subst '\\' '/' xs - -pgmPath dir pgm = dosifyPath dir ++ '\\' : pgm +normalisePath xs = subst '\\' '/' xs +platformPath p = subst '/' '\\' p +pgmPath dir pgm = platformPath 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 = dropList 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 -dosifyPath stuff = stuff +--------------------- 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} @@ -830,47 +853,36 @@ slash s1 s2 = s1 ++ ('/' : s2) \begin{code} ----------------------------------------------------------------------------- --- Define getExecDir :: IO (Maybe String) +-- Define getBaseDir :: IO (Maybe String) #if defined(mingw32_HOST_OS) -getExecDir :: IO (Maybe String) -getExecDir = do let len = (2048::Int) -- plenty, PATH_MAX is 512 under Win32. +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 nullAddr buf len + ret <- getModuleFileName nullPtr buf len if ret == 0 then free buf >> return Nothing else do s <- peekCString buf free buf - return (Just (reverse (dropList "/bin/ghc.exe" (reverse (unDosifyPath s))))) - + return (Just (rootDir s)) + where + rootDir s = reverse (dropList "/bin/ghc.exe" (reverse (normalisePath s))) -foreign import stdcall "GetModuleFileNameA" unsafe getModuleFileName :: Addr -> CString -> Int -> IO Int32 +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_HOST_OS -foreign import "_getpid" unsafe getProcessID :: IO Int -- relies on Int == Int32 on Windows +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 -#if defined(mingw32_HOST_OS) && (__GLASGOW_HASKELL__ <= 408) -rawSystem :: String -> IO ExitCode -rawSystem cmd = system cmd - -- mingw only: if you try to build a stage2 compiler with a stage1 - -- that has been bootstrapped with 4.08 (or earlier), this will run - -- into problems with limits on command-line lengths with the std. - -- Win32 command interpreters. So don't this - use 5.00 or later - -- to compile up the GHC sources. -#endif - -quote :: String -> String -#if defined(mingw32_HOST_OS) -quote "" = "" -quote s = "\"" ++ s ++ "\"" -#else -quote s = s -#endif - \end{code}