* AssemblyInfo.cs: Don't make internals visible to
[mono.git] / support / map.c
index 4cc79b31e0aa24228ed1b1e30ef9a6cf1446d9fd..0fc5255640b4655b3d5928221ed767ecb24520fa 100644 (file)
 /*
- * This file was automatically generated by make-map from ../../mcs/class/lib/default/Mono.Posix.dll.
+ * This file was automatically generated by create-native-map from ../../mcs/class/lib/net_2_0/Mono.Posix.dll.
  *
  * DO NOT MODIFY.
  */
+#ifdef HAVE_CONFIG_H
 #include <config.h>
+#endif /* ndef HAVE_CONFIG_H */
 
-#include "map.h"
+#include <stdlib.h>
+#include <string.h>
 
+/*
+ * Implementation Macros
+ */
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif /* ndef _GNU_SOURCE */
+
 #ifndef _XOPEN_SOURCE
 #define _XOPEN_SOURCE
 #endif /* ndef _XOPEN_SOURCE */
+
+
+/*
+ * Implementation Includes
+ */
 #include <sys/types.h>
 #include <sys/stat.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif /* ndef HAVE_SYS_TIME_H */
 #ifdef HAVE_SYS_POLL_H
 #include <sys/poll.h>
-#endif
+#endif /* ndef HAVE_SYS_POLL_H */
 #ifdef HAVE_SYS_WAIT_H
 #include <sys/wait.h>
-#endif
+#endif /* ndef HAVE_SYS_WAIT_H */
 #ifdef HAVE_SYS_STATVFS_H
 #include <sys/statvfs.h>
-#endif
+#endif /* ndef HAVE_SYS_STATVFS_H */
 #ifdef HAVE_SYS_XATTR_H
 #include <sys/xattr.h>
-#endif
+#endif /* ndef HAVE_SYS_XATTR_H */
+#ifdef HAVE_SYS_MMAN_H
+#include <sys/mman.h>
+#endif /* ndef HAVE_SYS_MMAN_H */
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
+#endif /* ndef HAVE_UNISTD_H */
 #include <fcntl.h>
 #include <signal.h>
 #ifdef HAVE_POLL_H
 #include <poll.h>
-#endif
+#endif /* ndef HAVE_POLL_H */
 #ifdef HAVE_GRP_H
 #include <grp.h>
-#endif
+#endif /* ndef HAVE_GRP_H */
 #include <errno.h>
 #ifdef HAVE_SYSLOG_H
 #include <syslog.h>
+#endif /* ndef HAVE_SYSLOG_H */
+#ifdef HAVE_DIRENT_H
+#include <dirent.h>
+#endif /* ndef HAVE_DIRENT_H */
+#ifdef HAVE_UTIME_H
+#include <utime.h>
+#endif /* ndef HAVE_UTIME_H */
+#include <time.h>
+#include "mph.h"
+
+#include "map.h"
+
+#include <errno.h>    /* errno, EOVERFLOW */
+#include <glib.h>     /* g* types, g_assert_not_reached() */
+
+#if defined (G_MININT8)
+#define CNM_MININT8 G_MININT8
+#else
+#define CNM_MININT8 (-128)
 #endif
 
-int Mono_Posix_FromAccessMode (int x, int *r)
-{
-       *r = 0;
-       if (x == 0)
-               return 0;
-       if ((x & Mono_Posix_AccessMode_F_OK) == Mono_Posix_AccessMode_F_OK)
-#ifdef F_OK
-               *r |= F_OK;
-#else /* def F_OK */
-               {errno = EINVAL; return -1;}
-#endif /* ndef F_OK */
-       if ((x & Mono_Posix_AccessMode_R_OK) == Mono_Posix_AccessMode_R_OK)
-#ifdef R_OK
-               *r |= R_OK;
-#else /* def R_OK */
-               {errno = EINVAL; return -1;}
-#endif /* ndef R_OK */
-       if ((x & Mono_Posix_AccessMode_W_OK) == Mono_Posix_AccessMode_W_OK)
-#ifdef W_OK
-               *r |= W_OK;
-#else /* def W_OK */
-               {errno = EINVAL; return -1;}
-#endif /* ndef W_OK */
-       if ((x & Mono_Posix_AccessMode_X_OK) == Mono_Posix_AccessMode_X_OK)
-#ifdef X_OK
-               *r |= X_OK;
-#else /* def X_OK */
-               {errno = EINVAL; return -1;}
-#endif /* ndef X_OK */
-       return 0;
-}
+#if defined (G_MAXINT8)
+#define CNM_MAXINT8 G_MAXINT8
+#else
+#define CNM_MAXINT8 (127)
+#endif
 
-int Mono_Posix_ToAccessMode (int x, int *r)
-{
-       *r = 0;
-       if (x == 0)
-               return 0;
-#ifdef F_OK
-       if ((x & F_OK) == F_OK)
-               *r |= Mono_Posix_AccessMode_F_OK;
-#endif /* ndef F_OK */
-#ifdef R_OK
-       if ((x & R_OK) == R_OK)
-               *r |= Mono_Posix_AccessMode_R_OK;
-#endif /* ndef R_OK */
-#ifdef W_OK
-       if ((x & W_OK) == W_OK)
-               *r |= Mono_Posix_AccessMode_W_OK;
-#endif /* ndef W_OK */
-#ifdef X_OK
-       if ((x & X_OK) == X_OK)
-               *r |= Mono_Posix_AccessMode_X_OK;
-#endif /* ndef X_OK */
-       return 0;
-}
+#if defined (G_MAXUINT8)
+#define CNM_MAXUINT8 G_MAXUINT8
+#else
+#define CNM_MAXUINT8 (255)
+#endif
 
-int Mono_Posix_FromError (int x, int *r)
-{
-       *r = 0;
-       if (x == 0)
-               return 0;
-       if (x == Mono_Posix_Error_E2BIG)
-#ifdef E2BIG
-               {*r = E2BIG; return 0;}
-#else /* def E2BIG */
-               {errno = EINVAL; return -1;}
-#endif /* ndef E2BIG */
-       if (x == Mono_Posix_Error_EACCES)
-#ifdef EACCES
-               {*r = EACCES; return 0;}
-#else /* def EACCES */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EACCES */
-       if (x == Mono_Posix_Error_EADDRINUSE)
-#ifdef EADDRINUSE
-               {*r = EADDRINUSE; return 0;}
-#else /* def EADDRINUSE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EADDRINUSE */
-       if (x == Mono_Posix_Error_EADDRNOTAVAIL)
-#ifdef EADDRNOTAVAIL
-               {*r = EADDRNOTAVAIL; return 0;}
-#else /* def EADDRNOTAVAIL */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EADDRNOTAVAIL */
-       if (x == Mono_Posix_Error_EADV)
-#ifdef EADV
-               {*r = EADV; return 0;}
-#else /* def EADV */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EADV */
-       if (x == Mono_Posix_Error_EAFNOSUPPORT)
-#ifdef EAFNOSUPPORT
-               {*r = EAFNOSUPPORT; return 0;}
-#else /* def EAFNOSUPPORT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EAFNOSUPPORT */
-       if (x == Mono_Posix_Error_EAGAIN)
-#ifdef EAGAIN
-               {*r = EAGAIN; return 0;}
-#else /* def EAGAIN */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EAGAIN */
-       if (x == Mono_Posix_Error_EALREADY)
-#ifdef EALREADY
-               {*r = EALREADY; return 0;}
-#else /* def EALREADY */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EALREADY */
-       if (x == Mono_Posix_Error_EBADE)
-#ifdef EBADE
-               {*r = EBADE; return 0;}
-#else /* def EBADE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EBADE */
-       if (x == Mono_Posix_Error_EBADF)
-#ifdef EBADF
-               {*r = EBADF; return 0;}
-#else /* def EBADF */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EBADF */
-       if (x == Mono_Posix_Error_EBADFD)
-#ifdef EBADFD
-               {*r = EBADFD; return 0;}
-#else /* def EBADFD */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EBADFD */
-       if (x == Mono_Posix_Error_EBADMSG)
-#ifdef EBADMSG
-               {*r = EBADMSG; return 0;}
-#else /* def EBADMSG */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EBADMSG */
-       if (x == Mono_Posix_Error_EBADR)
-#ifdef EBADR
-               {*r = EBADR; return 0;}
-#else /* def EBADR */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EBADR */
-       if (x == Mono_Posix_Error_EBADRQC)
-#ifdef EBADRQC
-               {*r = EBADRQC; return 0;}
-#else /* def EBADRQC */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EBADRQC */
-       if (x == Mono_Posix_Error_EBADSLT)
-#ifdef EBADSLT
-               {*r = EBADSLT; return 0;}
-#else /* def EBADSLT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EBADSLT */
-       if (x == Mono_Posix_Error_EBFONT)
-#ifdef EBFONT
-               {*r = EBFONT; return 0;}
-#else /* def EBFONT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EBFONT */
-       if (x == Mono_Posix_Error_EBUSY)
-#ifdef EBUSY
-               {*r = EBUSY; return 0;}
-#else /* def EBUSY */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EBUSY */
-       if (x == Mono_Posix_Error_ECHILD)
-#ifdef ECHILD
-               {*r = ECHILD; return 0;}
-#else /* def ECHILD */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ECHILD */
-       if (x == Mono_Posix_Error_ECHRNG)
-#ifdef ECHRNG
-               {*r = ECHRNG; return 0;}
-#else /* def ECHRNG */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ECHRNG */
-       if (x == Mono_Posix_Error_ECOMM)
-#ifdef ECOMM
-               {*r = ECOMM; return 0;}
-#else /* def ECOMM */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ECOMM */
-       if (x == Mono_Posix_Error_ECONNABORTED)
-#ifdef ECONNABORTED
-               {*r = ECONNABORTED; return 0;}
-#else /* def ECONNABORTED */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ECONNABORTED */
-       if (x == Mono_Posix_Error_ECONNREFUSED)
-#ifdef ECONNREFUSED
-               {*r = ECONNREFUSED; return 0;}
-#else /* def ECONNREFUSED */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ECONNREFUSED */
-       if (x == Mono_Posix_Error_ECONNRESET)
-#ifdef ECONNRESET
-               {*r = ECONNRESET; return 0;}
-#else /* def ECONNRESET */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ECONNRESET */
-       if (x == Mono_Posix_Error_EDEADLK)
-#ifdef EDEADLK
-               {*r = EDEADLK; return 0;}
-#else /* def EDEADLK */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EDEADLK */
-       if (x == Mono_Posix_Error_EDEADLOCK)
-#ifdef EDEADLOCK
-               {*r = EDEADLOCK; return 0;}
-#else /* def EDEADLOCK */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EDEADLOCK */
-       if (x == Mono_Posix_Error_EDESTADDRREQ)
-#ifdef EDESTADDRREQ
-               {*r = EDESTADDRREQ; return 0;}
-#else /* def EDESTADDRREQ */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EDESTADDRREQ */
-       if (x == Mono_Posix_Error_EDOM)
-#ifdef EDOM
-               {*r = EDOM; return 0;}
-#else /* def EDOM */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EDOM */
-       if (x == Mono_Posix_Error_EDOTDOT)
-#ifdef EDOTDOT
-               {*r = EDOTDOT; return 0;}
-#else /* def EDOTDOT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EDOTDOT */
-       if (x == Mono_Posix_Error_EDQUOT)
-#ifdef EDQUOT
-               {*r = EDQUOT; return 0;}
-#else /* def EDQUOT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EDQUOT */
-       if (x == Mono_Posix_Error_EEXIST)
-#ifdef EEXIST
-               {*r = EEXIST; return 0;}
-#else /* def EEXIST */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EEXIST */
-       if (x == Mono_Posix_Error_EFAULT)
-#ifdef EFAULT
-               {*r = EFAULT; return 0;}
-#else /* def EFAULT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EFAULT */
-       if (x == Mono_Posix_Error_EFBIG)
-#ifdef EFBIG
-               {*r = EFBIG; return 0;}
-#else /* def EFBIG */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EFBIG */
-       if (x == Mono_Posix_Error_EHOSTDOWN)
-#ifdef EHOSTDOWN
-               {*r = EHOSTDOWN; return 0;}
-#else /* def EHOSTDOWN */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EHOSTDOWN */
-       if (x == Mono_Posix_Error_EHOSTUNREACH)
-#ifdef EHOSTUNREACH
-               {*r = EHOSTUNREACH; return 0;}
-#else /* def EHOSTUNREACH */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EHOSTUNREACH */
-       if (x == Mono_Posix_Error_EIDRM)
-#ifdef EIDRM
-               {*r = EIDRM; return 0;}
-#else /* def EIDRM */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EIDRM */
-       if (x == Mono_Posix_Error_EILSEQ)
-#ifdef EILSEQ
-               {*r = EILSEQ; return 0;}
-#else /* def EILSEQ */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EILSEQ */
-       if (x == Mono_Posix_Error_EINPROGRESS)
-#ifdef EINPROGRESS
-               {*r = EINPROGRESS; return 0;}
-#else /* def EINPROGRESS */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EINPROGRESS */
-       if (x == Mono_Posix_Error_EINTR)
-#ifdef EINTR
-               {*r = EINTR; return 0;}
-#else /* def EINTR */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EINTR */
-       if (x == Mono_Posix_Error_EINVAL)
-#ifdef EINVAL
-               {*r = EINVAL; return 0;}
-#else /* def EINVAL */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EINVAL */
-       if (x == Mono_Posix_Error_EIO)
-#ifdef EIO
-               {*r = EIO; return 0;}
-#else /* def EIO */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EIO */
-       if (x == Mono_Posix_Error_EISCONN)
-#ifdef EISCONN
-               {*r = EISCONN; return 0;}
-#else /* def EISCONN */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EISCONN */
-       if (x == Mono_Posix_Error_EISDIR)
-#ifdef EISDIR
-               {*r = EISDIR; return 0;}
-#else /* def EISDIR */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EISDIR */
-       if (x == Mono_Posix_Error_EISNAM)
-#ifdef EISNAM
-               {*r = EISNAM; return 0;}
-#else /* def EISNAM */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EISNAM */
-       if (x == Mono_Posix_Error_EL2HLT)
-#ifdef EL2HLT
-               {*r = EL2HLT; return 0;}
-#else /* def EL2HLT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EL2HLT */
-       if (x == Mono_Posix_Error_EL2NSYNC)
-#ifdef EL2NSYNC
-               {*r = EL2NSYNC; return 0;}
-#else /* def EL2NSYNC */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EL2NSYNC */
-       if (x == Mono_Posix_Error_EL3HLT)
-#ifdef EL3HLT
-               {*r = EL3HLT; return 0;}
-#else /* def EL3HLT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EL3HLT */
-       if (x == Mono_Posix_Error_EL3RST)
-#ifdef EL3RST
-               {*r = EL3RST; return 0;}
-#else /* def EL3RST */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EL3RST */
-       if (x == Mono_Posix_Error_ELIBACC)
-#ifdef ELIBACC
-               {*r = ELIBACC; return 0;}
-#else /* def ELIBACC */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ELIBACC */
-       if (x == Mono_Posix_Error_ELIBBAD)
-#ifdef ELIBBAD
-               {*r = ELIBBAD; return 0;}
-#else /* def ELIBBAD */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ELIBBAD */
-       if (x == Mono_Posix_Error_ELIBEXEC)
-#ifdef ELIBEXEC
-               {*r = ELIBEXEC; return 0;}
-#else /* def ELIBEXEC */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ELIBEXEC */
-       if (x == Mono_Posix_Error_ELIBMAX)
-#ifdef ELIBMAX
-               {*r = ELIBMAX; return 0;}
-#else /* def ELIBMAX */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ELIBMAX */
-       if (x == Mono_Posix_Error_ELIBSCN)
-#ifdef ELIBSCN
-               {*r = ELIBSCN; return 0;}
-#else /* def ELIBSCN */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ELIBSCN */
-       if (x == Mono_Posix_Error_ELNRNG)
-#ifdef ELNRNG
-               {*r = ELNRNG; return 0;}
-#else /* def ELNRNG */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ELNRNG */
-       if (x == Mono_Posix_Error_ELOOP)
-#ifdef ELOOP
-               {*r = ELOOP; return 0;}
-#else /* def ELOOP */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ELOOP */
-       if (x == Mono_Posix_Error_EMEDIUMTYPE)
-#ifdef EMEDIUMTYPE
-               {*r = EMEDIUMTYPE; return 0;}
-#else /* def EMEDIUMTYPE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EMEDIUMTYPE */
-       if (x == Mono_Posix_Error_EMFILE)
-#ifdef EMFILE
-               {*r = EMFILE; return 0;}
-#else /* def EMFILE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EMFILE */
-       if (x == Mono_Posix_Error_EMLINK)
-#ifdef EMLINK
-               {*r = EMLINK; return 0;}
-#else /* def EMLINK */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EMLINK */
-       if (x == Mono_Posix_Error_EMSGSIZE)
-#ifdef EMSGSIZE
-               {*r = EMSGSIZE; return 0;}
-#else /* def EMSGSIZE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EMSGSIZE */
-       if (x == Mono_Posix_Error_EMULTIHOP)
-#ifdef EMULTIHOP
-               {*r = EMULTIHOP; return 0;}
-#else /* def EMULTIHOP */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EMULTIHOP */
-       if (x == Mono_Posix_Error_ENAMETOOLONG)
-#ifdef ENAMETOOLONG
-               {*r = ENAMETOOLONG; return 0;}
-#else /* def ENAMETOOLONG */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENAMETOOLONG */
-       if (x == Mono_Posix_Error_ENAVAIL)
-#ifdef ENAVAIL
-               {*r = ENAVAIL; return 0;}
-#else /* def ENAVAIL */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENAVAIL */
-       if (x == Mono_Posix_Error_ENETDOWN)
-#ifdef ENETDOWN
-               {*r = ENETDOWN; return 0;}
-#else /* def ENETDOWN */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENETDOWN */
-       if (x == Mono_Posix_Error_ENETRESET)
-#ifdef ENETRESET
-               {*r = ENETRESET; return 0;}
-#else /* def ENETRESET */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENETRESET */
-       if (x == Mono_Posix_Error_ENETUNREACH)
-#ifdef ENETUNREACH
-               {*r = ENETUNREACH; return 0;}
-#else /* def ENETUNREACH */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENETUNREACH */
-       if (x == Mono_Posix_Error_ENFILE)
-#ifdef ENFILE
-               {*r = ENFILE; return 0;}
-#else /* def ENFILE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENFILE */
-       if (x == Mono_Posix_Error_ENOANO)
-#ifdef ENOANO
-               {*r = ENOANO; return 0;}
-#else /* def ENOANO */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOANO */
-       if (x == Mono_Posix_Error_ENOBUFS)
-#ifdef ENOBUFS
-               {*r = ENOBUFS; return 0;}
-#else /* def ENOBUFS */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOBUFS */
-       if (x == Mono_Posix_Error_ENOCSI)
-#ifdef ENOCSI
-               {*r = ENOCSI; return 0;}
-#else /* def ENOCSI */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOCSI */
-       if (x == Mono_Posix_Error_ENODATA)
-#ifdef ENODATA
-               {*r = ENODATA; return 0;}
-#else /* def ENODATA */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENODATA */
-       if (x == Mono_Posix_Error_ENODEV)
-#ifdef ENODEV
-               {*r = ENODEV; return 0;}
-#else /* def ENODEV */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENODEV */
-       if (x == Mono_Posix_Error_ENOENT)
-#ifdef ENOENT
-               {*r = ENOENT; return 0;}
-#else /* def ENOENT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOENT */
-       if (x == Mono_Posix_Error_ENOEXEC)
-#ifdef ENOEXEC
-               {*r = ENOEXEC; return 0;}
-#else /* def ENOEXEC */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOEXEC */
-       if (x == Mono_Posix_Error_ENOLCK)
-#ifdef ENOLCK
-               {*r = ENOLCK; return 0;}
-#else /* def ENOLCK */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOLCK */
-       if (x == Mono_Posix_Error_ENOLINK)
-#ifdef ENOLINK
-               {*r = ENOLINK; return 0;}
-#else /* def ENOLINK */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOLINK */
-       if (x == Mono_Posix_Error_ENOMEDIUM)
-#ifdef ENOMEDIUM
-               {*r = ENOMEDIUM; return 0;}
-#else /* def ENOMEDIUM */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOMEDIUM */
-       if (x == Mono_Posix_Error_ENOMEM)
-#ifdef ENOMEM
-               {*r = ENOMEM; return 0;}
-#else /* def ENOMEM */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOMEM */
-       if (x == Mono_Posix_Error_ENOMSG)
-#ifdef ENOMSG
-               {*r = ENOMSG; return 0;}
-#else /* def ENOMSG */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOMSG */
-       if (x == Mono_Posix_Error_ENONET)
-#ifdef ENONET
-               {*r = ENONET; return 0;}
-#else /* def ENONET */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENONET */
-       if (x == Mono_Posix_Error_ENOPKG)
-#ifdef ENOPKG
-               {*r = ENOPKG; return 0;}
-#else /* def ENOPKG */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOPKG */
-       if (x == Mono_Posix_Error_ENOPROTOOPT)
-#ifdef ENOPROTOOPT
-               {*r = ENOPROTOOPT; return 0;}
-#else /* def ENOPROTOOPT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOPROTOOPT */
-       if (x == Mono_Posix_Error_ENOSPC)
-#ifdef ENOSPC
-               {*r = ENOSPC; return 0;}
-#else /* def ENOSPC */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOSPC */
-       if (x == Mono_Posix_Error_ENOSR)
-#ifdef ENOSR
-               {*r = ENOSR; return 0;}
-#else /* def ENOSR */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOSR */
-       if (x == Mono_Posix_Error_ENOSTR)
-#ifdef ENOSTR
-               {*r = ENOSTR; return 0;}
-#else /* def ENOSTR */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOSTR */
-       if (x == Mono_Posix_Error_ENOSYS)
-#ifdef ENOSYS
-               {*r = ENOSYS; return 0;}
-#else /* def ENOSYS */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOSYS */
-       if (x == Mono_Posix_Error_ENOTBLK)
-#ifdef ENOTBLK
-               {*r = ENOTBLK; return 0;}
-#else /* def ENOTBLK */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOTBLK */
-       if (x == Mono_Posix_Error_ENOTCONN)
-#ifdef ENOTCONN
-               {*r = ENOTCONN; return 0;}
-#else /* def ENOTCONN */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOTCONN */
-       if (x == Mono_Posix_Error_ENOTDIR)
-#ifdef ENOTDIR
-               {*r = ENOTDIR; return 0;}
-#else /* def ENOTDIR */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOTDIR */
-       if (x == Mono_Posix_Error_ENOTEMPTY)
-#ifdef ENOTEMPTY
-               {*r = ENOTEMPTY; return 0;}
-#else /* def ENOTEMPTY */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOTEMPTY */
-       if (x == Mono_Posix_Error_ENOTNAM)
-#ifdef ENOTNAM
-               {*r = ENOTNAM; return 0;}
-#else /* def ENOTNAM */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOTNAM */
-       if (x == Mono_Posix_Error_ENOTSOCK)
-#ifdef ENOTSOCK
-               {*r = ENOTSOCK; return 0;}
-#else /* def ENOTSOCK */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOTSOCK */
-       if (x == Mono_Posix_Error_ENOTTY)
-#ifdef ENOTTY
-               {*r = ENOTTY; return 0;}
-#else /* def ENOTTY */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOTTY */
-       if (x == Mono_Posix_Error_ENOTUNIQ)
-#ifdef ENOTUNIQ
-               {*r = ENOTUNIQ; return 0;}
-#else /* def ENOTUNIQ */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENOTUNIQ */
-       if (x == Mono_Posix_Error_ENXIO)
-#ifdef ENXIO
-               {*r = ENXIO; return 0;}
-#else /* def ENXIO */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ENXIO */
-       if (x == Mono_Posix_Error_EOPNOTSUPP)
-#ifdef EOPNOTSUPP
-               {*r = EOPNOTSUPP; return 0;}
-#else /* def EOPNOTSUPP */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EOPNOTSUPP */
-       if (x == Mono_Posix_Error_EOVERFLOW)
-#ifdef EOVERFLOW
-               {*r = EOVERFLOW; return 0;}
-#else /* def EOVERFLOW */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EOVERFLOW */
-       if (x == Mono_Posix_Error_EPERM)
-#ifdef EPERM
-               {*r = EPERM; return 0;}
-#else /* def EPERM */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EPERM */
-       if (x == Mono_Posix_Error_EPFNOSUPPORT)
-#ifdef EPFNOSUPPORT
-               {*r = EPFNOSUPPORT; return 0;}
-#else /* def EPFNOSUPPORT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EPFNOSUPPORT */
-       if (x == Mono_Posix_Error_EPIPE)
-#ifdef EPIPE
-               {*r = EPIPE; return 0;}
-#else /* def EPIPE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EPIPE */
-       if (x == Mono_Posix_Error_EPROTO)
-#ifdef EPROTO
-               {*r = EPROTO; return 0;}
-#else /* def EPROTO */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EPROTO */
-       if (x == Mono_Posix_Error_EPROTONOSUPPORT)
-#ifdef EPROTONOSUPPORT
-               {*r = EPROTONOSUPPORT; return 0;}
-#else /* def EPROTONOSUPPORT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EPROTONOSUPPORT */
-       if (x == Mono_Posix_Error_EPROTOTYPE)
-#ifdef EPROTOTYPE
-               {*r = EPROTOTYPE; return 0;}
-#else /* def EPROTOTYPE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EPROTOTYPE */
-       if (x == Mono_Posix_Error_ERANGE)
-#ifdef ERANGE
-               {*r = ERANGE; return 0;}
-#else /* def ERANGE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ERANGE */
-       if (x == Mono_Posix_Error_EREMCHG)
-#ifdef EREMCHG
-               {*r = EREMCHG; return 0;}
-#else /* def EREMCHG */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EREMCHG */
-       if (x == Mono_Posix_Error_EREMOTE)
-#ifdef EREMOTE
-               {*r = EREMOTE; return 0;}
-#else /* def EREMOTE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EREMOTE */
-       if (x == Mono_Posix_Error_EREMOTEIO)
-#ifdef EREMOTEIO
-               {*r = EREMOTEIO; return 0;}
-#else /* def EREMOTEIO */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EREMOTEIO */
-       if (x == Mono_Posix_Error_ERESTART)
-#ifdef ERESTART
-               {*r = ERESTART; return 0;}
-#else /* def ERESTART */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ERESTART */
-       if (x == Mono_Posix_Error_EROFS)
-#ifdef EROFS
-               {*r = EROFS; return 0;}
-#else /* def EROFS */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EROFS */
-       if (x == Mono_Posix_Error_ESHUTDOWN)
-#ifdef ESHUTDOWN
-               {*r = ESHUTDOWN; return 0;}
-#else /* def ESHUTDOWN */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ESHUTDOWN */
-       if (x == Mono_Posix_Error_ESOCKTNOSUPPORT)
-#ifdef ESOCKTNOSUPPORT
-               {*r = ESOCKTNOSUPPORT; return 0;}
-#else /* def ESOCKTNOSUPPORT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ESOCKTNOSUPPORT */
-       if (x == Mono_Posix_Error_ESPIPE)
-#ifdef ESPIPE
-               {*r = ESPIPE; return 0;}
-#else /* def ESPIPE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ESPIPE */
-       if (x == Mono_Posix_Error_ESRCH)
-#ifdef ESRCH
-               {*r = ESRCH; return 0;}
-#else /* def ESRCH */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ESRCH */
-       if (x == Mono_Posix_Error_ESRMNT)
-#ifdef ESRMNT
-               {*r = ESRMNT; return 0;}
-#else /* def ESRMNT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ESRMNT */
-       if (x == Mono_Posix_Error_ESTALE)
-#ifdef ESTALE
-               {*r = ESTALE; return 0;}
-#else /* def ESTALE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ESTALE */
-       if (x == Mono_Posix_Error_ESTRPIPE)
-#ifdef ESTRPIPE
-               {*r = ESTRPIPE; return 0;}
-#else /* def ESTRPIPE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ESTRPIPE */
-       if (x == Mono_Posix_Error_ETIME)
-#ifdef ETIME
-               {*r = ETIME; return 0;}
-#else /* def ETIME */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ETIME */
-       if (x == Mono_Posix_Error_ETIMEDOUT)
-#ifdef ETIMEDOUT
-               {*r = ETIMEDOUT; return 0;}
-#else /* def ETIMEDOUT */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ETIMEDOUT */
-       if (x == Mono_Posix_Error_ETOOMANYREFS)
-#ifdef ETOOMANYREFS
-               {*r = ETOOMANYREFS; return 0;}
-#else /* def ETOOMANYREFS */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ETOOMANYREFS */
-       if (x == Mono_Posix_Error_ETXTBSY)
-#ifdef ETXTBSY
-               {*r = ETXTBSY; return 0;}
-#else /* def ETXTBSY */
-               {errno = EINVAL; return -1;}
-#endif /* ndef ETXTBSY */
-       if (x == Mono_Posix_Error_EUCLEAN)
-#ifdef EUCLEAN
-               {*r = EUCLEAN; return 0;}
-#else /* def EUCLEAN */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EUCLEAN */
-       if (x == Mono_Posix_Error_EUNATCH)
-#ifdef EUNATCH
-               {*r = EUNATCH; return 0;}
-#else /* def EUNATCH */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EUNATCH */
-       if (x == Mono_Posix_Error_EUSERS)
-#ifdef EUSERS
-               {*r = EUSERS; return 0;}
-#else /* def EUSERS */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EUSERS */
-       if (x == Mono_Posix_Error_EWOULDBLOCK)
-#ifdef EWOULDBLOCK
-               {*r = EWOULDBLOCK; return 0;}
-#else /* def EWOULDBLOCK */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EWOULDBLOCK */
-       if (x == Mono_Posix_Error_EXDEV)
-#ifdef EXDEV
-               {*r = EXDEV; return 0;}
-#else /* def EXDEV */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EXDEV */
-       if (x == Mono_Posix_Error_EXFULL)
-#ifdef EXFULL
-               {*r = EXFULL; return 0;}
-#else /* def EXFULL */
-               {errno = EINVAL; return -1;}
-#endif /* ndef EXFULL */
-       errno = EINVAL; return -1;
-}
-
-int Mono_Posix_ToError (int x, int *r)
-{
-       *r = 0;
-       if (x == 0)
-               return 0;
-#ifdef E2BIG
-       if (x == E2BIG)
-               {*r = Mono_Posix_Error_E2BIG; return 0;}
-#endif /* ndef E2BIG */
-#ifdef EACCES
-       if (x == EACCES)
-               {*r = Mono_Posix_Error_EACCES; return 0;}
-#endif /* ndef EACCES */
-#ifdef EADDRINUSE
-       if (x == EADDRINUSE)
-               {*r = Mono_Posix_Error_EADDRINUSE; return 0;}
-#endif /* ndef EADDRINUSE */
-#ifdef EADDRNOTAVAIL
-       if (x == EADDRNOTAVAIL)
-               {*r = Mono_Posix_Error_EADDRNOTAVAIL; return 0;}
-#endif /* ndef EADDRNOTAVAIL */
-#ifdef EADV
-       if (x == EADV)
-               {*r = Mono_Posix_Error_EADV; return 0;}
-#endif /* ndef EADV */
-#ifdef EAFNOSUPPORT
-       if (x == EAFNOSUPPORT)
-               {*r = Mono_Posix_Error_EAFNOSUPPORT; return 0;}
-#endif /* ndef EAFNOSUPPORT */
-#ifdef EAGAIN
-       if (x == EAGAIN)
-               {*r = Mono_Posix_Error_EAGAIN; return 0;}
-#endif /* ndef EAGAIN */
-#ifdef EALREADY
-       if (x == EALREADY)
-               {*r = Mono_Posix_Error_EALREADY; return 0;}
-#endif /* ndef EALREADY */
-#ifdef EBADE
-       if (x == EBADE)
-               {*r = Mono_Posix_Error_EBADE; return 0;}
-#endif /* ndef EBADE */
-#ifdef EBADF
-       if (x == EBADF)
-               {*r = Mono_Posix_Error_EBADF; return 0;}
-#endif /* ndef EBADF */
-#ifdef EBADFD
-       if (x == EBADFD)
-               {*r = Mono_Posix_Error_EBADFD; return 0;}
-#endif /* ndef EBADFD */
-#ifdef EBADMSG
-       if (x == EBADMSG)
-               {*r = Mono_Posix_Error_EBADMSG; return 0;}
-#endif /* ndef EBADMSG */
-#ifdef EBADR
-       if (x == EBADR)
-               {*r = Mono_Posix_Error_EBADR; return 0;}
-#endif /* ndef EBADR */
-#ifdef EBADRQC
-       if (x == EBADRQC)
-               {*r = Mono_Posix_Error_EBADRQC; return 0;}
-#endif /* ndef EBADRQC */
-#ifdef EBADSLT
-       if (x == EBADSLT)
-               {*r = Mono_Posix_Error_EBADSLT; return 0;}
-#endif /* ndef EBADSLT */
-#ifdef EBFONT
-       if (x == EBFONT)
-               {*r = Mono_Posix_Error_EBFONT; return 0;}
-#endif /* ndef EBFONT */
-#ifdef EBUSY
-       if (x == EBUSY)
-               {*r = Mono_Posix_Error_EBUSY; return 0;}
-#endif /* ndef EBUSY */
-#ifdef ECHILD
-       if (x == ECHILD)
-               {*r = Mono_Posix_Error_ECHILD; return 0;}
-#endif /* ndef ECHILD */
-#ifdef ECHRNG
-       if (x == ECHRNG)
-               {*r = Mono_Posix_Error_ECHRNG; return 0;}
-#endif /* ndef ECHRNG */
-#ifdef ECOMM
-       if (x == ECOMM)
-               {*r = Mono_Posix_Error_ECOMM; return 0;}
-#endif /* ndef ECOMM */
-#ifdef ECONNABORTED
-       if (x == ECONNABORTED)
-               {*r = Mono_Posix_Error_ECONNABORTED; return 0;}
-#endif /* ndef ECONNABORTED */
-#ifdef ECONNREFUSED
-       if (x == ECONNREFUSED)
-               {*r = Mono_Posix_Error_ECONNREFUSED; return 0;}
-#endif /* ndef ECONNREFUSED */
-#ifdef ECONNRESET
-       if (x == ECONNRESET)
-               {*r = Mono_Posix_Error_ECONNRESET; return 0;}
-#endif /* ndef ECONNRESET */
-#ifdef EDEADLK
-       if (x == EDEADLK)
-               {*r = Mono_Posix_Error_EDEADLK; return 0;}
-#endif /* ndef EDEADLK */
-#ifdef EDEADLOCK
-       if (x == EDEADLOCK)
-               {*r = Mono_Posix_Error_EDEADLOCK; return 0;}
-#endif /* ndef EDEADLOCK */
-#ifdef EDESTADDRREQ
-       if (x == EDESTADDRREQ)
-               {*r = Mono_Posix_Error_EDESTADDRREQ; return 0;}
-#endif /* ndef EDESTADDRREQ */
-#ifdef EDOM
-       if (x == EDOM)
-               {*r = Mono_Posix_Error_EDOM; return 0;}
-#endif /* ndef EDOM */
-#ifdef EDOTDOT
-       if (x == EDOTDOT)
-               {*r = Mono_Posix_Error_EDOTDOT; return 0;}
-#endif /* ndef EDOTDOT */
-#ifdef EDQUOT
-       if (x == EDQUOT)
-               {*r = Mono_Posix_Error_EDQUOT; return 0;}
-#endif /* ndef EDQUOT */
-#ifdef EEXIST
-       if (x == EEXIST)
-               {*r = Mono_Posix_Error_EEXIST; return 0;}
-#endif /* ndef EEXIST */
-#ifdef EFAULT
-       if (x == EFAULT)
-               {*r = Mono_Posix_Error_EFAULT; return 0;}
-#endif /* ndef EFAULT */
-#ifdef EFBIG
-       if (x == EFBIG)
-               {*r = Mono_Posix_Error_EFBIG; return 0;}
-#endif /* ndef EFBIG */
-#ifdef EHOSTDOWN
-       if (x == EHOSTDOWN)
-               {*r = Mono_Posix_Error_EHOSTDOWN; return 0;}
-#endif /* ndef EHOSTDOWN */
-#ifdef EHOSTUNREACH
-       if (x == EHOSTUNREACH)
-               {*r = Mono_Posix_Error_EHOSTUNREACH; return 0;}
-#endif /* ndef EHOSTUNREACH */
-#ifdef EIDRM
-       if (x == EIDRM)
-               {*r = Mono_Posix_Error_EIDRM; return 0;}
-#endif /* ndef EIDRM */
-#ifdef EILSEQ
-       if (x == EILSEQ)
-               {*r = Mono_Posix_Error_EILSEQ; return 0;}
-#endif /* ndef EILSEQ */
-#ifdef EINPROGRESS
-       if (x == EINPROGRESS)
-               {*r = Mono_Posix_Error_EINPROGRESS; return 0;}
-#endif /* ndef EINPROGRESS */
-#ifdef EINTR
-       if (x == EINTR)
-               {*r = Mono_Posix_Error_EINTR; return 0;}
-#endif /* ndef EINTR */
-#ifdef EINVAL
-       if (x == EINVAL)
-               {*r = Mono_Posix_Error_EINVAL; return 0;}
-#endif /* ndef EINVAL */
-#ifdef EIO
-       if (x == EIO)
-               {*r = Mono_Posix_Error_EIO; return 0;}
-#endif /* ndef EIO */
-#ifdef EISCONN
-       if (x == EISCONN)
-               {*r = Mono_Posix_Error_EISCONN; return 0;}
-#endif /* ndef EISCONN */
-#ifdef EISDIR
-       if (x == EISDIR)
-               {*r = Mono_Posix_Error_EISDIR; return 0;}
-#endif /* ndef EISDIR */
-#ifdef EISNAM
-       if (x == EISNAM)
-               {*r = Mono_Posix_Error_EISNAM; return 0;}
-#endif /* ndef EISNAM */
-#ifdef EL2HLT
-       if (x == EL2HLT)
-               {*r = Mono_Posix_Error_EL2HLT; return 0;}
-#endif /* ndef EL2HLT */
-#ifdef EL2NSYNC
-       if (x == EL2NSYNC)
-               {*r = Mono_Posix_Error_EL2NSYNC; return 0;}
-#endif /* ndef EL2NSYNC */
-#ifdef EL3HLT
-       if (x == EL3HLT)
-               {*r = Mono_Posix_Error_EL3HLT; return 0;}
-#endif /* ndef EL3HLT */
-#ifdef EL3RST
-       if (x == EL3RST)
-               {*r = Mono_Posix_Error_EL3RST; return 0;}
-#endif /* ndef EL3RST */
-#ifdef ELIBACC
-       if (x == ELIBACC)
-               {*r = Mono_Posix_Error_ELIBACC; return 0;}
-#endif /* ndef ELIBACC */
-#ifdef ELIBBAD
-       if (x == ELIBBAD)
-               {*r = Mono_Posix_Error_ELIBBAD; return 0;}
-#endif /* ndef ELIBBAD */
-#ifdef ELIBEXEC
-       if (x == ELIBEXEC)
-               {*r = Mono_Posix_Error_ELIBEXEC; return 0;}
-#endif /* ndef ELIBEXEC */
-#ifdef ELIBMAX
-       if (x == ELIBMAX)
-               {*r = Mono_Posix_Error_ELIBMAX; return 0;}
-#endif /* ndef ELIBMAX */
-#ifdef ELIBSCN
-       if (x == ELIBSCN)
-               {*r = Mono_Posix_Error_ELIBSCN; return 0;}
-#endif /* ndef ELIBSCN */
-#ifdef ELNRNG
-       if (x == ELNRNG)
-               {*r = Mono_Posix_Error_ELNRNG; return 0;}
-#endif /* ndef ELNRNG */
-#ifdef ELOOP
-       if (x == ELOOP)
-               {*r = Mono_Posix_Error_ELOOP; return 0;}
-#endif /* ndef ELOOP */
-#ifdef EMEDIUMTYPE
-       if (x == EMEDIUMTYPE)
-               {*r = Mono_Posix_Error_EMEDIUMTYPE; return 0;}
-#endif /* ndef EMEDIUMTYPE */
-#ifdef EMFILE
-       if (x == EMFILE)
-               {*r = Mono_Posix_Error_EMFILE; return 0;}
-#endif /* ndef EMFILE */
-#ifdef EMLINK
-       if (x == EMLINK)
-               {*r = Mono_Posix_Error_EMLINK; return 0;}
-#endif /* ndef EMLINK */
-#ifdef EMSGSIZE
-       if (x == EMSGSIZE)
-               {*r = Mono_Posix_Error_EMSGSIZE; return 0;}
-#endif /* ndef EMSGSIZE */
-#ifdef EMULTIHOP
-       if (x == EMULTIHOP)
-               {*r = Mono_Posix_Error_EMULTIHOP; return 0;}
-#endif /* ndef EMULTIHOP */
-#ifdef ENAMETOOLONG
-       if (x == ENAMETOOLONG)
-               {*r = Mono_Posix_Error_ENAMETOOLONG; return 0;}
-#endif /* ndef ENAMETOOLONG */
-#ifdef ENAVAIL
-       if (x == ENAVAIL)
-               {*r = Mono_Posix_Error_ENAVAIL; return 0;}
-#endif /* ndef ENAVAIL */
-#ifdef ENETDOWN
-       if (x == ENETDOWN)
-               {*r = Mono_Posix_Error_ENETDOWN; return 0;}
-#endif /* ndef ENETDOWN */
-#ifdef ENETRESET
-       if (x == ENETRESET)
-               {*r = Mono_Posix_Error_ENETRESET; return 0;}
-#endif /* ndef ENETRESET */
-#ifdef ENETUNREACH
-       if (x == ENETUNREACH)
-               {*r = Mono_Posix_Error_ENETUNREACH; return 0;}
-#endif /* ndef ENETUNREACH */
-#ifdef ENFILE
-       if (x == ENFILE)
-               {*r = Mono_Posix_Error_ENFILE; return 0;}
-#endif /* ndef ENFILE */
-#ifdef ENOANO
-       if (x == ENOANO)
-               {*r = Mono_Posix_Error_ENOANO; return 0;}
-#endif /* ndef ENOANO */
-#ifdef ENOBUFS
-       if (x == ENOBUFS)
-               {*r = Mono_Posix_Error_ENOBUFS; return 0;}
-#endif /* ndef ENOBUFS */
-#ifdef ENOCSI
-       if (x == ENOCSI)
-               {*r = Mono_Posix_Error_ENOCSI; return 0;}
-#endif /* ndef ENOCSI */
-#ifdef ENODATA
-       if (x == ENODATA)
-               {*r = Mono_Posix_Error_ENODATA; return 0;}
-#endif /* ndef ENODATA */
-#ifdef ENODEV
-       if (x == ENODEV)
-               {*r = Mono_Posix_Error_ENODEV; return 0;}
-#endif /* ndef ENODEV */
-#ifdef ENOENT
-       if (x == ENOENT)
-               {*r = Mono_Posix_Error_ENOENT; return 0;}
-#endif /* ndef ENOENT */
-#ifdef ENOEXEC
-       if (x == ENOEXEC)
-               {*r = Mono_Posix_Error_ENOEXEC; return 0;}
-#endif /* ndef ENOEXEC */
-#ifdef ENOLCK
-       if (x == ENOLCK)
-               {*r = Mono_Posix_Error_ENOLCK; return 0;}
-#endif /* ndef ENOLCK */
-#ifdef ENOLINK
-       if (x == ENOLINK)
-               {*r = Mono_Posix_Error_ENOLINK; return 0;}
-#endif /* ndef ENOLINK */
-#ifdef ENOMEDIUM
-       if (x == ENOMEDIUM)
-               {*r = Mono_Posix_Error_ENOMEDIUM; return 0;}
-#endif /* ndef ENOMEDIUM */
-#ifdef ENOMEM
-       if (x == ENOMEM)
-               {*r = Mono_Posix_Error_ENOMEM; return 0;}
-#endif /* ndef ENOMEM */
-#ifdef ENOMSG
-       if (x == ENOMSG)
-               {*r = Mono_Posix_Error_ENOMSG; return 0;}
-#endif /* ndef ENOMSG */
-#ifdef ENONET
-       if (x == ENONET)
-               {*r = Mono_Posix_Error_ENONET; return 0;}
-#endif /* ndef ENONET */
-#ifdef ENOPKG
-       if (x == ENOPKG)
-               {*r = Mono_Posix_Error_ENOPKG; return 0;}
-#endif /* ndef ENOPKG */
-#ifdef ENOPROTOOPT
-       if (x == ENOPROTOOPT)
-               {*r = Mono_Posix_Error_ENOPROTOOPT; return 0;}
-#endif /* ndef ENOPROTOOPT */
-#ifdef ENOSPC
-       if (x == ENOSPC)
-               {*r = Mono_Posix_Error_ENOSPC; return 0;}
-#endif /* ndef ENOSPC */
-#ifdef ENOSR
-       if (x == ENOSR)
-               {*r = Mono_Posix_Error_ENOSR; return 0;}
-#endif /* ndef ENOSR */
-#ifdef ENOSTR
-       if (x == ENOSTR)
-               {*r = Mono_Posix_Error_ENOSTR; return 0;}
-#endif /* ndef ENOSTR */
-#ifdef ENOSYS
-       if (x == ENOSYS)
-               {*r = Mono_Posix_Error_ENOSYS; return 0;}
-#endif /* ndef ENOSYS */
-#ifdef ENOTBLK
-       if (x == ENOTBLK)
-               {*r = Mono_Posix_Error_ENOTBLK; return 0;}
-#endif /* ndef ENOTBLK */
-#ifdef ENOTCONN
-       if (x == ENOTCONN)
-               {*r = Mono_Posix_Error_ENOTCONN; return 0;}
-#endif /* ndef ENOTCONN */
-#ifdef ENOTDIR
-       if (x == ENOTDIR)
-               {*r = Mono_Posix_Error_ENOTDIR; return 0;}
-#endif /* ndef ENOTDIR */
-#ifdef ENOTEMPTY
-       if (x == ENOTEMPTY)
-               {*r = Mono_Posix_Error_ENOTEMPTY; return 0;}
-#endif /* ndef ENOTEMPTY */
-#ifdef ENOTNAM
-       if (x == ENOTNAM)
-               {*r = Mono_Posix_Error_ENOTNAM; return 0;}
-#endif /* ndef ENOTNAM */
-#ifdef ENOTSOCK
-       if (x == ENOTSOCK)
-               {*r = Mono_Posix_Error_ENOTSOCK; return 0;}
-#endif /* ndef ENOTSOCK */
-#ifdef ENOTTY
-       if (x == ENOTTY)
-               {*r = Mono_Posix_Error_ENOTTY; return 0;}
-#endif /* ndef ENOTTY */
-#ifdef ENOTUNIQ
-       if (x == ENOTUNIQ)
-               {*r = Mono_Posix_Error_ENOTUNIQ; return 0;}
-#endif /* ndef ENOTUNIQ */
-#ifdef ENXIO
-       if (x == ENXIO)
-               {*r = Mono_Posix_Error_ENXIO; return 0;}
-#endif /* ndef ENXIO */
-#ifdef EOPNOTSUPP
-       if (x == EOPNOTSUPP)
-               {*r = Mono_Posix_Error_EOPNOTSUPP; return 0;}
-#endif /* ndef EOPNOTSUPP */
-#ifdef EOVERFLOW
-       if (x == EOVERFLOW)
-               {*r = Mono_Posix_Error_EOVERFLOW; return 0;}
-#endif /* ndef EOVERFLOW */
-#ifdef EPERM
-       if (x == EPERM)
-               {*r = Mono_Posix_Error_EPERM; return 0;}
-#endif /* ndef EPERM */
-#ifdef EPFNOSUPPORT
-       if (x == EPFNOSUPPORT)
-               {*r = Mono_Posix_Error_EPFNOSUPPORT; return 0;}
-#endif /* ndef EPFNOSUPPORT */
-#ifdef EPIPE
-       if (x == EPIPE)
-               {*r = Mono_Posix_Error_EPIPE; return 0;}
-#endif /* ndef EPIPE */
-#ifdef EPROTO
-       if (x == EPROTO)
-               {*r = Mono_Posix_Error_EPROTO; return 0;}
-#endif /* ndef EPROTO */
-#ifdef EPROTONOSUPPORT
-       if (x == EPROTONOSUPPORT)
-               {*r = Mono_Posix_Error_EPROTONOSUPPORT; return 0;}
-#endif /* ndef EPROTONOSUPPORT */
-#ifdef EPROTOTYPE
-       if (x == EPROTOTYPE)
-               {*r = Mono_Posix_Error_EPROTOTYPE; return 0;}
-#endif /* ndef EPROTOTYPE */
-#ifdef ERANGE
-       if (x == ERANGE)
-               {*r = Mono_Posix_Error_ERANGE; return 0;}
-#endif /* ndef ERANGE */
-#ifdef EREMCHG
-       if (x == EREMCHG)
-               {*r = Mono_Posix_Error_EREMCHG; return 0;}
-#endif /* ndef EREMCHG */
-#ifdef EREMOTE
-       if (x == EREMOTE)
-               {*r = Mono_Posix_Error_EREMOTE; return 0;}
-#endif /* ndef EREMOTE */
-#ifdef EREMOTEIO
-       if (x == EREMOTEIO)
-               {*r = Mono_Posix_Error_EREMOTEIO; return 0;}
-#endif /* ndef EREMOTEIO */
-#ifdef ERESTART
-       if (x == ERESTART)
-               {*r = Mono_Posix_Error_ERESTART; return 0;}
-#endif /* ndef ERESTART */
-#ifdef EROFS
-       if (x == EROFS)
-               {*r = Mono_Posix_Error_EROFS; return 0;}
-#endif /* ndef EROFS */
-#ifdef ESHUTDOWN
-       if (x == ESHUTDOWN)
-               {*r = Mono_Posix_Error_ESHUTDOWN; return 0;}
-#endif /* ndef ESHUTDOWN */
-#ifdef ESOCKTNOSUPPORT
-       if (x == ESOCKTNOSUPPORT)
-               {*r = Mono_Posix_Error_ESOCKTNOSUPPORT; return 0;}
-#endif /* ndef ESOCKTNOSUPPORT */
-#ifdef ESPIPE
-       if (x == ESPIPE)
-               {*r = Mono_Posix_Error_ESPIPE; return 0;}
-#endif /* ndef ESPIPE */
-#ifdef ESRCH
-       if (x == ESRCH)
-               {*r = Mono_Posix_Error_ESRCH; return 0;}
-#endif /* ndef ESRCH */
-#ifdef ESRMNT
-       if (x == ESRMNT)
-               {*r = Mono_Posix_Error_ESRMNT; return 0;}
-#endif /* ndef ESRMNT */
-#ifdef ESTALE
-       if (x == ESTALE)
-               {*r = Mono_Posix_Error_ESTALE; return 0;}
-#endif /* ndef ESTALE */
-#ifdef ESTRPIPE
-       if (x == ESTRPIPE)
-               {*r = Mono_Posix_Error_ESTRPIPE; return 0;}
-#endif /* ndef ESTRPIPE */
-#ifdef ETIME
-       if (x == ETIME)
-               {*r = Mono_Posix_Error_ETIME; return 0;}
-#endif /* ndef ETIME */
-#ifdef ETIMEDOUT
-       if (x == ETIMEDOUT)
-               {*r = Mono_Posix_Error_ETIMEDOUT; return 0;}
-#endif /* ndef ETIMEDOUT */
-#ifdef ETOOMANYREFS
-       if (x == ETOOMANYREFS)
-               {*r = Mono_Posix_Error_ETOOMANYREFS; return 0;}
-#endif /* ndef ETOOMANYREFS */
-#ifdef ETXTBSY
-       if (x == ETXTBSY)
-               {*r = Mono_Posix_Error_ETXTBSY; return 0;}
-#endif /* ndef ETXTBSY */
-#ifdef EUCLEAN
-       if (x == EUCLEAN)
-               {*r = Mono_Posix_Error_EUCLEAN; return 0;}
-#endif /* ndef EUCLEAN */
-#ifdef EUNATCH
-       if (x == EUNATCH)
-               {*r = Mono_Posix_Error_EUNATCH; return 0;}
-#endif /* ndef EUNATCH */
-#ifdef EUSERS
-       if (x == EUSERS)
-               {*r = Mono_Posix_Error_EUSERS; return 0;}
-#endif /* ndef EUSERS */
-#ifdef EWOULDBLOCK
-       if (x == EWOULDBLOCK)
-               {*r = Mono_Posix_Error_EWOULDBLOCK; return 0;}
-#endif /* ndef EWOULDBLOCK */
-#ifdef EXDEV
-       if (x == EXDEV)
-               {*r = Mono_Posix_Error_EXDEV; return 0;}
-#endif /* ndef EXDEV */
-#ifdef EXFULL
-       if (x == EXFULL)
-               {*r = Mono_Posix_Error_EXFULL; return 0;}
-#endif /* ndef EXFULL */
-       errno = EINVAL; return -1;
-}
+#if defined (G_MININT16)
+#define CNM_MININT16 G_MININT16
+#else
+#define CNM_MININT16 (-32768)
+#endif
 
