packages feed

unix (empty) → 2.0

raw patch · 26 files changed

+9532/−0 lines, 26 filesdep +basebuild-type:Customsetup-changed

Dependencies added: base

Files

+ LICENSE view
@@ -0,0 +1,31 @@+The Glasgow Haskell Compiler License++Copyright 2004, The University Court of the University of Glasgow. +All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met:++- Redistributions of source code must retain the above copyright notice,+this list of conditions and the following disclaimer.+ +- Redistributions in binary form must reproduce the above copyright notice,+this list of conditions and the following disclaimer in the documentation+and/or other materials provided with the distribution.+ +- Neither name of the University nor the names of its contributors may be+used to endorse or promote products derived from this software without+specific prior written permission. ++THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF+GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE+UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH+DAMAGE.
+ Setup.hs view
@@ -0,0 +1,6 @@+module Main (main) where++import Distribution.Simple (defaultMainWithHooks, defaultUserHooks)++main :: IO ()+main = defaultMainWithHooks defaultUserHooks
+ System/Posix.hs view
@@ -0,0 +1,177 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix+-- Copyright   :  (c) The University of Glasgow 2002+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- POSIX support+--+-----------------------------------------------------------------------------++module System.Posix (+  module System.Posix.Types,+  module System.Posix.Signals,+  module System.Posix.Directory,+  module System.Posix.Files,+  module System.Posix.Unistd,+  module System.Posix.IO,+  module System.Posix.Env,+  module System.Posix.Process,+  module System.Posix.Temp,+  module System.Posix.Terminal,+  module System.Posix.Time,+  module System.Posix.User,+  module System.Posix.Resource+ ) where++import System.Posix.Types+import System.Posix.Signals+import System.Posix.Directory+import System.Posix.Files+import System.Posix.Unistd+import System.Posix.Process+import System.Posix.IO+import System.Posix.Env+import System.Posix.Temp+import System.Posix.Terminal+import System.Posix.Time+import System.Posix.User+import System.Posix.Resource++{- TODO++Here we detail our support for the IEEE Std 1003.1-2001 standard.  For+each header file defined by the standard, we categorise its+functionality as++ - "supported" ++   Full equivalent functionality is provided by the specified Haskell+   module.++ - "unsupported" (functionality not provided by a Haskell module)++   The functionality is not currently provided.++ - "to be supported" ++   Currently unsupported, but support is planned for the future.++Exceptions are listed where appropriate.++Interfaces supported+--------------------++base package:++regex.h		Text.Regex.Posix+signal.h	System.Posix.Signals++unix package:++dirent.h 	System.Posix.Directory+dlfcn.h 	System.Posix.DynamicLinker+errno.h 	Foreign.C.Error+fcntl.h 	System.Posix.IO+sys/stat.h	System.Posix.Files+sys/times.h	System.Posix.Process+sys/types.h	System.Posix.Types (with exceptions...)+sys/utsname.h	System.Posix.Unistd+sys/wait.h	System.Posix.Process+termios.h	System.Posix.Terminal (check exceptions)+unistd.h	System.Posix.*+utime.h		System.Posix.Files+pwd.h		System.Posix.User+grp.h		System.Posix.User+stdlib.h: 	System.Posix.Env (getenv()/setenv()/unsetenv())+		System.Posix.Temp (mkstemp())+sys/resource.h: System.Posix.Resource (get/setrlimit() only)++network package:++arpa/inet.h+net/if.h+netinet/in.h+netinet/tcp.h+sys/socket.h+sys/un.h++To be supported+---------------++limits.h	(pathconf()/fpathconf() already done)+poll.h+sys/resource.h  (getrusage(): use instead of times() for getProcessTimes?)+sys/select.h+sys/statvfs.h	 (?)+sys/time.h	(but maybe not the itimer?)+time.h		(System.Posix.Time)+stdio.h		(popen only: System.Posix.IO)+sys/mman.h++Unsupported interfaces+----------------------++aio.h+assert.h+complex.h+cpio.h +ctype.h +fenv.h+float.h+fmtmsg.h+fnmatch.h+ftw.h+glob.h+iconv.h +inttypes.h +iso646.h +langinfo.h+libgen.h+locale.h	(see System.Locale)+math.h+monetary.h+mqueue.h+ndbm.h+netdb.h+nl_types.h+pthread.h+sched.h+search.h+semaphore.h+setjmp.h+spawn.h+stdarg.h+stdbool.h+stddef.h+stdint.h+stdio.h		except: popen()+stdlib.h	except: exit(): System.Posix.Process+			free()/malloc(): Foreign.Marshal.Alloc+			getenv()/setenv(): ?? System.Environment+			rand() etc.: System.Random+string.h+strings.h+stropts.h+sys/ipc.h+sys/msg.h+sys/sem.h+sys/shm.h+sys/timeb.h+sys/uio.h+syslog.h+tar.h+tgmath.h+trace.h+ucontext.h+ulimit.h+utmpx.h+wchar.h+wctype.h+wordexp.h++-}
+ System/Posix/Directory.hsc view
@@ -0,0 +1,139 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.Files+-- Copyright   :  (c) The University of Glasgow 2002+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- POSIX directory support+--+-----------------------------------------------------------------------------++module System.Posix.Directory (+   -- * Creating and removing directories+   createDirectory, removeDirectory,++   -- * Reading directories+   DirStream,+   openDirStream,+   readDirStream,+   rewindDirStream,   +   closeDirStream,+   DirStreamOffset,+   tellDirStream,+   seekDirStream,++   -- * The working dirctory+   getWorkingDirectory,+   changeWorkingDirectory,+   changeWorkingDirectoryFd,+  ) where++import System.Posix.Error+import System.Posix.Types+import System.Posix.Internals+import System.Directory hiding (createDirectory)+import Foreign+import Foreign.C++-- | @createDirectory dir mode@ calls @mkdir@ to +--   create a new directory, @dir@, with permissions based on+--  @mode@.+createDirectory :: FilePath -> FileMode -> IO ()+createDirectory name mode =+  withCString name $ \s -> +    throwErrnoPathIfMinus1_ "createDirectory" name (c_mkdir s mode)  ++foreign import ccall unsafe "mkdir"+  c_mkdir :: CString -> CMode -> IO CInt++newtype DirStream = DirStream (Ptr CDir)++-- | @openDirStream dir@ calls @opendir@ to obtain a+--   directory stream for @dir@.+openDirStream :: FilePath -> IO DirStream+openDirStream name =+  withCString name $ \s -> do+    dirp <- throwErrnoPathIfNull "openDirStream" name $ c_opendir s+    return (DirStream dirp)++-- | @readDirStream dp@ calls @readdir@ to obtain the+--   next directory entry (@struct dirent@) for the open directory+--   stream @dp@, and returns the @d_name@ member of that+--  structure.+readDirStream :: DirStream -> IO FilePath+readDirStream (DirStream dirp) =+  alloca $ \ptr_dEnt  -> loop ptr_dEnt+ where+  loop ptr_dEnt = do+    resetErrno+    r <- readdir dirp ptr_dEnt+    if (r == 0)+	 then do dEnt <- peek ptr_dEnt+		 if (dEnt == nullPtr)+		    then return []+		    else do+	 	     entry <- (d_name dEnt >>= peekCString)+		     freeDirEnt dEnt+		     return entry+	 else do errno <- getErrno+		 if (errno == eINTR) then loop ptr_dEnt else do+		 let (Errno eo) = errno+		 if (eo == end_of_dir)+		    then return []+		    else throwErrno "readDirStream"++-- | @rewindDirStream dp@ calls @rewinddir@ to reposition+--   the directory stream @dp@ at the beginning of the directory.+rewindDirStream :: DirStream -> IO ()+rewindDirStream (DirStream dirp) = c_rewinddir dirp++-- | @closeDirStream dp@ calls @closedir@ to close+--   the directory stream @dp@.+closeDirStream :: DirStream -> IO ()+closeDirStream (DirStream dirp) = do+  throwErrnoIfMinus1_ "closeDirStream" (c_closedir dirp)++newtype DirStreamOffset = DirStreamOffset CLong++seekDirStream :: DirStream -> DirStreamOffset -> IO ()+seekDirStream (DirStream dirp) (DirStreamOffset off) =+  c_seekdir dirp off++foreign import ccall unsafe "seekdir"+  c_seekdir :: Ptr CDir -> CLong -> IO ()++tellDirStream :: DirStream -> IO DirStreamOffset+tellDirStream (DirStream dirp) = do+  off <- c_telldir dirp+  return (DirStreamOffset off)++foreign import ccall unsafe "telldir"+  c_telldir :: Ptr CDir -> IO CLong++{-+ Renamings of functionality provided via Directory interface,+ kept around for b.wards compatibility and for having more POSIXy+ names+-}++-- | @getWorkingDirectory@ calls @getcwd@ to obtain the name+--   of the current working directory.+getWorkingDirectory :: IO FilePath+getWorkingDirectory = getCurrentDirectory++-- | @changeWorkingDirectory dir@ calls @chdir@ to change+--   the current working directory to @dir@.+changeWorkingDirectory :: FilePath -> IO ()+changeWorkingDirectory name = setCurrentDirectory name++changeWorkingDirectoryFd :: Fd -> IO ()+changeWorkingDirectoryFd (Fd fd) = +  throwErrnoIfMinus1_ "changeWorkingDirectoryFd" (c_fchdir fd)++foreign import ccall unsafe "fchdir"+  c_fchdir :: CInt -> IO CInt
+ System/Posix/DynamicLinker.hsc view
@@ -0,0 +1,95 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.DynamicLinker+-- Copyright   :  (c) Volker Stolz <vs@foldr.org> 2003+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  vs@foldr.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- Dynamic linker support through dlopen()+-----------------------------------------------------------------------------++module System.Posix.DynamicLinker (++    module System.Posix.DynamicLinker.Prim,+    dlopen,+    dlsym,+    dlerror,+    dlclose,+    withDL, withDL_,+    undl,+    )++--  Usage:+--  ******+--  +--  Let's assume you want to open a local shared library \'foo\' (.\/libfoo.so)+--  offering a function+--    @char \* mogrify (char\*,int)@+--  and invoke @str = mogrify("test",1)@:+-- +--  +--  type Fun = CString -> Int -> IO CString+--  foreign import dynamic unsafe fun__ :: FunPtr Fun -> Fun+-- +--  withDL "libfoo.so" [RTLD_NOW] \$ \\ mod -> do+--     funptr <- dlsym mod "mogrify"+--     let fun = fun__ funptr+--     withCString "test" \$ \\ str -> do+--       strptr <- fun str 1+--       strstr <- peekCString strptr+--       ...+--  ++where++#include "HsUnix.h"++import System.Posix.DynamicLinker.Prim+import Control.Exception	( bracket )+import Control.Monad	( liftM )+import Foreign.Ptr	( Ptr, nullPtr, FunPtr, nullFunPtr )+import Foreign.C.String	( withCString, peekCString )++dlopen :: String -> [RTLDFlags] -> IO DL+dlopen path flags = do+  withCString path $ \ p -> do+    liftM DLHandle $ throwDLErrorIf "dlopen" (== nullPtr) $ c_dlopen p (packRTLDFlags flags)++dlclose :: DL -> IO ()+dlclose (DLHandle h) = throwDLErrorIf_ "dlclose" (/= 0) $ c_dlclose h+dlclose h = error $ "dlclose: invalid argument" ++ (show h)++dlerror :: IO String+dlerror = c_dlerror >>= peekCString ++-- |'dlsym' returns the address binding of the symbol described in @symbol@,+-- as it occurs in the shared object identified by @source@.++dlsym :: DL -> String -> IO (FunPtr a)+dlsym source symbol = do+  withCString symbol $ \ s -> do+    throwDLErrorIf "dlsym" (== nullFunPtr) $ c_dlsym (packDL source) s++withDL :: String -> [RTLDFlags] -> (DL -> IO a) -> IO a+withDL mod flags f = bracket (dlopen mod flags) (dlclose) f++withDL_ :: String -> [RTLDFlags] -> (DL -> IO a) -> IO ()+withDL_ mod flags f = withDL mod flags f >> return ()++-- |'undl' obtains the raw handle. You mustn't do something like+-- @withDL mod flags $ liftM undl >>= \ p -> use p@++undl :: DL -> Ptr ()+undl = packDL++throwDLErrorIf :: String -> (a -> Bool) -> IO a -> IO a+throwDLErrorIf s p f = do+  r <- f+  if (p r)+    then dlerror >>= \ err -> ioError (userError ( s ++ ": " ++ err))+    else return r++throwDLErrorIf_ s p f = throwDLErrorIf s p f >> return ()
+ System/Posix/DynamicLinker/Module.hsc view
@@ -0,0 +1,120 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.DynamicLinker.Module+-- Copyright   :  (c) Volker Stolz <vs@foldr.org> 2003+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  vs@foldr.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- DLOpen support, old API+--  Derived from GModule.chs by M.Weber & M.Chakravarty which is part of c2hs+--  I left the API more or less the same, mostly the flags are different.+--+-----------------------------------------------------------------------------++module System.Posix.DynamicLinker.Module (++--  Usage:+--  ******+--  +--  Let's assume you want to open a local shared library 'foo' (./libfoo.so)+--  offering a function+--    char * mogrify (char*,int)+--  and invoke str = mogrify("test",1):+-- +--  type Fun = CString -> Int -> IO CString+--  foreign import dynamic unsafe fun__ :: FunPtr Fun -> Fun+-- +--  withModule (Just ".") ("libfoo.so") [RTLD_NOW] $ \ mod -> do+--     funptr <- moduleSymbol mod "mogrify"+--     let fun = fun__ funptr+--     withCString "test" $ \ str -> do+--       strptr <- fun str 1+--       strstr <- peekCString strptr+--       ...++      Module+    , moduleOpen             -- :: String -> ModuleFlags -> IO Module+    , moduleSymbol           -- :: Source -> String -> IO (FunPtr a)+    , moduleClose            -- :: Module -> IO Bool+    , moduleError            -- :: IO String+    , withModule             -- :: Maybe String +                             -- -> String +	                     -- -> [ModuleFlags ]+			     -- -> (Module -> IO a) +			     -- -> IO a+    , withModule_            -- :: Maybe String + 			     -- -> String + 			     -- -> [ModuleFlags] + 			     -- -> (Module -> IO a) + 			     -- -> IO ()+    )+where++#include "HsUnix.h"++import System.Posix.DynamicLinker+import Foreign.Ptr	( Ptr, nullPtr, FunPtr )+import Foreign.C.String	( withCString )++-- abstract handle for dynamically loaded module (EXPORTED)+--+newtype Module = Module (Ptr ())++unModule              :: Module -> (Ptr ())+unModule (Module adr)  = adr++-- Opens a module (EXPORTED)+--++moduleOpen :: String -> [RTLDFlags] -> IO Module+moduleOpen mod flags = do+  modPtr <- withCString mod $ \ modAddr -> c_dlopen modAddr (packRTLDFlags flags)+  if (modPtr == nullPtr)+      then moduleError >>= \ err -> ioError (userError ("dlopen: " ++ err))+      else return $ Module modPtr++-- Gets a symbol pointer from a module (EXPORTED)+--+moduleSymbol :: Module -> String -> IO (FunPtr a)+moduleSymbol mod sym = dlsym (DLHandle (unModule mod)) sym++-- Closes a module (EXPORTED)+-- +moduleClose     :: Module -> IO ()+moduleClose mod  = dlclose (DLHandle (unModule mod))++-- Gets a string describing the last module error (EXPORTED)+-- +moduleError :: IO String+moduleError  = dlerror+++-- Convenience function, cares for module open- & closing+-- additionally returns status of `moduleClose' (EXPORTED)+-- +withModule :: Maybe String +           -> String +	   -> [RTLDFlags]+           -> (Module -> IO a) +	   -> IO a+withModule dir mod flags p = do+  let modPath = case dir of+                  Nothing -> mod+	          Just p  -> p ++ if ((head (reverse p)) == '/')+                                       then mod+				       else ('/':mod)+  mod <- moduleOpen modPath flags+  result <- p mod+  moduleClose mod+  return result++withModule_ :: Maybe String +            -> String +	    -> [RTLDFlags]+            -> (Module -> IO a) +	    -> IO ()+withModule_ dir mod flags p = withModule dir mod flags p >>= \ _ -> return ()
+ System/Posix/DynamicLinker/Prim.hsc view
@@ -0,0 +1,130 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.DynamicLinker.Prim+-- Copyright   :  (c) Volker Stolz <vs@foldr.org> 2003+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  vs@foldr.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- DLOpen and friend+--  Derived from GModule.chs by M.Weber & M.Chakravarty which is part of c2hs+--  I left the API more or less the same, mostly the flags are different.+--+-----------------------------------------------------------------------------++module System.Posix.DynamicLinker.Prim (+  -- * low level API+  c_dlopen,+  c_dlsym,+  c_dlerror,+  c_dlclose,+  -- dlAddr, -- XXX NYI+  haveRtldNext,+  haveRtldLocal,+  packRTLDFlags,+  RTLDFlags(..),+  packDL,+  DL(..)+ )++where++#include "HsUnix.h"++import Data.Bits	( (.|.) )+import Foreign.Ptr	( Ptr, FunPtr, nullPtr )+import Foreign.C.Types	( CInt )+import Foreign.C.String	( CString )++-- RTLD_NEXT madness+-- On some host (e.g. SuSe Linux 7.2) RTLD_NEXT is not visible+-- without setting _GNU_SOURCE. Since we don't want to set this+-- flag, here's a different solution: You can use the Haskell+-- function 'haveRtldNext' to check wether the flag is available+-- to you. Ideally, this will be optimized by the compiler so+-- that it should be as efficient as an #ifdef.+--    If you fail to test the flag and use it although it is+-- undefined, 'packOneModuleFlag' will bomb.+--    The same applies to RTLD_LOCAL which isn't available on+-- cygwin.++haveRtldNext :: Bool++#ifdef HAVE_RTLDNEXT+haveRtldNext = True++foreign import ccall unsafe "__hsunix_rtldNext" rtldNext :: Ptr a++#else  /* HAVE_RTLDNEXT */+haveRtldNext = False+#endif /* HAVE_RTLDNEXT */++#ifdef HAVE_RTLDDEFAULT+foreign import ccall unsafe "__hsunix_rtldDefault" rtldDefault :: Ptr a+#endif /* HAVE_RTLDDEFAULT */++haveRtldLocal :: Bool++#ifdef HAVE_RTLDLOCAL+haveRtldLocal = True+#else /* HAVE_RTLDLOCAL */+haveRtldLocal = False+#endif /* HAVE_RTLDLOCAL */++data RTLDFlags +  = RTLD_LAZY+  | RTLD_NOW+  | RTLD_GLOBAL +  | RTLD_LOCAL+    deriving (Show, Read)++foreign import ccall unsafe "dlopen" c_dlopen :: CString -> CInt -> IO (Ptr ())+foreign import ccall unsafe "dlsym"  c_dlsym  :: Ptr () -> CString -> IO (FunPtr a)+foreign import ccall unsafe "dlerror" c_dlerror :: IO CString+foreign import ccall unsafe "dlclose" c_dlclose :: (Ptr ()) -> IO CInt++packRTLDFlags :: [RTLDFlags] -> CInt+packRTLDFlags flags = foldl (\ s f -> (packRTLDFlag f) .|. s) 0 flags++packRTLDFlag :: RTLDFlags -> CInt+packRTLDFlag RTLD_LAZY = #const RTLD_LAZY++#ifdef HAVE_RTLDNOW+packRTLDFlag RTLD_NOW = #const RTLD_NOW+#else /* HAVE_RTLDNOW */+packRTLDFlag RTLD_NOW =  error "RTLD_NOW not available"+#endif /* HAVE_RTLDNOW */++#ifdef HAVE_RTLDGLOBAL+packRTLDFlag RTLD_GLOBAL = #const RTLD_GLOBAL+#else /* HAVE_RTLDGLOBAL */+packRTLDFlag RTLD_GLOBAL = error "RTLD_GLOBAL not available"+#endif++#ifdef HAVE_RTLDLOCAL+packRTLDFlag RTLD_LOCAL = #const RTLD_LOCAL+#else /* HAVE_RTLDLOCAL */+packRTLDFlag RTLD_LOCAL = error "RTLD_LOCAL not available"+#endif /* HAVE_RTLDLOCAL */++-- |Flags for 'System.Posix.DynamicLinker.dlsym'. Notice that 'Next'+-- might not be available on your particular platform!++data DL = Null | Next | Default | DLHandle (Ptr ()) deriving (Show)++packDL :: DL -> Ptr ()+packDL Null = nullPtr+#ifdef HAVE_RTLDNEXT+packDL Next = rtldNext+#else+packDL Next = error "RTLD_NEXT not available"+#endif+#ifdef HAVE_RTLDDEFAULT+packDL Default = rtldDefault+#else+packDL Default = nullPtr+#endif+packDL (DLHandle h) = h
+ System/Posix/Env.hsc view
@@ -0,0 +1,124 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.Env+-- Copyright   :  (c) The University of Glasgow 2002+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- POSIX environment support+--+-----------------------------------------------------------------------------++module System.Posix.Env (+	getEnv+	, getEnvDefault+	, getEnvironmentPrim+	, getEnvironment+	, putEnv+	, setEnv+	, unsetEnv+) where++#include "HsUnix.h"++import Foreign.C.Error	( throwErrnoIfMinus1_ )+import Foreign.C.Types	( CInt )+import Foreign.C.String+import Foreign.Marshal.Array+import Foreign.Ptr+import Foreign.Storable+import Control.Monad	( liftM )+import Data.Maybe	( fromMaybe )++-- |'getEnv' looks up a variable in the environment.++getEnv :: String -> IO (Maybe String)+getEnv name = do+  litstring <- withCString name c_getenv+  if litstring /= nullPtr+     then liftM Just $ peekCString litstring+     else return Nothing++-- |'getEnvDefault' is a wrapper around 'getEnv' where the+-- programmer can specify a fallback if the variable is not found+-- in the environment.++getEnvDefault :: String -> String -> IO String+getEnvDefault name fallback = liftM (fromMaybe fallback) (getEnv name)++foreign import ccall unsafe "getenv"+   c_getenv :: CString -> IO CString++getEnvironmentPrim :: IO [String]+getEnvironmentPrim = do+  c_environ <- peek c_environ_p+  arr <- peekArray0 nullPtr c_environ+  mapM peekCString arr++foreign import ccall unsafe "&environ"+   c_environ_p :: Ptr (Ptr CString)++-- |'getEnvironment' retrieves the entire environment as a+-- list of @(key,value)@ pairs.++getEnvironment :: IO [(String,String)]+getEnvironment = do+  env <- getEnvironmentPrim+  return $ map (dropEq.(break ((==) '='))) env+ where+   dropEq (x,'=':ys) = (x,ys)+   dropEq (x,_)      = error $ "getEnvironment: insane variable " ++ x++-- |The 'unsetEnv' function deletes all instances of the variable name+-- from the environment.++unsetEnv :: String -> IO ()+#ifdef HAVE_UNSETENV++unsetEnv name = withCString name c_unsetenv++foreign import ccall unsafe "unsetenv"+   c_unsetenv :: CString -> IO ()+#else+unsetEnv name = putEnv (name ++ "=")+#endif++-- |'putEnv' function takes an argument of the form @name=value@+-- and is equivalent to @setEnv(key,value,True{-overwrite-})@.++putEnv :: String -> IO ()+putEnv keyvalue = withCString keyvalue $ \s ->+  throwErrnoIfMinus1_ "putenv" (c_putenv s)++foreign import ccall unsafe "putenv"+   c_putenv :: CString -> IO CInt++{- |The 'setEnv' function inserts or resets the environment variable name in+     the current environment list.  If the variable @name@ does not exist in the+     list, it is inserted with the given value.  If the variable does exist,+     the argument @overwrite@ is tested; if @overwrite@ is @False@, the variable is+     not reset, otherwise it is reset to the given value.+-}++setEnv :: String -> String -> Bool {-overwrite-} -> IO ()+#ifdef HAVE_SETENV+setEnv key value ovrwrt = do+  withCString key $ \ keyP ->+    withCString value $ \ valueP ->+      throwErrnoIfMinus1_ "putenv" $+	c_setenv keyP valueP (fromIntegral (fromEnum ovrwrt))++foreign import ccall unsafe "setenv"+   c_setenv :: CString -> CString -> CInt -> IO CInt+#else+setEnv key value True = putEnv (key++"="++value)+setEnv key value False = do+  res <- getEnv key+  case res of+    Just _  -> return ()+    Nothing -> putEnv (key++"="++value)+#endif
+ System/Posix/Error.hs view
@@ -0,0 +1,50 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.Error+-- Copyright   :  (c) The University of Glasgow 2002+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- POSIX error support+--+-----------------------------------------------------------------------------++module System.Posix.Error (+	throwErrnoPath,+	throwErrnoPathIf, +	throwErrnoPathIf_,+	throwErrnoPathIfNull,+	throwErrnoPathIfMinus1,+	throwErrnoPathIfMinus1_+  ) where++import Foreign.C.Error+import Foreign.Ptr+import Foreign.Marshal.Error 	( void )++throwErrnoPath :: String -> FilePath -> IO a+throwErrnoPath loc path =+  do+    errno <- getErrno+    ioError (errnoToIOError loc errno Nothing (Just path))++throwErrnoPathIf :: (a -> Bool) -> String -> FilePath -> IO a -> IO a+throwErrnoPathIf pred loc path f  = +  do+    res <- f+    if pred res then throwErrnoPath loc path else return res++throwErrnoPathIf_ :: (a -> Bool) -> String -> FilePath -> IO a -> IO ()+throwErrnoPathIf_ pred loc path f  = void $ throwErrnoPathIf pred loc path f++throwErrnoPathIfNull :: String -> FilePath -> IO (Ptr a) -> IO (Ptr a)+throwErrnoPathIfNull  = throwErrnoPathIf (== nullPtr)++throwErrnoPathIfMinus1 :: Num a => String -> FilePath -> IO a -> IO a+throwErrnoPathIfMinus1 = throwErrnoPathIf (== -1)++throwErrnoPathIfMinus1_ :: Num a => String -> FilePath -> IO a -> IO ()+throwErrnoPathIfMinus1_  = throwErrnoPathIf_ (== -1)
+ System/Posix/Files.hsc view
@@ -0,0 +1,689 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.Files+-- Copyright   :  (c) The University of Glasgow 2002+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- Functions defined by the POSIX standards for manipulating and querying the+-- file system. Names of underlying POSIX functions are indicated whenever+-- possible. A more complete documentation of the POSIX functions together+-- with a more detailed description of different error conditions are usually+-- available in the system's manual pages or from+-- <http://www.unix.org/version3/online.html> (free registration required).+--+-- When a function that calls an underlying POSIX function fails, the errno+-- code is converted to an 'IOError' using 'Foreign.C.Error.errnoToIOError'.+-- For a list of which errno codes may be generated, consult the POSIX+-- documentation for the underlying function.+--+-----------------------------------------------------------------------------++module System.Posix.Files (+    -- * File modes+    -- FileMode exported by System.Posix.Types+    unionFileModes, intersectFileModes,+    nullFileMode,+    ownerReadMode, ownerWriteMode, ownerExecuteMode, ownerModes,+    groupReadMode, groupWriteMode, groupExecuteMode, groupModes,+    otherReadMode, otherWriteMode, otherExecuteMode, otherModes,+    setUserIDMode, setGroupIDMode,+    stdFileMode,   accessModes,++    -- ** Setting file modes+    setFileMode, setFdMode, setFileCreationMask,++    -- ** Checking file existence and permissions+    fileAccess, fileExist,++    -- * File status+    FileStatus,+    -- ** Obtaining file status+    getFileStatus, getFdStatus, getSymbolicLinkStatus,+    -- ** Querying file status+    deviceID, fileID, fileMode, linkCount, fileOwner, fileGroup,+    specialDeviceID, fileSize, accessTime, modificationTime,+    statusChangeTime,+    isBlockDevice, isCharacterDevice, isNamedPipe, isRegularFile,+    isDirectory, isSymbolicLink, isSocket,++    -- * Creation+    createNamedPipe, +    createDevice,++    -- * Hard links+    createLink, removeLink,++    -- * Symbolic links+    createSymbolicLink, readSymbolicLink,++    -- * Renaming files+    rename,++    -- * Changing file ownership+    setOwnerAndGroup,  setFdOwnerAndGroup,+#if HAVE_LCHOWN+    setSymbolicLinkOwnerAndGroup,+#endif++    -- * Changing file timestamps+    setFileTimes, touchFile,++    -- * Setting file sizes+    setFileSize, setFdSize,++    -- * Find system-specific limits for a file+    PathVar(..), getPathVar, getFdPathVar,+  ) where++#include "HsUnix.h"++import System.Posix.Error+import System.Posix.Types+import System.IO.Unsafe+import Data.Bits+import System.Posix.Internals+import Foreign+import Foreign.C++-- -----------------------------------------------------------------------------+-- POSIX file modes++-- The abstract type 'FileMode', constants and operators for+-- manipulating the file modes defined by POSIX.++-- | No permissions.+nullFileMode :: FileMode+nullFileMode = 0++-- | Owner has read permission.+ownerReadMode :: FileMode+ownerReadMode = (#const S_IRUSR)++-- | Owner has write permission.+ownerWriteMode :: FileMode+ownerWriteMode = (#const S_IWUSR)++-- | Owner has execute permission.+ownerExecuteMode :: FileMode+ownerExecuteMode = (#const S_IXUSR)++-- | Group has read permission.+groupReadMode :: FileMode+groupReadMode = (#const S_IRGRP)++-- | Group has write permission.+groupWriteMode :: FileMode+groupWriteMode = (#const S_IWGRP)++-- | Group has execute permission.+groupExecuteMode :: FileMode+groupExecuteMode = (#const S_IXGRP)++-- | Others have read permission.+otherReadMode :: FileMode+otherReadMode = (#const S_IROTH)++-- | Others have write permission.+otherWriteMode :: FileMode+otherWriteMode = (#const S_IWOTH)++-- | Others have execute permission.+otherExecuteMode :: FileMode+otherExecuteMode = (#const S_IXOTH)++-- | Set user ID on execution.+setUserIDMode :: FileMode+setUserIDMode = (#const S_ISUID)++-- | Set group ID on execution.+setGroupIDMode :: FileMode+setGroupIDMode = (#const S_ISGID)++-- | Owner, group and others have read and write permission.+stdFileMode :: FileMode+stdFileMode = ownerReadMode  .|. ownerWriteMode .|. +	      groupReadMode  .|. groupWriteMode .|. +	      otherReadMode  .|. otherWriteMode++-- | Owner has read, write and execute permission.+ownerModes :: FileMode+ownerModes = (#const S_IRWXU)++-- | Group has read, write and execute permission.+groupModes :: FileMode+groupModes = (#const S_IRWXG)++-- | Others have read, write and execute permission.+otherModes :: FileMode+otherModes = (#const S_IRWXO)++-- | Owner, group and others have read, write and execute permission.+accessModes :: FileMode+accessModes = ownerModes .|. groupModes .|. otherModes++-- | Combines the two file modes into one that contains modes that appear in+-- either.+unionFileModes :: FileMode -> FileMode -> FileMode+unionFileModes m1 m2 = m1 .|. m2++-- | Combines two file modes into one that only contains modes that appear in+-- both.+intersectFileModes :: FileMode -> FileMode -> FileMode+intersectFileModes m1 m2 = m1 .&. m2++-- Not exported:+fileTypeModes :: FileMode+fileTypeModes = (#const S_IFMT)++blockSpecialMode :: FileMode+blockSpecialMode = (#const S_IFBLK)++characterSpecialMode :: FileMode+characterSpecialMode = (#const S_IFCHR)++namedPipeMode :: FileMode+namedPipeMode = (#const S_IFIFO)++regularFileMode :: FileMode+regularFileMode = (#const S_IFREG)++directoryMode :: FileMode+directoryMode = (#const S_IFDIR)++symbolicLinkMode :: FileMode+symbolicLinkMode = (#const S_IFLNK)++socketMode :: FileMode+socketMode = (#const S_IFSOCK)++-- | @setFileMode path mode@ changes permission of the file given by @path@+-- to @mode@. This operation may fail with 'throwErrnoPathIfMinus1_' if @path@+-- doesn't exist or if the effective user ID of the current process is not that+-- of the file's owner.+--+-- Note: calls @chmod@.+setFileMode :: FilePath -> FileMode -> IO ()+setFileMode name m =+  withCString name $ \s -> do+    throwErrnoPathIfMinus1_ "setFileMode" name (c_chmod s m)++-- | @setFdMode fd mode@ acts like 'setFileMode' but uses a file descriptor+-- @fd@ instead of a 'FilePath'.+--+-- Note: calls @fchmod@.+setFdMode :: Fd -> FileMode -> IO ()+setFdMode fd m =+  throwErrnoIfMinus1_ "setFdMode" (c_fchmod fd m)++foreign import ccall unsafe "fchmod" +  c_fchmod :: Fd -> CMode -> IO CInt++-- | @setFileCreationMask mode@ sets the file mode creation mask to @mode@.+-- Modes set by this operation are subtracted from files and directories upon+-- creation. The previous file creation mask is returned.+--+-- Note: calls @umask@.+setFileCreationMask :: FileMode -> IO FileMode+setFileCreationMask mask = c_umask mask++-- -----------------------------------------------------------------------------+-- access()++-- | @fileAccess name read write exec@ checks if the file (or other file system+-- object) @name@ can be accessed for reading, writing and\/or executing. To+-- check a permission set the corresponding argument to 'True'.+--+-- Note: calls @access@.+fileAccess :: FilePath -> Bool -> Bool -> Bool -> IO Bool+fileAccess name read write exec = access name flags+  where+   flags   = read_f .|. write_f .|. exec_f+   read_f  = if read  then (#const R_OK) else 0+   write_f = if write then (#const W_OK) else 0+   exec_f  = if exec  then (#const X_OK) else 0++-- | Checks for the existence of the file.+--+-- Note: calls @access@.+fileExist :: FilePath -> IO Bool+fileExist name = +  withCString name $ \s -> do+    r <- c_access s (#const F_OK)+    if (r == 0)+	then return True+	else do err <- getErrno+	        if (err == eNOENT)+		   then return False+		   else throwErrnoPath "fileExist" name++access :: FilePath -> CMode -> IO Bool+access name flags = +  withCString name $ \s -> do+    r <- c_access s flags+    if (r == 0)+	then return True+	else do err <- getErrno+	        if (err == eACCES)+		   then return False+		   else throwErrnoPath "fileAccess" name++-- -----------------------------------------------------------------------------+-- stat() support++-- | POSIX defines operations to get information, such as owner, permissions,+-- size and access times, about a file. This information is represented by the+-- 'FileStatus' type.+--+-- Note: see @chmod@.+newtype FileStatus = FileStatus (ForeignPtr CStat)++-- | ID of the device on which this file resides.+deviceID         :: FileStatus -> DeviceID+-- | inode number+fileID           :: FileStatus -> FileID+-- | File mode (such as permissions).+fileMode         :: FileStatus -> FileMode+-- | Number of hard links to this file.+linkCount        :: FileStatus -> LinkCount+-- | ID of owner.+fileOwner        :: FileStatus -> UserID+-- | ID of group.+fileGroup        :: FileStatus -> GroupID+-- | Describes the device that this file represents.+specialDeviceID  :: FileStatus -> DeviceID+-- | Size of the file in bytes. If this file is a symbolic link the size is+-- the length of the pathname it contains.+fileSize         :: FileStatus -> FileOffset+-- | Time of last access.+accessTime       :: FileStatus -> EpochTime+-- | Time of last modification.+modificationTime :: FileStatus -> EpochTime+-- | Time of last status change (i.e. owner, group, link count, mode, etc.).+statusChangeTime :: FileStatus -> EpochTime++deviceID (FileStatus stat) = +  unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_dev)+fileID (FileStatus stat) = +  unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_ino)+fileMode (FileStatus stat) =+  unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_mode)+linkCount (FileStatus stat) =+  unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_nlink)+fileOwner (FileStatus stat) =+  unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_uid)+fileGroup (FileStatus stat) =+  unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_gid)+specialDeviceID (FileStatus stat) =+  unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_rdev)+fileSize (FileStatus stat) =+  unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_size)+accessTime (FileStatus stat) =+  unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_atime)+modificationTime (FileStatus stat) =+  unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_mtime)+statusChangeTime (FileStatus stat) =+  unsafePerformIO $ withForeignPtr stat $ (#peek struct stat, st_ctime)++-- | Checks if this file is a block device.+isBlockDevice     :: FileStatus -> Bool+-- | Checks if this file is a character device.+isCharacterDevice :: FileStatus -> Bool+-- | Checks if this file is a named pipe device.+isNamedPipe       :: FileStatus -> Bool+-- | Checks if this file is a regular file device.+isRegularFile     :: FileStatus -> Bool+-- | Checks if this file is a directory device.+isDirectory       :: FileStatus -> Bool+-- | Checks if this file is a symbolic link device.+isSymbolicLink    :: FileStatus -> Bool+-- | Checks if this file is a socket device.+isSocket          :: FileStatus -> Bool++isBlockDevice stat = +  (fileMode stat `intersectFileModes` fileTypeModes) == blockSpecialMode+isCharacterDevice stat = +  (fileMode stat `intersectFileModes` fileTypeModes) == characterSpecialMode+isNamedPipe stat = +  (fileMode stat `intersectFileModes` fileTypeModes) == namedPipeMode+isRegularFile stat = +  (fileMode stat `intersectFileModes` fileTypeModes) == regularFileMode+isDirectory stat = +  (fileMode stat `intersectFileModes` fileTypeModes) == directoryMode+isSymbolicLink stat = +  (fileMode stat `intersectFileModes` fileTypeModes) == symbolicLinkMode+isSocket stat = +  (fileMode stat `intersectFileModes` fileTypeModes) == socketMode++-- | @getFileStatus path@ calls gets the @FileStatus@ information (user ID,+-- size, access times, etc.) for the file @path@.+--+-- Note: calls @stat@.+getFileStatus :: FilePath -> IO FileStatus+getFileStatus path = do+  fp <- mallocForeignPtrBytes (#const sizeof(struct stat)) +  withForeignPtr fp $ \p ->+    withCString path $ \s -> +      throwErrnoPathIfMinus1_ "getFileStatus" path (c_stat s p)+  return (FileStatus fp)++-- | @getFdStatus fd@ acts as 'getFileStatus' but uses a file descriptor @fd@.+--+-- Note: calls @fstat@.+getFdStatus :: Fd -> IO FileStatus+getFdStatus (Fd fd) = do+  fp <- mallocForeignPtrBytes (#const sizeof(struct stat)) +  withForeignPtr fp $ \p ->+    throwErrnoIfMinus1_ "getFdStatus" (c_fstat fd p)+  return (FileStatus fp)++-- | Acts as 'getFileStatus' except when the 'FilePath' refers to a symbolic+-- link. In that case the @FileStatus@ information of the symbolic link itself+-- is returned instead of that of the file it points to.+--+-- Note: calls @lstat@.+getSymbolicLinkStatus :: FilePath -> IO FileStatus+getSymbolicLinkStatus path = do+  fp <- mallocForeignPtrBytes (#const sizeof(struct stat)) +  withForeignPtr fp $ \p ->+    withCString path $ \s -> +      throwErrnoPathIfMinus1_ "getSymbolicLinkStatus" path (c_lstat s p)+  return (FileStatus fp)++foreign import ccall unsafe "lstat" +  c_lstat :: CString -> Ptr CStat -> IO CInt++-- | @createNamedPipe fifo mode@  +-- creates a new named pipe, @fifo@, with permissions based on+-- @mode@. May fail with 'throwErrnoPathIfMinus1_' if a file named @name@+-- already exists or if the effective user ID of the current process doesn't+-- have permission to create the pipe.+--+-- Note: calls @mkfifo@.+createNamedPipe :: FilePath -> FileMode -> IO ()+createNamedPipe name mode = do+  withCString name $ \s -> +    throwErrnoPathIfMinus1_ "createNamedPipe" name (c_mkfifo s mode)++-- | @createDevice path mode dev@ creates either a regular or a special file+-- depending on the value of @mode@ (and @dev@). May fail with+-- 'throwErrnoPathIfMinus1_' if a file named @name@ already exists or if the+-- effective user ID of the current process doesn't have permission to create+-- the file.+--+-- Note: calls @mknod@.+createDevice :: FilePath -> FileMode -> DeviceID -> IO ()+createDevice path mode dev =+  withCString path $ \s ->+    throwErrnoPathIfMinus1_ "createDevice" path (c_mknod s mode dev)++foreign import ccall unsafe "mknod" +  c_mknod :: CString -> CMode -> CDev -> IO CInt++-- -----------------------------------------------------------------------------+-- Hard links++-- | @createLink old new@ creates a new path, @new@, linked to an existing file,+-- @old@.+--+-- Note: calls @link@.+createLink :: FilePath -> FilePath -> IO ()+createLink name1 name2 =+  withCString name1 $ \s1 ->+  withCString name2 $ \s2 ->+  throwErrnoPathIfMinus1_ "createLink" name1 (c_link s1 s2)++-- | @removeLink path@ removes the link named @path@.+--+-- Note: calls @unlink@.+removeLink :: FilePath -> IO ()+removeLink name =+  withCString name $ \s ->+  throwErrnoPathIfMinus1_ "removeLink" name (c_unlink s)++-- -----------------------------------------------------------------------------+-- Symbolic Links++-- | @createSymbolicLink file1 file2@ creates a symbolic link named @file2@+-- which points to the file @file1@.+--+-- Symbolic links are interpreted at run-time as if the contents of the link+-- had been substituted into the path being followed to find a file or directory.+--+-- Note: calls @symlink@.+createSymbolicLink :: FilePath -> FilePath -> IO ()+createSymbolicLink file1 file2 =+  withCString file1 $ \s1 ->+  withCString file2 $ \s2 ->+  throwErrnoPathIfMinus1_ "createSymbolicLink" file1 (c_symlink s1 s2)++foreign import ccall unsafe "symlink"+  c_symlink :: CString -> CString -> IO CInt++-- ToDo: should really use SYMLINK_MAX, but not everyone supports it yet,+-- and it seems that the intention is that SYMLINK_MAX is no larger than+-- PATH_MAX.+#if !defined(PATH_MAX)+-- PATH_MAX is not defined on systems with unlimited path length.+-- Ugly.  Fix this.+#define PATH_MAX 4096+#endif++-- | Reads the @FilePath@ pointed to by the symbolic link and returns it.+--+-- Note: calls @readlink@.+readSymbolicLink :: FilePath -> IO FilePath+readSymbolicLink file =+  allocaArray0 (#const PATH_MAX) $ \buf -> do+    withCString file $ \s -> do+      len <- throwErrnoPathIfMinus1 "readSymbolicLink" file $ +	c_readlink s buf (#const PATH_MAX)+      peekCStringLen (buf,fromIntegral len)++foreign import ccall unsafe "readlink"+  c_readlink :: CString -> CString -> CInt -> IO CInt++-- -----------------------------------------------------------------------------+-- Renaming files++-- | @rename old new@ renames a file or directory from @old@ to @new@.+--+-- Note: calls @rename@.+rename :: FilePath -> FilePath -> IO ()+rename name1 name2 =+  withCString name1 $ \s1 ->+  withCString name2 $ \s2 ->+  throwErrnoPathIfMinus1_ "rename" name1 (c_rename s1 s2)++-- -----------------------------------------------------------------------------+-- chown()++-- | @setOwnerAndGroup path uid gid@ changes the owner and group of @path@ to+-- @uid@ and @gid@, respectively.+--+-- If @uid@ or @gid@ is specified as -1, then that ID is not changed.+--+-- Note: calls @chown@.+setOwnerAndGroup :: FilePath -> UserID -> GroupID -> IO ()+setOwnerAndGroup name uid gid = do+  withCString name $ \s ->+    throwErrnoPathIfMinus1_ "setOwnerAndGroup" name (c_chown s uid gid)++foreign import ccall unsafe "chown"+  c_chown :: CString -> CUid -> CGid -> IO CInt++-- | Acts as 'setOwnerAndGroup' but uses a file descriptor instead of a+-- 'FilePath'.+--+-- Note: calls @fchown@.+setFdOwnerAndGroup :: Fd -> UserID -> GroupID -> IO ()+setFdOwnerAndGroup (Fd fd) uid gid = +  throwErrnoIfMinus1_ "setFdOwnerAndGroup" (c_fchown fd uid gid)++foreign import ccall unsafe "fchown"+  c_fchown :: CInt -> CUid -> CGid -> IO CInt++#if HAVE_LCHOWN+-- | Acts as 'setOwnerAndGroup' but does not follow symlinks (and thus+-- changes permissions on the link itself).+--+-- Note: calls @lchown@.+setSymbolicLinkOwnerAndGroup :: FilePath -> UserID -> GroupID -> IO ()+setSymbolicLinkOwnerAndGroup name uid gid = do+  withCString name $ \s ->+    throwErrnoPathIfMinus1_ "setSymbolicLinkOwnerAndGroup" name+	(c_lchown s uid gid)++foreign import ccall unsafe "lchown"+  c_lchown :: CString -> CUid -> CGid -> IO CInt+#endif++-- -----------------------------------------------------------------------------+-- utime()++-- | @setFileTimes path atime mtime@ sets the access and modification times+-- associated with file @path@ to @atime@ and @mtime@, respectively.+--+-- Note: calls @utime@.+setFileTimes :: FilePath -> EpochTime -> EpochTime -> IO ()+setFileTimes name atime mtime = do+  withCString name $ \s ->+   allocaBytes (#const sizeof(struct utimbuf)) $ \p -> do+     (#poke struct utimbuf, actime)  p atime+     (#poke struct utimbuf, modtime) p mtime+     throwErrnoPathIfMinus1_ "setFileTimes" name (c_utime s p)++-- | @touchFile path@ sets the access and modification times associated with+-- file @path@ to the current time.+--+-- Note: calls @utime@.+touchFile :: FilePath -> IO ()+touchFile name = do+  withCString name $ \s ->+   throwErrnoPathIfMinus1_ "touchFile" name (c_utime s nullPtr)++-- -----------------------------------------------------------------------------+-- Setting file sizes++-- | Truncates the file down to the specified length. If the file was larger+-- than the given length before this operation was performed the extra is lost.+--+-- Note: calls @truncate@.+setFileSize :: FilePath -> FileOffset -> IO ()+setFileSize file off = +  withCString file $ \s ->+    throwErrnoPathIfMinus1_ "setFileSize" file (c_truncate s off)++foreign import ccall unsafe "truncate"+  c_truncate :: CString -> COff -> IO CInt++-- | Acts as 'setFileSize' but uses a file descriptor instead of a 'FilePath'.+--+-- Note: calls @ftruncate@.+setFdSize :: Fd -> FileOffset -> IO ()+setFdSize (Fd fd) off =+  throwErrnoIfMinus1_ "setFdSize" (c_ftruncate fd off)++-- -----------------------------------------------------------------------------+-- pathconf()/fpathconf() support++data PathVar+  = FileSizeBits		  {- _PC_FILESIZEBITS     -}+  | LinkLimit                     {- _PC_LINK_MAX         -}+  | InputLineLimit                {- _PC_MAX_CANON        -}+  | InputQueueLimit               {- _PC_MAX_INPUT        -}+  | FileNameLimit                 {- _PC_NAME_MAX         -}+  | PathNameLimit                 {- _PC_PATH_MAX         -}+  | PipeBufferLimit               {- _PC_PIPE_BUF         -}+				  -- These are described as optional in POSIX:+  				  {- _PC_ALLOC_SIZE_MIN     -}+  				  {- _PC_REC_INCR_XFER_SIZE -}+  				  {- _PC_REC_MAX_XFER_SIZE  -}+  				  {- _PC_REC_MIN_XFER_SIZE  -}+ 				  {- _PC_REC_XFER_ALIGN     -}+  | SymbolicLinkLimit		  {- _PC_SYMLINK_MAX      -}+  | SetOwnerAndGroupIsRestricted  {- _PC_CHOWN_RESTRICTED -}+  | FileNamesAreNotTruncated      {- _PC_NO_TRUNC         -}+  | VDisableChar		  {- _PC_VDISABLE         -}+  | AsyncIOAvailable		  {- _PC_ASYNC_IO         -}+  | PrioIOAvailable		  {- _PC_PRIO_IO          -}+  | SyncIOAvailable		  {- _PC_SYNC_IO          -}++pathVarConst :: PathVar -> CInt+pathVarConst v = case v of+	LinkLimit     			-> (#const _PC_LINK_MAX)+	InputLineLimit			-> (#const _PC_MAX_CANON)+	InputQueueLimit			-> (#const _PC_MAX_INPUT)+	FileNameLimit			-> (#const _PC_NAME_MAX)+	PathNameLimit			-> (#const _PC_PATH_MAX)+	PipeBufferLimit			-> (#const _PC_PIPE_BUF)+	SetOwnerAndGroupIsRestricted	-> (#const _PC_CHOWN_RESTRICTED)+	FileNamesAreNotTruncated	-> (#const _PC_NO_TRUNC)+	VDisableChar			-> (#const _PC_VDISABLE)++#ifdef _PC_SYNC_IO+	SyncIOAvailable		-> (#const _PC_SYNC_IO)+#else+	SyncIOAvailable		-> error "_PC_SYNC_IO not available"+#endif++#ifdef _PC_ASYNC_IO+	AsyncIOAvailable	-> (#const _PC_ASYNC_IO)+#else+	AsyncIOAvailable	-> error "_PC_ASYNC_IO not available"+#endif++#ifdef _PC_PRIO_IO+	PrioIOAvailable		-> (#const _PC_PRIO_IO)+#else+	PrioIOAvailable		-> error "_PC_PRIO_IO not available"+#endif++#if _PC_FILESIZEBITS+	FileSizeBits		-> (#const _PC_FILESIZEBITS)+#else+	FileSizeBits		-> error "_PC_FILESIZEBITS not available"+#endif++#if _PC_SYMLINK_MAX+	SymbolicLinkLimit	-> (#const _PC_SYMLINK_MAX)+#else+	SymbolicLinkLimit	-> error "_PC_SYMLINK_MAX not available"+#endif+++-- | @getPathVar var path@ obtains the dynamic value of the requested+-- configurable file limit or option associated with file or directory @path@.+-- For defined file limits, @getPathVar@ returns the associated+-- value.  For defined file options, the result of @getPathVar@+-- is undefined, but not failure.+--+-- Note: calls @pathconf@.+getPathVar :: FilePath -> PathVar -> IO Limit+getPathVar name v = do+  withCString name $ \ nameP -> +    throwErrnoPathIfMinus1 "getPathVar" name $ +      c_pathconf nameP (pathVarConst v)++foreign import ccall unsafe "pathconf" +  c_pathconf :: CString -> CInt -> IO CLong+++-- | @getFdPathVar var fd@ obtains the dynamic value of the requested+-- configurable file limit or option associated with the file or directory+-- attached to the open channel @fd@. For defined file limits, @getFdPathVar@+-- returns the associated value.  For defined file options, the result of+-- @getFdPathVar@ is undefined, but not failure.+--+-- Note: calls @fpathconf@.+getFdPathVar :: Fd -> PathVar -> IO Limit+getFdPathVar fd v =+    throwErrnoIfMinus1 "getFdPathVar" $ +      c_fpathconf fd (pathVarConst v)++foreign import ccall unsafe "fpathconf" +  c_fpathconf :: Fd -> CInt -> IO CLong
+ System/Posix/IO.hsc view
@@ -0,0 +1,376 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.IO+-- Copyright   :  (c) The University of Glasgow 2002+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- POSIX IO support.  These types and functions correspond to the unix+-- functions open(2), close(2), etc.  For more portable functions+-- which are more like fopen(3) and friends from stdio.h, see+-- 'System.IO'.+--+-----------------------------------------------------------------------------++module System.Posix.IO (+    -- * Input \/ Output++    -- ** Standard file descriptors+    stdInput, stdOutput, stdError,++    -- ** Opening and closing files+    OpenMode(..),+    OpenFileFlags(..), defaultFileFlags,+    openFd, createFile,+    closeFd,++    -- ** Reading\/writing data+    -- |Programmers using the 'fdRead' and 'fdWrite' API should be aware that+    -- EAGAIN exceptions may occur for non-blocking IO!++    fdRead, fdWrite,++    -- ** Seeking+    fdSeek,++    -- ** File options+    FdOption(..),+    queryFdOption,+    setFdOption,++    -- ** Locking+    FileLock,+    LockRequest(..),+    getLock,  setLock,+    waitToSetLock,++    -- ** Pipes+    createPipe,++    -- ** Duplicating file descriptors+    dup, dupTo,++    -- ** Converting file descriptors to\/from Handles+    handleToFd,+    fdToHandle,  ++  ) where++import System.IO+import System.IO.Error+import System.Posix.Types+import System.Posix.Error+import System.Posix.Internals++import Foreign+import Foreign.C+import Data.Bits++#ifdef __GLASGOW_HASKELL__+import GHC.IOBase+import GHC.Handle hiding (fdToHandle, openFd)+import qualified GHC.Handle+#endif++#ifdef __HUGS__+import Hugs.Prelude (IOException(..), IOErrorType(..))+import qualified Hugs.IO (handleToFd, openFd)+#endif++#include "HsUnix.h"++-- -----------------------------------------------------------------------------+-- Pipes+-- |The 'createPipe' function creates a pair of connected file+-- descriptors. The first component is the fd to read from, the second+-- is the write end.  Although pipes may be bidirectional, this+-- behaviour is not portable and programmers should use two separate+-- pipes for this purpose.  May throw an exception if this is an+-- invalid descriptor.++createPipe :: IO (Fd, Fd)+createPipe =+  allocaArray 2 $ \p_fd -> do+    throwErrnoIfMinus1_ "createPipe" (c_pipe p_fd)+    rfd <- peekElemOff p_fd 0+    wfd <- peekElemOff p_fd 1+    return (Fd rfd, Fd wfd)++-- -----------------------------------------------------------------------------+-- Duplicating file descriptors++-- | May throw an exception if this is an invalid descriptor.+dup :: Fd -> IO Fd+dup (Fd fd) = do r <- throwErrnoIfMinus1 "dup" (c_dup fd); return (Fd r)++-- | May throw an exception if this is an invalid descriptor.+dupTo :: Fd -> Fd -> IO Fd+dupTo (Fd fd1) (Fd fd2) = do+  r <- throwErrnoIfMinus1 "dupTo" (c_dup2 fd1 fd2)+  return (Fd r)++-- -----------------------------------------------------------------------------+-- Opening and closing files++stdInput, stdOutput, stdError :: Fd+stdInput   = Fd (#const STDIN_FILENO)+stdOutput  = Fd (#const STDOUT_FILENO)+stdError   = Fd (#const STDERR_FILENO)++data OpenMode = ReadOnly | WriteOnly | ReadWrite++-- |Correspond to some of the int flags from C's fcntl.h.+data OpenFileFlags =+ OpenFileFlags {+    append    :: Bool, -- ^ O_APPEND+    exclusive :: Bool, -- ^ O_EXCL+    noctty    :: Bool, -- ^ O_NOCTTY+    nonBlock  :: Bool, -- ^ O_NONBLOCK+    trunc     :: Bool  -- ^ O_TRUNC+ }+++-- |Default values for the 'OpenFileFlags' type. False for each of+-- append, exclusive, noctty, nonBlock, and trunc.+defaultFileFlags :: OpenFileFlags+defaultFileFlags =+ OpenFileFlags {+    append    = False,+    exclusive = False,+    noctty    = False,+    nonBlock  = False,+    trunc     = False+  }+++-- |Open and optionally create this file.  See 'System.Posix.Files'+-- for information on how to use the 'FileMode' type.+openFd :: FilePath+       -> OpenMode+       -> Maybe FileMode -- ^Just x => creates the file with the given modes, Nothing => the file must exist.+       -> OpenFileFlags+       -> IO Fd+openFd name how maybe_mode (OpenFileFlags append exclusive noctty+				nonBlock truncate) = do+   withCString name $ \s -> do+    fd <- throwErrnoPathIfMinus1 "openFd" name (c_open s all_flags mode_w)+    return (Fd fd)+  where+    all_flags  = creat .|. flags .|. open_mode++    flags =+       (if append    then (#const O_APPEND)   else 0) .|.+       (if exclusive then (#const O_EXCL)     else 0) .|.+       (if noctty    then (#const O_NOCTTY)   else 0) .|.+       (if nonBlock  then (#const O_NONBLOCK) else 0) .|.+       (if truncate  then (#const O_TRUNC)    else 0)++    (creat, mode_w) = case maybe_mode of +			Nothing -> (0,0)+			Just x  -> ((#const O_CREAT), x)++    open_mode = case how of+		   ReadOnly  -> (#const O_RDONLY)+		   WriteOnly -> (#const O_WRONLY)+		   ReadWrite -> (#const O_RDWR)++-- |Create and open this file in WriteOnly mode.  A special case of+-- 'openFd'.  See 'System.Posix.Files' for information on how to use+-- the 'FileMode' type.++createFile :: FilePath -> FileMode -> IO Fd+createFile name mode+  = openFd name WriteOnly (Just mode) defaultFileFlags{ trunc=True } ++-- |Close this file descriptor.  May throw an exception if this is an+-- invalid descriptor.++closeFd :: Fd -> IO ()+closeFd (Fd fd) = throwErrnoIfMinus1_ "closeFd" (c_close fd)++-- -----------------------------------------------------------------------------+-- Converting file descriptors to/from Handles++-- | Extracts the 'Fd' from a 'Handle'.  This function has the side effect+-- of closing the 'Handle' and flushing its write buffer, if necessary.+handleToFd :: Handle -> IO Fd++-- | Converts an 'Fd' into a 'Handle' that can be used with the+-- standard Haskell IO library (see "System.IO").  +--+-- GHC only: this function has the side effect of putting the 'Fd'+-- into non-blocking mode (@O_NONBLOCK@) due to the way the standard+-- IO library implements multithreaded I\/O.+--+fdToHandle :: Fd -> IO Handle++#ifdef __GLASGOW_HASKELL__+handleToFd h = withHandle "handleToFd" h $ \ h_ -> do+  -- converting a Handle into an Fd effectively means+  -- letting go of the Handle; it is put into a closed+  -- state as a result. +  let fd = haFD h_+  flushWriteBufferOnly h_+  unlockFile (fromIntegral fd)+    -- setting the Handle's fd to (-1) as well as its 'type'+    -- to closed, is enough to disable the finalizer that+    -- eventually is run on the Handle.+  return (h_{haFD= (-1),haType=ClosedHandle}, Fd (fromIntegral fd))++fdToHandle fd = GHC.Handle.fdToHandle (fromIntegral fd)+#endif++#ifdef __HUGS__+handleToFd h = do+  fd <- Hugs.IO.handleToFd h+  return (fromIntegral fd)++fdToHandle fd = do+  mode <- fdGetMode (fromIntegral fd)+  Hugs.IO.openFd (fromIntegral fd) False mode True+#endif++-- -----------------------------------------------------------------------------+-- Fd options++data FdOption = AppendOnWrite     -- ^O_APPEND+	      | CloseOnExec       -- ^FD_CLOEXEC+	      | NonBlockingRead   -- ^O_NONBLOCK+	      | SynchronousWrites -- ^O_SYNC++fdOption2Int :: FdOption -> CInt+fdOption2Int CloseOnExec       = (#const FD_CLOEXEC)+fdOption2Int AppendOnWrite     = (#const O_APPEND)+fdOption2Int NonBlockingRead   = (#const O_NONBLOCK)+fdOption2Int SynchronousWrites = (#const O_SYNC)++-- | May throw an exception if this is an invalid descriptor.+queryFdOption :: Fd -> FdOption -> IO Bool+queryFdOption (Fd fd) opt = do+  r <- throwErrnoIfMinus1 "queryFdOption" (c_fcntl_read fd flag)+  return ((r .&. fdOption2Int opt) /= 0)+ where+  flag    = case opt of+	      CloseOnExec       -> (#const F_GETFD)+	      other		-> (#const F_GETFL)++-- | May throw an exception if this is an invalid descriptor.+setFdOption :: Fd -> FdOption -> Bool -> IO ()+setFdOption (Fd fd) opt val = do+  r <- throwErrnoIfMinus1 "setFdOption" (c_fcntl_read fd getflag)+  let r' | val       = r .|. opt_val+	 | otherwise = r .&. (complement opt_val)+  throwErrnoIfMinus1_ "setFdOption" (c_fcntl_write fd setflag r')+ where+  (getflag,setflag)= case opt of+	      CloseOnExec       -> ((#const F_GETFD),(#const F_SETFD)) +	      other		-> ((#const F_GETFL),(#const F_SETFL))+  opt_val = fdOption2Int opt++-- -----------------------------------------------------------------------------+-- Seeking ++mode2Int :: SeekMode -> CInt+mode2Int AbsoluteSeek = (#const SEEK_SET)+mode2Int RelativeSeek = (#const SEEK_CUR)+mode2Int SeekFromEnd  = (#const SEEK_END)++-- | May throw an exception if this is an invalid descriptor.+fdSeek :: Fd -> SeekMode -> FileOffset -> IO FileOffset+fdSeek (Fd fd) mode off =+  throwErrnoIfMinus1 "fdSeek" (c_lseek fd off (mode2Int mode))++-- -----------------------------------------------------------------------------+-- Locking++data LockRequest = ReadLock+                 | WriteLock+                 | Unlock++type FileLock = (LockRequest, SeekMode, FileOffset, FileOffset)++-- | May throw an exception if this is an invalid descriptor.+getLock :: Fd -> FileLock -> IO (Maybe (ProcessID, FileLock))+getLock (Fd fd) lock =+  allocaLock lock $ \p_flock -> do+    throwErrnoIfMinus1_ "getLock" (c_fcntl_lock fd (#const F_GETLK) p_flock)+    result <- bytes2ProcessIDAndLock p_flock+    return (maybeResult result)+  where+    maybeResult (_, (Unlock, _, _, _)) = Nothing+    maybeResult x = Just x++allocaLock :: FileLock -> (Ptr CFLock -> IO a) -> IO a+allocaLock (lockreq, mode, start, len) io = +  allocaBytes (#const sizeof(struct flock)) $ \p -> do+    (#poke struct flock, l_type)   p (lockReq2Int lockreq :: CShort)+    (#poke struct flock, l_whence) p (fromIntegral (mode2Int mode) :: CShort)+    (#poke struct flock, l_start)  p start+    (#poke struct flock, l_len)    p len+    io p++lockReq2Int :: LockRequest -> CShort+lockReq2Int ReadLock  = (#const F_RDLCK)+lockReq2Int WriteLock = (#const F_WRLCK)+lockReq2Int Unlock    = (#const F_UNLCK)++bytes2ProcessIDAndLock :: Ptr CFLock -> IO (ProcessID, FileLock)+bytes2ProcessIDAndLock p = do+  req   <- (#peek struct flock, l_type)   p+  mode  <- (#peek struct flock, l_whence) p+  start <- (#peek struct flock, l_start)  p+  len   <- (#peek struct flock, l_len)    p+  pid   <- (#peek struct flock, l_pid)    p+  return (pid, (int2req req, int2mode mode, start, len))+ where+  int2req :: CShort -> LockRequest+  int2req (#const F_RDLCK) = ReadLock+  int2req (#const F_WRLCK) = WriteLock+  int2req (#const F_UNLCK) = Unlock+  int2req _ = error $ "int2req: bad argument"++  int2mode :: CShort -> SeekMode+  int2mode (#const SEEK_SET) = AbsoluteSeek+  int2mode (#const SEEK_CUR) = RelativeSeek+  int2mode (#const SEEK_END) = SeekFromEnd+  int2mode _ = error $ "int2mode: bad argument"++-- | May throw an exception if this is an invalid descriptor.+setLock :: Fd -> FileLock -> IO ()+setLock (Fd fd) lock = do+  allocaLock lock $ \p_flock ->+    throwErrnoIfMinus1_ "setLock" (c_fcntl_lock fd (#const F_SETLK) p_flock)++-- | May throw an exception if this is an invalid descriptor.+waitToSetLock :: Fd -> FileLock -> IO ()+waitToSetLock (Fd fd) lock = do+  allocaLock lock $ \p_flock ->+    throwErrnoIfMinus1_ "waitToSetLock" +	(c_fcntl_lock fd (#const F_SETLKW) p_flock)++-- -----------------------------------------------------------------------------+-- fd{Read,Write}++-- | May throw an exception if this is an invalid descriptor.+fdRead :: Fd+       -> ByteCount -- ^How many bytes to read+       -> IO (String, ByteCount) -- ^The bytes read, how many bytes were read.+fdRead _fd 0 = return ("", 0)+fdRead (Fd fd) nbytes = do+    allocaBytes (fromIntegral nbytes) $ \ bytes -> do+    rc    <-  throwErrnoIfMinus1Retry "fdRead" (c_read fd bytes nbytes)+    case fromIntegral rc of+      0 -> ioError (IOError Nothing EOF "fdRead" "EOF" Nothing)+      n -> do+       s <- peekCStringLen (bytes, fromIntegral n)+       return (s, n)++-- | May throw an exception if this is an invalid descriptor.+fdWrite :: Fd -> String -> IO ByteCount+fdWrite (Fd fd) str = withCStringLen str $ \ (strPtr,len) -> do+    rc <- throwErrnoIfMinus1Retry "fdWrite" (c_write fd strPtr (fromIntegral len))+    return (fromIntegral rc)
+ System/Posix/Process.hsc view
@@ -0,0 +1,424 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.Process+-- Copyright   :  (c) The University of Glasgow 2002+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- POSIX process support+--+-----------------------------------------------------------------------------++module System.Posix.Process (+    -- * Processes++    -- ** Forking and executing+#ifdef __GLASGOW_HASKELL__+    forkProcess,+#endif+    executeFile,+    +    -- ** Exiting+    exitImmediately,++    -- ** Process environment+    getProcessID,+    getParentProcessID,+    getProcessGroupID,++    -- ** Process groups+    createProcessGroup,+    joinProcessGroup,+    setProcessGroupID,++    -- ** Sessions+    createSession,++    -- ** Process times+    ProcessTimes(..),+    getProcessTimes,++    -- ** Scheduling priority+    nice,+    getProcessPriority,+    getProcessGroupPriority,+    getUserPriority,+    setProcessPriority,+    setProcessGroupPriority,+    setUserPriority,++    -- ** Process status+    ProcessStatus(..),+    getProcessStatus,+    getAnyProcessStatus,+    getGroupProcessStatus,++ ) where++#include "HsUnix.h"++import Foreign.C.Error+import Foreign.C.String ( CString, withCString )+import Foreign.C.Types ( CInt, CClock )+import Foreign.Marshal.Alloc ( alloca, allocaBytes )+import Foreign.Marshal.Array ( withArray0 )+import Foreign.Marshal.Utils ( withMany )+import Foreign.Ptr ( Ptr, nullPtr )+import Foreign.StablePtr ( StablePtr, newStablePtr, freeStablePtr )+import Foreign.Storable ( Storable(..) )+import System.IO+import System.IO.Error+import System.Exit+import System.Posix.Error+import System.Posix.Types+import System.Posix.Signals+import System.Process.Internals ( pPrPr_disableITimers, c_execvpe )+import Control.Monad++#ifdef __GLASGOW_HASKELL__+import GHC.TopHandler	( runIO )+#endif++#ifdef __HUGS__+{-# CFILES cbits/HsUnix.c  #-}+#endif++-- -----------------------------------------------------------------------------+-- Process environment++-- | 'getProcessID' calls @getpid@ to obtain the 'ProcessID' for+--   the current process.+getProcessID :: IO ProcessID+getProcessID = c_getpid++foreign import ccall unsafe "getpid"+   c_getpid :: IO CPid++-- | 'getProcessID' calls @getppid@ to obtain the 'ProcessID' for+--   the parent of the current process.+getParentProcessID :: IO ProcessID+getParentProcessID = c_getppid++foreign import ccall unsafe "getppid"+  c_getppid :: IO CPid++-- | 'getProcessGroupID' calls @getpgrp@ to obtain the+--   'ProcessGroupID' for the current process.+getProcessGroupID :: IO ProcessGroupID+getProcessGroupID = c_getpgrp++foreign import ccall unsafe "getpgrp"+  c_getpgrp :: IO CPid++-- | @'createProcessGroup' pid@ calls @setpgid@ to make+--   process @pid@ a new process group leader.+createProcessGroup :: ProcessID -> IO ProcessGroupID+createProcessGroup pid = do+  throwErrnoIfMinus1_ "createProcessGroup" (c_setpgid pid 0)+  return pid++-- | @'joinProcessGroup' pgid@ calls @setpgid@ to set the+--   'ProcessGroupID' of the current process to @pgid@.+joinProcessGroup :: ProcessGroupID -> IO ()+joinProcessGroup pgid =+  throwErrnoIfMinus1_ "joinProcessGroup" (c_setpgid 0 pgid)++-- | @'setProcessGroupID' pid pgid@ calls @setpgid@ to set the+--   'ProcessGroupID' for process @pid@ to @pgid@.+setProcessGroupID :: ProcessID -> ProcessGroupID -> IO ()+setProcessGroupID pid pgid =+  throwErrnoIfMinus1_ "setProcessGroupID" (c_setpgid pid pgid)++foreign import ccall unsafe "setpgid"+  c_setpgid :: CPid -> CPid -> IO CInt++-- | 'createSession' calls @setsid@ to create a new session+--   with the current process as session leader.+createSession :: IO ProcessGroupID+createSession = throwErrnoIfMinus1 "createSession" c_setsid++foreign import ccall unsafe "setsid"+  c_setsid :: IO CPid++-- -----------------------------------------------------------------------------+-- Process times++-- All times in clock ticks (see getClockTick)++data ProcessTimes+  = ProcessTimes { elapsedTime     :: ClockTick+  		 , userTime        :: ClockTick+		 , systemTime      :: ClockTick+		 , childUserTime   :: ClockTick+		 , childSystemTime :: ClockTick+		 }++-- | 'getProcessTimes' calls @times@ to obtain time-accounting+--   information for the current process and its children.+getProcessTimes :: IO ProcessTimes+getProcessTimes = do+   allocaBytes (#const sizeof(struct tms)) $ \p_tms -> do+     elapsed <- throwErrnoIfMinus1 "getProcessTimes" (c_times p_tms)+     ut  <- (#peek struct tms, tms_utime)  p_tms+     st  <- (#peek struct tms, tms_stime)  p_tms+     cut <- (#peek struct tms, tms_cutime) p_tms+     cst <- (#peek struct tms, tms_cstime) p_tms+     return (ProcessTimes{ elapsedTime     = elapsed,+	 		   userTime        = ut,+	 		   systemTime      = st,+	 		   childUserTime   = cut,+	 		   childSystemTime = cst+			  })++type CTms = ()++foreign import ccall unsafe "times"+  c_times :: Ptr CTms -> IO CClock++-- -----------------------------------------------------------------------------+-- Process scheduling priority++nice :: Int -> IO ()+nice prio = do+  resetErrno+  res <- c_nice (fromIntegral prio)+  when (res == -1) $ do+    err <- getErrno+    when (err /= eOK) (throwErrno "nice")++foreign import ccall unsafe "nice"+  c_nice :: CInt -> IO CInt++getProcessPriority      :: ProcessID      -> IO Int+getProcessGroupPriority :: ProcessGroupID -> IO Int+getUserPriority         :: UserID         -> IO Int++getProcessPriority pid = do+  r <- throwErrnoIfMinus1 "getProcessPriority" $+         c_getpriority (#const PRIO_PROCESS) (fromIntegral pid)+  return (fromIntegral r)++getProcessGroupPriority pid = do+  r <- throwErrnoIfMinus1 "getProcessPriority" $+         c_getpriority (#const PRIO_PGRP) (fromIntegral pid)+  return (fromIntegral r)++getUserPriority uid = do+  r <- throwErrnoIfMinus1 "getUserPriority" $+         c_getpriority (#const PRIO_USER) (fromIntegral uid)+  return (fromIntegral r)++foreign import ccall unsafe "getpriority"+  c_getpriority :: CInt -> CInt -> IO CInt++setProcessPriority      :: ProcessID      -> Int -> IO ()+setProcessGroupPriority :: ProcessGroupID -> Int -> IO ()+setUserPriority         :: UserID         -> Int -> IO ()++setProcessPriority pid val = +  throwErrnoIfMinus1_ "setProcessPriority" $+    c_setpriority (#const PRIO_PROCESS) (fromIntegral pid) (fromIntegral val)++setProcessGroupPriority pid val =+  throwErrnoIfMinus1_ "setProcessPriority" $+    c_setpriority (#const PRIO_PGRP) (fromIntegral pid) (fromIntegral val)++setUserPriority uid val =+  throwErrnoIfMinus1_ "setUserPriority" $+    c_setpriority (#const PRIO_USER) (fromIntegral uid) (fromIntegral val)++foreign import ccall unsafe "setpriority"+  c_setpriority :: CInt -> CInt -> CInt -> IO CInt++-- -----------------------------------------------------------------------------+-- Forking, execution++#ifdef __GLASGOW_HASKELL__+{- | 'forkProcess' corresponds to the POSIX @fork@ system call.+The 'IO' action passed as an argument is executed in the child process; no other+threads will be copied to the child process.+On success, 'forkProcess' returns the child's 'ProcessID' to the parent process;+in case of an error, an exception is thrown.+-}++forkProcess :: IO () -> IO ProcessID+forkProcess action = do+  stable <- newStablePtr (runIO action)+  pid <- throwErrnoIfMinus1 "forkProcess" (forkProcessPrim stable)+  freeStablePtr stable+  return $ fromIntegral pid++foreign import ccall "forkProcess" forkProcessPrim :: StablePtr (IO ()) -> IO CPid+#endif /* __GLASGOW_HASKELL__ */++-- | @'executeFile' cmd args env@ calls one of the+--   @execv*@ family, depending on whether or not the current+--   PATH is to be searched for the command, and whether or not an+--   environment is provided to supersede the process's current+--   environment.  The basename (leading directory names suppressed) of+--   the command is passed to @execv*@ as @arg[0]@;+--   the argument list passed to 'executeFile' therefore +--   begins with @arg[1]@.+executeFile :: FilePath			    -- ^ Command+            -> Bool			    -- ^ Search PATH?+            -> [String]			    -- ^ Arguments+            -> Maybe [(String, String)]	    -- ^ Environment+            -> IO ()+executeFile path search args Nothing = do+  withCString path $ \s ->+    withMany withCString (path:args) $ \cstrs ->+      withArray0 nullPtr cstrs $ \arr -> do+	pPrPr_disableITimers+	if search +	   then throwErrnoPathIfMinus1_ "executeFile" path (c_execvp s arr)+	   else throwErrnoPathIfMinus1_ "executeFile" path (c_execv s arr)++executeFile path search args (Just env) = do+  withCString path $ \s ->+    withMany withCString (path:args) $ \cstrs ->+      withArray0 nullPtr cstrs $ \arg_arr ->+    let env' = map (\ (name, val) -> name ++ ('=' : val)) env in+    withMany withCString env' $ \cenv ->+      withArray0 nullPtr cenv $ \env_arr -> do+	pPrPr_disableITimers+	if search +	   then throwErrnoPathIfMinus1_ "executeFile" path+		   (c_execvpe s arg_arr env_arr)+	   else throwErrnoPathIfMinus1_ "executeFile" path+		   (c_execve s arg_arr env_arr)++foreign import ccall unsafe "execvp"+  c_execvp :: CString -> Ptr CString -> IO CInt++foreign import ccall unsafe "execv"+  c_execv :: CString -> Ptr CString -> IO CInt++foreign import ccall unsafe "execve"+  c_execve :: CString -> Ptr CString -> Ptr CString -> IO CInt++-- -----------------------------------------------------------------------------+-- Waiting for process termination++data ProcessStatus = Exited ExitCode+                   | Terminated Signal+                   | Stopped Signal+		   deriving (Eq, Ord, Show)++-- | @'getProcessStatus' blk stopped pid@ calls @waitpid@, returning+--   @'Just' tc@, the 'ProcessStatus' for process @pid@ if it is+--   available, 'Nothing' otherwise.  If @blk@ is 'False', then+--   @WNOHANG@ is set in the options for @waitpid@, otherwise not.+--   If @stopped@ is 'True', then @WUNTRACED@ is set in the+--   options for @waitpid@, otherwise not.+getProcessStatus :: Bool -> Bool -> ProcessID -> IO (Maybe ProcessStatus)+getProcessStatus block stopped pid =+  alloca $ \wstatp -> do+    pid <- throwErrnoIfMinus1Retry "getProcessStatus"+		(c_waitpid pid wstatp (waitOptions block stopped))+    case pid of+      0  -> return Nothing+      _  -> do ps <- decipherWaitStatus wstatp+	       return (Just ps)++-- safe, because this call might block+foreign import ccall safe "waitpid"+  c_waitpid :: CPid -> Ptr CInt -> CInt -> IO CPid++-- | @'getGroupProcessStatus' blk stopped pgid@ calls @waitpid@,+--   returning @'Just' (pid, tc)@, the 'ProcessID' and+--   'ProcessStatus' for any process in group @pgid@ if one is+--   available, 'Nothing' otherwise.  If @blk@ is 'False', then+--   @WNOHANG@ is set in the options for @waitpid@, otherwise not.+--   If @stopped@ is 'True', then @WUNTRACED@ is set in the+--   options for @waitpid@, otherwise not.+getGroupProcessStatus :: Bool+                      -> Bool+                      -> ProcessGroupID+                      -> IO (Maybe (ProcessID, ProcessStatus))+getGroupProcessStatus block stopped pgid =+  alloca $ \wstatp -> do+    pid <- throwErrnoIfMinus1Retry "getGroupProcessStatus"+		(c_waitpid (-pgid) wstatp (waitOptions block stopped))+    case pid of+      0  -> return Nothing+      _  -> do ps <- decipherWaitStatus wstatp+	       return (Just (pid, ps))+-- | @'getAnyProcessStatus' blk stopped@ calls @waitpid@, returning+--   @'Just' (pid, tc)@, the 'ProcessID' and 'ProcessStatus' for any+--   child process if one is available, 'Nothing' otherwise.  If+--   @blk@ is 'False', then @WNOHANG@ is set in the options for+--   @waitpid@, otherwise not.  If @stopped@ is 'True', then+--   @WUNTRACED@ is set in the options for @waitpid@, otherwise not.+getAnyProcessStatus :: Bool -> Bool -> IO (Maybe (ProcessID, ProcessStatus))+getAnyProcessStatus block stopped = getGroupProcessStatus block stopped 1++waitOptions :: Bool -> Bool -> CInt+--             block   stopped+waitOptions False False = (#const WNOHANG)+waitOptions False True  = (#const (WNOHANG|WUNTRACED))+waitOptions True  False = 0+waitOptions True  True  = (#const WUNTRACED)++-- Turn a (ptr to a) wait status into a ProcessStatus++decipherWaitStatus :: Ptr CInt -> IO ProcessStatus+decipherWaitStatus wstatp = do+  wstat <- peek wstatp+  if c_WIFEXITED wstat /= 0+      then do+        let exitstatus = c_WEXITSTATUS wstat+        if exitstatus == 0+	   then return (Exited ExitSuccess)+	   else return (Exited (ExitFailure (fromIntegral exitstatus)))+      else do+        if c_WIFSIGNALED wstat /= 0+	   then do+		let termsig = c_WTERMSIG wstat+		return (Terminated (fromIntegral termsig))+	   else do+		if c_WIFSTOPPED wstat /= 0+		   then do+			let stopsig = c_WSTOPSIG wstat+			return (Stopped (fromIntegral stopsig))+		   else do+			ioError (mkIOError illegalOperationErrorType+				   "waitStatus" Nothing Nothing)++foreign import ccall unsafe "__hsunix_wifexited"+  c_WIFEXITED :: CInt -> CInt ++foreign import ccall unsafe "__hsunix_wexitstatus"+  c_WEXITSTATUS :: CInt -> CInt++foreign import ccall unsafe "__hsunix_wifsignaled"+  c_WIFSIGNALED :: CInt -> CInt++foreign import ccall unsafe "__hsunix_wtermsig"+  c_WTERMSIG :: CInt -> CInt ++foreign import ccall unsafe "__hsunix_wifstopped"+  c_WIFSTOPPED :: CInt -> CInt++foreign import ccall unsafe "__hsunix_wstopsig"+  c_WSTOPSIG :: CInt -> CInt++-- -----------------------------------------------------------------------------+-- Exiting++-- | @'exitImmediately' status@ calls @_exit@ to terminate the process+--   with the indicated exit @status@.+--   The operation never returns.+exitImmediately :: ExitCode -> IO ()+exitImmediately exitcode = c_exit (exitcode2Int exitcode)+  where+    exitcode2Int ExitSuccess = 0+    exitcode2Int (ExitFailure n) = fromIntegral n++foreign import ccall unsafe "exit"+  c_exit :: CInt -> IO ()++-- -----------------------------------------------------------------------------
+ System/Posix/Resource.hsc view
@@ -0,0 +1,148 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.Resource+-- Copyright   :  (c) The University of Glasgow 2003+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- POSIX resource support+--+-----------------------------------------------------------------------------++module System.Posix.Resource (+    -- * Resource Limits+    ResourceLimit(..), ResourceLimits(..), Resource(..),+    getResourceLimit,+    setResourceLimit,+  ) where++#include "HsUnix.h"++import System.Posix.Types+import Foreign+import Foreign.C++-- -----------------------------------------------------------------------------+-- Resource limits++data Resource+  = ResourceCoreFileSize+  | ResourceCPUTime+  | ResourceDataSize+  | ResourceFileSize+  | ResourceOpenFiles+  | ResourceStackSize+#ifdef RLIMIT_AS+  | ResourceTotalMemory+#endif+  deriving Eq++data ResourceLimits+  = ResourceLimits { softLimit, hardLimit :: ResourceLimit }+  deriving Eq++data ResourceLimit+  = ResourceLimitInfinity+  | ResourceLimitUnknown+  | ResourceLimit Integer+  deriving Eq++type RLimit = ()++foreign import ccall unsafe "getrlimit"+  c_getrlimit :: CInt -> Ptr RLimit -> IO CInt++foreign import ccall unsafe "setrlimit"+  c_setrlimit :: CInt -> Ptr RLimit -> IO CInt++getResourceLimit :: Resource -> IO ResourceLimits+getResourceLimit res = do+  allocaBytes (#const sizeof(struct rlimit)) $ \p_rlimit -> do+    throwErrnoIfMinus1 "getResourceLimit" $+      c_getrlimit (packResource res) p_rlimit+    soft <- (#peek struct rlimit, rlim_cur) p_rlimit+    hard <- (#peek struct rlimit, rlim_max) p_rlimit+    return (ResourceLimits { +		softLimit = unpackRLimit soft,+		hardLimit = unpackRLimit hard+	   })++setResourceLimit :: Resource -> ResourceLimits -> IO ()+setResourceLimit res ResourceLimits{softLimit=soft,hardLimit=hard} = do+  allocaBytes (#const sizeof(struct rlimit)) $ \p_rlimit -> do+    (#poke struct rlimit, rlim_cur) p_rlimit (packRLimit soft True)+    (#poke struct rlimit, rlim_max) p_rlimit (packRLimit hard False)+    throwErrnoIfMinus1 "setResourceLimit" $+	c_setrlimit (packResource res) p_rlimit+    return ()++packResource :: Resource -> CInt+packResource ResourceCoreFileSize  = (#const RLIMIT_CORE)+packResource ResourceCPUTime       = (#const RLIMIT_CPU)+packResource ResourceDataSize      = (#const RLIMIT_DATA)+packResource ResourceFileSize      = (#const RLIMIT_FSIZE)+packResource ResourceOpenFiles     = (#const RLIMIT_NOFILE)+packResource ResourceStackSize     = (#const RLIMIT_STACK)+#ifdef RLIMIT_AS+packResource ResourceTotalMemory   = (#const RLIMIT_AS)+#endif++unpackRLimit :: CRLim -> ResourceLimit+unpackRLimit (#const RLIM_INFINITY)  = ResourceLimitInfinity+#ifdef RLIM_SAVED_MAX+unpackRLimit (#const RLIM_SAVED_MAX) = ResourceLimitUnknown+unpackRLimit (#const RLIM_SAVED_CUR) = ResourceLimitUnknown+#endif+unpackRLimit other = ResourceLimit (fromIntegral other)++packRLimit :: ResourceLimit -> Bool -> CRLim+packRLimit ResourceLimitInfinity _     = (#const RLIM_INFINITY)+#ifdef RLIM_SAVED_MAX+packRLimit ResourceLimitUnknown  True  = (#const RLIM_SAVED_CUR)+packRLimit ResourceLimitUnknown  False = (#const RLIM_SAVED_MAX)+#endif+packRLimit (ResourceLimit other) _     = fromIntegral other+++-- -----------------------------------------------------------------------------+-- Test code++{-+import System.Posix+import Control.Monad++main = do+ zipWithM_ (\r n -> setResourceLimit r ResourceLimits{+					hardLimit = ResourceLimit n,+					softLimit = ResourceLimit n })+	allResources [1..]	+ showAll+ mapM_ (\r -> setResourceLimit r ResourceLimits{+					hardLimit = ResourceLimit 1,+					softLimit = ResourceLimitInfinity })+	allResources+   -- should fail+++showAll = +  mapM_ (\r -> getResourceLimit r >>= (putStrLn . showRLims)) allResources++allResources =+    [ResourceCoreFileSize, ResourceCPUTime, ResourceDataSize,+	ResourceFileSize, ResourceOpenFiles, ResourceStackSize+#ifdef RLIMIT_AS+	, ResourceTotalMemory +#endif+	]++showRLims ResourceLimits{hardLimit=h,softLimit=s}+  = "hard: " ++ showRLim h ++ ", soft: " ++ showRLim s+ +showRLim ResourceLimitInfinity = "infinity"+showRLim ResourceLimitUnknown  = "unknown"+showRLim (ResourceLimit other)  = show other+-}
+ System/Posix/Signals/Exts.hsc view
@@ -0,0 +1,57 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.Signals.Exts+-- Copyright   :  (c) The University of Glasgow 2002+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX, includes Linuxisms/BSDisms)+--+-- non-POSIX signal support commonly available+--+-----------------------------------------------------------------------------++#include "HsUnix.h"++module System.Posix.Signals.Exts (+  module System.Posix.Signals++#ifdef SIGINFO+  , infoEvent, sigINFO+#endif+#ifdef SIGWINCH+  , windowChange, sigWINCH+#endif++  ) where++import Foreign.C ( CInt )+import System.Posix.Signals++#ifdef __HUGS__+# ifdef SIGINFO+sigINFO   = (#const SIGINFO)   :: CInt+# endif+# ifdef SIGWINCH+sigWINCH  = (#const SIGWINCH)  :: CInt+# endif+#else /* !HUGS */+# ifdef SIGINFO+foreign import ccall unsafe "__hsunix_SIGINFO"   sigINFO   :: CInt+# endif+# ifdef SIGWINCH+foreign import ccall unsafe "__hsunix_SIGWINCH"   sigWINCH   :: CInt+# endif+#endif /* !HUGS */++#ifdef SIGINFO+infoEvent :: Signal+infoEvent = sigINFO+#endif++#ifdef SIGWINCH+windowChange :: Signal+windowChange = sigWINCH+#endif
+ System/Posix/Temp.hsc view
@@ -0,0 +1,66 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.Temp+-- Copyright   :  (c) Volker Stolz <vs@foldr.org>+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  vs@foldr.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- POSIX environment support+--+-----------------------------------------------------------------------------++module System.Posix.Temp (++	mkstemp++{- Not ported (yet?):+	tmpfile: can we handle FILE*?+	tmpnam: ISO C, should go in base?+	tempname: dito+-}++) where++#include "HsUnix.h"++import System.IO+import System.Posix.IO+import System.Posix.Types+import Foreign.C++-- |'mkstemp' - make a unique filename and open it for+-- reading\/writing (only safe on GHC & Hugs)++mkstemp :: String -> IO (String, Handle)+mkstemp template = do+#if defined(__GLASGOW_HASKELL__) || defined(__HUGS__)+  withCString template $ \ ptr -> do+    fd <- throwErrnoIfMinus1 "mkstemp" (c_mkstemp ptr)+    name <- peekCString ptr+    h <- fdToHandle fd+    return (name, h)+#else+  name <- mktemp template+  h <- openFile name ReadWriteMode+  return (name, h)++-- |'mktemp' - make a unique file name+-- This function should be considered deprecated++mktemp :: String -> IO String+mktemp template = do+  withCString template $ \ ptr -> do+    ptr <- throwErrnoIfNull "mktemp" (c_mktemp ptr)+    peekCString ptr++foreign import ccall unsafe "mktemp"+  c_mktemp :: CString -> IO CString+#endif++foreign import ccall unsafe "mkstemp"+  c_mkstemp :: CString -> IO Fd+
+ System/Posix/Terminal.hsc view
@@ -0,0 +1,713 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.Terminal+-- Copyright   :  (c) The University of Glasgow 2002+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- POSIX Terminal support+--+-----------------------------------------------------------------------------++module System.Posix.Terminal (+  -- * Terminal support++  -- ** Terminal attributes+  TerminalAttributes,+  getTerminalAttributes,+  TerminalState(..),+  setTerminalAttributes,++  TerminalMode(..),+  withoutMode,+  withMode,+  terminalMode,+  bitsPerByte,+  withBits,++  ControlCharacter(..),+  controlChar,+  withCC,+  withoutCC,++  inputTime,+  withTime,+  minInput,+  withMinInput,++  BaudRate(..),+  inputSpeed,+  withInputSpeed,+  outputSpeed,+  withOutputSpeed,++  -- ** Terminal operations+  sendBreak,+  drainOutput,+  QueueSelector(..),+  discardData,+  FlowAction(..),+  controlFlow,++  -- ** Process groups+  getTerminalProcessGroupID,+  setTerminalProcessGroupID,++  -- ** Testing a file descriptor+  queryTerminal,+  getTerminalName,+  getControllingTerminalName++  ) where++#include "HsUnix.h"++import Data.Bits+import Data.Char+import Foreign.C.Error ( throwErrnoIfMinus1, throwErrnoIfMinus1_, throwErrnoIfNull )+import Foreign.C.String ( CString, peekCString )+import Foreign.C.Types ( CInt )+import Foreign.ForeignPtr ( ForeignPtr, withForeignPtr, mallocForeignPtrBytes )+import Foreign.Marshal.Utils ( copyBytes )+import Foreign.Ptr ( Ptr, nullPtr, plusPtr )+import Foreign.Storable ( Storable(..) )+import System.IO.Unsafe ( unsafePerformIO )+import System.Posix.Types++-- -----------------------------------------------------------------------------+-- Terminal attributes++type CTermios = ()+newtype TerminalAttributes = TerminalAttributes (ForeignPtr CTermios)++makeTerminalAttributes :: ForeignPtr CTermios -> TerminalAttributes+makeTerminalAttributes = TerminalAttributes++withTerminalAttributes :: TerminalAttributes -> (Ptr CTermios -> IO a) -> IO a+withTerminalAttributes (TerminalAttributes termios) = withForeignPtr termios+++data TerminalMode+	-- input flags+   = InterruptOnBreak		-- BRKINT+   | MapCRtoLF			-- ICRNL+   | IgnoreBreak		-- IGNBRK+   | IgnoreCR			-- IGNCR+   | IgnoreParityErrors		-- IGNPAR+   | MapLFtoCR			-- INLCR+   | CheckParity		-- INPCK+   | StripHighBit		-- ISTRIP+   | StartStopInput		-- IXOFF+   | StartStopOutput		-- IXON+   | MarkParityErrors		-- PARMRK++	-- output flags+   | ProcessOutput		-- OPOST+	-- ToDo: ONLCR, OCRNL, ONOCR, ONLRET, OFILL,+	--       NLDLY(NL0,NL1), CRDLY(CR0,CR1,CR2,CR2)+	--	 TABDLY(TAB0,TAB1,TAB2,TAB3)+	--	 BSDLY(BS0,BS1), VTDLY(VT0,VT1), FFDLY(FF0,FF1)++	-- control flags+   | LocalMode			-- CLOCAL+   | ReadEnable			-- CREAD+   | TwoStopBits		-- CSTOPB+   | HangupOnClose		-- HUPCL+   | EnableParity		-- PARENB+   | OddParity			-- PARODD++	-- local modes+   | EnableEcho			-- ECHO+   | EchoErase			-- ECHOE+   | EchoKill			-- ECHOK+   | EchoLF			-- ECHONL+   | ProcessInput		-- ICANON+   | ExtendedFunctions		-- IEXTEN+   | KeyboardInterrupts		-- ISIG+   | NoFlushOnInterrupt		-- NOFLSH+   | BackgroundWriteInterrupt	-- TOSTOP++withoutMode :: TerminalAttributes -> TerminalMode -> TerminalAttributes+withoutMode termios InterruptOnBreak = clearInputFlag (#const BRKINT) termios+withoutMode termios MapCRtoLF = clearInputFlag (#const ICRNL) termios+withoutMode termios IgnoreBreak = clearInputFlag (#const IGNBRK) termios+withoutMode termios IgnoreCR = clearInputFlag (#const IGNCR) termios+withoutMode termios IgnoreParityErrors = clearInputFlag (#const IGNPAR) termios+withoutMode termios MapLFtoCR = clearInputFlag (#const INLCR) termios+withoutMode termios CheckParity = clearInputFlag (#const INPCK) termios+withoutMode termios StripHighBit = clearInputFlag (#const ISTRIP) termios+withoutMode termios StartStopInput = clearInputFlag (#const IXOFF) termios+withoutMode termios StartStopOutput = clearInputFlag (#const IXON) termios+withoutMode termios MarkParityErrors = clearInputFlag (#const PARMRK) termios+withoutMode termios ProcessOutput = clearOutputFlag (#const OPOST) termios+withoutMode termios LocalMode = clearControlFlag (#const CLOCAL) termios+withoutMode termios ReadEnable = clearControlFlag (#const CREAD) termios+withoutMode termios TwoStopBits = clearControlFlag (#const CSTOPB) termios+withoutMode termios HangupOnClose = clearControlFlag (#const HUPCL) termios+withoutMode termios EnableParity = clearControlFlag (#const PARENB) termios+withoutMode termios OddParity = clearControlFlag (#const PARODD) termios+withoutMode termios EnableEcho = clearLocalFlag (#const ECHO) termios+withoutMode termios EchoErase = clearLocalFlag (#const ECHOE) termios+withoutMode termios EchoKill = clearLocalFlag (#const ECHOK) termios+withoutMode termios EchoLF = clearLocalFlag (#const ECHONL) termios+withoutMode termios ProcessInput = clearLocalFlag (#const ICANON) termios+withoutMode termios ExtendedFunctions = clearLocalFlag (#const IEXTEN) termios+withoutMode termios KeyboardInterrupts = clearLocalFlag (#const ISIG) termios+withoutMode termios NoFlushOnInterrupt = setLocalFlag (#const NOFLSH) termios+withoutMode termios BackgroundWriteInterrupt = clearLocalFlag (#const TOSTOP) termios++withMode :: TerminalAttributes -> TerminalMode -> TerminalAttributes+withMode termios InterruptOnBreak = setInputFlag (#const BRKINT) termios+withMode termios MapCRtoLF = setInputFlag (#const ICRNL) termios+withMode termios IgnoreBreak = setInputFlag (#const IGNBRK) termios+withMode termios IgnoreCR = setInputFlag (#const IGNCR) termios+withMode termios IgnoreParityErrors = setInputFlag (#const IGNPAR) termios+withMode termios MapLFtoCR = setInputFlag (#const INLCR) termios+withMode termios CheckParity = setInputFlag (#const INPCK) termios+withMode termios StripHighBit = setInputFlag (#const ISTRIP) termios+withMode termios StartStopInput = setInputFlag (#const IXOFF) termios+withMode termios StartStopOutput = setInputFlag (#const IXON) termios+withMode termios MarkParityErrors = setInputFlag (#const PARMRK) termios+withMode termios ProcessOutput = setOutputFlag (#const OPOST) termios+withMode termios LocalMode = setControlFlag (#const CLOCAL) termios+withMode termios ReadEnable = setControlFlag (#const CREAD) termios+withMode termios TwoStopBits = setControlFlag (#const CSTOPB) termios+withMode termios HangupOnClose = setControlFlag (#const HUPCL) termios+withMode termios EnableParity = setControlFlag (#const PARENB) termios+withMode termios OddParity = setControlFlag (#const PARODD) termios+withMode termios EnableEcho = setLocalFlag (#const ECHO) termios+withMode termios EchoErase = setLocalFlag (#const ECHOE) termios+withMode termios EchoKill = setLocalFlag (#const ECHOK) termios+withMode termios EchoLF = setLocalFlag (#const ECHONL) termios+withMode termios ProcessInput = setLocalFlag (#const ICANON) termios+withMode termios ExtendedFunctions = setLocalFlag (#const IEXTEN) termios+withMode termios KeyboardInterrupts = setLocalFlag (#const ISIG) termios+withMode termios NoFlushOnInterrupt = clearLocalFlag (#const NOFLSH) termios+withMode termios BackgroundWriteInterrupt = setLocalFlag (#const TOSTOP) termios++terminalMode :: TerminalMode -> TerminalAttributes -> Bool+terminalMode InterruptOnBreak = testInputFlag (#const BRKINT)+terminalMode MapCRtoLF = testInputFlag (#const ICRNL)+terminalMode IgnoreBreak = testInputFlag (#const IGNBRK)+terminalMode IgnoreCR = testInputFlag (#const IGNCR)+terminalMode IgnoreParityErrors = testInputFlag (#const IGNPAR)+terminalMode MapLFtoCR = testInputFlag (#const INLCR)+terminalMode CheckParity = testInputFlag (#const INPCK)+terminalMode StripHighBit = testInputFlag (#const ISTRIP)+terminalMode StartStopInput = testInputFlag (#const IXOFF)+terminalMode StartStopOutput = testInputFlag (#const IXON)+terminalMode MarkParityErrors = testInputFlag (#const PARMRK)+terminalMode ProcessOutput = testOutputFlag (#const OPOST)+terminalMode LocalMode = testControlFlag (#const CLOCAL)+terminalMode ReadEnable = testControlFlag (#const CREAD)+terminalMode TwoStopBits = testControlFlag (#const CSTOPB)+terminalMode HangupOnClose = testControlFlag (#const HUPCL)+terminalMode EnableParity = testControlFlag (#const PARENB)+terminalMode OddParity = testControlFlag (#const PARODD)+terminalMode EnableEcho = testLocalFlag (#const ECHO)+terminalMode EchoErase = testLocalFlag (#const ECHOE)+terminalMode EchoKill = testLocalFlag (#const ECHOK)+terminalMode EchoLF = testLocalFlag (#const ECHONL)+terminalMode ProcessInput = testLocalFlag (#const ICANON)+terminalMode ExtendedFunctions = testLocalFlag (#const IEXTEN)+terminalMode KeyboardInterrupts = testLocalFlag (#const ISIG)+terminalMode NoFlushOnInterrupt = not . testLocalFlag (#const NOFLSH)+terminalMode BackgroundWriteInterrupt = testLocalFlag (#const TOSTOP)++bitsPerByte :: TerminalAttributes -> Int+bitsPerByte termios = unsafePerformIO $ do+  withTerminalAttributes termios $ \p -> do+    cflag <- (#peek struct termios, c_cflag) p+    return $! (word2Bits (cflag .&. (#const CSIZE)))+  where+    word2Bits :: CTcflag -> Int+    word2Bits x =+	if x == (#const CS5) then 5+	else if x == (#const CS6) then 6+	else if x == (#const CS7) then 7+	else if x == (#const CS8) then 8+	else 0++withBits :: TerminalAttributes -> Int -> TerminalAttributes+withBits termios bits = unsafePerformIO $ do+  withNewTermios termios $ \p -> do+    cflag <- (#peek struct termios, c_cflag) p+    (#poke struct termios, c_cflag) p+       ((cflag .&. complement (#const CSIZE)) .|. mask bits)+  where+    mask :: Int -> CTcflag+    mask 5 = (#const CS5)+    mask 6 = (#const CS6)+    mask 7 = (#const CS7)+    mask 8 = (#const CS8)+    mask _ = error "withBits bit value out of range [5..8]"++data ControlCharacter+  = EndOfFile		-- VEOF+  | EndOfLine		-- VEOL+  | Erase		-- VERASE+  | Interrupt		-- VINTR+  | Kill		-- VKILL+  | Quit		-- VQUIT+  | Start		-- VSTART+  | Stop		-- VSTOP+  | Suspend		-- VSUSP++controlChar :: TerminalAttributes -> ControlCharacter -> Maybe Char+controlChar termios cc = unsafePerformIO $ do+  withTerminalAttributes termios $ \p -> do+    let c_cc = (#ptr struct termios, c_cc) p+    val <- peekElemOff c_cc (cc2Word cc)+    if val == ((#const _POSIX_VDISABLE)::CCc)+       then return Nothing+       else return (Just (chr (fromEnum val)))+  +withCC :: TerminalAttributes+       -> (ControlCharacter, Char)+       -> TerminalAttributes+withCC termios (cc, c) = unsafePerformIO $ do+  withNewTermios termios $ \p -> do+    let c_cc = (#ptr struct termios, c_cc) p+    pokeElemOff c_cc (cc2Word cc) (fromIntegral (ord c) :: CCc)++withoutCC :: TerminalAttributes+          -> ControlCharacter+          -> TerminalAttributes+withoutCC termios cc = unsafePerformIO $ do+  withNewTermios termios $ \p -> do+    let c_cc = (#ptr struct termios, c_cc) p+    pokeElemOff c_cc (cc2Word cc) ((#const _POSIX_VDISABLE) :: CCc)++inputTime :: TerminalAttributes -> Int+inputTime termios = unsafePerformIO $ do+  withTerminalAttributes termios $ \p -> do+    c <- peekElemOff ((#ptr struct termios, c_cc) p) (#const VTIME)+    return (fromEnum (c :: CCc))++withTime :: TerminalAttributes -> Int -> TerminalAttributes+withTime termios time = unsafePerformIO $ do+  withNewTermios termios $ \p -> do+    let c_cc = (#ptr struct termios, c_cc) p+    pokeElemOff c_cc (#const VTIME) (fromIntegral time :: CCc)++minInput :: TerminalAttributes -> Int+minInput termios = unsafePerformIO $ do+  withTerminalAttributes termios $ \p -> do+    c <- peekElemOff ((#ptr struct termios, c_cc) p) (#const VMIN)+    return (fromEnum (c :: CCc))++withMinInput :: TerminalAttributes -> Int -> TerminalAttributes+withMinInput termios count = unsafePerformIO $ do+  withNewTermios termios $ \p -> do+    let c_cc = (#ptr struct termios, c_cc) p+    pokeElemOff c_cc (#const VMIN) (fromIntegral count :: CCc)++data BaudRate+  = B0+  | B50+  | B75+  | B110+  | B134+  | B150+  | B200+  | B300+  | B600+  | B1200+  | B1800+  | B2400+  | B4800+  | B9600+  | B19200+  | B38400++inputSpeed :: TerminalAttributes -> BaudRate+inputSpeed termios = unsafePerformIO $ do+  withTerminalAttributes termios $ \p -> do+    w <- c_cfgetispeed p+    return (word2Baud w)++foreign import ccall unsafe "cfgetispeed"+  c_cfgetispeed :: Ptr CTermios -> IO CSpeed++withInputSpeed :: TerminalAttributes -> BaudRate -> TerminalAttributes+withInputSpeed termios br = unsafePerformIO $ do+  withNewTermios termios $ \p -> c_cfsetispeed p (baud2Word br)++foreign import ccall unsafe "cfsetispeed"+  c_cfsetispeed :: Ptr CTermios -> CSpeed -> IO CInt+++outputSpeed :: TerminalAttributes -> BaudRate+outputSpeed termios = unsafePerformIO $ do+  withTerminalAttributes termios $ \p ->  do+    w <- c_cfgetospeed p+    return (word2Baud w)++foreign import ccall unsafe "cfgetospeed"+  c_cfgetospeed :: Ptr CTermios -> IO CSpeed++withOutputSpeed :: TerminalAttributes -> BaudRate -> TerminalAttributes+withOutputSpeed termios br = unsafePerformIO $ do+  withNewTermios termios $ \p -> c_cfsetospeed p (baud2Word br)++foreign import ccall unsafe "cfsetospeed"+  c_cfsetospeed :: Ptr CTermios -> CSpeed -> IO CInt++-- | @getTerminalAttributes fd@ calls @tcgetattr@ to obtain+--   the @TerminalAttributes@ associated with @Fd@ @fd@.+getTerminalAttributes :: Fd -> IO TerminalAttributes+getTerminalAttributes fd = do+  fp <- mallocForeignPtrBytes (#const sizeof(struct termios))+  withForeignPtr fp $ \p ->+      throwErrnoIfMinus1_ "getTerminalAttributes" (c_tcgetattr fd p)+  return $ makeTerminalAttributes fp++foreign import ccall unsafe "tcgetattr"+  c_tcgetattr :: Fd -> Ptr CTermios -> IO CInt++data TerminalState+  = Immediately+  | WhenDrained+  | WhenFlushed++-- | @setTerminalAttributes fd attr ts@ calls @tcsetattr@ to change+--   the @TerminalAttributes@ associated with @Fd@ @fd@ to+--   @attr@, when the terminal is in the state indicated by @ts@.+setTerminalAttributes :: Fd+                      -> TerminalAttributes+                      -> TerminalState+                      -> IO ()+setTerminalAttributes fd termios state = do+  withTerminalAttributes termios $ \p ->+    throwErrnoIfMinus1_ "setTerminalAttributes"+      (c_tcsetattr fd (state2Int state) p)+  where+    state2Int :: TerminalState -> CInt+    state2Int Immediately = (#const TCSANOW)+    state2Int WhenDrained = (#const TCSADRAIN)+    state2Int WhenFlushed = (#const TCSAFLUSH)++foreign import ccall unsafe "tcsetattr"+   c_tcsetattr :: Fd -> CInt -> Ptr CTermios -> IO CInt++-- | @sendBreak fd duration@ calls @tcsendbreak@ to transmit a+--   continuous stream of zero-valued bits on @Fd@ @fd@ for the+--   specified implementation-dependent @duration@.+sendBreak :: Fd -> Int -> IO ()+sendBreak fd duration+  = throwErrnoIfMinus1_ "sendBreak" (c_tcsendbreak fd (fromIntegral duration))++foreign import ccall unsafe "tcsendbreak"+  c_tcsendbreak :: Fd -> CInt -> IO CInt++-- | @drainOutput fd@ calls @tcdrain@ to block until all output+--   written to @Fd@ @fd@ has been transmitted.+drainOutput :: Fd -> IO ()+drainOutput fd = throwErrnoIfMinus1_ "drainOutput" (c_tcdrain fd)++foreign import ccall unsafe "tcdrain"+  c_tcdrain :: Fd -> IO CInt+++data QueueSelector+  = InputQueue		-- TCIFLUSH+  | OutputQueue		-- TCOFLUSH+  | BothQueues		-- TCIOFLUSH++-- | @discardData fd queues@ calls @tcflush@ to discard+--   pending input and\/or output for @Fd@ @fd@,+--   as indicated by the @QueueSelector@ @queues@.+discardData :: Fd -> QueueSelector -> IO ()+discardData fd queue =+  throwErrnoIfMinus1_ "discardData" (c_tcflush fd (queue2Int queue))+  where+    queue2Int :: QueueSelector -> CInt+    queue2Int InputQueue  = (#const TCIFLUSH)+    queue2Int OutputQueue = (#const TCOFLUSH)+    queue2Int BothQueues  = (#const TCIOFLUSH)++foreign import ccall unsafe "tcflush"+  c_tcflush :: Fd -> CInt -> IO CInt++data FlowAction+  = SuspendOutput	-- ^ TCOOFF+  | RestartOutput	-- ^ TCOON+  | TransmitStop	-- ^ TCIOFF+  | TransmitStart	-- ^ TCION++-- | @controlFlow fd action@ calls @tcflow@ to control the +--   flow of data on @Fd@ @fd@, as indicated by+--   @action@.+controlFlow :: Fd -> FlowAction -> IO ()+controlFlow fd action =+  throwErrnoIfMinus1_ "controlFlow" (c_tcflow fd (action2Int action))+  where+    action2Int :: FlowAction -> CInt+    action2Int SuspendOutput = (#const TCOOFF)+    action2Int RestartOutput = (#const TCOON)+    action2Int TransmitStop  = (#const TCIOFF)+    action2Int TransmitStart = (#const TCION)++foreign import ccall unsafe "tcflow"+  c_tcflow :: Fd -> CInt -> IO CInt++-- | @getTerminalProcessGroupID fd@ calls @tcgetpgrp@ to+--   obtain the @ProcessGroupID@ of the foreground process group +--   associated with the terminal attached to @Fd@ @fd@.+getTerminalProcessGroupID :: Fd -> IO ProcessGroupID+getTerminalProcessGroupID fd = do+  throwErrnoIfMinus1 "getTerminalProcessGroupID" (c_tcgetpgrp fd)++foreign import ccall unsafe "tcgetpgrp"+  c_tcgetpgrp :: Fd -> IO CPid++-- | @setTerminalProcessGroupID fd pgid@ calls @tcsetpgrp@ to+--   set the @ProcessGroupID@ of the foreground process group +--   associated with the terminal attached to @Fd@ +--   @fd@ to @pgid@.+setTerminalProcessGroupID :: Fd -> ProcessGroupID -> IO ()+setTerminalProcessGroupID fd pgid =+  throwErrnoIfMinus1_ "setTerminalProcessGroupID" (c_tcsetpgrp fd pgid)++foreign import ccall unsafe "tcsetpgrp"+  c_tcsetpgrp :: Fd -> CPid -> IO CInt++-- -----------------------------------------------------------------------------+-- file descriptor queries++-- | @queryTerminal fd@ calls @isatty@ to determine whether or+--   not @Fd@ @fd@ is associated with a terminal.+queryTerminal :: Fd -> IO Bool+queryTerminal fd = do+  r <- c_isatty fd+  return (r == 1)+  -- ToDo: the spec says that it can set errno to EBADF if the result is zero++foreign import ccall unsafe "isatty"+  c_isatty :: Fd -> IO CInt++-- | @getTerminalName fd@ calls @ttyname@ to obtain a name associated+--   with the terminal for @Fd@ @fd@. If @fd@ is associated+--   with a terminal, @getTerminalName@ returns the name of the+--   terminal.+getTerminalName :: Fd -> IO FilePath+getTerminalName fd = do+  s <- throwErrnoIfNull "getTerminalName" (c_ttyname fd)+  peekCString s  ++foreign import ccall unsafe "ttyname"+  c_ttyname :: Fd -> IO CString++-- | @getControllingTerminalName@ calls @ctermid@ to obtain+--   a name associated with the controlling terminal for the process.  If a+--   controlling terminal exists,+--   @getControllingTerminalName@ returns the name of the+--   controlling terminal.+getControllingTerminalName :: IO FilePath+getControllingTerminalName = do+  s <- throwErrnoIfNull "getControllingTerminalName" (c_ctermid nullPtr)+  peekCString s++foreign import ccall unsafe "ctermid"+  c_ctermid :: CString -> IO CString++-- -----------------------------------------------------------------------------+-- Local utility functions++-- Convert Haskell ControlCharacter to Int++cc2Word :: ControlCharacter -> Int+cc2Word EndOfFile = (#const VEOF)+cc2Word EndOfLine = (#const VEOL)+cc2Word Erase     = (#const VERASE)+cc2Word Interrupt = (#const VINTR)+cc2Word Kill      = (#const VKILL)+cc2Word Quit      = (#const VQUIT)+cc2Word Suspend   = (#const VSUSP)+cc2Word Start     = (#const VSTART)+cc2Word Stop      = (#const VSTOP)++-- Convert Haskell BaudRate to unsigned integral type (Word)++baud2Word :: BaudRate -> CSpeed+baud2Word B0 = (#const B0)+baud2Word B50 = (#const B50)+baud2Word B75 = (#const B75)+baud2Word B110 = (#const B110)+baud2Word B134 = (#const B134)+baud2Word B150 = (#const B150)+baud2Word B200 = (#const B200)+baud2Word B300 = (#const B300)+baud2Word B600 = (#const B600)+baud2Word B1200 = (#const B1200)+baud2Word B1800 = (#const B1800)+baud2Word B2400 = (#const B2400)+baud2Word B4800 = (#const B4800)+baud2Word B9600 = (#const B9600)+baud2Word B19200 = (#const B19200)+baud2Word B38400 = (#const B38400)++-- And convert a word back to a baud rate+-- We really need some cpp macros here.++word2Baud :: CSpeed -> BaudRate+word2Baud x =+    if x == (#const B0) then B0+    else if x == (#const B50) then B50+    else if x == (#const B75) then B75+    else if x == (#const B110) then B110+    else if x == (#const B134) then B134+    else if x == (#const B150) then B150+    else if x == (#const B200) then B200+    else if x == (#const B300) then B300+    else if x == (#const B600) then B600+    else if x == (#const B1200) then B1200+    else if x == (#const B1800) then B1800+    else if x == (#const B2400) then B2400+    else if x == (#const B4800) then B4800+    else if x == (#const B9600) then B9600+    else if x == (#const B19200) then B19200+    else if x == (#const B38400) then B38400+    else error "unknown baud rate"++-- Clear termios i_flag++clearInputFlag :: CTcflag -> TerminalAttributes -> TerminalAttributes+clearInputFlag flag termios = unsafePerformIO $ do+  fp <- mallocForeignPtrBytes (#const sizeof(struct termios))+  withForeignPtr fp $ \p1 -> do+    withTerminalAttributes termios $ \p2 -> do+      copyBytes p1 p2 (#const sizeof(struct termios)) +      iflag <- (#peek struct termios, c_iflag) p2+      (#poke struct termios, c_iflag) p1 (iflag .&. complement flag)+  return $ makeTerminalAttributes fp++-- Set termios i_flag++setInputFlag :: CTcflag -> TerminalAttributes -> TerminalAttributes+setInputFlag flag termios = unsafePerformIO $ do+  fp <- mallocForeignPtrBytes (#const sizeof(struct termios))+  withForeignPtr fp $ \p1 -> do+    withTerminalAttributes termios $ \p2 -> do+      copyBytes p1 p2 (#const sizeof(struct termios)) +      iflag <- (#peek struct termios, c_iflag) p2+      (#poke struct termios, c_iflag) p1 (iflag .|. flag)+  return $ makeTerminalAttributes fp++-- Examine termios i_flag++testInputFlag :: CTcflag -> TerminalAttributes -> Bool+testInputFlag flag termios = unsafePerformIO $+  withTerminalAttributes termios $ \p ->  do+    iflag <- (#peek struct termios, c_iflag) p+    return $! ((iflag .&. flag) /= 0)++-- Clear termios c_flag++clearControlFlag :: CTcflag -> TerminalAttributes -> TerminalAttributes+clearControlFlag flag termios = unsafePerformIO $ do+  fp <- mallocForeignPtrBytes (#const sizeof(struct termios))+  withForeignPtr fp $ \p1 -> do+    withTerminalAttributes termios $ \p2 -> do+      copyBytes p1 p2 (#const sizeof(struct termios)) +      cflag <- (#peek struct termios, c_cflag) p2+      (#poke struct termios, c_cflag) p1 (cflag .&. complement flag)+  return $ makeTerminalAttributes fp++-- Set termios c_flag++setControlFlag :: CTcflag -> TerminalAttributes -> TerminalAttributes+setControlFlag flag termios = unsafePerformIO $ do+  fp <- mallocForeignPtrBytes (#const sizeof(struct termios))+  withForeignPtr fp $ \p1 -> do+    withTerminalAttributes termios $ \p2 -> do+      copyBytes p1 p2 (#const sizeof(struct termios)) +      cflag <- (#peek struct termios, c_cflag) p2+      (#poke struct termios, c_cflag) p1 (cflag .|. flag)+  return $ makeTerminalAttributes fp++-- Examine termios c_flag++testControlFlag :: CTcflag -> TerminalAttributes -> Bool+testControlFlag flag termios = unsafePerformIO $+  withTerminalAttributes termios $ \p -> do+    cflag <- (#peek struct termios, c_cflag) p+    return $! ((cflag .&. flag) /= 0)++-- Clear termios l_flag++clearLocalFlag :: CTcflag -> TerminalAttributes -> TerminalAttributes+clearLocalFlag flag termios = unsafePerformIO $ do+  fp <- mallocForeignPtrBytes (#const sizeof(struct termios))+  withForeignPtr fp $ \p1 -> do+    withTerminalAttributes termios $ \p2 -> do+      copyBytes p1 p2 (#const sizeof(struct termios)) +      lflag <- (#peek struct termios, c_lflag) p2+      (#poke struct termios, c_lflag) p1 (lflag .&. complement flag)+  return $ makeTerminalAttributes fp++-- Set termios l_flag++setLocalFlag :: CTcflag -> TerminalAttributes -> TerminalAttributes+setLocalFlag flag termios = unsafePerformIO $ do+  fp <- mallocForeignPtrBytes (#const sizeof(struct termios))+  withForeignPtr fp $ \p1 -> do+    withTerminalAttributes termios $ \p2 -> do+      copyBytes p1 p2 (#const sizeof(struct termios)) +      lflag <- (#peek struct termios, c_lflag) p2+      (#poke struct termios, c_lflag) p1 (lflag .|. flag)+  return $ makeTerminalAttributes fp++-- Examine termios l_flag++testLocalFlag :: CTcflag -> TerminalAttributes -> Bool+testLocalFlag flag termios = unsafePerformIO $+  withTerminalAttributes termios $ \p ->  do+    lflag <- (#peek struct termios, c_lflag) p+    return $! ((lflag .&. flag) /= 0)++-- Clear termios o_flag++clearOutputFlag :: CTcflag -> TerminalAttributes -> TerminalAttributes+clearOutputFlag flag termios = unsafePerformIO $ do+  fp <- mallocForeignPtrBytes (#const sizeof(struct termios))+  withForeignPtr fp $ \p1 -> do+    withTerminalAttributes termios $ \p2 -> do+      copyBytes p1 p2 (#const sizeof(struct termios)) +      oflag <- (#peek struct termios, c_oflag) p2+      (#poke struct termios, c_oflag) p1 (oflag .&. complement flag)+  return $ makeTerminalAttributes fp++-- Set termios o_flag++setOutputFlag :: CTcflag -> TerminalAttributes -> TerminalAttributes+setOutputFlag flag termios = unsafePerformIO $ do+  fp <- mallocForeignPtrBytes (#const sizeof(struct termios))+  withForeignPtr fp $ \p1 -> do+    withTerminalAttributes termios $ \p2 -> do+      copyBytes p1 p2 (#const sizeof(struct termios)) +      oflag <- (#peek struct termios, c_oflag) p2+      (#poke struct termios, c_oflag) p1 (oflag .|. flag)+  return $ makeTerminalAttributes fp++-- Examine termios o_flag++testOutputFlag :: CTcflag -> TerminalAttributes -> Bool+testOutputFlag flag termios = unsafePerformIO $+  withTerminalAttributes termios $ \p -> do+    oflag <- (#peek struct termios, c_oflag) p+    return $! ((oflag .&. flag) /= 0)++withNewTermios :: TerminalAttributes -> (Ptr CTermios -> IO a) +  -> IO TerminalAttributes+withNewTermios termios action = do+  fp1 <- mallocForeignPtrBytes (#const sizeof(struct termios))+  withForeignPtr fp1 $ \p1 -> do+   withTerminalAttributes termios $ \p2 -> do+    copyBytes p1 p2 (#const sizeof(struct termios))+    action p1+  return $ makeTerminalAttributes fp1
+ System/Posix/Time.hsc view
@@ -0,0 +1,37 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.Time+-- Copyright   :  (c) The University of Glasgow 2002+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- POSIX Time support+--+-----------------------------------------------------------------------------++module System.Posix.Time (+	epochTime,+	-- ToDo: lots more from sys/time.h+	-- how much already supported by System.Time?+  ) where++#include "HsUnix.h"++import System.Posix.Types+import Foreign+import Foreign.C++-- -----------------------------------------------------------------------------+-- epochTime++-- | @epochTime@ calls @time@ to obtain the number of +--   seconds that have elapsed since the epoch (Jan 01 00:00:00 GMT 1970).+epochTime :: IO EpochTime+epochTime = throwErrnoIfMinus1 "epochTime" (c_time nullPtr)++foreign import ccall unsafe "time"+  c_time :: Ptr CTime -> IO CTime
+ System/Posix/Unistd.hsc view
@@ -0,0 +1,159 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.Unistd+-- Copyright   :  (c) The University of Glasgow 2002+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- POSIX miscellaneous stuff, mostly from unistd.h+--+-----------------------------------------------------------------------------++module System.Posix.Unistd (+    -- * System environment+    SystemID(..),+    getSystemID,++    SysVar(..),+    getSysVar,++    -- * Sleeping+    sleep, usleep,++  {-+    ToDo from unistd.h:+      confstr, +      lots of sysconf variables++    -- use Network.BSD+    gethostid, gethostname++    -- should be in System.Posix.Files?+    pathconf, fpathconf,++    -- System.Posix.Signals+    ualarm,++    -- System.Posix.IO+    read, write,++    -- should be in System.Posix.User?+    getEffectiveUserName,+-}+  ) where++#include "HsUnix.h"++import Foreign.C.Error+import Foreign.C.String ( peekCString )+import Foreign.C.Types ( CInt, CUInt, CLong )+import Foreign.Marshal.Alloc ( allocaBytes )+import Foreign.Ptr ( Ptr, plusPtr )+import System.Posix.Types+import System.Posix.Internals++-- -----------------------------------------------------------------------------+-- System environment (uname())++data SystemID =+  SystemID { systemName :: String+  	   , nodeName   :: String+	   , release    :: String+	   , version    :: String+	   , machine    :: String+	   }++getSystemID :: IO SystemID+getSystemID = do+  allocaBytes (#const sizeof(struct utsname)) $ \p_sid -> do+    throwErrnoIfMinus1_ "getSystemID" (c_uname p_sid)+    sysN <- peekCString ((#ptr struct utsname, sysname) p_sid)+    node <- peekCString ((#ptr struct utsname, nodename) p_sid)+    rel  <- peekCString ((#ptr struct utsname, release) p_sid)+    ver  <- peekCString ((#ptr struct utsname, version) p_sid)+    mach <- peekCString ((#ptr struct utsname, machine) p_sid)+    return (SystemID { systemName = sysN,+		       nodeName   = node,+		       release    = rel,+		       version    = ver,+		       machine    = mach+		     })++foreign import ccall unsafe "uname"+   c_uname :: Ptr CUtsname -> IO CInt++-- -----------------------------------------------------------------------------+-- sleeping++-- | Sleep for the specified duration (in seconds).  Returns the time remaining+-- (if the sleep was interrupted by a signal, for example).+--+-- GHC Note: the comment for 'usleep' also applies here.+--+sleep :: Int -> IO Int+sleep 0 = return 0+sleep secs = do r <- c_sleep (fromIntegral secs); return (fromIntegral r)++foreign import ccall safe "sleep"+  c_sleep :: CUInt -> IO CUInt++-- | Sleep for the specified duration (in microseconds).+--+-- GHC Note: 'Control.Concurrent.threadDelay' is a better choice.+-- Without the @-threaded@ option, 'usleep' will block all other user+-- threads.  Even with the @-threaded@ option, 'usleep' requires a+-- full OS thread to itself.  'Control.Concurrent.threadDelay' has+-- neither of these shortcomings.+--+usleep :: Int -> IO ()+usleep 0 = return ()+#ifdef USLEEP_RETURNS_VOID+usleep usecs = c_usleep (fromIntegral usecs)+#else+usleep usecs = throwErrnoIfMinus1Retry_ "usleep" (c_usleep (fromIntegral usecs))+#endif++#ifdef USLEEP_RETURNS_VOID+foreign import ccall safe "usleep"+  c_usleep :: CUInt -> IO ()+#else+foreign import ccall safe "usleep"+  c_usleep :: CUInt -> IO CInt+#endif++-- -----------------------------------------------------------------------------+-- System variables++data SysVar = ArgumentLimit+            | ChildLimit+            | ClockTick+            | GroupLimit+            | OpenFileLimit+            | PosixVersion+            | HasSavedIDs+            | HasJobControl+	-- ToDo: lots more++getSysVar :: SysVar -> IO Integer+getSysVar v =+    case v of+      ArgumentLimit -> sysconf (#const _SC_ARG_MAX)+      ChildLimit    -> sysconf (#const _SC_CHILD_MAX)+      ClockTick	    -> sysconf (#const _SC_CLK_TCK)+      GroupLimit    -> sysconf (#const _SC_NGROUPS_MAX)+      OpenFileLimit -> sysconf (#const _SC_OPEN_MAX)+      PosixVersion  -> sysconf (#const _SC_VERSION)+      HasSavedIDs   -> sysconf (#const _SC_SAVED_IDS)+      HasJobControl -> sysconf (#const _SC_JOB_CONTROL)++sysconf :: CInt -> IO Integer+sysconf n = do +  r <- throwErrnoIfMinus1 "getSysVar" (c_sysconf n)+  return (fromIntegral r)++foreign import ccall unsafe "sysconf"+  c_sysconf :: CInt -> IO CLong
+ System/Posix/User.hsc view
@@ -0,0 +1,394 @@+{-# OPTIONS -fffi #-}+-----------------------------------------------------------------------------+-- |+-- Module      :  System.Posix.User+-- Copyright   :  (c) The University of Glasgow 2002+-- License     :  BSD-style (see the file libraries/base/LICENSE)+-- +-- Maintainer  :  libraries@haskell.org+-- Stability   :  provisional+-- Portability :  non-portable (requires POSIX)+--+-- POSIX user\/group support+--+-----------------------------------------------------------------------------++module System.Posix.User (+    -- * User environment+    -- ** Querying the user environment+    getRealUserID,+    getRealGroupID,+    getEffectiveUserID,+    getEffectiveGroupID,+    getGroups,+    getLoginName,+    getEffectiveUserName,++    -- *** The group database+    GroupEntry(..),+    getGroupEntryForID,+    getGroupEntryForName,+    getAllGroupEntries,++    -- *** The user database+    UserEntry(..),+    getUserEntryForID,+    getUserEntryForName,+    getAllUserEntries,++    -- ** Modifying the user environment+    setUserID,+    setGroupID,++  ) where++#include "HsUnix.h"++import System.Posix.Types+import Foreign+import Foreign.C+import System.Posix.Internals	( CGroup, CPasswd )++#if !defined(HAVE_GETPWNAM_R) || !defined(HAVE_GETPWUID_R) || defined(HAVE_GETPWENT) || defined(HAVE_GETGRENT)+import Control.Concurrent.MVar  ( newMVar, withMVar )+#endif++-- -----------------------------------------------------------------------------+-- user environemnt++-- | @getRealUserID@ calls @getuid@ to obtain the real @UserID@+--   associated with the current process.+getRealUserID :: IO UserID+getRealUserID = c_getuid++foreign import ccall unsafe "getuid"+  c_getuid :: IO CUid++-- | @getRealGroupID@ calls @getgid@ to obtain the real @GroupID@+--   associated with the current process.+getRealGroupID :: IO GroupID+getRealGroupID = c_getgid++foreign import ccall unsafe "getgid"+  c_getgid :: IO CGid++-- | @getEffectiveUserID@ calls @geteuid@ to obtain the effective+--   @UserID@ associated with the current process.+getEffectiveUserID :: IO UserID+getEffectiveUserID = c_geteuid++foreign import ccall unsafe "geteuid"+  c_geteuid :: IO CUid++-- | @getEffectiveGroupID@ calls @getegid@ to obtain the effective+--   @GroupID@ associated with the current process.+getEffectiveGroupID :: IO GroupID+getEffectiveGroupID = c_getegid++foreign import ccall unsafe "getegid"+  c_getegid :: IO CGid++-- | @getGroups@ calls @getgroups@ to obtain the list of+--   supplementary @GroupID@s associated with the current process.+getGroups :: IO [GroupID]+getGroups = do+    ngroups <- c_getgroups 0 nullPtr+    allocaArray (fromIntegral ngroups) $ \arr -> do+       throwErrnoIfMinus1_ "getGroups" (c_getgroups ngroups arr)+       groups <- peekArray (fromIntegral ngroups) arr+       return groups++foreign import ccall unsafe "getgroups"+  c_getgroups :: CInt -> Ptr CGid -> IO CInt+++++-- | @getLoginName@ calls @getlogin@ to obtain the login name+--   associated with the current process.+getLoginName :: IO String+getLoginName =  do+    -- ToDo: use getlogin_r+    str <- throwErrnoIfNull "getLoginName" c_getlogin+    peekCString str++foreign import ccall unsafe "getlogin"+  c_getlogin :: IO CString++-- | @setUserID uid@ calls @setuid@ to set the real, effective, and+--   saved set-user-id associated with the current process to @uid@.+setUserID :: UserID -> IO ()+setUserID uid = throwErrnoIfMinus1_ "setUserID" (c_setuid uid)++foreign import ccall unsafe "setuid"+  c_setuid :: CUid -> IO CInt++-- | @setGroupID gid@ calls @setgid@ to set the real, effective, and+--   saved set-group-id associated with the current process to @gid@.+setGroupID :: GroupID -> IO ()+setGroupID gid = throwErrnoIfMinus1_ "setGroupID" (c_setgid gid)++foreign import ccall unsafe "setgid"+  c_setgid :: CGid -> IO CInt++-- -----------------------------------------------------------------------------+-- User names++-- | @getEffectiveUserName@ gets the name+--   associated with the effective @UserID@ of the process.+getEffectiveUserName :: IO String+getEffectiveUserName = do+    euid <- getEffectiveUserID+    pw <- getUserEntryForID euid+    return (userName pw)++-- -----------------------------------------------------------------------------+-- The group database (grp.h)++data GroupEntry =+ GroupEntry {+  groupName    :: String,       -- ^ The name of this group (gr_name)+  groupPassword :: String,      -- ^ The password for this group (gr_passwd)+  groupID      :: GroupID,      -- ^ The unique numeric ID for this group (gr_gid)+  groupMembers :: [String]      -- ^ A list of zero or more usernames that are members (gr_mem)+ } deriving (Show, Read, Eq)++-- | @getGroupEntryForID gid@ calls @getgrgid@ to obtain+--   the @GroupEntry@ information associated with @GroupID@+--   @gid@.+getGroupEntryForID :: GroupID -> IO GroupEntry+#ifdef HAVE_GETGRGID_R+getGroupEntryForID gid = do+  allocaBytes (#const sizeof(struct group)) $ \pgr ->+    allocaBytes grBufSize $ \pbuf ->+      alloca $ \ ppgr -> do+        throwErrorIfNonZero_ "getGroupEntryForID" $+	     c_getgrgid_r gid pgr pbuf (fromIntegral grBufSize) ppgr+	throwErrnoIfNull "getGroupEntryForID" $+	     peekElemOff ppgr 0+	unpackGroupEntry pgr+++foreign import ccall unsafe "getgrgid_r"+  c_getgrgid_r :: CGid -> Ptr CGroup -> CString+		 -> CSize -> Ptr (Ptr CGroup) -> IO CInt+#else+getGroupEntryForID = error "System.Posix.User.getGroupEntryForID: not supported"+#endif++-- | @getGroupEntryForName name@ calls @getgrnam@ to obtain+--   the @GroupEntry@ information associated with the group called+--   @name@.+getGroupEntryForName :: String -> IO GroupEntry+#ifdef HAVE_GETGRNAM_R+getGroupEntryForName name = do+  allocaBytes (#const sizeof(struct group)) $ \pgr ->+    allocaBytes grBufSize $ \pbuf ->+      alloca $ \ ppgr -> +	withCString name $ \ pstr -> do+          throwErrorIfNonZero_ "getGroupEntryForName" $+	     c_getgrnam_r pstr pgr pbuf (fromIntegral grBufSize) ppgr+	  throwErrnoIfNull "getGroupEntryForName" $+	     peekElemOff ppgr 0+	  unpackGroupEntry pgr++foreign import ccall unsafe "getgrnam_r"+  c_getgrnam_r :: CString -> Ptr CGroup -> CString+		 -> CSize -> Ptr (Ptr CGroup) -> IO CInt+#else+getGroupEntryForName = error "System.Posix.User.getGroupEntryForName: not supported"+#endif++-- | @getAllGroupEntries@ returns all group entries on the system by+--   repeatedly calling @getgrent@+getAllGroupEntries :: IO [GroupEntry]+#ifdef HAVE_GETGRENT+getAllGroupEntries =+    withMVar lock $ \_ -> worker []+    where worker accum =+              do resetErrno+                 ppw <- throwErrnoIfNullAndError "getAllGroupEntries" $ +                        c_getgrent+                 if ppw == nullPtr+                     then return (reverse accum)+                     else do thisentry <- unpackGroupEntry ppw+                             worker (thisentry : accum)++foreign import ccall unsafe "getgrent"+  c_getgrent :: IO (Ptr CGroup)+#else+getAllGroupEntries = error "System.Posix.User.getAllGroupEntries: not supported"+#endif++#if defined(HAVE_GETGRGID_R) || defined(HAVE_GETGRNAM_R)+grBufSize :: Int+#if defined(HAVE_SYSCONF) && defined(HAVE_SC_GETGR_R_SIZE_MAX)+grBufSize = fromIntegral $ unsafePerformIO $+		c_sysconf (#const _SC_GETGR_R_SIZE_MAX)+#else+grBufSize = 2048	-- just assume some value (1024 is too small on OpenBSD)+#endif+#endif++unpackGroupEntry :: Ptr CGroup -> IO GroupEntry+unpackGroupEntry ptr = do+   name    <- (#peek struct group, gr_name) ptr >>= peekCString+   passwd  <- (#peek struct group, gr_passwd) ptr >>= peekCString+   gid     <- (#peek struct group, gr_gid) ptr+   mem     <- (#peek struct group, gr_mem) ptr+   members <- peekArray0 nullPtr mem >>= mapM peekCString+   return (GroupEntry name passwd gid members)++-- -----------------------------------------------------------------------------+-- The user database (pwd.h)++data UserEntry =+ UserEntry {+   userName      :: String,     -- ^ Textual name of this user (pw_name)+   userPassword  :: String,     -- ^ Password -- may be empty or fake if shadow is in use (pw_passwd)+   userID        :: UserID,     -- ^ Numeric ID for this user (pw_uid)+   userGroupID   :: GroupID,    -- ^ Primary group ID (pw_gid)+   userGecos     :: String,     -- ^ Usually the real name for the user (pw_gecos)+   homeDirectory :: String,     -- ^ Home directory (pw_dir)+   userShell     :: String      -- ^ Default shell (pw_shell)+ } deriving (Show, Read, Eq)++--+-- getpwuid and getpwnam leave results in a static object. Subsequent+-- calls modify the same object, which isn't threadsafe. We attempt to+-- mitigate this issue, on platforms that don't provide the safe _r versions+--+-- Also, getpwent/setpwent require a global lock since they maintain+-- an internal file position pointer.+#if !defined(HAVE_GETPWNAM_R) || !defined(HAVE_GETPWUID_R) || defined(HAVE_GETPWENT) || defined(HAVE_GETGRENT)+lock = unsafePerformIO $ newMVar ()+{-# NOINLINE lock #-}+#endif++-- | @getUserEntryForID gid@ calls @getpwuid@ to obtain+--   the @UserEntry@ information associated with @UserID@+--   @uid@.+getUserEntryForID :: UserID -> IO UserEntry+#ifdef HAVE_GETPWUID_R+getUserEntryForID uid = do+  allocaBytes (#const sizeof(struct passwd)) $ \ppw ->+    allocaBytes pwBufSize $ \pbuf ->+      alloca $ \ pppw -> do+        throwErrorIfNonZero_ "getUserEntryForID" $+	     c_getpwuid_r uid ppw pbuf (fromIntegral pwBufSize) pppw+	throwErrnoIfNull "getUserEntryForID" $+	     peekElemOff pppw 0+	unpackUserEntry ppw++foreign import ccall unsafe "getpwuid_r"+  c_getpwuid_r :: CUid -> Ptr CPasswd -> +			CString -> CSize -> Ptr (Ptr CPasswd) -> IO CInt+#elif HAVE_GETPWUID+getUserEntryForID uid = do+  withMVar lock $ \_ -> do+    ppw <- throwErrnoIfNull "getUserEntryForID" $ c_getpwuid uid+    unpackUserEntry ppw++foreign import ccall unsafe "getpwuid" +  c_getpwuid :: CUid -> IO (Ptr CPasswd)+#else+getUserEntryForID = error "System.Posix.User.getUserEntryForID: not supported"+#endif++-- | @getUserEntryForName name@ calls @getpwnam@ to obtain+--   the @UserEntry@ information associated with the user login+--   @name@.+getUserEntryForName :: String -> IO UserEntry+#if HAVE_GETPWNAM_R+getUserEntryForName name = do+  allocaBytes (#const sizeof(struct passwd)) $ \ppw ->+    allocaBytes pwBufSize $ \pbuf ->+      alloca $ \ pppw -> +	withCString name $ \ pstr -> do+          throwErrorIfNonZero_ "getUserEntryForName" $+	       c_getpwnam_r pstr ppw pbuf (fromIntegral pwBufSize) pppw+	  throwErrnoIfNull "getUserEntryForName" $+		peekElemOff pppw 0+	  unpackUserEntry ppw++foreign import ccall unsafe "getpwnam_r"+  c_getpwnam_r :: CString -> Ptr CPasswd -> +			CString -> CSize -> Ptr (Ptr CPasswd) -> IO CInt+#elif HAVE_GETPWNAM+getUserEntryForName name = do+  withCString name $ \ pstr -> do+    withMVar lock $ \_ -> do+      ppw <- throwErrnoIfNull "getUserEntryForName" $ c_getpwnam pstr+      unpackUserEntry ppw++foreign import ccall unsafe "getpwnam" +  c_getpwnam :: CString -> IO (Ptr CPasswd)+#else+getUserEntryForName = error "System.Posix.User.getUserEntryForName: not supported"+#endif++-- | @getAllUserEntries@ returns all user entries on the system by +--   repeatedly calling @getpwent@+getAllUserEntries :: IO [UserEntry]+#ifdef HAVE_GETPWENT+getAllUserEntries = +    withMVar lock $ \_ -> worker []+    where worker accum = +              do resetErrno+                 ppw <- throwErrnoIfNullAndError "getAllUserEntries" $ +                        c_getpwent+                 if ppw == nullPtr+                     then return (reverse accum)+                     else do thisentry <- unpackUserEntry ppw+                             worker (thisentry : accum)++foreign import ccall unsafe "getpwent"+  c_getpwent :: IO (Ptr CPasswd)+#else+getAllUserEntries = error "System.Posix.User.getAllUserEntries: not supported"+#endif++#if defined(HAVE_GETPWUID_R) || defined(HAVE_GETPWNAM_R)+pwBufSize :: Int+#if  defined(HAVE_SYSCONF) && defined(HAVE_SC_GETPW_R_SIZE_MAX)+pwBufSize = fromIntegral $ unsafePerformIO $+		c_sysconf (#const _SC_GETPW_R_SIZE_MAX)+#else+pwBufSize = 1024+#endif+#endif++#ifdef HAVE_SYSCONF+foreign import ccall unsafe "sysconf"+  c_sysconf :: CInt -> IO CLong+#endif++unpackUserEntry :: Ptr CPasswd -> IO UserEntry+unpackUserEntry ptr = do+   name   <- (#peek struct passwd, pw_name)   ptr >>= peekCString+   passwd <- (#peek struct passwd, pw_passwd) ptr >>= peekCString+   uid    <- (#peek struct passwd, pw_uid)    ptr+   gid    <- (#peek struct passwd, pw_gid)    ptr+   gecos  <- (#peek struct passwd, pw_gecos)  ptr >>= peekCString+   dir    <- (#peek struct passwd, pw_dir)    ptr >>= peekCString+   shell  <- (#peek struct passwd, pw_shell)  ptr >>= peekCString+   return (UserEntry name passwd uid gid gecos dir shell)++-- Used when calling re-entrant system calls that signal their 'errno' +-- directly through the return value.+throwErrorIfNonZero_ :: String -> IO CInt -> IO ()+throwErrorIfNonZero_ loc act = do+    rc <- act+    if (rc == 0) +     then return ()+     else ioError (errnoToIOError loc (Errno (fromIntegral rc)) Nothing Nothing)++-- Used when a function returns NULL to indicate either an error or+-- EOF, depending on whether the global errno is nonzero.+throwErrnoIfNullAndError :: String -> IO (Ptr a) -> IO (Ptr a)+throwErrnoIfNullAndError loc act = do+    rc <- act+    errno <- getErrno+    if rc == nullPtr && errno /= eOK+       then throwErrno loc+       else return rc
+ cbits/HsUnix.c view
@@ -0,0 +1,12 @@+/* -----------------------------------------------------------------------------+ * $Id: HsUnix.c,v 1.1 2002/09/12 16:38:22 simonmar Exp $+ *+ * (c) The University of Glasgow 2002+ *+ * Definitions for package `unix' which are visible in Haskell land.+ *+ * ---------------------------------------------------------------------------*/++// Out-of-line versions of all the inline functions from HsUnix.h+#define INLINE  /* nothing */+#include "HsUnix.h"
+ configure view
@@ -0,0 +1,5122 @@+#! /bin/sh+# Guess values for system-dependent variables and create Makefiles.+# Generated by GNU Autoconf 2.57 for Haskell unix package 2.0.+#+# Report bugs to <libraries@haskell.org>.+#+# Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002+# Free Software Foundation, Inc.+# This configure script is free software; the Free Software Foundation+# gives unlimited permission to copy, distribute and modify it.+## --------------------- ##+## M4sh Initialization.  ##+## --------------------- ##++# Be Bourne compatible+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then+  emulate sh+  NULLCMD=:+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+  # is contrary to our usage.  Disable this feature.+  alias -g '${1+"$@"}'='"$@"'+elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then+  set -o posix+fi++# Support unset when possible.+if (FOO=FOO; unset FOO) >/dev/null 2>&1; then+  as_unset=unset+else+  as_unset=false+fi+++# Work around bugs in pre-3.0 UWIN ksh.+$as_unset ENV MAIL MAILPATH+PS1='$ '+PS2='> '+PS4='+ '++# NLS nuisances.+for as_var in \+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \+  LC_TELEPHONE LC_TIME+do+  if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then+    eval $as_var=C; export $as_var+  else+    $as_unset $as_var+  fi+done++# Required to use basename.+if expr a : '\(a\)' >/dev/null 2>&1; then+  as_expr=expr+else+  as_expr=false+fi++if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then+  as_basename=basename+else+  as_basename=false+fi+++# Name of the executable.+as_me=`$as_basename "$0" ||+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \+	 X"$0" : 'X\(//\)$' \| \+	 X"$0" : 'X\(/\)$' \| \+	 .     : '\(.\)' 2>/dev/null ||+echo X/"$0" |+    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }+  	  /^X\/\(\/\/\)$/{ s//\1/; q; }+  	  /^X\/\(\/\).*/{ s//\1/; q; }+  	  s/.*/./; q'`+++# PATH needs CR, and LINENO needs CR and PATH.+# Avoid depending upon Character Ranges.+as_cr_letters='abcdefghijklmnopqrstuvwxyz'+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'+as_cr_Letters=$as_cr_letters$as_cr_LETTERS+as_cr_digits='0123456789'+as_cr_alnum=$as_cr_Letters$as_cr_digits++# The user is always right.+if test "${PATH_SEPARATOR+set}" != set; then+  echo "#! /bin/sh" >conf$$.sh+  echo  "exit 0"   >>conf$$.sh+  chmod +x conf$$.sh+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then+    PATH_SEPARATOR=';'+  else+    PATH_SEPARATOR=:+  fi+  rm -f conf$$.sh+fi+++  as_lineno_1=$LINENO+  as_lineno_2=$LINENO+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`+  test "x$as_lineno_1" != "x$as_lineno_2" &&+  test "x$as_lineno_3"  = "x$as_lineno_2"  || {+  # Find who we are.  Look in the path if we contain no path at all+  # relative or not.+  case $0 in+    *[\\/]* ) as_myself=$0 ;;+    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break+done++       ;;+  esac+  # We did not find ourselves, most probably we were run as `sh COMMAND'+  # in which case we are not to be found in the path.+  if test "x$as_myself" = x; then+    as_myself=$0+  fi+  if test ! -f "$as_myself"; then+    { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2+   { (exit 1); exit 1; }; }+  fi+  case $CONFIG_SHELL in+  '')+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for as_base in sh bash ksh sh5; do+	 case $as_dir in+	 /*)+	   if ("$as_dir/$as_base" -c '+  as_lineno_1=$LINENO+  as_lineno_2=$LINENO+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`+  test "x$as_lineno_1" != "x$as_lineno_2" &&+  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then+	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }+	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }+	     CONFIG_SHELL=$as_dir/$as_base+	     export CONFIG_SHELL+	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}+	   fi;;+	 esac+       done+done+;;+  esac++  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO+  # uniformly replaced by the line number.  The first 'sed' inserts a+  # line-number line before each line; the second 'sed' does the real+  # work.  The second script uses 'N' to pair each line-number line+  # with the numbered line, and appends trailing '-' during+  # substitution so that $LINENO is not a special case at line end.+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the+  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)+  sed '=' <$as_myself |+    sed '+      N+      s,$,-,+      : loop+      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,+      t loop+      s,-$,,+      s,^['$as_cr_digits']*\n,,+    ' >$as_me.lineno &&+  chmod +x $as_me.lineno ||+    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2+   { (exit 1); exit 1; }; }++  # Don't try to exec as it changes $[0], causing all sort of problems+  # (the dirname of $[0] is not the place where we might find the+  # original and so on.  Autoconf is especially sensible to this).+  . ./$as_me.lineno+  # Exit status is that of the last command.+  exit+}+++case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in+  *c*,-n*) ECHO_N= ECHO_C='+' ECHO_T='	' ;;+  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;+  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;+esac++if expr a : '\(a\)' >/dev/null 2>&1; then+  as_expr=expr+else+  as_expr=false+fi++rm -f conf$$ conf$$.exe conf$$.file+echo >conf$$.file+if ln -s conf$$.file conf$$ 2>/dev/null; then+  # We could just check for DJGPP; but this test a) works b) is more generic+  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).+  if test -f conf$$.exe; then+    # Don't use ln at all; we don't have any links+    as_ln_s='cp -p'+  else+    as_ln_s='ln -s'+  fi+elif ln conf$$.file conf$$ 2>/dev/null; then+  as_ln_s=ln+else+  as_ln_s='cp -p'+fi+rm -f conf$$ conf$$.exe conf$$.file++if mkdir -p . 2>/dev/null; then+  as_mkdir_p=:+else+  as_mkdir_p=false+fi++as_executable_p="test -f"++# Sed expression to map a string onto a valid CPP name.+as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"++# Sed expression to map a string onto a valid variable name.+as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"+++# IFS+# We need space, tab and new line, in precisely that order.+as_nl='+'+IFS=" 	$as_nl"++# CDPATH.+$as_unset CDPATH+++# Name of the host.+# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,+# so uname gets run too.+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`++exec 6>&1++#+# Initializations.+#+ac_default_prefix=/usr/local+ac_config_libobj_dir=.+cross_compiling=no+subdirs=+MFLAGS=+MAKEFLAGS=+SHELL=${CONFIG_SHELL-/bin/sh}++# Maximum number of lines to put in a shell here document.+# This variable seems obsolete.  It should probably be removed, and+# only ac_max_sed_lines should be used.+: ${ac_max_here_lines=38}++# Identity of this package.+PACKAGE_NAME='Haskell unix package'+PACKAGE_TARNAME='unix'+PACKAGE_VERSION='2.0'+PACKAGE_STRING='Haskell unix package 2.0'+PACKAGE_BUGREPORT='libraries@haskell.org'++ac_unique_file="include/HsUnix.h"+# Factoring default headers for most tests.+ac_includes_default="\+#include <stdio.h>+#if HAVE_SYS_TYPES_H+# include <sys/types.h>+#endif+#if HAVE_SYS_STAT_H+# include <sys/stat.h>+#endif+#if STDC_HEADERS+# include <stdlib.h>+# include <stddef.h>+#else+# if HAVE_STDLIB_H+#  include <stdlib.h>+# endif+#endif+#if HAVE_STRING_H+# if !STDC_HEADERS && HAVE_MEMORY_H+#  include <memory.h>+# endif+# include <string.h>+#endif+#if HAVE_STRINGS_H+# include <strings.h>+#endif+#if HAVE_INTTYPES_H+# include <inttypes.h>+#else+# if HAVE_STDINT_H+#  include <stdint.h>+# endif+#endif+#if HAVE_UNISTD_H+# include <unistd.h>+#endif"++ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CPP EGREP BUILD_PACKAGE_BOOL EXTRA_LIBS LIBOBJS LTLIBOBJS'+ac_subst_files=''++# Initialize some variables set by options.+ac_init_help=+ac_init_version=false+# The variables have the same names as the options, with+# dashes changed to underlines.+cache_file=/dev/null+exec_prefix=NONE+no_create=+no_recursion=+prefix=NONE+program_prefix=NONE+program_suffix=NONE+program_transform_name=s,x,x,+silent=+site=+srcdir=+verbose=+x_includes=NONE+x_libraries=NONE++# Installation directory options.+# These are left unexpanded so users can "make install exec_prefix=/foo"+# and all the variables that are supposed to be based on exec_prefix+# by default will actually change.+# Use braces instead of parens because sh, perl, etc. also accept them.+bindir='${exec_prefix}/bin'+sbindir='${exec_prefix}/sbin'+libexecdir='${exec_prefix}/libexec'+datadir='${prefix}/share'+sysconfdir='${prefix}/etc'+sharedstatedir='${prefix}/com'+localstatedir='${prefix}/var'+libdir='${exec_prefix}/lib'+includedir='${prefix}/include'+oldincludedir='/usr/include'+infodir='${prefix}/info'+mandir='${prefix}/man'++ac_prev=+for ac_option+do+  # If the previous option needs an argument, assign it.+  if test -n "$ac_prev"; then+    eval "$ac_prev=\$ac_option"+    ac_prev=+    continue+  fi++  ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`++  # Accept the important Cygnus configure options, so we can diagnose typos.++  case $ac_option in++  -bindir | --bindir | --bindi | --bind | --bin | --bi)+    ac_prev=bindir ;;+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)+    bindir=$ac_optarg ;;++  -build | --build | --buil | --bui | --bu)+    ac_prev=build_alias ;;+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)+    build_alias=$ac_optarg ;;++  -cache-file | --cache-file | --cache-fil | --cache-fi \+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)+    ac_prev=cache_file ;;+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)+    cache_file=$ac_optarg ;;++  --config-cache | -C)+    cache_file=config.cache ;;++  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)+    ac_prev=datadir ;;+  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \+  | --da=*)+    datadir=$ac_optarg ;;++  -disable-* | --disable-*)+    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`+    # Reject names that are not valid shell variable names.+    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&+      { echo "$as_me: error: invalid feature name: $ac_feature" >&2+   { (exit 1); exit 1; }; }+    ac_feature=`echo $ac_feature | sed 's/-/_/g'`+    eval "enable_$ac_feature=no" ;;++  -enable-* | --enable-*)+    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`+    # Reject names that are not valid shell variable names.+    expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&+      { echo "$as_me: error: invalid feature name: $ac_feature" >&2+   { (exit 1); exit 1; }; }+    ac_feature=`echo $ac_feature | sed 's/-/_/g'`+    case $ac_option in+      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;+      *) ac_optarg=yes ;;+    esac+    eval "enable_$ac_feature='$ac_optarg'" ;;++  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \+  | --exec | --exe | --ex)+    ac_prev=exec_prefix ;;+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \+  | --exec=* | --exe=* | --ex=*)+    exec_prefix=$ac_optarg ;;++  -gas | --gas | --ga | --g)+    # Obsolete; use --with-gas.+    with_gas=yes ;;++  -help | --help | --hel | --he | -h)+    ac_init_help=long ;;+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)+    ac_init_help=recursive ;;+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)+    ac_init_help=short ;;++  -host | --host | --hos | --ho)+    ac_prev=host_alias ;;+  -host=* | --host=* | --hos=* | --ho=*)+    host_alias=$ac_optarg ;;++  -includedir | --includedir | --includedi | --included | --include \+  | --includ | --inclu | --incl | --inc)+    ac_prev=includedir ;;+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \+  | --includ=* | --inclu=* | --incl=* | --inc=*)+    includedir=$ac_optarg ;;++  -infodir | --infodir | --infodi | --infod | --info | --inf)+    ac_prev=infodir ;;+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)+    infodir=$ac_optarg ;;++  -libdir | --libdir | --libdi | --libd)+    ac_prev=libdir ;;+  -libdir=* | --libdir=* | --libdi=* | --libd=*)+    libdir=$ac_optarg ;;++  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \+  | --libexe | --libex | --libe)+    ac_prev=libexecdir ;;+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \+  | --libexe=* | --libex=* | --libe=*)+    libexecdir=$ac_optarg ;;++  -localstatedir | --localstatedir | --localstatedi | --localstated \+  | --localstate | --localstat | --localsta | --localst \+  | --locals | --local | --loca | --loc | --lo)+    ac_prev=localstatedir ;;+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \+  | --localstate=* | --localstat=* | --localsta=* | --localst=* \+  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)+    localstatedir=$ac_optarg ;;++  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)+    ac_prev=mandir ;;+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)+    mandir=$ac_optarg ;;++  -nfp | --nfp | --nf)+    # Obsolete; use --without-fp.+    with_fp=no ;;++  -no-create | --no-create | --no-creat | --no-crea | --no-cre \+  | --no-cr | --no-c | -n)+    no_create=yes ;;++  -no-recursion | --no-recursion | --no-recursio | --no-recursi \+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)+    no_recursion=yes ;;++  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \+  | --oldin | --oldi | --old | --ol | --o)+    ac_prev=oldincludedir ;;+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)+    oldincludedir=$ac_optarg ;;++  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)+    ac_prev=prefix ;;+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)+    prefix=$ac_optarg ;;++  -program-prefix | --program-prefix | --program-prefi | --program-pref \+  | --program-pre | --program-pr | --program-p)+    ac_prev=program_prefix ;;+  -program-prefix=* | --program-prefix=* | --program-prefi=* \+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)+    program_prefix=$ac_optarg ;;++  -program-suffix | --program-suffix | --program-suffi | --program-suff \+  | --program-suf | --program-su | --program-s)+    ac_prev=program_suffix ;;+  -program-suffix=* | --program-suffix=* | --program-suffi=* \+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)+    program_suffix=$ac_optarg ;;++  -program-transform-name | --program-transform-name \+  | --program-transform-nam | --program-transform-na \+  | --program-transform-n | --program-transform- \+  | --program-transform | --program-transfor \+  | --program-transfo | --program-transf \+  | --program-trans | --program-tran \+  | --progr-tra | --program-tr | --program-t)+    ac_prev=program_transform_name ;;+  -program-transform-name=* | --program-transform-name=* \+  | --program-transform-nam=* | --program-transform-na=* \+  | --program-transform-n=* | --program-transform-=* \+  | --program-transform=* | --program-transfor=* \+  | --program-transfo=* | --program-transf=* \+  | --program-trans=* | --program-tran=* \+  | --progr-tra=* | --program-tr=* | --program-t=*)+    program_transform_name=$ac_optarg ;;++  -q | -quiet | --quiet | --quie | --qui | --qu | --q \+  | -silent | --silent | --silen | --sile | --sil)+    silent=yes ;;++  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)+    ac_prev=sbindir ;;+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \+  | --sbi=* | --sb=*)+    sbindir=$ac_optarg ;;++  -sharedstatedir | --sharedstatedir | --sharedstatedi \+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \+  | --sharedst | --shareds | --shared | --share | --shar \+  | --sha | --sh)+    ac_prev=sharedstatedir ;;+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \+  | --sha=* | --sh=*)+    sharedstatedir=$ac_optarg ;;++  -site | --site | --sit)+    ac_prev=site ;;+  -site=* | --site=* | --sit=*)+    site=$ac_optarg ;;++  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)+    ac_prev=srcdir ;;+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)+    srcdir=$ac_optarg ;;++  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \+  | --syscon | --sysco | --sysc | --sys | --sy)+    ac_prev=sysconfdir ;;+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)+    sysconfdir=$ac_optarg ;;++  -target | --target | --targe | --targ | --tar | --ta | --t)+    ac_prev=target_alias ;;+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)+    target_alias=$ac_optarg ;;++  -v | -verbose | --verbose | --verbos | --verbo | --verb)+    verbose=yes ;;++  -version | --version | --versio | --versi | --vers | -V)+    ac_init_version=: ;;++  -with-* | --with-*)+    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`+    # Reject names that are not valid shell variable names.+    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&+      { echo "$as_me: error: invalid package name: $ac_package" >&2+   { (exit 1); exit 1; }; }+    ac_package=`echo $ac_package| sed 's/-/_/g'`+    case $ac_option in+      *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;+      *) ac_optarg=yes ;;+    esac+    eval "with_$ac_package='$ac_optarg'" ;;++  -without-* | --without-*)+    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`+    # Reject names that are not valid shell variable names.+    expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&+      { echo "$as_me: error: invalid package name: $ac_package" >&2+   { (exit 1); exit 1; }; }+    ac_package=`echo $ac_package | sed 's/-/_/g'`+    eval "with_$ac_package=no" ;;++  --x)+    # Obsolete; use --with-x.+    with_x=yes ;;++  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \+  | --x-incl | --x-inc | --x-in | --x-i)+    ac_prev=x_includes ;;+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)+    x_includes=$ac_optarg ;;++  -x-libraries | --x-libraries | --x-librarie | --x-librari \+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)+    ac_prev=x_libraries ;;+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)+    x_libraries=$ac_optarg ;;++  -*) { echo "$as_me: error: unrecognized option: $ac_option+Try \`$0 --help' for more information." >&2+   { (exit 1); exit 1; }; }+    ;;++  *=*)+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`+    # Reject names that are not valid shell variable names.+    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&+      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2+   { (exit 1); exit 1; }; }+    ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`+    eval "$ac_envvar='$ac_optarg'"+    export $ac_envvar ;;++  *)+    # FIXME: should be removed in autoconf 3.0.+    echo "$as_me: WARNING: you should use --build, --host, --target" >&2+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&+      echo "$as_me: WARNING: invalid host type: $ac_option" >&2+    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}+    ;;++  esac+done++if test -n "$ac_prev"; then+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`+  { echo "$as_me: error: missing argument to $ac_option" >&2+   { (exit 1); exit 1; }; }+fi++# Be sure to have absolute paths.+for ac_var in exec_prefix prefix+do+  eval ac_val=$`echo $ac_var`+  case $ac_val in+    [\\/$]* | ?:[\\/]* | NONE | '' ) ;;+    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2+   { (exit 1); exit 1; }; };;+  esac+done++# Be sure to have absolute paths.+for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \+              localstatedir libdir includedir oldincludedir infodir mandir+do+  eval ac_val=$`echo $ac_var`+  case $ac_val in+    [\\/$]* | ?:[\\/]* ) ;;+    *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2+   { (exit 1); exit 1; }; };;+  esac+done++# There might be people who depend on the old broken behavior: `$host'+# used to hold the argument of --host etc.+# FIXME: To remove some day.+build=$build_alias+host=$host_alias+target=$target_alias++# FIXME: To remove some day.+if test "x$host_alias" != x; then+  if test "x$build_alias" = x; then+    cross_compiling=maybe+    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.+    If a cross compiler is detected then cross compile mode will be used." >&2+  elif test "x$build_alias" != "x$host_alias"; then+    cross_compiling=yes+  fi+fi++ac_tool_prefix=+test -n "$host_alias" && ac_tool_prefix=$host_alias-++test "$silent" = yes && exec 6>/dev/null+++# Find the source files, if location was not specified.+if test -z "$srcdir"; then+  ac_srcdir_defaulted=yes+  # Try the directory containing this script, then its parent.+  ac_confdir=`(dirname "$0") 2>/dev/null ||+$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+         X"$0" : 'X\(//\)[^/]' \| \+         X"$0" : 'X\(//\)$' \| \+         X"$0" : 'X\(/\)' \| \+         .     : '\(.\)' 2>/dev/null ||+echo X"$0" |+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }+  	  /^X\(\/\/\)$/{ s//\1/; q; }+  	  /^X\(\/\).*/{ s//\1/; q; }+  	  s/.*/./; q'`+  srcdir=$ac_confdir+  if test ! -r $srcdir/$ac_unique_file; then+    srcdir=..+  fi+else+  ac_srcdir_defaulted=no+fi+if test ! -r $srcdir/$ac_unique_file; then+  if test "$ac_srcdir_defaulted" = yes; then+    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2+   { (exit 1); exit 1; }; }+  else+    { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2+   { (exit 1); exit 1; }; }+  fi+fi+(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||+  { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2+   { (exit 1); exit 1; }; }+srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`+ac_env_build_alias_set=${build_alias+set}+ac_env_build_alias_value=$build_alias+ac_cv_env_build_alias_set=${build_alias+set}+ac_cv_env_build_alias_value=$build_alias+ac_env_host_alias_set=${host_alias+set}+ac_env_host_alias_value=$host_alias+ac_cv_env_host_alias_set=${host_alias+set}+ac_cv_env_host_alias_value=$host_alias+ac_env_target_alias_set=${target_alias+set}+ac_env_target_alias_value=$target_alias+ac_cv_env_target_alias_set=${target_alias+set}+ac_cv_env_target_alias_value=$target_alias+ac_env_CC_set=${CC+set}+ac_env_CC_value=$CC+ac_cv_env_CC_set=${CC+set}+ac_cv_env_CC_value=$CC+ac_env_CFLAGS_set=${CFLAGS+set}+ac_env_CFLAGS_value=$CFLAGS+ac_cv_env_CFLAGS_set=${CFLAGS+set}+ac_cv_env_CFLAGS_value=$CFLAGS+ac_env_LDFLAGS_set=${LDFLAGS+set}+ac_env_LDFLAGS_value=$LDFLAGS+ac_cv_env_LDFLAGS_set=${LDFLAGS+set}+ac_cv_env_LDFLAGS_value=$LDFLAGS+ac_env_CPPFLAGS_set=${CPPFLAGS+set}+ac_env_CPPFLAGS_value=$CPPFLAGS+ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}+ac_cv_env_CPPFLAGS_value=$CPPFLAGS+ac_env_CPP_set=${CPP+set}+ac_env_CPP_value=$CPP+ac_cv_env_CPP_set=${CPP+set}+ac_cv_env_CPP_value=$CPP++#+# Report the --help message.+#+if test "$ac_init_help" = "long"; then+  # Omit some internal or obsolete options to make the list less imposing.+  # This message is too long to be a string in the A/UX 3.1 sh.+  cat <<_ACEOF+\`configure' configures Haskell unix package 2.0 to adapt to many kinds of systems.++Usage: $0 [OPTION]... [VAR=VALUE]...++To assign environment variables (e.g., CC, CFLAGS...), specify them as+VAR=VALUE.  See below for descriptions of some of the useful variables.++Defaults for the options are specified in brackets.++Configuration:+  -h, --help              display this help and exit+      --help=short        display options specific to this package+      --help=recursive    display the short help of all the included packages+  -V, --version           display version information and exit+  -q, --quiet, --silent   do not print \`checking...' messages+      --cache-file=FILE   cache test results in FILE [disabled]+  -C, --config-cache      alias for \`--cache-file=config.cache'+  -n, --no-create         do not create output files+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']++_ACEOF++  cat <<_ACEOF+Installation directories:+  --prefix=PREFIX         install architecture-independent files in PREFIX+                          [$ac_default_prefix]+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX+                          [PREFIX]++By default, \`make install' will install all the files in+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify+an installation prefix other than \`$ac_default_prefix' using \`--prefix',+for instance \`--prefix=\$HOME'.++For better control, use the options below.++Fine tuning of the installation directories:+  --bindir=DIR           user executables [EPREFIX/bin]+  --sbindir=DIR          system admin executables [EPREFIX/sbin]+  --libexecdir=DIR       program executables [EPREFIX/libexec]+  --datadir=DIR          read-only architecture-independent data [PREFIX/share]+  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]+  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]+  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]+  --libdir=DIR           object code libraries [EPREFIX/lib]+  --includedir=DIR       C header files [PREFIX/include]+  --oldincludedir=DIR    C header files for non-gcc [/usr/include]+  --infodir=DIR          info documentation [PREFIX/info]+  --mandir=DIR           man documentation [PREFIX/man]+_ACEOF++  cat <<\_ACEOF+_ACEOF+fi++if test -n "$ac_init_help"; then+  case $ac_init_help in+     short | recursive ) echo "Configuration of Haskell unix package 2.0:";;+   esac+  cat <<\_ACEOF++Some influential environment variables:+  CC          C compiler command+  CFLAGS      C compiler flags+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a+              nonstandard directory <lib dir>+  CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have+              headers in a nonstandard directory <include dir>+  CPP         C preprocessor++Use these variables to override the choices made by `configure' or to help+it to find libraries and programs with nonstandard names/locations.++Report bugs to <libraries@haskell.org>.+_ACEOF+fi++if test "$ac_init_help" = "recursive"; then+  # If there are subdirs, report their specific --help.+  ac_popdir=`pwd`+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue+    test -d $ac_dir || continue+    ac_builddir=.++if test "$ac_dir" != .; then+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`+  # A "../" for each directory in $ac_dir_suffix.+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`+else+  ac_dir_suffix= ac_top_builddir=+fi++case $srcdir in+  .)  # No --srcdir option.  We are building in place.+    ac_srcdir=.+    if test -z "$ac_top_builddir"; then+       ac_top_srcdir=.+    else+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`+    fi ;;+  [\\/]* | ?:[\\/]* )  # Absolute path.+    ac_srcdir=$srcdir$ac_dir_suffix;+    ac_top_srcdir=$srcdir ;;+  *) # Relative path.+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix+    ac_top_srcdir=$ac_top_builddir$srcdir ;;+esac+# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be+# absolute.+ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`+ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd`+ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`+ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`++    cd $ac_dir+    # Check for guested configure; otherwise get Cygnus style configure.+    if test -f $ac_srcdir/configure.gnu; then+      echo+      $SHELL $ac_srcdir/configure.gnu  --help=recursive+    elif test -f $ac_srcdir/configure; then+      echo+      $SHELL $ac_srcdir/configure  --help=recursive+    elif test -f $ac_srcdir/configure.ac ||+           test -f $ac_srcdir/configure.in; then+      echo+      $ac_configure --help+    else+      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2+    fi+    cd $ac_popdir+  done+fi++test -n "$ac_init_help" && exit 0+if $ac_init_version; then+  cat <<\_ACEOF+Haskell unix package configure 2.0+generated by GNU Autoconf 2.57++Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002+Free Software Foundation, Inc.+This configure script is free software; the Free Software Foundation+gives unlimited permission to copy, distribute and modify it.+_ACEOF+  exit 0+fi+exec 5>config.log+cat >&5 <<_ACEOF+This file contains any messages produced by compilers while+running configure, to aid debugging if configure makes a mistake.++It was created by Haskell unix package $as_me 2.0, which was+generated by GNU Autoconf 2.57.  Invocation command line was++  $ $0 $@++_ACEOF+{+cat <<_ASUNAME+## --------- ##+## Platform. ##+## --------- ##++hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`+uname -m = `(uname -m) 2>/dev/null || echo unknown`+uname -r = `(uname -r) 2>/dev/null || echo unknown`+uname -s = `(uname -s) 2>/dev/null || echo unknown`+uname -v = `(uname -v) 2>/dev/null || echo unknown`++/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`++/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`+hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`++_ASUNAME++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  echo "PATH: $as_dir"+done++} >&5++cat >&5 <<_ACEOF+++## ----------- ##+## Core tests. ##+## ----------- ##++_ACEOF+++# Keep a trace of the command line.+# Strip out --no-create and --no-recursion so they do not pile up.+# Strip out --silent because we don't want to record it for future runs.+# Also quote any args containing shell meta-characters.+# Make two passes to allow for proper duplicate-argument suppression.+ac_configure_args=+ac_configure_args0=+ac_configure_args1=+ac_sep=+ac_must_keep_next=false+for ac_pass in 1 2+do+  for ac_arg+  do+    case $ac_arg in+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \+    | -silent | --silent | --silen | --sile | --sil)+      continue ;;+    *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)+      ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;+    esac+    case $ac_pass in+    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;+    2)+      ac_configure_args1="$ac_configure_args1 '$ac_arg'"+      if test $ac_must_keep_next = true; then+        ac_must_keep_next=false # Got value, back to normal.+      else+        case $ac_arg in+          *=* | --config-cache | -C | -disable-* | --disable-* \+          | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \+          | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \+          | -with-* | --with-* | -without-* | --without-* | --x)+            case "$ac_configure_args0 " in+              "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;+            esac+            ;;+          -* ) ac_must_keep_next=true ;;+        esac+      fi+      ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"+      # Get rid of the leading space.+      ac_sep=" "+      ;;+    esac+  done+done+$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }+$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }++# When interrupted or exit'd, cleanup temporary files, and complete+# config.log.  We remove comments because anyway the quotes in there+# would cause problems or look ugly.+# WARNING: Be sure not to use single quotes in there, as some shells,+# such as our DU 5.0 friend, will then `close' the trap.+trap 'exit_status=$?+  # Save into config.log some information that might help in debugging.+  {+    echo++    cat <<\_ASBOX+## ---------------- ##+## Cache variables. ##+## ---------------- ##+_ASBOX+    echo+    # The following way of writing the cache mishandles newlines in values,+{+  (set) 2>&1 |+    case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in+    *ac_space=\ *)+      sed -n \+        "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;+    	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"+      ;;+    *)+      sed -n \+        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"+      ;;+    esac;+}+    echo++    cat <<\_ASBOX+## ----------------- ##+## Output variables. ##+## ----------------- ##+_ASBOX+    echo+    for ac_var in $ac_subst_vars+    do+      eval ac_val=$`echo $ac_var`+      echo "$ac_var='"'"'$ac_val'"'"'"+    done | sort+    echo++    if test -n "$ac_subst_files"; then+      cat <<\_ASBOX+## ------------- ##+## Output files. ##+## ------------- ##+_ASBOX+      echo+      for ac_var in $ac_subst_files+      do+	eval ac_val=$`echo $ac_var`+        echo "$ac_var='"'"'$ac_val'"'"'"+      done | sort+      echo+    fi++    if test -s confdefs.h; then+      cat <<\_ASBOX+## ----------- ##+## confdefs.h. ##+## ----------- ##+_ASBOX+      echo+      sed "/^$/d" confdefs.h | sort+      echo+    fi+    test "$ac_signal" != 0 &&+      echo "$as_me: caught signal $ac_signal"+    echo "$as_me: exit $exit_status"+  } >&5+  rm -f core core.* *.core &&+  rm -rf conftest* confdefs* conf$$* $ac_clean_files &&+    exit $exit_status+     ' 0+for ac_signal in 1 2 13 15; do+  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal+done+ac_signal=0++# confdefs.h avoids OS command line length limits that DEFS can exceed.+rm -rf conftest* confdefs.h+# AIX cpp loses on an empty file, so make sure it contains at least a newline.+echo >confdefs.h++# Predefined preprocessor variables.++cat >>confdefs.h <<_ACEOF+#define PACKAGE_NAME "$PACKAGE_NAME"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_VERSION "$PACKAGE_VERSION"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_STRING "$PACKAGE_STRING"+_ACEOF+++cat >>confdefs.h <<_ACEOF+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"+_ACEOF+++# Let the site file select an alternate cache file if it wants to.+# Prefer explicitly selected file to automatically selected ones.+if test -z "$CONFIG_SITE"; then+  if test "x$prefix" != xNONE; then+    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"+  else+    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"+  fi+fi+for ac_site_file in $CONFIG_SITE; do+  if test -r "$ac_site_file"; then+    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5+echo "$as_me: loading site script $ac_site_file" >&6;}+    sed 's/^/| /' "$ac_site_file" >&5+    . "$ac_site_file"+  fi+done++if test -r "$cache_file"; then+  # Some versions of bash will fail to source /dev/null (special+  # files actually), so we avoid doing that.+  if test -f "$cache_file"; then+    { echo "$as_me:$LINENO: loading cache $cache_file" >&5+echo "$as_me: loading cache $cache_file" >&6;}+    case $cache_file in+      [\\/]* | ?:[\\/]* ) . $cache_file;;+      *)                      . ./$cache_file;;+    esac+  fi+else+  { echo "$as_me:$LINENO: creating cache $cache_file" >&5+echo "$as_me: creating cache $cache_file" >&6;}+  >$cache_file+fi++# Check that the precious variables saved in the cache have kept the same+# value.+ac_cache_corrupted=false+for ac_var in `(set) 2>&1 |+               sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do+  eval ac_old_set=\$ac_cv_env_${ac_var}_set+  eval ac_new_set=\$ac_env_${ac_var}_set+  eval ac_old_val="\$ac_cv_env_${ac_var}_value"+  eval ac_new_val="\$ac_env_${ac_var}_value"+  case $ac_old_set,$ac_new_set in+    set,)+      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5+echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}+      ac_cache_corrupted=: ;;+    ,set)+      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5+echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}+      ac_cache_corrupted=: ;;+    ,);;+    *)+      if test "x$ac_old_val" != "x$ac_new_val"; then+        { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5+echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}+        { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5+echo "$as_me:   former value:  $ac_old_val" >&2;}+        { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5+echo "$as_me:   current value: $ac_new_val" >&2;}+        ac_cache_corrupted=:+      fi;;+  esac+  # Pass precious variables to config.status.+  if test "$ac_new_set" = set; then+    case $ac_new_val in+    *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)+      ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;+    *) ac_arg=$ac_var=$ac_new_val ;;+    esac+    case " $ac_configure_args " in+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.+      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;+    esac+  fi+done+if $ac_cache_corrupted; then+  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5+echo "$as_me: error: changes in the environment can compromise the build" >&2;}+  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5+echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}+   { (exit 1); exit 1; }; }+fi++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+++++++++++++++++++++++++++++# Safety check: Ensure that we are in the correct source directory.+++          ac_config_headers="$ac_config_headers include/HsUnixConfig.h"+++# Is this a Unix system?+ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+if test -n "$ac_tool_prefix"; then+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.+set dummy ${ac_tool_prefix}gcc; ac_word=$2+echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6+if test "${ac_cv_prog_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$CC"; then+  ac_cv_prog_CC="$CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then+    ac_cv_prog_CC="${ac_tool_prefix}gcc"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done++fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+  echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6+else+  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6+fi++fi+if test -z "$ac_cv_prog_CC"; then+  ac_ct_CC=$CC+  # Extract the first word of "gcc", so it can be a program name with args.+set dummy gcc; ac_word=$2+echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$ac_ct_CC"; then+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then+    ac_cv_prog_ac_ct_CC="gcc"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done++fi+fi+ac_ct_CC=$ac_cv_prog_ac_ct_CC+if test -n "$ac_ct_CC"; then+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5+echo "${ECHO_T}$ac_ct_CC" >&6+else+  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6+fi++  CC=$ac_ct_CC+else+  CC="$ac_cv_prog_CC"+fi++if test -z "$CC"; then+  if test -n "$ac_tool_prefix"; then+  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.+set dummy ${ac_tool_prefix}cc; ac_word=$2+echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6+if test "${ac_cv_prog_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$CC"; then+  ac_cv_prog_CC="$CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then+    ac_cv_prog_CC="${ac_tool_prefix}cc"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done++fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+  echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6+else+  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6+fi++fi+if test -z "$ac_cv_prog_CC"; then+  ac_ct_CC=$CC+  # Extract the first word of "cc", so it can be a program name with args.+set dummy cc; ac_word=$2+echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$ac_ct_CC"; then+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then+    ac_cv_prog_ac_ct_CC="cc"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done++fi+fi+ac_ct_CC=$ac_cv_prog_ac_ct_CC+if test -n "$ac_ct_CC"; then+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5+echo "${ECHO_T}$ac_ct_CC" >&6+else+  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6+fi++  CC=$ac_ct_CC+else+  CC="$ac_cv_prog_CC"+fi++fi+if test -z "$CC"; then+  # Extract the first word of "cc", so it can be a program name with args.+set dummy cc; ac_word=$2+echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6+if test "${ac_cv_prog_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$CC"; then+  ac_cv_prog_CC="$CC" # Let the user override the test.+else+  ac_prog_rejected=no+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then+       ac_prog_rejected=yes+       continue+     fi+    ac_cv_prog_CC="cc"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done++if test $ac_prog_rejected = yes; then+  # We found a bogon in the path, so make sure we never use it.+  set dummy $ac_cv_prog_CC+  shift+  if test $# != 0; then+    # We chose a different compiler from the bogus one.+    # However, it has the same basename, so the bogon will be chosen+    # first if we set CC to just the basename; use the full file name.+    shift+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"+  fi+fi+fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+  echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6+else+  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6+fi++fi+if test -z "$CC"; then+  if test -n "$ac_tool_prefix"; then+  for ac_prog in cl+  do+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.+set dummy $ac_tool_prefix$ac_prog; ac_word=$2+echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6+if test "${ac_cv_prog_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$CC"; then+  ac_cv_prog_CC="$CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done++fi+fi+CC=$ac_cv_prog_CC+if test -n "$CC"; then+  echo "$as_me:$LINENO: result: $CC" >&5+echo "${ECHO_T}$CC" >&6+else+  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6+fi++    test -n "$CC" && break+  done+fi+if test -z "$CC"; then+  ac_ct_CC=$CC+  for ac_prog in cl+do+  # Extract the first word of "$ac_prog", so it can be a program name with args.+set dummy $ac_prog; ac_word=$2+echo "$as_me:$LINENO: checking for $ac_word" >&5+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if test -n "$ac_ct_CC"; then+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.+else+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for ac_exec_ext in '' $ac_executable_extensions; do+  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then+    ac_cv_prog_ac_ct_CC="$ac_prog"+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5+    break 2+  fi+done+done++fi+fi+ac_ct_CC=$ac_cv_prog_ac_ct_CC+if test -n "$ac_ct_CC"; then+  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5+echo "${ECHO_T}$ac_ct_CC" >&6+else+  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6+fi++  test -n "$ac_ct_CC" && break+done++  CC=$ac_ct_CC+fi++fi+++test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH+See \`config.log' for more details." >&5+echo "$as_me: error: no acceptable C compiler found in \$PATH+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }++# Provide some information about the compiler.+echo "$as_me:$LINENO:" \+     "checking for C compiler version" >&5+ac_compiler=`set X $ac_compile; echo $2`+{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5+  (eval $ac_compiler --version </dev/null >&5) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5+  (eval $ac_compiler -v </dev/null >&5) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5+  (eval $ac_compiler -V </dev/null >&5) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }++cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++int+main ()+{++  ;+  return 0;+}+_ACEOF+ac_clean_files_save=$ac_clean_files+ac_clean_files="$ac_clean_files a.out a.exe b.out"+# Try to create an executable without -o first, disregard a.out.+# It will help us diagnose broken compilers, and finding out an intuition+# of exeext.+echo "$as_me:$LINENO: checking for C compiler default output" >&5+echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6+ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`+if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5+  (eval $ac_link_default) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; then+  # Find the output, starting from the most likely.  This scheme is+# not robust to junk in `.', hence go to wildcards (a.*) only as a last+# resort.++# Be careful to initialize this variable, since it used to be cached.+# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.+ac_cv_exeext=+# b.out is created by i960 compilers.+for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out+do+  test -f "$ac_file" || continue+  case $ac_file in+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )+        ;;+    conftest.$ac_ext )+        # This is the source file.+        ;;+    [ab].out )+        # We found the default executable, but exeext='' is most+        # certainly right.+        break;;+    *.* )+        ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`+        # FIXME: I believe we export ac_cv_exeext for Libtool,+        # but it would be cool to find out if it's true.  Does anybody+        # maintain Libtool? --akim.+        export ac_cv_exeext+        break;;+    * )+        break;;+  esac+done+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++{ { echo "$as_me:$LINENO: error: C compiler cannot create executables+See \`config.log' for more details." >&5+echo "$as_me: error: C compiler cannot create executables+See \`config.log' for more details." >&2;}+   { (exit 77); exit 77; }; }+fi++ac_exeext=$ac_cv_exeext+echo "$as_me:$LINENO: result: $ac_file" >&5+echo "${ECHO_T}$ac_file" >&6++# Check the compiler produces executables we can run.  If not, either+# the compiler is broken, or we cross compile.+echo "$as_me:$LINENO: checking whether the C compiler works" >&5+echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6+# FIXME: These cross compiler hacks should be removed for Autoconf 3.0+# If not cross compiling, check that we can run a simple program.+if test "$cross_compiling" != yes; then+  if { ac_try='./$ac_file'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+    cross_compiling=no+  else+    if test "$cross_compiling" = maybe; then+	cross_compiling=yes+    else+	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.+If you meant to cross compile, use \`--host'.+See \`config.log' for more details." >&5+echo "$as_me: error: cannot run C compiled programs.+If you meant to cross compile, use \`--host'.+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }+    fi+  fi+fi+echo "$as_me:$LINENO: result: yes" >&5+echo "${ECHO_T}yes" >&6++rm -f a.out a.exe conftest$ac_cv_exeext b.out+ac_clean_files=$ac_clean_files_save+# Check the compiler produces executables we can run.  If not, either+# the compiler is broken, or we cross compile.+echo "$as_me:$LINENO: checking whether we are cross compiling" >&5+echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6+echo "$as_me:$LINENO: result: $cross_compiling" >&5+echo "${ECHO_T}$cross_compiling" >&6++echo "$as_me:$LINENO: checking for suffix of executables" >&5+echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5+  (eval $ac_link) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; then+  # If both `conftest.exe' and `conftest' are `present' (well, observable)+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will+# work properly (i.e., refer to `conftest.exe'), while it won't with+# `rm'.+for ac_file in conftest.exe conftest conftest.*; do+  test -f "$ac_file" || continue+  case $ac_file in+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`+          export ac_cv_exeext+          break;;+    * ) break;;+  esac+done+else+  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link+See \`config.log' for more details." >&5+echo "$as_me: error: cannot compute suffix of executables: cannot compile and link+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }+fi++rm -f conftest$ac_cv_exeext+echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5+echo "${ECHO_T}$ac_cv_exeext" >&6++rm -f conftest.$ac_ext+EXEEXT=$ac_cv_exeext+ac_exeext=$EXEEXT+echo "$as_me:$LINENO: checking for suffix of object files" >&5+echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6+if test "${ac_cv_objext+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++int+main ()+{++  ;+  return 0;+}+_ACEOF+rm -f conftest.o conftest.obj+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; then+  for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do+  case $ac_file in+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`+       break;;+  esac+done+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile+See \`config.log' for more details." >&5+echo "$as_me: error: cannot compute suffix of object files: cannot compile+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }+fi++rm -f conftest.$ac_cv_objext conftest.$ac_ext+fi+echo "$as_me:$LINENO: result: $ac_cv_objext" >&5+echo "${ECHO_T}$ac_cv_objext" >&6+OBJEXT=$ac_cv_objext+ac_objext=$OBJEXT+echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5+echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6+if test "${ac_cv_c_compiler_gnu+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++int+main ()+{+#ifndef __GNUC__+       choke me+#endif++  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  ac_compiler_gnu=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ac_compiler_gnu=no+fi+rm -f conftest.$ac_objext conftest.$ac_ext+ac_cv_c_compiler_gnu=$ac_compiler_gnu++fi+echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5+echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6+GCC=`test $ac_compiler_gnu = yes && echo yes`+ac_test_CFLAGS=${CFLAGS+set}+ac_save_CFLAGS=$CFLAGS+CFLAGS="-g"+echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5+echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6+if test "${ac_cv_prog_cc_g+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++int+main ()+{++  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  ac_cv_prog_cc_g=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ac_cv_prog_cc_g=no+fi+rm -f conftest.$ac_objext conftest.$ac_ext+fi+echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5+echo "${ECHO_T}$ac_cv_prog_cc_g" >&6+if test "$ac_test_CFLAGS" = set; then+  CFLAGS=$ac_save_CFLAGS+elif test $ac_cv_prog_cc_g = yes; then+  if test "$GCC" = yes; then+    CFLAGS="-g -O2"+  else+    CFLAGS="-g"+  fi+else+  if test "$GCC" = yes; then+    CFLAGS="-O2"+  else+    CFLAGS=+  fi+fi+echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5+echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6+if test "${ac_cv_prog_cc_stdc+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  ac_cv_prog_cc_stdc=no+ac_save_CC=$CC+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <stdarg.h>+#include <stdio.h>+#include <sys/types.h>+#include <sys/stat.h>+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */+struct buf { int x; };+FILE * (*rcsopen) (struct buf *, struct stat *, int);+static char *e (p, i)+     char **p;+     int i;+{+  return p[i];+}+static char *f (char * (*g) (char **, int), char **p, ...)+{+  char *s;+  va_list v;+  va_start (v,p);+  s = g (p, va_arg (v,int));+  va_end (v);+  return s;+}+int test (int i, double x);+struct s1 {int (*f) (int a);};+struct s2 {int (*f) (double a);};+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);+int argc;+char **argv;+int+main ()+{+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];+  ;+  return 0;+}+_ACEOF+# Don't try gcc -ansi; that turns off useful extensions and+# breaks some systems' header files.+# AIX			-qlanglvl=ansi+# Ultrix and OSF/1	-std1+# HP-UX 10.20 and later	-Ae+# HP-UX older versions	-Aa -D_HPUX_SOURCE+# SVR4			-Xc -D__EXTENSIONS__+for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"+do+  CC="$ac_save_CC $ac_arg"+  rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  ac_cv_prog_cc_stdc=$ac_arg+break+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++fi+rm -f conftest.$ac_objext+done+rm -f conftest.$ac_ext conftest.$ac_objext+CC=$ac_save_CC++fi++case "x$ac_cv_prog_cc_stdc" in+  x|xno)+    echo "$as_me:$LINENO: result: none needed" >&5+echo "${ECHO_T}none needed" >&6 ;;+  *)+    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5+echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6+    CC="$CC $ac_cv_prog_cc_stdc" ;;+esac++# Some people use a C++ compiler to compile C.  Since we use `exit',+# in C++ we need to declare it.  In case someone uses the same compiler+# for both compiling C and C++ we need to have the C++ compiler decide+# the declaration of exit, since it's the most demanding environment.+cat >conftest.$ac_ext <<_ACEOF+#ifndef __cplusplus+  choke me+#endif+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  for ac_declaration in \+   ''\+   '#include <stdlib.h>' \+   'extern "C" void std::exit (int) throw (); using std::exit;' \+   'extern "C" void std::exit (int); using std::exit;' \+   'extern "C" void exit (int) throw ();' \+   'extern "C" void exit (int);' \+   'void exit (int);'+do+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <stdlib.h>+$ac_declaration+int+main ()+{+exit (42);+  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  :+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++continue+fi+rm -f conftest.$ac_objext conftest.$ac_ext+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+$ac_declaration+int+main ()+{+exit (42);+  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  break+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++fi+rm -f conftest.$ac_objext conftest.$ac_ext+done+rm -f conftest*+if test -n "$ac_declaration"; then+  echo '#ifdef __cplusplus' >>confdefs.h+  echo $ac_declaration      >>confdefs.h+  echo '#endif'             >>confdefs.h+fi++else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++fi+rm -f conftest.$ac_objext conftest.$ac_ext+ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5+echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6+# On Suns, sometimes $CPP names a directory.+if test -n "$CPP" && test -d "$CPP"; then+  CPP=+fi+if test -z "$CPP"; then+  if test "${ac_cv_prog_CPP+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+      # Double quotes because CPP needs to be expanded+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"+    do+      ac_preproc_ok=false+for ac_c_preproc_warn_flag in '' yes+do+  # Use a header file that comes with gcc, so configuring glibc+  # with a fresh cross-compiler works.+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since+  # <limits.h> exists even on freestanding compilers.+  # On the NeXT, cc -E runs the code through the compiler's parser,+  # not just through cpp. "Syntax error" is here to catch this case.+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#ifdef __STDC__+# include <limits.h>+#else+# include <assert.h>+#endif+                     Syntax error+_ACEOF+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } >/dev/null; then+  if test -s conftest.err; then+    ac_cpp_err=$ac_c_preproc_warn_flag+  else+    ac_cpp_err=+  fi+else+  ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+  :+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++  # Broken: fails on valid input.+continue+fi+rm -f conftest.err conftest.$ac_ext++  # OK, works on sane cases.  Now check whether non-existent headers+  # can be detected and how.+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <ac_nonexistent.h>+_ACEOF+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } >/dev/null; then+  if test -s conftest.err; then+    ac_cpp_err=$ac_c_preproc_warn_flag+  else+    ac_cpp_err=+  fi+else+  ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+  # Broken: success on invalid input.+continue+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++  # Passes both tests.+ac_preproc_ok=:+break+fi+rm -f conftest.err conftest.$ac_ext++done+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.+rm -f conftest.err conftest.$ac_ext+if $ac_preproc_ok; then+  break+fi++    done+    ac_cv_prog_CPP=$CPP++fi+  CPP=$ac_cv_prog_CPP+else+  ac_cv_prog_CPP=$CPP+fi+echo "$as_me:$LINENO: result: $CPP" >&5+echo "${ECHO_T}$CPP" >&6+ac_preproc_ok=false+for ac_c_preproc_warn_flag in '' yes+do+  # Use a header file that comes with gcc, so configuring glibc+  # with a fresh cross-compiler works.+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since+  # <limits.h> exists even on freestanding compilers.+  # On the NeXT, cc -E runs the code through the compiler's parser,+  # not just through cpp. "Syntax error" is here to catch this case.+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#ifdef __STDC__+# include <limits.h>+#else+# include <assert.h>+#endif+                     Syntax error+_ACEOF+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } >/dev/null; then+  if test -s conftest.err; then+    ac_cpp_err=$ac_c_preproc_warn_flag+  else+    ac_cpp_err=+  fi+else+  ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+  :+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++  # Broken: fails on valid input.+continue+fi+rm -f conftest.err conftest.$ac_ext++  # OK, works on sane cases.  Now check whether non-existent headers+  # can be detected and how.+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <ac_nonexistent.h>+_ACEOF+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } >/dev/null; then+  if test -s conftest.err; then+    ac_cpp_err=$ac_c_preproc_warn_flag+  else+    ac_cpp_err=+  fi+else+  ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+  # Broken: success on invalid input.+continue+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++  # Passes both tests.+ac_preproc_ok=:+break+fi+rm -f conftest.err conftest.$ac_ext++done+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.+rm -f conftest.err conftest.$ac_ext+if $ac_preproc_ok; then+  :+else+  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check+See \`config.log' for more details." >&5+echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check+See \`config.log' for more details." >&2;}+   { (exit 1); exit 1; }; }+fi++ac_ext=c+ac_cpp='$CPP $CPPFLAGS'+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'+ac_compiler_gnu=$ac_cv_c_compiler_gnu+++echo "$as_me:$LINENO: checking for egrep" >&5+echo $ECHO_N "checking for egrep... $ECHO_C" >&6+if test "${ac_cv_prog_egrep+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  if echo a | (grep -E '(a|b)') >/dev/null 2>&1+    then ac_cv_prog_egrep='grep -E'+    else ac_cv_prog_egrep='egrep'+    fi+fi+echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5+echo "${ECHO_T}$ac_cv_prog_egrep" >&6+ EGREP=$ac_cv_prog_egrep+++echo "$as_me:$LINENO: checking for ANSI C header files" >&5+echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6+if test "${ac_cv_header_stdc+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <stdlib.h>+#include <stdarg.h>+#include <string.h>+#include <float.h>++int+main ()+{++  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  ac_cv_header_stdc=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ac_cv_header_stdc=no+fi+rm -f conftest.$ac_objext conftest.$ac_ext++if test $ac_cv_header_stdc = yes; then+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <string.h>++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+  $EGREP "memchr" >/dev/null 2>&1; then+  :+else+  ac_cv_header_stdc=no+fi+rm -f conftest*++fi++if test $ac_cv_header_stdc = yes; then+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <stdlib.h>++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+  $EGREP "free" >/dev/null 2>&1; then+  :+else+  ac_cv_header_stdc=no+fi+rm -f conftest*++fi++if test $ac_cv_header_stdc = yes; then+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.+  if test "$cross_compiling" = yes; then+  :+else+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <ctype.h>+#if ((' ' & 0x0FF) == 0x020)+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))+#else+# define ISLOWER(c) \+                   (('a' <= (c) && (c) <= 'i') \+                     || ('j' <= (c) && (c) <= 'r') \+                     || ('s' <= (c) && (c) <= 'z'))+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))+#endif++#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))+int+main ()+{+  int i;+  for (i = 0; i < 256; i++)+    if (XOR (islower (i), ISLOWER (i))+        || toupper (i) != TOUPPER (i))+      exit(2);+  exit (0);+}+_ACEOF+rm -f conftest$ac_exeext+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5+  (eval $ac_link) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  :+else+  echo "$as_me: program exited with status $ac_status" >&5+echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++( exit $ac_status )+ac_cv_header_stdc=no+fi+rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext+fi+fi+fi+echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5+echo "${ECHO_T}$ac_cv_header_stdc" >&6+if test $ac_cv_header_stdc = yes; then++cat >>confdefs.h <<\_ACEOF+#define STDC_HEADERS 1+_ACEOF++fi++# On IRIX 5.3, sys/types and inttypes.h are conflicting.++++++++++for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \+                  inttypes.h stdint.h unistd.h+do+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`+echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+$ac_includes_default++#include <$ac_header>+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  eval "$as_ac_Header=yes"+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++eval "$as_ac_Header=no"+fi+rm -f conftest.$ac_objext conftest.$ac_ext+fi+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6+if test `eval echo '${'$as_ac_Header'}'` = yes; then+  cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1+_ACEOF++fi++done+++if test "${ac_cv_header_dlfcn_h+set}" = set; then+  echo "$as_me:$LINENO: checking for dlfcn.h" >&5+echo $ECHO_N "checking for dlfcn.h... $ECHO_C" >&6+if test "${ac_cv_header_dlfcn_h+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+fi+echo "$as_me:$LINENO: result: $ac_cv_header_dlfcn_h" >&5+echo "${ECHO_T}$ac_cv_header_dlfcn_h" >&6+else+  # Is the header compilable?+echo "$as_me:$LINENO: checking dlfcn.h usability" >&5+echo $ECHO_N "checking dlfcn.h usability... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+$ac_includes_default+#include <dlfcn.h>+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  ac_header_compiler=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ac_header_compiler=no+fi+rm -f conftest.$ac_objext conftest.$ac_ext+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5+echo "${ECHO_T}$ac_header_compiler" >&6++# Is the header present?+echo "$as_me:$LINENO: checking dlfcn.h presence" >&5+echo $ECHO_N "checking dlfcn.h presence... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <dlfcn.h>+_ACEOF+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } >/dev/null; then+  if test -s conftest.err; then+    ac_cpp_err=$ac_c_preproc_warn_flag+  else+    ac_cpp_err=+  fi+else+  ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+  ac_header_preproc=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++  ac_header_preproc=no+fi+rm -f conftest.err conftest.$ac_ext+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5+echo "${ECHO_T}$ac_header_preproc" >&6++# So?  What about this header?+case $ac_header_compiler:$ac_header_preproc in+  yes:no )+    { echo "$as_me:$LINENO: WARNING: dlfcn.h: accepted by the compiler, rejected by the preprocessor!" >&5+echo "$as_me: WARNING: dlfcn.h: accepted by the compiler, rejected by the preprocessor!" >&2;}+    { echo "$as_me:$LINENO: WARNING: dlfcn.h: proceeding with the preprocessor's result" >&5+echo "$as_me: WARNING: dlfcn.h: proceeding with the preprocessor's result" >&2;}+    (+      cat <<\_ASBOX+## ------------------------------------ ##+## Report this to bug-autoconf@gnu.org. ##+## ------------------------------------ ##+_ASBOX+    ) |+      sed "s/^/$as_me: WARNING:     /" >&2+    ;;+  no:yes )+    { echo "$as_me:$LINENO: WARNING: dlfcn.h: present but cannot be compiled" >&5+echo "$as_me: WARNING: dlfcn.h: present but cannot be compiled" >&2;}+    { echo "$as_me:$LINENO: WARNING: dlfcn.h: check for missing prerequisite headers?" >&5+echo "$as_me: WARNING: dlfcn.h: check for missing prerequisite headers?" >&2;}+    { echo "$as_me:$LINENO: WARNING: dlfcn.h: proceeding with the preprocessor's result" >&5+echo "$as_me: WARNING: dlfcn.h: proceeding with the preprocessor's result" >&2;}+    (+      cat <<\_ASBOX+## ------------------------------------ ##+## Report this to bug-autoconf@gnu.org. ##+## ------------------------------------ ##+_ASBOX+    ) |+      sed "s/^/$as_me: WARNING:     /" >&2+    ;;+esac+echo "$as_me:$LINENO: checking for dlfcn.h" >&5+echo $ECHO_N "checking for dlfcn.h... $ECHO_C" >&6+if test "${ac_cv_header_dlfcn_h+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  ac_cv_header_dlfcn_h=$ac_header_preproc+fi+echo "$as_me:$LINENO: result: $ac_cv_header_dlfcn_h" >&5+echo "${ECHO_T}$ac_cv_header_dlfcn_h" >&6++fi+if test $ac_cv_header_dlfcn_h = yes; then+  BUILD_PACKAGE_BOOL=True+else+  BUILD_PACKAGE_BOOL=False+fi+++++echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5+echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6+if test "${ac_cv_c_const+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++int+main ()+{+/* FIXME: Include the comments suggested by Paul. */+#ifndef __cplusplus+  /* Ultrix mips cc rejects this.  */+  typedef int charset[2];+  const charset x;+  /* SunOS 4.1.1 cc rejects this.  */+  char const *const *ccp;+  char **p;+  /* NEC SVR4.0.2 mips cc rejects this.  */+  struct point {int x, y;};+  static struct point const zero = {0,0};+  /* AIX XL C 1.02.0.0 rejects this.+     It does not let you subtract one const X* pointer from another in+     an arm of an if-expression whose if-part is not a constant+     expression */+  const char *g = "string";+  ccp = &g + (g ? g-g : 0);+  /* HPUX 7.0 cc rejects these. */+  ++ccp;+  p = (char**) ccp;+  ccp = (char const *const *) p;+  { /* SCO 3.2v4 cc rejects this.  */+    char *t;+    char const *s = 0 ? (char *) 0 : (char const *) 0;++    *t++ = 0;+  }+  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */+    int x[] = {25, 17};+    const int *foo = &x[0];+    ++foo;+  }+  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */+    typedef const int *iptr;+    iptr p = 0;+    ++p;+  }+  { /* AIX XL C 1.02.0.0 rejects this saying+       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */+    struct s { int j; const int *ap[3]; };+    struct s *b; b->j = 5;+  }+  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */+    const int foo = 10;+  }+#endif++  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  ac_cv_c_const=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ac_cv_c_const=no+fi+rm -f conftest.$ac_objext conftest.$ac_ext+fi+echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5+echo "${ECHO_T}$ac_cv_c_const" >&6+if test $ac_cv_c_const = no; then++cat >>confdefs.h <<\_ACEOF+#define const+_ACEOF++fi++++++++++for ac_header in dirent.h fcntl.h grp.h limits.h pwd.h signal.h string.h+do+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+fi+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6+else+  # Is the header compilable?+echo "$as_me:$LINENO: checking $ac_header usability" >&5+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+$ac_includes_default+#include <$ac_header>+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  ac_header_compiler=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ac_header_compiler=no+fi+rm -f conftest.$ac_objext conftest.$ac_ext+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5+echo "${ECHO_T}$ac_header_compiler" >&6++# Is the header present?+echo "$as_me:$LINENO: checking $ac_header presence" >&5+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <$ac_header>+_ACEOF+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } >/dev/null; then+  if test -s conftest.err; then+    ac_cpp_err=$ac_c_preproc_warn_flag+  else+    ac_cpp_err=+  fi+else+  ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+  ac_header_preproc=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++  ac_header_preproc=no+fi+rm -f conftest.err conftest.$ac_ext+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5+echo "${ECHO_T}$ac_header_preproc" >&6++# So?  What about this header?+case $ac_header_compiler:$ac_header_preproc in+  yes:no )+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}+    (+      cat <<\_ASBOX+## ------------------------------------ ##+## Report this to bug-autoconf@gnu.org. ##+## ------------------------------------ ##+_ASBOX+    ) |+      sed "s/^/$as_me: WARNING:     /" >&2+    ;;+  no:yes )+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}+    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5+echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}+    (+      cat <<\_ASBOX+## ------------------------------------ ##+## Report this to bug-autoconf@gnu.org. ##+## ------------------------------------ ##+_ASBOX+    ) |+      sed "s/^/$as_me: WARNING:     /" >&2+    ;;+esac+echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  eval "$as_ac_Header=$ac_header_preproc"+fi+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6++fi+if test `eval echo '${'$as_ac_Header'}'` = yes; then+  cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1+_ACEOF++fi++done++++++for ac_header in sys/resource.h sys/stat.h sys/times.h sys/time.h+do+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+fi+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6+else+  # Is the header compilable?+echo "$as_me:$LINENO: checking $ac_header usability" >&5+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+$ac_includes_default+#include <$ac_header>+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  ac_header_compiler=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ac_header_compiler=no+fi+rm -f conftest.$ac_objext conftest.$ac_ext+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5+echo "${ECHO_T}$ac_header_compiler" >&6++# Is the header present?+echo "$as_me:$LINENO: checking $ac_header presence" >&5+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <$ac_header>+_ACEOF+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } >/dev/null; then+  if test -s conftest.err; then+    ac_cpp_err=$ac_c_preproc_warn_flag+  else+    ac_cpp_err=+  fi+else+  ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+  ac_header_preproc=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++  ac_header_preproc=no+fi+rm -f conftest.err conftest.$ac_ext+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5+echo "${ECHO_T}$ac_header_preproc" >&6++# So?  What about this header?+case $ac_header_compiler:$ac_header_preproc in+  yes:no )+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}+    (+      cat <<\_ASBOX+## ------------------------------------ ##+## Report this to bug-autoconf@gnu.org. ##+## ------------------------------------ ##+_ASBOX+    ) |+      sed "s/^/$as_me: WARNING:     /" >&2+    ;;+  no:yes )+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}+    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5+echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}+    (+      cat <<\_ASBOX+## ------------------------------------ ##+## Report this to bug-autoconf@gnu.org. ##+## ------------------------------------ ##+_ASBOX+    ) |+      sed "s/^/$as_me: WARNING:     /" >&2+    ;;+esac+echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  eval "$as_ac_Header=$ac_header_preproc"+fi+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6++fi+if test `eval echo '${'$as_ac_Header'}'` = yes; then+  cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1+_ACEOF++fi++done++++for ac_header in sys/utsname.h sys/wait.h+do+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+fi+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6+else+  # Is the header compilable?+echo "$as_me:$LINENO: checking $ac_header usability" >&5+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+$ac_includes_default+#include <$ac_header>+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  ac_header_compiler=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ac_header_compiler=no+fi+rm -f conftest.$ac_objext conftest.$ac_ext+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5+echo "${ECHO_T}$ac_header_compiler" >&6++# Is the header present?+echo "$as_me:$LINENO: checking $ac_header presence" >&5+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <$ac_header>+_ACEOF+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } >/dev/null; then+  if test -s conftest.err; then+    ac_cpp_err=$ac_c_preproc_warn_flag+  else+    ac_cpp_err=+  fi+else+  ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+  ac_header_preproc=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++  ac_header_preproc=no+fi+rm -f conftest.err conftest.$ac_ext+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5+echo "${ECHO_T}$ac_header_preproc" >&6++# So?  What about this header?+case $ac_header_compiler:$ac_header_preproc in+  yes:no )+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}+    (+      cat <<\_ASBOX+## ------------------------------------ ##+## Report this to bug-autoconf@gnu.org. ##+## ------------------------------------ ##+_ASBOX+    ) |+      sed "s/^/$as_me: WARNING:     /" >&2+    ;;+  no:yes )+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}+    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5+echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}+    (+      cat <<\_ASBOX+## ------------------------------------ ##+## Report this to bug-autoconf@gnu.org. ##+## ------------------------------------ ##+_ASBOX+    ) |+      sed "s/^/$as_me: WARNING:     /" >&2+    ;;+esac+echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  eval "$as_ac_Header=$ac_header_preproc"+fi+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6++fi+if test `eval echo '${'$as_ac_Header'}'` = yes; then+  cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1+_ACEOF++fi++done++++++for ac_header in termios.h time.h unistd.h utime.h+do+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+fi+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6+else+  # Is the header compilable?+echo "$as_me:$LINENO: checking $ac_header usability" >&5+echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+$ac_includes_default+#include <$ac_header>+_ACEOF+rm -f conftest.$ac_objext+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5+  (eval $ac_compile) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest.$ac_objext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  ac_header_compiler=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ac_header_compiler=no+fi+rm -f conftest.$ac_objext conftest.$ac_ext+echo "$as_me:$LINENO: result: $ac_header_compiler" >&5+echo "${ECHO_T}$ac_header_compiler" >&6++# Is the header present?+echo "$as_me:$LINENO: checking $ac_header presence" >&5+echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include <$ac_header>+_ACEOF+if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5+  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1+  ac_status=$?+  grep -v '^ *+' conftest.er1 >conftest.err+  rm -f conftest.er1+  cat conftest.err >&5+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } >/dev/null; then+  if test -s conftest.err; then+    ac_cpp_err=$ac_c_preproc_warn_flag+  else+    ac_cpp_err=+  fi+else+  ac_cpp_err=yes+fi+if test -z "$ac_cpp_err"; then+  ac_header_preproc=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++  ac_header_preproc=no+fi+rm -f conftest.err conftest.$ac_ext+echo "$as_me:$LINENO: result: $ac_header_preproc" >&5+echo "${ECHO_T}$ac_header_preproc" >&6++# So?  What about this header?+case $ac_header_compiler:$ac_header_preproc in+  yes:no )+    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5+echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}+    (+      cat <<\_ASBOX+## ------------------------------------ ##+## Report this to bug-autoconf@gnu.org. ##+## ------------------------------------ ##+_ASBOX+    ) |+      sed "s/^/$as_me: WARNING:     /" >&2+    ;;+  no:yes )+    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5+echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}+    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5+echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}+    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5+echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}+    (+      cat <<\_ASBOX+## ------------------------------------ ##+## Report this to bug-autoconf@gnu.org. ##+## ------------------------------------ ##+_ASBOX+    ) |+      sed "s/^/$as_me: WARNING:     /" >&2+    ;;+esac+echo "$as_me:$LINENO: checking for $ac_header" >&5+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6+if eval "test \"\${$as_ac_Header+set}\" = set"; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  eval "$as_ac_Header=$ac_header_preproc"+fi+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5+echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6++fi+if test `eval echo '${'$as_ac_Header'}'` = yes; then+  cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1+_ACEOF++fi++done+++++++++for ac_func in getgrgid_r getgrnam_r getpwnam_r getpwuid_r getpwnam getpwuid+do+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`+echo "$as_me:$LINENO: checking for $ac_func" >&5+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6+if eval "test \"\${$as_ac_var+set}\" = set"; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+/* System header to define __stub macros and hopefully few prototypes,+    which can conflict with char $ac_func (); below.+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since+    <limits.h> exists even on freestanding compilers.  */+#ifdef __STDC__+# include <limits.h>+#else+# include <assert.h>+#endif+/* Override any gcc2 internal prototype to avoid an error.  */+#ifdef __cplusplus+extern "C"+{+#endif+/* We use char because int might match the return type of a gcc2+   builtin and then its argument prototype would still apply.  */+char $ac_func ();+/* The GNU C library defines this for functions which it implements+    to always fail with ENOSYS.  Some functions are actually named+    something starting with __ and the normal name is an alias.  */+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)+choke me+#else+char (*f) () = $ac_func;+#endif+#ifdef __cplusplus+}+#endif++int+main ()+{+return f != $ac_func;+  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext conftest$ac_exeext+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5+  (eval $ac_link) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest$ac_exeext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  eval "$as_ac_var=yes"+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++eval "$as_ac_var=no"+fi+rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext+fi+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6+if test `eval echo '${'$as_ac_var'}'` = yes; then+  cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1+_ACEOF++fi+done++++for ac_func in getpwent getgrent+do+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`+echo "$as_me:$LINENO: checking for $ac_func" >&5+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6+if eval "test \"\${$as_ac_var+set}\" = set"; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+/* System header to define __stub macros and hopefully few prototypes,+    which can conflict with char $ac_func (); below.+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since+    <limits.h> exists even on freestanding compilers.  */+#ifdef __STDC__+# include <limits.h>+#else+# include <assert.h>+#endif+/* Override any gcc2 internal prototype to avoid an error.  */+#ifdef __cplusplus+extern "C"+{+#endif+/* We use char because int might match the return type of a gcc2+   builtin and then its argument prototype would still apply.  */+char $ac_func ();+/* The GNU C library defines this for functions which it implements+    to always fail with ENOSYS.  Some functions are actually named+    something starting with __ and the normal name is an alias.  */+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)+choke me+#else+char (*f) () = $ac_func;+#endif+#ifdef __cplusplus+}+#endif++int+main ()+{+return f != $ac_func;+  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext conftest$ac_exeext+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5+  (eval $ac_link) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest$ac_exeext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  eval "$as_ac_var=yes"+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++eval "$as_ac_var=no"+fi+rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext+fi+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6+if test `eval echo '${'$as_ac_var'}'` = yes; then+  cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1+_ACEOF++fi+done++++++for ac_func in lchown setenv sysconf unsetenv+do+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`+echo "$as_me:$LINENO: checking for $ac_func" >&5+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6+if eval "test \"\${$as_ac_var+set}\" = set"; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+/* System header to define __stub macros and hopefully few prototypes,+    which can conflict with char $ac_func (); below.+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since+    <limits.h> exists even on freestanding compilers.  */+#ifdef __STDC__+# include <limits.h>+#else+# include <assert.h>+#endif+/* Override any gcc2 internal prototype to avoid an error.  */+#ifdef __cplusplus+extern "C"+{+#endif+/* We use char because int might match the return type of a gcc2+   builtin and then its argument prototype would still apply.  */+char $ac_func ();+/* The GNU C library defines this for functions which it implements+    to always fail with ENOSYS.  Some functions are actually named+    something starting with __ and the normal name is an alias.  */+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)+choke me+#else+char (*f) () = $ac_func;+#endif+#ifdef __cplusplus+}+#endif++int+main ()+{+return f != $ac_func;+  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext conftest$ac_exeext+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5+  (eval $ac_link) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest$ac_exeext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  eval "$as_ac_var=yes"+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++eval "$as_ac_var=no"+fi+rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext+fi+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6+if test `eval echo '${'$as_ac_var'}'` = yes; then+  cat >>confdefs.h <<_ACEOF+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1+_ACEOF++fi+done+++echo "$as_me:$LINENO: checking for _SC_GETGR_R_SIZE_MAX" >&5+echo $ECHO_N "checking for _SC_GETGR_R_SIZE_MAX... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++#include <unistd.h>+#ifdef _SC_GETGR_R_SIZE_MAX+we_have_that_sysconf_thing+#endif++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+  $EGREP "we_have_that_sysconf_thing" >/dev/null 2>&1; then+  echo "$as_me:$LINENO: result: yes" >&5+echo "${ECHO_T}yes" >&6++cat >>confdefs.h <<\_ACEOF+#define HAVE_SC_GETGR_R_SIZE_MAX 1+_ACEOF++else+  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6+fi+rm -f conftest*+++echo "$as_me:$LINENO: checking for _SC_GETPW_R_SIZE_MAX" >&5+echo $ECHO_N "checking for _SC_GETPW_R_SIZE_MAX... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++#include <unistd.h>+#ifdef _SC_GETPW_R_SIZE_MAX+we_have_that_sysconf_thing+#endif++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+  $EGREP "we_have_that_sysconf_thing" >/dev/null 2>&1; then+  echo "$as_me:$LINENO: result: yes" >&5+echo "${ECHO_T}yes" >&6++cat >>confdefs.h <<\_ACEOF+#define HAVE_SC_GETPW_R_SIZE_MAX 1+_ACEOF++else+  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6+fi+rm -f conftest*++++### On some systems usleep has no return value.  If it does have one,+### we'd like to return it; otherwise, we'll fake it.+echo "$as_me:$LINENO: checking return type of usleep" >&5+echo $ECHO_N "checking return type of usleep... $ECHO_C" >&6+if test "${cv_func_usleep_return_type+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */+#include </usr/include/unistd.h>++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+  $EGREP "void[      ]+usleep" >/dev/null 2>&1; then+  cv_func_usleep_return_type=void+else+  cv_func_usleep_return_type=int+fi+rm -f conftest*++fi+echo "$as_me:$LINENO: result: $cv_func_usleep_return_type" >&5+echo "${ECHO_T}$cv_func_usleep_return_type" >&6+case "$cv_func_usleep_return_type" in+  "void" )++cat >>confdefs.h <<\_ACEOF+#define USLEEP_RETURNS_VOID 1+_ACEOF++  ;;+esac++echo "$as_me:$LINENO: checking for RTLD_NEXT from dlfcn.h" >&5+echo $ECHO_N "checking for RTLD_NEXT from dlfcn.h... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++ #include <dlfcn.h>+ #ifdef RTLD_NEXT+        yes+ #endif++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+  $EGREP "yes" >/dev/null 2>&1; then++  echo "$as_me:$LINENO: result: yes" >&5+echo "${ECHO_T}yes" >&6++cat >>confdefs.h <<\_ACEOF+#define HAVE_RTLDNEXT 1+_ACEOF+++else++  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6++fi+rm -f conftest*+++echo "$as_me:$LINENO: checking for RTLD_DEFAULT from dlfcn.h" >&5+echo $ECHO_N "checking for RTLD_DEFAULT from dlfcn.h... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++ #include <dlfcn.h>+ #ifdef RTLD_DEFAULT+        yes+ #endif++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+  $EGREP "yes" >/dev/null 2>&1; then++  echo "$as_me:$LINENO: result: yes" >&5+echo "${ECHO_T}yes" >&6++cat >>confdefs.h <<\_ACEOF+#define HAVE_RTLDDEFAULT 1+_ACEOF+++else++  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6++fi+rm -f conftest*+++echo "$as_me:$LINENO: checking for RTLD_LOCAL from dlfcn.h" >&5+echo $ECHO_N "checking for RTLD_LOCAL from dlfcn.h... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++ #include <dlfcn.h>+ #ifdef RTLD_LOCAL+        yes+ #endif++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+  $EGREP "yes" >/dev/null 2>&1; then++  echo "$as_me:$LINENO: result: yes" >&5+echo "${ECHO_T}yes" >&6++cat >>confdefs.h <<\_ACEOF+#define HAVE_RTLDLOCAL 1+_ACEOF+++else++  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6++fi+rm -f conftest*+++echo "$as_me:$LINENO: checking for RTLD_GLOBAL from dlfcn.h" >&5+echo $ECHO_N "checking for RTLD_GLOBAL from dlfcn.h... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++ #include <dlfcn.h>+ #ifdef RTLD_GLOBAL+        yes+ #endif++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+  $EGREP "yes" >/dev/null 2>&1; then++  echo "$as_me:$LINENO: result: yes" >&5+echo "${ECHO_T}yes" >&6++cat >>confdefs.h <<\_ACEOF+#define HAVE_RTLDGLOBAL 1+_ACEOF+++else++  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6++fi+rm -f conftest*+++echo "$as_me:$LINENO: checking for RTLD_NOW from dlfcn.h" >&5+echo $ECHO_N "checking for RTLD_NOW from dlfcn.h... $ECHO_C" >&6+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++ #include <dlfcn.h>+ #ifdef RTLD_NOW+        yes+ #endif++_ACEOF+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |+  $EGREP "yes" >/dev/null 2>&1; then++  echo "$as_me:$LINENO: result: yes" >&5+echo "${ECHO_T}yes" >&6++cat >>confdefs.h <<\_ACEOF+#define HAVE_RTLDNOW 1+_ACEOF+++else++  echo "$as_me:$LINENO: result: no" >&5+echo "${ECHO_T}no" >&6++fi+rm -f conftest*+++# Avoid adding dl if absent or unneeded+echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5+echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6+if test "${ac_cv_lib_dl_dlopen+set}" = set; then+  echo $ECHO_N "(cached) $ECHO_C" >&6+else+  ac_check_lib_save_LIBS=$LIBS+LIBS="-ldl  $LIBS"+cat >conftest.$ac_ext <<_ACEOF+#line $LINENO "configure"+/* confdefs.h.  */+_ACEOF+cat confdefs.h >>conftest.$ac_ext+cat >>conftest.$ac_ext <<_ACEOF+/* end confdefs.h.  */++/* Override any gcc2 internal prototype to avoid an error.  */+#ifdef __cplusplus+extern "C"+#endif+/* We use char because int might match the return type of a gcc2+   builtin and then its argument prototype would still apply.  */+char dlopen ();+int+main ()+{+dlopen ();+  ;+  return 0;+}+_ACEOF+rm -f conftest.$ac_objext conftest$ac_exeext+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5+  (eval $ac_link) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); } &&+         { ac_try='test -s conftest$ac_exeext'+  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5+  (eval $ac_try) 2>&5+  ac_status=$?+  echo "$as_me:$LINENO: \$? = $ac_status" >&5+  (exit $ac_status); }; }; then+  ac_cv_lib_dl_dlopen=yes+else+  echo "$as_me: failed program was:" >&5+sed 's/^/| /' conftest.$ac_ext >&5++ac_cv_lib_dl_dlopen=no+fi+rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext+LIBS=$ac_check_lib_save_LIBS+fi+echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5+echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6+if test $ac_cv_lib_dl_dlopen = yes; then+  EXTRA_LIBS=dl+else+  EXTRA_LIBS=+fi++++          ac_config_files="$ac_config_files unix.buildinfo"+++cat >confcache <<\_ACEOF+# This file is a shell script that caches the results of configure+# tests run on this system so they can be shared between configure+# scripts and configure runs, see configure's option --config-cache.+# It is not useful on other systems.  If it contains results you don't+# want to keep, you may remove or edit it.+#+# config.status only pays attention to the cache file if you give it+# the --recheck option to rerun configure.+#+# `ac_cv_env_foo' variables (set or unset) will be overridden when+# loading this file, other *unset* `ac_cv_foo' will be assigned the+# following values.++_ACEOF++# The following way of writing the cache mishandles newlines in values,+# but we know of no workaround that is simple, portable, and efficient.+# So, don't put newlines in cache variables' values.+# Ultrix sh set writes to stderr and can't be redirected directly,+# and sets the high bit in the cache file unless we assign to the vars.+{+  (set) 2>&1 |+    case `(ac_space=' '; set | grep ac_space) 2>&1` in+    *ac_space=\ *)+      # `set' does not quote correctly, so add quotes (double-quote+      # substitution turns \\\\ into \\, and sed turns \\ into \).+      sed -n \+        "s/'/'\\\\''/g;+    	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"+      ;;+    *)+      # `set' quotes correctly as required by POSIX, so do not add quotes.+      sed -n \+        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"+      ;;+    esac;+} |+  sed '+     t clear+     : clear+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/+     t end+     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/+     : end' >>confcache+if diff $cache_file confcache >/dev/null 2>&1; then :; else+  if test -w $cache_file; then+    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"+    cat confcache >$cache_file+  else+    echo "not updating unwritable cache $cache_file"+  fi+fi+rm -f confcache++test "x$prefix" = xNONE && prefix=$ac_default_prefix+# Let make expand exec_prefix.+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'++# VPATH may cause trouble with some makes, so we remove $(srcdir),+# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and+# trailing colons and then remove the whole line if VPATH becomes empty+# (actually we leave an empty line to preserve line numbers).+if test "x$srcdir" = x.; then+  ac_vpsub='/^[ 	]*VPATH[ 	]*=/{+s/:*\$(srcdir):*/:/;+s/:*\${srcdir}:*/:/;+s/:*@srcdir@:*/:/;+s/^\([^=]*=[ 	]*\):*/\1/;+s/:*$//;+s/^[^=]*=[ 	]*$//;+}'+fi++DEFS=-DHAVE_CONFIG_H++ac_libobjs=+ac_ltlibobjs=+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue+  # 1. Remove the extension, and $U if already installed.+  ac_i=`echo "$ac_i" |+         sed 's/\$U\././;s/\.o$//;s/\.obj$//'`+  # 2. Add them.+  ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"+  ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'+done+LIBOBJS=$ac_libobjs++LTLIBOBJS=$ac_ltlibobjs++++: ${CONFIG_STATUS=./config.status}+ac_clean_files_save=$ac_clean_files+ac_clean_files="$ac_clean_files $CONFIG_STATUS"+{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5+echo "$as_me: creating $CONFIG_STATUS" >&6;}+cat >$CONFIG_STATUS <<_ACEOF+#! $SHELL+# Generated by $as_me.+# Run this file to recreate the current configuration.+# Compiler output produced by configure, useful for debugging+# configure, is in config.log if it exists.++debug=false+ac_cs_recheck=false+ac_cs_silent=false+SHELL=\${CONFIG_SHELL-$SHELL}+_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+## --------------------- ##+## M4sh Initialization.  ##+## --------------------- ##++# Be Bourne compatible+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then+  emulate sh+  NULLCMD=:+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which+  # is contrary to our usage.  Disable this feature.+  alias -g '${1+"$@"}'='"$@"'+elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then+  set -o posix+fi++# Support unset when possible.+if (FOO=FOO; unset FOO) >/dev/null 2>&1; then+  as_unset=unset+else+  as_unset=false+fi+++# Work around bugs in pre-3.0 UWIN ksh.+$as_unset ENV MAIL MAILPATH+PS1='$ '+PS2='> '+PS4='+ '++# NLS nuisances.+for as_var in \+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \+  LC_TELEPHONE LC_TIME+do+  if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then+    eval $as_var=C; export $as_var+  else+    $as_unset $as_var+  fi+done++# Required to use basename.+if expr a : '\(a\)' >/dev/null 2>&1; then+  as_expr=expr+else+  as_expr=false+fi++if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then+  as_basename=basename+else+  as_basename=false+fi+++# Name of the executable.+as_me=`$as_basename "$0" ||+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \+	 X"$0" : 'X\(//\)$' \| \+	 X"$0" : 'X\(/\)$' \| \+	 .     : '\(.\)' 2>/dev/null ||+echo X/"$0" |+    sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }+  	  /^X\/\(\/\/\)$/{ s//\1/; q; }+  	  /^X\/\(\/\).*/{ s//\1/; q; }+  	  s/.*/./; q'`+++# PATH needs CR, and LINENO needs CR and PATH.+# Avoid depending upon Character Ranges.+as_cr_letters='abcdefghijklmnopqrstuvwxyz'+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'+as_cr_Letters=$as_cr_letters$as_cr_LETTERS+as_cr_digits='0123456789'+as_cr_alnum=$as_cr_Letters$as_cr_digits++# The user is always right.+if test "${PATH_SEPARATOR+set}" != set; then+  echo "#! /bin/sh" >conf$$.sh+  echo  "exit 0"   >>conf$$.sh+  chmod +x conf$$.sh+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then+    PATH_SEPARATOR=';'+  else+    PATH_SEPARATOR=:+  fi+  rm -f conf$$.sh+fi+++  as_lineno_1=$LINENO+  as_lineno_2=$LINENO+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`+  test "x$as_lineno_1" != "x$as_lineno_2" &&+  test "x$as_lineno_3"  = "x$as_lineno_2"  || {+  # Find who we are.  Look in the path if we contain no path at all+  # relative or not.+  case $0 in+    *[\\/]* ) as_myself=$0 ;;+    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in $PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break+done++       ;;+  esac+  # We did not find ourselves, most probably we were run as `sh COMMAND'+  # in which case we are not to be found in the path.+  if test "x$as_myself" = x; then+    as_myself=$0+  fi+  if test ! -f "$as_myself"; then+    { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5+echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}+   { (exit 1); exit 1; }; }+  fi+  case $CONFIG_SHELL in+  '')+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH+do+  IFS=$as_save_IFS+  test -z "$as_dir" && as_dir=.+  for as_base in sh bash ksh sh5; do+	 case $as_dir in+	 /*)+	   if ("$as_dir/$as_base" -c '+  as_lineno_1=$LINENO+  as_lineno_2=$LINENO+  as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`+  test "x$as_lineno_1" != "x$as_lineno_2" &&+  test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then+	     $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }+	     $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }+	     CONFIG_SHELL=$as_dir/$as_base+	     export CONFIG_SHELL+	     exec "$CONFIG_SHELL" "$0" ${1+"$@"}+	   fi;;+	 esac+       done+done+;;+  esac++  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO+  # uniformly replaced by the line number.  The first 'sed' inserts a+  # line-number line before each line; the second 'sed' does the real+  # work.  The second script uses 'N' to pair each line-number line+  # with the numbered line, and appends trailing '-' during+  # substitution so that $LINENO is not a special case at line end.+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the+  # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)+  sed '=' <$as_myself |+    sed '+      N+      s,$,-,+      : loop+      s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,+      t loop+      s,-$,,+      s,^['$as_cr_digits']*\n,,+    ' >$as_me.lineno &&+  chmod +x $as_me.lineno ||+    { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5+echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}+   { (exit 1); exit 1; }; }++  # Don't try to exec as it changes $[0], causing all sort of problems+  # (the dirname of $[0] is not the place where we might find the+  # original and so on.  Autoconf is especially sensible to this).+  . ./$as_me.lineno+  # Exit status is that of the last command.+  exit+}+++case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in+  *c*,-n*) ECHO_N= ECHO_C='+' ECHO_T='	' ;;+  *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;+  *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;+esac++if expr a : '\(a\)' >/dev/null 2>&1; then+  as_expr=expr+else+  as_expr=false+fi++rm -f conf$$ conf$$.exe conf$$.file+echo >conf$$.file+if ln -s conf$$.file conf$$ 2>/dev/null; then+  # We could just check for DJGPP; but this test a) works b) is more generic+  # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).+  if test -f conf$$.exe; then+    # Don't use ln at all; we don't have any links+    as_ln_s='cp -p'+  else+    as_ln_s='ln -s'+  fi+elif ln conf$$.file conf$$ 2>/dev/null; then+  as_ln_s=ln+else+  as_ln_s='cp -p'+fi+rm -f conf$$ conf$$.exe conf$$.file++if mkdir -p . 2>/dev/null; then+  as_mkdir_p=:+else+  as_mkdir_p=false+fi++as_executable_p="test -f"++# Sed expression to map a string onto a valid CPP name.+as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"++# Sed expression to map a string onto a valid variable name.+as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"+++# IFS+# We need space, tab and new line, in precisely that order.+as_nl='+'+IFS=" 	$as_nl"++# CDPATH.+$as_unset CDPATH++exec 6>&1++# Open the log real soon, to keep \$[0] and so on meaningful, and to+# report actual input values of CONFIG_FILES etc. instead of their+# values after options handling.  Logging --version etc. is OK.+exec 5>>config.log+{+  echo+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX+## Running $as_me. ##+_ASBOX+} >&5+cat >&5 <<_CSEOF++This file was extended by Haskell unix package $as_me 2.0, which was+generated by GNU Autoconf 2.57.  Invocation command line was++  CONFIG_FILES    = $CONFIG_FILES+  CONFIG_HEADERS  = $CONFIG_HEADERS+  CONFIG_LINKS    = $CONFIG_LINKS+  CONFIG_COMMANDS = $CONFIG_COMMANDS+  $ $0 $@++_CSEOF+echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5+echo >&5+_ACEOF++# Files that config.status was made for.+if test -n "$ac_config_files"; then+  echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS+fi++if test -n "$ac_config_headers"; then+  echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS+fi++if test -n "$ac_config_links"; then+  echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS+fi++if test -n "$ac_config_commands"; then+  echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS+fi++cat >>$CONFIG_STATUS <<\_ACEOF++ac_cs_usage="\+\`$as_me' instantiates files from templates according to the+current configuration.++Usage: $0 [OPTIONS] [FILE]...++  -h, --help       print this help, then exit+  -V, --version    print version number, then exit+  -q, --quiet      do not print progress messages+  -d, --debug      don't remove temporary files+      --recheck    update $as_me by reconfiguring in the same conditions+  --file=FILE[:TEMPLATE]+                   instantiate the configuration file FILE+  --header=FILE[:TEMPLATE]+                   instantiate the configuration header FILE++Configuration files:+$config_files++Configuration headers:+$config_headers++Report bugs to <bug-autoconf@gnu.org>."+_ACEOF++cat >>$CONFIG_STATUS <<_ACEOF+ac_cs_version="\\+Haskell unix package config.status 2.0+configured by $0, generated by GNU Autoconf 2.57,+  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"++Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001+Free Software Foundation, Inc.+This config.status script is free software; the Free Software Foundation+gives unlimited permission to copy, distribute and modify it."+srcdir=$srcdir+_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF+# If no file are specified by the user, then we need to provide default+# value.  By we need to know if files were specified by the user.+ac_need_defaults=:+while test $# != 0+do+  case $1 in+  --*=*)+    ac_option=`expr "x$1" : 'x\([^=]*\)='`+    ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`+    ac_shift=:+    ;;+  -*)+    ac_option=$1+    ac_optarg=$2+    ac_shift=shift+    ;;+  *) # This is not an option, so the user has probably given explicit+     # arguments.+     ac_option=$1+     ac_need_defaults=false;;+  esac++  case $ac_option in+  # Handling of the options.+_ACEOF+cat >>$CONFIG_STATUS <<\_ACEOF+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)+    ac_cs_recheck=: ;;+  --version | --vers* | -V )+    echo "$ac_cs_version"; exit 0 ;;+  --he | --h)+    # Conflict between --help and --header+    { { echo "$as_me:$LINENO: error: ambiguous option: $1+Try \`$0 --help' for more information." >&5+echo "$as_me: error: ambiguous option: $1+Try \`$0 --help' for more information." >&2;}+   { (exit 1); exit 1; }; };;+  --help | --hel | -h )+    echo "$ac_cs_usage"; exit 0 ;;+  --debug | --d* | -d )+    debug=: ;;+  --file | --fil | --fi | --f )+    $ac_shift+    CONFIG_FILES="$CONFIG_FILES $ac_optarg"+    ac_need_defaults=false;;+  --header | --heade | --head | --hea )+    $ac_shift+    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"+    ac_need_defaults=false;;+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \+  | -silent | --silent | --silen | --sile | --sil | --si | --s)+    ac_cs_silent=: ;;++  # This is an error.+  -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1+Try \`$0 --help' for more information." >&5+echo "$as_me: error: unrecognized option: $1+Try \`$0 --help' for more information." >&2;}+   { (exit 1); exit 1; }; } ;;++  *) ac_config_targets="$ac_config_targets $1" ;;++  esac+  shift+done++ac_configure_extra_args=++if $ac_cs_silent; then+  exec 6>/dev/null+  ac_configure_extra_args="$ac_configure_extra_args --silent"+fi++_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+if \$ac_cs_recheck; then+  echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6+  exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion+fi++_ACEOF++++++cat >>$CONFIG_STATUS <<\_ACEOF+for ac_config_target in $ac_config_targets+do+  case "$ac_config_target" in+  # Handling of arguments.+  "unix.buildinfo" ) CONFIG_FILES="$CONFIG_FILES unix.buildinfo" ;;+  "include/HsUnixConfig.h" ) CONFIG_HEADERS="$CONFIG_HEADERS include/HsUnixConfig.h" ;;+  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5+echo "$as_me: error: invalid argument: $ac_config_target" >&2;}+   { (exit 1); exit 1; }; };;+  esac+done++# If the user did not use the arguments to specify the items to instantiate,+# then the envvar interface is used.  Set only those that are not.+# We use the long form for the default assignment because of an extremely+# bizarre bug on SunOS 4.1.3.+if $ac_need_defaults; then+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files+  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers+fi++# Have a temporary directory for convenience.  Make it in the build tree+# simply because there is no reason to put it here, and in addition,+# creating and moving files from /tmp can sometimes cause problems.+# Create a temporary directory, and hook for its removal unless debugging.+$debug ||+{+  trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0+  trap '{ (exit 1); exit 1; }' 1 2 13 15+}++# Create a (secure) tmp directory for tmp files.++{+  tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&+  test -n "$tmp" && test -d "$tmp"+}  ||+{+  tmp=./confstat$$-$RANDOM+  (umask 077 && mkdir $tmp)+} ||+{+   echo "$me: cannot create a temporary directory in ." >&2+   { (exit 1); exit 1; }+}++_ACEOF++cat >>$CONFIG_STATUS <<_ACEOF++#+# CONFIG_FILES section.+#++# No need to generate the scripts if there are no CONFIG_FILES.+# This happens for instance when ./config.status config.h+if test -n "\$CONFIG_FILES"; then+  # Protect against being on the right side of a sed subst in config.status.+  sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;+   s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF+s,@SHELL@,$SHELL,;t t+s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t+s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t+s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t+s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t+s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t+s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t+s,@exec_prefix@,$exec_prefix,;t t+s,@prefix@,$prefix,;t t+s,@program_transform_name@,$program_transform_name,;t t+s,@bindir@,$bindir,;t t+s,@sbindir@,$sbindir,;t t+s,@libexecdir@,$libexecdir,;t t+s,@datadir@,$datadir,;t t+s,@sysconfdir@,$sysconfdir,;t t+s,@sharedstatedir@,$sharedstatedir,;t t+s,@localstatedir@,$localstatedir,;t t+s,@libdir@,$libdir,;t t+s,@includedir@,$includedir,;t t+s,@oldincludedir@,$oldincludedir,;t t+s,@infodir@,$infodir,;t t+s,@mandir@,$mandir,;t t+s,@build_alias@,$build_alias,;t t+s,@host_alias@,$host_alias,;t t+s,@target_alias@,$target_alias,;t t+s,@DEFS@,$DEFS,;t t+s,@ECHO_C@,$ECHO_C,;t t+s,@ECHO_N@,$ECHO_N,;t t+s,@ECHO_T@,$ECHO_T,;t t+s,@LIBS@,$LIBS,;t t+s,@CC@,$CC,;t t+s,@CFLAGS@,$CFLAGS,;t t+s,@LDFLAGS@,$LDFLAGS,;t t+s,@CPPFLAGS@,$CPPFLAGS,;t t+s,@ac_ct_CC@,$ac_ct_CC,;t t+s,@EXEEXT@,$EXEEXT,;t t+s,@OBJEXT@,$OBJEXT,;t t+s,@CPP@,$CPP,;t t+s,@EGREP@,$EGREP,;t t+s,@BUILD_PACKAGE_BOOL@,$BUILD_PACKAGE_BOOL,;t t+s,@EXTRA_LIBS@,$EXTRA_LIBS,;t t+s,@LIBOBJS@,$LIBOBJS,;t t+s,@LTLIBOBJS@,$LTLIBOBJS,;t t+CEOF++_ACEOF++  cat >>$CONFIG_STATUS <<\_ACEOF+  # Split the substitutions into bite-sized pieces for seds with+  # small command number limits, like on Digital OSF/1 and HP-UX.+  ac_max_sed_lines=48+  ac_sed_frag=1 # Number of current file.+  ac_beg=1 # First line for current file.+  ac_end=$ac_max_sed_lines # Line after last line for current file.+  ac_more_lines=:+  ac_sed_cmds=+  while $ac_more_lines; do+    if test $ac_beg -gt 1; then+      sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag+    else+      sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag+    fi+    if test ! -s $tmp/subs.frag; then+      ac_more_lines=false+    else+      # The purpose of the label and of the branching condition is to+      # speed up the sed processing (if there are no `@' at all, there+      # is no need to browse any of the substitutions).+      # These are the two extra sed commands mentioned above.+      (echo ':t+  /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed+      if test -z "$ac_sed_cmds"; then+  	ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"+      else+  	ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"+      fi+      ac_sed_frag=`expr $ac_sed_frag + 1`+      ac_beg=$ac_end+      ac_end=`expr $ac_end + $ac_max_sed_lines`+    fi+  done+  if test -z "$ac_sed_cmds"; then+    ac_sed_cmds=cat+  fi+fi # test -n "$CONFIG_FILES"++_ACEOF+cat >>$CONFIG_STATUS <<\_ACEOF+for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue+  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".+  case $ac_file in+  - | *:- | *:-:* ) # input from stdin+        cat >$tmp/stdin+        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`+        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;+  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`+        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;+  * )   ac_file_in=$ac_file.in ;;+  esac++  # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.+  ac_dir=`(dirname "$ac_file") 2>/dev/null ||+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+         X"$ac_file" : 'X\(//\)[^/]' \| \+         X"$ac_file" : 'X\(//\)$' \| \+         X"$ac_file" : 'X\(/\)' \| \+         .     : '\(.\)' 2>/dev/null ||+echo X"$ac_file" |+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }+  	  /^X\(\/\/\)$/{ s//\1/; q; }+  	  /^X\(\/\).*/{ s//\1/; q; }+  	  s/.*/./; q'`+  { if $as_mkdir_p; then+    mkdir -p "$ac_dir"+  else+    as_dir="$ac_dir"+    as_dirs=+    while test ! -d "$as_dir"; do+      as_dirs="$as_dir $as_dirs"+      as_dir=`(dirname "$as_dir") 2>/dev/null ||+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+         X"$as_dir" : 'X\(//\)[^/]' \| \+         X"$as_dir" : 'X\(//\)$' \| \+         X"$as_dir" : 'X\(/\)' \| \+         .     : '\(.\)' 2>/dev/null ||+echo X"$as_dir" |+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }+  	  /^X\(\/\/\)$/{ s//\1/; q; }+  	  /^X\(\/\).*/{ s//\1/; q; }+  	  s/.*/./; q'`+    done+    test ! -n "$as_dirs" || mkdir $as_dirs+  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5+echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}+   { (exit 1); exit 1; }; }; }++  ac_builddir=.++if test "$ac_dir" != .; then+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`+  # A "../" for each directory in $ac_dir_suffix.+  ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`+else+  ac_dir_suffix= ac_top_builddir=+fi++case $srcdir in+  .)  # No --srcdir option.  We are building in place.+    ac_srcdir=.+    if test -z "$ac_top_builddir"; then+       ac_top_srcdir=.+    else+       ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`+    fi ;;+  [\\/]* | ?:[\\/]* )  # Absolute path.+    ac_srcdir=$srcdir$ac_dir_suffix;+    ac_top_srcdir=$srcdir ;;+  *) # Relative path.+    ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix+    ac_top_srcdir=$ac_top_builddir$srcdir ;;+esac+# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be+# absolute.+ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`+ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd`+ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`+ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`++++  if test x"$ac_file" != x-; then+    { echo "$as_me:$LINENO: creating $ac_file" >&5+echo "$as_me: creating $ac_file" >&6;}+    rm -f "$ac_file"+  fi+  # Let's still pretend it is `configure' which instantiates (i.e., don't+  # use $as_me), people would be surprised to read:+  #    /* config.h.  Generated by config.status.  */+  if test x"$ac_file" = x-; then+    configure_input=+  else+    configure_input="$ac_file.  "+  fi+  configure_input=$configure_input"Generated from `echo $ac_file_in |+                                     sed 's,.*/,,'` by configure."++  # First look for the input files in the build tree, otherwise in the+  # src tree.+  ac_file_inputs=`IFS=:+    for f in $ac_file_in; do+      case $f in+      -) echo $tmp/stdin ;;+      [\\/$]*)+         # Absolute (can't be DOS-style, as IFS=:)+         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5+echo "$as_me: error: cannot find input file: $f" >&2;}+   { (exit 1); exit 1; }; }+         echo $f;;+      *) # Relative+         if test -f "$f"; then+           # Build tree+           echo $f+         elif test -f "$srcdir/$f"; then+           # Source tree+           echo $srcdir/$f+         else+           # /dev/null tree+           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5+echo "$as_me: error: cannot find input file: $f" >&2;}+   { (exit 1); exit 1; }; }+         fi;;+      esac+    done` || { (exit 1); exit 1; }+_ACEOF+cat >>$CONFIG_STATUS <<_ACEOF+  sed "$ac_vpsub+$extrasub+_ACEOF+cat >>$CONFIG_STATUS <<\_ACEOF+:t+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b+s,@configure_input@,$configure_input,;t t+s,@srcdir@,$ac_srcdir,;t t+s,@abs_srcdir@,$ac_abs_srcdir,;t t+s,@top_srcdir@,$ac_top_srcdir,;t t+s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t+s,@builddir@,$ac_builddir,;t t+s,@abs_builddir@,$ac_abs_builddir,;t t+s,@top_builddir@,$ac_top_builddir,;t t+s,@abs_top_builddir@,$ac_abs_top_builddir,;t t+" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out+  rm -f $tmp/stdin+  if test x"$ac_file" != x-; then+    mv $tmp/out $ac_file+  else+    cat $tmp/out+    rm -f $tmp/out+  fi++done+_ACEOF+cat >>$CONFIG_STATUS <<\_ACEOF++#+# CONFIG_HEADER section.+#++# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where+# NAME is the cpp macro being defined and VALUE is the value it is being given.+#+# ac_d sets the value in "#define NAME VALUE" lines.+ac_dA='s,^\([ 	]*\)#\([ 	]*define[ 	][ 	]*\)'+ac_dB='[ 	].*$,\1#\2'+ac_dC=' '+ac_dD=',;t'+# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".+ac_uA='s,^\([ 	]*\)#\([ 	]*\)undef\([ 	][ 	]*\)'+ac_uB='$,\1#\2define\3'+ac_uC=' '+ac_uD=',;t'++for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue+  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".+  case $ac_file in+  - | *:- | *:-:* ) # input from stdin+        cat >$tmp/stdin+        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`+        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;+  *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`+        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;+  * )   ac_file_in=$ac_file.in ;;+  esac++  test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5+echo "$as_me: creating $ac_file" >&6;}++  # First look for the input files in the build tree, otherwise in the+  # src tree.+  ac_file_inputs=`IFS=:+    for f in $ac_file_in; do+      case $f in+      -) echo $tmp/stdin ;;+      [\\/$]*)+         # Absolute (can't be DOS-style, as IFS=:)+         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5+echo "$as_me: error: cannot find input file: $f" >&2;}+   { (exit 1); exit 1; }; }+         echo $f;;+      *) # Relative+         if test -f "$f"; then+           # Build tree+           echo $f+         elif test -f "$srcdir/$f"; then+           # Source tree+           echo $srcdir/$f+         else+           # /dev/null tree+           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5+echo "$as_me: error: cannot find input file: $f" >&2;}+   { (exit 1); exit 1; }; }+         fi;;+      esac+    done` || { (exit 1); exit 1; }+  # Remove the trailing spaces.+  sed 's/[ 	]*$//' $ac_file_inputs >$tmp/in++_ACEOF++# Transform confdefs.h into two sed scripts, `conftest.defines' and+# `conftest.undefs', that substitutes the proper values into+# config.h.in to produce config.h.  The first handles `#define'+# templates, and the second `#undef' templates.+# And first: Protect against being on the right side of a sed subst in+# config.status.  Protect against being in an unquoted here document+# in config.status.+rm -f conftest.defines conftest.undefs+# Using a here document instead of a string reduces the quoting nightmare.+# Putting comments in sed scripts is not portable.+#+# `end' is used to avoid that the second main sed command (meant for+# 0-ary CPP macros) applies to n-ary macro definitions.+# See the Autoconf documentation for `clear'.+cat >confdef2sed.sed <<\_ACEOF+s/[\\&,]/\\&/g+s,[\\$`],\\&,g+t clear+: clear+s,^[ 	]*#[ 	]*define[ 	][ 	]*\([^ 	(][^ 	(]*\)\(([^)]*)\)[ 	]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp+t end+s,^[ 	]*#[ 	]*define[ 	][ 	]*\([^ 	][^ 	]*\)[ 	]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp+: end+_ACEOF+# If some macros were called several times there might be several times+# the same #defines, which is useless.  Nevertheless, we may not want to+# sort them, since we want the *last* AC-DEFINE to be honored.+uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines+sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs+rm -f confdef2sed.sed++# This sed command replaces #undef with comments.  This is necessary, for+# example, in the case of _POSIX_SOURCE, which is predefined and required+# on some systems where configure will not decide to define it.+cat >>conftest.undefs <<\_ACEOF+s,^[ 	]*#[ 	]*undef[ 	][ 	]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,+_ACEOF++# Break up conftest.defines because some shells have a limit on the size+# of here documents, and old seds have small limits too (100 cmds).+echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS+echo '  if grep "^[ 	]*#[ 	]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS+echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS+echo '  :' >>$CONFIG_STATUS+rm -f conftest.tail+while grep . conftest.defines >/dev/null+do+  # Write a limited-size here document to $tmp/defines.sed.+  echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS+  # Speed up: don't consider the non `#define' lines.+  echo '/^[ 	]*#[ 	]*define/!b' >>$CONFIG_STATUS+  # Work around the forget-to-reset-the-flag bug.+  echo 't clr' >>$CONFIG_STATUS+  echo ': clr' >>$CONFIG_STATUS+  sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS+  echo 'CEOF+  sed -f $tmp/defines.sed $tmp/in >$tmp/out+  rm -f $tmp/in+  mv $tmp/out $tmp/in+' >>$CONFIG_STATUS+  sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail+  rm -f conftest.defines+  mv conftest.tail conftest.defines+done+rm -f conftest.defines+echo '  fi # grep' >>$CONFIG_STATUS+echo >>$CONFIG_STATUS++# Break up conftest.undefs because some shells have a limit on the size+# of here documents, and old seds have small limits too (100 cmds).+echo '  # Handle all the #undef templates' >>$CONFIG_STATUS+rm -f conftest.tail+while grep . conftest.undefs >/dev/null+do+  # Write a limited-size here document to $tmp/undefs.sed.+  echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS+  # Speed up: don't consider the non `#undef'+  echo '/^[ 	]*#[ 	]*undef/!b' >>$CONFIG_STATUS+  # Work around the forget-to-reset-the-flag bug.+  echo 't clr' >>$CONFIG_STATUS+  echo ': clr' >>$CONFIG_STATUS+  sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS+  echo 'CEOF+  sed -f $tmp/undefs.sed $tmp/in >$tmp/out+  rm -f $tmp/in+  mv $tmp/out $tmp/in+' >>$CONFIG_STATUS+  sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail+  rm -f conftest.undefs+  mv conftest.tail conftest.undefs+done+rm -f conftest.undefs++cat >>$CONFIG_STATUS <<\_ACEOF+  # Let's still pretend it is `configure' which instantiates (i.e., don't+  # use $as_me), people would be surprised to read:+  #    /* config.h.  Generated by config.status.  */+  if test x"$ac_file" = x-; then+    echo "/* Generated by configure.  */" >$tmp/config.h+  else+    echo "/* $ac_file.  Generated by configure.  */" >$tmp/config.h+  fi+  cat $tmp/in >>$tmp/config.h+  rm -f $tmp/in+  if test x"$ac_file" != x-; then+    if diff $ac_file $tmp/config.h >/dev/null 2>&1; then+      { echo "$as_me:$LINENO: $ac_file is unchanged" >&5+echo "$as_me: $ac_file is unchanged" >&6;}+    else+      ac_dir=`(dirname "$ac_file") 2>/dev/null ||+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+         X"$ac_file" : 'X\(//\)[^/]' \| \+         X"$ac_file" : 'X\(//\)$' \| \+         X"$ac_file" : 'X\(/\)' \| \+         .     : '\(.\)' 2>/dev/null ||+echo X"$ac_file" |+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }+  	  /^X\(\/\/\)$/{ s//\1/; q; }+  	  /^X\(\/\).*/{ s//\1/; q; }+  	  s/.*/./; q'`+      { if $as_mkdir_p; then+    mkdir -p "$ac_dir"+  else+    as_dir="$ac_dir"+    as_dirs=+    while test ! -d "$as_dir"; do+      as_dirs="$as_dir $as_dirs"+      as_dir=`(dirname "$as_dir") 2>/dev/null ||+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \+         X"$as_dir" : 'X\(//\)[^/]' \| \+         X"$as_dir" : 'X\(//\)$' \| \+         X"$as_dir" : 'X\(/\)' \| \+         .     : '\(.\)' 2>/dev/null ||+echo X"$as_dir" |+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }+  	  /^X\(\/\/\)[^/].*/{ s//\1/; q; }+  	  /^X\(\/\/\)$/{ s//\1/; q; }+  	  /^X\(\/\).*/{ s//\1/; q; }+  	  s/.*/./; q'`+    done+    test ! -n "$as_dirs" || mkdir $as_dirs+  fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5+echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}+   { (exit 1); exit 1; }; }; }++      rm -f $ac_file+      mv $tmp/config.h $ac_file+    fi+  else+    cat $tmp/config.h+    rm -f $tmp/config.h+  fi+done+_ACEOF++cat >>$CONFIG_STATUS <<\_ACEOF++{ (exit 0); exit 0; }+_ACEOF+chmod +x $CONFIG_STATUS+ac_clean_files=$ac_clean_files_save+++# configure is writing to config.log, and then calls config.status.+# config.status does its own redirection, appending to config.log.+# Unfortunately, on DOS this fails, as config.log is still kept open+# by configure, so config.status won't be able to write to it; its+# output is simply discarded.  So we exec the FD to /dev/null,+# effectively closing config.log, so it can be properly (re)opened and+# appended to by config.status.  When coming back to configure, we+# need to make the FD available again.+if test "$no_create" != yes; then+  ac_cs_success=:+  ac_config_status_args=+  test "$silent" = yes &&+    ac_config_status_args="$ac_config_status_args --quiet"+  exec 5>/dev/null+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false+  exec 5>>config.log+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which+  # would make configure fail if this is the last instruction.+  $ac_cs_success || { (exit 1); exit 1; }+fi+
+ configure.ac view
@@ -0,0 +1,145 @@+AC_INIT([Haskell unix package], [2.0], [libraries@haskell.org], [unix])++# Safety check: Ensure that we are in the correct source directory.+AC_CONFIG_SRCDIR([include/HsUnix.h])++AC_CONFIG_HEADERS([include/HsUnixConfig.h])++# Is this a Unix system?+AC_CHECK_HEADER([dlfcn.h], [BUILD_PACKAGE_BOOL=True], [BUILD_PACKAGE_BOOL=False])+AC_SUBST([BUILD_PACKAGE_BOOL])++AC_C_CONST++AC_CHECK_HEADERS([dirent.h fcntl.h grp.h limits.h pwd.h signal.h string.h])+AC_CHECK_HEADERS([sys/resource.h sys/stat.h sys/times.h sys/time.h])+AC_CHECK_HEADERS([sys/utsname.h sys/wait.h])+AC_CHECK_HEADERS([termios.h time.h unistd.h utime.h])++AC_CHECK_FUNCS([getgrgid_r getgrnam_r getpwnam_r getpwuid_r getpwnam getpwuid])+AC_CHECK_FUNCS([getpwent getgrent])+AC_CHECK_FUNCS([lchown setenv sysconf unsetenv])++AC_MSG_CHECKING([for _SC_GETGR_R_SIZE_MAX])+AC_EGREP_CPP(we_have_that_sysconf_thing,+[+#include <unistd.h>+#ifdef _SC_GETGR_R_SIZE_MAX+we_have_that_sysconf_thing+#endif+],+[AC_MSG_RESULT([yes])+AC_DEFINE([HAVE_SC_GETGR_R_SIZE_MAX], [1], [Define to 1 if <unistd.h> defines _SC_GETGR_R_SIZE_MAX.])],+[AC_MSG_RESULT([no])])++AC_MSG_CHECKING([for _SC_GETPW_R_SIZE_MAX])+AC_EGREP_CPP(we_have_that_sysconf_thing,+[+#include <unistd.h>+#ifdef _SC_GETPW_R_SIZE_MAX+we_have_that_sysconf_thing+#endif+],+[AC_MSG_RESULT([yes])+AC_DEFINE([HAVE_SC_GETPW_R_SIZE_MAX], [1], [Define to 1 if <unistd.h> defines _SC_GETPW_R_SIZE_MAX.])],+[AC_MSG_RESULT([no])])++dnl ---------- usleep ----------+dnl --- stolen from guile configure ---+dnl --- FIXME: /usr/include/unistd.h can't be right?++### On some systems usleep has no return value.  If it does have one,+### we'd like to return it; otherwise, we'll fake it.+AC_CACHE_CHECK([return type of usleep], cv_func_usleep_return_type,+  [AC_EGREP_HEADER(changequote(<, >)<void[      ]+usleep>changequote([, ]),+                   /usr/include/unistd.h,+                   [cv_func_usleep_return_type=void],+                   [cv_func_usleep_return_type=int])])+case "$cv_func_usleep_return_type" in+  "void" )+    AC_DEFINE([USLEEP_RETURNS_VOID], [1], [Define if the system headers declare usleep to return void.])+  ;;+esac++dnl ** sometimes RTLD_NEXT is hidden in #ifdefs we really don't wan to set+AC_MSG_CHECKING(for RTLD_NEXT from dlfcn.h)+AC_EGREP_CPP(yes,+[+ #include <dlfcn.h>+ #ifdef RTLD_NEXT+        yes+ #endif+], [+  AC_MSG_RESULT(yes)+  AC_DEFINE([HAVE_RTLDNEXT], [1], [Define to 1 if we can see RTLD_NEXT in dlfcn.h.])+], [+  AC_MSG_RESULT(no)+  ])    ++dnl ** RTLD_DEFAULT isn't available on cygwin+AC_MSG_CHECKING(for RTLD_DEFAULT from dlfcn.h)+AC_EGREP_CPP(yes,+[+ #include <dlfcn.h>+ #ifdef RTLD_DEFAULT+        yes+ #endif+], [+  AC_MSG_RESULT(yes)+  AC_DEFINE([HAVE_RTLDDEFAULT], [1], [Define to 1 if RTLD_DEFAULT is available.])+], [+  AC_MSG_RESULT(no)+  ])    ++dnl ** RTLD_LOCAL isn't available on cygwin or openbsd+AC_MSG_CHECKING(for RTLD_LOCAL from dlfcn.h)+AC_EGREP_CPP(yes,+[+ #include <dlfcn.h>+ #ifdef RTLD_LOCAL+        yes+ #endif+], [+  AC_MSG_RESULT(yes)+  AC_DEFINE([HAVE_RTLDLOCAL], [1], [Define to 1 if RTLD_LOCAL is available.])+], [+  AC_MSG_RESULT(no)+  ])    ++dnl ** RTLD_GLOBAL isn't available on openbsd+AC_MSG_CHECKING(for RTLD_GLOBAL from dlfcn.h)+AC_EGREP_CPP(yes,+[+ #include <dlfcn.h>+ #ifdef RTLD_GLOBAL+        yes+ #endif+], [+  AC_MSG_RESULT(yes)+  AC_DEFINE([HAVE_RTLDGLOBAL], [1], [Define to 1 if RTLD_GLOBAL is available.])+], [+  AC_MSG_RESULT(no)+  ])    ++dnl ** RTLD_NOW isn't available on openbsd+AC_MSG_CHECKING(for RTLD_NOW from dlfcn.h)+AC_EGREP_CPP(yes,+[+ #include <dlfcn.h>+ #ifdef RTLD_NOW+        yes+ #endif+], [+  AC_MSG_RESULT(yes)+  AC_DEFINE([HAVE_RTLDNOW], [1], [Define to 1 if we can see RTLD_NOW in dlfcn.h])+], [+  AC_MSG_RESULT(no)+  ])    ++# Avoid adding dl if absent or unneeded+AC_CHECK_LIB(dl, dlopen, [EXTRA_LIBS=dl], [EXTRA_LIBS=])+AC_SUBST([EXTRA_LIBS])++AC_CONFIG_FILES([unix.buildinfo])++AC_OUTPUT
+ include/HsUnix.h view
@@ -0,0 +1,121 @@+/* -----------------------------------------------------------------------------+ *+ * (c) The University of Glasgow 2002+ *+ * Definitions for package `unix' which are visible in Haskell land.+ *+ * ---------------------------------------------------------------------------*/++#ifndef HSUNIX_H+#define HSUNIX_H++#include "HsUnixConfig.h"++/* ultra-evil... */+#undef PACKAGE_BUGREPORT+#undef PACKAGE_NAME+#undef PACKAGE_STRING+#undef PACKAGE_TARNAME+#undef PACKAGE_VERSION++#ifdef solaris2_HOST_OS+#define _POSIX_PTHREAD_SEMANTICS+#endif++#include <stdlib.h>+#include <stdio.h>++#ifdef HAVE_STRING_H+#include <string.h>+#endif+#ifdef HAVE_SYS_TIMES_H+#include <sys/times.h>+#endif+#ifdef HAVE_SYS_TIME_H+#include <sys/time.h>+#endif+#ifdef HAVE_SYS_RESOURCE_H+#include <sys/resource.h>+#endif+#ifdef HAVE_SYS_WAIT_H+#include <sys/wait.h>+#endif+#ifdef HAVE_SYS_STAT_H+#include <sys/stat.h>+#endif+#ifdef HAVE_TIME_H+#include <time.h>+#endif+#ifdef HAVE_UNISTD_H+#include <unistd.h>+#endif+#ifdef HAVE_UTIME_H+#include <utime.h>+#endif+#ifdef HAVE_FCNTL_H+#include <fcntl.h>+#endif+#ifdef HAVE_LIMITS_H+#include <limits.h>+#endif+#ifdef HAVE_TERMIOS_H+#include <termios.h>+#endif+#ifdef HAVE_SYS_UTSNAME_H+#include <sys/utsname.h>+#endif+#ifdef HAVE_PWD_H+#include <pwd.h>+#endif+#ifdef HAVE_GRP_H+#include <grp.h>+#endif+#ifdef HAVE_DIRENT_H+#include <dirent.h>+#endif++#include <dlfcn.h>++#ifdef HAVE_SIGNAL_H+#include <signal.h>+#endif++extern char **environ;++#ifndef INLINE+# if defined(__GNUC__)+#  define INLINE extern inline+# else+#  define INLINE inline+# endif+#endif++INLINE int __hsunix_wifexited   (int stat) { return WIFEXITED(stat); }+INLINE int __hsunix_wexitstatus (int stat) { return WEXITSTATUS(stat); }+INLINE int __hsunix_wifsignaled (int stat) { return WIFSIGNALED(stat); }+INLINE int __hsunix_wtermsig    (int stat) { return WTERMSIG(stat); }+INLINE int __hsunix_wifstopped  (int stat) { return WIFSTOPPED(stat); }+INLINE int __hsunix_wstopsig    (int stat) { return WSTOPSIG(stat); }++#ifdef HAVE_RTLDNEXT+INLINE void *__hsunix_rtldNext (void) {return RTLD_NEXT;} +#endif++#ifdef HAVE_RTLDDEFAULT+INLINE void *__hsunix_rtldDefault (void) {return RTLD_DEFAULT;} +#endif++/* O_SYNC doesn't exist on Mac OS X and (at least some versions of) FreeBSD,+fall back to O_FSYNC, which should be the same */+#ifndef O_SYNC+#define O_SYNC O_FSYNC+#endif++#ifdef SIGINFO+INLINE int __hsunix_SIGINFO()	{ return SIGINFO; }+#endif+#ifdef SIGWINCH+INLINE int __hsunix_SIGWINCH()	{ return SIGWINCH; }+#endif++#endif
+ include/HsUnixConfig.h.in view
@@ -0,0 +1,151 @@+/* include/HsUnixConfig.h.in.  Generated from configure.ac by autoheader.  */++/* Define to 1 if you have the <dirent.h> header file. */+#undef HAVE_DIRENT_H++/* Define to 1 if you have the <fcntl.h> header file. */+#undef HAVE_FCNTL_H++/* Define to 1 if you have the `getgrent' function. */+#undef HAVE_GETGRENT++/* Define to 1 if you have the `getgrgid_r' function. */+#undef HAVE_GETGRGID_R++/* Define to 1 if you have the `getgrnam_r' function. */+#undef HAVE_GETGRNAM_R++/* Define to 1 if you have the `getpwent' function. */+#undef HAVE_GETPWENT++/* Define to 1 if you have the `getpwnam' function. */+#undef HAVE_GETPWNAM++/* Define to 1 if you have the `getpwnam_r' function. */+#undef HAVE_GETPWNAM_R++/* Define to 1 if you have the `getpwuid' function. */+#undef HAVE_GETPWUID++/* Define to 1 if you have the `getpwuid_r' function. */+#undef HAVE_GETPWUID_R++/* Define to 1 if you have the <grp.h> header file. */+#undef HAVE_GRP_H++/* Define to 1 if you have the <inttypes.h> header file. */+#undef HAVE_INTTYPES_H++/* Define to 1 if you have the `lchown' function. */+#undef HAVE_LCHOWN++/* Define to 1 if you have the <limits.h> header file. */+#undef HAVE_LIMITS_H++/* Define to 1 if you have the <memory.h> header file. */+#undef HAVE_MEMORY_H++/* Define to 1 if you have the <pwd.h> header file. */+#undef HAVE_PWD_H++/* Define to 1 if RTLD_DEFAULT is available. */+#undef HAVE_RTLDDEFAULT++/* Define to 1 if RTLD_GLOBAL is available. */+#undef HAVE_RTLDGLOBAL++/* Define to 1 if RTLD_LOCAL is available. */+#undef HAVE_RTLDLOCAL++/* Define to 1 if we can see RTLD_NEXT in dlfcn.h. */+#undef HAVE_RTLDNEXT++/* Define to 1 if we can see RTLD_NOW in dlfcn.h */+#undef HAVE_RTLDNOW++/* Define to 1 if <unistd.h> defines _SC_GETGR_R_SIZE_MAX. */+#undef HAVE_SC_GETGR_R_SIZE_MAX++/* Define to 1 if <unistd.h> defines _SC_GETPW_R_SIZE_MAX. */+#undef HAVE_SC_GETPW_R_SIZE_MAX++/* Define to 1 if you have the `setenv' function. */+#undef HAVE_SETENV++/* Define to 1 if you have the <signal.h> header file. */+#undef HAVE_SIGNAL_H++/* Define to 1 if you have the <stdint.h> header file. */+#undef HAVE_STDINT_H++/* Define to 1 if you have the <stdlib.h> header file. */+#undef HAVE_STDLIB_H++/* Define to 1 if you have the <strings.h> header file. */+#undef HAVE_STRINGS_H++/* Define to 1 if you have the <string.h> header file. */+#undef HAVE_STRING_H++/* Define to 1 if you have the `sysconf' function. */+#undef HAVE_SYSCONF++/* Define to 1 if you have the <sys/resource.h> header file. */+#undef HAVE_SYS_RESOURCE_H++/* Define to 1 if you have the <sys/stat.h> header file. */+#undef HAVE_SYS_STAT_H++/* Define to 1 if you have the <sys/times.h> header file. */+#undef HAVE_SYS_TIMES_H++/* Define to 1 if you have the <sys/time.h> header file. */+#undef HAVE_SYS_TIME_H++/* Define to 1 if you have the <sys/types.h> header file. */+#undef HAVE_SYS_TYPES_H++/* Define to 1 if you have the <sys/utsname.h> header file. */+#undef HAVE_SYS_UTSNAME_H++/* Define to 1 if you have the <sys/wait.h> header file. */+#undef HAVE_SYS_WAIT_H++/* Define to 1 if you have the <termios.h> header file. */+#undef HAVE_TERMIOS_H++/* Define to 1 if you have the <time.h> header file. */+#undef HAVE_TIME_H++/* Define to 1 if you have the <unistd.h> header file. */+#undef HAVE_UNISTD_H++/* Define to 1 if you have the `unsetenv' function. */+#undef HAVE_UNSETENV++/* Define to 1 if you have the <utime.h> header file. */+#undef HAVE_UTIME_H++/* Define to the address where bug reports for this package should be sent. */+#undef PACKAGE_BUGREPORT++/* Define to the full name of this package. */+#undef PACKAGE_NAME++/* Define to the full name and version of this package. */+#undef PACKAGE_STRING++/* Define to the one symbol short name of this package. */+#undef PACKAGE_TARNAME++/* Define to the version of this package. */+#undef PACKAGE_VERSION++/* Define to 1 if you have the ANSI C header files. */+#undef STDC_HEADERS++/* Define if the system headers declare usleep to return void. */+#undef USLEEP_RETURNS_VOID++/* Define to empty if `const' does not conform to ANSI C. */+#undef const
+ unix.buildinfo.in view
@@ -0,0 +1,2 @@+buildable: @BUILD_PACKAGE_BOOL@+extra-libraries: @EXTRA_LIBS@
+ unix.cabal view
@@ -0,0 +1,44 @@+name:		unix+version:	2.0+license:	BSD3+license-file:	LICENSE+maintainer:	libraries@haskell.org+synopsis:	POSIX functionality+description:+	This package gives you access to the set of operating system+	services standardised by POSIX 1003.1b (or the IEEE Portable+	Operating System Interface for Computing Environments -+	IEEE Std. 1003.1).+	.+	The package is not supported under Windows (except under Cygwin).+exposed-modules:+		System.Posix+		System.Posix.DynamicLinker.Module+		System.Posix.DynamicLinker.Prim+		System.Posix.Directory+		System.Posix.DynamicLinker+		System.Posix.Env+		System.Posix.Error+		System.Posix.Files+		System.Posix.IO+		System.Posix.Process+		System.Posix.Resource+		System.Posix.Temp+		System.Posix.Terminal+		System.Posix.Time+		System.Posix.Unistd+		System.Posix.User+		System.Posix.Signals.Exts+extra-source-files:+		configure.ac configure+		unix.buildinfo.in include/HsUnixConfig.h.in+		include/HsUnix.h+extra-tmp-files:+		config.log config.status autom4te.cache+		unix.buildinfo include/HsUnixConfig.h+build-depends:	base+extensions:	CPP+include-dirs: 	include+install-includes:+		HsUnix.h HsUnixConfig.h+c-sources:	cbits/HsUnix.c