X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fmain%2FSysTools.lhs;h=56dd3fca2bc934ab2c7e50e42db17eac63b0cdfc;hb=fd9b0b3e33bee9bc7565aaacdf91710216a53f88;hp=271d947dd7cca7e1ab64d89bb595c5f2f2a684b9;hpb=f8d8ea662828a295e27a2f5f52ce38d68fd3dee2;p=ghc-hetmet.git diff --git a/ghc/compiler/main/SysTools.lhs b/ghc/compiler/main/SysTools.lhs index 271d947..56dd3fc 100644 --- a/ghc/compiler/main/SysTools.lhs +++ b/ghc/compiler/main/SysTools.lhs @@ -1,7 +1,9 @@ ----------------------------------------------------------------------------- --- Access to system tools: gcc, cp, rm etc +-- $Id: SysTools.lhs,v 1.52 2001/08/15 15:02:04 rrt Exp $ +-- +-- (c) The University of Glasgow 2001 -- --- (c) The University of Glasgow 2000 +-- Access to system tools: gcc, cp, rm etc -- ----------------------------------------------------------------------------- @@ -13,17 +15,22 @@ module SysTools ( -- 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 -- Interface to system tools - runUnlit, runCpp, runCc, -- [String] -> IO () - runMangle, runSplit, -- [String] -> IO () - runAs, runLink, -- [String] -> IO () + runUnlit, runCpp, runCc, -- [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 () + unDosifyPath, -- String -> String -- Temporary-file management setTmpDir, @@ -33,14 +40,14 @@ module SysTools ( -- 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 - dosifyPath, -- String -> String + + Option(..) - runSomething -- ToDo: make private ) where import DriverUtil @@ -50,27 +57,33 @@ import Panic ( progName, GhcException(..) ) import Util ( global ) import CmdLineOpts ( dynFlag, verbosity ) -import List ( intersperse, isPrefixOf ) -import Exception ( throw, throwDyn, catchAllIO ) -import IO ( hPutStr, hPutChar, hPutStrLn, hFlush, stderr ) -import IO ( openFile, IOMode(..), hClose ) -- For temp "system" +import Exception ( throwDyn, catchAllIO ) +import IO import Directory ( doesFileExist, removeFile ) import IOExts ( IORef, readIORef, writeIORef ) import Monad ( when, unless ) -import qualified System -import System ( ExitCode(..) ) - +import System ( ExitCode(..), exitWith, getEnv, system ) +import CString +import Int +import Addr + #include "../includes/config.h" -#if !defined(mingw32_TARGET_OS) +#ifndef mingw32_TARGET_OS import qualified Posix #else -import Addr ( nullAddr ) +import List ( isPrefixOf ) +import MarshalArray #endif -#include "HsVersions.h" +-- use the line below when we can be sure of compiling with GHC >= +-- 5.02, and remove the implementation of rawSystem at the end of this +-- file +import PrelIOBase -- this can be removed when SystemExts is used +import CError ( throwErrnoIfMinus1 ) -- as can this +-- import SystemExts ( rawSystem ) -{-# DEPRECATED runSomething "runSomething should be private to SysTools" #-} +#include "HsVersions.h" \end{code} @@ -113,12 +126,39 @@ Config.hs contains two sorts of things +--------------------------------------------- +NOTES for an ALTERNATIVE scheme (i.e *not* what is currently implemented): + +Another hair-brained scheme for simplifying the current tool location +nightmare in GHC: Simon originally suggested using another +configuration file along the lines of GCC's specs file - which is fine +except that it means adding code to read yet another configuration +file. What I didn't notice is that the current package.conf is +general enough to do this: + +Package + {name = "tools", import_dirs = [], source_dirs = [], + library_dirs = [], hs_libraries = [], extra_libraries = [], + include_dirs = [], c_includes = [], package_deps = [], + extra_ghc_opts = ["-pgmc/usr/bin/gcc","-pgml${libdir}/bin/unlit", ... etc.], + extra_cc_opts = [], extra_ld_opts = []} + +Which would have the advantage that we get to collect together in one +place the path-specific package stuff with the path-specific tool +stuff. + End of NOTES +--------------------------------------------- + + %************************************************************************ %* * \subsection{Global variables to contain system programs} %* * %************************************************************************ +All these pathnames are maintained IN THE NATIVE FORMAT OF THE HOST MACHINE. +(See remarks under pathnames below) + \begin{code} GLOBAL_VAR(v_Pgm_L, error "pgm_L", String) -- unlit GLOBAL_VAR(v_Pgm_P, error "pgm_P", String) -- cpp @@ -126,6 +166,10 @@ 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 @@ -135,8 +179,14 @@ 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_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} @@ -149,22 +199,24 @@ 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_bin pgm = top_dir `slash` "bin" `slash` pgm - installed file = top_dir `slash` file - inplace dir pgm = top_dir `slash` dosifyPath dir `slash` pgm + ; let installed, installed_bin :: FilePath -> FilePath + installed_bin pgm = pgmPath (top_dir `slash` "extra-bin") pgm + installed file = pgmPath top_dir file + inplace dir pgm = pgmPath (top_dir `slash` dir) pgm ; let pkgconfig_path | am_installed = installed "package.conf" @@ -189,11 +241,19 @@ initSysTools minusB_args | am_installed = installed_bin cGHC_MANGLER | otherwise = inplace cGHC_MANGLER_DIR cGHC_MANGLER +#ifndef mingw32_TARGET_OS + -- check whether TMPDIR is set in the environment + ; IO.try (do dir <- getEnv "TMPDIR" -- fails if not set + setTmpDir dir + return () + ) +#endif + -- Check that the package config exists ; config_exists <- doesFileExist pkgconfig_path ; when (not config_exists) $ throwDyn (InstallationError - ("Can't find package.conf in " ++ pkgconfig_path)) + ("Can't find package.conf as " ++ pkgconfig_path)) #if defined(mingw32_TARGET_OS) -- WINDOWS-SPECIFIC STUFF @@ -201,21 +261,36 @@ initSysTools minusB_args -- so when "installed" we look in TopDir/bin -- When "in-place" we look wherever the build-time configure -- script found them - ; let cpp_path | am_installed = installed cRAWCPP - | otherwise = cRAWCPP - gcc_path | am_installed = installed cGCC + -- When "install" we tell gcc where its specs file + exes are (-B) + -- and also some places to pick up include files. We need + -- to be careful to put all necessary exes in the -B place + -- (as, ld, cc1, etc) since if they don't get found there, gcc + -- then tries to run unadorned "as", "ld", etc, and will + -- 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/\"") | otherwise = cGCC - perl_path | am_installed = installed cGHC_PERL + -- 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 cGHC_TOUCHY + ; let touch_path | am_installed = installed_bin cGHC_TOUCHY | otherwise = inplace cGHC_TOUCHY_DIR cGHC_TOUCHY -- 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 split_path = perl_path ++ " \"" ++ split_script ++ "\"" + mangle_path = perl_path ++ " \"" ++ mangle_script ++ "\"" ; let mkdll_path = cMKDLL #else @@ -223,10 +298,9 @@ initSysTools minusB_args -- 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 cpp_path = cRAWCPP - gcc_path = cGCC + ; let gcc_path = cGCC touch_path = cGHC_TOUCHY - mkdll_path = panic "Cant build DLLs on a non-Win32 system" + mkdll_path = panic "Can't build DLLs on a non-Win32 system" -- On Unix, scripts are invoked using the '#!' method. Binary -- installations of GHC on Unix place the correct line on the front @@ -234,10 +308,12 @@ initSysTools minusB_args -- our knowledge of $(PERL) on the host system here. ; let split_path = split_script mangle_path = mangle_script - #endif - -- For all systems, copy and remove are provided by the host + -- cpp is derived from gcc on all platforms + ; let cpp_path = gcc_path ++ " -E " ++ cRAWCPP_FLAGS + + -- For all systems, copy and remove are provided by the host -- system; architecture-specific stuff is done when building Config.hs ; let cp_path = cGHC_CP @@ -245,6 +321,11 @@ 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 @@ -260,18 +341,22 @@ initSysTools minusB_args ; 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 () } \end{code} setPgm is 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 () @@ -284,6 +369,10 @@ 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 +#ifdef ILX +setPgm ('I' : pgm) = writeIORef v_Pgm_I pgm +setPgm ('i' : pgm) = writeIORef v_Pgm_i pgm +#endif setPgm pgm = unknownFlagErr ("-pgm" ++ pgm) \end{code} @@ -297,7 +386,7 @@ setPgm pgm = unknownFlagErr ("-pgm" ++ pgm) -- 1. Set proto_top_dir -- a) look for (the last) -B flag, and use it -- b) if there are no -B flags, get the directory --- where GHC is running +-- where GHC is running (only on Windows) -- -- 2. If package.conf exists in proto_top_dir, we are running -- installed; and TopDir = proto_top_dir @@ -308,43 +397,64 @@ setPgm pgm = unknownFlagErr ("-pgm" ++ pgm) -- -- This is very gruesome indeed -getTopDir :: [String] +findTopDir :: [String] -> IO (Bool, -- True <=> am installed, False <=> in-place - String) -- TopDir - -getTopDir minusbs - = do { proto_top_dir <- get_proto + String) -- TopDir (in Unix format '/' separated) - -- Discover whether we're running in a build tree or in an installation, +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. - ; am_installed <- doesFileExist (proto_top_dir `slash` "package.conf") + ; am_installed <- doesFileExist (top_dir `slash` "package.conf") - ; if am_installed then - return (True, proto_top_dir) - else - return (False, remove_suffix proto_top_dir) + ; return (am_installed, top_dir) } where - get_proto | not (null minusbs) - = return (dosifyPath (drop 2 (last minusbs))) + -- get_proto returns a Unix-format path (relying on getExecDir to do so too) + get_proto | not (null minusbs) + = return (unDosifyPath (drop 2 (last minusbs))) -- 2 for "-B" | otherwise = do { maybe_exec_dir <- getExecDir -- Get directory of executable - ; case maybe_exec_dir of -- (only works on Windows) - Nothing -> throwDyn (InstallationError - "missing -B option") + ; case maybe_exec_dir of -- (only works on Windows; + -- returns Nothing on Unix) + Nothing -> throwDyn (InstallationError "missing -B option") 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 String + | Option String + +showOptions :: [Option] -> String +showOptions ls = unwords (map (quote.showOpt) ls) + where + showOpt (FileOption f) = dosifyPath f + showOpt (Option s) = s + +#if defined(mingw32_TARGET_OS) + quote "" = "" + quote s = "\"" ++ s ++ "\"" +#else + quote = id +#endif - remove_suffix dir -- "/...stuff.../ghc/compiler" --> "/...stuff..." - = ASSERT2( not (null p1) && - not (null p2) && - dosifyPath dir == dosifyPath (top_dir ++ "/ghc/compiler"), - text dir ) - top_dir - where - p1 = dropWhile (not . isSlash) (reverse dir) - p2 = dropWhile (not . isSlash) (tail p1) -- head is '/' - top_dir = reverse (tail p2) -- head is '/' \end{code} @@ -356,45 +466,62 @@ 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 :: [Option] -> IO () runCpp args = do p <- readIORef v_Pgm_P runSomething "C 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 :: [String] -> IO () +runIlx2il args = do p <- readIORef v_Pgm_I + runSomething "Ilx2Il" p args + +runIlasm :: [String] -> 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 p <- readIORef v_Pgm_CP - runSomething purpose p [from,to] +copy purpose from to = do + verb <- dynFlag verbosity + when (verb >= 2) $ hPutStrLn stderr ("*** " ++ purpose) + + h <- openFile to WriteMode + ls <- readFile from -- inefficient, but it'll do for now. + -- ToDo: speed up via slurping. + hPutStr h ls + hClose h \end{code} \begin{code} @@ -415,13 +542,11 @@ Show the usage message and exit showGhcUsage = do { usage_path <- readIORef v_Path_usage ; usage <- readFile usage_path ; dump usage - ; System.exitWith System.ExitSuccess } + ; 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 \end{code} @@ -431,9 +556,6 @@ packageConfigPath = readIORef v_Path_package_config %* * %************************************************************************ -One reason this code is here is because SysTools.system needs to make -a temporary file. - \begin{code} GLOBAL_VAR(v_FilesToClean, [], [String] ) GLOBAL_VAR(v_TmpDir, cDEFAULT_TMPDIR, String ) @@ -476,12 +598,14 @@ addFilesToClean files = mapM_ (add v_FilesToClean) files removeTmpFiles :: Int -> [FilePath] -> IO () removeTmpFiles verb fs = traceCmd "Deleting temp files" - ("Deleting: " ++ concat (intersperse " " fs)) + ("Deleting: " ++ unwords fs) (mapM_ rm fs) where - rm f = removeFile f `catchAllIO` - (\exn -> hPutStrLn stderr ("Warning: deleting non-existent " ++ f) >> - return ()) + rm f = removeFile f `catchAllIO` + (\_ignored -> + when (verb >= 2) $ + hPutStrLn stderr ("Warning: deleting non-existent " ++ f) + ) \end{code} @@ -504,19 +628,31 @@ setDryRun = writeIORef v_Dry_run True runSomething :: String -- For -v message -> String -- Command name (possibly a full path) -- assumed already dos-ified - -> [String] -- Arguments - -- runSomthing will dos-ify them + -> [Option] -- Arguments + -- runSomething will dos-ify them -> IO () runSomething phase_name pgm args = traceCmd phase_name cmd_line $ - do { exit_code <- system cmd_line + do { +#ifndef mingw32_TARGET_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 - cmd_line = unwords (pgm : dosifyPaths args) + cmd_line = pgm ++ ' ':showOptions args -- unwords (pgm : dosifyPaths (map quote args)) + -- The pgm is already in native format (appropriate dir separators) +#if defined(mingw32_TARGET_OS) + quote "" = "" + quote s = "\"" ++ s ++ "\"" +#else + quote = id +#endif traceCmd :: String -> String -> IO () -> IO () -- a) trace the command (at two levels of verbosity) @@ -543,24 +679,52 @@ traceCmd phase_name cmd_line action %************************************************************************ %* * -\subsection{Support code} +\subsection{Path names} %* * %************************************************************************ +We maintain path names in Unix form ('/'-separated) right until +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, +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. dosifyPaths :: [String] -> [String] -dosifyPath :: String -> String --- dosifyPath does two things +-- dosifyPaths does two things -- a) change '/' to '\' -- b) remove initial '/cygdrive/' +unDosifyPath :: String -> String +-- Just change '\' to '/' + +pgmPath :: String -- Directory string in Unix format + -> String -- Program name with no directory separators + -- (e.g. copy /y) + -> String -- Program invocation string in native format + + + #if defined(mingw32_TARGET_OS) + +--------------------- Windows version ------------------ dosifyPaths xs = map dosifyPath xs +unDosifyPath xs = subst '\\' '/' xs + +pgmPath dir pgm = dosifyPath dir ++ '\\' : pgm + +-- HACK! +dosifyPath "\"/DLL\"" = "\"/DLL\"" +dosifyPath "\"/QUIET\"" = "\"/QUIET\"" +dosifyPath l@('"':'/':'O':'U':'T':_) = l +-- end of HACK! dosifyPath stuff = subst '/' '\\' real_stuff where @@ -572,22 +736,28 @@ dosifyPath 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 -dosifyPaths xs = xs -dosifyPath xs = xs + +--------------------- Unix version --------------------- +dosifyPaths ps = ps +unDosifyPath xs = xs +pgmPath dir pgm = dir ++ '/' : pgm +dosifyPath stuff = stuff +-------------------------------------------------------- #endif +subst a b ls = map (\ x -> if x == a then b else x) ls +\end{code} + + ----------------------------------------------------------------------------- --- Path name construction --- At the moment, we always use '/' and rely on dosifyPath --- to switch to DOS pathnames when necessary + Path name construction +\begin{code} slash :: String -> String -> String absPath, relPath :: [String] -> String isSlash '/' = True -isSlash '\\' = True isSlash other = False relPath [] = "" @@ -595,74 +765,52 @@ relPath xs = foldr1 slash xs absPath xs = "" `slash` relPath xs -#if defined(mingw32_TARGET_OS) -slash s1 s2 = s1 ++ ('\\' : s2) -#else slash s1 s2 = s1 ++ ('/' : s2) -#endif +\end{code} ------------------------------------------------------------------------------ --- Define myGetProcessId :: IO Int --- getExecDir :: IO (Maybe String) -#ifdef mingw32_TARGET_OS -foreign import "_getpid" getProcessID :: IO Int -- relies on Int == Int32 on Windows +%************************************************************************ +%* * +\subsection{Support code} +%* * +%************************************************************************ +\begin{code} +----------------------------------------------------------------------------- +-- Define getExecDir :: IO (Maybe String) + +#if defined(mingw32_TARGET_OS) getExecDir :: IO (Maybe String) -getExecDir = return Nothing -{- -foreign import stdcall "GetCurrentDirectoryA" getCurrentDirectory :: Int32 -> CString -> IO Int32 -getExecDir = do len <- getCurrentDirectory 0 nullAddr +getExecDir = do let len = 2048 -- plenty, PATH_MAX is 512 under Win32. buf <- mallocArray (fromIntegral len) - ret <- getCurrentDirectory len buf + ret <- getModuleFileName nullAddr buf len if ret == 0 then return Nothing else do s <- peekCString buf destructArray (fromIntegral len) buf - return (Just s) --} + return (Just (reverse (drop (length "/bin/ghc.exe") (reverse (unDosifyPath s))))) + + +foreign import stdcall "GetModuleFileNameA" getModuleFileName :: Addr -> CString -> Int32 -> IO Int32 #else -getProcessID :: IO Int -getProcessID = Posix.getProcessID getExecDir :: IO (Maybe String) = do return Nothing #endif -\end{code} -%************************************************************************ -%* * -\subsection{System} -%* * -%************************************************************************ - -In GHC prior to 5.01 (or so), on Windows, the implementation -of "system" in the library System.system does not work for very -long command lines. But GHC may need to make a system call with -a very long command line, notably when it links itself during -bootstrapping. +#ifdef mingw32_TARGET_OS +foreign import "_getpid" getProcessID :: IO Int -- relies on Int == Int32 on Windows +#else +getProcessID :: IO Int +getProcessID = Posix.getProcessID +#endif -Solution: when compiling SysTools for Windows, using GHC prior -to 5.01, write the command to a file and use "sh" (not cmd.exe) -to execute it. Such GHCs require "sh" on the path, but once -bootstrapped this problem goes away. +rawSystem :: String -> IO ExitCode +rawSystem "" = ioException (IOError Nothing InvalidArgument "rawSystem" "null command" Nothing) +rawSystem cmd = + withCString cmd $ \s -> do + status <- throwErrnoIfMinus1 "rawSystem" (primRawSystem s) + case status of + 0 -> return ExitSuccess + n -> return (ExitFailure n) -ToDo: remove when compiling with GHC < 5 is not relevant any more +foreign import ccall "rawSystemCmd" unsafe primRawSystem :: CString -> IO Int -\begin{code} -system cmd - -#if !defined(mingw32_TARGET_OS) || __GLASGOW_HASKELL__ > 501 - -- The usual case - = System.system cmd - -#else -- The Hackoid case - = do pid <- getProcessID - tmp_dir <- readIORef v_TmpDir - let tmp = tmp_dir++"/sh"++show pid - h <- openFile tmp WriteMode - hPutStrLn h cmd - hClose h - exit_code <- System.system ("sh - " ++ tmp) `catchAllIO` - (\exn -> removeFile tmp >> throw exn) - removeFile tmp - return exit_code -#endif -\end{code} \ No newline at end of file +\end{code}