-int Mono_Posix_FromMmapProt (int x, int *r)
-{
-       *r = 0;
-       if (x == 0)
-               return 0;
-       if ((x & Mono_Posix_MmapProt_PROT_EXEC) == Mono_Posix_MmapProt_PROT_EXEC)
-#ifdef PROT_EXEC
-               *r |= PROT_EXEC;
-#else /* def PROT_EXEC */
-               {errno = EINVAL; return -1;}
-#endif /* ndef PROT_EXEC */
-       if ((x & Mono_Posix_MmapProt_PROT_GROWSDOWN) == Mono_Posix_MmapProt_PROT_GROWSDOWN)
-#ifdef PROT_GROWSDOWN
-               *r |= PROT_GROWSDOWN;
-#else /* def PROT_GROWSDOWN */
-               {errno = EINVAL; return -1;}
-#endif /* ndef PROT_GROWSDOWN */
-       if ((x & Mono_Posix_MmapProt_PROT_GROWSUP) == Mono_Posix_MmapProt_PROT_GROWSUP)
-#ifdef PROT_GROWSUP
-               *r |= PROT_GROWSUP;
-#else /* def PROT_GROWSUP */
-               {errno = EINVAL; return -1;}
-#endif /* ndef PROT_GROWSUP */
-       if ((x & Mono_Posix_MmapProt_PROT_NONE) == Mono_Posix_MmapProt_PROT_NONE)
-#ifdef PROT_NONE
-               *r |= PROT_NONE;
-#else /* def PROT_NONE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef PROT_NONE */
-       if ((x & Mono_Posix_MmapProt_PROT_READ) == Mono_Posix_MmapProt_PROT_READ)
-#ifdef PROT_READ
-               *r |= PROT_READ;
-#else /* def PROT_READ */
-               {errno = EINVAL; return -1;}
-#endif /* ndef PROT_READ */
-       if ((x & Mono_Posix_MmapProt_PROT_WRITE) == Mono_Posix_MmapProt_PROT_WRITE)
-#ifdef PROT_WRITE
-               *r |= PROT_WRITE;
-#else /* def PROT_WRITE */
-               {errno = EINVAL; return -1;}
-#endif /* ndef PROT_WRITE */
-       return 0;
-}
+#if defined (G_MAXINT16)
+#define CNM_MAXINT16 G_MAXINT16
+#else
+#define CNM_MAXINT16 (32767)
+#endif
+
+#if defined (G_MAXUINT16)
+#define CNM_MAXUINT16 G_MAXUINT16
+#else
+#define CNM_MAXUINT16 (65535)
+#endif
+
+#if defined (G_MININT32)
+#define CNM_MININT32 G_MININT32
+#else
+#define CNM_MININT32 (-2147483648)
+#endif
+
+#if defined (G_MAXINT32)
+#define CNM_MAXINT32 G_MAXINT32
+#else
+#define CNM_MAXINT32 (2147483647)
+#endif
+
+#if defined (G_MAXUINT32)
+#define CNM_MAXUINT32 G_MAXUINT32
+#else
+#define CNM_MAXUINT32 (4294967295U)
+#endif
+
+#if defined (G_MININT64)
+#define CNM_MININT64 G_MININT64
+#else
+#define CNM_MININT64 (-9223372036854775808LL)
+#endif
+
+#if defined (G_MAXINT64)
+#define CNM_MAXINT64 G_MAXINT64
+#else
+#define CNM_MAXINT64 (9223372036854775807LL)
+#endif
+
+#if defined (G_MAXUINT64)
+#define CNM_MAXUINT64 G_MAXUINT64
+#else
+#define CNM_MAXUINT64 (18446744073709551615ULL)
+#endif
+
+
+/* returns TRUE if @type is an unsigned type */
+#define _cnm_integral_type_is_unsigned(type) \
+    (sizeof(type) == sizeof(gint8)           \
+      ? (((type)-1) > CNM_MAXINT8)             \
+      : sizeof(type) == sizeof(gint16)       \
+        ? (((type)-1) > CNM_MAXINT16)          \
+        : sizeof(type) == sizeof(gint32)     \
+          ? (((type)-1) > CNM_MAXINT32)        \
+          : sizeof(type) == sizeof(gint64)   \
+            ? (((type)-1) > CNM_MAXINT64)      \
+            : (g_assert_not_reached (), 0))
+
+/* returns the minimum value of @type as a gint64 */
+#define _cnm_integral_type_min(type)          \
+    (_cnm_integral_type_is_unsigned (type)    \
+      ? 0                                     \
+      : sizeof(type) == sizeof(gint8)         \
+        ? CNM_MININT8                           \
+        : sizeof(type) == sizeof(gint16)      \
+          ? CNM_MININT16                        \
+          : sizeof(type) == sizeof(gint32)    \
+            ? CNM_MININT32                      \
+            : sizeof(type) == sizeof(gint64)  \
+              ? CNM_MININT64                    \
+              : (g_assert_not_reached (), 0))
 
-int Mono_Posix_ToMmapProt (int x, int *r)
-{
-       *r = 0;
-       if (x == 0)
-               return 0;
-#ifdef PROT_EXEC
-       if ((x & PROT_EXEC) == PROT_EXEC)
-               *r |= Mono_Posix_MmapProt_PROT_EXEC;
-#endif /* ndef PROT_EXEC */
-#ifdef PROT_GROWSDOWN
-       if ((x & PROT_GROWSDOWN) == PROT_GROWSDOWN)
-               *r |= Mono_Posix_MmapProt_PROT_GROWSDOWN;
-#endif /* ndef PROT_GROWSDOWN */
-#ifdef PROT_GROWSUP
-       if ((x & PROT_GROWSUP) == PROT_GROWSUP)
-               *r |= Mono_Posix_MmapProt_PROT_GROWSUP;
-#endif /* ndef PROT_GROWSUP */
-#ifdef PROT_NONE
-       if ((x & PROT_NONE) == PROT_NONE)
-               *r |= Mono_Posix_MmapProt_PROT_NONE;
-#endif /* ndef PROT_NONE */
-#ifdef PROT_READ
-       if ((x & PROT_READ) == PROT_READ)
-               *r |= Mono_Posix_MmapProt_PROT_READ;
-#endif /* ndef PROT_READ */
-#ifdef PROT_WRITE
-       if ((x & PROT_WRITE) == PROT_WRITE)
-               *r |= Mono_Posix_MmapProt_PROT_WRITE;
-#endif /* ndef PROT_WRITE */
-       return 0;
-}
+/* returns the maximum value of @type as a guint64 */
+#define _cnm_integral_type_max(type)            \
+    (_cnm_integral_type_is_unsigned (type)      \
+      ? sizeof(type) == sizeof(gint8)           \
+        ? CNM_MAXUINT8                            \
+        : sizeof(type) == sizeof(gint16)        \
+          ? CNM_MAXUINT16                         \
+          : sizeof(type) == sizeof(gint32)      \
+            ? CNM_MAXUINT32                       \
+            : sizeof(type) == sizeof(gint64)    \
+              ? CNM_MAXUINT64                     \
+              : (g_assert_not_reached (), 0)    \
+      : sizeof(type) == sizeof(gint8)           \
+          ? CNM_MAXINT8                           \
+          : sizeof(type) == sizeof(gint16)      \
+            ? CNM_MAXINT16                        \
+            : sizeof(type) == sizeof(gint32)    \
+              ? CNM_MAXINT32                      \
+              : sizeof(type) == sizeof(gint64)  \
+                ? CNM_MAXINT64                    \
+                : (g_assert_not_reached (), 0))
+
+#ifdef _CNM_DUMP
+#define _cnm_dump(to_t,from)                                             \
+  printf ("# %s -> %s: uns=%i; min=%llx; max=%llx; value=%llx; lt=%i; l0=%i; gt=%i; e=%i\n", \
+    #from, #to_t,                                                        \
+    (int) _cnm_integral_type_is_unsigned (to_t),                         \
+    (gint64) (_cnm_integral_type_min (to_t)),                            \
+    (gint64) (_cnm_integral_type_max (to_t)),                            \
+    (gint64) (from),                                                     \
+    (((gint64) _cnm_integral_type_min (to_t)) <= (gint64) from),         \
+    (from < 0),                                                          \
+    (((guint64) from) <= (guint64) _cnm_integral_type_max (to_t)),       \
+    !((int) _cnm_integral_type_is_unsigned (to_t)                        \
+      ? ((0 <= from) &&                                                  \
+         ((guint64) from <= (guint64) _cnm_integral_type_max (to_t)))    \
+      : ((gint64) _cnm_integral_type_min(to_t) <= (gint64) from &&       \
+         (guint64) from <= (guint64) _cnm_integral_type_max (to_t)))     \
+  )
+#else /* ndef _CNM_DUMP */
+#define _cnm_dump(to_t, from) do {} while (0)
+#endif /* def _CNM_DUMP */
+
+#ifdef DEBUG
+#define _cnm_return_val_if_overflow(to_t,from,val)  G_STMT_START {   \
+    int     uns = _cnm_integral_type_is_unsigned (to_t);             \
+    gint64  min = (gint64)  _cnm_integral_type_min (to_t);           \
+    guint64 max = (guint64) _cnm_integral_type_max (to_t);           \
+    gint64  sf  = (gint64)  from;                                    \
+    guint64 uf  = (guint64) from;                                    \
+    if (!(uns ? ((0 <= from) && (uf <= max))                         \
+              : (min <= sf && (from < 0 || uf <= max)))) {           \
+      _cnm_dump(to_t, from);                                         \
+      errno = EOVERFLOW;                                             \
+      return (val);                                                  \
+    }                                                                \
+  } G_STMT_END
+#else /* !def DEBUG */
+/* don't do any overflow checking */
+#define _cnm_return_val_if_overflow(to_t,from,val)  G_STMT_START {   \
+  } G_STMT_END
+#endif /* def DEBUG */
 
 int Mono_Posix_FromAccessModes (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_AccessModes_F_OK) == Mono_Posix_AccessModes_F_OK)
 #ifdef F_OK
                *r |= F_OK;
@@ -1458,6 +263,8 @@ int Mono_Posix_FromAccessModes (int x, int *r)
 #else /* def X_OK */
                {errno = EINVAL; return -1;}
 #endif /* ndef X_OK */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -1485,458 +292,458 @@ int Mono_Posix_ToAccessModes (int x, int *r)
        return 0;
 }
 
