1 {-# OPTIONS_GHC -XNoImplicitPrelude -#include "HsBase.h" #-}
2 -----------------------------------------------------------------------------
4 -- Module : Foreign.C.Error
5 -- Copyright : (c) The FFI task force 2001
6 -- License : BSD-style (see the file libraries/base/LICENSE)
8 -- Maintainer : ffi@haskell.org
9 -- Stability : provisional
10 -- Portability : portable
12 -- C-specific Marshalling support: Handling of C \"errno\" error codes.
14 -----------------------------------------------------------------------------
16 module Foreign.C.Error (
18 -- * Haskell representations of @errno@ values
20 Errno(..), -- instance: Eq
22 -- ** Common @errno@ symbols
23 -- | Different operating systems and\/or C libraries often support
24 -- different values of @errno@. This module defines the common values,
25 -- but due to the open definition of 'Errno' users may add definitions
26 -- which are not predefined.
27 eOK, e2BIG, eACCES, eADDRINUSE, eADDRNOTAVAIL, eADV, eAFNOSUPPORT, eAGAIN,
28 eALREADY, eBADF, eBADMSG, eBADRPC, eBUSY, eCHILD, eCOMM, eCONNABORTED,
29 eCONNREFUSED, eCONNRESET, eDEADLK, eDESTADDRREQ, eDIRTY, eDOM, eDQUOT,
30 eEXIST, eFAULT, eFBIG, eFTYPE, eHOSTDOWN, eHOSTUNREACH, eIDRM, eILSEQ,
31 eINPROGRESS, eINTR, eINVAL, eIO, eISCONN, eISDIR, eLOOP, eMFILE, eMLINK,
32 eMSGSIZE, eMULTIHOP, eNAMETOOLONG, eNETDOWN, eNETRESET, eNETUNREACH,
33 eNFILE, eNOBUFS, eNODATA, eNODEV, eNOENT, eNOEXEC, eNOLCK, eNOLINK,
34 eNOMEM, eNOMSG, eNONET, eNOPROTOOPT, eNOSPC, eNOSR, eNOSTR, eNOSYS,
35 eNOTBLK, eNOTCONN, eNOTDIR, eNOTEMPTY, eNOTSOCK, eNOTTY, eNXIO,
36 eOPNOTSUPP, ePERM, ePFNOSUPPORT, ePIPE, ePROCLIM, ePROCUNAVAIL,
37 ePROGMISMATCH, ePROGUNAVAIL, ePROTO, ePROTONOSUPPORT, ePROTOTYPE,
38 eRANGE, eREMCHG, eREMOTE, eROFS, eRPCMISMATCH, eRREMOTE, eSHUTDOWN,
39 eSOCKTNOSUPPORT, eSPIPE, eSRCH, eSRMNT, eSTALE, eTIME, eTIMEDOUT,
40 eTOOMANYREFS, eTXTBSY, eUSERS, eWOULDBLOCK, eXDEV,
42 -- ** 'Errno' functions
44 isValidErrno, -- :: Errno -> Bool
46 -- access to the current thread's "errno" value
48 getErrno, -- :: IO Errno
49 resetErrno, -- :: IO ()
51 -- conversion of an "errno" value into IO error
53 errnoToIOError, -- :: String -- location
55 -- -> Maybe Handle -- handle
56 -- -> Maybe String -- filename
59 -- throw current "errno" value
61 throwErrno, -- :: String -> IO a
63 -- ** Guards for IO operations that may fail
65 throwErrnoIf, -- :: (a -> Bool) -> String -> IO a -> IO a
66 throwErrnoIf_, -- :: (a -> Bool) -> String -> IO a -> IO ()
67 throwErrnoIfRetry, -- :: (a -> Bool) -> String -> IO a -> IO a
68 throwErrnoIfRetry_, -- :: (a -> Bool) -> String -> IO a -> IO ()
69 throwErrnoIfMinus1, -- :: Num a
70 -- => String -> IO a -> IO a
71 throwErrnoIfMinus1_, -- :: Num a
72 -- => String -> IO a -> IO ()
73 throwErrnoIfMinus1Retry,
75 -- => String -> IO a -> IO a
76 throwErrnoIfMinus1Retry_,
78 -- => String -> IO a -> IO ()
79 throwErrnoIfNull, -- :: String -> IO (Ptr a) -> IO (Ptr a)
80 throwErrnoIfNullRetry,-- :: String -> IO (Ptr a) -> IO (Ptr a)
82 throwErrnoIfRetryMayBlock,
83 throwErrnoIfRetryMayBlock_,
84 throwErrnoIfMinus1RetryMayBlock,
85 throwErrnoIfMinus1RetryMayBlock_,
86 throwErrnoIfNullRetryMayBlock,
92 throwErrnoPathIfMinus1,
93 throwErrnoPathIfMinus1_,
97 -- this is were we get the CONST_XXX definitions from that configure
101 #include "HsBaseConfig.h"
104 -- system dependent imports
105 -- ------------------------
107 -- GHC allows us to get at the guts inside IO errors/exceptions
109 #if __GLASGOW_HASKELL__
110 import GHC.IOBase (IOException(..), IOErrorType(..))
111 #endif /* __GLASGOW_HASKELL__ */
117 import Foreign.Storable
119 import Foreign.C.Types
120 import Foreign.C.String
121 import Foreign.Marshal.Error ( void )
124 #if __GLASGOW_HASKELL__
129 import Hugs.Prelude ( Handle, IOError, ioError )
130 import System.IO.Unsafe ( unsafePerformIO )
132 import System.IO ( Handle )
133 import System.IO.Error ( IOError, ioError )
134 import System.IO.Unsafe ( unsafePerformIO )
138 {-# CFILES cbits/PrelIOUtils.c #-}
145 -- | Haskell representation for @errno@ values.
146 -- The implementation is deliberately exposed, to allow users to add
147 -- their own definitions of 'Errno' values.
149 newtype Errno = Errno CInt
151 instance Eq Errno where
152 errno1@(Errno no1) == errno2@(Errno no2)
153 | isValidErrno errno1 && isValidErrno errno2 = no1 == no2
156 -- common "errno" symbols
158 eOK, e2BIG, eACCES, eADDRINUSE, eADDRNOTAVAIL, eADV, eAFNOSUPPORT, eAGAIN,
159 eALREADY, eBADF, eBADMSG, eBADRPC, eBUSY, eCHILD, eCOMM, eCONNABORTED,
160 eCONNREFUSED, eCONNRESET, eDEADLK, eDESTADDRREQ, eDIRTY, eDOM, eDQUOT,
161 eEXIST, eFAULT, eFBIG, eFTYPE, eHOSTDOWN, eHOSTUNREACH, eIDRM, eILSEQ,
162 eINPROGRESS, eINTR, eINVAL, eIO, eISCONN, eISDIR, eLOOP, eMFILE, eMLINK,
163 eMSGSIZE, eMULTIHOP, eNAMETOOLONG, eNETDOWN, eNETRESET, eNETUNREACH,
164 eNFILE, eNOBUFS, eNODATA, eNODEV, eNOENT, eNOEXEC, eNOLCK, eNOLINK,
165 eNOMEM, eNOMSG, eNONET, eNOPROTOOPT, eNOSPC, eNOSR, eNOSTR, eNOSYS,
166 eNOTBLK, eNOTCONN, eNOTDIR, eNOTEMPTY, eNOTSOCK, eNOTTY, eNXIO,
167 eOPNOTSUPP, ePERM, ePFNOSUPPORT, ePIPE, ePROCLIM, ePROCUNAVAIL,
168 ePROGMISMATCH, ePROGUNAVAIL, ePROTO, ePROTONOSUPPORT, ePROTOTYPE,
169 eRANGE, eREMCHG, eREMOTE, eROFS, eRPCMISMATCH, eRREMOTE, eSHUTDOWN,
170 eSOCKTNOSUPPORT, eSPIPE, eSRCH, eSRMNT, eSTALE, eTIME, eTIMEDOUT,
171 eTOOMANYREFS, eTXTBSY, eUSERS, eWOULDBLOCK, eXDEV :: Errno
173 -- the cCONST_XXX identifiers are cpp symbols whose value is computed by
180 e2BIG = Errno (CONST_E2BIG)
181 eACCES = Errno (CONST_EACCES)
182 eADDRINUSE = Errno (CONST_EADDRINUSE)
183 eADDRNOTAVAIL = Errno (CONST_EADDRNOTAVAIL)
184 eADV = Errno (CONST_EADV)
185 eAFNOSUPPORT = Errno (CONST_EAFNOSUPPORT)
186 eAGAIN = Errno (CONST_EAGAIN)
187 eALREADY = Errno (CONST_EALREADY)
188 eBADF = Errno (CONST_EBADF)
189 eBADMSG = Errno (CONST_EBADMSG)
190 eBADRPC = Errno (CONST_EBADRPC)
191 eBUSY = Errno (CONST_EBUSY)
192 eCHILD = Errno (CONST_ECHILD)
193 eCOMM = Errno (CONST_ECOMM)
194 eCONNABORTED = Errno (CONST_ECONNABORTED)
195 eCONNREFUSED = Errno (CONST_ECONNREFUSED)
196 eCONNRESET = Errno (CONST_ECONNRESET)
197 eDEADLK = Errno (CONST_EDEADLK)
198 eDESTADDRREQ = Errno (CONST_EDESTADDRREQ)
199 eDIRTY = Errno (CONST_EDIRTY)
200 eDOM = Errno (CONST_EDOM)
201 eDQUOT = Errno (CONST_EDQUOT)
202 eEXIST = Errno (CONST_EEXIST)
203 eFAULT = Errno (CONST_EFAULT)
204 eFBIG = Errno (CONST_EFBIG)
205 eFTYPE = Errno (CONST_EFTYPE)
206 eHOSTDOWN = Errno (CONST_EHOSTDOWN)
207 eHOSTUNREACH = Errno (CONST_EHOSTUNREACH)
208 eIDRM = Errno (CONST_EIDRM)
209 eILSEQ = Errno (CONST_EILSEQ)
210 eINPROGRESS = Errno (CONST_EINPROGRESS)
211 eINTR = Errno (CONST_EINTR)
212 eINVAL = Errno (CONST_EINVAL)
213 eIO = Errno (CONST_EIO)
214 eISCONN = Errno (CONST_EISCONN)
215 eISDIR = Errno (CONST_EISDIR)
216 eLOOP = Errno (CONST_ELOOP)
217 eMFILE = Errno (CONST_EMFILE)
218 eMLINK = Errno (CONST_EMLINK)
219 eMSGSIZE = Errno (CONST_EMSGSIZE)
220 eMULTIHOP = Errno (CONST_EMULTIHOP)
221 eNAMETOOLONG = Errno (CONST_ENAMETOOLONG)
222 eNETDOWN = Errno (CONST_ENETDOWN)
223 eNETRESET = Errno (CONST_ENETRESET)
224 eNETUNREACH = Errno (CONST_ENETUNREACH)
225 eNFILE = Errno (CONST_ENFILE)
226 eNOBUFS = Errno (CONST_ENOBUFS)
227 eNODATA = Errno (CONST_ENODATA)
228 eNODEV = Errno (CONST_ENODEV)
229 eNOENT = Errno (CONST_ENOENT)
230 eNOEXEC = Errno (CONST_ENOEXEC)
231 eNOLCK = Errno (CONST_ENOLCK)
232 eNOLINK = Errno (CONST_ENOLINK)
233 eNOMEM = Errno (CONST_ENOMEM)
234 eNOMSG = Errno (CONST_ENOMSG)
235 eNONET = Errno (CONST_ENONET)
236 eNOPROTOOPT = Errno (CONST_ENOPROTOOPT)
237 eNOSPC = Errno (CONST_ENOSPC)
238 eNOSR = Errno (CONST_ENOSR)
239 eNOSTR = Errno (CONST_ENOSTR)
240 eNOSYS = Errno (CONST_ENOSYS)
241 eNOTBLK = Errno (CONST_ENOTBLK)
242 eNOTCONN = Errno (CONST_ENOTCONN)
243 eNOTDIR = Errno (CONST_ENOTDIR)
244 eNOTEMPTY = Errno (CONST_ENOTEMPTY)
245 eNOTSOCK = Errno (CONST_ENOTSOCK)
246 eNOTTY = Errno (CONST_ENOTTY)
247 eNXIO = Errno (CONST_ENXIO)
248 eOPNOTSUPP = Errno (CONST_EOPNOTSUPP)
249 ePERM = Errno (CONST_EPERM)
250 ePFNOSUPPORT = Errno (CONST_EPFNOSUPPORT)
251 ePIPE = Errno (CONST_EPIPE)
252 ePROCLIM = Errno (CONST_EPROCLIM)
253 ePROCUNAVAIL = Errno (CONST_EPROCUNAVAIL)
254 ePROGMISMATCH = Errno (CONST_EPROGMISMATCH)
255 ePROGUNAVAIL = Errno (CONST_EPROGUNAVAIL)
256 ePROTO = Errno (CONST_EPROTO)
257 ePROTONOSUPPORT = Errno (CONST_EPROTONOSUPPORT)
258 ePROTOTYPE = Errno (CONST_EPROTOTYPE)
259 eRANGE = Errno (CONST_ERANGE)
260 eREMCHG = Errno (CONST_EREMCHG)
261 eREMOTE = Errno (CONST_EREMOTE)
262 eROFS = Errno (CONST_EROFS)
263 eRPCMISMATCH = Errno (CONST_ERPCMISMATCH)
264 eRREMOTE = Errno (CONST_ERREMOTE)
265 eSHUTDOWN = Errno (CONST_ESHUTDOWN)
266 eSOCKTNOSUPPORT = Errno (CONST_ESOCKTNOSUPPORT)
267 eSPIPE = Errno (CONST_ESPIPE)
268 eSRCH = Errno (CONST_ESRCH)
269 eSRMNT = Errno (CONST_ESRMNT)
270 eSTALE = Errno (CONST_ESTALE)
271 eTIME = Errno (CONST_ETIME)
272 eTIMEDOUT = Errno (CONST_ETIMEDOUT)
273 eTOOMANYREFS = Errno (CONST_ETOOMANYREFS)
274 eTXTBSY = Errno (CONST_ETXTBSY)
275 eUSERS = Errno (CONST_EUSERS)
276 eWOULDBLOCK = Errno (CONST_EWOULDBLOCK)
277 eXDEV = Errno (CONST_EXDEV)
280 -- | Yield 'True' if the given 'Errno' value is valid on the system.
281 -- This implies that the 'Eq' instance of 'Errno' is also system dependent
282 -- as it is only defined for valid values of 'Errno'.
284 isValidErrno :: Errno -> Bool
286 -- the configure script sets all invalid "errno"s to -1
288 isValidErrno (Errno errno) = errno /= -1
291 -- access to the current thread's "errno" value
292 -- --------------------------------------------
294 -- | Get the current value of @errno@ in the current thread.
298 -- We must call a C function to get the value of errno in general. On
299 -- threaded systems, errno is hidden behind a C macro so that each OS
300 -- thread gets its own copy.
302 getErrno = do e <- peek _errno; return (Errno e)
303 foreign import ccall unsafe "errno.h &errno" _errno :: Ptr CInt
305 getErrno = do e <- get_errno; return (Errno e)
306 foreign import ccall unsafe "HsBase.h __hscore_get_errno" get_errno :: IO CInt
309 -- | Reset the current thread\'s @errno@ value to 'eOK'.
313 -- Again, setting errno has to be done via a C function.
315 resetErrno = poke _errno 0
317 resetErrno = set_errno 0
318 foreign import ccall unsafe "HsBase.h __hscore_set_errno" set_errno :: CInt -> IO ()
321 -- throw current "errno" value
322 -- ---------------------------
324 -- | Throw an 'IOError' corresponding to the current value of 'getErrno'.
326 throwErrno :: String -- ^ textual description of the error location
331 ioError (errnoToIOError loc errno Nothing Nothing)
334 -- guards for IO operations that may fail
335 -- --------------------------------------
337 -- | Throw an 'IOError' corresponding to the current value of 'getErrno'
338 -- if the result value of the 'IO' action meets the given predicate.
340 throwErrnoIf :: (a -> Bool) -- ^ predicate to apply to the result value
341 -- of the 'IO' operation
342 -> String -- ^ textual description of the location
343 -> IO a -- ^ the 'IO' operation to be executed
345 throwErrnoIf pred loc f =
348 if pred res then throwErrno loc else return res
350 -- | as 'throwErrnoIf', but discards the result of the 'IO' action after
353 throwErrnoIf_ :: (a -> Bool) -> String -> IO a -> IO ()
354 throwErrnoIf_ pred loc f = void $ throwErrnoIf pred loc f
356 -- | as 'throwErrnoIf', but retry the 'IO' action when it yields the
357 -- error code 'eINTR' - this amounts to the standard retry loop for
358 -- interrupted POSIX system calls.
360 throwErrnoIfRetry :: (a -> Bool) -> String -> IO a -> IO a
361 throwErrnoIfRetry pred loc f =
368 then throwErrnoIfRetry pred loc f
372 -- | as 'throwErrnoIfRetry', but checks for operations that would block and
373 -- executes an alternative action before retrying in that case.
375 throwErrnoIfRetryMayBlock
376 :: (a -> Bool) -- ^ predicate to apply to the result value
377 -- of the 'IO' operation
378 -> String -- ^ textual description of the location
379 -> IO a -- ^ the 'IO' operation to be executed
380 -> IO b -- ^ action to execute before retrying if
381 -- an immediate retry would block
383 throwErrnoIfRetryMayBlock pred loc f on_block =
390 then throwErrnoIfRetryMayBlock pred loc f on_block
391 else if err == eWOULDBLOCK || err == eAGAIN
392 then do on_block; throwErrnoIfRetryMayBlock pred loc f on_block
396 -- | as 'throwErrnoIfRetry', but discards the result.
398 throwErrnoIfRetry_ :: (a -> Bool) -> String -> IO a -> IO ()
399 throwErrnoIfRetry_ pred loc f = void $ throwErrnoIfRetry pred loc f
401 -- | as 'throwErrnoIfRetryMayBlock', but discards the result.
403 throwErrnoIfRetryMayBlock_ :: (a -> Bool) -> String -> IO a -> IO b -> IO ()
404 throwErrnoIfRetryMayBlock_ pred loc f on_block
405 = void $ throwErrnoIfRetryMayBlock pred loc f on_block
407 -- | Throw an 'IOError' corresponding to the current value of 'getErrno'
408 -- if the 'IO' action returns a result of @-1@.
410 throwErrnoIfMinus1 :: Num a => String -> IO a -> IO a
411 throwErrnoIfMinus1 = throwErrnoIf (== -1)
413 -- | as 'throwErrnoIfMinus1', but discards the result.
415 throwErrnoIfMinus1_ :: Num a => String -> IO a -> IO ()
416 throwErrnoIfMinus1_ = throwErrnoIf_ (== -1)
418 -- | Throw an 'IOError' corresponding to the current value of 'getErrno'
419 -- if the 'IO' action returns a result of @-1@, but retries in case of
420 -- an interrupted operation.
422 throwErrnoIfMinus1Retry :: Num a => String -> IO a -> IO a
423 throwErrnoIfMinus1Retry = throwErrnoIfRetry (== -1)
425 -- | as 'throwErrnoIfMinus1', but discards the result.
427 throwErrnoIfMinus1Retry_ :: Num a => String -> IO a -> IO ()
428 throwErrnoIfMinus1Retry_ = throwErrnoIfRetry_ (== -1)
430 -- | as 'throwErrnoIfMinus1Retry', but checks for operations that would block.
432 throwErrnoIfMinus1RetryMayBlock :: Num a => String -> IO a -> IO b -> IO a
433 throwErrnoIfMinus1RetryMayBlock = throwErrnoIfRetryMayBlock (== -1)
435 -- | as 'throwErrnoIfMinus1RetryMayBlock', but discards the result.
437 throwErrnoIfMinus1RetryMayBlock_ :: Num a => String -> IO a -> IO b -> IO ()
438 throwErrnoIfMinus1RetryMayBlock_ = throwErrnoIfRetryMayBlock_ (== -1)
440 -- | Throw an 'IOError' corresponding to the current value of 'getErrno'
441 -- if the 'IO' action returns 'nullPtr'.
443 throwErrnoIfNull :: String -> IO (Ptr a) -> IO (Ptr a)
444 throwErrnoIfNull = throwErrnoIf (== nullPtr)
446 -- | Throw an 'IOError' corresponding to the current value of 'getErrno'
447 -- if the 'IO' action returns 'nullPtr',
448 -- but retry in case of an interrupted operation.
450 throwErrnoIfNullRetry :: String -> IO (Ptr a) -> IO (Ptr a)
451 throwErrnoIfNullRetry = throwErrnoIfRetry (== nullPtr)
453 -- | as 'throwErrnoIfNullRetry', but checks for operations that would block.
455 throwErrnoIfNullRetryMayBlock :: String -> IO (Ptr a) -> IO b -> IO (Ptr a)
456 throwErrnoIfNullRetryMayBlock = throwErrnoIfRetryMayBlock (== nullPtr)
458 -- | as 'throwErrno', but exceptions include the given path when appropriate.
460 throwErrnoPath :: String -> FilePath -> IO a
461 throwErrnoPath loc path =
464 ioError (errnoToIOError loc errno Nothing (Just path))
466 -- | as 'throwErrnoIf', but exceptions include the given path when
469 throwErrnoPathIf :: (a -> Bool) -> String -> FilePath -> IO a -> IO a
470 throwErrnoPathIf pred loc path f =
473 if pred res then throwErrnoPath loc path else return res
475 -- | as 'throwErrnoIf_', but exceptions include the given path when
478 throwErrnoPathIf_ :: (a -> Bool) -> String -> FilePath -> IO a -> IO ()
479 throwErrnoPathIf_ pred loc path f = void $ throwErrnoPathIf pred loc path f
481 -- | as 'throwErrnoIfNull', but exceptions include the given path when
484 throwErrnoPathIfNull :: String -> FilePath -> IO (Ptr a) -> IO (Ptr a)
485 throwErrnoPathIfNull = throwErrnoPathIf (== nullPtr)
487 -- | as 'throwErrnoIfMinus1', but exceptions include the given path when
490 throwErrnoPathIfMinus1 :: Num a => String -> FilePath -> IO a -> IO a
491 throwErrnoPathIfMinus1 = throwErrnoPathIf (== -1)
493 -- | as 'throwErrnoIfMinus1_', but exceptions include the given path when
496 throwErrnoPathIfMinus1_ :: Num a => String -> FilePath -> IO a -> IO ()
497 throwErrnoPathIfMinus1_ = throwErrnoPathIf_ (== -1)
499 -- conversion of an "errno" value into IO error
500 -- --------------------------------------------
502 -- | Construct a Haskell 98 I\/O error based on the given 'Errno' value.
503 -- The optional information can be used to improve the accuracy of
506 errnoToIOError :: String -- ^ the location where the error occurred
507 -> Errno -- ^ the error number
508 -> Maybe Handle -- ^ optional handle associated with the error
509 -> Maybe String -- ^ optional filename associated with the error
511 errnoToIOError loc errno maybeHdl maybeName = unsafePerformIO $ do
512 str <- strerror errno >>= peekCString
513 #if __GLASGOW_HASKELL__
514 return (IOError maybeHdl errType loc str maybeName)
517 | errno == eOK = OtherError
518 | errno == e2BIG = ResourceExhausted
519 | errno == eACCES = PermissionDenied
520 | errno == eADDRINUSE = ResourceBusy
521 | errno == eADDRNOTAVAIL = UnsupportedOperation
522 | errno == eADV = OtherError
523 | errno == eAFNOSUPPORT = UnsupportedOperation
524 | errno == eAGAIN = ResourceExhausted
525 | errno == eALREADY = AlreadyExists
526 | errno == eBADF = InvalidArgument
527 | errno == eBADMSG = InappropriateType
528 | errno == eBADRPC = OtherError
529 | errno == eBUSY = ResourceBusy
530 | errno == eCHILD = NoSuchThing
531 | errno == eCOMM = ResourceVanished
532 | errno == eCONNABORTED = OtherError
533 | errno == eCONNREFUSED = NoSuchThing
534 | errno == eCONNRESET = ResourceVanished
535 | errno == eDEADLK = ResourceBusy
536 | errno == eDESTADDRREQ = InvalidArgument
537 | errno == eDIRTY = UnsatisfiedConstraints
538 | errno == eDOM = InvalidArgument
539 | errno == eDQUOT = PermissionDenied
540 | errno == eEXIST = AlreadyExists
541 | errno == eFAULT = OtherError
542 | errno == eFBIG = PermissionDenied
543 | errno == eFTYPE = InappropriateType
544 | errno == eHOSTDOWN = NoSuchThing
545 | errno == eHOSTUNREACH = NoSuchThing
546 | errno == eIDRM = ResourceVanished
547 | errno == eILSEQ = InvalidArgument
548 | errno == eINPROGRESS = AlreadyExists
549 | errno == eINTR = Interrupted
550 | errno == eINVAL = InvalidArgument
551 | errno == eIO = HardwareFault
552 | errno == eISCONN = AlreadyExists
553 | errno == eISDIR = InappropriateType
554 | errno == eLOOP = InvalidArgument
555 | errno == eMFILE = ResourceExhausted
556 | errno == eMLINK = ResourceExhausted
557 | errno == eMSGSIZE = ResourceExhausted
558 | errno == eMULTIHOP = UnsupportedOperation
559 | errno == eNAMETOOLONG = InvalidArgument
560 | errno == eNETDOWN = ResourceVanished
561 | errno == eNETRESET = ResourceVanished
562 | errno == eNETUNREACH = NoSuchThing
563 | errno == eNFILE = ResourceExhausted
564 | errno == eNOBUFS = ResourceExhausted
565 | errno == eNODATA = NoSuchThing
566 | errno == eNODEV = UnsupportedOperation
567 | errno == eNOENT = NoSuchThing
568 | errno == eNOEXEC = InvalidArgument
569 | errno == eNOLCK = ResourceExhausted
570 | errno == eNOLINK = ResourceVanished
571 | errno == eNOMEM = ResourceExhausted
572 | errno == eNOMSG = NoSuchThing
573 | errno == eNONET = NoSuchThing
574 | errno == eNOPROTOOPT = UnsupportedOperation
575 | errno == eNOSPC = ResourceExhausted
576 | errno == eNOSR = ResourceExhausted
577 | errno == eNOSTR = InvalidArgument
578 | errno == eNOSYS = UnsupportedOperation
579 | errno == eNOTBLK = InvalidArgument
580 | errno == eNOTCONN = InvalidArgument
581 | errno == eNOTDIR = InappropriateType
582 | errno == eNOTEMPTY = UnsatisfiedConstraints
583 | errno == eNOTSOCK = InvalidArgument
584 | errno == eNOTTY = IllegalOperation
585 | errno == eNXIO = NoSuchThing
586 | errno == eOPNOTSUPP = UnsupportedOperation
587 | errno == ePERM = PermissionDenied
588 | errno == ePFNOSUPPORT = UnsupportedOperation
589 | errno == ePIPE = ResourceVanished
590 | errno == ePROCLIM = PermissionDenied
591 | errno == ePROCUNAVAIL = UnsupportedOperation
592 | errno == ePROGMISMATCH = ProtocolError
593 | errno == ePROGUNAVAIL = UnsupportedOperation
594 | errno == ePROTO = ProtocolError
595 | errno == ePROTONOSUPPORT = ProtocolError
596 | errno == ePROTOTYPE = ProtocolError
597 | errno == eRANGE = UnsupportedOperation
598 | errno == eREMCHG = ResourceVanished
599 | errno == eREMOTE = IllegalOperation
600 | errno == eROFS = PermissionDenied
601 | errno == eRPCMISMATCH = ProtocolError
602 | errno == eRREMOTE = IllegalOperation
603 | errno == eSHUTDOWN = IllegalOperation
604 | errno == eSOCKTNOSUPPORT = UnsupportedOperation
605 | errno == eSPIPE = UnsupportedOperation
606 | errno == eSRCH = NoSuchThing
607 | errno == eSRMNT = UnsatisfiedConstraints
608 | errno == eSTALE = ResourceVanished
609 | errno == eTIME = TimeExpired
610 | errno == eTIMEDOUT = TimeExpired
611 | errno == eTOOMANYREFS = ResourceExhausted
612 | errno == eTXTBSY = ResourceBusy
613 | errno == eUSERS = ResourceExhausted
614 | errno == eWOULDBLOCK = OtherError
615 | errno == eXDEV = UnsupportedOperation
616 | otherwise = OtherError
618 return (userError (loc ++ ": " ++ str ++ maybe "" (": "++) maybeName))
621 foreign import ccall unsafe "string.h" strerror :: Errno -> IO (Ptr CChar)