diff options
Diffstat (limited to 'ghc/lib/cbits/errno.lc')
| -rw-r--r-- | ghc/lib/cbits/errno.lc | 925 |
1 files changed, 925 insertions, 0 deletions
diff --git a/ghc/lib/cbits/errno.lc b/ghc/lib/cbits/errno.lc new file mode 100644 index 0000000000..24ea25d088 --- /dev/null +++ b/ghc/lib/cbits/errno.lc @@ -0,0 +1,925 @@ +% +% (c) The GRASP/AQUA Project, Glasgow University, 1994 +% +\subsection[errno.lc]{GHC Error Number Conversion} + +\begin{code} + +#include "rtsdefs.h" +#include "stgio.h" + +int ghc_errno = 0; +int ghc_errtype = 0; + +char *ghc_errstr = NULL; + +/* Collect all of the grotty #ifdef's in one place. */ + +void cvtErrno(STG_NO_ARGS) +{ + switch(errno) { +#ifdef E2BIG + case E2BIG: + ghc_errno = GHC_E2BIG; + break; +#endif +#ifdef EACCES + case EACCES: + ghc_errno = GHC_EACCES; + break; +#endif +#ifdef EADDRINUSE + case EADDRINUSE: + ghc_errno = GHC_EADDRINUSE; + break; +#endif +#ifdef EADDRNOTAVAIL + case EADDRNOTAVAIL: + ghc_errno = GHC_EADDRNOTAVAIL; + break; +#endif +#ifdef EADV + case EADV: + ghc_errno = GHC_EADV; + break; +#endif +#ifdef EAFNOSUPPORT + case EAFNOSUPPORT: + ghc_errno = GHC_EAFNOSUPPORT; + break; +#endif +#ifdef EAGAIN + case EAGAIN: + ghc_errno = GHC_EAGAIN; + break; +#endif +#ifdef EALREADY + case EALREADY: + ghc_errno = GHC_EALREADY; + break; +#endif +#ifdef EBADF + case EBADF: + ghc_errno = GHC_EBADF; + break; +#endif +#ifdef EBADMSG + case EBADMSG: + ghc_errno = GHC_EBADMSG; + break; +#endif +#ifdef EBADRPC + case EBADRPC: + ghc_errno = GHC_EBADRPC; + break; +#endif +#ifdef EBUSY + case EBUSY: + ghc_errno = GHC_EBUSY; + break; +#endif +#ifdef ECHILD + case ECHILD: + ghc_errno = GHC_ECHILD; + break; +#endif +#ifdef ECOMM + case ECOMM: + ghc_errno = GHC_ECOMM; + break; +#endif +#ifdef ECONNABORTED + case ECONNABORTED: + ghc_errno = GHC_ECONNABORTED; + break; +#endif +#ifdef ECONNREFUSED + case ECONNREFUSED: + ghc_errno = GHC_ECONNREFUSED; + break; +#endif +#ifdef ECONNRESET + case ECONNRESET: + ghc_errno = GHC_ECONNRESET; + break; +#endif +#ifdef EDEADLK + case EDEADLK: + ghc_errno = GHC_EDEADLK; + break; +#endif +#ifdef EDESTADDRREQ + case EDESTADDRREQ: + ghc_errno = GHC_EDESTADDRREQ; + break; +#endif +#ifdef EDIRTY + case EDIRTY: + ghc_errno = GHC_EDIRTY; + break; +#endif +#ifdef EDOM + case EDOM: + ghc_errno = GHC_EDOM; + break; +#endif +#ifdef EDQUOT + case EDQUOT: + ghc_errno = GHC_EDQUOT; + break; +#endif +#ifdef EEXIST + case EEXIST: + ghc_errno = GHC_EEXIST; + break; +#endif +#ifdef EFAULT + case EFAULT: + ghc_errno = GHC_EFAULT; + break; +#endif +#ifdef EFBIG + case EFBIG: + ghc_errno = GHC_EFBIG; + break; +#endif +#ifdef EFTYPE + case EFTYPE: + ghc_errno = GHC_EFTYPE; + break; +#endif +#ifdef EHOSTDOWN + case EHOSTDOWN: + ghc_errno = GHC_EHOSTDOWN; + break; +#endif +#ifdef EHOSTUNREACH + case EHOSTUNREACH: + ghc_errno = GHC_EHOSTUNREACH; + break; +#endif +#ifdef EIDRM + case EIDRM: + ghc_errno = GHC_EIDRM; + break; +#endif +#ifdef EILSEQ + case EILSEQ: + ghc_errno = GHC_EILSEQ; + break; +#endif +#ifdef EINPROGRESS + case EINPROGRESS: + ghc_errno = GHC_EINPROGRESS; + break; +#endif +#ifdef EINTR + case EINTR: + ghc_errno = GHC_EINTR; + break; +#endif +#ifdef EINVAL + case EINVAL: + ghc_errno = GHC_EINVAL; + break; +#endif +#ifdef EIO + case EIO: + ghc_errno = GHC_EIO; + break; +#endif +#ifdef EISCONN + case EISCONN: + ghc_errno = GHC_EISCONN; + break; +#endif +#ifdef EISDIR + case EISDIR: + ghc_errno = GHC_EISDIR; + break; +#endif +#ifdef ELOOP + case ELOOP: + ghc_errno = GHC_ELOOP; + break; +#endif +#ifdef EMFILE + case EMFILE: + ghc_errno = GHC_EMFILE; + break; +#endif +#ifdef EMLINK + case EMLINK: + ghc_errno = GHC_EMLINK; + break; +#endif +#ifdef EMSGSIZE + case EMSGSIZE: + ghc_errno = GHC_EMSGSIZE; + break; +#endif +#ifdef EMULTIHOP + case EMULTIHOP: + ghc_errno = GHC_EMULTIHOP; + break; +#endif +#ifdef ENAMETOOLONG + case ENAMETOOLONG: + ghc_errno = GHC_ENAMETOOLONG; + break; +#endif +#ifdef ENETDOWN + case ENETDOWN: + ghc_errno = GHC_ENETDOWN; + break; +#endif +#ifdef ENETRESET + case ENETRESET: + ghc_errno = GHC_ENETRESET; + break; +#endif +#ifdef ENETUNREACH + case ENETUNREACH: + ghc_errno = GHC_ENETUNREACH; + break; +#endif +#ifdef ENFILE + case ENFILE: + ghc_errno = GHC_ENFILE; + break; +#endif +#ifdef ENOBUFS + case ENOBUFS: + ghc_errno = GHC_ENOBUFS; + break; +#endif +#ifdef ENODATA + case ENODATA: + ghc_errno = GHC_ENODATA; + break; +#endif +#ifdef ENODEV + case ENODEV: + ghc_errno = GHC_ENODEV; + break; +#endif +#ifdef ENOENT + case ENOENT: + ghc_errno = GHC_ENOENT; + break; +#endif +#ifdef ENOEXEC + case ENOEXEC: + ghc_errno = GHC_ENOEXEC; + break; +#endif +#ifdef ENOLCK + case ENOLCK: + ghc_errno = GHC_ENOLCK; + break; +#endif +#ifdef ENOLINK + case ENOLINK: + ghc_errno = GHC_ENOLINK; + break; +#endif +#ifdef ENOMEM + case ENOMEM: + ghc_errno = GHC_ENOMEM; + break; +#endif +#ifdef ENOMSG + case ENOMSG: + ghc_errno = GHC_ENOMSG; + break; +#endif +#ifdef ENONET + case ENONET: + ghc_errno = GHC_ENONET; + break; +#endif +#ifdef ENOPROTOOPT + case ENOPROTOOPT: + ghc_errno = GHC_ENOPROTOOPT; + break; +#endif +#ifdef ENOSPC + case ENOSPC: + ghc_errno = GHC_ENOSPC; + break; +#endif +#ifdef ENOSR + case ENOSR: + ghc_errno = GHC_ENOSR; + break; +#endif +#ifdef ENOSTR + case ENOSTR: + ghc_errno = GHC_ENOSTR; + break; +#endif +#ifdef ENOSYS + case ENOSYS: + ghc_errno = GHC_ENOSYS; + break; +#endif +#ifdef ENOTBLK + case ENOTBLK: + ghc_errno = GHC_ENOTBLK; + break; +#endif +#ifdef ENOTCONN + case ENOTCONN: + ghc_errno = GHC_ENOTCONN; + break; +#endif +#ifdef ENOTDIR + case ENOTDIR: + ghc_errno = GHC_ENOTDIR; + break; +#endif +#ifdef ENOTEMPTY + case ENOTEMPTY: + ghc_errno = GHC_ENOTEMPTY; + break; +#endif +#ifdef ENOTSOCK + case ENOTSOCK: + ghc_errno = GHC_ENOTSOCK; + break; +#endif +#ifdef ENOTTY + case ENOTTY: + ghc_errno = GHC_ENOTTY; + break; +#endif +#ifdef ENXIO + case ENXIO: + ghc_errno = GHC_ENXIO; + break; +#endif +#ifdef EOPNOTSUPP + case EOPNOTSUPP: + ghc_errno = GHC_EOPNOTSUPP; + break; +#endif +#ifdef EPERM + case EPERM: + ghc_errno = GHC_EPERM; + break; +#endif +#ifdef EPFNOSUPPORT + case EPFNOSUPPORT: + ghc_errno = GHC_EPFNOSUPPORT; + break; +#endif +#ifdef EPIPE + case EPIPE: + ghc_errno = GHC_EPIPE; + break; +#endif +#ifdef EPROCLIM + case EPROCLIM: + ghc_errno = GHC_EPROCLIM; + break; +#endif +#ifdef EPROCUNAVAIL + case EPROCUNAVAIL: + ghc_errno = GHC_EPROCUNAVAIL; + break; +#endif +#ifdef EPROGMISMATCH + case EPROGMISMATCH: + ghc_errno = GHC_EPROGMISMATCH; + break; +#endif +#ifdef EPROGUNAVAIL + case EPROGUNAVAIL: + ghc_errno = GHC_EPROGUNAVAIL; + break; +#endif +#ifdef EPROTO + case EPROTO: + ghc_errno = GHC_EPROTO; + break; +#endif +#ifdef EPROTONOSUPPORT + case EPROTONOSUPPORT: + ghc_errno = GHC_EPROTONOSUPPORT; + break; +#endif +#ifdef EPROTOTYPE + case EPROTOTYPE: + ghc_errno = GHC_EPROTOTYPE; + break; +#endif +#ifdef ERANGE + case ERANGE: + ghc_errno = GHC_ERANGE; + break; +#endif +#ifdef EREMCHG + case EREMCHG: + ghc_errno = GHC_EREMCHG; + break; +#endif +#ifdef EREMOTE + case EREMOTE: + ghc_errno = GHC_EREMOTE; + break; +#endif +#ifdef EROFS + case EROFS: + ghc_errno = GHC_EROFS; + break; +#endif +#ifdef ERPCMISMATCH + case ERPCMISMATCH: + ghc_errno = GHC_ERPCMISMATCH; + break; +#endif +#ifdef ERREMOTE + case ERREMOTE: + ghc_errno = GHC_ERREMOTE; + break; +#endif +#ifdef ESHUTDOWN + case ESHUTDOWN: + ghc_errno = GHC_ESHUTDOWN; + break; +#endif +#ifdef ESOCKTNOSUPPORT + case ESOCKTNOSUPPORT: + ghc_errno = GHC_ESOCKTNOSUPPORT; + break; +#endif +#ifdef ESPIPE + case ESPIPE: + ghc_errno = GHC_ESPIPE; + break; +#endif +#ifdef ESRCH + case ESRCH: + ghc_errno = GHC_ESRCH; + break; +#endif +#ifdef ESRMNT + case ESRMNT: + ghc_errno = GHC_ESRMNT; + break; +#endif +#ifdef ESTALE + case ESTALE: + ghc_errno = GHC_ESTALE; + break; +#endif +#ifdef ETIME + case ETIME: + ghc_errno = GHC_ETIME; + break; +#endif +#ifdef ETIMEDOUT + case ETIMEDOUT: + ghc_errno = GHC_ETIMEDOUT; + break; +#endif +#ifdef ETOOMANYREFS + case ETOOMANYREFS: + ghc_errno = GHC_ETOOMANYREFS; + break; +#endif +#ifdef ETXTBSY + case ETXTBSY: + ghc_errno = GHC_ETXTBSY; + break; +#endif +#ifdef EUSERS + case EUSERS: + ghc_errno = GHC_EUSERS; + break; +#endif +#if 0 +#ifdef EWOULDBLOCK + case EWOULDBLOCK: + ghc_errno = GHC_EWOULDBLOCK; + break; +#endif +#endif +#ifdef EXDEV + case EXDEV: + ghc_errno = GHC_EXDEV; + break; +#endif + default: + ghc_errno = errno; + break; + } +} + +void +stdErrno(STG_NO_ARGS) +{ + switch(ghc_errno) { + default: + ghc_errtype = ERR_OTHERERROR; + ghc_errstr = "unexpected error"; + break; + case 0: + ghc_errtype = ERR_OTHERERROR; + ghc_errstr = "no error"; + case GHC_E2BIG: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "argument list too long"; + break; + case GHC_EACCES: + ghc_errtype = ERR_PERMISSIONDENIED; + ghc_errstr = "inadequate access permission"; + break; + case GHC_EADDRINUSE: + ghc_errtype = ERR_RESOURCEBUSY; + ghc_errstr = "address already in use"; + break; + case GHC_EADDRNOTAVAIL: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "address not available"; + break; + case GHC_EADV: + ghc_errtype = ERR_OTHERERROR; + ghc_errstr = "RFS advertise error"; + break; + case GHC_EAFNOSUPPORT: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "address family not supported by protocol family"; + break; + case GHC_EAGAIN: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "insufficient resources"; + break; + case GHC_EALREADY: + ghc_errtype = ERR_ALREADYEXISTS; + ghc_errstr = "operation already in progress"; + break; + case GHC_EBADF: + ghc_errtype = ERR_OTHERERROR; + ghc_errstr = "internal error (EBADF)"; + break; + case GHC_EBADMSG: + ghc_errtype = ERR_INAPPROPRIATETYPE; + ghc_errstr = "next message has wrong type"; + break; + case GHC_EBADRPC: + ghc_errtype = ERR_OTHERERROR; + ghc_errstr = "invalid RPC request or response"; + break; + case GHC_EBUSY: + ghc_errtype = ERR_RESOURCEBUSY; + ghc_errstr = "device busy"; + break; + case GHC_ECHILD: + ghc_errtype = ERR_NOSUCHTHING; + ghc_errstr = "no child processes"; + break; + case GHC_ECOMM: + ghc_errtype = ERR_RESOURCEVANISHED; + ghc_errstr = "no virtual circuit could be found"; + break; + case GHC_ECONNABORTED: + ghc_errtype = ERR_OTHERERROR; + ghc_errstr = "aborted connection"; + break; + case GHC_ECONNREFUSED: + ghc_errtype = ERR_NOSUCHTHING; + ghc_errstr = "no listener on remote host"; + break; + case GHC_ECONNRESET: + ghc_errtype = ERR_RESOURCEVANISHED; + ghc_errstr = "connection reset by peer"; + break; + case GHC_EDEADLK: + ghc_errtype = ERR_RESOURCEBUSY; + ghc_errstr = "resource deadlock avoided"; + break; + case GHC_EDESTADDRREQ: + ghc_errtype = ERR_INVALIDARGUMENT; + ghc_errstr = "destination address required"; + break; + case GHC_EDIRTY: + ghc_errtype = ERR_UNSATISFIEDCONSTRAINTS; + ghc_errstr = "file system dirty"; + break; + case GHC_EDOM: + ghc_errtype = ERR_INVALIDARGUMENT; + ghc_errstr = "argument too large"; + break; + case GHC_EDQUOT: + ghc_errtype = ERR_PERMISSIONDENIED; + ghc_errstr = "quota exceeded"; + break; + case GHC_EEXIST: + ghc_errtype = ERR_ALREADYEXISTS; + ghc_errstr = "file already exists"; + break; + case GHC_EFAULT: + ghc_errtype = ERR_OTHERERROR; + ghc_errstr = "internal error (EFAULT)"; + break; + case GHC_EFBIG: + ghc_errtype = ERR_PERMISSIONDENIED; + ghc_errstr = "file too large"; + break; + case GHC_EFTYPE: + ghc_errtype = ERR_INAPPROPRIATETYPE; + ghc_errstr = "inappropriate NFS file type or format"; + break; + case GHC_EHOSTDOWN: + ghc_errtype = ERR_NOSUCHTHING; + ghc_errstr = "destination host down"; + break; + case GHC_EHOSTUNREACH: + ghc_errtype = ERR_NOSUCHTHING; + ghc_errstr = "remote host is unreachable"; + break; + case GHC_EIDRM: + ghc_errtype = ERR_RESOURCEVANISHED; + ghc_errstr = "IPC identifier removed"; + break; + case GHC_EILSEQ: + ghc_errtype = ERR_INVALIDARGUMENT; + ghc_errstr = "invalid wide character"; + break; + case GHC_EINPROGRESS: + ghc_errtype = ERR_ALREADYEXISTS; + ghc_errstr = "operation now in progress"; + break; + case GHC_EINTR: + ghc_errtype = ERR_INTERRUPTED; + ghc_errstr = "interrupted system call"; + break; + case GHC_EINVAL: + ghc_errtype = ERR_INVALIDARGUMENT; + ghc_errstr = "invalid argument"; + break; + case GHC_EIO: + ghc_errtype = ERR_HARDWAREFAULT; + ghc_errstr = "unknown I/O fault"; + break; + case GHC_EISCONN: + ghc_errtype = ERR_ALREADYEXISTS; + ghc_errstr = "socket is already connected"; + break; + case GHC_EISDIR: + ghc_errtype = ERR_INAPPROPRIATETYPE; + ghc_errstr = "file is a directory"; + break; + case GHC_ELOOP: + ghc_errtype = ERR_INVALIDARGUMENT; + ghc_errstr = "too many symbolic links"; + break; + case GHC_EMFILE: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "process file table full"; + break; + case GHC_EMLINK: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "too many links"; + break; + case GHC_EMSGSIZE: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "message too long"; + break; + case GHC_EMULTIHOP: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "multi-hop RFS request"; + break; + case GHC_ENAMETOOLONG: + ghc_errtype = ERR_INVALIDARGUMENT; + ghc_errstr = "filename too long"; + break; + case GHC_ENETDOWN: + ghc_errtype = ERR_RESOURCEVANISHED; + ghc_errstr = "network is down"; + break; + case GHC_ENETRESET: + ghc_errtype = ERR_RESOURCEVANISHED; + ghc_errstr = "remote host rebooted; connection lost"; + break; + case GHC_ENETUNREACH: + ghc_errtype = ERR_NOSUCHTHING; + ghc_errstr = "remote network is unreachable"; + break; + case GHC_ENFILE: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "system file table full"; + break; + case GHC_ENOBUFS: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "no buffer space available"; + break; + case GHC_ENODATA: + ghc_errtype = ERR_NOSUCHTHING; + ghc_errstr = "no message on the stream head read queue"; + break; + case GHC_ENODEV: + ghc_errtype = ERR_NOSUCHTHING; + ghc_errstr = "no such device"; + break; + case GHC_ENOENT: + ghc_errtype = ERR_NOSUCHTHING; + ghc_errstr = "no such file or directory"; + break; + case GHC_ENOEXEC: + ghc_errtype = ERR_INVALIDARGUMENT; + ghc_errstr = "not an executable file"; + break; + case GHC_ENOLCK: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "no file locks available"; + break; + case GHC_ENOLINK: + ghc_errtype = ERR_RESOURCEVANISHED; + ghc_errstr = "RFS link has been severed"; + break; + case GHC_ENOMEM: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "not enough virtual memory"; + break; + case GHC_ENOMSG: + ghc_errtype = ERR_NOSUCHTHING; + ghc_errstr = "no message of desired type"; + break; + case GHC_ENONET: + ghc_errtype = ERR_NOSUCHTHING; + ghc_errstr = "host is not on a network"; + break; + case GHC_ENOPROTOOPT: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "operation not supported by protocol"; + break; + case GHC_ENOSPC: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "no space left on device"; + break; + case GHC_ENOSR: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "out of stream resources"; + break; + case GHC_ENOSTR: + ghc_errtype = ERR_INVALIDARGUMENT; + ghc_errstr = "not a stream device"; + break; + case GHC_ENOSYS: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "function not implemented"; + break; + case GHC_ENOTBLK: + ghc_errtype = ERR_INVALIDARGUMENT; + ghc_errstr = "not a block device"; + break; + case GHC_ENOTCONN: + ghc_errtype = ERR_INVALIDARGUMENT; + ghc_errstr = "socket is not connected"; + break; + case GHC_ENOTDIR: + ghc_errtype = ERR_INAPPROPRIATETYPE; + ghc_errstr = "not a directory"; + break; + case GHC_ENOTEMPTY: + ghc_errtype = ERR_UNSATISFIEDCONSTRAINTS; + ghc_errstr = "directory not empty"; + break; + case GHC_ENOTSOCK: + ghc_errtype = ERR_INVALIDARGUMENT; + ghc_errstr = "not a socket"; + break; + case GHC_ENOTTY: + ghc_errtype = ERR_ILLEGALOPERATION; + ghc_errstr = "inappropriate ioctl for device"; + break; + case GHC_ENXIO: + ghc_errtype = ERR_NOSUCHTHING; + ghc_errstr = "no such device or address"; + break; + case GHC_EOPNOTSUPP: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "operation not supported on socket"; + break; + case GHC_EPERM: + ghc_errtype = ERR_PERMISSIONDENIED; + ghc_errstr = "privileged operation"; + break; + case GHC_EPFNOSUPPORT: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "protocol family not supported"; + break; + case GHC_EPIPE: + ghc_errtype = ERR_RESOURCEVANISHED; + ghc_errstr = "broken pipe"; + break; + case GHC_EPROCLIM: + ghc_errtype = ERR_PERMISSIONDENIED; + ghc_errstr = "too many processes"; + break; + case GHC_EPROCUNAVAIL: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "unimplemented RPC procedure"; + break; + case GHC_EPROGMISMATCH: + ghc_errtype = ERR_PROTOCOLERROR; + ghc_errstr = "unsupported RPC program version"; + break; + case GHC_EPROGUNAVAIL: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "RPC program unavailable"; + break; + case GHC_EPROTO: + ghc_errtype = ERR_PROTOCOLERROR; + ghc_errstr = "error in streams protocol"; + break; + case GHC_EPROTONOSUPPORT: + ghc_errtype = ERR_PROTOCOLERROR; + ghc_errstr = "protocol not supported"; + break; + case GHC_EPROTOTYPE: + ghc_errtype = ERR_PROTOCOLERROR; + ghc_errstr = "wrong protocol for socket"; + break; + case GHC_ERANGE: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "result too large"; + break; + case GHC_EREMCHG: + ghc_errtype = ERR_RESOURCEVANISHED; + ghc_errstr = "remote address changed"; + break; + case GHC_EREMOTE: + ghc_errtype = ERR_ILLEGALOPERATION; + ghc_errstr = "too many levels of remote in path"; + break; + case GHC_EROFS: + ghc_errtype = ERR_PERMISSIONDENIED; + ghc_errstr = "read-only file system"; + break; + case GHC_ERPCMISMATCH: + ghc_errtype = ERR_PROTOCOLERROR; + ghc_errstr = "RPC version is wrong"; + break; + case GHC_ERREMOTE: + ghc_errtype = ERR_ILLEGALOPERATION; + ghc_errstr = "object is remote"; + break; + case GHC_ESHUTDOWN: + ghc_errtype = ERR_ILLEGALOPERATION; + ghc_errstr = "can't send after socket shutdown"; + break; + case GHC_ESOCKTNOSUPPORT: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "socket type not supported"; + break; + case GHC_ESPIPE: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "can't seek on a pipe"; + break; + case GHC_ESRCH: + ghc_errtype = ERR_NOSUCHTHING; + ghc_errstr = "no such process"; + break; + case GHC_ESRMNT: + ghc_errtype = ERR_UNSATISFIEDCONSTRAINTS; + ghc_errstr = "RFS resources still mounted by remote host(s)"; + break; + case GHC_ESTALE: + ghc_errtype = ERR_RESOURCEVANISHED; + ghc_errstr = "stale NFS file handle"; + break; + case GHC_ETIME: + ghc_errtype = ERR_TIMEEXPIRED; + ghc_errstr = "timer expired"; + break; + case GHC_ETIMEDOUT: + ghc_errtype = ERR_TIMEEXPIRED; + ghc_errstr = "connection timed out"; + break; + case GHC_ETOOMANYREFS: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "too many references; can't splice"; + break; + case GHC_ETXTBSY: + ghc_errtype = ERR_RESOURCEBUSY; + ghc_errstr = "text file in-use"; + break; + case GHC_EUSERS: + ghc_errtype = ERR_RESOURCEEXHAUSTED; + ghc_errstr = "quota table full"; + break; + case GHC_EWOULDBLOCK: + ghc_errtype = ERR_OTHERERROR; + ghc_errstr = "operation would block"; + break; + case GHC_EXDEV: + ghc_errtype = ERR_UNSUPPORTEDOPERATION; + ghc_errstr = "can't make a cross-device link"; + break; + } +} + +\end{code} |