-int Mono_Posix_FromConfStr (int x, int *r)
+int Mono_Posix_FromConfstrName (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
-       if (x == Mono_Posix_ConfStr__CS_GNU_LIBC_VERSION)
+       if (x == Mono_Posix_ConfstrName__CS_GNU_LIBC_VERSION)
 #ifdef _CS_GNU_LIBC_VERSION
                {*r = _CS_GNU_LIBC_VERSION; return 0;}
 #else /* def _CS_GNU_LIBC_VERSION */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_GNU_LIBC_VERSION */
-       if (x == Mono_Posix_ConfStr__CS_GNU_LIBPTHREAD_VERSION)
+       if (x == Mono_Posix_ConfstrName__CS_GNU_LIBPTHREAD_VERSION)
 #ifdef _CS_GNU_LIBPTHREAD_VERSION
                {*r = _CS_GNU_LIBPTHREAD_VERSION; return 0;}
 #else /* def _CS_GNU_LIBPTHREAD_VERSION */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_GNU_LIBPTHREAD_VERSION */
-       if (x == Mono_Posix_ConfStr__CS_LFS64_CFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_LFS64_CFLAGS)
 #ifdef _CS_LFS64_CFLAGS
                {*r = _CS_LFS64_CFLAGS; return 0;}
 #else /* def _CS_LFS64_CFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_LFS64_CFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_LFS64_LDFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_LFS64_LDFLAGS)
 #ifdef _CS_LFS64_LDFLAGS
                {*r = _CS_LFS64_LDFLAGS; return 0;}
 #else /* def _CS_LFS64_LDFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_LFS64_LDFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_LFS64_LIBS)
+       if (x == Mono_Posix_ConfstrName__CS_LFS64_LIBS)
 #ifdef _CS_LFS64_LIBS
                {*r = _CS_LFS64_LIBS; return 0;}
 #else /* def _CS_LFS64_LIBS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_LFS64_LIBS */
-       if (x == Mono_Posix_ConfStr__CS_LFS64_LINTFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_LFS64_LINTFLAGS)
 #ifdef _CS_LFS64_LINTFLAGS
                {*r = _CS_LFS64_LINTFLAGS; return 0;}
 #else /* def _CS_LFS64_LINTFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_LFS64_LINTFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_LFS_CFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_LFS_CFLAGS)
 #ifdef _CS_LFS_CFLAGS
                {*r = _CS_LFS_CFLAGS; return 0;}
 #else /* def _CS_LFS_CFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_LFS_CFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_LFS_LDFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_LFS_LDFLAGS)
 #ifdef _CS_LFS_LDFLAGS
                {*r = _CS_LFS_LDFLAGS; return 0;}
 #else /* def _CS_LFS_LDFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_LFS_LDFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_LFS_LIBS)
+       if (x == Mono_Posix_ConfstrName__CS_LFS_LIBS)
 #ifdef _CS_LFS_LIBS
                {*r = _CS_LFS_LIBS; return 0;}
 #else /* def _CS_LFS_LIBS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_LFS_LIBS */
-       if (x == Mono_Posix_ConfStr__CS_LFS_LINTFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_LFS_LINTFLAGS)
 #ifdef _CS_LFS_LINTFLAGS
                {*r = _CS_LFS_LINTFLAGS; return 0;}
 #else /* def _CS_LFS_LINTFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_LFS_LINTFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_PATH)
+       if (x == Mono_Posix_ConfstrName__CS_PATH)
 #ifdef _CS_PATH
                {*r = _CS_PATH; return 0;}
 #else /* def _CS_PATH */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_PATH */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_CFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_CFLAGS)
 #ifdef _CS_POSIX_V6_ILP32_OFF32_CFLAGS
                {*r = _CS_POSIX_V6_ILP32_OFF32_CFLAGS; return 0;}
 #else /* def _CS_POSIX_V6_ILP32_OFF32_CFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_CFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_LDFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_LDFLAGS)
 #ifdef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS
                {*r = _CS_POSIX_V6_ILP32_OFF32_LDFLAGS; return 0;}
 #else /* def _CS_POSIX_V6_ILP32_OFF32_LDFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_LIBS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_LIBS)
 #ifdef _CS_POSIX_V6_ILP32_OFF32_LIBS
                {*r = _CS_POSIX_V6_ILP32_OFF32_LIBS; return 0;}
 #else /* def _CS_POSIX_V6_ILP32_OFF32_LIBS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LIBS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_LINTFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_LINTFLAGS)
 #ifdef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
                {*r = _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS; return 0;}
 #else /* def _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_CFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_CFLAGS)
 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
                {*r = _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS; return 0;}
 #else /* def _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS)
 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
                {*r = _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS; return 0;}
 #else /* def _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_LIBS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_LIBS)
 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LIBS
                {*r = _CS_POSIX_V6_ILP32_OFFBIG_LIBS; return 0;}
 #else /* def _CS_POSIX_V6_ILP32_OFFBIG_LIBS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LIBS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS)
 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
                {*r = _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS; return 0;}
 #else /* def _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_CFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_CFLAGS)
 #ifdef _CS_POSIX_V6_LP64_OFF64_CFLAGS
                {*r = _CS_POSIX_V6_LP64_OFF64_CFLAGS; return 0;}
 #else /* def _CS_POSIX_V6_LP64_OFF64_CFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_CFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_LDFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_LDFLAGS)
 #ifdef _CS_POSIX_V6_LP64_OFF64_LDFLAGS
                {*r = _CS_POSIX_V6_LP64_OFF64_LDFLAGS; return 0;}
 #else /* def _CS_POSIX_V6_LP64_OFF64_LDFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_LDFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_LIBS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_LIBS)
 #ifdef _CS_POSIX_V6_LP64_OFF64_LIBS
                {*r = _CS_POSIX_V6_LP64_OFF64_LIBS; return 0;}
 #else /* def _CS_POSIX_V6_LP64_OFF64_LIBS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_LIBS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_LINTFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_LINTFLAGS)
 #ifdef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS
                {*r = _CS_POSIX_V6_LP64_OFF64_LINTFLAGS; return 0;}
 #else /* def _CS_POSIX_V6_LP64_OFF64_LINTFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS)
 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
                {*r = _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS; return 0;}
 #else /* def _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS)
 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
                {*r = _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS; return 0;}
 #else /* def _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_LIBS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_LIBS)
 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS
                {*r = _CS_POSIX_V6_LPBIG_OFFBIG_LIBS; return 0;}
 #else /* def _CS_POSIX_V6_LPBIG_OFFBIG_LIBS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS */
-       if (x == Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS)
 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
                {*r = _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS; return 0;}
 #else /* def _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_V6_WIDTH_RESTRICTED_ENVS)
+       if (x == Mono_Posix_ConfstrName__CS_V6_WIDTH_RESTRICTED_ENVS)
 #ifdef _CS_V6_WIDTH_RESTRICTED_ENVS
                {*r = _CS_V6_WIDTH_RESTRICTED_ENVS; return 0;}
 #else /* def _CS_V6_WIDTH_RESTRICTED_ENVS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_V6_WIDTH_RESTRICTED_ENVS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_CFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_CFLAGS)
 #ifdef _CS_XBS5_ILP32_OFF32_CFLAGS
                {*r = _CS_XBS5_ILP32_OFF32_CFLAGS; return 0;}
 #else /* def _CS_XBS5_ILP32_OFF32_CFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_ILP32_OFF32_CFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_LDFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_LDFLAGS)
 #ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS
                {*r = _CS_XBS5_ILP32_OFF32_LDFLAGS; return 0;}
 #else /* def _CS_XBS5_ILP32_OFF32_LDFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_ILP32_OFF32_LDFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_LIBS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_LIBS)
 #ifdef _CS_XBS5_ILP32_OFF32_LIBS
                {*r = _CS_XBS5_ILP32_OFF32_LIBS; return 0;}
 #else /* def _CS_XBS5_ILP32_OFF32_LIBS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_ILP32_OFF32_LIBS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_LINTFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_LINTFLAGS)
 #ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS
                {*r = _CS_XBS5_ILP32_OFF32_LINTFLAGS; return 0;}
 #else /* def _CS_XBS5_ILP32_OFF32_LINTFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_ILP32_OFF32_LINTFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_CFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_CFLAGS)
 #ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS
                {*r = _CS_XBS5_ILP32_OFFBIG_CFLAGS; return 0;}
 #else /* def _CS_XBS5_ILP32_OFFBIG_CFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_CFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_LDFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_LDFLAGS)
 #ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS
                {*r = _CS_XBS5_ILP32_OFFBIG_LDFLAGS; return 0;}
 #else /* def _CS_XBS5_ILP32_OFFBIG_LDFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_LDFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_LIBS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_LIBS)
 #ifdef _CS_XBS5_ILP32_OFFBIG_LIBS
                {*r = _CS_XBS5_ILP32_OFFBIG_LIBS; return 0;}
 #else /* def _CS_XBS5_ILP32_OFFBIG_LIBS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_LIBS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_LINTFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_LINTFLAGS)
 #ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
                {*r = _CS_XBS5_ILP32_OFFBIG_LINTFLAGS; return 0;}
 #else /* def _CS_XBS5_ILP32_OFFBIG_LINTFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_CFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_CFLAGS)
 #ifdef _CS_XBS5_LP64_OFF64_CFLAGS
                {*r = _CS_XBS5_LP64_OFF64_CFLAGS; return 0;}
 #else /* def _CS_XBS5_LP64_OFF64_CFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_LP64_OFF64_CFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_LDFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_LDFLAGS)
 #ifdef _CS_XBS5_LP64_OFF64_LDFLAGS
                {*r = _CS_XBS5_LP64_OFF64_LDFLAGS; return 0;}
 #else /* def _CS_XBS5_LP64_OFF64_LDFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_LP64_OFF64_LDFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_LIBS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_LIBS)
 #ifdef _CS_XBS5_LP64_OFF64_LIBS
                {*r = _CS_XBS5_LP64_OFF64_LIBS; return 0;}
 #else /* def _CS_XBS5_LP64_OFF64_LIBS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_LP64_OFF64_LIBS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_LINTFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_LINTFLAGS)
 #ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS
                {*r = _CS_XBS5_LP64_OFF64_LINTFLAGS; return 0;}
 #else /* def _CS_XBS5_LP64_OFF64_LINTFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_LP64_OFF64_LINTFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_CFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_CFLAGS)
 #ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS
                {*r = _CS_XBS5_LPBIG_OFFBIG_CFLAGS; return 0;}
 #else /* def _CS_XBS5_LPBIG_OFFBIG_CFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_CFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_LDFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_LDFLAGS)
 #ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
                {*r = _CS_XBS5_LPBIG_OFFBIG_LDFLAGS; return 0;}
 #else /* def _CS_XBS5_LPBIG_OFFBIG_LDFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_LIBS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_LIBS)
 #ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS
                {*r = _CS_XBS5_LPBIG_OFFBIG_LIBS; return 0;}
 #else /* def _CS_XBS5_LPBIG_OFFBIG_LIBS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LIBS */
-       if (x == Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_LINTFLAGS)
+       if (x == Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_LINTFLAGS)
 #ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
                {*r = _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS; return 0;}
 #else /* def _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
-int Mono_Posix_ToConfStr (int x, int *r)
+int Mono_Posix_ToConfstrName (int x, int *r)
 {
        *r = 0;
        if (x == 0)
                return 0;
 #ifdef _CS_GNU_LIBC_VERSION
        if (x == _CS_GNU_LIBC_VERSION)
-               {*r = Mono_Posix_ConfStr__CS_GNU_LIBC_VERSION; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_GNU_LIBC_VERSION; return 0;}
 #endif /* ndef _CS_GNU_LIBC_VERSION */
 #ifdef _CS_GNU_LIBPTHREAD_VERSION
        if (x == _CS_GNU_LIBPTHREAD_VERSION)
-               {*r = Mono_Posix_ConfStr__CS_GNU_LIBPTHREAD_VERSION; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_GNU_LIBPTHREAD_VERSION; return 0;}
 #endif /* ndef _CS_GNU_LIBPTHREAD_VERSION */
 #ifdef _CS_LFS64_CFLAGS
        if (x == _CS_LFS64_CFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_LFS64_CFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_LFS64_CFLAGS; return 0;}
 #endif /* ndef _CS_LFS64_CFLAGS */
 #ifdef _CS_LFS64_LDFLAGS
        if (x == _CS_LFS64_LDFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_LFS64_LDFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_LFS64_LDFLAGS; return 0;}
 #endif /* ndef _CS_LFS64_LDFLAGS */
 #ifdef _CS_LFS64_LIBS
        if (x == _CS_LFS64_LIBS)
-               {*r = Mono_Posix_ConfStr__CS_LFS64_LIBS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_LFS64_LIBS; return 0;}
 #endif /* ndef _CS_LFS64_LIBS */
 #ifdef _CS_LFS64_LINTFLAGS
        if (x == _CS_LFS64_LINTFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_LFS64_LINTFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_LFS64_LINTFLAGS; return 0;}
 #endif /* ndef _CS_LFS64_LINTFLAGS */
 #ifdef _CS_LFS_CFLAGS
        if (x == _CS_LFS_CFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_LFS_CFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_LFS_CFLAGS; return 0;}
 #endif /* ndef _CS_LFS_CFLAGS */
 #ifdef _CS_LFS_LDFLAGS
        if (x == _CS_LFS_LDFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_LFS_LDFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_LFS_LDFLAGS; return 0;}
 #endif /* ndef _CS_LFS_LDFLAGS */
 #ifdef _CS_LFS_LIBS
        if (x == _CS_LFS_LIBS)
-               {*r = Mono_Posix_ConfStr__CS_LFS_LIBS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_LFS_LIBS; return 0;}
 #endif /* ndef _CS_LFS_LIBS */
 #ifdef _CS_LFS_LINTFLAGS
        if (x == _CS_LFS_LINTFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_LFS_LINTFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_LFS_LINTFLAGS; return 0;}
 #endif /* ndef _CS_LFS_LINTFLAGS */
 #ifdef _CS_PATH
        if (x == _CS_PATH)
-               {*r = Mono_Posix_ConfStr__CS_PATH; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_PATH; return 0;}
 #endif /* ndef _CS_PATH */
 #ifdef _CS_POSIX_V6_ILP32_OFF32_CFLAGS
        if (x == _CS_POSIX_V6_ILP32_OFF32_CFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_CFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_CFLAGS; return 0;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_CFLAGS */
 #ifdef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS
        if (x == _CS_POSIX_V6_ILP32_OFF32_LDFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_LDFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_LDFLAGS; return 0;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LDFLAGS */
 #ifdef _CS_POSIX_V6_ILP32_OFF32_LIBS
        if (x == _CS_POSIX_V6_ILP32_OFF32_LIBS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_LIBS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_LIBS; return 0;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LIBS */
 #ifdef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
        if (x == _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFF32_LINTFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFF32_LINTFLAGS; return 0;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS */
 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
        if (x == _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_CFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_CFLAGS; return 0;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS */
 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
        if (x == _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS; return 0;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS */
 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LIBS
        if (x == _CS_POSIX_V6_ILP32_OFFBIG_LIBS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_LIBS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_LIBS; return 0;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LIBS */
 #ifdef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
        if (x == _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS; return 0;}
 #endif /* ndef _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS */
 #ifdef _CS_POSIX_V6_LP64_OFF64_CFLAGS
        if (x == _CS_POSIX_V6_LP64_OFF64_CFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_CFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_CFLAGS; return 0;}
 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_CFLAGS */
 #ifdef _CS_POSIX_V6_LP64_OFF64_LDFLAGS
        if (x == _CS_POSIX_V6_LP64_OFF64_LDFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_LDFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_LDFLAGS; return 0;}
 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_LDFLAGS */
 #ifdef _CS_POSIX_V6_LP64_OFF64_LIBS
        if (x == _CS_POSIX_V6_LP64_OFF64_LIBS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_LIBS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_LIBS; return 0;}
 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_LIBS */
 #ifdef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS
        if (x == _CS_POSIX_V6_LP64_OFF64_LINTFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LP64_OFF64_LINTFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LP64_OFF64_LINTFLAGS; return 0;}
 #endif /* ndef _CS_POSIX_V6_LP64_OFF64_LINTFLAGS */
 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
        if (x == _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS; return 0;}
 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS */
 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
        if (x == _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS; return 0;}
 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS */
 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS
        if (x == _CS_POSIX_V6_LPBIG_OFFBIG_LIBS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_LIBS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_LIBS; return 0;}
 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LIBS */
 #ifdef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
        if (x == _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS; return 0;}
 #endif /* ndef _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS */
 #ifdef _CS_V6_WIDTH_RESTRICTED_ENVS
        if (x == _CS_V6_WIDTH_RESTRICTED_ENVS)
-               {*r = Mono_Posix_ConfStr__CS_V6_WIDTH_RESTRICTED_ENVS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_V6_WIDTH_RESTRICTED_ENVS; return 0;}
 #endif /* ndef _CS_V6_WIDTH_RESTRICTED_ENVS */
 #ifdef _CS_XBS5_ILP32_OFF32_CFLAGS
        if (x == _CS_XBS5_ILP32_OFF32_CFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_CFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_CFLAGS; return 0;}
 #endif /* ndef _CS_XBS5_ILP32_OFF32_CFLAGS */
 #ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS
        if (x == _CS_XBS5_ILP32_OFF32_LDFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_LDFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_LDFLAGS; return 0;}
 #endif /* ndef _CS_XBS5_ILP32_OFF32_LDFLAGS */
 #ifdef _CS_XBS5_ILP32_OFF32_LIBS
        if (x == _CS_XBS5_ILP32_OFF32_LIBS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_LIBS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_LIBS; return 0;}
 #endif /* ndef _CS_XBS5_ILP32_OFF32_LIBS */
 #ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS
        if (x == _CS_XBS5_ILP32_OFF32_LINTFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFF32_LINTFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFF32_LINTFLAGS; return 0;}
 #endif /* ndef _CS_XBS5_ILP32_OFF32_LINTFLAGS */
 #ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS
        if (x == _CS_XBS5_ILP32_OFFBIG_CFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_CFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_CFLAGS; return 0;}
 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_CFLAGS */
 #ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS
        if (x == _CS_XBS5_ILP32_OFFBIG_LDFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_LDFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_LDFLAGS; return 0;}
 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_LDFLAGS */
 #ifdef _CS_XBS5_ILP32_OFFBIG_LIBS
        if (x == _CS_XBS5_ILP32_OFFBIG_LIBS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_LIBS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_LIBS; return 0;}
 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_LIBS */
 #ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
        if (x == _CS_XBS5_ILP32_OFFBIG_LINTFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_ILP32_OFFBIG_LINTFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_ILP32_OFFBIG_LINTFLAGS; return 0;}
 #endif /* ndef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS */
 #ifdef _CS_XBS5_LP64_OFF64_CFLAGS
        if (x == _CS_XBS5_LP64_OFF64_CFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_CFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_CFLAGS; return 0;}
 #endif /* ndef _CS_XBS5_LP64_OFF64_CFLAGS */
 #ifdef _CS_XBS5_LP64_OFF64_LDFLAGS
        if (x == _CS_XBS5_LP64_OFF64_LDFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_LDFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_LDFLAGS; return 0;}
 #endif /* ndef _CS_XBS5_LP64_OFF64_LDFLAGS */
 #ifdef _CS_XBS5_LP64_OFF64_LIBS
        if (x == _CS_XBS5_LP64_OFF64_LIBS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_LIBS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_LIBS; return 0;}
 #endif /* ndef _CS_XBS5_LP64_OFF64_LIBS */
 #ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS
        if (x == _CS_XBS5_LP64_OFF64_LINTFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_LP64_OFF64_LINTFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_LP64_OFF64_LINTFLAGS; return 0;}
 #endif /* ndef _CS_XBS5_LP64_OFF64_LINTFLAGS */
 #ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS
        if (x == _CS_XBS5_LPBIG_OFFBIG_CFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_CFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_CFLAGS; return 0;}
 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_CFLAGS */
 #ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
        if (x == _CS_XBS5_LPBIG_OFFBIG_LDFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_LDFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_LDFLAGS; return 0;}
 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS */
 #ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS
        if (x == _CS_XBS5_LPBIG_OFFBIG_LIBS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_LIBS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_LIBS; return 0;}
 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LIBS */
 #ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
        if (x == _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS)
-               {*r = Mono_Posix_ConfStr__CS_XBS5_LPBIG_OFFBIG_LINTFLAGS; return 0;}
+               {*r = Mono_Posix_ConfstrName__CS_XBS5_LPBIG_OFFBIG_LINTFLAGS; return 0;}
 #endif /* ndef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS */
        errno = EINVAL; return -1;
 }
@@ -1944,8 +751,6 @@ int Mono_Posix_ToConfStr (int x, int *r)
 int Mono_Posix_FromDirectoryNotifyFlags (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_DirectoryNotifyFlags_DN_ACCESS) == Mono_Posix_DirectoryNotifyFlags_DN_ACCESS)
 #ifdef DN_ACCESS
                *r |= DN_ACCESS;
@@ -1988,6 +793,8 @@ int Mono_Posix_FromDirectoryNotifyFlags (int x, int *r)
 #else /* def DN_RENAME */
                {errno = EINVAL; return -1;}
 #endif /* ndef DN_RENAME */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -2030,8 +837,6 @@ int Mono_Posix_ToDirectoryNotifyFlags (int x, int *r)
 int Mono_Posix_FromErrno (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if (x == Mono_Posix_Errno_E2BIG)
 #ifdef E2BIG
                {*r = E2BIG; return 0;}
@@ -2776,6 +1581,8 @@ int Mono_Posix_FromErrno (int x, int *r)
 #else /* def EXFULL */
                {errno = EINVAL; return -1;}
 #endif /* ndef EXFULL */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
@@ -3286,8 +2093,6 @@ int Mono_Posix_ToErrno (int x, int *r)
 int Mono_Posix_FromFcntlCommand (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if (x == Mono_Posix_FcntlCommand_F_DUPFD)
 #ifdef F_DUPFD
                {*r = F_DUPFD; return 0;}
@@ -3378,6 +2183,8 @@ int Mono_Posix_FromFcntlCommand (int x, int *r)
 #else /* def F_SETSIG */
                {errno = EINVAL; return -1;}
 #endif /* ndef F_SETSIG */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
@@ -3452,51 +2259,49 @@ int Mono_Posix_ToFcntlCommand (int x, int *r)
 int Mono_Posix_FromFilePermissions (unsigned int x, unsigned int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_FilePermissions_ACCESSPERMS) == Mono_Posix_FilePermissions_ACCESSPERMS)
 #ifdef ACCESSPERMS
                *r |= ACCESSPERMS;
 #else /* def ACCESSPERMS */
-               {errno = EINVAL; return -1;}
+               {/* Ignoring Mono_Posix_FilePermissions_ACCESSPERMS, as it is constructed from other values */}
 #endif /* ndef ACCESSPERMS */
        if ((x & Mono_Posix_FilePermissions_ALLPERMS) == Mono_Posix_FilePermissions_ALLPERMS)
 #ifdef ALLPERMS
                *r |= ALLPERMS;
 #else /* def ALLPERMS */
-               {errno = EINVAL; return -1;}
+               {/* Ignoring Mono_Posix_FilePermissions_ALLPERMS, as it is constructed from other values */}
 #endif /* ndef ALLPERMS */
        if ((x & Mono_Posix_FilePermissions_DEFFILEMODE) == Mono_Posix_FilePermissions_DEFFILEMODE)
 #ifdef DEFFILEMODE
                *r |= DEFFILEMODE;
 #else /* def DEFFILEMODE */
-               {errno = EINVAL; return -1;}
+               {/* Ignoring Mono_Posix_FilePermissions_DEFFILEMODE, as it is constructed from other values */}
 #endif /* ndef DEFFILEMODE */
-       if ((x & Mono_Posix_FilePermissions_S_IFBLK) == Mono_Posix_FilePermissions_S_IFBLK)
+       if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFBLK)
 #ifdef S_IFBLK
                *r |= S_IFBLK;
 #else /* def S_IFBLK */
                {errno = EINVAL; return -1;}
 #endif /* ndef S_IFBLK */
-       if ((x & Mono_Posix_FilePermissions_S_IFCHR) == Mono_Posix_FilePermissions_S_IFCHR)
+       if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFCHR)
 #ifdef S_IFCHR
                *r |= S_IFCHR;
 #else /* def S_IFCHR */
                {errno = EINVAL; return -1;}
 #endif /* ndef S_IFCHR */
-       if ((x & Mono_Posix_FilePermissions_S_IFDIR) == Mono_Posix_FilePermissions_S_IFDIR)
+       if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFDIR)
 #ifdef S_IFDIR
                *r |= S_IFDIR;
 #else /* def S_IFDIR */
                {errno = EINVAL; return -1;}
 #endif /* ndef S_IFDIR */
-       if ((x & Mono_Posix_FilePermissions_S_IFIFO) == Mono_Posix_FilePermissions_S_IFIFO)
+       if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFIFO)
 #ifdef S_IFIFO
                *r |= S_IFIFO;
 #else /* def S_IFIFO */
                {errno = EINVAL; return -1;}
 #endif /* ndef S_IFIFO */
-       if ((x & Mono_Posix_FilePermissions_S_IFLNK) == Mono_Posix_FilePermissions_S_IFLNK)
+       if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFLNK)
 #ifdef S_IFLNK
                *r |= S_IFLNK;
 #else /* def S_IFLNK */
@@ -3506,15 +2311,15 @@ int Mono_Posix_FromFilePermissions (unsigned int x, unsigned int *r)
 #ifdef S_IFMT
                *r |= S_IFMT;
 #else /* def S_IFMT */
-               {errno = EINVAL; return -1;}
+               {/* Ignoring Mono_Posix_FilePermissions_S_IFMT, as it is constructed from other values */}
 #endif /* ndef S_IFMT */
-       if ((x & Mono_Posix_FilePermissions_S_IFREG) == Mono_Posix_FilePermissions_S_IFREG)
+       if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFREG)
 #ifdef S_IFREG
                *r |= S_IFREG;
 #else /* def S_IFREG */
                {errno = EINVAL; return -1;}
 #endif /* ndef S_IFREG */
-       if ((x & Mono_Posix_FilePermissions_S_IFSOCK) == Mono_Posix_FilePermissions_S_IFSOCK)
+       if ((x & Mono_Posix_FilePermissions_S_IFMT) == Mono_Posix_FilePermissions_S_IFSOCK)
 #ifdef S_IFSOCK
                *r |= S_IFSOCK;
 #else /* def S_IFSOCK */
@@ -3542,19 +2347,19 @@ int Mono_Posix_FromFilePermissions (unsigned int x, unsigned int *r)
 #ifdef S_IRWXG
                *r |= S_IRWXG;
 #else /* def S_IRWXG */
-               {errno = EINVAL; return -1;}
+               {/* Ignoring Mono_Posix_FilePermissions_S_IRWXG, as it is constructed from other values */}
 #endif /* ndef S_IRWXG */
        if ((x & Mono_Posix_FilePermissions_S_IRWXO) == Mono_Posix_FilePermissions_S_IRWXO)
 #ifdef S_IRWXO
                *r |= S_IRWXO;
 #else /* def S_IRWXO */
-               {errno = EINVAL; return -1;}
+               {/* Ignoring Mono_Posix_FilePermissions_S_IRWXO, as it is constructed from other values */}
 #endif /* ndef S_IRWXO */
        if ((x & Mono_Posix_FilePermissions_S_IRWXU) == Mono_Posix_FilePermissions_S_IRWXU)
 #ifdef S_IRWXU
                *r |= S_IRWXU;
 #else /* def S_IRWXU */
-               {errno = EINVAL; return -1;}
+               {/* Ignoring Mono_Posix_FilePermissions_S_IRWXU, as it is constructed from other values */}
 #endif /* ndef S_IRWXU */
        if ((x & Mono_Posix_FilePermissions_S_ISGID) == Mono_Posix_FilePermissions_S_ISGID)
 #ifdef S_ISGID
@@ -3610,6 +2415,8 @@ int Mono_Posix_FromFilePermissions (unsigned int x, unsigned int *r)
 #else /* def S_IXUSR */
                {errno = EINVAL; return -1;}
 #endif /* ndef S_IXUSR */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -3631,23 +2438,23 @@ int Mono_Posix_ToFilePermissions (unsigned int x, unsigned int *r)
                *r |= Mono_Posix_FilePermissions_DEFFILEMODE;
 #endif /* ndef DEFFILEMODE */
 #ifdef S_IFBLK
-       if ((x & S_IFBLK) == S_IFBLK)
+       if ((x & S_IFMT) == S_IFBLK)
                *r |= Mono_Posix_FilePermissions_S_IFBLK;
 #endif /* ndef S_IFBLK */
 #ifdef S_IFCHR
-       if ((x & S_IFCHR) == S_IFCHR)
+       if ((x & S_IFMT) == S_IFCHR)
                *r |= Mono_Posix_FilePermissions_S_IFCHR;
 #endif /* ndef S_IFCHR */
 #ifdef S_IFDIR
-       if ((x & S_IFDIR) == S_IFDIR)
+       if ((x & S_IFMT) == S_IFDIR)
                *r |= Mono_Posix_FilePermissions_S_IFDIR;
 #endif /* ndef S_IFDIR */
 #ifdef S_IFIFO
-       if ((x & S_IFIFO) == S_IFIFO)
+       if ((x & S_IFMT) == S_IFIFO)
                *r |= Mono_Posix_FilePermissions_S_IFIFO;
 #endif /* ndef S_IFIFO */
 #ifdef S_IFLNK
-       if ((x & S_IFLNK) == S_IFLNK)
+       if ((x & S_IFMT) == S_IFLNK)
                *r |= Mono_Posix_FilePermissions_S_IFLNK;
 #endif /* ndef S_IFLNK */
 #ifdef S_IFMT
@@ -3655,11 +2462,11 @@ int Mono_Posix_ToFilePermissions (unsigned int x, unsigned int *r)
                *r |= Mono_Posix_FilePermissions_S_IFMT;
 #endif /* ndef S_IFMT */
 #ifdef S_IFREG
-       if ((x & S_IFREG) == S_IFREG)
+       if ((x & S_IFMT) == S_IFREG)
                *r |= Mono_Posix_FilePermissions_S_IFREG;
 #endif /* ndef S_IFREG */
 #ifdef S_IFSOCK
-       if ((x & S_IFSOCK) == S_IFSOCK)
+       if ((x & S_IFMT) == S_IFSOCK)
                *r |= Mono_Posix_FilePermissions_S_IFSOCK;
 #endif /* ndef S_IFSOCK */
 #ifdef S_IRGRP
@@ -3725,11 +2532,59 @@ int Mono_Posix_ToFilePermissions (unsigned int x, unsigned int *r)
        return 0;
 }
 
+#ifdef HAVE_STRUCT_FLOCK
+int
+Mono_Posix_FromFlock (struct Mono_Posix_Flock *from, struct flock *to)
+{
+       _cnm_return_val_if_overflow (off_t, from->l_start, -1);
+       _cnm_return_val_if_overflow (off_t, from->l_len, -1);
+       _cnm_return_val_if_overflow (pid_t, from->l_pid, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       if (Mono_Posix_FromLockType (from->l_type, &to->l_type) != 0) {
+               return -1;
+       }
+       if (Mono_Posix_FromSeekFlags (from->l_whence, &to->l_whence) != 0) {
+               return -1;
+       }
+       to->l_start  = from->l_start;
+       to->l_len    = from->l_len;
+       to->l_pid    = from->l_pid;
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_FLOCK */
+
+
+#ifdef HAVE_STRUCT_FLOCK
+int
+Mono_Posix_ToFlock (struct flock *from, struct Mono_Posix_Flock *to)
+{
+       _cnm_return_val_if_overflow (gint64, from->l_start, -1);
+       _cnm_return_val_if_overflow (gint64, from->l_len, -1);
+       _cnm_return_val_if_overflow (int, from->l_pid, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       if (Mono_Posix_ToLockType (from->l_type, &to->l_type) != 0) {
+               return -1;
+       }
+       if (Mono_Posix_ToSeekFlags (from->l_whence, &to->l_whence) != 0) {
+               return -1;
+       }
+       to->l_start  = from->l_start;
+       to->l_len    = from->l_len;
+       to->l_pid    = from->l_pid;
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_FLOCK */
+
+
 int Mono_Posix_FromLockType (short x, short *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if (x == Mono_Posix_LockType_F_RDLCK)
 #ifdef F_RDLCK
                {*r = F_RDLCK; return 0;}
@@ -3748,6 +2603,8 @@ int Mono_Posix_FromLockType (short x, short *r)
 #else /* def F_WRLCK */
                {errno = EINVAL; return -1;}
 #endif /* ndef F_WRLCK */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
@@ -3774,8 +2631,6 @@ int Mono_Posix_ToLockType (short x, short *r)
 int Mono_Posix_FromLockfCommand (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if (x == Mono_Posix_LockfCommand_F_LOCK)
 #ifdef F_LOCK
                {*r = F_LOCK; return 0;}
@@ -3800,6 +2655,8 @@ int Mono_Posix_FromLockfCommand (int x, int *r)
 #else /* def F_ULOCK */
                {errno = EINVAL; return -1;}
 #endif /* ndef F_ULOCK */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
@@ -3830,8 +2687,6 @@ int Mono_Posix_ToLockfCommand (int x, int *r)
 int Mono_Posix_FromMlockallFlags (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_MlockallFlags_MCL_CURRENT) == Mono_Posix_MlockallFlags_MCL_CURRENT)
 #ifdef MCL_CURRENT
                *r |= MCL_CURRENT;
@@ -3844,6 +2699,8 @@ int Mono_Posix_FromMlockallFlags (int x, int *r)
 #else /* def MCL_FUTURE */
                {errno = EINVAL; return -1;}
 #endif /* ndef MCL_FUTURE */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -3866,8 +2723,6 @@ int Mono_Posix_ToMlockallFlags (int x, int *r)
 int Mono_Posix_FromMmapFlags (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_MmapFlags_MAP_ANON) == Mono_Posix_MmapFlags_MAP_ANON)
 #ifdef MAP_ANON
                *r |= MAP_ANON;
@@ -3952,6 +2807,8 @@ int Mono_Posix_FromMmapFlags (int x, int *r)
 #else /* def MAP_TYPE */
                {errno = EINVAL; return -1;}
 #endif /* ndef MAP_TYPE */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -4022,8 +2879,6 @@ int Mono_Posix_ToMmapFlags (int x, int *r)
 int Mono_Posix_FromMmapProts (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_MmapProts_PROT_EXEC) == Mono_Posix_MmapProts_PROT_EXEC)
 #ifdef PROT_EXEC
                *r |= PROT_EXEC;
@@ -4060,6 +2915,8 @@ int Mono_Posix_FromMmapProts (int x, int *r)
 #else /* def PROT_WRITE */
                {errno = EINVAL; return -1;}
 #endif /* ndef PROT_WRITE */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -4098,14 +2955,18 @@ int Mono_Posix_ToMmapProts (int x, int *r)
 int Mono_Posix_FromMountFlags (guint64 x, guint64 *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_MountFlags_ST_APPEND) == Mono_Posix_MountFlags_ST_APPEND)
 #ifdef ST_APPEND
                *r |= ST_APPEND;
 #else /* def ST_APPEND */
                {errno = EINVAL; return -1;}
 #endif /* ndef ST_APPEND */
+       if ((x & Mono_Posix_MountFlags_ST_BIND) == Mono_Posix_MountFlags_ST_BIND)
+#ifdef ST_BIND
+               *r |= ST_BIND;
+#else /* def ST_BIND */
+               {errno = EINVAL; return -1;}
+#endif /* ndef ST_BIND */
        if ((x & Mono_Posix_MountFlags_ST_IMMUTABLE) == Mono_Posix_MountFlags_ST_IMMUTABLE)
 #ifdef ST_IMMUTABLE
                *r |= ST_IMMUTABLE;
@@ -4136,6 +2997,12 @@ int Mono_Posix_FromMountFlags (guint64 x, guint64 *r)
 #else /* def ST_NODIRATIME */
                {errno = EINVAL; return -1;}
 #endif /* ndef ST_NODIRATIME */
+       if ((x & Mono_Posix_MountFlags_ST_NOEXEC) == Mono_Posix_MountFlags_ST_NOEXEC)
+#ifdef ST_NOEXEC
+               *r |= ST_NOEXEC;
+#else /* def ST_NOEXEC */
+               {errno = EINVAL; return -1;}
+#endif /* ndef ST_NOEXEC */
        if ((x & Mono_Posix_MountFlags_ST_NOSUID) == Mono_Posix_MountFlags_ST_NOSUID)
 #ifdef ST_NOSUID
                *r |= ST_NOSUID;
@@ -4148,6 +3015,12 @@ int Mono_Posix_FromMountFlags (guint64 x, guint64 *r)
 #else /* def ST_RDONLY */
                {errno = EINVAL; return -1;}
 #endif /* ndef ST_RDONLY */
+       if ((x & Mono_Posix_MountFlags_ST_REMOUNT) == Mono_Posix_MountFlags_ST_REMOUNT)
+#ifdef ST_REMOUNT
+               *r |= ST_REMOUNT;
+#else /* def ST_REMOUNT */
+               {errno = EINVAL; return -1;}
+#endif /* ndef ST_REMOUNT */
        if ((x & Mono_Posix_MountFlags_ST_SYNCHRONOUS) == Mono_Posix_MountFlags_ST_SYNCHRONOUS)
 #ifdef ST_SYNCHRONOUS
                *r |= ST_SYNCHRONOUS;
@@ -4160,6 +3033,8 @@ int Mono_Posix_FromMountFlags (guint64 x, guint64 *r)
 #else /* def ST_WRITE */
                {errno = EINVAL; return -1;}
 #endif /* ndef ST_WRITE */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -4172,6 +3047,10 @@ int Mono_Posix_ToMountFlags (guint64 x, guint64 *r)
        if ((x & ST_APPEND) == ST_APPEND)
                *r |= Mono_Posix_MountFlags_ST_APPEND;
 #endif /* ndef ST_APPEND */
+#ifdef ST_BIND
+       if ((x & ST_BIND) == ST_BIND)
+               *r |= Mono_Posix_MountFlags_ST_BIND;
+#endif /* ndef ST_BIND */
 #ifdef ST_IMMUTABLE
        if ((x & ST_IMMUTABLE) == ST_IMMUTABLE)
                *r |= Mono_Posix_MountFlags_ST_IMMUTABLE;
@@ -4192,6 +3071,10 @@ int Mono_Posix_ToMountFlags (guint64 x, guint64 *r)
        if ((x & ST_NODIRATIME) == ST_NODIRATIME)
                *r |= Mono_Posix_MountFlags_ST_NODIRATIME;
 #endif /* ndef ST_NODIRATIME */
+#ifdef ST_NOEXEC
+       if ((x & ST_NOEXEC) == ST_NOEXEC)
+               *r |= Mono_Posix_MountFlags_ST_NOEXEC;
+#endif /* ndef ST_NOEXEC */
 #ifdef ST_NOSUID
        if ((x & ST_NOSUID) == ST_NOSUID)
                *r |= Mono_Posix_MountFlags_ST_NOSUID;
@@ -4200,6 +3083,10 @@ int Mono_Posix_ToMountFlags (guint64 x, guint64 *r)
        if ((x & ST_RDONLY) == ST_RDONLY)
                *r |= Mono_Posix_MountFlags_ST_RDONLY;
 #endif /* ndef ST_RDONLY */
+#ifdef ST_REMOUNT
+       if ((x & ST_REMOUNT) == ST_REMOUNT)
+               *r |= Mono_Posix_MountFlags_ST_REMOUNT;
+#endif /* ndef ST_REMOUNT */
 #ifdef ST_SYNCHRONOUS
        if ((x & ST_SYNCHRONOUS) == ST_SYNCHRONOUS)
                *r |= Mono_Posix_MountFlags_ST_SYNCHRONOUS;
@@ -4214,14 +3101,14 @@ int Mono_Posix_ToMountFlags (guint64 x, guint64 *r)
 int Mono_Posix_FromMremapFlags (guint64 x, guint64 *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_MremapFlags_MREMAP_MAYMOVE) == Mono_Posix_MremapFlags_MREMAP_MAYMOVE)
 #ifdef MREMAP_MAYMOVE
                *r |= MREMAP_MAYMOVE;
 #else /* def MREMAP_MAYMOVE */
                {errno = EINVAL; return -1;}
 #endif /* ndef MREMAP_MAYMOVE */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -4240,8 +3127,6 @@ int Mono_Posix_ToMremapFlags (guint64 x, guint64 *r)
 int Mono_Posix_FromMsyncFlags (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_MsyncFlags_MS_ASYNC) == Mono_Posix_MsyncFlags_MS_ASYNC)
 #ifdef MS_ASYNC
                *r |= MS_ASYNC;
@@ -4260,6 +3145,8 @@ int Mono_Posix_FromMsyncFlags (int x, int *r)
 #else /* def MS_SYNC */
                {errno = EINVAL; return -1;}
 #endif /* ndef MS_SYNC */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -4286,8 +3173,6 @@ int Mono_Posix_ToMsyncFlags (int x, int *r)
 int Mono_Posix_FromOpenFlags (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_OpenFlags_O_APPEND) == Mono_Posix_OpenFlags_O_APPEND)
 #ifdef O_APPEND
                *r |= O_APPEND;
@@ -4378,6 +3263,8 @@ int Mono_Posix_FromOpenFlags (int x, int *r)
 #else /* def O_WRONLY */
                {errno = EINVAL; return -1;}
 #endif /* ndef O_WRONLY */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -4449,228 +3336,228 @@ int Mono_Posix_ToOpenFlags (int x, int *r)
        return 0;
 }
 
-int Mono_Posix_FromPathConf (int x, int *r)
+int Mono_Posix_FromPathconfName (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
-       if (x == Mono_Posix_PathConf__PC_2_SYMLINKS)
+       if (x == Mono_Posix_PathconfName__PC_2_SYMLINKS)
 #ifdef _PC_2_SYMLINKS
                {*r = _PC_2_SYMLINKS; return 0;}
 #else /* def _PC_2_SYMLINKS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_2_SYMLINKS */
-       if (x == Mono_Posix_PathConf__PC_ALLOC_SIZE_MIN)
+       if (x == Mono_Posix_PathconfName__PC_ALLOC_SIZE_MIN)
 #ifdef _PC_ALLOC_SIZE_MIN
                {*r = _PC_ALLOC_SIZE_MIN; return 0;}
 #else /* def _PC_ALLOC_SIZE_MIN */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_ALLOC_SIZE_MIN */
-       if (x == Mono_Posix_PathConf__PC_ASYNC_IO)
+       if (x == Mono_Posix_PathconfName__PC_ASYNC_IO)
 #ifdef _PC_ASYNC_IO
                {*r = _PC_ASYNC_IO; return 0;}
 #else /* def _PC_ASYNC_IO */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_ASYNC_IO */
-       if (x == Mono_Posix_PathConf__PC_CHOWN_RESTRICTED)
+       if (x == Mono_Posix_PathconfName__PC_CHOWN_RESTRICTED)
 #ifdef _PC_CHOWN_RESTRICTED
                {*r = _PC_CHOWN_RESTRICTED; return 0;}
 #else /* def _PC_CHOWN_RESTRICTED */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_CHOWN_RESTRICTED */
-       if (x == Mono_Posix_PathConf__PC_FILESIZEBITS)
+       if (x == Mono_Posix_PathconfName__PC_FILESIZEBITS)
 #ifdef _PC_FILESIZEBITS
                {*r = _PC_FILESIZEBITS; return 0;}
 #else /* def _PC_FILESIZEBITS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_FILESIZEBITS */
-       if (x == Mono_Posix_PathConf__PC_LINK_MAX)
+       if (x == Mono_Posix_PathconfName__PC_LINK_MAX)
 #ifdef _PC_LINK_MAX
                {*r = _PC_LINK_MAX; return 0;}
 #else /* def _PC_LINK_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_LINK_MAX */
-       if (x == Mono_Posix_PathConf__PC_MAX_CANON)
+       if (x == Mono_Posix_PathconfName__PC_MAX_CANON)
 #ifdef _PC_MAX_CANON
                {*r = _PC_MAX_CANON; return 0;}
 #else /* def _PC_MAX_CANON */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_MAX_CANON */
-       if (x == Mono_Posix_PathConf__PC_MAX_INPUT)
+       if (x == Mono_Posix_PathconfName__PC_MAX_INPUT)
 #ifdef _PC_MAX_INPUT
                {*r = _PC_MAX_INPUT; return 0;}
 #else /* def _PC_MAX_INPUT */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_MAX_INPUT */
-       if (x == Mono_Posix_PathConf__PC_NAME_MAX)
+       if (x == Mono_Posix_PathconfName__PC_NAME_MAX)
 #ifdef _PC_NAME_MAX
                {*r = _PC_NAME_MAX; return 0;}
 #else /* def _PC_NAME_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_NAME_MAX */
-       if (x == Mono_Posix_PathConf__PC_NO_TRUNC)
+       if (x == Mono_Posix_PathconfName__PC_NO_TRUNC)
 #ifdef _PC_NO_TRUNC
                {*r = _PC_NO_TRUNC; return 0;}
 #else /* def _PC_NO_TRUNC */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_NO_TRUNC */
-       if (x == Mono_Posix_PathConf__PC_PATH_MAX)
+       if (x == Mono_Posix_PathconfName__PC_PATH_MAX)
 #ifdef _PC_PATH_MAX
                {*r = _PC_PATH_MAX; return 0;}
 #else /* def _PC_PATH_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_PATH_MAX */
-       if (x == Mono_Posix_PathConf__PC_PIPE_BUF)
+       if (x == Mono_Posix_PathconfName__PC_PIPE_BUF)
 #ifdef _PC_PIPE_BUF
                {*r = _PC_PIPE_BUF; return 0;}
 #else /* def _PC_PIPE_BUF */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_PIPE_BUF */
-       if (x == Mono_Posix_PathConf__PC_PRIO_IO)
+       if (x == Mono_Posix_PathconfName__PC_PRIO_IO)
 #ifdef _PC_PRIO_IO
                {*r = _PC_PRIO_IO; return 0;}
 #else /* def _PC_PRIO_IO */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_PRIO_IO */
-       if (x == Mono_Posix_PathConf__PC_REC_INCR_XFER_SIZE)
+       if (x == Mono_Posix_PathconfName__PC_REC_INCR_XFER_SIZE)
 #ifdef _PC_REC_INCR_XFER_SIZE
                {*r = _PC_REC_INCR_XFER_SIZE; return 0;}
 #else /* def _PC_REC_INCR_XFER_SIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_REC_INCR_XFER_SIZE */
-       if (x == Mono_Posix_PathConf__PC_REC_MAX_XFER_SIZE)
+       if (x == Mono_Posix_PathconfName__PC_REC_MAX_XFER_SIZE)
 #ifdef _PC_REC_MAX_XFER_SIZE
                {*r = _PC_REC_MAX_XFER_SIZE; return 0;}
 #else /* def _PC_REC_MAX_XFER_SIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_REC_MAX_XFER_SIZE */
-       if (x == Mono_Posix_PathConf__PC_REC_MIN_XFER_SIZE)
+       if (x == Mono_Posix_PathconfName__PC_REC_MIN_XFER_SIZE)
 #ifdef _PC_REC_MIN_XFER_SIZE
                {*r = _PC_REC_MIN_XFER_SIZE; return 0;}
 #else /* def _PC_REC_MIN_XFER_SIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_REC_MIN_XFER_SIZE */
-       if (x == Mono_Posix_PathConf__PC_REC_XFER_ALIGN)
+       if (x == Mono_Posix_PathconfName__PC_REC_XFER_ALIGN)
 #ifdef _PC_REC_XFER_ALIGN
                {*r = _PC_REC_XFER_ALIGN; return 0;}
 #else /* def _PC_REC_XFER_ALIGN */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_REC_XFER_ALIGN */
-       if (x == Mono_Posix_PathConf__PC_SOCK_MAXBUF)
+       if (x == Mono_Posix_PathconfName__PC_SOCK_MAXBUF)
 #ifdef _PC_SOCK_MAXBUF
                {*r = _PC_SOCK_MAXBUF; return 0;}
 #else /* def _PC_SOCK_MAXBUF */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_SOCK_MAXBUF */
-       if (x == Mono_Posix_PathConf__PC_SYMLINK_MAX)
+       if (x == Mono_Posix_PathconfName__PC_SYMLINK_MAX)
 #ifdef _PC_SYMLINK_MAX
                {*r = _PC_SYMLINK_MAX; return 0;}
 #else /* def _PC_SYMLINK_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_SYMLINK_MAX */
-       if (x == Mono_Posix_PathConf__PC_SYNC_IO)
+       if (x == Mono_Posix_PathconfName__PC_SYNC_IO)
 #ifdef _PC_SYNC_IO
                {*r = _PC_SYNC_IO; return 0;}
 #else /* def _PC_SYNC_IO */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_SYNC_IO */
-       if (x == Mono_Posix_PathConf__PC_VDISABLE)
+       if (x == Mono_Posix_PathconfName__PC_VDISABLE)
 #ifdef _PC_VDISABLE
                {*r = _PC_VDISABLE; return 0;}
 #else /* def _PC_VDISABLE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _PC_VDISABLE */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
-int Mono_Posix_ToPathConf (int x, int *r)
+int Mono_Posix_ToPathconfName (int x, int *r)
 {
        *r = 0;
        if (x == 0)
                return 0;
 #ifdef _PC_2_SYMLINKS
        if (x == _PC_2_SYMLINKS)
-               {*r = Mono_Posix_PathConf__PC_2_SYMLINKS; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_2_SYMLINKS; return 0;}
 #endif /* ndef _PC_2_SYMLINKS */
 #ifdef _PC_ALLOC_SIZE_MIN
        if (x == _PC_ALLOC_SIZE_MIN)
-               {*r = Mono_Posix_PathConf__PC_ALLOC_SIZE_MIN; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_ALLOC_SIZE_MIN; return 0;}
 #endif /* ndef _PC_ALLOC_SIZE_MIN */
 #ifdef _PC_ASYNC_IO
        if (x == _PC_ASYNC_IO)
-               {*r = Mono_Posix_PathConf__PC_ASYNC_IO; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_ASYNC_IO; return 0;}
 #endif /* ndef _PC_ASYNC_IO */
 #ifdef _PC_CHOWN_RESTRICTED
        if (x == _PC_CHOWN_RESTRICTED)
-               {*r = Mono_Posix_PathConf__PC_CHOWN_RESTRICTED; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_CHOWN_RESTRICTED; return 0;}
 #endif /* ndef _PC_CHOWN_RESTRICTED */
 #ifdef _PC_FILESIZEBITS
        if (x == _PC_FILESIZEBITS)
-               {*r = Mono_Posix_PathConf__PC_FILESIZEBITS; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_FILESIZEBITS; return 0;}
 #endif /* ndef _PC_FILESIZEBITS */
 #ifdef _PC_LINK_MAX
        if (x == _PC_LINK_MAX)
-               {*r = Mono_Posix_PathConf__PC_LINK_MAX; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_LINK_MAX; return 0;}
 #endif /* ndef _PC_LINK_MAX */
 #ifdef _PC_MAX_CANON
        if (x == _PC_MAX_CANON)
-               {*r = Mono_Posix_PathConf__PC_MAX_CANON; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_MAX_CANON; return 0;}
 #endif /* ndef _PC_MAX_CANON */
 #ifdef _PC_MAX_INPUT
        if (x == _PC_MAX_INPUT)
-               {*r = Mono_Posix_PathConf__PC_MAX_INPUT; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_MAX_INPUT; return 0;}
 #endif /* ndef _PC_MAX_INPUT */
 #ifdef _PC_NAME_MAX
        if (x == _PC_NAME_MAX)
-               {*r = Mono_Posix_PathConf__PC_NAME_MAX; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_NAME_MAX; return 0;}
 #endif /* ndef _PC_NAME_MAX */
 #ifdef _PC_NO_TRUNC
        if (x == _PC_NO_TRUNC)
-               {*r = Mono_Posix_PathConf__PC_NO_TRUNC; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_NO_TRUNC; return 0;}
 #endif /* ndef _PC_NO_TRUNC */
 #ifdef _PC_PATH_MAX
        if (x == _PC_PATH_MAX)
-               {*r = Mono_Posix_PathConf__PC_PATH_MAX; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_PATH_MAX; return 0;}
 #endif /* ndef _PC_PATH_MAX */
 #ifdef _PC_PIPE_BUF
        if (x == _PC_PIPE_BUF)
-               {*r = Mono_Posix_PathConf__PC_PIPE_BUF; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_PIPE_BUF; return 0;}
 #endif /* ndef _PC_PIPE_BUF */
 #ifdef _PC_PRIO_IO
        if (x == _PC_PRIO_IO)
-               {*r = Mono_Posix_PathConf__PC_PRIO_IO; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_PRIO_IO; return 0;}
 #endif /* ndef _PC_PRIO_IO */
 #ifdef _PC_REC_INCR_XFER_SIZE
        if (x == _PC_REC_INCR_XFER_SIZE)
-               {*r = Mono_Posix_PathConf__PC_REC_INCR_XFER_SIZE; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_REC_INCR_XFER_SIZE; return 0;}
 #endif /* ndef _PC_REC_INCR_XFER_SIZE */
 #ifdef _PC_REC_MAX_XFER_SIZE
        if (x == _PC_REC_MAX_XFER_SIZE)
-               {*r = Mono_Posix_PathConf__PC_REC_MAX_XFER_SIZE; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_REC_MAX_XFER_SIZE; return 0;}
 #endif /* ndef _PC_REC_MAX_XFER_SIZE */
 #ifdef _PC_REC_MIN_XFER_SIZE
        if (x == _PC_REC_MIN_XFER_SIZE)
-               {*r = Mono_Posix_PathConf__PC_REC_MIN_XFER_SIZE; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_REC_MIN_XFER_SIZE; return 0;}
 #endif /* ndef _PC_REC_MIN_XFER_SIZE */
 #ifdef _PC_REC_XFER_ALIGN
        if (x == _PC_REC_XFER_ALIGN)
-               {*r = Mono_Posix_PathConf__PC_REC_XFER_ALIGN; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_REC_XFER_ALIGN; return 0;}
 #endif /* ndef _PC_REC_XFER_ALIGN */
 #ifdef _PC_SOCK_MAXBUF
        if (x == _PC_SOCK_MAXBUF)
-               {*r = Mono_Posix_PathConf__PC_SOCK_MAXBUF; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_SOCK_MAXBUF; return 0;}
 #endif /* ndef _PC_SOCK_MAXBUF */
 #ifdef _PC_SYMLINK_MAX
        if (x == _PC_SYMLINK_MAX)
-               {*r = Mono_Posix_PathConf__PC_SYMLINK_MAX; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_SYMLINK_MAX; return 0;}
 #endif /* ndef _PC_SYMLINK_MAX */
 #ifdef _PC_SYNC_IO
        if (x == _PC_SYNC_IO)
-               {*r = Mono_Posix_PathConf__PC_SYNC_IO; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_SYNC_IO; return 0;}
 #endif /* ndef _PC_SYNC_IO */
 #ifdef _PC_VDISABLE
        if (x == _PC_VDISABLE)
-               {*r = Mono_Posix_PathConf__PC_VDISABLE; return 0;}
+               {*r = Mono_Posix_PathconfName__PC_VDISABLE; return 0;}
 #endif /* ndef _PC_VDISABLE */
        errno = EINVAL; return -1;
 }
@@ -4678,8 +3565,6 @@ int Mono_Posix_ToPathConf (int x, int *r)
 int Mono_Posix_FromPollEvents (short x, short *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_PollEvents_POLLERR) == Mono_Posix_PollEvents_POLLERR)
 #ifdef POLLERR
                *r |= POLLERR;
@@ -4740,6 +3625,8 @@ int Mono_Posix_FromPollEvents (short x, short *r)
 #else /* def POLLWRNORM */
                {errno = EINVAL; return -1;}
 #endif /* ndef POLLWRNORM */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -4791,11 +3678,51 @@ int Mono_Posix_ToPollEvents (short x, short *r)
        return 0;
 }
 
+#ifdef HAVE_STRUCT_POLLFD
+int
+Mono_Posix_FromPollfd (struct Mono_Posix_Pollfd *from, struct pollfd *to)
+{
+       _cnm_return_val_if_overflow (int, from->fd, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       to->fd      = from->fd;
+       if (Mono_Posix_FromPollEvents (from->events, &to->events) != 0) {
+               return -1;
+       }
+       if (Mono_Posix_FromPollEvents (from->revents, &to->revents) != 0) {
+               return -1;
+       }
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_POLLFD */
+
+
+#ifdef HAVE_STRUCT_POLLFD
+int
+Mono_Posix_ToPollfd (struct pollfd *from, struct Mono_Posix_Pollfd *to)
+{
+       _cnm_return_val_if_overflow (int, from->fd, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       to->fd      = from->fd;
+       if (Mono_Posix_ToPollEvents (from->events, &to->events) != 0) {
+               return -1;
+       }
+       if (Mono_Posix_ToPollEvents (from->revents, &to->revents) != 0) {
+               return -1;
+       }
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_POLLFD */
+
+
 int Mono_Posix_FromPosixFadviseAdvice (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if (x == Mono_Posix_PosixFadviseAdvice_POSIX_FADV_DONTNEED)
 #ifdef POSIX_FADV_DONTNEED
                {*r = POSIX_FADV_DONTNEED; return 0;}
@@ -4832,6 +3759,8 @@ int Mono_Posix_FromPosixFadviseAdvice (int x, int *r)
 #else /* def POSIX_FADV_WILLNEED */
                {errno = EINVAL; return -1;}
 #endif /* ndef POSIX_FADV_WILLNEED */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
@@ -4870,8 +3799,6 @@ int Mono_Posix_ToPosixFadviseAdvice (int x, int *r)
 int Mono_Posix_FromPosixMadviseAdvice (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if (x == Mono_Posix_PosixMadviseAdvice_POSIX_MADV_DONTNEED)
 #ifdef POSIX_MADV_DONTNEED
                {*r = POSIX_MADV_DONTNEED; return 0;}
@@ -4902,6 +3829,8 @@ int Mono_Posix_FromPosixMadviseAdvice (int x, int *r)
 #else /* def POSIX_MADV_WILLNEED */
                {errno = EINVAL; return -1;}
 #endif /* ndef POSIX_MADV_WILLNEED */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
@@ -4936,8 +3865,6 @@ int Mono_Posix_ToPosixMadviseAdvice (int x, int *r)
 int Mono_Posix_FromSeekFlags (short x, short *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if (x == Mono_Posix_SeekFlags_L_INCR)
 #ifdef L_INCR
                {*r = L_INCR; return 0;}
@@ -4974,6 +3901,8 @@ int Mono_Posix_FromSeekFlags (short x, short *r)
 #else /* def SEEK_SET */
                {errno = EINVAL; return -1;}
 #endif /* ndef SEEK_SET */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
@@ -5012,8 +3941,6 @@ int Mono_Posix_ToSeekFlags (short x, short *r)
 int Mono_Posix_FromSignum (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if (x == Mono_Posix_Signum_SIGABRT)
 #ifdef SIGABRT
                {*r = SIGABRT; return 0;}
@@ -5224,6 +4151,8 @@ int Mono_Posix_FromSignum (int x, int *r)
 #else /* def SIGXFSZ */
                {errno = EINVAL; return -1;}
 #endif /* ndef SIGXFSZ */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
@@ -5375,2028 +4304,2108 @@ int Mono_Posix_ToSignum (int x, int *r)
        errno = EINVAL; return -1;
 }
 
-int Mono_Posix_FromSysConf (int x, int *r)
+#ifdef HAVE_STRUCT_STAT
+int
+Mono_Posix_FromStat (struct Mono_Posix_Stat *from, struct stat *to)
+{
+       _cnm_return_val_if_overflow (dev_t, from->st_dev, -1);
+       _cnm_return_val_if_overflow (ino_t, from->st_ino, -1);
+       _cnm_return_val_if_overflow (nlink_t, from->st_nlink, -1);
+       _cnm_return_val_if_overflow (uid_t, from->st_uid, -1);
+       _cnm_return_val_if_overflow (gid_t, from->st_gid, -1);
+       _cnm_return_val_if_overflow (dev_t, from->st_rdev, -1);
+       _cnm_return_val_if_overflow (off_t, from->st_size, -1);
+       _cnm_return_val_if_overflow (blksize_t, from->st_blksize, -1);
+       _cnm_return_val_if_overflow (blkcnt_t, from->st_blocks, -1);
+       _cnm_return_val_if_overflow (time_t, from->st_atime_, -1);
+       _cnm_return_val_if_overflow (time_t, from->st_mtime_, -1);
+       _cnm_return_val_if_overflow (time_t, from->st_ctime_, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       to->st_dev     = from->st_dev;
+       to->st_ino     = from->st_ino;
+       if (Mono_Posix_FromFilePermissions (from->st_mode, &to->st_mode) != 0) {
+               return -1;
+       }
+       to->st_nlink   = from->st_nlink;
+       to->st_uid     = from->st_uid;
+       to->st_gid     = from->st_gid;
+       to->st_rdev    = from->st_rdev;
+       to->st_size    = from->st_size;
+       to->st_blksize = from->st_blksize;
+       to->st_blocks  = from->st_blocks;
+       to->st_atime   = from->st_atime_;
+       to->st_mtime   = from->st_mtime_;
+       to->st_ctime   = from->st_ctime_;
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_STAT */
+
+
+#ifdef HAVE_STRUCT_STAT
+int
+Mono_Posix_ToStat (struct stat *from, struct Mono_Posix_Stat *to)
+{
+       _cnm_return_val_if_overflow (guint64, from->st_dev, -1);
+       _cnm_return_val_if_overflow (guint64, from->st_ino, -1);
+       _cnm_return_val_if_overflow (guint64, from->st_nlink, -1);
+       _cnm_return_val_if_overflow (unsigned int, from->st_uid, -1);
+       _cnm_return_val_if_overflow (unsigned int, from->st_gid, -1);
+       _cnm_return_val_if_overflow (guint64, from->st_rdev, -1);
+       _cnm_return_val_if_overflow (gint64, from->st_size, -1);
+       _cnm_return_val_if_overflow (gint64, from->st_blksize, -1);
+       _cnm_return_val_if_overflow (gint64, from->st_blocks, -1);
+       _cnm_return_val_if_overflow (gint64, from->st_atime, -1);
+       _cnm_return_val_if_overflow (gint64, from->st_mtime, -1);
+       _cnm_return_val_if_overflow (gint64, from->st_ctime, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       to->st_dev     = from->st_dev;
+       to->st_ino     = from->st_ino;
+       if (Mono_Posix_ToFilePermissions (from->st_mode, &to->st_mode) != 0) {
+               return -1;
+       }
+       to->st_nlink   = from->st_nlink;
+       to->st_uid     = from->st_uid;
+       to->st_gid     = from->st_gid;
+       to->st_rdev    = from->st_rdev;
+       to->st_size    = from->st_size;
+       to->st_blksize = from->st_blksize;
+       to->st_blocks  = from->st_blocks;
+       to->st_atime_  = from->st_atime;
+       to->st_mtime_  = from->st_mtime;
+       to->st_ctime_  = from->st_ctime;
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_STAT */
+
+
+int Mono_Posix_FromSysconfName (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
-       if (x == Mono_Posix_SysConf__SC_2_CHAR_TERM)
+       if (x == Mono_Posix_SysconfName__SC_2_CHAR_TERM)
 #ifdef _SC_2_CHAR_TERM
                {*r = _SC_2_CHAR_TERM; return 0;}
 #else /* def _SC_2_CHAR_TERM */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_CHAR_TERM */
-       if (x == Mono_Posix_SysConf__SC_2_C_BIND)
+       if (x == Mono_Posix_SysconfName__SC_2_C_BIND)
 #ifdef _SC_2_C_BIND
                {*r = _SC_2_C_BIND; return 0;}
 #else /* def _SC_2_C_BIND */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_C_BIND */
-       if (x == Mono_Posix_SysConf__SC_2_C_DEV)
+       if (x == Mono_Posix_SysconfName__SC_2_C_DEV)
 #ifdef _SC_2_C_DEV
                {*r = _SC_2_C_DEV; return 0;}
 #else /* def _SC_2_C_DEV */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_C_DEV */
-       if (x == Mono_Posix_SysConf__SC_2_C_VERSION)
+       if (x == Mono_Posix_SysconfName__SC_2_C_VERSION)
 #ifdef _SC_2_C_VERSION
                {*r = _SC_2_C_VERSION; return 0;}
 #else /* def _SC_2_C_VERSION */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_C_VERSION */
-       if (x == Mono_Posix_SysConf__SC_2_FORT_DEV)
+       if (x == Mono_Posix_SysconfName__SC_2_FORT_DEV)
 #ifdef _SC_2_FORT_DEV
                {*r = _SC_2_FORT_DEV; return 0;}
 #else /* def _SC_2_FORT_DEV */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_FORT_DEV */
-       if (x == Mono_Posix_SysConf__SC_2_FORT_RUN)
+       if (x == Mono_Posix_SysconfName__SC_2_FORT_RUN)
 #ifdef _SC_2_FORT_RUN
                {*r = _SC_2_FORT_RUN; return 0;}
 #else /* def _SC_2_FORT_RUN */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_FORT_RUN */
-       if (x == Mono_Posix_SysConf__SC_2_LOCALEDEF)
+       if (x == Mono_Posix_SysconfName__SC_2_LOCALEDEF)
 #ifdef _SC_2_LOCALEDEF
                {*r = _SC_2_LOCALEDEF; return 0;}
 #else /* def _SC_2_LOCALEDEF */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_LOCALEDEF */
-       if (x == Mono_Posix_SysConf__SC_2_PBS)
+       if (x == Mono_Posix_SysconfName__SC_2_PBS)
 #ifdef _SC_2_PBS
                {*r = _SC_2_PBS; return 0;}
 #else /* def _SC_2_PBS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_PBS */
-       if (x == Mono_Posix_SysConf__SC_2_PBS_ACCOUNTING)
+       if (x == Mono_Posix_SysconfName__SC_2_PBS_ACCOUNTING)
 #ifdef _SC_2_PBS_ACCOUNTING
                {*r = _SC_2_PBS_ACCOUNTING; return 0;}
 #else /* def _SC_2_PBS_ACCOUNTING */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_PBS_ACCOUNTING */
-       if (x == Mono_Posix_SysConf__SC_2_PBS_CHECKPOINT)
+       if (x == Mono_Posix_SysconfName__SC_2_PBS_CHECKPOINT)
 #ifdef _SC_2_PBS_CHECKPOINT
                {*r = _SC_2_PBS_CHECKPOINT; return 0;}
 #else /* def _SC_2_PBS_CHECKPOINT */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_PBS_CHECKPOINT */
-       if (x == Mono_Posix_SysConf__SC_2_PBS_LOCATE)
+       if (x == Mono_Posix_SysconfName__SC_2_PBS_LOCATE)
 #ifdef _SC_2_PBS_LOCATE
                {*r = _SC_2_PBS_LOCATE; return 0;}
 #else /* def _SC_2_PBS_LOCATE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_PBS_LOCATE */
-       if (x == Mono_Posix_SysConf__SC_2_PBS_MESSAGE)
+       if (x == Mono_Posix_SysconfName__SC_2_PBS_MESSAGE)
 #ifdef _SC_2_PBS_MESSAGE
                {*r = _SC_2_PBS_MESSAGE; return 0;}
 #else /* def _SC_2_PBS_MESSAGE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_PBS_MESSAGE */
-       if (x == Mono_Posix_SysConf__SC_2_PBS_TRACK)
+       if (x == Mono_Posix_SysconfName__SC_2_PBS_TRACK)
 #ifdef _SC_2_PBS_TRACK
                {*r = _SC_2_PBS_TRACK; return 0;}
 #else /* def _SC_2_PBS_TRACK */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_PBS_TRACK */
-       if (x == Mono_Posix_SysConf__SC_2_SW_DEV)
+       if (x == Mono_Posix_SysconfName__SC_2_SW_DEV)
 #ifdef _SC_2_SW_DEV
                {*r = _SC_2_SW_DEV; return 0;}
 #else /* def _SC_2_SW_DEV */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_SW_DEV */
-       if (x == Mono_Posix_SysConf__SC_2_UPE)
+       if (x == Mono_Posix_SysconfName__SC_2_UPE)
 #ifdef _SC_2_UPE
                {*r = _SC_2_UPE; return 0;}
 #else /* def _SC_2_UPE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_UPE */
-       if (x == Mono_Posix_SysConf__SC_2_VERSION)
+       if (x == Mono_Posix_SysconfName__SC_2_VERSION)
 #ifdef _SC_2_VERSION
                {*r = _SC_2_VERSION; return 0;}
 #else /* def _SC_2_VERSION */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_2_VERSION */
-       if (x == Mono_Posix_SysConf__SC_ADVISORY_INFO)
+       if (x == Mono_Posix_SysconfName__SC_ADVISORY_INFO)
 #ifdef _SC_ADVISORY_INFO
                {*r = _SC_ADVISORY_INFO; return 0;}
 #else /* def _SC_ADVISORY_INFO */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_ADVISORY_INFO */
-       if (x == Mono_Posix_SysConf__SC_AIO_LISTIO_MAX)
+       if (x == Mono_Posix_SysconfName__SC_AIO_LISTIO_MAX)
 #ifdef _SC_AIO_LISTIO_MAX
                {*r = _SC_AIO_LISTIO_MAX; return 0;}
 #else /* def _SC_AIO_LISTIO_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_AIO_LISTIO_MAX */
-       if (x == Mono_Posix_SysConf__SC_AIO_MAX)
+       if (x == Mono_Posix_SysconfName__SC_AIO_MAX)
 #ifdef _SC_AIO_MAX
                {*r = _SC_AIO_MAX; return 0;}
 #else /* def _SC_AIO_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_AIO_MAX */
-       if (x == Mono_Posix_SysConf__SC_AIO_PRIO_DELTA_MAX)
+       if (x == Mono_Posix_SysconfName__SC_AIO_PRIO_DELTA_MAX)
 #ifdef _SC_AIO_PRIO_DELTA_MAX
                {*r = _SC_AIO_PRIO_DELTA_MAX; return 0;}
 #else /* def _SC_AIO_PRIO_DELTA_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_AIO_PRIO_DELTA_MAX */
-       if (x == Mono_Posix_SysConf__SC_ARG_MAX)
+       if (x == Mono_Posix_SysconfName__SC_ARG_MAX)
 #ifdef _SC_ARG_MAX
                {*r = _SC_ARG_MAX; return 0;}
 #else /* def _SC_ARG_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_ARG_MAX */
-       if (x == Mono_Posix_SysConf__SC_ASYNCHRONOUS_IO)
+       if (x == Mono_Posix_SysconfName__SC_ASYNCHRONOUS_IO)
 #ifdef _SC_ASYNCHRONOUS_IO
                {*r = _SC_ASYNCHRONOUS_IO; return 0;}
 #else /* def _SC_ASYNCHRONOUS_IO */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_ASYNCHRONOUS_IO */
-       if (x == Mono_Posix_SysConf__SC_ATEXIT_MAX)
+       if (x == Mono_Posix_SysconfName__SC_ATEXIT_MAX)
 #ifdef _SC_ATEXIT_MAX
                {*r = _SC_ATEXIT_MAX; return 0;}
 #else /* def _SC_ATEXIT_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_ATEXIT_MAX */
-       if (x == Mono_Posix_SysConf__SC_AVPHYS_PAGES)
+       if (x == Mono_Posix_SysconfName__SC_AVPHYS_PAGES)
 #ifdef _SC_AVPHYS_PAGES
                {*r = _SC_AVPHYS_PAGES; return 0;}
 #else /* def _SC_AVPHYS_PAGES */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_AVPHYS_PAGES */
-       if (x == Mono_Posix_SysConf__SC_BARRIERS)
+       if (x == Mono_Posix_SysconfName__SC_BARRIERS)
 #ifdef _SC_BARRIERS
                {*r = _SC_BARRIERS; return 0;}
 #else /* def _SC_BARRIERS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_BARRIERS */
-       if (x == Mono_Posix_SysConf__SC_BASE)
+       if (x == Mono_Posix_SysconfName__SC_BASE)
 #ifdef _SC_BASE
                {*r = _SC_BASE; return 0;}
 #else /* def _SC_BASE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_BASE */
-       if (x == Mono_Posix_SysConf__SC_BC_BASE_MAX)
+       if (x == Mono_Posix_SysconfName__SC_BC_BASE_MAX)
 #ifdef _SC_BC_BASE_MAX
                {*r = _SC_BC_BASE_MAX; return 0;}
 #else /* def _SC_BC_BASE_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_BC_BASE_MAX */
-       if (x == Mono_Posix_SysConf__SC_BC_DIM_MAX)
+       if (x == Mono_Posix_SysconfName__SC_BC_DIM_MAX)
 #ifdef _SC_BC_DIM_MAX
                {*r = _SC_BC_DIM_MAX; return 0;}
 #else /* def _SC_BC_DIM_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_BC_DIM_MAX */
-       if (x == Mono_Posix_SysConf__SC_BC_SCALE_MAX)
+       if (x == Mono_Posix_SysconfName__SC_BC_SCALE_MAX)
 #ifdef _SC_BC_SCALE_MAX
                {*r = _SC_BC_SCALE_MAX; return 0;}
 #else /* def _SC_BC_SCALE_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_BC_SCALE_MAX */
-       if (x == Mono_Posix_SysConf__SC_BC_STRING_MAX)
+       if (x == Mono_Posix_SysconfName__SC_BC_STRING_MAX)
 #ifdef _SC_BC_STRING_MAX
                {*r = _SC_BC_STRING_MAX; return 0;}
 #else /* def _SC_BC_STRING_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_BC_STRING_MAX */
-       if (x == Mono_Posix_SysConf__SC_CHARCLASS_NAME_MAX)
+       if (x == Mono_Posix_SysconfName__SC_CHARCLASS_NAME_MAX)
 #ifdef _SC_CHARCLASS_NAME_MAX
                {*r = _SC_CHARCLASS_NAME_MAX; return 0;}
 #else /* def _SC_CHARCLASS_NAME_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_CHARCLASS_NAME_MAX */
-       if (x == Mono_Posix_SysConf__SC_CHAR_BIT)
+       if (x == Mono_Posix_SysconfName__SC_CHAR_BIT)
 #ifdef _SC_CHAR_BIT
                {*r = _SC_CHAR_BIT; return 0;}
 #else /* def _SC_CHAR_BIT */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_CHAR_BIT */
-       if (x == Mono_Posix_SysConf__SC_CHAR_MAX)
+       if (x == Mono_Posix_SysconfName__SC_CHAR_MAX)
 #ifdef _SC_CHAR_MAX
                {*r = _SC_CHAR_MAX; return 0;}
 #else /* def _SC_CHAR_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_CHAR_MAX */
-       if (x == Mono_Posix_SysConf__SC_CHAR_MIN)
+       if (x == Mono_Posix_SysconfName__SC_CHAR_MIN)
 #ifdef _SC_CHAR_MIN
                {*r = _SC_CHAR_MIN; return 0;}
 #else /* def _SC_CHAR_MIN */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_CHAR_MIN */
-       if (x == Mono_Posix_SysConf__SC_CHILD_MAX)
+       if (x == Mono_Posix_SysconfName__SC_CHILD_MAX)
 #ifdef _SC_CHILD_MAX
                {*r = _SC_CHILD_MAX; return 0;}
 #else /* def _SC_CHILD_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_CHILD_MAX */
-       if (x == Mono_Posix_SysConf__SC_CLK_TCK)
+       if (x == Mono_Posix_SysconfName__SC_CLK_TCK)
 #ifdef _SC_CLK_TCK
                {*r = _SC_CLK_TCK; return 0;}
 #else /* def _SC_CLK_TCK */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_CLK_TCK */
-       if (x == Mono_Posix_SysConf__SC_CLOCK_SELECTION)
+       if (x == Mono_Posix_SysconfName__SC_CLOCK_SELECTION)
 #ifdef _SC_CLOCK_SELECTION
                {*r = _SC_CLOCK_SELECTION; return 0;}
 #else /* def _SC_CLOCK_SELECTION */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_CLOCK_SELECTION */
-       if (x == Mono_Posix_SysConf__SC_COLL_WEIGHTS_MAX)
+       if (x == Mono_Posix_SysconfName__SC_COLL_WEIGHTS_MAX)
 #ifdef _SC_COLL_WEIGHTS_MAX
                {*r = _SC_COLL_WEIGHTS_MAX; return 0;}
 #else /* def _SC_COLL_WEIGHTS_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_COLL_WEIGHTS_MAX */
-       if (x == Mono_Posix_SysConf__SC_CPUTIME)
+       if (x == Mono_Posix_SysconfName__SC_CPUTIME)
 #ifdef _SC_CPUTIME
                {*r = _SC_CPUTIME; return 0;}
 #else /* def _SC_CPUTIME */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_CPUTIME */
-       if (x == Mono_Posix_SysConf__SC_C_LANG_SUPPORT)
+       if (x == Mono_Posix_SysconfName__SC_C_LANG_SUPPORT)
 #ifdef _SC_C_LANG_SUPPORT
                {*r = _SC_C_LANG_SUPPORT; return 0;}
 #else /* def _SC_C_LANG_SUPPORT */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_C_LANG_SUPPORT */
-       if (x == Mono_Posix_SysConf__SC_C_LANG_SUPPORT_R)
+       if (x == Mono_Posix_SysconfName__SC_C_LANG_SUPPORT_R)
 #ifdef _SC_C_LANG_SUPPORT_R
                {*r = _SC_C_LANG_SUPPORT_R; return 0;}
 #else /* def _SC_C_LANG_SUPPORT_R */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_C_LANG_SUPPORT_R */
-       if (x == Mono_Posix_SysConf__SC_DELAYTIMER_MAX)
+       if (x == Mono_Posix_SysconfName__SC_DELAYTIMER_MAX)
 #ifdef _SC_DELAYTIMER_MAX
                {*r = _SC_DELAYTIMER_MAX; return 0;}
 #else /* def _SC_DELAYTIMER_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_DELAYTIMER_MAX */
-       if (x == Mono_Posix_SysConf__SC_DEVICE_IO)
+       if (x == Mono_Posix_SysconfName__SC_DEVICE_IO)
 #ifdef _SC_DEVICE_IO
                {*r = _SC_DEVICE_IO; return 0;}
 #else /* def _SC_DEVICE_IO */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_DEVICE_IO */
-       if (x == Mono_Posix_SysConf__SC_DEVICE_SPECIFIC)
+       if (x == Mono_Posix_SysconfName__SC_DEVICE_SPECIFIC)
 #ifdef _SC_DEVICE_SPECIFIC
                {*r = _SC_DEVICE_SPECIFIC; return 0;}
 #else /* def _SC_DEVICE_SPECIFIC */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_DEVICE_SPECIFIC */
-       if (x == Mono_Posix_SysConf__SC_DEVICE_SPECIFIC_R)
+       if (x == Mono_Posix_SysconfName__SC_DEVICE_SPECIFIC_R)
 #ifdef _SC_DEVICE_SPECIFIC_R
                {*r = _SC_DEVICE_SPECIFIC_R; return 0;}
 #else /* def _SC_DEVICE_SPECIFIC_R */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_DEVICE_SPECIFIC_R */
-       if (x == Mono_Posix_SysConf__SC_EQUIV_CLASS_MAX)
+       if (x == Mono_Posix_SysconfName__SC_EQUIV_CLASS_MAX)
 #ifdef _SC_EQUIV_CLASS_MAX
                {*r = _SC_EQUIV_CLASS_MAX; return 0;}
 #else /* def _SC_EQUIV_CLASS_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_EQUIV_CLASS_MAX */
-       if (x == Mono_Posix_SysConf__SC_EXPR_NEST_MAX)
+       if (x == Mono_Posix_SysconfName__SC_EXPR_NEST_MAX)
 #ifdef _SC_EXPR_NEST_MAX
                {*r = _SC_EXPR_NEST_MAX; return 0;}
 #else /* def _SC_EXPR_NEST_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_EXPR_NEST_MAX */
-       if (x == Mono_Posix_SysConf__SC_FD_MGMT)
+       if (x == Mono_Posix_SysconfName__SC_FD_MGMT)
 #ifdef _SC_FD_MGMT
                {*r = _SC_FD_MGMT; return 0;}
 #else /* def _SC_FD_MGMT */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_FD_MGMT */
-       if (x == Mono_Posix_SysConf__SC_FIFO)
+       if (x == Mono_Posix_SysconfName__SC_FIFO)
 #ifdef _SC_FIFO
                {*r = _SC_FIFO; return 0;}
 #else /* def _SC_FIFO */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_FIFO */
-       if (x == Mono_Posix_SysConf__SC_FILE_ATTRIBUTES)
+       if (x == Mono_Posix_SysconfName__SC_FILE_ATTRIBUTES)
 #ifdef _SC_FILE_ATTRIBUTES
                {*r = _SC_FILE_ATTRIBUTES; return 0;}
 #else /* def _SC_FILE_ATTRIBUTES */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_FILE_ATTRIBUTES */
-       if (x == Mono_Posix_SysConf__SC_FILE_LOCKING)
+       if (x == Mono_Posix_SysconfName__SC_FILE_LOCKING)
 #ifdef _SC_FILE_LOCKING
                {*r = _SC_FILE_LOCKING; return 0;}
 #else /* def _SC_FILE_LOCKING */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_FILE_LOCKING */
-       if (x == Mono_Posix_SysConf__SC_FILE_SYSTEM)
+       if (x == Mono_Posix_SysconfName__SC_FILE_SYSTEM)
 #ifdef _SC_FILE_SYSTEM
                {*r = _SC_FILE_SYSTEM; return 0;}
 #else /* def _SC_FILE_SYSTEM */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_FILE_SYSTEM */
-       if (x == Mono_Posix_SysConf__SC_FSYNC)
+       if (x == Mono_Posix_SysconfName__SC_FSYNC)
 #ifdef _SC_FSYNC
                {*r = _SC_FSYNC; return 0;}
 #else /* def _SC_FSYNC */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_FSYNC */
-       if (x == Mono_Posix_SysConf__SC_GETGR_R_SIZE_MAX)
+       if (x == Mono_Posix_SysconfName__SC_GETGR_R_SIZE_MAX)
 #ifdef _SC_GETGR_R_SIZE_MAX
                {*r = _SC_GETGR_R_SIZE_MAX; return 0;}
 #else /* def _SC_GETGR_R_SIZE_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_GETGR_R_SIZE_MAX */
-       if (x == Mono_Posix_SysConf__SC_GETPW_R_SIZE_MAX)
+       if (x == Mono_Posix_SysconfName__SC_GETPW_R_SIZE_MAX)
 #ifdef _SC_GETPW_R_SIZE_MAX
                {*r = _SC_GETPW_R_SIZE_MAX; return 0;}
 #else /* def _SC_GETPW_R_SIZE_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_GETPW_R_SIZE_MAX */
-       if (x == Mono_Posix_SysConf__SC_HOST_NAME_MAX)
+       if (x == Mono_Posix_SysconfName__SC_HOST_NAME_MAX)
 #ifdef _SC_HOST_NAME_MAX
                {*r = _SC_HOST_NAME_MAX; return 0;}
 #else /* def _SC_HOST_NAME_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_HOST_NAME_MAX */
-       if (x == Mono_Posix_SysConf__SC_INT_MAX)
+       if (x == Mono_Posix_SysconfName__SC_INT_MAX)
 #ifdef _SC_INT_MAX
                {*r = _SC_INT_MAX; return 0;}
 #else /* def _SC_INT_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_INT_MAX */
-       if (x == Mono_Posix_SysConf__SC_INT_MIN)
+       if (x == Mono_Posix_SysconfName__SC_INT_MIN)
 #ifdef _SC_INT_MIN
                {*r = _SC_INT_MIN; return 0;}
 #else /* def _SC_INT_MIN */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_INT_MIN */
-       if (x == Mono_Posix_SysConf__SC_IOV_MAX)
+       if (x == Mono_Posix_SysconfName__SC_IOV_MAX)
 #ifdef _SC_IOV_MAX
                {*r = _SC_IOV_MAX; return 0;}
 #else /* def _SC_IOV_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_IOV_MAX */
-       if (x == Mono_Posix_SysConf__SC_JOB_CONTROL)
+       if (x == Mono_Posix_SysconfName__SC_JOB_CONTROL)
 #ifdef _SC_JOB_CONTROL
                {*r = _SC_JOB_CONTROL; return 0;}
 #else /* def _SC_JOB_CONTROL */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_JOB_CONTROL */
-       if (x == Mono_Posix_SysConf__SC_LEVEL1_DCACHE_ASSOC)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL1_DCACHE_ASSOC)
 #ifdef _SC_LEVEL1_DCACHE_ASSOC
                {*r = _SC_LEVEL1_DCACHE_ASSOC; return 0;}
 #else /* def _SC_LEVEL1_DCACHE_ASSOC */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL1_DCACHE_ASSOC */
-       if (x == Mono_Posix_SysConf__SC_LEVEL1_DCACHE_LINESIZE)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL1_DCACHE_LINESIZE)
 #ifdef _SC_LEVEL1_DCACHE_LINESIZE
                {*r = _SC_LEVEL1_DCACHE_LINESIZE; return 0;}
 #else /* def _SC_LEVEL1_DCACHE_LINESIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL1_DCACHE_LINESIZE */
-       if (x == Mono_Posix_SysConf__SC_LEVEL1_DCACHE_SIZE)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL1_DCACHE_SIZE)
 #ifdef _SC_LEVEL1_DCACHE_SIZE
                {*r = _SC_LEVEL1_DCACHE_SIZE; return 0;}
 #else /* def _SC_LEVEL1_DCACHE_SIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL1_DCACHE_SIZE */
-       if (x == Mono_Posix_SysConf__SC_LEVEL1_ICACHE_ASSOC)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL1_ICACHE_ASSOC)
 #ifdef _SC_LEVEL1_ICACHE_ASSOC
                {*r = _SC_LEVEL1_ICACHE_ASSOC; return 0;}
 #else /* def _SC_LEVEL1_ICACHE_ASSOC */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL1_ICACHE_ASSOC */
-       if (x == Mono_Posix_SysConf__SC_LEVEL1_ICACHE_LINESIZE)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL1_ICACHE_LINESIZE)
 #ifdef _SC_LEVEL1_ICACHE_LINESIZE
                {*r = _SC_LEVEL1_ICACHE_LINESIZE; return 0;}
 #else /* def _SC_LEVEL1_ICACHE_LINESIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL1_ICACHE_LINESIZE */
-       if (x == Mono_Posix_SysConf__SC_LEVEL1_ICACHE_SIZE)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL1_ICACHE_SIZE)
 #ifdef _SC_LEVEL1_ICACHE_SIZE
                {*r = _SC_LEVEL1_ICACHE_SIZE; return 0;}
 #else /* def _SC_LEVEL1_ICACHE_SIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL1_ICACHE_SIZE */
-       if (x == Mono_Posix_SysConf__SC_LEVEL2_CACHE_ASSOC)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL2_CACHE_ASSOC)
 #ifdef _SC_LEVEL2_CACHE_ASSOC
                {*r = _SC_LEVEL2_CACHE_ASSOC; return 0;}
 #else /* def _SC_LEVEL2_CACHE_ASSOC */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL2_CACHE_ASSOC */
-       if (x == Mono_Posix_SysConf__SC_LEVEL2_CACHE_LINESIZE)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL2_CACHE_LINESIZE)
 #ifdef _SC_LEVEL2_CACHE_LINESIZE
                {*r = _SC_LEVEL2_CACHE_LINESIZE; return 0;}
 #else /* def _SC_LEVEL2_CACHE_LINESIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL2_CACHE_LINESIZE */
-       if (x == Mono_Posix_SysConf__SC_LEVEL2_CACHE_SIZE)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL2_CACHE_SIZE)
 #ifdef _SC_LEVEL2_CACHE_SIZE
                {*r = _SC_LEVEL2_CACHE_SIZE; return 0;}
 #else /* def _SC_LEVEL2_CACHE_SIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL2_CACHE_SIZE */
-       if (x == Mono_Posix_SysConf__SC_LEVEL3_CACHE_ASSOC)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL3_CACHE_ASSOC)
 #ifdef _SC_LEVEL3_CACHE_ASSOC
                {*r = _SC_LEVEL3_CACHE_ASSOC; return 0;}
 #else /* def _SC_LEVEL3_CACHE_ASSOC */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL3_CACHE_ASSOC */
-       if (x == Mono_Posix_SysConf__SC_LEVEL3_CACHE_LINESIZE)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL3_CACHE_LINESIZE)
 #ifdef _SC_LEVEL3_CACHE_LINESIZE
                {*r = _SC_LEVEL3_CACHE_LINESIZE; return 0;}
 #else /* def _SC_LEVEL3_CACHE_LINESIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL3_CACHE_LINESIZE */
-       if (x == Mono_Posix_SysConf__SC_LEVEL3_CACHE_SIZE)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL3_CACHE_SIZE)
 #ifdef _SC_LEVEL3_CACHE_SIZE
                {*r = _SC_LEVEL3_CACHE_SIZE; return 0;}
 #else /* def _SC_LEVEL3_CACHE_SIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL3_CACHE_SIZE */
-       if (x == Mono_Posix_SysConf__SC_LEVEL4_CACHE_ASSOC)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL4_CACHE_ASSOC)
 #ifdef _SC_LEVEL4_CACHE_ASSOC
                {*r = _SC_LEVEL4_CACHE_ASSOC; return 0;}
 #else /* def _SC_LEVEL4_CACHE_ASSOC */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL4_CACHE_ASSOC */
-       if (x == Mono_Posix_SysConf__SC_LEVEL4_CACHE_LINESIZE)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL4_CACHE_LINESIZE)
 #ifdef _SC_LEVEL4_CACHE_LINESIZE
                {*r = _SC_LEVEL4_CACHE_LINESIZE; return 0;}
 #else /* def _SC_LEVEL4_CACHE_LINESIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL4_CACHE_LINESIZE */
-       if (x == Mono_Posix_SysConf__SC_LEVEL4_CACHE_SIZE)
+       if (x == Mono_Posix_SysconfName__SC_LEVEL4_CACHE_SIZE)
 #ifdef _SC_LEVEL4_CACHE_SIZE
                {*r = _SC_LEVEL4_CACHE_SIZE; return 0;}
 #else /* def _SC_LEVEL4_CACHE_SIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LEVEL4_CACHE_SIZE */
-       if (x == Mono_Posix_SysConf__SC_LINE_MAX)
+       if (x == Mono_Posix_SysconfName__SC_LINE_MAX)
 #ifdef _SC_LINE_MAX
                {*r = _SC_LINE_MAX; return 0;}
 #else /* def _SC_LINE_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LINE_MAX */
-       if (x == Mono_Posix_SysConf__SC_LOGIN_NAME_MAX)
+       if (x == Mono_Posix_SysconfName__SC_LOGIN_NAME_MAX)
 #ifdef _SC_LOGIN_NAME_MAX
                {*r = _SC_LOGIN_NAME_MAX; return 0;}
 #else /* def _SC_LOGIN_NAME_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LOGIN_NAME_MAX */
-       if (x == Mono_Posix_SysConf__SC_LONG_BIT)
+       if (x == Mono_Posix_SysconfName__SC_LONG_BIT)
 #ifdef _SC_LONG_BIT
                {*r = _SC_LONG_BIT; return 0;}
 #else /* def _SC_LONG_BIT */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_LONG_BIT */
-       if (x == Mono_Posix_SysConf__SC_MAPPED_FILES)
+       if (x == Mono_Posix_SysconfName__SC_MAPPED_FILES)
 #ifdef _SC_MAPPED_FILES
                {*r = _SC_MAPPED_FILES; return 0;}
 #else /* def _SC_MAPPED_FILES */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_MAPPED_FILES */
-       if (x == Mono_Posix_SysConf__SC_MB_LEN_MAX)
+       if (x == Mono_Posix_SysconfName__SC_MB_LEN_MAX)
 #ifdef _SC_MB_LEN_MAX
                {*r = _SC_MB_LEN_MAX; return 0;}
 #else /* def _SC_MB_LEN_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_MB_LEN_MAX */
-       if (x == Mono_Posix_SysConf__SC_MEMLOCK)
+       if (x == Mono_Posix_SysconfName__SC_MEMLOCK)
 #ifdef _SC_MEMLOCK
                {*r = _SC_MEMLOCK; return 0;}
 #else /* def _SC_MEMLOCK */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_MEMLOCK */
-       if (x == Mono_Posix_SysConf__SC_MEMLOCK_RANGE)
+       if (x == Mono_Posix_SysconfName__SC_MEMLOCK_RANGE)
 #ifdef _SC_MEMLOCK_RANGE
                {*r = _SC_MEMLOCK_RANGE; return 0;}
 #else /* def _SC_MEMLOCK_RANGE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_MEMLOCK_RANGE */
-       if (x == Mono_Posix_SysConf__SC_MEMORY_PROTECTION)
+       if (x == Mono_Posix_SysconfName__SC_MEMORY_PROTECTION)
 #ifdef _SC_MEMORY_PROTECTION
                {*r = _SC_MEMORY_PROTECTION; return 0;}
 #else /* def _SC_MEMORY_PROTECTION */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_MEMORY_PROTECTION */
-       if (x == Mono_Posix_SysConf__SC_MESSAGE_PASSING)
+       if (x == Mono_Posix_SysconfName__SC_MESSAGE_PASSING)
 #ifdef _SC_MESSAGE_PASSING
                {*r = _SC_MESSAGE_PASSING; return 0;}
 #else /* def _SC_MESSAGE_PASSING */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_MESSAGE_PASSING */
-       if (x == Mono_Posix_SysConf__SC_MONOTONIC_CLOCK)
+       if (x == Mono_Posix_SysconfName__SC_MONOTONIC_CLOCK)
 #ifdef _SC_MONOTONIC_CLOCK
                {*r = _SC_MONOTONIC_CLOCK; return 0;}
 #else /* def _SC_MONOTONIC_CLOCK */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_MONOTONIC_CLOCK */
-       if (x == Mono_Posix_SysConf__SC_MQ_OPEN_MAX)
+       if (x == Mono_Posix_SysconfName__SC_MQ_OPEN_MAX)
 #ifdef _SC_MQ_OPEN_MAX
                {*r = _SC_MQ_OPEN_MAX; return 0;}
 #else /* def _SC_MQ_OPEN_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_MQ_OPEN_MAX */
-       if (x == Mono_Posix_SysConf__SC_MQ_PRIO_MAX)
+       if (x == Mono_Posix_SysconfName__SC_MQ_PRIO_MAX)
 #ifdef _SC_MQ_PRIO_MAX
                {*r = _SC_MQ_PRIO_MAX; return 0;}
 #else /* def _SC_MQ_PRIO_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_MQ_PRIO_MAX */
-       if (x == Mono_Posix_SysConf__SC_MULTI_PROCESS)
+       if (x == Mono_Posix_SysconfName__SC_MULTI_PROCESS)
 #ifdef _SC_MULTI_PROCESS
                {*r = _SC_MULTI_PROCESS; return 0;}
 #else /* def _SC_MULTI_PROCESS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_MULTI_PROCESS */
-       if (x == Mono_Posix_SysConf__SC_NETWORKING)
+       if (x == Mono_Posix_SysconfName__SC_NETWORKING)
 #ifdef _SC_NETWORKING
                {*r = _SC_NETWORKING; return 0;}
 #else /* def _SC_NETWORKING */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_NETWORKING */
-       if (x == Mono_Posix_SysConf__SC_NGROUPS_MAX)
+       if (x == Mono_Posix_SysconfName__SC_NGROUPS_MAX)
 #ifdef _SC_NGROUPS_MAX
                {*r = _SC_NGROUPS_MAX; return 0;}
 #else /* def _SC_NGROUPS_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_NGROUPS_MAX */
-       if (x == Mono_Posix_SysConf__SC_NL_ARGMAX)
+       if (x == Mono_Posix_SysconfName__SC_NL_ARGMAX)
 #ifdef _SC_NL_ARGMAX
                {*r = _SC_NL_ARGMAX; return 0;}
 #else /* def _SC_NL_ARGMAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_NL_ARGMAX */
-       if (x == Mono_Posix_SysConf__SC_NL_LANGMAX)
+       if (x == Mono_Posix_SysconfName__SC_NL_LANGMAX)
 #ifdef _SC_NL_LANGMAX
                {*r = _SC_NL_LANGMAX; return 0;}
 #else /* def _SC_NL_LANGMAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_NL_LANGMAX */
-       if (x == Mono_Posix_SysConf__SC_NL_MSGMAX)
+       if (x == Mono_Posix_SysconfName__SC_NL_MSGMAX)
 #ifdef _SC_NL_MSGMAX
                {*r = _SC_NL_MSGMAX; return 0;}
 #else /* def _SC_NL_MSGMAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_NL_MSGMAX */
-       if (x == Mono_Posix_SysConf__SC_NL_NMAX)
+       if (x == Mono_Posix_SysconfName__SC_NL_NMAX)
 #ifdef _SC_NL_NMAX
                {*r = _SC_NL_NMAX; return 0;}
 #else /* def _SC_NL_NMAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_NL_NMAX */
-       if (x == Mono_Posix_SysConf__SC_NL_SETMAX)
+       if (x == Mono_Posix_SysconfName__SC_NL_SETMAX)
 #ifdef _SC_NL_SETMAX
                {*r = _SC_NL_SETMAX; return 0;}
 #else /* def _SC_NL_SETMAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_NL_SETMAX */
-       if (x == Mono_Posix_SysConf__SC_NL_TEXTMAX)
+       if (x == Mono_Posix_SysconfName__SC_NL_TEXTMAX)
 #ifdef _SC_NL_TEXTMAX
                {*r = _SC_NL_TEXTMAX; return 0;}
 #else /* def _SC_NL_TEXTMAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_NL_TEXTMAX */
-       if (x == Mono_Posix_SysConf__SC_NPROCESSORS_CONF)
+       if (x == Mono_Posix_SysconfName__SC_NPROCESSORS_CONF)
 #ifdef _SC_NPROCESSORS_CONF
                {*r = _SC_NPROCESSORS_CONF; return 0;}
 #else /* def _SC_NPROCESSORS_CONF */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_NPROCESSORS_CONF */
-       if (x == Mono_Posix_SysConf__SC_NPROCESSORS_ONLN)
+       if (x == Mono_Posix_SysconfName__SC_NPROCESSORS_ONLN)
 #ifdef _SC_NPROCESSORS_ONLN
                {*r = _SC_NPROCESSORS_ONLN; return 0;}
 #else /* def _SC_NPROCESSORS_ONLN */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_NPROCESSORS_ONLN */
-       if (x == Mono_Posix_SysConf__SC_NZERO)
+       if (x == Mono_Posix_SysconfName__SC_NZERO)
 #ifdef _SC_NZERO
                {*r = _SC_NZERO; return 0;}
 #else /* def _SC_NZERO */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_NZERO */
-       if (x == Mono_Posix_SysConf__SC_OPEN_MAX)
+       if (x == Mono_Posix_SysconfName__SC_OPEN_MAX)
 #ifdef _SC_OPEN_MAX
                {*r = _SC_OPEN_MAX; return 0;}
 #else /* def _SC_OPEN_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_OPEN_MAX */
-       if (x == Mono_Posix_SysConf__SC_PAGESIZE)
+       if (x == Mono_Posix_SysconfName__SC_PAGESIZE)
 #ifdef _SC_PAGESIZE
                {*r = _SC_PAGESIZE; return 0;}
 #else /* def _SC_PAGESIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PAGESIZE */
-       if (x == Mono_Posix_SysConf__SC_PASS_MAX)
+       if (x == Mono_Posix_SysconfName__SC_PASS_MAX)
 #ifdef _SC_PASS_MAX
                {*r = _SC_PASS_MAX; return 0;}
 #else /* def _SC_PASS_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PASS_MAX */
-       if (x == Mono_Posix_SysConf__SC_PHYS_PAGES)
+       if (x == Mono_Posix_SysconfName__SC_PHYS_PAGES)
 #ifdef _SC_PHYS_PAGES
                {*r = _SC_PHYS_PAGES; return 0;}
 #else /* def _SC_PHYS_PAGES */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PHYS_PAGES */
-       if (x == Mono_Posix_SysConf__SC_PII)
+       if (x == Mono_Posix_SysconfName__SC_PII)
 #ifdef _SC_PII
                {*r = _SC_PII; return 0;}
 #else /* def _SC_PII */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PII */
-       if (x == Mono_Posix_SysConf__SC_PII_INTERNET)
+       if (x == Mono_Posix_SysconfName__SC_PII_INTERNET)
 #ifdef _SC_PII_INTERNET
                {*r = _SC_PII_INTERNET; return 0;}
 #else /* def _SC_PII_INTERNET */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PII_INTERNET */
-       if (x == Mono_Posix_SysConf__SC_PII_INTERNET_DGRAM)
+       if (x == Mono_Posix_SysconfName__SC_PII_INTERNET_DGRAM)
 #ifdef _SC_PII_INTERNET_DGRAM
                {*r = _SC_PII_INTERNET_DGRAM; return 0;}
 #else /* def _SC_PII_INTERNET_DGRAM */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PII_INTERNET_DGRAM */
-       if (x == Mono_Posix_SysConf__SC_PII_INTERNET_STREAM)
+       if (x == Mono_Posix_SysconfName__SC_PII_INTERNET_STREAM)
 #ifdef _SC_PII_INTERNET_STREAM
                {*r = _SC_PII_INTERNET_STREAM; return 0;}
 #else /* def _SC_PII_INTERNET_STREAM */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PII_INTERNET_STREAM */
-       if (x == Mono_Posix_SysConf__SC_PII_OSI)
+       if (x == Mono_Posix_SysconfName__SC_PII_OSI)
 #ifdef _SC_PII_OSI
                {*r = _SC_PII_OSI; return 0;}
 #else /* def _SC_PII_OSI */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PII_OSI */
-       if (x == Mono_Posix_SysConf__SC_PII_OSI_CLTS)
+       if (x == Mono_Posix_SysconfName__SC_PII_OSI_CLTS)
 #ifdef _SC_PII_OSI_CLTS
                {*r = _SC_PII_OSI_CLTS; return 0;}
 #else /* def _SC_PII_OSI_CLTS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PII_OSI_CLTS */
-       if (x == Mono_Posix_SysConf__SC_PII_OSI_COTS)
+       if (x == Mono_Posix_SysconfName__SC_PII_OSI_COTS)
 #ifdef _SC_PII_OSI_COTS
                {*r = _SC_PII_OSI_COTS; return 0;}
 #else /* def _SC_PII_OSI_COTS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PII_OSI_COTS */
-       if (x == Mono_Posix_SysConf__SC_PII_OSI_M)
+       if (x == Mono_Posix_SysconfName__SC_PII_OSI_M)
 #ifdef _SC_PII_OSI_M
                {*r = _SC_PII_OSI_M; return 0;}
 #else /* def _SC_PII_OSI_M */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PII_OSI_M */
-       if (x == Mono_Posix_SysConf__SC_PII_SOCKET)
+       if (x == Mono_Posix_SysconfName__SC_PII_SOCKET)
 #ifdef _SC_PII_SOCKET
                {*r = _SC_PII_SOCKET; return 0;}
 #else /* def _SC_PII_SOCKET */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PII_SOCKET */
-       if (x == Mono_Posix_SysConf__SC_PII_XTI)
+       if (x == Mono_Posix_SysconfName__SC_PII_XTI)
 #ifdef _SC_PII_XTI
                {*r = _SC_PII_XTI; return 0;}
 #else /* def _SC_PII_XTI */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PII_XTI */
-       if (x == Mono_Posix_SysConf__SC_PIPE)
+       if (x == Mono_Posix_SysconfName__SC_PIPE)
 #ifdef _SC_PIPE
                {*r = _SC_PIPE; return 0;}
 #else /* def _SC_PIPE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PIPE */
-       if (x == Mono_Posix_SysConf__SC_POLL)
+       if (x == Mono_Posix_SysconfName__SC_POLL)
 #ifdef _SC_POLL
                {*r = _SC_POLL; return 0;}
 #else /* def _SC_POLL */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_POLL */
-       if (x == Mono_Posix_SysConf__SC_PRIORITIZED_IO)
+       if (x == Mono_Posix_SysconfName__SC_PRIORITIZED_IO)
 #ifdef _SC_PRIORITIZED_IO
                {*r = _SC_PRIORITIZED_IO; return 0;}
 #else /* def _SC_PRIORITIZED_IO */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PRIORITIZED_IO */
-       if (x == Mono_Posix_SysConf__SC_PRIORITY_SCHEDULING)
+       if (x == Mono_Posix_SysconfName__SC_PRIORITY_SCHEDULING)
 #ifdef _SC_PRIORITY_SCHEDULING
                {*r = _SC_PRIORITY_SCHEDULING; return 0;}
 #else /* def _SC_PRIORITY_SCHEDULING */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_PRIORITY_SCHEDULING */
-       if (x == Mono_Posix_SysConf__SC_READER_WRITER_LOCKS)
+       if (x == Mono_Posix_SysconfName__SC_READER_WRITER_LOCKS)
 #ifdef _SC_READER_WRITER_LOCKS
                {*r = _SC_READER_WRITER_LOCKS; return 0;}
 #else /* def _SC_READER_WRITER_LOCKS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_READER_WRITER_LOCKS */
-       if (x == Mono_Posix_SysConf__SC_REALTIME_SIGNALS)
+       if (x == Mono_Posix_SysconfName__SC_REALTIME_SIGNALS)
 #ifdef _SC_REALTIME_SIGNALS
                {*r = _SC_REALTIME_SIGNALS; return 0;}
 #else /* def _SC_REALTIME_SIGNALS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_REALTIME_SIGNALS */
-       if (x == Mono_Posix_SysConf__SC_REGEXP)
+       if (x == Mono_Posix_SysconfName__SC_REGEXP)
 #ifdef _SC_REGEXP
                {*r = _SC_REGEXP; return 0;}
 #else /* def _SC_REGEXP */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_REGEXP */
-       if (x == Mono_Posix_SysConf__SC_REGEX_VERSION)
+       if (x == Mono_Posix_SysconfName__SC_REGEX_VERSION)
 #ifdef _SC_REGEX_VERSION
                {*r = _SC_REGEX_VERSION; return 0;}
 #else /* def _SC_REGEX_VERSION */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_REGEX_VERSION */
-       if (x == Mono_Posix_SysConf__SC_RE_DUP_MAX)
+       if (x == Mono_Posix_SysconfName__SC_RE_DUP_MAX)
 #ifdef _SC_RE_DUP_MAX
                {*r = _SC_RE_DUP_MAX; return 0;}
 #else /* def _SC_RE_DUP_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_RE_DUP_MAX */
-       if (x == Mono_Posix_SysConf__SC_RTSIG_MAX)
+       if (x == Mono_Posix_SysconfName__SC_RTSIG_MAX)
 #ifdef _SC_RTSIG_MAX
                {*r = _SC_RTSIG_MAX; return 0;}
 #else /* def _SC_RTSIG_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_RTSIG_MAX */
-       if (x == Mono_Posix_SysConf__SC_SAVED_IDS)
+       if (x == Mono_Posix_SysconfName__SC_SAVED_IDS)
 #ifdef _SC_SAVED_IDS
                {*r = _SC_SAVED_IDS; return 0;}
 #else /* def _SC_SAVED_IDS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SAVED_IDS */
-       if (x == Mono_Posix_SysConf__SC_SCHAR_MAX)
+       if (x == Mono_Posix_SysconfName__SC_SCHAR_MAX)
 #ifdef _SC_SCHAR_MAX
                {*r = _SC_SCHAR_MAX; return 0;}
 #else /* def _SC_SCHAR_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SCHAR_MAX */
-       if (x == Mono_Posix_SysConf__SC_SCHAR_MIN)
+       if (x == Mono_Posix_SysconfName__SC_SCHAR_MIN)
 #ifdef _SC_SCHAR_MIN
                {*r = _SC_SCHAR_MIN; return 0;}
 #else /* def _SC_SCHAR_MIN */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SCHAR_MIN */
-       if (x == Mono_Posix_SysConf__SC_SELECT)
+       if (x == Mono_Posix_SysconfName__SC_SELECT)
 #ifdef _SC_SELECT
                {*r = _SC_SELECT; return 0;}
 #else /* def _SC_SELECT */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SELECT */
-       if (x == Mono_Posix_SysConf__SC_SEMAPHORES)
+       if (x == Mono_Posix_SysconfName__SC_SEMAPHORES)
 #ifdef _SC_SEMAPHORES
                {*r = _SC_SEMAPHORES; return 0;}
 #else /* def _SC_SEMAPHORES */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SEMAPHORES */
-       if (x == Mono_Posix_SysConf__SC_SEM_NSEMS_MAX)
+       if (x == Mono_Posix_SysconfName__SC_SEM_NSEMS_MAX)
 #ifdef _SC_SEM_NSEMS_MAX
                {*r = _SC_SEM_NSEMS_MAX; return 0;}
 #else /* def _SC_SEM_NSEMS_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SEM_NSEMS_MAX */
-       if (x == Mono_Posix_SysConf__SC_SEM_VALUE_MAX)
+       if (x == Mono_Posix_SysconfName__SC_SEM_VALUE_MAX)
 #ifdef _SC_SEM_VALUE_MAX
                {*r = _SC_SEM_VALUE_MAX; return 0;}
 #else /* def _SC_SEM_VALUE_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SEM_VALUE_MAX */
-       if (x == Mono_Posix_SysConf__SC_SHARED_MEMORY_OBJECTS)
+       if (x == Mono_Posix_SysconfName__SC_SHARED_MEMORY_OBJECTS)
 #ifdef _SC_SHARED_MEMORY_OBJECTS
                {*r = _SC_SHARED_MEMORY_OBJECTS; return 0;}
 #else /* def _SC_SHARED_MEMORY_OBJECTS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SHARED_MEMORY_OBJECTS */
-       if (x == Mono_Posix_SysConf__SC_SHELL)
+       if (x == Mono_Posix_SysconfName__SC_SHELL)
 #ifdef _SC_SHELL
                {*r = _SC_SHELL; return 0;}
 #else /* def _SC_SHELL */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SHELL */
-       if (x == Mono_Posix_SysConf__SC_SHRT_MAX)
+       if (x == Mono_Posix_SysconfName__SC_SHRT_MAX)
 #ifdef _SC_SHRT_MAX
                {*r = _SC_SHRT_MAX; return 0;}
 #else /* def _SC_SHRT_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SHRT_MAX */
-       if (x == Mono_Posix_SysConf__SC_SHRT_MIN)
+       if (x == Mono_Posix_SysconfName__SC_SHRT_MIN)
 #ifdef _SC_SHRT_MIN
                {*r = _SC_SHRT_MIN; return 0;}
 #else /* def _SC_SHRT_MIN */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SHRT_MIN */
-       if (x == Mono_Posix_SysConf__SC_SIGNALS)
+       if (x == Mono_Posix_SysconfName__SC_SIGNALS)
 #ifdef _SC_SIGNALS
                {*r = _SC_SIGNALS; return 0;}
 #else /* def _SC_SIGNALS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SIGNALS */
-       if (x == Mono_Posix_SysConf__SC_SIGQUEUE_MAX)
+       if (x == Mono_Posix_SysconfName__SC_SIGQUEUE_MAX)
 #ifdef _SC_SIGQUEUE_MAX
                {*r = _SC_SIGQUEUE_MAX; return 0;}
 #else /* def _SC_SIGQUEUE_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SIGQUEUE_MAX */
-       if (x == Mono_Posix_SysConf__SC_SINGLE_PROCESS)
+       if (x == Mono_Posix_SysconfName__SC_SINGLE_PROCESS)
 #ifdef _SC_SINGLE_PROCESS
                {*r = _SC_SINGLE_PROCESS; return 0;}
 #else /* def _SC_SINGLE_PROCESS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SINGLE_PROCESS */
-       if (x == Mono_Posix_SysConf__SC_SPAWN)
+       if (x == Mono_Posix_SysconfName__SC_SPAWN)
 #ifdef _SC_SPAWN
                {*r = _SC_SPAWN; return 0;}
 #else /* def _SC_SPAWN */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SPAWN */
-       if (x == Mono_Posix_SysConf__SC_SPIN_LOCKS)
+       if (x == Mono_Posix_SysconfName__SC_SPIN_LOCKS)
 #ifdef _SC_SPIN_LOCKS
                {*r = _SC_SPIN_LOCKS; return 0;}
 #else /* def _SC_SPIN_LOCKS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SPIN_LOCKS */
-       if (x == Mono_Posix_SysConf__SC_SPORADIC_SERVER)
+       if (x == Mono_Posix_SysconfName__SC_SPORADIC_SERVER)
 #ifdef _SC_SPORADIC_SERVER
                {*r = _SC_SPORADIC_SERVER; return 0;}
 #else /* def _SC_SPORADIC_SERVER */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SPORADIC_SERVER */
-       if (x == Mono_Posix_SysConf__SC_SSIZE_MAX)
+       if (x == Mono_Posix_SysconfName__SC_SSIZE_MAX)
 #ifdef _SC_SSIZE_MAX
                {*r = _SC_SSIZE_MAX; return 0;}
 #else /* def _SC_SSIZE_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SSIZE_MAX */
-       if (x == Mono_Posix_SysConf__SC_STREAMS)
+       if (x == Mono_Posix_SysconfName__SC_STREAMS)
 #ifdef _SC_STREAMS
                {*r = _SC_STREAMS; return 0;}
 #else /* def _SC_STREAMS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_STREAMS */
-       if (x == Mono_Posix_SysConf__SC_STREAM_MAX)
+       if (x == Mono_Posix_SysconfName__SC_STREAM_MAX)
 #ifdef _SC_STREAM_MAX
                {*r = _SC_STREAM_MAX; return 0;}
 #else /* def _SC_STREAM_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_STREAM_MAX */
-       if (x == Mono_Posix_SysConf__SC_SYMLOOP_MAX)
+       if (x == Mono_Posix_SysconfName__SC_SYMLOOP_MAX)
 #ifdef _SC_SYMLOOP_MAX
                {*r = _SC_SYMLOOP_MAX; return 0;}
 #else /* def _SC_SYMLOOP_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SYMLOOP_MAX */
-       if (x == Mono_Posix_SysConf__SC_SYNCHRONIZED_IO)
+       if (x == Mono_Posix_SysconfName__SC_SYNCHRONIZED_IO)
 #ifdef _SC_SYNCHRONIZED_IO
                {*r = _SC_SYNCHRONIZED_IO; return 0;}
 #else /* def _SC_SYNCHRONIZED_IO */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SYNCHRONIZED_IO */
-       if (x == Mono_Posix_SysConf__SC_SYSTEM_DATABASE)
+       if (x == Mono_Posix_SysconfName__SC_SYSTEM_DATABASE)
 #ifdef _SC_SYSTEM_DATABASE
                {*r = _SC_SYSTEM_DATABASE; return 0;}
 #else /* def _SC_SYSTEM_DATABASE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SYSTEM_DATABASE */
-       if (x == Mono_Posix_SysConf__SC_SYSTEM_DATABASE_R)
+       if (x == Mono_Posix_SysconfName__SC_SYSTEM_DATABASE_R)
 #ifdef _SC_SYSTEM_DATABASE_R
                {*r = _SC_SYSTEM_DATABASE_R; return 0;}
 #else /* def _SC_SYSTEM_DATABASE_R */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_SYSTEM_DATABASE_R */
-       if (x == Mono_Posix_SysConf__SC_THREADS)
+       if (x == Mono_Posix_SysconfName__SC_THREADS)
 #ifdef _SC_THREADS
                {*r = _SC_THREADS; return 0;}
 #else /* def _SC_THREADS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREADS */
-       if (x == Mono_Posix_SysConf__SC_THREAD_ATTR_STACKADDR)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_ATTR_STACKADDR)
 #ifdef _SC_THREAD_ATTR_STACKADDR
                {*r = _SC_THREAD_ATTR_STACKADDR; return 0;}
 #else /* def _SC_THREAD_ATTR_STACKADDR */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_ATTR_STACKADDR */
-       if (x == Mono_Posix_SysConf__SC_THREAD_ATTR_STACKSIZE)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_ATTR_STACKSIZE)
 #ifdef _SC_THREAD_ATTR_STACKSIZE
                {*r = _SC_THREAD_ATTR_STACKSIZE; return 0;}
 #else /* def _SC_THREAD_ATTR_STACKSIZE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_ATTR_STACKSIZE */
-       if (x == Mono_Posix_SysConf__SC_THREAD_CPUTIME)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_CPUTIME)
 #ifdef _SC_THREAD_CPUTIME
                {*r = _SC_THREAD_CPUTIME; return 0;}
 #else /* def _SC_THREAD_CPUTIME */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_CPUTIME */
-       if (x == Mono_Posix_SysConf__SC_THREAD_DESTRUCTOR_ITERATIONS)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_DESTRUCTOR_ITERATIONS)
 #ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS
                {*r = _SC_THREAD_DESTRUCTOR_ITERATIONS; return 0;}
 #else /* def _SC_THREAD_DESTRUCTOR_ITERATIONS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_DESTRUCTOR_ITERATIONS */
-       if (x == Mono_Posix_SysConf__SC_THREAD_KEYS_MAX)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_KEYS_MAX)
 #ifdef _SC_THREAD_KEYS_MAX
                {*r = _SC_THREAD_KEYS_MAX; return 0;}
 #else /* def _SC_THREAD_KEYS_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_KEYS_MAX */
-       if (x == Mono_Posix_SysConf__SC_THREAD_PRIORITY_SCHEDULING)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_PRIORITY_SCHEDULING)
 #ifdef _SC_THREAD_PRIORITY_SCHEDULING
                {*r = _SC_THREAD_PRIORITY_SCHEDULING; return 0;}
 #else /* def _SC_THREAD_PRIORITY_SCHEDULING */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_PRIORITY_SCHEDULING */
-       if (x == Mono_Posix_SysConf__SC_THREAD_PRIO_INHERIT)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_PRIO_INHERIT)
 #ifdef _SC_THREAD_PRIO_INHERIT
                {*r = _SC_THREAD_PRIO_INHERIT; return 0;}
 #else /* def _SC_THREAD_PRIO_INHERIT */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_PRIO_INHERIT */
-       if (x == Mono_Posix_SysConf__SC_THREAD_PRIO_PROTECT)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_PRIO_PROTECT)
 #ifdef _SC_THREAD_PRIO_PROTECT
                {*r = _SC_THREAD_PRIO_PROTECT; return 0;}
 #else /* def _SC_THREAD_PRIO_PROTECT */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_PRIO_PROTECT */
-       if (x == Mono_Posix_SysConf__SC_THREAD_PROCESS_SHARED)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_PROCESS_SHARED)
 #ifdef _SC_THREAD_PROCESS_SHARED
                {*r = _SC_THREAD_PROCESS_SHARED; return 0;}
 #else /* def _SC_THREAD_PROCESS_SHARED */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_PROCESS_SHARED */
-       if (x == Mono_Posix_SysConf__SC_THREAD_SAFE_FUNCTIONS)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_SAFE_FUNCTIONS)
 #ifdef _SC_THREAD_SAFE_FUNCTIONS
                {*r = _SC_THREAD_SAFE_FUNCTIONS; return 0;}
 #else /* def _SC_THREAD_SAFE_FUNCTIONS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_SAFE_FUNCTIONS */
-       if (x == Mono_Posix_SysConf__SC_THREAD_SPORADIC_SERVER)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_SPORADIC_SERVER)
 #ifdef _SC_THREAD_SPORADIC_SERVER
                {*r = _SC_THREAD_SPORADIC_SERVER; return 0;}
 #else /* def _SC_THREAD_SPORADIC_SERVER */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_SPORADIC_SERVER */
-       if (x == Mono_Posix_SysConf__SC_THREAD_STACK_MIN)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_STACK_MIN)
 #ifdef _SC_THREAD_STACK_MIN
                {*r = _SC_THREAD_STACK_MIN; return 0;}
 #else /* def _SC_THREAD_STACK_MIN */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_STACK_MIN */
-       if (x == Mono_Posix_SysConf__SC_THREAD_THREADS_MAX)
+       if (x == Mono_Posix_SysconfName__SC_THREAD_THREADS_MAX)
 #ifdef _SC_THREAD_THREADS_MAX
                {*r = _SC_THREAD_THREADS_MAX; return 0;}
 #else /* def _SC_THREAD_THREADS_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_THREAD_THREADS_MAX */
-       if (x == Mono_Posix_SysConf__SC_TIMEOUTS)
+       if (x == Mono_Posix_SysconfName__SC_TIMEOUTS)
 #ifdef _SC_TIMEOUTS
                {*r = _SC_TIMEOUTS; return 0;}
 #else /* def _SC_TIMEOUTS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_TIMEOUTS */
-       if (x == Mono_Posix_SysConf__SC_TIMERS)
+       if (x == Mono_Posix_SysconfName__SC_TIMERS)
 #ifdef _SC_TIMERS
                {*r = _SC_TIMERS; return 0;}
 #else /* def _SC_TIMERS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_TIMERS */
-       if (x == Mono_Posix_SysConf__SC_TIMER_MAX)
+       if (x == Mono_Posix_SysconfName__SC_TIMER_MAX)
 #ifdef _SC_TIMER_MAX
                {*r = _SC_TIMER_MAX; return 0;}
 #else /* def _SC_TIMER_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_TIMER_MAX */
-       if (x == Mono_Posix_SysConf__SC_TRACE)
+       if (x == Mono_Posix_SysconfName__SC_TRACE)
 #ifdef _SC_TRACE
                {*r = _SC_TRACE; return 0;}
 #else /* def _SC_TRACE */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_TRACE */
-       if (x == Mono_Posix_SysConf__SC_TRACE_EVENT_FILTER)
+       if (x == Mono_Posix_SysconfName__SC_TRACE_EVENT_FILTER)
 #ifdef _SC_TRACE_EVENT_FILTER
                {*r = _SC_TRACE_EVENT_FILTER; return 0;}
 #else /* def _SC_TRACE_EVENT_FILTER */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_TRACE_EVENT_FILTER */
-       if (x == Mono_Posix_SysConf__SC_TRACE_INHERIT)
+       if (x == Mono_Posix_SysconfName__SC_TRACE_INHERIT)
 #ifdef _SC_TRACE_INHERIT
                {*r = _SC_TRACE_INHERIT; return 0;}
 #else /* def _SC_TRACE_INHERIT */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_TRACE_INHERIT */
-       if (x == Mono_Posix_SysConf__SC_TRACE_LOG)
+       if (x == Mono_Posix_SysconfName__SC_TRACE_LOG)
 #ifdef _SC_TRACE_LOG
                {*r = _SC_TRACE_LOG; return 0;}
 #else /* def _SC_TRACE_LOG */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_TRACE_LOG */
-       if (x == Mono_Posix_SysConf__SC_TTY_NAME_MAX)
+       if (x == Mono_Posix_SysconfName__SC_TTY_NAME_MAX)
 #ifdef _SC_TTY_NAME_MAX
                {*r = _SC_TTY_NAME_MAX; return 0;}
 #else /* def _SC_TTY_NAME_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_TTY_NAME_MAX */
-       if (x == Mono_Posix_SysConf__SC_TYPED_MEMORY_OBJECTS)
+       if (x == Mono_Posix_SysconfName__SC_TYPED_MEMORY_OBJECTS)
 #ifdef _SC_TYPED_MEMORY_OBJECTS
                {*r = _SC_TYPED_MEMORY_OBJECTS; return 0;}
 #else /* def _SC_TYPED_MEMORY_OBJECTS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_TYPED_MEMORY_OBJECTS */
-       if (x == Mono_Posix_SysConf__SC_TZNAME_MAX)
+       if (x == Mono_Posix_SysconfName__SC_TZNAME_MAX)
 #ifdef _SC_TZNAME_MAX
                {*r = _SC_TZNAME_MAX; return 0;}
 #else /* def _SC_TZNAME_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_TZNAME_MAX */
-       if (x == Mono_Posix_SysConf__SC_T_IOV_MAX)
+       if (x == Mono_Posix_SysconfName__SC_T_IOV_MAX)
 #ifdef _SC_T_IOV_MAX
                {*r = _SC_T_IOV_MAX; return 0;}
 #else /* def _SC_T_IOV_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_T_IOV_MAX */
-       if (x == Mono_Posix_SysConf__SC_UCHAR_MAX)
+       if (x == Mono_Posix_SysconfName__SC_UCHAR_MAX)
 #ifdef _SC_UCHAR_MAX
                {*r = _SC_UCHAR_MAX; return 0;}
 #else /* def _SC_UCHAR_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_UCHAR_MAX */
-       if (x == Mono_Posix_SysConf__SC_UINT_MAX)
+       if (x == Mono_Posix_SysconfName__SC_UINT_MAX)
 #ifdef _SC_UINT_MAX
                {*r = _SC_UINT_MAX; return 0;}
 #else /* def _SC_UINT_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_UINT_MAX */
-       if (x == Mono_Posix_SysConf__SC_UIO_MAXIOV)
+       if (x == Mono_Posix_SysconfName__SC_UIO_MAXIOV)
 #ifdef _SC_UIO_MAXIOV
                {*r = _SC_UIO_MAXIOV; return 0;}
 #else /* def _SC_UIO_MAXIOV */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_UIO_MAXIOV */
-       if (x == Mono_Posix_SysConf__SC_ULONG_MAX)
+       if (x == Mono_Posix_SysconfName__SC_ULONG_MAX)
 #ifdef _SC_ULONG_MAX
                {*r = _SC_ULONG_MAX; return 0;}
 #else /* def _SC_ULONG_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_ULONG_MAX */
-       if (x == Mono_Posix_SysConf__SC_USER_GROUPS)
+       if (x == Mono_Posix_SysconfName__SC_USER_GROUPS)
 #ifdef _SC_USER_GROUPS
                {*r = _SC_USER_GROUPS; return 0;}
 #else /* def _SC_USER_GROUPS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_USER_GROUPS */
-       if (x == Mono_Posix_SysConf__SC_USER_GROUPS_R)
+       if (x == Mono_Posix_SysconfName__SC_USER_GROUPS_R)
 #ifdef _SC_USER_GROUPS_R
                {*r = _SC_USER_GROUPS_R; return 0;}
 #else /* def _SC_USER_GROUPS_R */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_USER_GROUPS_R */
-       if (x == Mono_Posix_SysConf__SC_USHRT_MAX)
+       if (x == Mono_Posix_SysconfName__SC_USHRT_MAX)
 #ifdef _SC_USHRT_MAX
                {*r = _SC_USHRT_MAX; return 0;}
 #else /* def _SC_USHRT_MAX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_USHRT_MAX */
-       if (x == Mono_Posix_SysConf__SC_V6_ILP32_OFF32)
+       if (x == Mono_Posix_SysconfName__SC_V6_ILP32_OFF32)
 #ifdef _SC_V6_ILP32_OFF32
                {*r = _SC_V6_ILP32_OFF32; return 0;}
 #else /* def _SC_V6_ILP32_OFF32 */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_V6_ILP32_OFF32 */
-       if (x == Mono_Posix_SysConf__SC_V6_ILP32_OFFBIG)
+       if (x == Mono_Posix_SysconfName__SC_V6_ILP32_OFFBIG)
 #ifdef _SC_V6_ILP32_OFFBIG
                {*r = _SC_V6_ILP32_OFFBIG; return 0;}
 #else /* def _SC_V6_ILP32_OFFBIG */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_V6_ILP32_OFFBIG */
-       if (x == Mono_Posix_SysConf__SC_V6_LP64_OFF64)
+       if (x == Mono_Posix_SysconfName__SC_V6_LP64_OFF64)
 #ifdef _SC_V6_LP64_OFF64
                {*r = _SC_V6_LP64_OFF64; return 0;}
 #else /* def _SC_V6_LP64_OFF64 */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_V6_LP64_OFF64 */
-       if (x == Mono_Posix_SysConf__SC_V6_LPBIG_OFFBIG)
+       if (x == Mono_Posix_SysconfName__SC_V6_LPBIG_OFFBIG)
 #ifdef _SC_V6_LPBIG_OFFBIG
                {*r = _SC_V6_LPBIG_OFFBIG; return 0;}
 #else /* def _SC_V6_LPBIG_OFFBIG */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_V6_LPBIG_OFFBIG */
-       if (x == Mono_Posix_SysConf__SC_VERSION)
+       if (x == Mono_Posix_SysconfName__SC_VERSION)
 #ifdef _SC_VERSION
                {*r = _SC_VERSION; return 0;}
 #else /* def _SC_VERSION */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_VERSION */
-       if (x == Mono_Posix_SysConf__SC_WORD_BIT)
+       if (x == Mono_Posix_SysconfName__SC_WORD_BIT)
 #ifdef _SC_WORD_BIT
                {*r = _SC_WORD_BIT; return 0;}
 #else /* def _SC_WORD_BIT */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_WORD_BIT */
-       if (x == Mono_Posix_SysConf__SC_XBS5_ILP32_OFF32)
+       if (x == Mono_Posix_SysconfName__SC_XBS5_ILP32_OFF32)
 #ifdef _SC_XBS5_ILP32_OFF32
                {*r = _SC_XBS5_ILP32_OFF32; return 0;}
 #else /* def _SC_XBS5_ILP32_OFF32 */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XBS5_ILP32_OFF32 */
-       if (x == Mono_Posix_SysConf__SC_XBS5_ILP32_OFFBIG)
+       if (x == Mono_Posix_SysconfName__SC_XBS5_ILP32_OFFBIG)
 #ifdef _SC_XBS5_ILP32_OFFBIG
                {*r = _SC_XBS5_ILP32_OFFBIG; return 0;}
 #else /* def _SC_XBS5_ILP32_OFFBIG */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XBS5_ILP32_OFFBIG */
-       if (x == Mono_Posix_SysConf__SC_XBS5_LP64_OFF64)
+       if (x == Mono_Posix_SysconfName__SC_XBS5_LP64_OFF64)
 #ifdef _SC_XBS5_LP64_OFF64
                {*r = _SC_XBS5_LP64_OFF64; return 0;}
 #else /* def _SC_XBS5_LP64_OFF64 */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XBS5_LP64_OFF64 */
-       if (x == Mono_Posix_SysConf__SC_XBS5_LPBIG_OFFBIG)
+       if (x == Mono_Posix_SysconfName__SC_XBS5_LPBIG_OFFBIG)
 #ifdef _SC_XBS5_LPBIG_OFFBIG
                {*r = _SC_XBS5_LPBIG_OFFBIG; return 0;}
 #else /* def _SC_XBS5_LPBIG_OFFBIG */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XBS5_LPBIG_OFFBIG */
-       if (x == Mono_Posix_SysConf__SC_XOPEN_CRYPT)
+       if (x == Mono_Posix_SysconfName__SC_XOPEN_CRYPT)
 #ifdef _SC_XOPEN_CRYPT
                {*r = _SC_XOPEN_CRYPT; return 0;}
 #else /* def _SC_XOPEN_CRYPT */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XOPEN_CRYPT */
-       if (x == Mono_Posix_SysConf__SC_XOPEN_ENH_I18N)
+       if (x == Mono_Posix_SysconfName__SC_XOPEN_ENH_I18N)
 #ifdef _SC_XOPEN_ENH_I18N
                {*r = _SC_XOPEN_ENH_I18N; return 0;}
 #else /* def _SC_XOPEN_ENH_I18N */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XOPEN_ENH_I18N */
-       if (x == Mono_Posix_SysConf__SC_XOPEN_LEGACY)
+       if (x == Mono_Posix_SysconfName__SC_XOPEN_LEGACY)
 #ifdef _SC_XOPEN_LEGACY
                {*r = _SC_XOPEN_LEGACY; return 0;}
 #else /* def _SC_XOPEN_LEGACY */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XOPEN_LEGACY */
-       if (x == Mono_Posix_SysConf__SC_XOPEN_REALTIME)
+       if (x == Mono_Posix_SysconfName__SC_XOPEN_REALTIME)
 #ifdef _SC_XOPEN_REALTIME
                {*r = _SC_XOPEN_REALTIME; return 0;}
 #else /* def _SC_XOPEN_REALTIME */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XOPEN_REALTIME */
-       if (x == Mono_Posix_SysConf__SC_XOPEN_REALTIME_THREADS)
+       if (x == Mono_Posix_SysconfName__SC_XOPEN_REALTIME_THREADS)
 #ifdef _SC_XOPEN_REALTIME_THREADS
                {*r = _SC_XOPEN_REALTIME_THREADS; return 0;}
 #else /* def _SC_XOPEN_REALTIME_THREADS */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XOPEN_REALTIME_THREADS */
-       if (x == Mono_Posix_SysConf__SC_XOPEN_SHM)
+       if (x == Mono_Posix_SysconfName__SC_XOPEN_SHM)
 #ifdef _SC_XOPEN_SHM
                {*r = _SC_XOPEN_SHM; return 0;}
 #else /* def _SC_XOPEN_SHM */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XOPEN_SHM */
-       if (x == Mono_Posix_SysConf__SC_XOPEN_UNIX)
+       if (x == Mono_Posix_SysconfName__SC_XOPEN_UNIX)
 #ifdef _SC_XOPEN_UNIX
                {*r = _SC_XOPEN_UNIX; return 0;}
 #else /* def _SC_XOPEN_UNIX */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XOPEN_UNIX */
-       if (x == Mono_Posix_SysConf__SC_XOPEN_VERSION)
+       if (x == Mono_Posix_SysconfName__SC_XOPEN_VERSION)
 #ifdef _SC_XOPEN_VERSION
                {*r = _SC_XOPEN_VERSION; return 0;}
 #else /* def _SC_XOPEN_VERSION */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XOPEN_VERSION */
-       if (x == Mono_Posix_SysConf__SC_XOPEN_XCU_VERSION)
+       if (x == Mono_Posix_SysconfName__SC_XOPEN_XCU_VERSION)
 #ifdef _SC_XOPEN_XCU_VERSION
                {*r = _SC_XOPEN_XCU_VERSION; return 0;}
 #else /* def _SC_XOPEN_XCU_VERSION */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XOPEN_XCU_VERSION */
-       if (x == Mono_Posix_SysConf__SC_XOPEN_XPG2)
+       if (x == Mono_Posix_SysconfName__SC_XOPEN_XPG2)
 #ifdef _SC_XOPEN_XPG2
                {*r = _SC_XOPEN_XPG2; return 0;}
 #else /* def _SC_XOPEN_XPG2 */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XOPEN_XPG2 */
-       if (x == Mono_Posix_SysConf__SC_XOPEN_XPG3)
+       if (x == Mono_Posix_SysconfName__SC_XOPEN_XPG3)
 #ifdef _SC_XOPEN_XPG3
                {*r = _SC_XOPEN_XPG3; return 0;}
 #else /* def _SC_XOPEN_XPG3 */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XOPEN_XPG3 */
-       if (x == Mono_Posix_SysConf__SC_XOPEN_XPG4)
+       if (x == Mono_Posix_SysconfName__SC_XOPEN_XPG4)
 #ifdef _SC_XOPEN_XPG4
                {*r = _SC_XOPEN_XPG4; return 0;}
 #else /* def _SC_XOPEN_XPG4 */
                {errno = EINVAL; return -1;}
 #endif /* ndef _SC_XOPEN_XPG4 */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
-int Mono_Posix_ToSysConf (int x, int *r)
+int Mono_Posix_ToSysconfName (int x, int *r)
 {
        *r = 0;
        if (x == 0)
                return 0;
 #ifdef _SC_2_CHAR_TERM
        if (x == _SC_2_CHAR_TERM)
-               {*r = Mono_Posix_SysConf__SC_2_CHAR_TERM; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_CHAR_TERM; return 0;}
 #endif /* ndef _SC_2_CHAR_TERM */
 #ifdef _SC_2_C_BIND
        if (x == _SC_2_C_BIND)
-               {*r = Mono_Posix_SysConf__SC_2_C_BIND; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_C_BIND; return 0;}
 #endif /* ndef _SC_2_C_BIND */
 #ifdef _SC_2_C_DEV
        if (x == _SC_2_C_DEV)
-               {*r = Mono_Posix_SysConf__SC_2_C_DEV; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_C_DEV; return 0;}
 #endif /* ndef _SC_2_C_DEV */
 #ifdef _SC_2_C_VERSION
        if (x == _SC_2_C_VERSION)
-               {*r = Mono_Posix_SysConf__SC_2_C_VERSION; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_C_VERSION; return 0;}
 #endif /* ndef _SC_2_C_VERSION */
 #ifdef _SC_2_FORT_DEV
        if (x == _SC_2_FORT_DEV)
-               {*r = Mono_Posix_SysConf__SC_2_FORT_DEV; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_FORT_DEV; return 0;}
 #endif /* ndef _SC_2_FORT_DEV */
 #ifdef _SC_2_FORT_RUN
        if (x == _SC_2_FORT_RUN)
-               {*r = Mono_Posix_SysConf__SC_2_FORT_RUN; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_FORT_RUN; return 0;}
 #endif /* ndef _SC_2_FORT_RUN */
 #ifdef _SC_2_LOCALEDEF
        if (x == _SC_2_LOCALEDEF)
-               {*r = Mono_Posix_SysConf__SC_2_LOCALEDEF; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_LOCALEDEF; return 0;}
 #endif /* ndef _SC_2_LOCALEDEF */
 #ifdef _SC_2_PBS
        if (x == _SC_2_PBS)
-               {*r = Mono_Posix_SysConf__SC_2_PBS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_PBS; return 0;}
 #endif /* ndef _SC_2_PBS */
 #ifdef _SC_2_PBS_ACCOUNTING
        if (x == _SC_2_PBS_ACCOUNTING)
-               {*r = Mono_Posix_SysConf__SC_2_PBS_ACCOUNTING; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_PBS_ACCOUNTING; return 0;}
 #endif /* ndef _SC_2_PBS_ACCOUNTING */
 #ifdef _SC_2_PBS_CHECKPOINT
        if (x == _SC_2_PBS_CHECKPOINT)
-               {*r = Mono_Posix_SysConf__SC_2_PBS_CHECKPOINT; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_PBS_CHECKPOINT; return 0;}
 #endif /* ndef _SC_2_PBS_CHECKPOINT */
 #ifdef _SC_2_PBS_LOCATE
        if (x == _SC_2_PBS_LOCATE)
-               {*r = Mono_Posix_SysConf__SC_2_PBS_LOCATE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_PBS_LOCATE; return 0;}
 #endif /* ndef _SC_2_PBS_LOCATE */
 #ifdef _SC_2_PBS_MESSAGE
        if (x == _SC_2_PBS_MESSAGE)
-               {*r = Mono_Posix_SysConf__SC_2_PBS_MESSAGE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_PBS_MESSAGE; return 0;}
 #endif /* ndef _SC_2_PBS_MESSAGE */
 #ifdef _SC_2_PBS_TRACK
        if (x == _SC_2_PBS_TRACK)
-               {*r = Mono_Posix_SysConf__SC_2_PBS_TRACK; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_PBS_TRACK; return 0;}
 #endif /* ndef _SC_2_PBS_TRACK */
 #ifdef _SC_2_SW_DEV
        if (x == _SC_2_SW_DEV)
-               {*r = Mono_Posix_SysConf__SC_2_SW_DEV; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_SW_DEV; return 0;}
 #endif /* ndef _SC_2_SW_DEV */
 #ifdef _SC_2_UPE
        if (x == _SC_2_UPE)
-               {*r = Mono_Posix_SysConf__SC_2_UPE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_UPE; return 0;}
 #endif /* ndef _SC_2_UPE */
 #ifdef _SC_2_VERSION
        if (x == _SC_2_VERSION)
-               {*r = Mono_Posix_SysConf__SC_2_VERSION; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_2_VERSION; return 0;}
 #endif /* ndef _SC_2_VERSION */
 #ifdef _SC_ADVISORY_INFO
        if (x == _SC_ADVISORY_INFO)
-               {*r = Mono_Posix_SysConf__SC_ADVISORY_INFO; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_ADVISORY_INFO; return 0;}
 #endif /* ndef _SC_ADVISORY_INFO */
 #ifdef _SC_AIO_LISTIO_MAX
        if (x == _SC_AIO_LISTIO_MAX)
-               {*r = Mono_Posix_SysConf__SC_AIO_LISTIO_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_AIO_LISTIO_MAX; return 0;}
 #endif /* ndef _SC_AIO_LISTIO_MAX */
 #ifdef _SC_AIO_MAX
        if (x == _SC_AIO_MAX)
-               {*r = Mono_Posix_SysConf__SC_AIO_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_AIO_MAX; return 0;}
 #endif /* ndef _SC_AIO_MAX */
 #ifdef _SC_AIO_PRIO_DELTA_MAX
        if (x == _SC_AIO_PRIO_DELTA_MAX)
-               {*r = Mono_Posix_SysConf__SC_AIO_PRIO_DELTA_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_AIO_PRIO_DELTA_MAX; return 0;}
 #endif /* ndef _SC_AIO_PRIO_DELTA_MAX */
 #ifdef _SC_ARG_MAX
        if (x == _SC_ARG_MAX)
-               {*r = Mono_Posix_SysConf__SC_ARG_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_ARG_MAX; return 0;}
 #endif /* ndef _SC_ARG_MAX */
 #ifdef _SC_ASYNCHRONOUS_IO
        if (x == _SC_ASYNCHRONOUS_IO)
-               {*r = Mono_Posix_SysConf__SC_ASYNCHRONOUS_IO; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_ASYNCHRONOUS_IO; return 0;}
 #endif /* ndef _SC_ASYNCHRONOUS_IO */
 #ifdef _SC_ATEXIT_MAX
        if (x == _SC_ATEXIT_MAX)
-               {*r = Mono_Posix_SysConf__SC_ATEXIT_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_ATEXIT_MAX; return 0;}
 #endif /* ndef _SC_ATEXIT_MAX */
 #ifdef _SC_AVPHYS_PAGES
        if (x == _SC_AVPHYS_PAGES)
-               {*r = Mono_Posix_SysConf__SC_AVPHYS_PAGES; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_AVPHYS_PAGES; return 0;}
 #endif /* ndef _SC_AVPHYS_PAGES */
 #ifdef _SC_BARRIERS
        if (x == _SC_BARRIERS)
-               {*r = Mono_Posix_SysConf__SC_BARRIERS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_BARRIERS; return 0;}
 #endif /* ndef _SC_BARRIERS */
 #ifdef _SC_BASE
        if (x == _SC_BASE)
-               {*r = Mono_Posix_SysConf__SC_BASE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_BASE; return 0;}
 #endif /* ndef _SC_BASE */
 #ifdef _SC_BC_BASE_MAX
        if (x == _SC_BC_BASE_MAX)
-               {*r = Mono_Posix_SysConf__SC_BC_BASE_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_BC_BASE_MAX; return 0;}
 #endif /* ndef _SC_BC_BASE_MAX */
 #ifdef _SC_BC_DIM_MAX
        if (x == _SC_BC_DIM_MAX)
-               {*r = Mono_Posix_SysConf__SC_BC_DIM_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_BC_DIM_MAX; return 0;}
 #endif /* ndef _SC_BC_DIM_MAX */
 #ifdef _SC_BC_SCALE_MAX
        if (x == _SC_BC_SCALE_MAX)
-               {*r = Mono_Posix_SysConf__SC_BC_SCALE_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_BC_SCALE_MAX; return 0;}
 #endif /* ndef _SC_BC_SCALE_MAX */
 #ifdef _SC_BC_STRING_MAX
        if (x == _SC_BC_STRING_MAX)
-               {*r = Mono_Posix_SysConf__SC_BC_STRING_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_BC_STRING_MAX; return 0;}
 #endif /* ndef _SC_BC_STRING_MAX */
 #ifdef _SC_CHARCLASS_NAME_MAX
        if (x == _SC_CHARCLASS_NAME_MAX)
-               {*r = Mono_Posix_SysConf__SC_CHARCLASS_NAME_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_CHARCLASS_NAME_MAX; return 0;}
 #endif /* ndef _SC_CHARCLASS_NAME_MAX */
 #ifdef _SC_CHAR_BIT
        if (x == _SC_CHAR_BIT)
-               {*r = Mono_Posix_SysConf__SC_CHAR_BIT; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_CHAR_BIT; return 0;}
 #endif /* ndef _SC_CHAR_BIT */
 #ifdef _SC_CHAR_MAX
        if (x == _SC_CHAR_MAX)
-               {*r = Mono_Posix_SysConf__SC_CHAR_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_CHAR_MAX; return 0;}
 #endif /* ndef _SC_CHAR_MAX */
 #ifdef _SC_CHAR_MIN
        if (x == _SC_CHAR_MIN)
-               {*r = Mono_Posix_SysConf__SC_CHAR_MIN; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_CHAR_MIN; return 0;}
 #endif /* ndef _SC_CHAR_MIN */
 #ifdef _SC_CHILD_MAX
        if (x == _SC_CHILD_MAX)
-               {*r = Mono_Posix_SysConf__SC_CHILD_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_CHILD_MAX; return 0;}
 #endif /* ndef _SC_CHILD_MAX */
 #ifdef _SC_CLK_TCK
        if (x == _SC_CLK_TCK)
-               {*r = Mono_Posix_SysConf__SC_CLK_TCK; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_CLK_TCK; return 0;}
 #endif /* ndef _SC_CLK_TCK */
 #ifdef _SC_CLOCK_SELECTION
        if (x == _SC_CLOCK_SELECTION)
-               {*r = Mono_Posix_SysConf__SC_CLOCK_SELECTION; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_CLOCK_SELECTION; return 0;}
 #endif /* ndef _SC_CLOCK_SELECTION */
 #ifdef _SC_COLL_WEIGHTS_MAX
        if (x == _SC_COLL_WEIGHTS_MAX)
-               {*r = Mono_Posix_SysConf__SC_COLL_WEIGHTS_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_COLL_WEIGHTS_MAX; return 0;}
 #endif /* ndef _SC_COLL_WEIGHTS_MAX */
 #ifdef _SC_CPUTIME
        if (x == _SC_CPUTIME)
-               {*r = Mono_Posix_SysConf__SC_CPUTIME; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_CPUTIME; return 0;}
 #endif /* ndef _SC_CPUTIME */
 #ifdef _SC_C_LANG_SUPPORT
        if (x == _SC_C_LANG_SUPPORT)
-               {*r = Mono_Posix_SysConf__SC_C_LANG_SUPPORT; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_C_LANG_SUPPORT; return 0;}
 #endif /* ndef _SC_C_LANG_SUPPORT */
 #ifdef _SC_C_LANG_SUPPORT_R
        if (x == _SC_C_LANG_SUPPORT_R)
-               {*r = Mono_Posix_SysConf__SC_C_LANG_SUPPORT_R; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_C_LANG_SUPPORT_R; return 0;}
 #endif /* ndef _SC_C_LANG_SUPPORT_R */
 #ifdef _SC_DELAYTIMER_MAX
        if (x == _SC_DELAYTIMER_MAX)
-               {*r = Mono_Posix_SysConf__SC_DELAYTIMER_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_DELAYTIMER_MAX; return 0;}
 #endif /* ndef _SC_DELAYTIMER_MAX */
 #ifdef _SC_DEVICE_IO
        if (x == _SC_DEVICE_IO)
-               {*r = Mono_Posix_SysConf__SC_DEVICE_IO; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_DEVICE_IO; return 0;}
 #endif /* ndef _SC_DEVICE_IO */
 #ifdef _SC_DEVICE_SPECIFIC
        if (x == _SC_DEVICE_SPECIFIC)
-               {*r = Mono_Posix_SysConf__SC_DEVICE_SPECIFIC; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_DEVICE_SPECIFIC; return 0;}
 #endif /* ndef _SC_DEVICE_SPECIFIC */
 #ifdef _SC_DEVICE_SPECIFIC_R
        if (x == _SC_DEVICE_SPECIFIC_R)
-               {*r = Mono_Posix_SysConf__SC_DEVICE_SPECIFIC_R; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_DEVICE_SPECIFIC_R; return 0;}
 #endif /* ndef _SC_DEVICE_SPECIFIC_R */
 #ifdef _SC_EQUIV_CLASS_MAX
        if (x == _SC_EQUIV_CLASS_MAX)
-               {*r = Mono_Posix_SysConf__SC_EQUIV_CLASS_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_EQUIV_CLASS_MAX; return 0;}
 #endif /* ndef _SC_EQUIV_CLASS_MAX */
 #ifdef _SC_EXPR_NEST_MAX
        if (x == _SC_EXPR_NEST_MAX)
-               {*r = Mono_Posix_SysConf__SC_EXPR_NEST_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_EXPR_NEST_MAX; return 0;}
 #endif /* ndef _SC_EXPR_NEST_MAX */
 #ifdef _SC_FD_MGMT
        if (x == _SC_FD_MGMT)
-               {*r = Mono_Posix_SysConf__SC_FD_MGMT; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_FD_MGMT; return 0;}
 #endif /* ndef _SC_FD_MGMT */
 #ifdef _SC_FIFO
        if (x == _SC_FIFO)
-               {*r = Mono_Posix_SysConf__SC_FIFO; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_FIFO; return 0;}
 #endif /* ndef _SC_FIFO */
 #ifdef _SC_FILE_ATTRIBUTES
        if (x == _SC_FILE_ATTRIBUTES)
-               {*r = Mono_Posix_SysConf__SC_FILE_ATTRIBUTES; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_FILE_ATTRIBUTES; return 0;}
 #endif /* ndef _SC_FILE_ATTRIBUTES */
 #ifdef _SC_FILE_LOCKING
        if (x == _SC_FILE_LOCKING)
-               {*r = Mono_Posix_SysConf__SC_FILE_LOCKING; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_FILE_LOCKING; return 0;}
 #endif /* ndef _SC_FILE_LOCKING */
 #ifdef _SC_FILE_SYSTEM
        if (x == _SC_FILE_SYSTEM)
-               {*r = Mono_Posix_SysConf__SC_FILE_SYSTEM; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_FILE_SYSTEM; return 0;}
 #endif /* ndef _SC_FILE_SYSTEM */
 #ifdef _SC_FSYNC
        if (x == _SC_FSYNC)
-               {*r = Mono_Posix_SysConf__SC_FSYNC; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_FSYNC; return 0;}
 #endif /* ndef _SC_FSYNC */
 #ifdef _SC_GETGR_R_SIZE_MAX
        if (x == _SC_GETGR_R_SIZE_MAX)
-               {*r = Mono_Posix_SysConf__SC_GETGR_R_SIZE_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_GETGR_R_SIZE_MAX; return 0;}
 #endif /* ndef _SC_GETGR_R_SIZE_MAX */
 #ifdef _SC_GETPW_R_SIZE_MAX
        if (x == _SC_GETPW_R_SIZE_MAX)
-               {*r = Mono_Posix_SysConf__SC_GETPW_R_SIZE_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_GETPW_R_SIZE_MAX; return 0;}
 #endif /* ndef _SC_GETPW_R_SIZE_MAX */
 #ifdef _SC_HOST_NAME_MAX
        if (x == _SC_HOST_NAME_MAX)
-               {*r = Mono_Posix_SysConf__SC_HOST_NAME_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_HOST_NAME_MAX; return 0;}
 #endif /* ndef _SC_HOST_NAME_MAX */
 #ifdef _SC_INT_MAX
        if (x == _SC_INT_MAX)
-               {*r = Mono_Posix_SysConf__SC_INT_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_INT_MAX; return 0;}
 #endif /* ndef _SC_INT_MAX */
 #ifdef _SC_INT_MIN
        if (x == _SC_INT_MIN)
-               {*r = Mono_Posix_SysConf__SC_INT_MIN; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_INT_MIN; return 0;}
 #endif /* ndef _SC_INT_MIN */
 #ifdef _SC_IOV_MAX
        if (x == _SC_IOV_MAX)
-               {*r = Mono_Posix_SysConf__SC_IOV_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_IOV_MAX; return 0;}
 #endif /* ndef _SC_IOV_MAX */
 #ifdef _SC_JOB_CONTROL
        if (x == _SC_JOB_CONTROL)
-               {*r = Mono_Posix_SysConf__SC_JOB_CONTROL; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_JOB_CONTROL; return 0;}
 #endif /* ndef _SC_JOB_CONTROL */
 #ifdef _SC_LEVEL1_DCACHE_ASSOC
        if (x == _SC_LEVEL1_DCACHE_ASSOC)
-               {*r = Mono_Posix_SysConf__SC_LEVEL1_DCACHE_ASSOC; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL1_DCACHE_ASSOC; return 0;}
 #endif /* ndef _SC_LEVEL1_DCACHE_ASSOC */
 #ifdef _SC_LEVEL1_DCACHE_LINESIZE
        if (x == _SC_LEVEL1_DCACHE_LINESIZE)
-               {*r = Mono_Posix_SysConf__SC_LEVEL1_DCACHE_LINESIZE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL1_DCACHE_LINESIZE; return 0;}
 #endif /* ndef _SC_LEVEL1_DCACHE_LINESIZE */
 #ifdef _SC_LEVEL1_DCACHE_SIZE
        if (x == _SC_LEVEL1_DCACHE_SIZE)
-               {*r = Mono_Posix_SysConf__SC_LEVEL1_DCACHE_SIZE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL1_DCACHE_SIZE; return 0;}
 #endif /* ndef _SC_LEVEL1_DCACHE_SIZE */
 #ifdef _SC_LEVEL1_ICACHE_ASSOC
        if (x == _SC_LEVEL1_ICACHE_ASSOC)
-               {*r = Mono_Posix_SysConf__SC_LEVEL1_ICACHE_ASSOC; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL1_ICACHE_ASSOC; return 0;}
 #endif /* ndef _SC_LEVEL1_ICACHE_ASSOC */
 #ifdef _SC_LEVEL1_ICACHE_LINESIZE
        if (x == _SC_LEVEL1_ICACHE_LINESIZE)
-               {*r = Mono_Posix_SysConf__SC_LEVEL1_ICACHE_LINESIZE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL1_ICACHE_LINESIZE; return 0;}
 #endif /* ndef _SC_LEVEL1_ICACHE_LINESIZE */
 #ifdef _SC_LEVEL1_ICACHE_SIZE
        if (x == _SC_LEVEL1_ICACHE_SIZE)
-               {*r = Mono_Posix_SysConf__SC_LEVEL1_ICACHE_SIZE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL1_ICACHE_SIZE; return 0;}
 #endif /* ndef _SC_LEVEL1_ICACHE_SIZE */
 #ifdef _SC_LEVEL2_CACHE_ASSOC
        if (x == _SC_LEVEL2_CACHE_ASSOC)
-               {*r = Mono_Posix_SysConf__SC_LEVEL2_CACHE_ASSOC; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL2_CACHE_ASSOC; return 0;}
 #endif /* ndef _SC_LEVEL2_CACHE_ASSOC */
 #ifdef _SC_LEVEL2_CACHE_LINESIZE
        if (x == _SC_LEVEL2_CACHE_LINESIZE)
-               {*r = Mono_Posix_SysConf__SC_LEVEL2_CACHE_LINESIZE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL2_CACHE_LINESIZE; return 0;}
 #endif /* ndef _SC_LEVEL2_CACHE_LINESIZE */
 #ifdef _SC_LEVEL2_CACHE_SIZE
        if (x == _SC_LEVEL2_CACHE_SIZE)
-               {*r = Mono_Posix_SysConf__SC_LEVEL2_CACHE_SIZE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL2_CACHE_SIZE; return 0;}
 #endif /* ndef _SC_LEVEL2_CACHE_SIZE */
 #ifdef _SC_LEVEL3_CACHE_ASSOC
        if (x == _SC_LEVEL3_CACHE_ASSOC)
-               {*r = Mono_Posix_SysConf__SC_LEVEL3_CACHE_ASSOC; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL3_CACHE_ASSOC; return 0;}
 #endif /* ndef _SC_LEVEL3_CACHE_ASSOC */
 #ifdef _SC_LEVEL3_CACHE_LINESIZE
        if (x == _SC_LEVEL3_CACHE_LINESIZE)
-               {*r = Mono_Posix_SysConf__SC_LEVEL3_CACHE_LINESIZE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL3_CACHE_LINESIZE; return 0;}
 #endif /* ndef _SC_LEVEL3_CACHE_LINESIZE */
 #ifdef _SC_LEVEL3_CACHE_SIZE
        if (x == _SC_LEVEL3_CACHE_SIZE)
-               {*r = Mono_Posix_SysConf__SC_LEVEL3_CACHE_SIZE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL3_CACHE_SIZE; return 0;}
 #endif /* ndef _SC_LEVEL3_CACHE_SIZE */
 #ifdef _SC_LEVEL4_CACHE_ASSOC
        if (x == _SC_LEVEL4_CACHE_ASSOC)
-               {*r = Mono_Posix_SysConf__SC_LEVEL4_CACHE_ASSOC; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL4_CACHE_ASSOC; return 0;}
 #endif /* ndef _SC_LEVEL4_CACHE_ASSOC */
 #ifdef _SC_LEVEL4_CACHE_LINESIZE
        if (x == _SC_LEVEL4_CACHE_LINESIZE)
-               {*r = Mono_Posix_SysConf__SC_LEVEL4_CACHE_LINESIZE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL4_CACHE_LINESIZE; return 0;}
 #endif /* ndef _SC_LEVEL4_CACHE_LINESIZE */
 #ifdef _SC_LEVEL4_CACHE_SIZE
        if (x == _SC_LEVEL4_CACHE_SIZE)
-               {*r = Mono_Posix_SysConf__SC_LEVEL4_CACHE_SIZE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LEVEL4_CACHE_SIZE; return 0;}
 #endif /* ndef _SC_LEVEL4_CACHE_SIZE */
 #ifdef _SC_LINE_MAX
        if (x == _SC_LINE_MAX)
-               {*r = Mono_Posix_SysConf__SC_LINE_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LINE_MAX; return 0;}
 #endif /* ndef _SC_LINE_MAX */
 #ifdef _SC_LOGIN_NAME_MAX
        if (x == _SC_LOGIN_NAME_MAX)
-               {*r = Mono_Posix_SysConf__SC_LOGIN_NAME_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LOGIN_NAME_MAX; return 0;}
 #endif /* ndef _SC_LOGIN_NAME_MAX */
 #ifdef _SC_LONG_BIT
        if (x == _SC_LONG_BIT)
-               {*r = Mono_Posix_SysConf__SC_LONG_BIT; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_LONG_BIT; return 0;}
 #endif /* ndef _SC_LONG_BIT */
 #ifdef _SC_MAPPED_FILES
        if (x == _SC_MAPPED_FILES)
-               {*r = Mono_Posix_SysConf__SC_MAPPED_FILES; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_MAPPED_FILES; return 0;}
 #endif /* ndef _SC_MAPPED_FILES */
 #ifdef _SC_MB_LEN_MAX
        if (x == _SC_MB_LEN_MAX)
-               {*r = Mono_Posix_SysConf__SC_MB_LEN_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_MB_LEN_MAX; return 0;}
 #endif /* ndef _SC_MB_LEN_MAX */
 #ifdef _SC_MEMLOCK
        if (x == _SC_MEMLOCK)
-               {*r = Mono_Posix_SysConf__SC_MEMLOCK; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_MEMLOCK; return 0;}
 #endif /* ndef _SC_MEMLOCK */
 #ifdef _SC_MEMLOCK_RANGE
        if (x == _SC_MEMLOCK_RANGE)
-               {*r = Mono_Posix_SysConf__SC_MEMLOCK_RANGE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_MEMLOCK_RANGE; return 0;}
 #endif /* ndef _SC_MEMLOCK_RANGE */
 #ifdef _SC_MEMORY_PROTECTION
        if (x == _SC_MEMORY_PROTECTION)
-               {*r = Mono_Posix_SysConf__SC_MEMORY_PROTECTION; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_MEMORY_PROTECTION; return 0;}
 #endif /* ndef _SC_MEMORY_PROTECTION */
 #ifdef _SC_MESSAGE_PASSING
        if (x == _SC_MESSAGE_PASSING)
-               {*r = Mono_Posix_SysConf__SC_MESSAGE_PASSING; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_MESSAGE_PASSING; return 0;}
 #endif /* ndef _SC_MESSAGE_PASSING */
 #ifdef _SC_MONOTONIC_CLOCK
        if (x == _SC_MONOTONIC_CLOCK)
-               {*r = Mono_Posix_SysConf__SC_MONOTONIC_CLOCK; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_MONOTONIC_CLOCK; return 0;}
 #endif /* ndef _SC_MONOTONIC_CLOCK */
 #ifdef _SC_MQ_OPEN_MAX
        if (x == _SC_MQ_OPEN_MAX)
-               {*r = Mono_Posix_SysConf__SC_MQ_OPEN_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_MQ_OPEN_MAX; return 0;}
 #endif /* ndef _SC_MQ_OPEN_MAX */
 #ifdef _SC_MQ_PRIO_MAX
        if (x == _SC_MQ_PRIO_MAX)
-               {*r = Mono_Posix_SysConf__SC_MQ_PRIO_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_MQ_PRIO_MAX; return 0;}
 #endif /* ndef _SC_MQ_PRIO_MAX */
 #ifdef _SC_MULTI_PROCESS
        if (x == _SC_MULTI_PROCESS)
-               {*r = Mono_Posix_SysConf__SC_MULTI_PROCESS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_MULTI_PROCESS; return 0;}
 #endif /* ndef _SC_MULTI_PROCESS */
 #ifdef _SC_NETWORKING
        if (x == _SC_NETWORKING)
-               {*r = Mono_Posix_SysConf__SC_NETWORKING; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_NETWORKING; return 0;}
 #endif /* ndef _SC_NETWORKING */
 #ifdef _SC_NGROUPS_MAX
        if (x == _SC_NGROUPS_MAX)
-               {*r = Mono_Posix_SysConf__SC_NGROUPS_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_NGROUPS_MAX; return 0;}
 #endif /* ndef _SC_NGROUPS_MAX */
 #ifdef _SC_NL_ARGMAX
        if (x == _SC_NL_ARGMAX)
-               {*r = Mono_Posix_SysConf__SC_NL_ARGMAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_NL_ARGMAX; return 0;}
 #endif /* ndef _SC_NL_ARGMAX */
 #ifdef _SC_NL_LANGMAX
        if (x == _SC_NL_LANGMAX)
-               {*r = Mono_Posix_SysConf__SC_NL_LANGMAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_NL_LANGMAX; return 0;}
 #endif /* ndef _SC_NL_LANGMAX */
 #ifdef _SC_NL_MSGMAX
        if (x == _SC_NL_MSGMAX)
-               {*r = Mono_Posix_SysConf__SC_NL_MSGMAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_NL_MSGMAX; return 0;}
 #endif /* ndef _SC_NL_MSGMAX */
 #ifdef _SC_NL_NMAX
        if (x == _SC_NL_NMAX)
-               {*r = Mono_Posix_SysConf__SC_NL_NMAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_NL_NMAX; return 0;}
 #endif /* ndef _SC_NL_NMAX */
 #ifdef _SC_NL_SETMAX
        if (x == _SC_NL_SETMAX)
-               {*r = Mono_Posix_SysConf__SC_NL_SETMAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_NL_SETMAX; return 0;}
 #endif /* ndef _SC_NL_SETMAX */
 #ifdef _SC_NL_TEXTMAX
        if (x == _SC_NL_TEXTMAX)
-               {*r = Mono_Posix_SysConf__SC_NL_TEXTMAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_NL_TEXTMAX; return 0;}
 #endif /* ndef _SC_NL_TEXTMAX */
 #ifdef _SC_NPROCESSORS_CONF
        if (x == _SC_NPROCESSORS_CONF)
-               {*r = Mono_Posix_SysConf__SC_NPROCESSORS_CONF; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_NPROCESSORS_CONF; return 0;}
 #endif /* ndef _SC_NPROCESSORS_CONF */
 #ifdef _SC_NPROCESSORS_ONLN
        if (x == _SC_NPROCESSORS_ONLN)
-               {*r = Mono_Posix_SysConf__SC_NPROCESSORS_ONLN; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_NPROCESSORS_ONLN; return 0;}
 #endif /* ndef _SC_NPROCESSORS_ONLN */
 #ifdef _SC_NZERO
        if (x == _SC_NZERO)
-               {*r = Mono_Posix_SysConf__SC_NZERO; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_NZERO; return 0;}
 #endif /* ndef _SC_NZERO */
 #ifdef _SC_OPEN_MAX
        if (x == _SC_OPEN_MAX)
-               {*r = Mono_Posix_SysConf__SC_OPEN_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_OPEN_MAX; return 0;}
 #endif /* ndef _SC_OPEN_MAX */
 #ifdef _SC_PAGESIZE
        if (x == _SC_PAGESIZE)
-               {*r = Mono_Posix_SysConf__SC_PAGESIZE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PAGESIZE; return 0;}
 #endif /* ndef _SC_PAGESIZE */
 #ifdef _SC_PASS_MAX
        if (x == _SC_PASS_MAX)
-               {*r = Mono_Posix_SysConf__SC_PASS_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PASS_MAX; return 0;}
 #endif /* ndef _SC_PASS_MAX */
 #ifdef _SC_PHYS_PAGES
        if (x == _SC_PHYS_PAGES)
-               {*r = Mono_Posix_SysConf__SC_PHYS_PAGES; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PHYS_PAGES; return 0;}
 #endif /* ndef _SC_PHYS_PAGES */
 #ifdef _SC_PII
        if (x == _SC_PII)
-               {*r = Mono_Posix_SysConf__SC_PII; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PII; return 0;}
 #endif /* ndef _SC_PII */
 #ifdef _SC_PII_INTERNET
        if (x == _SC_PII_INTERNET)
-               {*r = Mono_Posix_SysConf__SC_PII_INTERNET; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PII_INTERNET; return 0;}
 #endif /* ndef _SC_PII_INTERNET */
 #ifdef _SC_PII_INTERNET_DGRAM
        if (x == _SC_PII_INTERNET_DGRAM)
-               {*r = Mono_Posix_SysConf__SC_PII_INTERNET_DGRAM; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PII_INTERNET_DGRAM; return 0;}
 #endif /* ndef _SC_PII_INTERNET_DGRAM */
 #ifdef _SC_PII_INTERNET_STREAM
        if (x == _SC_PII_INTERNET_STREAM)
-               {*r = Mono_Posix_SysConf__SC_PII_INTERNET_STREAM; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PII_INTERNET_STREAM; return 0;}
 #endif /* ndef _SC_PII_INTERNET_STREAM */
 #ifdef _SC_PII_OSI
        if (x == _SC_PII_OSI)
-               {*r = Mono_Posix_SysConf__SC_PII_OSI; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PII_OSI; return 0;}
 #endif /* ndef _SC_PII_OSI */
 #ifdef _SC_PII_OSI_CLTS
        if (x == _SC_PII_OSI_CLTS)
-               {*r = Mono_Posix_SysConf__SC_PII_OSI_CLTS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PII_OSI_CLTS; return 0;}
 #endif /* ndef _SC_PII_OSI_CLTS */
 #ifdef _SC_PII_OSI_COTS
        if (x == _SC_PII_OSI_COTS)
-               {*r = Mono_Posix_SysConf__SC_PII_OSI_COTS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PII_OSI_COTS; return 0;}
 #endif /* ndef _SC_PII_OSI_COTS */
 #ifdef _SC_PII_OSI_M
        if (x == _SC_PII_OSI_M)
-               {*r = Mono_Posix_SysConf__SC_PII_OSI_M; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PII_OSI_M; return 0;}
 #endif /* ndef _SC_PII_OSI_M */
 #ifdef _SC_PII_SOCKET
        if (x == _SC_PII_SOCKET)
-               {*r = Mono_Posix_SysConf__SC_PII_SOCKET; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PII_SOCKET; return 0;}
 #endif /* ndef _SC_PII_SOCKET */
 #ifdef _SC_PII_XTI
        if (x == _SC_PII_XTI)
-               {*r = Mono_Posix_SysConf__SC_PII_XTI; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PII_XTI; return 0;}
 #endif /* ndef _SC_PII_XTI */
 #ifdef _SC_PIPE
        if (x == _SC_PIPE)
-               {*r = Mono_Posix_SysConf__SC_PIPE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PIPE; return 0;}
 #endif /* ndef _SC_PIPE */
 #ifdef _SC_POLL
        if (x == _SC_POLL)
-               {*r = Mono_Posix_SysConf__SC_POLL; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_POLL; return 0;}
 #endif /* ndef _SC_POLL */
 #ifdef _SC_PRIORITIZED_IO
        if (x == _SC_PRIORITIZED_IO)
-               {*r = Mono_Posix_SysConf__SC_PRIORITIZED_IO; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PRIORITIZED_IO; return 0;}
 #endif /* ndef _SC_PRIORITIZED_IO */
 #ifdef _SC_PRIORITY_SCHEDULING
        if (x == _SC_PRIORITY_SCHEDULING)
-               {*r = Mono_Posix_SysConf__SC_PRIORITY_SCHEDULING; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_PRIORITY_SCHEDULING; return 0;}
 #endif /* ndef _SC_PRIORITY_SCHEDULING */
 #ifdef _SC_READER_WRITER_LOCKS
        if (x == _SC_READER_WRITER_LOCKS)
-               {*r = Mono_Posix_SysConf__SC_READER_WRITER_LOCKS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_READER_WRITER_LOCKS; return 0;}
 #endif /* ndef _SC_READER_WRITER_LOCKS */
 #ifdef _SC_REALTIME_SIGNALS
        if (x == _SC_REALTIME_SIGNALS)
-               {*r = Mono_Posix_SysConf__SC_REALTIME_SIGNALS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_REALTIME_SIGNALS; return 0;}
 #endif /* ndef _SC_REALTIME_SIGNALS */
 #ifdef _SC_REGEXP
        if (x == _SC_REGEXP)
-               {*r = Mono_Posix_SysConf__SC_REGEXP; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_REGEXP; return 0;}
 #endif /* ndef _SC_REGEXP */
 #ifdef _SC_REGEX_VERSION
        if (x == _SC_REGEX_VERSION)
-               {*r = Mono_Posix_SysConf__SC_REGEX_VERSION; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_REGEX_VERSION; return 0;}
 #endif /* ndef _SC_REGEX_VERSION */
 #ifdef _SC_RE_DUP_MAX
        if (x == _SC_RE_DUP_MAX)
-               {*r = Mono_Posix_SysConf__SC_RE_DUP_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_RE_DUP_MAX; return 0;}
 #endif /* ndef _SC_RE_DUP_MAX */
 #ifdef _SC_RTSIG_MAX
        if (x == _SC_RTSIG_MAX)
-               {*r = Mono_Posix_SysConf__SC_RTSIG_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_RTSIG_MAX; return 0;}
 #endif /* ndef _SC_RTSIG_MAX */
 #ifdef _SC_SAVED_IDS
        if (x == _SC_SAVED_IDS)
-               {*r = Mono_Posix_SysConf__SC_SAVED_IDS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SAVED_IDS; return 0;}
 #endif /* ndef _SC_SAVED_IDS */
 #ifdef _SC_SCHAR_MAX
        if (x == _SC_SCHAR_MAX)
-               {*r = Mono_Posix_SysConf__SC_SCHAR_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SCHAR_MAX; return 0;}
 #endif /* ndef _SC_SCHAR_MAX */
 #ifdef _SC_SCHAR_MIN
        if (x == _SC_SCHAR_MIN)
-               {*r = Mono_Posix_SysConf__SC_SCHAR_MIN; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SCHAR_MIN; return 0;}
 #endif /* ndef _SC_SCHAR_MIN */
 #ifdef _SC_SELECT
        if (x == _SC_SELECT)
-               {*r = Mono_Posix_SysConf__SC_SELECT; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SELECT; return 0;}
 #endif /* ndef _SC_SELECT */
 #ifdef _SC_SEMAPHORES
        if (x == _SC_SEMAPHORES)
-               {*r = Mono_Posix_SysConf__SC_SEMAPHORES; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SEMAPHORES; return 0;}
 #endif /* ndef _SC_SEMAPHORES */
 #ifdef _SC_SEM_NSEMS_MAX
        if (x == _SC_SEM_NSEMS_MAX)
-               {*r = Mono_Posix_SysConf__SC_SEM_NSEMS_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SEM_NSEMS_MAX; return 0;}
 #endif /* ndef _SC_SEM_NSEMS_MAX */
 #ifdef _SC_SEM_VALUE_MAX
        if (x == _SC_SEM_VALUE_MAX)
-               {*r = Mono_Posix_SysConf__SC_SEM_VALUE_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SEM_VALUE_MAX; return 0;}
 #endif /* ndef _SC_SEM_VALUE_MAX */
 #ifdef _SC_SHARED_MEMORY_OBJECTS
        if (x == _SC_SHARED_MEMORY_OBJECTS)
-               {*r = Mono_Posix_SysConf__SC_SHARED_MEMORY_OBJECTS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SHARED_MEMORY_OBJECTS; return 0;}
 #endif /* ndef _SC_SHARED_MEMORY_OBJECTS */
 #ifdef _SC_SHELL
        if (x == _SC_SHELL)
-               {*r = Mono_Posix_SysConf__SC_SHELL; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SHELL; return 0;}
 #endif /* ndef _SC_SHELL */
 #ifdef _SC_SHRT_MAX
        if (x == _SC_SHRT_MAX)
-               {*r = Mono_Posix_SysConf__SC_SHRT_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SHRT_MAX; return 0;}
 #endif /* ndef _SC_SHRT_MAX */
 #ifdef _SC_SHRT_MIN
        if (x == _SC_SHRT_MIN)
-               {*r = Mono_Posix_SysConf__SC_SHRT_MIN; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SHRT_MIN; return 0;}
 #endif /* ndef _SC_SHRT_MIN */
 #ifdef _SC_SIGNALS
        if (x == _SC_SIGNALS)
-               {*r = Mono_Posix_SysConf__SC_SIGNALS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SIGNALS; return 0;}
 #endif /* ndef _SC_SIGNALS */
 #ifdef _SC_SIGQUEUE_MAX
        if (x == _SC_SIGQUEUE_MAX)
-               {*r = Mono_Posix_SysConf__SC_SIGQUEUE_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SIGQUEUE_MAX; return 0;}
 #endif /* ndef _SC_SIGQUEUE_MAX */
 #ifdef _SC_SINGLE_PROCESS
        if (x == _SC_SINGLE_PROCESS)
-               {*r = Mono_Posix_SysConf__SC_SINGLE_PROCESS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SINGLE_PROCESS; return 0;}
 #endif /* ndef _SC_SINGLE_PROCESS */
 #ifdef _SC_SPAWN
        if (x == _SC_SPAWN)
-               {*r = Mono_Posix_SysConf__SC_SPAWN; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SPAWN; return 0;}
 #endif /* ndef _SC_SPAWN */
 #ifdef _SC_SPIN_LOCKS
        if (x == _SC_SPIN_LOCKS)
-               {*r = Mono_Posix_SysConf__SC_SPIN_LOCKS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SPIN_LOCKS; return 0;}
 #endif /* ndef _SC_SPIN_LOCKS */
 #ifdef _SC_SPORADIC_SERVER
        if (x == _SC_SPORADIC_SERVER)
-               {*r = Mono_Posix_SysConf__SC_SPORADIC_SERVER; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SPORADIC_SERVER; return 0;}
 #endif /* ndef _SC_SPORADIC_SERVER */
 #ifdef _SC_SSIZE_MAX
        if (x == _SC_SSIZE_MAX)
-               {*r = Mono_Posix_SysConf__SC_SSIZE_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SSIZE_MAX; return 0;}
 #endif /* ndef _SC_SSIZE_MAX */
 #ifdef _SC_STREAMS
        if (x == _SC_STREAMS)
-               {*r = Mono_Posix_SysConf__SC_STREAMS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_STREAMS; return 0;}
 #endif /* ndef _SC_STREAMS */
 #ifdef _SC_STREAM_MAX
        if (x == _SC_STREAM_MAX)
-               {*r = Mono_Posix_SysConf__SC_STREAM_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_STREAM_MAX; return 0;}
 #endif /* ndef _SC_STREAM_MAX */
 #ifdef _SC_SYMLOOP_MAX
        if (x == _SC_SYMLOOP_MAX)
-               {*r = Mono_Posix_SysConf__SC_SYMLOOP_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SYMLOOP_MAX; return 0;}
 #endif /* ndef _SC_SYMLOOP_MAX */
 #ifdef _SC_SYNCHRONIZED_IO
        if (x == _SC_SYNCHRONIZED_IO)
-               {*r = Mono_Posix_SysConf__SC_SYNCHRONIZED_IO; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SYNCHRONIZED_IO; return 0;}
 #endif /* ndef _SC_SYNCHRONIZED_IO */
 #ifdef _SC_SYSTEM_DATABASE
        if (x == _SC_SYSTEM_DATABASE)
-               {*r = Mono_Posix_SysConf__SC_SYSTEM_DATABASE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SYSTEM_DATABASE; return 0;}
 #endif /* ndef _SC_SYSTEM_DATABASE */
 #ifdef _SC_SYSTEM_DATABASE_R
        if (x == _SC_SYSTEM_DATABASE_R)
-               {*r = Mono_Posix_SysConf__SC_SYSTEM_DATABASE_R; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_SYSTEM_DATABASE_R; return 0;}
 #endif /* ndef _SC_SYSTEM_DATABASE_R */
 #ifdef _SC_THREADS
        if (x == _SC_THREADS)
-               {*r = Mono_Posix_SysConf__SC_THREADS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREADS; return 0;}
 #endif /* ndef _SC_THREADS */
 #ifdef _SC_THREAD_ATTR_STACKADDR
        if (x == _SC_THREAD_ATTR_STACKADDR)
-               {*r = Mono_Posix_SysConf__SC_THREAD_ATTR_STACKADDR; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_ATTR_STACKADDR; return 0;}
 #endif /* ndef _SC_THREAD_ATTR_STACKADDR */
 #ifdef _SC_THREAD_ATTR_STACKSIZE
        if (x == _SC_THREAD_ATTR_STACKSIZE)
-               {*r = Mono_Posix_SysConf__SC_THREAD_ATTR_STACKSIZE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_ATTR_STACKSIZE; return 0;}
 #endif /* ndef _SC_THREAD_ATTR_STACKSIZE */
 #ifdef _SC_THREAD_CPUTIME
        if (x == _SC_THREAD_CPUTIME)
-               {*r = Mono_Posix_SysConf__SC_THREAD_CPUTIME; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_CPUTIME; return 0;}
 #endif /* ndef _SC_THREAD_CPUTIME */
 #ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS
        if (x == _SC_THREAD_DESTRUCTOR_ITERATIONS)
-               {*r = Mono_Posix_SysConf__SC_THREAD_DESTRUCTOR_ITERATIONS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_DESTRUCTOR_ITERATIONS; return 0;}
 #endif /* ndef _SC_THREAD_DESTRUCTOR_ITERATIONS */
 #ifdef _SC_THREAD_KEYS_MAX
        if (x == _SC_THREAD_KEYS_MAX)
-               {*r = Mono_Posix_SysConf__SC_THREAD_KEYS_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_KEYS_MAX; return 0;}
 #endif /* ndef _SC_THREAD_KEYS_MAX */
 #ifdef _SC_THREAD_PRIORITY_SCHEDULING
        if (x == _SC_THREAD_PRIORITY_SCHEDULING)
-               {*r = Mono_Posix_SysConf__SC_THREAD_PRIORITY_SCHEDULING; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_PRIORITY_SCHEDULING; return 0;}
 #endif /* ndef _SC_THREAD_PRIORITY_SCHEDULING */
 #ifdef _SC_THREAD_PRIO_INHERIT
        if (x == _SC_THREAD_PRIO_INHERIT)
-               {*r = Mono_Posix_SysConf__SC_THREAD_PRIO_INHERIT; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_PRIO_INHERIT; return 0;}
 #endif /* ndef _SC_THREAD_PRIO_INHERIT */
 #ifdef _SC_THREAD_PRIO_PROTECT
        if (x == _SC_THREAD_PRIO_PROTECT)
-               {*r = Mono_Posix_SysConf__SC_THREAD_PRIO_PROTECT; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_PRIO_PROTECT; return 0;}
 #endif /* ndef _SC_THREAD_PRIO_PROTECT */
 #ifdef _SC_THREAD_PROCESS_SHARED
        if (x == _SC_THREAD_PROCESS_SHARED)
-               {*r = Mono_Posix_SysConf__SC_THREAD_PROCESS_SHARED; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_PROCESS_SHARED; return 0;}
 #endif /* ndef _SC_THREAD_PROCESS_SHARED */
 #ifdef _SC_THREAD_SAFE_FUNCTIONS
        if (x == _SC_THREAD_SAFE_FUNCTIONS)
-               {*r = Mono_Posix_SysConf__SC_THREAD_SAFE_FUNCTIONS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_SAFE_FUNCTIONS; return 0;}
 #endif /* ndef _SC_THREAD_SAFE_FUNCTIONS */
 #ifdef _SC_THREAD_SPORADIC_SERVER
        if (x == _SC_THREAD_SPORADIC_SERVER)
-               {*r = Mono_Posix_SysConf__SC_THREAD_SPORADIC_SERVER; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_SPORADIC_SERVER; return 0;}
 #endif /* ndef _SC_THREAD_SPORADIC_SERVER */
 #ifdef _SC_THREAD_STACK_MIN
        if (x == _SC_THREAD_STACK_MIN)
-               {*r = Mono_Posix_SysConf__SC_THREAD_STACK_MIN; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_STACK_MIN; return 0;}
 #endif /* ndef _SC_THREAD_STACK_MIN */
 #ifdef _SC_THREAD_THREADS_MAX
        if (x == _SC_THREAD_THREADS_MAX)
-               {*r = Mono_Posix_SysConf__SC_THREAD_THREADS_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_THREAD_THREADS_MAX; return 0;}
 #endif /* ndef _SC_THREAD_THREADS_MAX */
 #ifdef _SC_TIMEOUTS
        if (x == _SC_TIMEOUTS)
-               {*r = Mono_Posix_SysConf__SC_TIMEOUTS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_TIMEOUTS; return 0;}
 #endif /* ndef _SC_TIMEOUTS */
 #ifdef _SC_TIMERS
        if (x == _SC_TIMERS)
-               {*r = Mono_Posix_SysConf__SC_TIMERS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_TIMERS; return 0;}
 #endif /* ndef _SC_TIMERS */
 #ifdef _SC_TIMER_MAX
        if (x == _SC_TIMER_MAX)
-               {*r = Mono_Posix_SysConf__SC_TIMER_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_TIMER_MAX; return 0;}
 #endif /* ndef _SC_TIMER_MAX */
 #ifdef _SC_TRACE
        if (x == _SC_TRACE)
-               {*r = Mono_Posix_SysConf__SC_TRACE; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_TRACE; return 0;}
 #endif /* ndef _SC_TRACE */
 #ifdef _SC_TRACE_EVENT_FILTER
        if (x == _SC_TRACE_EVENT_FILTER)
-               {*r = Mono_Posix_SysConf__SC_TRACE_EVENT_FILTER; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_TRACE_EVENT_FILTER; return 0;}
 #endif /* ndef _SC_TRACE_EVENT_FILTER */
 #ifdef _SC_TRACE_INHERIT
        if (x == _SC_TRACE_INHERIT)
-               {*r = Mono_Posix_SysConf__SC_TRACE_INHERIT; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_TRACE_INHERIT; return 0;}
 #endif /* ndef _SC_TRACE_INHERIT */
 #ifdef _SC_TRACE_LOG
        if (x == _SC_TRACE_LOG)
-               {*r = Mono_Posix_SysConf__SC_TRACE_LOG; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_TRACE_LOG; return 0;}
 #endif /* ndef _SC_TRACE_LOG */
 #ifdef _SC_TTY_NAME_MAX
        if (x == _SC_TTY_NAME_MAX)
-               {*r = Mono_Posix_SysConf__SC_TTY_NAME_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_TTY_NAME_MAX; return 0;}
 #endif /* ndef _SC_TTY_NAME_MAX */
 #ifdef _SC_TYPED_MEMORY_OBJECTS
        if (x == _SC_TYPED_MEMORY_OBJECTS)
-               {*r = Mono_Posix_SysConf__SC_TYPED_MEMORY_OBJECTS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_TYPED_MEMORY_OBJECTS; return 0;}
 #endif /* ndef _SC_TYPED_MEMORY_OBJECTS */
 #ifdef _SC_TZNAME_MAX
        if (x == _SC_TZNAME_MAX)
-               {*r = Mono_Posix_SysConf__SC_TZNAME_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_TZNAME_MAX; return 0;}
 #endif /* ndef _SC_TZNAME_MAX */
 #ifdef _SC_T_IOV_MAX
        if (x == _SC_T_IOV_MAX)
-               {*r = Mono_Posix_SysConf__SC_T_IOV_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_T_IOV_MAX; return 0;}
 #endif /* ndef _SC_T_IOV_MAX */
 #ifdef _SC_UCHAR_MAX
        if (x == _SC_UCHAR_MAX)
-               {*r = Mono_Posix_SysConf__SC_UCHAR_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_UCHAR_MAX; return 0;}
 #endif /* ndef _SC_UCHAR_MAX */
 #ifdef _SC_UINT_MAX
        if (x == _SC_UINT_MAX)
-               {*r = Mono_Posix_SysConf__SC_UINT_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_UINT_MAX; return 0;}
 #endif /* ndef _SC_UINT_MAX */
 #ifdef _SC_UIO_MAXIOV
        if (x == _SC_UIO_MAXIOV)
-               {*r = Mono_Posix_SysConf__SC_UIO_MAXIOV; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_UIO_MAXIOV; return 0;}
 #endif /* ndef _SC_UIO_MAXIOV */
 #ifdef _SC_ULONG_MAX
        if (x == _SC_ULONG_MAX)
-               {*r = Mono_Posix_SysConf__SC_ULONG_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_ULONG_MAX; return 0;}
 #endif /* ndef _SC_ULONG_MAX */
 #ifdef _SC_USER_GROUPS
        if (x == _SC_USER_GROUPS)
-               {*r = Mono_Posix_SysConf__SC_USER_GROUPS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_USER_GROUPS; return 0;}
 #endif /* ndef _SC_USER_GROUPS */
 #ifdef _SC_USER_GROUPS_R
        if (x == _SC_USER_GROUPS_R)
-               {*r = Mono_Posix_SysConf__SC_USER_GROUPS_R; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_USER_GROUPS_R; return 0;}
 #endif /* ndef _SC_USER_GROUPS_R */
 #ifdef _SC_USHRT_MAX
        if (x == _SC_USHRT_MAX)
-               {*r = Mono_Posix_SysConf__SC_USHRT_MAX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_USHRT_MAX; return 0;}
 #endif /* ndef _SC_USHRT_MAX */
 #ifdef _SC_V6_ILP32_OFF32
        if (x == _SC_V6_ILP32_OFF32)
-               {*r = Mono_Posix_SysConf__SC_V6_ILP32_OFF32; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_V6_ILP32_OFF32; return 0;}
 #endif /* ndef _SC_V6_ILP32_OFF32 */
 #ifdef _SC_V6_ILP32_OFFBIG
        if (x == _SC_V6_ILP32_OFFBIG)
-               {*r = Mono_Posix_SysConf__SC_V6_ILP32_OFFBIG; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_V6_ILP32_OFFBIG; return 0;}
 #endif /* ndef _SC_V6_ILP32_OFFBIG */
 #ifdef _SC_V6_LP64_OFF64
        if (x == _SC_V6_LP64_OFF64)
-               {*r = Mono_Posix_SysConf__SC_V6_LP64_OFF64; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_V6_LP64_OFF64; return 0;}
 #endif /* ndef _SC_V6_LP64_OFF64 */
 #ifdef _SC_V6_LPBIG_OFFBIG
        if (x == _SC_V6_LPBIG_OFFBIG)
-               {*r = Mono_Posix_SysConf__SC_V6_LPBIG_OFFBIG; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_V6_LPBIG_OFFBIG; return 0;}
 #endif /* ndef _SC_V6_LPBIG_OFFBIG */
 #ifdef _SC_VERSION
        if (x == _SC_VERSION)
-               {*r = Mono_Posix_SysConf__SC_VERSION; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_VERSION; return 0;}
 #endif /* ndef _SC_VERSION */
 #ifdef _SC_WORD_BIT
        if (x == _SC_WORD_BIT)
-               {*r = Mono_Posix_SysConf__SC_WORD_BIT; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_WORD_BIT; return 0;}
 #endif /* ndef _SC_WORD_BIT */
 #ifdef _SC_XBS5_ILP32_OFF32
        if (x == _SC_XBS5_ILP32_OFF32)
-               {*r = Mono_Posix_SysConf__SC_XBS5_ILP32_OFF32; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XBS5_ILP32_OFF32; return 0;}
 #endif /* ndef _SC_XBS5_ILP32_OFF32 */
 #ifdef _SC_XBS5_ILP32_OFFBIG
        if (x == _SC_XBS5_ILP32_OFFBIG)
-               {*r = Mono_Posix_SysConf__SC_XBS5_ILP32_OFFBIG; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XBS5_ILP32_OFFBIG; return 0;}
 #endif /* ndef _SC_XBS5_ILP32_OFFBIG */
 #ifdef _SC_XBS5_LP64_OFF64
        if (x == _SC_XBS5_LP64_OFF64)
-               {*r = Mono_Posix_SysConf__SC_XBS5_LP64_OFF64; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XBS5_LP64_OFF64; return 0;}
 #endif /* ndef _SC_XBS5_LP64_OFF64 */
 #ifdef _SC_XBS5_LPBIG_OFFBIG
        if (x == _SC_XBS5_LPBIG_OFFBIG)
-               {*r = Mono_Posix_SysConf__SC_XBS5_LPBIG_OFFBIG; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XBS5_LPBIG_OFFBIG; return 0;}
 #endif /* ndef _SC_XBS5_LPBIG_OFFBIG */
 #ifdef _SC_XOPEN_CRYPT
        if (x == _SC_XOPEN_CRYPT)
-               {*r = Mono_Posix_SysConf__SC_XOPEN_CRYPT; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XOPEN_CRYPT; return 0;}
 #endif /* ndef _SC_XOPEN_CRYPT */
 #ifdef _SC_XOPEN_ENH_I18N
        if (x == _SC_XOPEN_ENH_I18N)
-               {*r = Mono_Posix_SysConf__SC_XOPEN_ENH_I18N; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XOPEN_ENH_I18N; return 0;}
 #endif /* ndef _SC_XOPEN_ENH_I18N */
 #ifdef _SC_XOPEN_LEGACY
        if (x == _SC_XOPEN_LEGACY)
-               {*r = Mono_Posix_SysConf__SC_XOPEN_LEGACY; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XOPEN_LEGACY; return 0;}
 #endif /* ndef _SC_XOPEN_LEGACY */
 #ifdef _SC_XOPEN_REALTIME
        if (x == _SC_XOPEN_REALTIME)
-               {*r = Mono_Posix_SysConf__SC_XOPEN_REALTIME; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XOPEN_REALTIME; return 0;}
 #endif /* ndef _SC_XOPEN_REALTIME */
 #ifdef _SC_XOPEN_REALTIME_THREADS
        if (x == _SC_XOPEN_REALTIME_THREADS)
-               {*r = Mono_Posix_SysConf__SC_XOPEN_REALTIME_THREADS; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XOPEN_REALTIME_THREADS; return 0;}
 #endif /* ndef _SC_XOPEN_REALTIME_THREADS */
 #ifdef _SC_XOPEN_SHM
        if (x == _SC_XOPEN_SHM)
-               {*r = Mono_Posix_SysConf__SC_XOPEN_SHM; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XOPEN_SHM; return 0;}
 #endif /* ndef _SC_XOPEN_SHM */
 #ifdef _SC_XOPEN_UNIX
        if (x == _SC_XOPEN_UNIX)
-               {*r = Mono_Posix_SysConf__SC_XOPEN_UNIX; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XOPEN_UNIX; return 0;}
 #endif /* ndef _SC_XOPEN_UNIX */
 #ifdef _SC_XOPEN_VERSION
        if (x == _SC_XOPEN_VERSION)
-               {*r = Mono_Posix_SysConf__SC_XOPEN_VERSION; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XOPEN_VERSION; return 0;}
 #endif /* ndef _SC_XOPEN_VERSION */
 #ifdef _SC_XOPEN_XCU_VERSION
        if (x == _SC_XOPEN_XCU_VERSION)
-               {*r = Mono_Posix_SysConf__SC_XOPEN_XCU_VERSION; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XOPEN_XCU_VERSION; return 0;}
 #endif /* ndef _SC_XOPEN_XCU_VERSION */
 #ifdef _SC_XOPEN_XPG2
        if (x == _SC_XOPEN_XPG2)
-               {*r = Mono_Posix_SysConf__SC_XOPEN_XPG2; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XOPEN_XPG2; return 0;}
 #endif /* ndef _SC_XOPEN_XPG2 */
 #ifdef _SC_XOPEN_XPG3
        if (x == _SC_XOPEN_XPG3)
-               {*r = Mono_Posix_SysConf__SC_XOPEN_XPG3; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XOPEN_XPG3; return 0;}
 #endif /* ndef _SC_XOPEN_XPG3 */
 #ifdef _SC_XOPEN_XPG4
        if (x == _SC_XOPEN_XPG4)
-               {*r = Mono_Posix_SysConf__SC_XOPEN_XPG4; return 0;}
+               {*r = Mono_Posix_SysconfName__SC_XOPEN_XPG4; return 0;}
 #endif /* ndef _SC_XOPEN_XPG4 */
        errno = EINVAL; return -1;
 }
@@ -7404,8 +6413,6 @@ int Mono_Posix_ToSysConf (int x, int *r)
 int Mono_Posix_FromSyslogFacility (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if (x == Mono_Posix_SyslogFacility_LOG_AUTH)
 #ifdef LOG_AUTH
                {*r = LOG_AUTH; return 0;}
@@ -7520,13 +6527,14 @@ int Mono_Posix_FromSyslogFacility (int x, int *r)
 #else /* def LOG_USER */
                {errno = EINVAL; return -1;}
 #endif /* ndef LOG_USER */
-       /* Mono_Posix_SyslogFacility_LOG_USRE is obsolete; ignoring */
        if (x == Mono_Posix_SyslogFacility_LOG_UUCP)
 #ifdef LOG_UUCP
                {*r = LOG_UUCP; return 0;}
 #else /* def LOG_UUCP */
                {errno = EINVAL; return -1;}
 #endif /* ndef LOG_UUCP */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
@@ -7611,10 +6619,6 @@ int Mono_Posix_ToSyslogFacility (int x, int *r)
        if (x == LOG_USER)
                {*r = Mono_Posix_SyslogFacility_LOG_USER; return 0;}
 #endif /* ndef LOG_USER */
-#ifdef LOG_USRE
-       if (x == LOG_USRE)
-               {*r = Mono_Posix_SyslogFacility_LOG_USRE; return 0;}
-#endif /* ndef LOG_USRE */
 #ifdef LOG_UUCP
        if (x == LOG_UUCP)
                {*r = Mono_Posix_SyslogFacility_LOG_UUCP; return 0;}
@@ -7625,8 +6629,6 @@ int Mono_Posix_ToSyslogFacility (int x, int *r)
 int Mono_Posix_FromSyslogLevel (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if (x == Mono_Posix_SyslogLevel_LOG_ALERT)
 #ifdef LOG_ALERT
                {*r = LOG_ALERT; return 0;}
@@ -7675,6 +6677,8 @@ int Mono_Posix_FromSyslogLevel (int x, int *r)
 #else /* def LOG_WARNING */
                {errno = EINVAL; return -1;}
 #endif /* ndef LOG_WARNING */
+       if (x == 0)
+               return 0;
        errno = EINVAL; return -1;
 }
 
@@ -7721,8 +6725,6 @@ int Mono_Posix_ToSyslogLevel (int x, int *r)
 int Mono_Posix_FromSyslogOptions (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_SyslogOptions_LOG_CONS) == Mono_Posix_SyslogOptions_LOG_CONS)
 #ifdef LOG_CONS
                *r |= LOG_CONS;
@@ -7759,6 +6761,8 @@ int Mono_Posix_FromSyslogOptions (int x, int *r)
 #else /* def LOG_PID */
                {errno = EINVAL; return -1;}
 #endif /* ndef LOG_PID */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -7794,11 +6798,145 @@ int Mono_Posix_ToSyslogOptions (int x, int *r)
        return 0;
 }
 
+#ifdef HAVE_STRUCT_TIMESPEC
+int
+Mono_Posix_FromTimespec (struct Mono_Posix_Timespec *from, struct timespec *to)
+{
+       _cnm_return_val_if_overflow (time_t, from->tv_sec, -1);
+       _cnm_return_val_if_overflow (gint64, from->tv_nsec, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       to->tv_sec  = from->tv_sec;
+       to->tv_nsec = from->tv_nsec;
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_TIMESPEC */
+
+
+#ifdef HAVE_STRUCT_TIMESPEC
+int
+Mono_Posix_ToTimespec (struct timespec *from, struct Mono_Posix_Timespec *to)
+{
+       _cnm_return_val_if_overflow (gint64, from->tv_sec, -1);
+       _cnm_return_val_if_overflow (gint64, from->tv_nsec, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       to->tv_sec  = from->tv_sec;
+       to->tv_nsec = from->tv_nsec;
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_TIMESPEC */
+
+
+#ifdef HAVE_STRUCT_TIMEVAL
+int
+Mono_Posix_FromTimeval (struct Mono_Posix_Timeval *from, struct timeval *to)
+{
+       _cnm_return_val_if_overflow (time_t, from->tv_sec, -1);
+       _cnm_return_val_if_overflow (suseconds_t, from->tv_usec, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       to->tv_sec  = from->tv_sec;
+       to->tv_usec = from->tv_usec;
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_TIMEVAL */
+
+
+#ifdef HAVE_STRUCT_TIMEVAL
+int
+Mono_Posix_ToTimeval (struct timeval *from, struct Mono_Posix_Timeval *to)
+{
+       _cnm_return_val_if_overflow (gint64, from->tv_sec, -1);
+       _cnm_return_val_if_overflow (gint64, from->tv_usec, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       to->tv_sec  = from->tv_sec;
+       to->tv_usec = from->tv_usec;
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_TIMEVAL */
+
+
+#ifdef HAVE_STRUCT_TIMEZONE
+int
+Mono_Posix_FromTimezone (struct Mono_Posix_Timezone *from, struct timezone *to)
+{
+       _cnm_return_val_if_overflow (int, from->tz_minuteswest, -1);
+       _cnm_return_val_if_overflow (int, from->tz_dsttime, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       to->tz_minuteswest = from->tz_minuteswest;
+       to->tz_dsttime     = from->tz_dsttime;
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_TIMEZONE */
+
+
+#ifdef HAVE_STRUCT_TIMEZONE
+int
+Mono_Posix_ToTimezone (struct timezone *from, struct Mono_Posix_Timezone *to)
+{
+       _cnm_return_val_if_overflow (int, from->tz_minuteswest, -1);
+       _cnm_return_val_if_overflow (int, from->tz_dsttime, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       to->tz_minuteswest = from->tz_minuteswest;
+       to->tz_dsttime     = from->tz_dsttime;
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_TIMEZONE */
+
+
+#ifdef HAVE_STRUCT_UTIMBUF
+int
+Mono_Posix_FromUtimbuf (struct Mono_Posix_Utimbuf *from, struct utimbuf *to)
+{
+       _cnm_return_val_if_overflow (time_t, from->actime, -1);
+       _cnm_return_val_if_overflow (time_t, from->modtime, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       to->actime  = from->actime;
+       to->modtime = from->modtime;
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_UTIMBUF */
+
+
+#ifdef HAVE_STRUCT_UTIMBUF
+int
+Mono_Posix_ToUtimbuf (struct utimbuf *from, struct Mono_Posix_Utimbuf *to)
+{
+       _cnm_return_val_if_overflow (gint64, from->actime, -1);
+       _cnm_return_val_if_overflow (gint64, from->modtime, -1);
+
+       memset (to, 0, sizeof(*to));
+
+       to->actime  = from->actime;
+       to->modtime = from->modtime;
+
+       return 0;
+}
+#endif /* ndef HAVE_STRUCT_UTIMBUF */
+
+
 int Mono_Posix_FromWaitOptions (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_WaitOptions_WNOHANG) == Mono_Posix_WaitOptions_WNOHANG)
 #ifdef WNOHANG
                *r |= WNOHANG;
@@ -7811,6 +6949,8 @@ int Mono_Posix_FromWaitOptions (int x, int *r)
 #else /* def WUNTRACED */
                {errno = EINVAL; return -1;}
 #endif /* ndef WUNTRACED */
+       if (x == 0)
+               return 0;
        return 0;
 }
 
@@ -7833,8 +6973,6 @@ int Mono_Posix_ToWaitOptions (int x, int *r)
 int Mono_Posix_FromXattrFlags (int x, int *r)
 {
        *r = 0;
-       if (x == 0)
-               return 0;
        if ((x & Mono_Posix_XattrFlags_XATTR_AUTO) == Mono_Posix_XattrFlags_XATTR_AUTO)
 #ifdef XATTR_AUTO
                *r |= XATTR_AUTO;
@@ -7853,6 +6991,8 @@ int Mono_Posix_FromXattrFlags (int x, int *r)
 #else /* def XATTR_REPLACE */
                {errno = EINVAL; return -1;}
 #endif /* ndef XATTR_REPLACE */
+       if (x == 0)
+               return 0;
        return 0;
 }